IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
[linux-2.6.git] / drivers / scsi / aic7xxx_old.c
1 /*+M*************************************************************************
2  * Adaptec AIC7xxx device driver for Linux.
3  *
4  * Copyright (c) 1994 John Aycock
5  *   The University of Calgary Department of Computer Science.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2, or (at your option)
10  * any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; see the file COPYING.  If not, write to
19  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  * Sources include the Adaptec 1740 driver (aha1740.c), the Ultrastor 24F
22  * driver (ultrastor.c), various Linux kernel source, the Adaptec EISA
23  * config file (!adp7771.cfg), the Adaptec AHA-2740A Series User's Guide,
24  * the Linux Kernel Hacker's Guide, Writing a SCSI Device Driver for Linux,
25  * the Adaptec 1542 driver (aha1542.c), the Adaptec EISA overlay file
26  * (adp7770.ovl), the Adaptec AHA-2740 Series Technical Reference Manual,
27  * the Adaptec AIC-7770 Data Book, the ANSI SCSI specification, the
28  * ANSI SCSI-2 specification (draft 10c), ...
29  *
30  * --------------------------------------------------------------------------
31  *
32  *  Modifications by Daniel M. Eischen (deischen@iworks.InterWorks.org):
33  *
34  *  Substantially modified to include support for wide and twin bus
35  *  adapters, DMAing of SCBs, tagged queueing, IRQ sharing, bug fixes,
36  *  SCB paging, and other rework of the code.
37  *
38  *  Parts of this driver were also based on the FreeBSD driver by
39  *  Justin T. Gibbs.  His copyright follows:
40  *
41  * --------------------------------------------------------------------------  
42  * Copyright (c) 1994-1997 Justin Gibbs.
43  * All rights reserved.
44  *
45  * Redistribution and use in source and binary forms, with or without
46  * modification, are permitted provided that the following conditions
47  * are met:
48  * 1. Redistributions of source code must retain the above copyright
49  *    notice, this list of conditions, and the following disclaimer,
50  *    without modification, immediately at the beginning of the file.
51  * 2. Redistributions in binary form must reproduce the above copyright
52  *    notice, this list of conditions and the following disclaimer in the
53  *    documentation and/or other materials provided with the distribution.
54  * 3. The name of the author may not be used to endorse or promote products
55  *    derived from this software without specific prior written permission.
56  *
57  * Where this Software is combined with software released under the terms of 
58  * the GNU General Public License ("GPL") and the terms of the GPL would require the 
59  * combined work to also be released under the terms of the GPL, the terms
60  * and conditions of this License will apply in addition to those of the
61  * GPL with the exception of any terms or conditions of this License that
62  * conflict with, or are expressly prohibited by, the GPL.
63  *
64  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
65  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
66  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
67  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
68  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
69  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
70  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
71  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
72  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
73  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
74  * SUCH DAMAGE.
75  *
76  *      $Id: aic7xxx.c,v 1.119 1997/06/27 19:39:18 gibbs Exp $
77  *---------------------------------------------------------------------------
78  *
79  *  Thanks also go to (in alphabetical order) the following:
80  *
81  *    Rory Bolt     - Sequencer bug fixes
82  *    Jay Estabrook - Initial DEC Alpha support
83  *    Doug Ledford  - Much needed abort/reset bug fixes
84  *    Kai Makisara  - DMAing of SCBs
85  *
86  *  A Boot time option was also added for not resetting the scsi bus.
87  *
88  *    Form:  aic7xxx=extended
89  *           aic7xxx=no_reset
90  *           aic7xxx=ultra
91  *           aic7xxx=irq_trigger:[0,1]  # 0 edge, 1 level
92  *           aic7xxx=verbose
93  *
94  *  Daniel M. Eischen, deischen@iworks.InterWorks.org, 1/23/97
95  *
96  *  $Id: aic7xxx.c,v 4.1 1997/06/12 08:23:42 deang Exp $
97  *-M*************************************************************************/
98
99 /*+M**************************************************************************
100  *
101  * Further driver modifications made by Doug Ledford <dledford@redhat.com>
102  *
103  * Copyright (c) 1997-1999 Doug Ledford
104  *
105  * These changes are released under the same licensing terms as the FreeBSD
106  * driver written by Justin Gibbs.  Please see his Copyright notice above
107  * for the exact terms and conditions covering my changes as well as the
108  * warranty statement.
109  *
110  * Modifications made to the aic7xxx.c,v 4.1 driver from Dan Eischen include
111  * but are not limited to:
112  *
113  *  1: Import of the latest FreeBSD sequencer code for this driver
114  *  2: Modification of kernel code to accommodate different sequencer semantics
115  *  3: Extensive changes throughout kernel portion of driver to improve
116  *     abort/reset processing and error hanndling
117  *  4: Other work contributed by various people on the Internet
118  *  5: Changes to printk information and verbosity selection code
119  *  6: General reliability related changes, especially in IRQ management
120  *  7: Modifications to the default probe/attach order for supported cards
121  *  8: SMP friendliness has been improved
122  *
123  * Overall, this driver represents a significant departure from the official
124  * aic7xxx driver released by Dan Eischen in two ways.  First, in the code
125  * itself.  A diff between the two version of the driver is now a several
126  * thousand line diff.  Second, in approach to solving the same problem.  The
127  * problem is importing the FreeBSD aic7xxx driver code to linux can be a
128  * difficult and time consuming process, that also can be error prone.  Dan
129  * Eischen's official driver uses the approach that the linux and FreeBSD
130  * drivers should be as identical as possible.  To that end, his next version
131  * of this driver will be using a mid-layer code library that he is developing
132  * to moderate communications between the linux mid-level SCSI code and the
133  * low level FreeBSD driver.  He intends to be able to essentially drop the
134  * FreeBSD driver into the linux kernel with only a few minor tweaks to some
135  * include files and the like and get things working, making for fast easy
136  * imports of the FreeBSD code into linux.
137  *
138  * I disagree with Dan's approach.  Not that I don't think his way of doing
139  * things would be nice, easy to maintain, and create a more uniform driver
140  * between FreeBSD and Linux.  I have no objection to those issues.  My
141  * disagreement is on the needed functionality.  There simply are certain
142  * things that are done differently in FreeBSD than linux that will cause
143  * problems for this driver regardless of any middle ware Dan implements.
144  * The biggest example of this at the moment is interrupt semantics.  Linux
145  * doesn't provide the same protection techniques as FreeBSD does, nor can
146  * they be easily implemented in any middle ware code since they would truly
147  * belong in the kernel proper and would effect all drivers.  For the time
148  * being, I see issues such as these as major stumbling blocks to the 
149  * reliability of code based upon such middle ware.  Therefore, I choose to
150  * use a different approach to importing the FreeBSD code that doesn't
151  * involve any middle ware type code.  My approach is to import the sequencer
152  * code from FreeBSD wholesale.  Then, to only make changes in the kernel
153  * portion of the driver as they are needed for the new sequencer semantics.
154  * In this way, the portion of the driver that speaks to the rest of the
155  * linux kernel is fairly static and can be changed/modified to solve
156  * any problems one might encounter without concern for the FreeBSD driver.
157  *
158  * Note: If time and experience should prove me wrong that the middle ware
159  * code Dan writes is reliable in its operation, then I'll retract my above
160  * statements.  But, for those that don't know, I'm from Missouri (in the US)
161  * and our state motto is "The Show-Me State".  Well, before I will put
162  * faith into it, you'll have to show me that it works :)
163  *
164  *_M*************************************************************************/
165
166 /*
167  * The next three defines are user configurable.  These should be the only
168  * defines a user might need to get in here and change.  There are other
169  * defines buried deeper in the code, but those really shouldn't need touched
170  * under normal conditions.
171  */
172
173 /*
174  * AIC7XXX_STRICT_PCI_SETUP
175  *   Should we assume the PCI config options on our controllers are set with
176  *   sane and proper values, or should we be anal about our PCI config
177  *   registers and force them to what we want?  The main advantage to
178  *   defining this option is on non-Intel hardware where the BIOS may not
179  *   have been run to set things up, or if you have one of the BIOSless
180  *   Adaptec controllers, such as a 2910, that don't get set up by the
181  *   BIOS.  However, keep in mind that we really do set the most important
182  *   items in the driver regardless of this setting, this only controls some
183  *   of the more esoteric PCI options on these cards.  In that sense, I
184  *   would default to leaving this off.  However, if people wish to try
185  *   things both ways, that would also help me to know if there are some
186  *   machines where it works one way but not another.
187  *
188  *   -- July 7, 17:09
189  *     OK...I need this on my machine for testing, so the default is to
190  *     leave it defined.
191  *
192  *   -- July 7, 18:49
193  *     I needed it for testing, but it didn't make any difference, so back
194  *     off she goes.
195  *
196  *   -- July 16, 23:04
197  *     I turned it back on to try and compensate for the 2.1.x PCI code
198  *     which no longer relies solely on the BIOS and now tries to set
199  *     things itself.
200  */
201
202 #define AIC7XXX_STRICT_PCI_SETUP
203
204 /*
205  * AIC7XXX_VERBOSE_DEBUGGING
206  *   This option enables a lot of extra printk();s in the code, surrounded
207  *   by if (aic7xxx_verbose ...) statements.  Executing all of those if
208  *   statements and the extra checks can get to where it actually does have
209  *   an impact on CPU usage and such, as well as code size.  Disabling this
210  *   define will keep some of those from becoming part of the code.
211  *
212  *   NOTE:  Currently, this option has no real effect, I will be adding the
213  *   various #ifdef's in the code later when I've decided a section is
214  *   complete and no longer needs debugging.  OK...a lot of things are now
215  *   surrounded by this define, so turning this off does have an impact.
216  */
217  
218 /*
219  * #define AIC7XXX_VERBOSE_DEBUGGING
220  */
221  
222 #include <linux/module.h>
223 #include <stdarg.h>
224 #include <asm/io.h>
225 #include <asm/irq.h>
226 #include <asm/byteorder.h>
227 #include <linux/string.h>
228 #include <linux/errno.h>
229 #include <linux/kernel.h>
230 #include <linux/ioport.h>
231 #include <linux/delay.h>
232 #include <linux/sched.h>
233 #include <linux/pci.h>
234 #include <linux/proc_fs.h>
235 #include <linux/blkdev.h>
236 #include <linux/init.h>
237 #include <linux/spinlock.h>
238 #include <linux/smp.h>
239 #include <linux/interrupt.h>
240 #include "scsi.h"
241 #include <scsi/scsi_host.h>
242 #include "aic7xxx_old/aic7xxx.h"
243
244 #include "aic7xxx_old/sequencer.h"
245 #include "aic7xxx_old/scsi_message.h"
246 #include "aic7xxx_old/aic7xxx_reg.h"
247 #include <scsi/scsicam.h>
248
249 #include <linux/stat.h>
250 #include <linux/slab.h>        /* for kmalloc() */
251
252 #define AIC7XXX_C_VERSION  "5.2.6"
253
254 #define ALL_TARGETS -1
255 #define ALL_CHANNELS -1
256 #define ALL_LUNS -1
257 #define MAX_TARGETS  16
258 #define MAX_LUNS     8
259 #ifndef TRUE
260 #  define TRUE 1
261 #endif
262 #ifndef FALSE
263 #  define FALSE 0
264 #endif
265
266 #if defined(__powerpc__) || defined(__i386__) || defined(__x86_64__)
267 #  define MMAPIO
268 #endif
269
270 /*
271  * You can try raising me for better performance or lowering me if you have
272  * flaky devices that go off the scsi bus when hit with too many tagged
273  * commands (like some IBM SCSI-3 LVD drives).
274  */
275 #define AIC7XXX_CMDS_PER_DEVICE 32
276
277 typedef struct
278 {
279   unsigned char tag_commands[16];   /* Allow for wide/twin adapters. */
280 } adapter_tag_info_t;
281
282 /*
283  * Make a define that will tell the driver not to the default tag depth
284  * everywhere.
285  */
286 #define DEFAULT_TAG_COMMANDS {0, 0, 0, 0, 0, 0, 0, 0,\
287                               0, 0, 0, 0, 0, 0, 0, 0}
288
289 /*
290  * Modify this as you see fit for your system.  By setting tag_commands
291  * to 0, the driver will use it's own algorithm for determining the
292  * number of commands to use (see above).  When 255, the driver will
293  * not enable tagged queueing for that particular device.  When positive
294  * (> 0) and (< 255) the values in the array are used for the queue_depth.
295  * Note that the maximum value for an entry is 254, but you're insane if
296  * you try to use that many commands on one device.
297  *
298  * In this example, the first line will disable tagged queueing for all
299  * the devices on the first probed aic7xxx adapter.
300  *
301  * The second line enables tagged queueing with 4 commands/LUN for IDs
302  * (1, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
303  * driver to use its own algorithm for ID 1.
304  *
305  * The third line is the same as the first line.
306  *
307  * The fourth line disables tagged queueing for devices 0 and 3.  It
308  * enables tagged queueing for the other IDs, with 16 commands/LUN
309  * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
310  * IDs 2, 5-7, and 9-15.
311  */
312
313 /*
314  * NOTE: The below structure is for reference only, the actual structure
315  *       to modify in order to change things is found after this fake one.
316  *
317 adapter_tag_info_t aic7xxx_tag_info[] =
318 {
319   {DEFAULT_TAG_COMMANDS},
320   {{4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 255, 4, 4, 4}},
321   {DEFAULT_TAG_COMMANDS},
322   {{255, 16, 4, 255, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
323 };
324 */
325
326 static adapter_tag_info_t aic7xxx_tag_info[] =
327 {
328   {DEFAULT_TAG_COMMANDS},
329   {DEFAULT_TAG_COMMANDS},
330   {DEFAULT_TAG_COMMANDS},
331   {DEFAULT_TAG_COMMANDS},
332   {DEFAULT_TAG_COMMANDS},
333   {DEFAULT_TAG_COMMANDS},
334   {DEFAULT_TAG_COMMANDS},
335   {DEFAULT_TAG_COMMANDS},
336   {DEFAULT_TAG_COMMANDS},
337   {DEFAULT_TAG_COMMANDS},
338   {DEFAULT_TAG_COMMANDS},
339   {DEFAULT_TAG_COMMANDS},
340   {DEFAULT_TAG_COMMANDS},
341   {DEFAULT_TAG_COMMANDS},
342   {DEFAULT_TAG_COMMANDS},
343   {DEFAULT_TAG_COMMANDS}
344 };
345
346
347 /*
348  * Define an array of board names that can be indexed by aha_type.
349  * Don't forget to change this when changing the types!
350  */
351 static const char *board_names[] = {
352   "AIC-7xxx Unknown",                                   /* AIC_NONE */
353   "Adaptec AIC-7810 Hardware RAID Controller",          /* AIC_7810 */
354   "Adaptec AIC-7770 SCSI host adapter",                 /* AIC_7770 */
355   "Adaptec AHA-274X SCSI host adapter",                 /* AIC_7771 */
356   "Adaptec AHA-284X SCSI host adapter",                 /* AIC_284x */
357   "Adaptec AIC-7850 SCSI host adapter",                 /* AIC_7850 */
358   "Adaptec AIC-7855 SCSI host adapter",                 /* AIC_7855 */
359   "Adaptec AIC-7860 Ultra SCSI host adapter",           /* AIC_7860 */
360   "Adaptec AHA-2940A Ultra SCSI host adapter",          /* AIC_7861 */
361   "Adaptec AIC-7870 SCSI host adapter",                 /* AIC_7870 */
362   "Adaptec AHA-294X SCSI host adapter",                 /* AIC_7871 */
363   "Adaptec AHA-394X SCSI host adapter",                 /* AIC_7872 */
364   "Adaptec AHA-398X SCSI host adapter",                 /* AIC_7873 */
365   "Adaptec AHA-2944 SCSI host adapter",                 /* AIC_7874 */
366   "Adaptec AIC-7880 Ultra SCSI host adapter",           /* AIC_7880 */
367   "Adaptec AHA-294X Ultra SCSI host adapter",           /* AIC_7881 */
368   "Adaptec AHA-394X Ultra SCSI host adapter",           /* AIC_7882 */
369   "Adaptec AHA-398X Ultra SCSI host adapter",           /* AIC_7883 */
370   "Adaptec AHA-2944 Ultra SCSI host adapter",           /* AIC_7884 */
371   "Adaptec AHA-2940UW Pro Ultra SCSI host adapter",     /* AIC_7887 */
372   "Adaptec AIC-7895 Ultra SCSI host adapter",           /* AIC_7895 */
373   "Adaptec AIC-7890/1 Ultra2 SCSI host adapter",        /* AIC_7890 */
374   "Adaptec AHA-293X Ultra2 SCSI host adapter",          /* AIC_7890 */
375   "Adaptec AHA-294X Ultra2 SCSI host adapter",          /* AIC_7890 */
376   "Adaptec AIC-7896/7 Ultra2 SCSI host adapter",        /* AIC_7896 */
377   "Adaptec AHA-394X Ultra2 SCSI host adapter",          /* AIC_7897 */
378   "Adaptec AHA-395X Ultra2 SCSI host adapter",          /* AIC_7897 */
379   "Adaptec PCMCIA SCSI controller",                     /* card bus stuff */
380   "Adaptec AIC-7892 Ultra 160/m SCSI host adapter",     /* AIC_7892 */
381   "Adaptec AIC-7899 Ultra 160/m SCSI host adapter",     /* AIC_7899 */
382 };
383
384 /*
385  * There should be a specific return value for this in scsi.h, but
386  * it seems that most drivers ignore it.
387  */
388 #define DID_UNDERFLOW   DID_ERROR
389
390 /*
391  *  What we want to do is have the higher level scsi driver requeue
392  *  the command to us. There is no specific driver status for this
393  *  condition, but the higher level scsi driver will requeue the
394  *  command on a DID_BUS_BUSY error.
395  *
396  *  Upon further inspection and testing, it seems that DID_BUS_BUSY
397  *  will *always* retry the command.  We can get into an infinite loop
398  *  if this happens when we really want some sort of counter that
399  *  will automatically abort/reset the command after so many retries.
400  *  Using DID_ERROR will do just that.  (Made by a suggestion by
401  *  Doug Ledford 8/1/96)
402  */
403 #define DID_RETRY_COMMAND DID_ERROR
404
405 #define HSCSIID        0x07
406 #define SCSI_RESET     0x040
407
408 /*
409  * EISA/VL-bus stuff
410  */
411 #define MINSLOT                1
412 #define MAXSLOT                15
413 #define SLOTBASE(x)        ((x) << 12)
414 #define BASE_TO_SLOT(x) ((x) >> 12)
415
416 /*
417  * Standard EISA Host ID regs  (Offset from slot base)
418  */
419 #define AHC_HID0              0x80   /* 0,1: msb of ID2, 2-7: ID1      */
420 #define AHC_HID1              0x81   /* 0-4: ID3, 5-7: LSB ID2         */
421 #define AHC_HID2              0x82   /* product                        */
422 #define AHC_HID3              0x83   /* firmware revision              */
423
424 /*
425  * AIC-7770 I/O range to reserve for a card
426  */
427 #define MINREG                0xC00
428 #define MAXREG                0xCFF
429
430 #define INTDEF                0x5C      /* Interrupt Definition Register */
431
432 /*
433  * AIC-78X0 PCI registers
434  */
435 #define        CLASS_PROGIF_REVID        0x08
436 #define                DEVREVID        0x000000FFul
437 #define                PROGINFC        0x0000FF00ul
438 #define                SUBCLASS        0x00FF0000ul
439 #define                BASECLASS        0xFF000000ul
440
441 #define        CSIZE_LATTIME                0x0C
442 #define                CACHESIZE        0x0000003Ful        /* only 5 bits */
443 #define                LATTIME                0x0000FF00ul
444
445 #define        DEVCONFIG                0x40
446 #define                SCBSIZE32        0x00010000ul        /* aic789X only */
447 #define                MPORTMODE        0x00000400ul        /* aic7870 only */
448 #define                RAMPSM           0x00000200ul        /* aic7870 only */
449 #define                RAMPSM_ULTRA2    0x00000004
450 #define                VOLSENSE         0x00000100ul
451 #define                SCBRAMSEL        0x00000080ul
452 #define                SCBRAMSEL_ULTRA2 0x00000008
453 #define                MRDCEN           0x00000040ul
454 #define                EXTSCBTIME       0x00000020ul        /* aic7870 only */
455 #define                EXTSCBPEN        0x00000010ul        /* aic7870 only */
456 #define                BERREN           0x00000008ul
457 #define                DACEN            0x00000004ul
458 #define                STPWLEVEL        0x00000002ul
459 #define                DIFACTNEGEN      0x00000001ul        /* aic7870 only */
460
461 #define        SCAMCTL                  0x1a                /* Ultra2 only  */
462 #define        CCSCBBADDR               0xf0                /* aic7895/6/7  */
463
464 /*
465  * Define the different types of SEEPROMs on aic7xxx adapters
466  * and make it also represent the address size used in accessing
467  * its registers.  The 93C46 chips have 1024 bits organized into
468  * 64 16-bit words, while the 93C56 chips have 2048 bits organized
469  * into 128 16-bit words.  The C46 chips use 6 bits to address
470  * each word, while the C56 and C66 (4096 bits) use 8 bits to
471  * address each word.
472  */
473 typedef enum {C46 = 6, C56_66 = 8} seeprom_chip_type;
474
475 /*
476  *
477  * Define the format of the SEEPROM registers (16 bits).
478  *
479  */
480 struct seeprom_config {
481
482 /*
483  * SCSI ID Configuration Flags
484  */
485 #define CFXFER                0x0007      /* synchronous transfer rate */
486 #define CFSYNCH               0x0008      /* enable synchronous transfer */
487 #define CFDISC                0x0010      /* enable disconnection */
488 #define CFWIDEB               0x0020      /* wide bus device (wide card) */
489 #define CFSYNCHISULTRA        0x0040      /* CFSYNC is an ultra offset */
490 #define CFNEWULTRAFORMAT      0x0080      /* Use the Ultra2 SEEPROM format */
491 #define CFSTART               0x0100      /* send start unit SCSI command */
492 #define CFINCBIOS             0x0200      /* include in BIOS scan */
493 #define CFRNFOUND             0x0400      /* report even if not found */
494 #define CFMULTILUN            0x0800      /* probe mult luns in BIOS scan */
495 #define CFWBCACHEYES          0x4000      /* Enable W-Behind Cache on drive */
496 #define CFWBCACHENC           0xc000      /* Don't change W-Behind Cache */
497 /* UNUSED                0x3000 */
498   unsigned short device_flags[16];        /* words 0-15 */
499
500 /*
501  * BIOS Control Bits
502  */
503 #define CFSUPREM        0x0001  /* support all removable drives */
504 #define CFSUPREMB       0x0002  /* support removable drives for boot only */
505 #define CFBIOSEN        0x0004  /* BIOS enabled */
506 /* UNUSED                0x0008 */
507 #define CFSM2DRV        0x0010  /* support more than two drives */
508 #define CF284XEXTEND    0x0020  /* extended translation (284x cards) */
509 /* UNUSED                0x0040 */
510 #define CFEXTEND        0x0080  /* extended translation enabled */
511 /* UNUSED                0xFF00 */
512   unsigned short bios_control;  /* word 16 */
513
514 /*
515  * Host Adapter Control Bits
516  */
517 #define CFAUTOTERM      0x0001  /* Perform Auto termination */
518 #define CFULTRAEN       0x0002  /* Ultra SCSI speed enable (Ultra cards) */
519 #define CF284XSELTO     0x0003  /* Selection timeout (284x cards) */
520 #define CF284XFIFO      0x000C  /* FIFO Threshold (284x cards) */
521 #define CFSTERM         0x0004  /* SCSI low byte termination */
522 #define CFWSTERM        0x0008  /* SCSI high byte termination (wide card) */
523 #define CFSPARITY       0x0010  /* SCSI parity */
524 #define CF284XSTERM     0x0020  /* SCSI low byte termination (284x cards) */
525 #define CFRESETB        0x0040  /* reset SCSI bus at boot */
526 #define CFBPRIMARY      0x0100  /* Channel B primary on 7895 chipsets */
527 #define CFSEAUTOTERM    0x0400  /* aic7890 Perform SE Auto Term */
528 #define CFLVDSTERM      0x0800  /* aic7890 LVD Termination */
529 /* UNUSED                0xF280 */
530   unsigned short adapter_control;        /* word 17 */
531
532 /*
533  * Bus Release, Host Adapter ID
534  */
535 #define CFSCSIID        0x000F                /* host adapter SCSI ID */
536 /* UNUSED                0x00F0 */
537 #define CFBRTIME        0xFF00                /* bus release time */
538   unsigned short brtime_id;                /* word 18 */
539
540 /*
541  * Maximum targets
542  */
543 #define CFMAXTARG        0x00FF        /* maximum targets */
544 /* UNUSED                0xFF00 */
545   unsigned short max_targets;                /* word 19 */
546
547   unsigned short res_1[11];                /* words 20-30 */
548   unsigned short checksum;                /* word 31 */
549 };
550
551 #define SELBUS_MASK                0x0a
552 #define         SELNARROW        0x00
553 #define         SELBUSB                0x08
554 #define SINGLE_BUS                0x00
555
556 #define SCB_TARGET(scb)         \
557        (((scb)->hscb->target_channel_lun & TID) >> 4)
558 #define SCB_LUN(scb)            \
559        ((scb)->hscb->target_channel_lun & LID)
560 #define SCB_IS_SCSIBUS_B(scb)   \
561        (((scb)->hscb->target_channel_lun & SELBUSB) != 0)
562
563 /*
564  * If an error occurs during a data transfer phase, run the command
565  * to completion - it's easier that way - making a note of the error
566  * condition in this location. This then will modify a DID_OK status
567  * into an appropriate error for the higher-level SCSI code.
568  */
569 #define aic7xxx_error(cmd)        ((cmd)->SCp.Status)
570
571 /*
572  * Keep track of the targets returned status.
573  */
574 #define aic7xxx_status(cmd)        ((cmd)->SCp.sent_command)
575
576 /*
577  * The position of the SCSI commands scb within the scb array.
578  */
579 #define aic7xxx_position(cmd)        ((cmd)->SCp.have_data_in)
580
581 /*
582  * The stored DMA mapping for single-buffer data transfers.
583  */
584 #define aic7xxx_mapping(cmd)         ((cmd)->SCp.phase)
585
586 /*
587  * Get out private data area from a scsi cmd pointer
588  */
589 #define AIC_DEV(cmd)    ((struct aic_dev_data *)(cmd)->device->hostdata)
590
591 /*
592  * So we can keep track of our host structs
593  */
594 static struct aic7xxx_host *first_aic7xxx = NULL;
595
596 /*
597  * As of Linux 2.1, the mid-level SCSI code uses virtual addresses
598  * in the scatter-gather lists.  We need to convert the virtual
599  * addresses to physical addresses.
600  */
601 struct hw_scatterlist {
602   unsigned int address;
603   unsigned int length;
604 };
605
606 /*
607  * Maximum number of SG segments these cards can support.
608  */
609 #define        AIC7XXX_MAX_SG 128
610
611 /*
612  * The maximum number of SCBs we could have for ANY type
613  * of card. DON'T FORGET TO CHANGE THE SCB MASK IN THE
614  * SEQUENCER CODE IF THIS IS MODIFIED!
615  */
616 #define AIC7XXX_MAXSCB        255
617
618
619 struct aic7xxx_hwscb {
620 /* ------------    Begin hardware supported fields    ---------------- */
621 /* 0*/  unsigned char control;
622 /* 1*/  unsigned char target_channel_lun;       /* 4/1/3 bits */
623 /* 2*/  unsigned char target_status;
624 /* 3*/  unsigned char SG_segment_count;
625 /* 4*/  unsigned int  SG_list_pointer;
626 /* 8*/  unsigned char residual_SG_segment_count;
627 /* 9*/  unsigned char residual_data_count[3];
628 /*12*/  unsigned int  data_pointer;
629 /*16*/  unsigned int  data_count;
630 /*20*/  unsigned int  SCSI_cmd_pointer;
631 /*24*/  unsigned char SCSI_cmd_length;
632 /*25*/  unsigned char tag;          /* Index into our kernel SCB array.
633                                      * Also used as the tag for tagged I/O
634                                      */
635 #define SCB_PIO_TRANSFER_SIZE  26   /* amount we need to upload/download
636                                      * via PIO to initialize a transaction.
637                                      */
638 /*26*/  unsigned char next;         /* Used to thread SCBs awaiting selection
639                                      * or disconnected down in the sequencer.
640                                      */
641 /*27*/  unsigned char prev;
642 /*28*/  unsigned int pad;           /*
643                                      * Unused by the kernel, but we require
644                                      * the padding so that the array of
645                                      * hardware SCBs is aligned on 32 byte
646                                      * boundaries so the sequencer can index
647                                      */
648 };
649
650 typedef enum {
651         SCB_FREE                = 0x0000,
652         SCB_DTR_SCB             = 0x0001,
653         SCB_WAITINGQ            = 0x0002,
654         SCB_ACTIVE              = 0x0004,
655         SCB_SENSE               = 0x0008,
656         SCB_ABORT               = 0x0010,
657         SCB_DEVICE_RESET        = 0x0020,
658         SCB_RESET               = 0x0040,
659         SCB_RECOVERY_SCB        = 0x0080,
660         SCB_MSGOUT_PPR          = 0x0100,
661         SCB_MSGOUT_SENT         = 0x0200,
662         SCB_MSGOUT_SDTR         = 0x0400,
663         SCB_MSGOUT_WDTR         = 0x0800,
664         SCB_MSGOUT_BITS         = SCB_MSGOUT_PPR |
665                                   SCB_MSGOUT_SENT | 
666                                   SCB_MSGOUT_SDTR |
667                                   SCB_MSGOUT_WDTR,
668         SCB_QUEUED_ABORT        = 0x1000,
669         SCB_QUEUED_FOR_DONE     = 0x2000,
670         SCB_WAS_BUSY            = 0x4000,
671         SCB_QUEUE_FULL          = 0x8000
672 } scb_flag_type;
673
674 typedef enum {
675         AHC_FNONE                 = 0x00000000,
676         AHC_PAGESCBS              = 0x00000001,
677         AHC_CHANNEL_B_PRIMARY     = 0x00000002,
678         AHC_USEDEFAULTS           = 0x00000004,
679         AHC_INDIRECT_PAGING       = 0x00000008,
680         AHC_CHNLB                 = 0x00000020,
681         AHC_CHNLC                 = 0x00000040,
682         AHC_EXTEND_TRANS_A        = 0x00000100,
683         AHC_EXTEND_TRANS_B        = 0x00000200,
684         AHC_TERM_ENB_A            = 0x00000400,
685         AHC_TERM_ENB_SE_LOW       = 0x00000400,
686         AHC_TERM_ENB_B            = 0x00000800,
687         AHC_TERM_ENB_SE_HIGH      = 0x00000800,
688         AHC_HANDLING_REQINITS     = 0x00001000,
689         AHC_TARGETMODE            = 0x00002000,
690         AHC_NEWEEPROM_FMT         = 0x00004000,
691  /*
692   *  Here ends the FreeBSD defined flags and here begins the linux defined
693   *  flags.  NOTE: I did not preserve the old flag name during this change
694   *  specifically to force me to evaluate what flags were being used properly
695   *  and what flags weren't.  This way, I could clean up the flag usage on
696   *  a use by use basis.  Doug Ledford
697   */
698         AHC_MOTHERBOARD           = 0x00020000,
699         AHC_NO_STPWEN             = 0x00040000,
700         AHC_RESET_DELAY           = 0x00080000,
701         AHC_A_SCANNED             = 0x00100000,
702         AHC_B_SCANNED             = 0x00200000,
703         AHC_MULTI_CHANNEL         = 0x00400000,
704         AHC_BIOS_ENABLED          = 0x00800000,
705         AHC_SEEPROM_FOUND         = 0x01000000,
706         AHC_TERM_ENB_LVD          = 0x02000000,
707         AHC_ABORT_PENDING         = 0x04000000,
708         AHC_RESET_PENDING         = 0x08000000,
709 #define AHC_IN_ISR_BIT              28
710         AHC_IN_ISR                = 0x10000000,
711         AHC_IN_ABORT              = 0x20000000,
712         AHC_IN_RESET              = 0x40000000,
713         AHC_EXTERNAL_SRAM         = 0x80000000
714 } ahc_flag_type;
715
716 typedef enum {
717   AHC_NONE             = 0x0000,
718   AHC_CHIPID_MASK      = 0x00ff,
719   AHC_AIC7770          = 0x0001,
720   AHC_AIC7850          = 0x0002,
721   AHC_AIC7860          = 0x0003,
722   AHC_AIC7870          = 0x0004,
723   AHC_AIC7880          = 0x0005,
724   AHC_AIC7890          = 0x0006,
725   AHC_AIC7895          = 0x0007,
726   AHC_AIC7896          = 0x0008,
727   AHC_AIC7892          = 0x0009,
728   AHC_AIC7899          = 0x000a,
729   AHC_VL               = 0x0100,
730   AHC_EISA             = 0x0200,
731   AHC_PCI              = 0x0400,
732 } ahc_chip;
733
734 typedef enum {
735   AHC_FENONE           = 0x0000,
736   AHC_ULTRA            = 0x0001,
737   AHC_ULTRA2           = 0x0002,
738   AHC_WIDE             = 0x0004,
739   AHC_TWIN             = 0x0008,
740   AHC_MORE_SRAM        = 0x0010,
741   AHC_CMD_CHAN         = 0x0020,
742   AHC_QUEUE_REGS       = 0x0040,
743   AHC_SG_PRELOAD       = 0x0080,
744   AHC_SPIOCAP          = 0x0100,
745   AHC_ULTRA3           = 0x0200,
746   AHC_NEW_AUTOTERM     = 0x0400,
747   AHC_AIC7770_FE       = AHC_FENONE,
748   AHC_AIC7850_FE       = AHC_SPIOCAP,
749   AHC_AIC7860_FE       = AHC_ULTRA|AHC_SPIOCAP,
750   AHC_AIC7870_FE       = AHC_FENONE,
751   AHC_AIC7880_FE       = AHC_ULTRA,
752   AHC_AIC7890_FE       = AHC_MORE_SRAM|AHC_CMD_CHAN|AHC_ULTRA2|
753                          AHC_QUEUE_REGS|AHC_SG_PRELOAD|AHC_NEW_AUTOTERM,
754   AHC_AIC7895_FE       = AHC_MORE_SRAM|AHC_CMD_CHAN|AHC_ULTRA,
755   AHC_AIC7896_FE       = AHC_AIC7890_FE,
756   AHC_AIC7892_FE       = AHC_AIC7890_FE|AHC_ULTRA3,
757   AHC_AIC7899_FE       = AHC_AIC7890_FE|AHC_ULTRA3,
758 } ahc_feature;
759
760 #define SCB_DMA_ADDR(scb, addr) ((unsigned long)(addr) + (scb)->scb_dma->dma_offset)
761
762 struct aic7xxx_scb_dma {
763         unsigned long          dma_offset;    /* Correction you have to add
764                                                * to virtual address to get
765                                                * dma handle in this region */
766         dma_addr_t             dma_address;   /* DMA handle of the start,
767                                                * for unmap */
768         unsigned int           dma_len;       /* DMA length */
769 };
770
771 typedef enum {
772   AHC_BUG_NONE            = 0x0000,
773   AHC_BUG_TMODE_WIDEODD   = 0x0001,
774   AHC_BUG_AUTOFLUSH       = 0x0002,
775   AHC_BUG_CACHETHEN       = 0x0004,
776   AHC_BUG_CACHETHEN_DIS   = 0x0008,
777   AHC_BUG_PCI_2_1_RETRY   = 0x0010,
778   AHC_BUG_PCI_MWI         = 0x0020,
779   AHC_BUG_SCBCHAN_UPLOAD  = 0x0040,
780 } ahc_bugs;
781
782 struct aic7xxx_scb {
783         struct aic7xxx_hwscb    *hscb;          /* corresponding hardware scb */
784         struct scsi_cmnd        *cmd;           /* scsi_cmnd for this scb */
785         struct aic7xxx_scb      *q_next;        /* next scb in queue */
786         volatile scb_flag_type  flags;          /* current state of scb */
787         struct hw_scatterlist   *sg_list;       /* SG list in adapter format */
788         unsigned char           tag_action;
789         unsigned char           sg_count;
790         unsigned char           *sense_cmd;     /*
791                                                  * Allocate 6 characters for
792                                                  * sense command.
793                                                  */
794         unsigned char           *cmnd;
795         unsigned int            sg_length;      /*
796                                                  * We init this during
797                                                  * buildscb so we don't have
798                                                  * to calculate anything during
799                                                  * underflow/overflow/stat code
800                                                  */
801         void                    *kmalloc_ptr;
802         struct aic7xxx_scb_dma  *scb_dma;
803 };
804
805 /*
806  * Define a linked list of SCBs.
807  */
808 typedef struct {
809   struct aic7xxx_scb *head;
810   struct aic7xxx_scb *tail;
811 } scb_queue_type;
812
813 static struct {
814   unsigned char errno;
815   const char *errmesg;
816 } hard_error[] = {
817   { ILLHADDR,  "Illegal Host Access" },
818   { ILLSADDR,  "Illegal Sequencer Address referenced" },
819   { ILLOPCODE, "Illegal Opcode in sequencer program" },
820   { SQPARERR,  "Sequencer Ram Parity Error" },
821   { DPARERR,   "Data-Path Ram Parity Error" },
822   { MPARERR,   "Scratch Ram/SCB Array Ram Parity Error" },
823   { PCIERRSTAT,"PCI Error detected" },
824   { CIOPARERR, "CIOBUS Parity Error" }
825 };
826
827 static unsigned char
828 generic_sense[] = { REQUEST_SENSE, 0, 0, 0, 255, 0 };
829
830 typedef struct {
831   scb_queue_type free_scbs;        /*
832                                     * SCBs assigned to free slot on
833                                     * card (no paging required)
834                                     */
835   struct aic7xxx_scb   *scb_array[AIC7XXX_MAXSCB];
836   struct aic7xxx_hwscb *hscbs;
837   unsigned char  numscbs;          /* current number of scbs */
838   unsigned char  maxhscbs;         /* hardware scbs */
839   unsigned char  maxscbs;          /* max scbs including pageable scbs */
840   dma_addr_t     hscbs_dma;        /* DMA handle to hscbs */
841   unsigned int   hscbs_dma_len;    /* length of the above DMA area */
842   void          *hscb_kmalloc_ptr;
843 } scb_data_type;
844
845 struct target_cmd {
846   unsigned char mesg_bytes[4];
847   unsigned char command[28];
848 };
849
850 #define AHC_TRANS_CUR    0x0001
851 #define AHC_TRANS_ACTIVE 0x0002
852 #define AHC_TRANS_GOAL   0x0004
853 #define AHC_TRANS_USER   0x0008
854 #define AHC_TRANS_QUITE  0x0010
855 typedef struct {
856   unsigned char width;
857   unsigned char period;
858   unsigned char offset;
859   unsigned char options;
860 } transinfo_type;
861
862 struct aic_dev_data {
863   volatile scb_queue_type  delayed_scbs;
864   volatile unsigned short  temp_q_depth;
865   unsigned short           max_q_depth;
866   volatile unsigned char   active_cmds;
867   /*
868    * Statistics Kept:
869    *
870    * Total Xfers (count for each command that has a data xfer),
871    * broken down by reads && writes.
872    *
873    * Further sorted into a few bins for keeping tabs on how many commands
874    * we get of various sizes.
875    *
876    */
877   long w_total;                          /* total writes */
878   long r_total;                          /* total reads */
879   long barrier_total;                    /* total num of REQ_BARRIER commands */
880   long ordered_total;                    /* How many REQ_BARRIER commands we
881                                             used ordered tags to satisfy */
882   long w_bins[6];                       /* binned write */
883   long r_bins[6];                       /* binned reads */
884   transinfo_type        cur;
885   transinfo_type        goal;
886 #define  BUS_DEVICE_RESET_PENDING       0x01
887 #define  DEVICE_RESET_DELAY             0x02
888 #define  DEVICE_PRINT_DTR               0x04
889 #define  DEVICE_WAS_BUSY                0x08
890 #define  DEVICE_DTR_SCANNED             0x10
891 #define  DEVICE_SCSI_3                  0x20
892   volatile unsigned char   flags;
893   unsigned needppr:1;
894   unsigned needppr_copy:1;
895   unsigned needsdtr:1;
896   unsigned needsdtr_copy:1;
897   unsigned needwdtr:1;
898   unsigned needwdtr_copy:1;
899   unsigned dtr_pending:1;
900   struct scsi_device *SDptr;
901   struct list_head list;
902 };
903
904 /*
905  * Define a structure used for each host adapter.  Note, in order to avoid
906  * problems with architectures I can't test on (because I don't have one,
907  * such as the Alpha based systems) which happen to give faults for
908  * non-aligned memory accesses, care was taken to align this structure
909  * in a way that gauranteed all accesses larger than 8 bits were aligned
910  * on the appropriate boundary.  It's also organized to try and be more
911  * cache line efficient.  Be careful when changing this lest you might hurt
912  * overall performance and bring down the wrath of the masses.
913  */
914 struct aic7xxx_host {
915   /*
916    *  This is the first 64 bytes in the host struct
917    */
918
919   /*
920    * We are grouping things here....first, items that get either read or
921    * written with nearly every interrupt
922    */
923         volatile long   flags;
924         ahc_feature     features;       /* chip features */
925         unsigned long   base;           /* card base address */
926         volatile unsigned char  __iomem *maddr; /* memory mapped address */
927         unsigned long   isr_count;      /* Interrupt count */
928         unsigned long   spurious_int;
929         scb_data_type   *scb_data;
930         struct aic7xxx_cmd_queue {
931                 struct scsi_cmnd *head;
932                 struct scsi_cmnd *tail;
933         } completeq;
934
935         /*
936         * Things read/written on nearly every entry into aic7xxx_queue()
937         */
938         volatile scb_queue_type waiting_scbs;
939         unsigned char   unpause;        /* unpause value for HCNTRL */
940         unsigned char   pause;          /* pause value for HCNTRL */
941         volatile unsigned char  qoutfifonext;
942         volatile unsigned char  activescbs;     /* active scbs */
943         volatile unsigned char  max_activescbs;
944         volatile unsigned char  qinfifonext;
945         volatile unsigned char  *untagged_scbs;
946         volatile unsigned char  *qoutfifo;
947         volatile unsigned char  *qinfifo;
948
949         unsigned char   dev_last_queue_full[MAX_TARGETS];
950         unsigned char   dev_last_queue_full_count[MAX_TARGETS];
951         unsigned short  ultraenb; /* Gets downloaded to card as a bitmap */
952         unsigned short  discenable; /* Gets downloaded to card as a bitmap */
953         transinfo_type  user[MAX_TARGETS];
954
955         unsigned char   msg_buf[13];    /* The message for the target */
956         unsigned char   msg_type;
957 #define MSG_TYPE_NONE              0x00
958 #define MSG_TYPE_INITIATOR_MSGOUT  0x01
959 #define MSG_TYPE_INITIATOR_MSGIN   0x02
960         unsigned char   msg_len;        /* Length of message */
961         unsigned char   msg_index;      /* Index into msg_buf array */
962
963
964         /*
965          * We put the less frequently used host structure items
966          * after the more frequently used items to try and ease
967          * the burden on the cache subsystem.
968          * These entries are not *commonly* accessed, whereas
969          * the preceding entries are accessed very often.
970          */
971
972         unsigned int    irq;            /* IRQ for this adapter */
973         int             instance;       /* aic7xxx instance number */
974         int             scsi_id;        /* host adapter SCSI ID */
975         int             scsi_id_b;      /* channel B for twin adapters */
976         unsigned int    bios_address;
977         int             board_name_index;
978         unsigned short  bios_control;           /* bios control - SEEPROM */
979         unsigned short  adapter_control;        /* adapter control - SEEPROM */
980         struct pci_dev  *pdev;
981         unsigned char   pci_bus;
982         unsigned char   pci_device_fn;
983         struct seeprom_config   sc;
984         unsigned short  sc_type;
985         unsigned short  sc_size;
986         struct aic7xxx_host     *next;  /* allow for multiple IRQs */
987         struct Scsi_Host        *host;  /* pointer to scsi host */
988         struct list_head         aic_devs; /* all aic_dev structs on host */
989         int             host_no;        /* SCSI host number */
990         unsigned long   mbase;          /* I/O memory address */
991         ahc_chip        chip;           /* chip type */
992         ahc_bugs        bugs;
993         dma_addr_t      fifo_dma;       /* DMA handle for fifo arrays */
994 };
995
996 /*
997  * Valid SCSIRATE values. (p. 3-17)
998  * Provides a mapping of transfer periods in ns/4 to the proper value to
999  * stick in the SCSIRATE reg to use that transfer rate.
1000  */
1001 #define AHC_SYNCRATE_ULTRA3 0
1002 #define AHC_SYNCRATE_ULTRA2 1
1003 #define AHC_SYNCRATE_ULTRA  3
1004 #define AHC_SYNCRATE_FAST   6
1005 #define AHC_SYNCRATE_CRC 0x40
1006 #define AHC_SYNCRATE_SE  0x10
1007 static struct aic7xxx_syncrate {
1008   /* Rates in Ultra mode have bit 8 of sxfr set */
1009 #define                ULTRA_SXFR 0x100
1010   int sxfr_ultra2;
1011   int sxfr;
1012   unsigned char period;
1013   const char *rate[2];
1014 } aic7xxx_syncrates[] = {
1015   { 0x42,  0x000,   9,  {"80.0", "160.0"} },
1016   { 0x13,  0x000,  10,  {"40.0", "80.0"} },
1017   { 0x14,  0x000,  11,  {"33.0", "66.6"} },
1018   { 0x15,  0x100,  12,  {"20.0", "40.0"} },
1019   { 0x16,  0x110,  15,  {"16.0", "32.0"} },
1020   { 0x17,  0x120,  18,  {"13.4", "26.8"} },
1021   { 0x18,  0x000,  25,  {"10.0", "20.0"} },
1022   { 0x19,  0x010,  31,  {"8.0",  "16.0"} },
1023   { 0x1a,  0x020,  37,  {"6.67", "13.3"} },
1024   { 0x1b,  0x030,  43,  {"5.7",  "11.4"} },
1025   { 0x10,  0x040,  50,  {"5.0",  "10.0"} },
1026   { 0x00,  0x050,  56,  {"4.4",  "8.8" } },
1027   { 0x00,  0x060,  62,  {"4.0",  "8.0" } },
1028   { 0x00,  0x070,  68,  {"3.6",  "7.2" } },
1029   { 0x00,  0x000,  0,   {NULL, NULL}   },
1030 };
1031
1032 #define CTL_OF_SCB(scb) (((scb->hscb)->target_channel_lun >> 3) & 0x1),  \
1033                         (((scb->hscb)->target_channel_lun >> 4) & 0xf), \
1034                         ((scb->hscb)->target_channel_lun & 0x07)
1035
1036 #define CTL_OF_CMD(cmd) ((cmd->device->channel) & 0x01),  \
1037                         ((cmd->device->id) & 0x0f), \
1038                         ((cmd->device->lun) & 0x07)
1039
1040 #define TARGET_INDEX(cmd)  ((cmd)->device->id | ((cmd)->device->channel << 3))
1041
1042 /*
1043  * A nice little define to make doing our printks a little easier
1044  */
1045
1046 #define WARN_LEAD KERN_WARNING "(scsi%d:%d:%d:%d) "
1047 #define INFO_LEAD KERN_INFO "(scsi%d:%d:%d:%d) "
1048
1049 /*
1050  * XXX - these options apply unilaterally to _all_ 274x/284x/294x
1051  *       cards in the system.  This should be fixed.  Exceptions to this
1052  *       rule are noted in the comments.
1053  */
1054
1055 /*
1056  * Use this as the default queue depth when setting tagged queueing on.
1057  */
1058 static unsigned int aic7xxx_default_queue_depth = AIC7XXX_CMDS_PER_DEVICE;
1059
1060 /*
1061  * Skip the scsi bus reset.  Non 0 make us skip the reset at startup.  This
1062  * has no effect on any later resets that might occur due to things like
1063  * SCSI bus timeouts.
1064  */
1065 static unsigned int aic7xxx_no_reset = 0;
1066 /*
1067  * Certain PCI motherboards will scan PCI devices from highest to lowest,
1068  * others scan from lowest to highest, and they tend to do all kinds of
1069  * strange things when they come into contact with PCI bridge chips.  The
1070  * net result of all this is that the PCI card that is actually used to boot
1071  * the machine is very hard to detect.  Most motherboards go from lowest
1072  * PCI slot number to highest, and the first SCSI controller found is the
1073  * one you boot from.  The only exceptions to this are when a controller
1074  * has its BIOS disabled.  So, we by default sort all of our SCSI controllers
1075  * from lowest PCI slot number to highest PCI slot number.  We also force
1076  * all controllers with their BIOS disabled to the end of the list.  This
1077  * works on *almost* all computers.  Where it doesn't work, we have this
1078  * option.  Setting this option to non-0 will reverse the order of the sort
1079  * to highest first, then lowest, but will still leave cards with their BIOS
1080  * disabled at the very end.  That should fix everyone up unless there are
1081  * really strange cirumstances.
1082  */
1083 static int aic7xxx_reverse_scan = 0;
1084 /*
1085  * Should we force EXTENDED translation on a controller.
1086  *     0 == Use whatever is in the SEEPROM or default to off
1087  *     1 == Use whatever is in the SEEPROM or default to on
1088  */
1089 static unsigned int aic7xxx_extended = 0;
1090 /*
1091  * The IRQ trigger method used on EISA controllers. Does not effect PCI cards.
1092  *   -1 = Use detected settings.
1093  *    0 = Force Edge triggered mode.
1094  *    1 = Force Level triggered mode.
1095  */
1096 static int aic7xxx_irq_trigger = -1;
1097 /*
1098  * This variable is used to override the termination settings on a controller.
1099  * This should not be used under normal conditions.  However, in the case
1100  * that a controller does not have a readable SEEPROM (so that we can't
1101  * read the SEEPROM settings directly) and that a controller has a buggered
1102  * version of the cable detection logic, this can be used to force the 
1103  * correct termination.  It is preferable to use the manual termination
1104  * settings in the BIOS if possible, but some motherboard controllers store
1105  * those settings in a format we can't read.  In other cases, auto term
1106  * should also work, but the chipset was put together with no auto term
1107  * logic (common on motherboard controllers).  In those cases, we have
1108  * 32 bits here to work with.  That's good for 8 controllers/channels.  The
1109  * bits are organized as 4 bits per channel, with scsi0 getting the lowest
1110  * 4 bits in the int.  A 1 in a bit position indicates the termination setting
1111  * that corresponds to that bit should be enabled, a 0 is disabled.
1112  * It looks something like this:
1113  *
1114  *    0x0f =  1111-Single Ended Low Byte Termination on/off
1115  *            ||\-Single Ended High Byte Termination on/off
1116  *            |\-LVD Low Byte Termination on/off
1117  *            \-LVD High Byte Termination on/off
1118  *
1119  * For non-Ultra2 controllers, the upper 2 bits are not important.  So, to
1120  * enable both high byte and low byte termination on scsi0, I would need to
1121  * make sure that the override_term variable was set to 0x03 (bits 0011).
1122  * To make sure that all termination is enabled on an Ultra2 controller at
1123  * scsi2 and only high byte termination on scsi1 and high and low byte
1124  * termination on scsi0, I would set override_term=0xf23 (bits 1111 0010 0011)
1125  *
1126  * For the most part, users should never have to use this, that's why I
1127  * left it fairly cryptic instead of easy to understand.  If you need it,
1128  * most likely someone will be telling you what your's needs to be set to.
1129  */
1130 static int aic7xxx_override_term = -1;
1131 /*
1132  * Certain motherboard chipset controllers tend to screw
1133  * up the polarity of the term enable output pin.  Use this variable
1134  * to force the correct polarity for your system.  This is a bitfield variable
1135  * similar to the previous one, but this one has one bit per channel instead
1136  * of four.
1137  *    0 = Force the setting to active low.
1138  *    1 = Force setting to active high.
1139  * Most Adaptec cards are active high, several motherboards are active low.
1140  * To force a 2940 card at SCSI 0 to active high and a motherboard 7895
1141  * controller at scsi1 and scsi2 to active low, and a 2910 card at scsi3
1142  * to active high, you would need to set stpwlev=0x9 (bits 1001).
1143  *
1144  * People shouldn't need to use this, but if you are experiencing lots of
1145  * SCSI timeout problems, this may help.  There is one sure way to test what
1146  * this option needs to be.  Using a boot floppy to boot the system, configure
1147  * your system to enable all SCSI termination (in the Adaptec SCSI BIOS) and
1148  * if needed then also pass a value to override_term to make sure that the
1149  * driver is enabling SCSI termination, then set this variable to either 0
1150  * or 1.  When the driver boots, make sure there are *NO* SCSI cables
1151  * connected to your controller.  If it finds and inits the controller
1152  * without problem, then the setting you passed to stpwlev was correct.  If
1153  * the driver goes into a reset loop and hangs the system, then you need the
1154  * other setting for this variable.  If neither setting lets the machine
1155  * boot then you have definite termination problems that may not be fixable.
1156  */
1157 static int aic7xxx_stpwlev = -1;
1158 /*
1159  * Set this to non-0 in order to force the driver to panic the kernel
1160  * and print out debugging info on a SCSI abort or reset cycle.
1161  */
1162 static int aic7xxx_panic_on_abort = 0;
1163 /*
1164  * PCI bus parity checking of the Adaptec controllers.  This is somewhat
1165  * dubious at best.  To my knowledge, this option has never actually
1166  * solved a PCI parity problem, but on certain machines with broken PCI
1167  * chipset configurations, it can generate tons of false error messages.
1168  * It's included in the driver for completeness.
1169  *   0 = Shut off PCI parity check
1170  *  -1 = Normal polarity pci parity checking
1171  *   1 = reverse polarity pci parity checking
1172  *
1173  * NOTE: you can't actually pass -1 on the lilo prompt.  So, to set this
1174  * variable to -1 you would actually want to simply pass the variable
1175  * name without a number.  That will invert the 0 which will result in
1176  * -1.
1177  */
1178 static int aic7xxx_pci_parity = 0;
1179 /*
1180  * Set this to any non-0 value to cause us to dump the contents of all
1181  * the card's registers in a hex dump format tailored to each model of
1182  * controller.
1183  * 
1184  * NOTE: THE CONTROLLER IS LEFT IN AN UNUSEABLE STATE BY THIS OPTION.
1185  *       YOU CANNOT BOOT UP WITH THIS OPTION, IT IS FOR DEBUGGING PURPOSES
1186  *       ONLY
1187  */
1188 static int aic7xxx_dump_card = 0;
1189 /*
1190  * Set this to a non-0 value to make us dump out the 32 bit instruction
1191  * registers on the card after completing the sequencer download.  This
1192  * allows the actual sequencer download to be verified.  It is possible
1193  * to use this option and still boot up and run your system.  This is
1194  * only intended for debugging purposes.
1195  */
1196 static int aic7xxx_dump_sequencer = 0;
1197 /*
1198  * Certain newer motherboards have put new PCI based devices into the
1199  * IO spaces that used to typically be occupied by VLB or EISA cards.
1200  * This overlap can cause these newer motherboards to lock up when scanned
1201  * for older EISA and VLB devices.  Setting this option to non-0 will
1202  * cause the driver to skip scanning for any VLB or EISA controllers and
1203  * only support the PCI controllers.  NOTE: this means that if the kernel
1204  * os compiled with PCI support disabled, then setting this to non-0
1205  * would result in never finding any devices :)
1206  */
1207 static int aic7xxx_no_probe = 0;
1208 /*
1209  * On some machines, enabling the external SCB RAM isn't reliable yet.  I
1210  * haven't had time to make test patches for things like changing the
1211  * timing mode on that external RAM either.  Some of those changes may
1212  * fix the problem.  Until then though, we default to external SCB RAM
1213  * off and give a command line option to enable it.
1214  */
1215 static int aic7xxx_scbram = 0;
1216 /*
1217  * So that we can set how long each device is given as a selection timeout.
1218  * The table of values goes like this:
1219  *   0 - 256ms
1220  *   1 - 128ms
1221  *   2 - 64ms
1222  *   3 - 32ms
1223  * We default to 64ms because it's fast.  Some old SCSI-I devices need a
1224  * longer time.  The final value has to be left shifted by 3, hence 0x10
1225  * is the final value.
1226  */
1227 static int aic7xxx_seltime = 0x10;
1228 /*
1229  * So that insmod can find the variable and make it point to something
1230  */
1231 #ifdef MODULE
1232 static char * aic7xxx = NULL;
1233 module_param(aic7xxx, charp, 0);
1234 #endif
1235
1236 #define VERBOSE_NORMAL         0x0000
1237 #define VERBOSE_NEGOTIATION    0x0001
1238 #define VERBOSE_SEQINT         0x0002
1239 #define VERBOSE_SCSIINT        0x0004
1240 #define VERBOSE_PROBE          0x0008
1241 #define VERBOSE_PROBE2         0x0010
1242 #define VERBOSE_NEGOTIATION2   0x0020
1243 #define VERBOSE_MINOR_ERROR    0x0040
1244 #define VERBOSE_TRACING        0x0080
1245 #define VERBOSE_ABORT          0x0f00
1246 #define VERBOSE_ABORT_MID      0x0100
1247 #define VERBOSE_ABORT_FIND     0x0200
1248 #define VERBOSE_ABORT_PROCESS  0x0400
1249 #define VERBOSE_ABORT_RETURN   0x0800
1250 #define VERBOSE_RESET          0xf000
1251 #define VERBOSE_RESET_MID      0x1000
1252 #define VERBOSE_RESET_FIND     0x2000
1253 #define VERBOSE_RESET_PROCESS  0x4000
1254 #define VERBOSE_RESET_RETURN   0x8000
1255 static int aic7xxx_verbose = VERBOSE_NORMAL | VERBOSE_NEGOTIATION |
1256            VERBOSE_PROBE;                     /* verbose messages */
1257
1258
1259 /****************************************************************************
1260  *
1261  * We're going to start putting in function declarations so that order of
1262  * functions is no longer important.  As needed, they are added here.
1263  *
1264  ***************************************************************************/
1265
1266 static int aic7xxx_release(struct Scsi_Host *host);
1267 static void aic7xxx_set_syncrate(struct aic7xxx_host *p, 
1268                 struct aic7xxx_syncrate *syncrate, int target, int channel,
1269                 unsigned int period, unsigned int offset, unsigned char options,
1270                 unsigned int type, struct aic_dev_data *aic_dev);
1271 static void aic7xxx_set_width(struct aic7xxx_host *p, int target, int channel,
1272                 int lun, unsigned int width, unsigned int type,
1273                 struct aic_dev_data *aic_dev);
1274 static void aic7xxx_panic_abort(struct aic7xxx_host *p, struct scsi_cmnd *cmd);
1275 static void aic7xxx_print_card(struct aic7xxx_host *p);
1276 static void aic7xxx_print_scratch_ram(struct aic7xxx_host *p);
1277 static void aic7xxx_print_sequencer(struct aic7xxx_host *p, int downloaded);
1278 #ifdef AIC7XXX_VERBOSE_DEBUGGING
1279 static void aic7xxx_check_scbs(struct aic7xxx_host *p, char *buffer);
1280 #endif
1281
1282 /****************************************************************************
1283  *
1284  * These functions are now used.  They happen to be wrapped in useless
1285  * inb/outb port read/writes around the real reads and writes because it
1286  * seems that certain very fast CPUs have a problem dealing with us when
1287  * going at full speed.
1288  *
1289  ***************************************************************************/
1290
1291 static unsigned char
1292 aic_inb(struct aic7xxx_host *p, long port)
1293 {
1294 #ifdef MMAPIO
1295   unsigned char x;
1296   if(p->maddr)
1297   {
1298     x = readb(p->maddr + port);
1299   }
1300   else
1301   {
1302     x = inb(p->base + port);
1303   }
1304   return(x);
1305 #else
1306   return(inb(p->base + port));
1307 #endif
1308 }
1309
1310 static void
1311 aic_outb(struct aic7xxx_host *p, unsigned char val, long port)
1312 {
1313 #ifdef MMAPIO
1314   if(p->maddr)
1315   {
1316     writeb(val, p->maddr + port);
1317     mb(); /* locked operation in order to force CPU ordering */
1318     readb(p->maddr + HCNTRL); /* dummy read to flush the PCI write */
1319   }
1320   else
1321   {
1322     outb(val, p->base + port);
1323     mb(); /* locked operation in order to force CPU ordering */
1324   }
1325 #else
1326   outb(val, p->base + port);
1327   mb(); /* locked operation in order to force CPU ordering */
1328 #endif
1329 }
1330
1331 /*+F*************************************************************************
1332  * Function:
1333  *   aic7xxx_setup
1334  *
1335  * Description:
1336  *   Handle Linux boot parameters. This routine allows for assigning a value
1337  *   to a parameter with a ':' between the parameter and the value.
1338  *   ie. aic7xxx=unpause:0x0A,extended
1339  *-F*************************************************************************/
1340 static int
1341 aic7xxx_setup(char *s)
1342 {
1343   int   i, n;
1344   char *p;
1345   char *end;
1346
1347   static struct {
1348     const char *name;
1349     unsigned int *flag;
1350   } options[] = {
1351     { "extended",    &aic7xxx_extended },
1352     { "no_reset",    &aic7xxx_no_reset },
1353     { "irq_trigger", &aic7xxx_irq_trigger },
1354     { "verbose",     &aic7xxx_verbose },
1355     { "reverse_scan",&aic7xxx_reverse_scan },
1356     { "override_term", &aic7xxx_override_term },
1357     { "stpwlev", &aic7xxx_stpwlev },
1358     { "no_probe", &aic7xxx_no_probe },
1359     { "panic_on_abort", &aic7xxx_panic_on_abort },
1360     { "pci_parity", &aic7xxx_pci_parity },
1361     { "dump_card", &aic7xxx_dump_card },
1362     { "dump_sequencer", &aic7xxx_dump_sequencer },
1363     { "default_queue_depth", &aic7xxx_default_queue_depth },
1364     { "scbram", &aic7xxx_scbram },
1365     { "seltime", &aic7xxx_seltime },
1366     { "tag_info",    NULL }
1367   };
1368
1369   end = strchr(s, '\0');
1370
1371   while ((p = strsep(&s, ",.")) != NULL)
1372   {
1373     for (i = 0; i < ARRAY_SIZE(options); i++)
1374     {
1375       n = strlen(options[i].name);
1376       if (!strncmp(options[i].name, p, n))
1377       {
1378         if (!strncmp(p, "tag_info", n))
1379         {
1380           if (p[n] == ':')
1381           {
1382             char *base;
1383             char *tok, *tok_end, *tok_end2;
1384             char tok_list[] = { '.', ',', '{', '}', '\0' };
1385             int i, instance = -1, device = -1;
1386             unsigned char done = FALSE;
1387
1388             base = p;
1389             tok = base + n + 1;  /* Forward us just past the ':' */
1390             tok_end = strchr(tok, '\0');
1391             if (tok_end < end)
1392               *tok_end = ',';
1393             while(!done)
1394             {
1395               switch(*tok)
1396               {
1397                 case '{':
1398                   if (instance == -1)
1399                     instance = 0;
1400                   else if (device == -1)
1401                     device = 0;
1402                   tok++;
1403                   break;
1404                 case '}':
1405                   if (device != -1)
1406                     device = -1;
1407                   else if (instance != -1)
1408                     instance = -1;
1409                   tok++;
1410                   break;
1411                 case ',':
1412                 case '.':
1413                   if (instance == -1)
1414                     done = TRUE;
1415                   else if (device >= 0)
1416                     device++;
1417                   else if (instance >= 0)
1418                     instance++;
1419                   if ( (device >= MAX_TARGETS) || 
1420                        (instance >= ARRAY_SIZE(aic7xxx_tag_info)) )
1421                     done = TRUE;
1422                   tok++;
1423                   if (!done)
1424                   {
1425                     base = tok;
1426                   }
1427                   break;
1428                 case '\0':
1429                   done = TRUE;
1430                   break;
1431                 default:
1432                   done = TRUE;
1433                   tok_end = strchr(tok, '\0');
1434                   for(i=0; tok_list[i]; i++)
1435                   {
1436                     tok_end2 = strchr(tok, tok_list[i]);
1437                     if ( (tok_end2) && (tok_end2 < tok_end) )
1438                     {
1439                       tok_end = tok_end2;
1440                       done = FALSE;
1441                     }
1442                   }
1443                   if ( (instance >= 0) && (device >= 0) &&
1444                        (instance < ARRAY_SIZE(aic7xxx_tag_info)) &&
1445                        (device < MAX_TARGETS) )
1446                     aic7xxx_tag_info[instance].tag_commands[device] =
1447                       simple_strtoul(tok, NULL, 0) & 0xff;
1448                   tok = tok_end;
1449                   break;
1450               }
1451             }
1452             while((p != base) && (p != NULL))
1453               p = strsep(&s, ",.");
1454           }
1455         }
1456         else if (p[n] == ':')
1457         {
1458           *(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0);
1459           if(!strncmp(p, "seltime", n))
1460           {
1461             *(options[i].flag) = (*(options[i].flag) % 4) << 3;
1462           }
1463         }
1464         else if (!strncmp(p, "verbose", n))
1465         {
1466           *(options[i].flag) = 0xff29;
1467         }
1468         else
1469         {
1470           *(options[i].flag) = ~(*(options[i].flag));
1471           if(!strncmp(p, "seltime", n))
1472           {
1473             *(options[i].flag) = (*(options[i].flag) % 4) << 3;
1474           }
1475         }
1476       }
1477     }
1478   }
1479   return 1;
1480 }
1481
1482 __setup("aic7xxx=", aic7xxx_setup);
1483
1484 /*+F*************************************************************************
1485  * Function:
1486  *   pause_sequencer
1487  *
1488  * Description:
1489  *   Pause the sequencer and wait for it to actually stop - this
1490  *   is important since the sequencer can disable pausing for critical
1491  *   sections.
1492  *-F*************************************************************************/
1493 static void
1494 pause_sequencer(struct aic7xxx_host *p)
1495 {
1496   aic_outb(p, p->pause, HCNTRL);
1497   while ((aic_inb(p, HCNTRL) & PAUSE) == 0)
1498   {
1499     ;
1500   }
1501   if(p->features & AHC_ULTRA2)
1502   {
1503     aic_inb(p, CCSCBCTL);
1504   }
1505 }
1506
1507 /*+F*************************************************************************
1508  * Function:
1509  *   unpause_sequencer
1510  *
1511  * Description:
1512  *   Unpause the sequencer. Unremarkable, yet done often enough to
1513  *   warrant an easy way to do it.
1514  *-F*************************************************************************/
1515 static void
1516 unpause_sequencer(struct aic7xxx_host *p, int unpause_always)
1517 {
1518   if (unpause_always ||
1519       ( !(aic_inb(p, INTSTAT) & (SCSIINT | SEQINT | BRKADRINT)) &&
1520         !(p->flags & AHC_HANDLING_REQINITS) ) )
1521   {
1522     aic_outb(p, p->unpause, HCNTRL);
1523   }
1524 }
1525
1526 /*+F*************************************************************************
1527  * Function:
1528  *   restart_sequencer
1529  *
1530  * Description:
1531  *   Restart the sequencer program from address zero.  This assumes
1532  *   that the sequencer is already paused.
1533  *-F*************************************************************************/
1534 static void
1535 restart_sequencer(struct aic7xxx_host *p)
1536 {
1537   aic_outb(p, 0, SEQADDR0);
1538   aic_outb(p, 0, SEQADDR1);
1539   aic_outb(p, FASTMODE, SEQCTL);
1540 }
1541
1542 /*
1543  * We include the aic7xxx_seq.c file here so that the other defines have
1544  * already been made, and so that it comes before the code that actually
1545  * downloads the instructions (since we don't typically use function
1546  * prototype, our code has to be ordered that way, it's a left-over from
1547  * the original driver days.....I should fix it some time DL).
1548  */
1549 #include "aic7xxx_old/aic7xxx_seq.c"
1550
1551 /*+F*************************************************************************
1552  * Function:
1553  *   aic7xxx_check_patch
1554  *
1555  * Description:
1556  *   See if the next patch to download should be downloaded.
1557  *-F*************************************************************************/
1558 static int
1559 aic7xxx_check_patch(struct aic7xxx_host *p,
1560   struct sequencer_patch **start_patch, int start_instr, int *skip_addr)
1561 {
1562   struct sequencer_patch *cur_patch;
1563   struct sequencer_patch *last_patch;
1564   int num_patches;
1565
1566   num_patches = ARRAY_SIZE(sequencer_patches);
1567   last_patch = &sequencer_patches[num_patches];
1568   cur_patch = *start_patch;
1569
1570   while ((cur_patch < last_patch) && (start_instr == cur_patch->begin))
1571   {
1572     if (cur_patch->patch_func(p) == 0)
1573     {
1574       /*
1575        * Start rejecting code.
1576        */
1577       *skip_addr = start_instr + cur_patch->skip_instr;
1578       cur_patch += cur_patch->skip_patch;
1579     }
1580     else
1581     {
1582       /*
1583        * Found an OK patch.  Advance the patch pointer to the next patch
1584        * and wait for our instruction pointer to get here.
1585        */
1586       cur_patch++;
1587     }
1588   }
1589
1590   *start_patch = cur_patch;
1591   if (start_instr < *skip_addr)
1592     /*
1593      * Still skipping
1594      */
1595     return (0);
1596   return(1);
1597 }
1598
1599
1600 /*+F*************************************************************************
1601  * Function:
1602  *   aic7xxx_download_instr
1603  *
1604  * Description:
1605  *   Find the next patch to download.
1606  *-F*************************************************************************/
1607 static void
1608 aic7xxx_download_instr(struct aic7xxx_host *p, int instrptr,
1609   unsigned char *dconsts)
1610 {
1611   union ins_formats instr;
1612   struct ins_format1 *fmt1_ins;
1613   struct ins_format3 *fmt3_ins;
1614   unsigned char opcode;
1615
1616   instr = *(union ins_formats*) &seqprog[instrptr * 4];
1617
1618   instr.integer = le32_to_cpu(instr.integer);
1619   
1620   fmt1_ins = &instr.format1;
1621   fmt3_ins = NULL;
1622
1623   /* Pull the opcode */
1624   opcode = instr.format1.opcode;
1625   switch (opcode)
1626   {
1627     case AIC_OP_JMP:
1628     case AIC_OP_JC:
1629     case AIC_OP_JNC:
1630     case AIC_OP_CALL:
1631     case AIC_OP_JNE:
1632     case AIC_OP_JNZ:
1633     case AIC_OP_JE:
1634     case AIC_OP_JZ:
1635     {
1636       struct sequencer_patch *cur_patch;
1637       int address_offset;
1638       unsigned int address;
1639       int skip_addr;
1640       int i;
1641
1642       fmt3_ins = &instr.format3;
1643       address_offset = 0;
1644       address = fmt3_ins->address;
1645       cur_patch = sequencer_patches;
1646       skip_addr = 0;
1647
1648       for (i = 0; i < address;)
1649       {
1650         aic7xxx_check_patch(p, &cur_patch, i, &skip_addr);
1651         if (skip_addr > i)
1652         {
1653           int end_addr;
1654
1655           end_addr = min_t(int, address, skip_addr);
1656           address_offset += end_addr - i;
1657           i = skip_addr;
1658         }
1659         else
1660         {
1661           i++;
1662         }
1663       }
1664       address -= address_offset;
1665       fmt3_ins->address = address;
1666       /* Fall Through to the next code section */
1667     }
1668     case AIC_OP_OR:
1669     case AIC_OP_AND:
1670     case AIC_OP_XOR:
1671     case AIC_OP_ADD:
1672     case AIC_OP_ADC:
1673     case AIC_OP_BMOV:
1674       if (fmt1_ins->parity != 0)
1675       {
1676         fmt1_ins->immediate = dconsts[fmt1_ins->immediate];
1677       }
1678       fmt1_ins->parity = 0;
1679       /* Fall Through to the next code section */
1680     case AIC_OP_ROL:
1681       if ((p->features & AHC_ULTRA2) != 0)
1682       {
1683         int i, count;
1684
1685         /* Calculate odd parity for the instruction */
1686         for ( i=0, count=0; i < 31; i++)
1687         {
1688           unsigned int mask;
1689
1690           mask = 0x01 << i;
1691           if ((instr.integer & mask) != 0)
1692             count++;
1693         }
1694         if (!(count & 0x01))
1695           instr.format1.parity = 1;
1696       }
1697       else
1698       {
1699         if (fmt3_ins != NULL)
1700         {
1701           instr.integer =  fmt3_ins->immediate |
1702                           (fmt3_ins->source << 8) |
1703                           (fmt3_ins->address << 16) |
1704                           (fmt3_ins->opcode << 25);
1705         }
1706         else
1707         {
1708           instr.integer =  fmt1_ins->immediate |
1709                           (fmt1_ins->source << 8) |
1710                           (fmt1_ins->destination << 16) |
1711                           (fmt1_ins->ret << 24) |
1712                           (fmt1_ins->opcode << 25);
1713         }
1714       }
1715       aic_outb(p, (instr.integer & 0xff), SEQRAM);
1716       aic_outb(p, ((instr.integer >> 8) & 0xff), SEQRAM);
1717       aic_outb(p, ((instr.integer >> 16) & 0xff), SEQRAM);
1718       aic_outb(p, ((instr.integer >> 24) & 0xff), SEQRAM);
1719       udelay(10);
1720       break;
1721
1722     default:
1723       panic("aic7xxx: Unknown opcode encountered in sequencer program.");
1724       break;
1725   }
1726 }
1727
1728
1729 /*+F*************************************************************************
1730  * Function:
1731  *   aic7xxx_loadseq
1732  *
1733  * Description:
1734  *   Load the sequencer code into the controller memory.
1735  *-F*************************************************************************/
1736 static void
1737 aic7xxx_loadseq(struct aic7xxx_host *p)
1738 {
1739   struct sequencer_patch *cur_patch;
1740   int i;
1741   int downloaded;
1742   int skip_addr;
1743   unsigned char download_consts[4] = {0, 0, 0, 0};
1744
1745   if (aic7xxx_verbose & VERBOSE_PROBE)
1746   {
1747     printk(KERN_INFO "(scsi%d) Downloading sequencer code...", p->host_no);
1748   }
1749 #if 0
1750   download_consts[TMODE_NUMCMDS] = p->num_targetcmds;
1751 #endif
1752   download_consts[TMODE_NUMCMDS] = 0;
1753   cur_patch = &sequencer_patches[0];
1754   downloaded = 0;
1755   skip_addr = 0;
1756
1757   aic_outb(p, PERRORDIS|LOADRAM|FAILDIS|FASTMODE, SEQCTL);
1758   aic_outb(p, 0, SEQADDR0);
1759   aic_outb(p, 0, SEQADDR1);
1760
1761   for (i = 0; i < sizeof(seqprog) / 4;  i++)
1762   {
1763     if (aic7xxx_check_patch(p, &cur_patch, i, &skip_addr) == 0)
1764     {
1765       /* Skip this instruction for this configuration. */
1766       continue;
1767     }
1768     aic7xxx_download_instr(p, i, &download_consts[0]);
1769     downloaded++;
1770   }
1771
1772   aic_outb(p, 0, SEQADDR0);
1773   aic_outb(p, 0, SEQADDR1);
1774   aic_outb(p, FASTMODE | FAILDIS, SEQCTL);
1775   unpause_sequencer(p, TRUE);
1776   mdelay(1);
1777   pause_sequencer(p);
1778   aic_outb(p, FASTMODE, SEQCTL);
1779   if (aic7xxx_verbose & VERBOSE_PROBE)
1780   {
1781     printk(" %d instructions downloaded\n", downloaded);
1782   }
1783   if (aic7xxx_dump_sequencer)
1784     aic7xxx_print_sequencer(p, downloaded);
1785 }
1786
1787 /*+F*************************************************************************
1788  * Function:
1789  *   aic7xxx_print_sequencer
1790  *
1791  * Description:
1792  *   Print the contents of the sequencer memory to the screen.
1793  *-F*************************************************************************/
1794 static void
1795 aic7xxx_print_sequencer(struct aic7xxx_host *p, int downloaded)
1796 {
1797   int i, k, temp;
1798   
1799   aic_outb(p, PERRORDIS|LOADRAM|FAILDIS|FASTMODE, SEQCTL);
1800   aic_outb(p, 0, SEQADDR0);
1801   aic_outb(p, 0, SEQADDR1);
1802
1803   k = 0;
1804   for (i=0; i < downloaded; i++)
1805   {
1806     if ( k == 0 )
1807       printk("%03x: ", i);
1808     temp = aic_inb(p, SEQRAM);
1809     temp |= (aic_inb(p, SEQRAM) << 8);
1810     temp |= (aic_inb(p, SEQRAM) << 16);
1811     temp |= (aic_inb(p, SEQRAM) << 24);
1812     printk("%08x", temp);
1813     if ( ++k == 8 )
1814     {
1815       printk("\n");
1816       k = 0;
1817     }
1818     else
1819       printk(" ");
1820   }
1821   aic_outb(p, 0, SEQADDR0);
1822   aic_outb(p, 0, SEQADDR1);
1823   aic_outb(p, FASTMODE | FAILDIS, SEQCTL);
1824   unpause_sequencer(p, TRUE);
1825   mdelay(1);
1826   pause_sequencer(p);
1827   aic_outb(p, FASTMODE, SEQCTL);
1828   printk("\n");
1829 }
1830
1831 /*+F*************************************************************************
1832  * Function:
1833  *   aic7xxx_info
1834  *
1835  * Description:
1836  *   Return a string describing the driver.
1837  *-F*************************************************************************/
1838 static const char *
1839 aic7xxx_info(struct Scsi_Host *dooh)
1840 {
1841   static char buffer[256];
1842   char *bp;
1843   struct aic7xxx_host *p;
1844
1845   bp = &buffer[0];
1846   p = (struct aic7xxx_host *)dooh->hostdata;
1847   memset(bp, 0, sizeof(buffer));
1848   strcpy(bp, "Adaptec AHA274x/284x/294x (EISA/VLB/PCI-Fast SCSI) ");
1849   strcat(bp, AIC7XXX_C_VERSION);
1850   strcat(bp, "/");
1851   strcat(bp, AIC7XXX_H_VERSION);
1852   strcat(bp, "\n");
1853   strcat(bp, "       <");
1854   strcat(bp, board_names[p->board_name_index]);
1855   strcat(bp, ">");
1856
1857   return(bp);
1858 }
1859
1860 /*+F*************************************************************************
1861  * Function:
1862  *   aic7xxx_find_syncrate
1863  *
1864  * Description:
1865  *   Look up the valid period to SCSIRATE conversion in our table
1866  *-F*************************************************************************/
1867 static struct aic7xxx_syncrate *
1868 aic7xxx_find_syncrate(struct aic7xxx_host *p, unsigned int *period,
1869   unsigned int maxsync, unsigned char *options)
1870 {
1871   struct aic7xxx_syncrate *syncrate;
1872   int done = FALSE;
1873
1874   switch(*options)
1875   {
1876     case MSG_EXT_PPR_OPTION_DT_CRC:
1877     case MSG_EXT_PPR_OPTION_DT_UNITS:
1878       if(!(p->features & AHC_ULTRA3))
1879       {
1880         *options = 0;
1881         maxsync = max_t(unsigned int, maxsync, AHC_SYNCRATE_ULTRA2);
1882       }
1883       break;
1884     case MSG_EXT_PPR_OPTION_DT_CRC_QUICK:
1885     case MSG_EXT_PPR_OPTION_DT_UNITS_QUICK:
1886       if(!(p->features & AHC_ULTRA3))
1887       {
1888         *options = 0;
1889         maxsync = max_t(unsigned int, maxsync, AHC_SYNCRATE_ULTRA2);
1890       }
1891       else
1892       {
1893         /*
1894          * we don't support the Quick Arbitration variants of dual edge
1895          * clocking.  As it turns out, we want to send back the
1896          * same basic option, but without the QA attribute.
1897          * We know that we are responding because we would never set
1898          * these options ourself, we would only respond to them.
1899          */
1900         switch(*options)
1901         {
1902           case MSG_EXT_PPR_OPTION_DT_CRC_QUICK:
1903             *options = MSG_EXT_PPR_OPTION_DT_CRC;
1904             break;
1905           case MSG_EXT_PPR_OPTION_DT_UNITS_QUICK:
1906             *options = MSG_EXT_PPR_OPTION_DT_UNITS;
1907             break;
1908         }
1909       }
1910       break;
1911     default:
1912       *options = 0;
1913       maxsync = max_t(unsigned int, maxsync, AHC_SYNCRATE_ULTRA2);
1914       break;
1915   }
1916   syncrate = &aic7xxx_syncrates[maxsync];
1917   while ( (syncrate->rate[0] != NULL) &&
1918          (!(p->features & AHC_ULTRA2) || syncrate->sxfr_ultra2) )
1919   {
1920     if (*period <= syncrate->period) 
1921     {
1922       switch(*options)
1923       {
1924         case MSG_EXT_PPR_OPTION_DT_CRC:
1925         case MSG_EXT_PPR_OPTION_DT_UNITS:
1926           if(!(syncrate->sxfr_ultra2 & AHC_SYNCRATE_CRC))
1927           {
1928             done = TRUE;
1929             /*
1930              * oops, we went too low for the CRC/DualEdge signalling, so
1931              * clear the options byte
1932              */
1933             *options = 0;
1934             /*
1935              * We'll be sending a reply to this packet to set the options
1936              * properly, so unilaterally set the period as well.
1937              */
1938             *period = syncrate->period;
1939           }
1940           else
1941           {
1942             done = TRUE;
1943             if(syncrate == &aic7xxx_syncrates[maxsync])
1944             {
1945               *period = syncrate->period;
1946             }
1947           }
1948           break;
1949         default:
1950           if(!(syncrate->sxfr_ultra2 & AHC_SYNCRATE_CRC))
1951           {
1952             done = TRUE;
1953             if(syncrate == &aic7xxx_syncrates[maxsync])
1954             {
1955               *period = syncrate->period;
1956             }
1957           }
1958           break;
1959       }
1960       if(done)
1961       {
1962         break;
1963       }
1964     }
1965     syncrate++;
1966   }
1967   if ( (*period == 0) || (syncrate->rate[0] == NULL) ||
1968        ((p->features & AHC_ULTRA2) && (syncrate->sxfr_ultra2 == 0)) )
1969   {
1970     /*
1971      * Use async transfers for this target
1972      */
1973     *options = 0;
1974     *period = 255;
1975     syncrate = NULL;
1976   }
1977   return (syncrate);
1978 }
1979
1980
1981 /*+F*************************************************************************
1982  * Function:
1983  *   aic7xxx_find_period
1984  *
1985  * Description:
1986  *   Look up the valid SCSIRATE to period conversion in our table
1987  *-F*************************************************************************/
1988 static unsigned int
1989 aic7xxx_find_period(struct aic7xxx_host *p, unsigned int scsirate,
1990   unsigned int maxsync)
1991 {
1992   struct aic7xxx_syncrate *syncrate;
1993
1994   if (p->features & AHC_ULTRA2)
1995   {
1996     scsirate &= SXFR_ULTRA2;
1997   }
1998   else
1999   {
2000     scsirate &= SXFR;
2001   }
2002
2003   syncrate = &aic7xxx_syncrates[maxsync];
2004   while (syncrate->rate[0] != NULL)
2005   {
2006     if (p->features & AHC_ULTRA2)
2007     {
2008       if (syncrate->sxfr_ultra2 == 0)
2009         break;
2010       else if (scsirate == syncrate->sxfr_ultra2)
2011         return (syncrate->period);
2012       else if (scsirate == (syncrate->sxfr_ultra2 & ~AHC_SYNCRATE_CRC))
2013         return (syncrate->period);
2014     }
2015     else if (scsirate == (syncrate->sxfr & ~ULTRA_SXFR))
2016     {
2017       return (syncrate->period);
2018     }
2019     syncrate++;
2020   }
2021   return (0); /* async */
2022 }
2023
2024 /*+F*************************************************************************
2025  * Function:
2026  *   aic7xxx_validate_offset
2027  *
2028  * Description:
2029  *   Set a valid offset value for a particular card in use and transfer
2030  *   settings in use.
2031  *-F*************************************************************************/
2032 static void
2033 aic7xxx_validate_offset(struct aic7xxx_host *p,
2034   struct aic7xxx_syncrate *syncrate, unsigned int *offset, int wide)
2035 {
2036   unsigned int maxoffset;
2037
2038   /* Limit offset to what the card (and device) can do */
2039   if (syncrate == NULL)
2040   {
2041     maxoffset = 0;
2042   }
2043   else if (p->features & AHC_ULTRA2)
2044   {
2045     maxoffset = MAX_OFFSET_ULTRA2;
2046   }
2047   else
2048   {
2049     if (wide)
2050       maxoffset = MAX_OFFSET_16BIT;
2051     else
2052       maxoffset = MAX_OFFSET_8BIT;
2053   }
2054   *offset = min(*offset, maxoffset);
2055 }
2056
2057 /*+F*************************************************************************
2058  * Function:
2059  *   aic7xxx_set_syncrate
2060  *
2061  * Description:
2062  *   Set the actual syncrate down in the card and in our host structs
2063  *-F*************************************************************************/
2064 static void
2065 aic7xxx_set_syncrate(struct aic7xxx_host *p, struct aic7xxx_syncrate *syncrate,
2066     int target, int channel, unsigned int period, unsigned int offset,
2067     unsigned char options, unsigned int type, struct aic_dev_data *aic_dev)
2068 {
2069   unsigned char tindex;
2070   unsigned short target_mask;
2071   unsigned char lun, old_options;
2072   unsigned int old_period, old_offset;
2073
2074   tindex = target | (channel << 3);
2075   target_mask = 0x01 << tindex;
2076   lun = aic_inb(p, SCB_TCL) & 0x07;
2077
2078   if (syncrate == NULL)
2079   {
2080     period = 0;
2081     offset = 0;
2082   }
2083
2084   old_period = aic_dev->cur.period;
2085   old_offset = aic_dev->cur.offset;
2086   old_options = aic_dev->cur.options;
2087
2088   
2089   if (type & AHC_TRANS_CUR)
2090   {
2091     unsigned int scsirate;
2092
2093     scsirate = aic_inb(p, TARG_SCSIRATE + tindex);
2094     if (p->features & AHC_ULTRA2)
2095     {
2096       scsirate &= ~SXFR_ULTRA2;
2097       if (syncrate != NULL)
2098       {
2099         switch(options)
2100         {
2101           case MSG_EXT_PPR_OPTION_DT_UNITS:
2102             /*
2103              * mask off the CRC bit in the xfer settings
2104              */
2105             scsirate |= (syncrate->sxfr_ultra2 & ~AHC_SYNCRATE_CRC);
2106             break;
2107           default:
2108             scsirate |= syncrate->sxfr_ultra2;
2109             break;
2110         }
2111       }
2112       if (type & AHC_TRANS_ACTIVE)
2113       {
2114         aic_outb(p, offset, SCSIOFFSET);
2115       }
2116       aic_outb(p, offset, TARG_OFFSET + tindex);
2117     }
2118     else /* Not an Ultra2 controller */
2119     {
2120       scsirate &= ~(SXFR|SOFS);
2121       p->ultraenb &= ~target_mask;
2122       if (syncrate != NULL)
2123       {
2124         if (syncrate->sxfr & ULTRA_SXFR)
2125         {
2126           p->ultraenb |= target_mask;
2127         }
2128         scsirate |= (syncrate->sxfr & SXFR);
2129         scsirate |= (offset & SOFS);
2130       }
2131       if (type & AHC_TRANS_ACTIVE)
2132       {
2133         unsigned char sxfrctl0;
2134
2135         sxfrctl0 = aic_inb(p, SXFRCTL0);
2136         sxfrctl0 &= ~FAST20;
2137         if (p->ultraenb & target_mask)
2138           sxfrctl0 |= FAST20;
2139         aic_outb(p, sxfrctl0, SXFRCTL0);
2140       }
2141       aic_outb(p, p->ultraenb & 0xff, ULTRA_ENB);
2142       aic_outb(p, (p->ultraenb >> 8) & 0xff, ULTRA_ENB + 1 );
2143     }
2144     if (type & AHC_TRANS_ACTIVE)
2145     {
2146       aic_outb(p, scsirate, SCSIRATE);
2147     }
2148     aic_outb(p, scsirate, TARG_SCSIRATE + tindex);
2149     aic_dev->cur.period = period;
2150     aic_dev->cur.offset = offset;
2151     aic_dev->cur.options = options;
2152     if ( !(type & AHC_TRANS_QUITE) &&
2153          (aic7xxx_verbose & VERBOSE_NEGOTIATION) &&
2154          (aic_dev->flags & DEVICE_PRINT_DTR) )
2155     {
2156       if (offset)
2157       {
2158         int rate_mod = (scsirate & WIDEXFER) ? 1 : 0;
2159       
2160         printk(INFO_LEAD "Synchronous at %s Mbyte/sec, "
2161                "offset %d.\n", p->host_no, channel, target, lun,
2162                syncrate->rate[rate_mod], offset);
2163       }
2164       else
2165       {
2166         printk(INFO_LEAD "Using asynchronous transfers.\n",
2167                p->host_no, channel, target, lun);
2168       }
2169       aic_dev->flags &= ~DEVICE_PRINT_DTR;
2170     }
2171   }
2172
2173   if (type & AHC_TRANS_GOAL)
2174   {
2175     aic_dev->goal.period = period;
2176     aic_dev->goal.offset = offset;
2177     aic_dev->goal.options = options;
2178   }
2179
2180   if (type & AHC_TRANS_USER)
2181   {
2182     p->user[tindex].period = period;
2183     p->user[tindex].offset = offset;
2184     p->user[tindex].options = options;
2185   }
2186 }
2187
2188 /*+F*************************************************************************
2189  * Function:
2190  *   aic7xxx_set_width
2191  *
2192  * Description:
2193  *   Set the actual width down in the card and in our host structs
2194  *-F*************************************************************************/
2195 static void
2196 aic7xxx_set_width(struct aic7xxx_host *p, int target, int channel, int lun,
2197     unsigned int width, unsigned int type, struct aic_dev_data *aic_dev)
2198 {
2199   unsigned char tindex;
2200   unsigned short target_mask;
2201   unsigned int old_width;
2202
2203   tindex = target | (channel << 3);
2204   target_mask = 1 << tindex;
2205   
2206   old_width = aic_dev->cur.width;
2207
2208   if (type & AHC_TRANS_CUR) 
2209   {
2210     unsigned char scsirate;
2211
2212     scsirate = aic_inb(p, TARG_SCSIRATE + tindex);
2213
2214     scsirate &= ~WIDEXFER;
2215     if (width == MSG_EXT_WDTR_BUS_16_BIT)
2216       scsirate |= WIDEXFER;
2217
2218     aic_outb(p, scsirate, TARG_SCSIRATE + tindex);
2219
2220     if (type & AHC_TRANS_ACTIVE)
2221       aic_outb(p, scsirate, SCSIRATE);
2222
2223     aic_dev->cur.width = width;
2224
2225     if ( !(type & AHC_TRANS_QUITE) &&
2226           (aic7xxx_verbose & VERBOSE_NEGOTIATION2) && 
2227           (aic_dev->flags & DEVICE_PRINT_DTR) )
2228     {
2229       printk(INFO_LEAD "Using %s transfers\n", p->host_no, channel, target,
2230         lun, (scsirate & WIDEXFER) ? "Wide(16bit)" : "Narrow(8bit)" );
2231     }
2232   }
2233
2234   if (type & AHC_TRANS_GOAL)
2235     aic_dev->goal.width = width;
2236   if (type & AHC_TRANS_USER)
2237     p->user[tindex].width = width;
2238
2239   if (aic_dev->goal.offset)
2240   {
2241     if (p->features & AHC_ULTRA2)
2242     {
2243       aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
2244     }
2245     else if (width == MSG_EXT_WDTR_BUS_16_BIT)
2246     {
2247       aic_dev->goal.offset = MAX_OFFSET_16BIT;
2248     }
2249     else
2250     {
2251       aic_dev->goal.offset = MAX_OFFSET_8BIT;
2252     }
2253   }
2254 }
2255       
2256 /*+F*************************************************************************
2257  * Function:
2258  *   scbq_init
2259  *
2260  * Description:
2261  *   SCB queue initialization.
2262  *
2263  *-F*************************************************************************/
2264 static void
2265 scbq_init(volatile scb_queue_type *queue)
2266 {
2267   queue->head = NULL;
2268   queue->tail = NULL;
2269 }
2270
2271 /*+F*************************************************************************
2272  * Function:
2273  *   scbq_insert_head
2274  *
2275  * Description:
2276  *   Add an SCB to the head of the list.
2277  *
2278  *-F*************************************************************************/
2279 static inline void
2280 scbq_insert_head(volatile scb_queue_type *queue, struct aic7xxx_scb *scb)
2281 {
2282   scb->q_next = queue->head;
2283   queue->head = scb;
2284   if (queue->tail == NULL)       /* If list was empty, update tail. */
2285     queue->tail = queue->head;
2286 }
2287
2288 /*+F*************************************************************************
2289  * Function:
2290  *   scbq_remove_head
2291  *
2292  * Description:
2293  *   Remove an SCB from the head of the list.
2294  *
2295  *-F*************************************************************************/
2296 static inline struct aic7xxx_scb *
2297 scbq_remove_head(volatile scb_queue_type *queue)
2298 {
2299   struct aic7xxx_scb * scbp;
2300
2301   scbp = queue->head;
2302   if (queue->head != NULL)
2303     queue->head = queue->head->q_next;
2304   if (queue->head == NULL)       /* If list is now empty, update tail. */
2305     queue->tail = NULL;
2306   return(scbp);
2307 }
2308
2309 /*+F*************************************************************************
2310  * Function:
2311  *   scbq_remove
2312  *
2313  * Description:
2314  *   Removes an SCB from the list.
2315  *
2316  *-F*************************************************************************/
2317 static inline void
2318 scbq_remove(volatile scb_queue_type *queue, struct aic7xxx_scb *scb)
2319 {
2320   if (queue->head == scb)
2321   {
2322     /* At beginning of queue, remove from head. */
2323     scbq_remove_head(queue);
2324   }
2325   else
2326   {
2327     struct aic7xxx_scb *curscb = queue->head;
2328
2329     /*
2330      * Search until the next scb is the one we're looking for, or
2331      * we run out of queue.
2332      */
2333     while ((curscb != NULL) && (curscb->q_next != scb))
2334     {
2335       curscb = curscb->q_next;
2336     }
2337     if (curscb != NULL)
2338     {
2339       /* Found it. */
2340       curscb->q_next = scb->q_next;
2341       if (scb->q_next == NULL)
2342       {
2343         /* Update the tail when removing the tail. */
2344         queue->tail = curscb;
2345       }
2346     }
2347   }
2348 }
2349
2350 /*+F*************************************************************************
2351  * Function:
2352  *   scbq_insert_tail
2353  *
2354  * Description:
2355  *   Add an SCB at the tail of the list.
2356  *
2357  *-F*************************************************************************/
2358 static inline void
2359 scbq_insert_tail(volatile scb_queue_type *queue, struct aic7xxx_scb *scb)
2360 {
2361   scb->q_next = NULL;
2362   if (queue->tail != NULL)       /* Add the scb at the end of the list. */
2363     queue->tail->q_next = scb;
2364   queue->tail = scb;             /* Update the tail. */
2365   if (queue->head == NULL)       /* If list was empty, update head. */
2366     queue->head = queue->tail;
2367 }
2368
2369 /*+F*************************************************************************
2370  * Function:
2371  *   aic7xxx_match_scb
2372  *
2373  * Description:
2374  *   Checks to see if an scb matches the target/channel as specified.
2375  *   If target is ALL_TARGETS (-1), then we're looking for any device
2376  *   on the specified channel; this happens when a channel is going
2377  *   to be reset and all devices on that channel must be aborted.
2378  *-F*************************************************************************/
2379 static int
2380 aic7xxx_match_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb,
2381     int target, int channel, int lun, unsigned char tag)
2382 {
2383   int targ = (scb->hscb->target_channel_lun >> 4) & 0x0F;
2384   int chan = (scb->hscb->target_channel_lun >> 3) & 0x01;
2385   int slun = scb->hscb->target_channel_lun & 0x07;
2386   int match;
2387
2388   match = ((chan == channel) || (channel == ALL_CHANNELS));
2389   if (match != 0)
2390     match = ((targ == target) || (target == ALL_TARGETS));
2391   if (match != 0)
2392     match = ((lun == slun) || (lun == ALL_LUNS));
2393   if (match != 0)
2394     match = ((tag == scb->hscb->tag) || (tag == SCB_LIST_NULL));
2395
2396   return (match);
2397 }
2398
2399 /*+F*************************************************************************
2400  * Function:
2401  *   aic7xxx_add_curscb_to_free_list
2402  *
2403  * Description:
2404  *   Adds the current scb (in SCBPTR) to the list of free SCBs.
2405  *-F*************************************************************************/
2406 static void
2407 aic7xxx_add_curscb_to_free_list(struct aic7xxx_host *p)
2408 {
2409   /*
2410    * Invalidate the tag so that aic7xxx_find_scb doesn't think
2411    * it's active
2412    */
2413   aic_outb(p, SCB_LIST_NULL, SCB_TAG);
2414   aic_outb(p, 0, SCB_CONTROL);
2415
2416   aic_outb(p, aic_inb(p, FREE_SCBH), SCB_NEXT);
2417   aic_outb(p, aic_inb(p, SCBPTR), FREE_SCBH);
2418 }
2419
2420 /*+F*************************************************************************
2421  * Function:
2422  *   aic7xxx_rem_scb_from_disc_list
2423  *
2424  * Description:
2425  *   Removes the current SCB from the disconnected list and adds it
2426  *   to the free list.
2427  *-F*************************************************************************/
2428 static unsigned char
2429 aic7xxx_rem_scb_from_disc_list(struct aic7xxx_host *p, unsigned char scbptr,
2430                                unsigned char prev)
2431 {
2432   unsigned char next;
2433
2434   aic_outb(p, scbptr, SCBPTR);
2435   next = aic_inb(p, SCB_NEXT);
2436   aic7xxx_add_curscb_to_free_list(p);
2437
2438   if (prev != SCB_LIST_NULL)
2439   {
2440     aic_outb(p, prev, SCBPTR);
2441     aic_outb(p, next, SCB_NEXT);
2442   }
2443   else
2444   {
2445     aic_outb(p, next, DISCONNECTED_SCBH);
2446   }
2447
2448   return next;
2449 }
2450
2451 /*+F*************************************************************************
2452  * Function:
2453  *   aic7xxx_busy_target
2454  *
2455  * Description:
2456  *   Set the specified target busy.
2457  *-F*************************************************************************/
2458 static inline void
2459 aic7xxx_busy_target(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2460 {
2461   p->untagged_scbs[scb->hscb->target_channel_lun] = scb->hscb->tag;
2462 }
2463
2464 /*+F*************************************************************************
2465  * Function:
2466  *   aic7xxx_index_busy_target
2467  *
2468  * Description:
2469  *   Returns the index of the busy target, and optionally sets the
2470  *   target inactive.
2471  *-F*************************************************************************/
2472 static inline unsigned char
2473 aic7xxx_index_busy_target(struct aic7xxx_host *p, unsigned char tcl,
2474     int unbusy)
2475 {
2476   unsigned char busy_scbid;
2477
2478   busy_scbid = p->untagged_scbs[tcl];
2479   if (unbusy)
2480   {
2481     p->untagged_scbs[tcl] = SCB_LIST_NULL;
2482   }
2483   return (busy_scbid);
2484 }
2485
2486 /*+F*************************************************************************
2487  * Function:
2488  *   aic7xxx_find_scb
2489  *
2490  * Description:
2491  *   Look through the SCB array of the card and attempt to find the
2492  *   hardware SCB that corresponds to the passed in SCB.  Return
2493  *   SCB_LIST_NULL if unsuccessful.  This routine assumes that the
2494  *   card is already paused.
2495  *-F*************************************************************************/
2496 static unsigned char
2497 aic7xxx_find_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2498 {
2499   unsigned char saved_scbptr;
2500   unsigned char curindex;
2501
2502   saved_scbptr = aic_inb(p, SCBPTR);
2503   curindex = 0;
2504   for (curindex = 0; curindex < p->scb_data->maxhscbs; curindex++)
2505   {
2506     aic_outb(p, curindex, SCBPTR);
2507     if (aic_inb(p, SCB_TAG) == scb->hscb->tag)
2508     {
2509       break;
2510     }
2511   }
2512   aic_outb(p, saved_scbptr, SCBPTR);
2513   if (curindex >= p->scb_data->maxhscbs)
2514   {
2515     curindex = SCB_LIST_NULL;
2516   }
2517
2518   return (curindex);
2519 }
2520
2521 /*+F*************************************************************************
2522  * Function:
2523  *   aic7xxx_allocate_scb
2524  *
2525  * Description:
2526  *   Get an SCB from the free list or by allocating a new one.
2527  *-F*************************************************************************/
2528 static int
2529 aic7xxx_allocate_scb(struct aic7xxx_host *p)
2530 {
2531   struct aic7xxx_scb   *scbp = NULL;
2532   int scb_size = (sizeof (struct hw_scatterlist) * AIC7XXX_MAX_SG) + 12 + 6;
2533   int i;
2534   int step = PAGE_SIZE / 1024;
2535   unsigned long scb_count = 0;
2536   struct hw_scatterlist *hsgp;
2537   struct aic7xxx_scb *scb_ap;
2538   struct aic7xxx_scb_dma *scb_dma;
2539   unsigned char *bufs;
2540
2541   if (p->scb_data->numscbs < p->scb_data->maxscbs)
2542   {
2543     /*
2544      * Calculate the optimal number of SCBs to allocate.
2545      *
2546      * NOTE: This formula works because the sizeof(sg_array) is always
2547      * 1024.  Therefore, scb_size * i would always be > PAGE_SIZE *
2548      * (i/step).  The (i-1) allows the left hand side of the equation
2549      * to grow into the right hand side to a point of near perfect
2550      * efficiency since scb_size * (i -1) is growing slightly faster
2551      * than the right hand side.  If the number of SG array elements
2552      * is changed, this function may not be near so efficient any more.
2553      *
2554      * Since the DMA'able buffers are now allocated in a separate
2555      * chunk this algorithm has been modified to match.  The '12'
2556      * and '6' factors in scb_size are for the DMA'able command byte
2557      * and sensebuffers respectively.  -DaveM
2558      */
2559     for ( i=step;; i *= 2 )
2560     {
2561       if ( (scb_size * (i-1)) >= ( (PAGE_SIZE * (i/step)) - 64 ) )
2562       {
2563         i /= 2;
2564         break;
2565       }
2566     }
2567     scb_count = min( (i-1), p->scb_data->maxscbs - p->scb_data->numscbs);
2568     scb_ap = (struct aic7xxx_scb *)kmalloc(sizeof (struct aic7xxx_scb) * scb_count
2569                                            + sizeof(struct aic7xxx_scb_dma), GFP_ATOMIC);
2570     if (scb_ap == NULL)
2571       return(0);
2572     scb_dma = (struct aic7xxx_scb_dma *)&scb_ap[scb_count];
2573     hsgp = (struct hw_scatterlist *)
2574       pci_alloc_consistent(p->pdev, scb_size * scb_count,
2575                            &scb_dma->dma_address);
2576     if (hsgp == NULL)
2577     {
2578       kfree(scb_ap);
2579       return(0);
2580     }
2581     bufs = (unsigned char *)&hsgp[scb_count * AIC7XXX_MAX_SG];
2582 #ifdef AIC7XXX_VERBOSE_DEBUGGING
2583     if (aic7xxx_verbose > 0xffff)
2584     {
2585       if (p->scb_data->numscbs == 0)
2586         printk(INFO_LEAD "Allocating initial %ld SCB structures.\n",
2587           p->host_no, -1, -1, -1, scb_count);
2588       else
2589         printk(INFO_LEAD "Allocating %ld additional SCB structures.\n",
2590           p->host_no, -1, -1, -1, scb_count);
2591     }
2592 #endif
2593     memset(scb_ap, 0, sizeof (struct aic7xxx_scb) * scb_count);
2594     scb_dma->dma_offset = (unsigned long)scb_dma->dma_address
2595                           - (unsigned long)hsgp;
2596     scb_dma->dma_len = scb_size * scb_count;
2597     for (i=0; i < scb_count; i++)
2598     {
2599       scbp = &scb_ap[i];
2600       scbp->hscb = &p->scb_data->hscbs[p->scb_data->numscbs];
2601       scbp->sg_list = &hsgp[i * AIC7XXX_MAX_SG];
2602       scbp->sense_cmd = bufs;
2603       scbp->cmnd = bufs + 6;
2604       bufs += 12 + 6;
2605       scbp->scb_dma = scb_dma;
2606       memset(scbp->hscb, 0, sizeof(struct aic7xxx_hwscb));
2607       scbp->hscb->tag = p->scb_data->numscbs;
2608       /*
2609        * Place in the scb array; never is removed
2610        */
2611       p->scb_data->scb_array[p->scb_data->numscbs++] = scbp;
2612       scbq_insert_tail(&p->scb_data->free_scbs, scbp);
2613     }
2614     scbp->kmalloc_ptr = scb_ap;
2615   }
2616   return(scb_count);
2617 }
2618
2619 /*+F*************************************************************************
2620  * Function:
2621  *   aic7xxx_queue_cmd_complete
2622  *
2623  * Description:
2624  *   Due to race conditions present in the SCSI subsystem, it is easier
2625  *   to queue completed commands, then call scsi_done() on them when
2626  *   we're finished.  This function queues the completed commands.
2627  *-F*************************************************************************/
2628 static void
2629 aic7xxx_queue_cmd_complete(struct aic7xxx_host *p, struct scsi_cmnd *cmd)
2630 {
2631   aic7xxx_position(cmd) = SCB_LIST_NULL;
2632   cmd->host_scribble = (char *)p->completeq.head;
2633   p->completeq.head = cmd;
2634 }
2635
2636 /*+F*************************************************************************
2637  * Function:
2638  *   aic7xxx_done_cmds_complete
2639  *
2640  * Description:
2641  *   Process the completed command queue.
2642  *-F*************************************************************************/
2643 static void aic7xxx_done_cmds_complete(struct aic7xxx_host *p)
2644 {
2645         struct scsi_cmnd *cmd;
2646
2647         while (p->completeq.head != NULL) {
2648                 cmd = p->completeq.head;
2649                 p->completeq.head = (struct scsi_Cmnd *) cmd->host_scribble;
2650                 cmd->host_scribble = NULL;
2651                 cmd->scsi_done(cmd);
2652         }
2653 }
2654
2655 /*+F*************************************************************************
2656  * Function:
2657  *   aic7xxx_free_scb
2658  *
2659  * Description:
2660  *   Free the scb and insert into the free scb list.
2661  *-F*************************************************************************/
2662 static void
2663 aic7xxx_free_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2664 {
2665
2666   scb->flags = SCB_FREE;
2667   scb->cmd = NULL;
2668   scb->sg_count = 0;
2669   scb->sg_length = 0;
2670   scb->tag_action = 0;
2671   scb->hscb->control = 0;
2672   scb->hscb->target_status = 0;
2673   scb->hscb->target_channel_lun = SCB_LIST_NULL;
2674
2675   scbq_insert_head(&p->scb_data->free_scbs, scb);
2676 }
2677
2678 /*+F*************************************************************************
2679  * Function:
2680  *   aic7xxx_done
2681  *
2682  * Description:
2683  *   Calls the higher level scsi done function and frees the scb.
2684  *-F*************************************************************************/
2685 static void
2686 aic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2687 {
2688         struct scsi_cmnd *cmd = scb->cmd;
2689         struct aic_dev_data *aic_dev = cmd->device->hostdata;
2690         int tindex = TARGET_INDEX(cmd);
2691         struct aic7xxx_scb *scbp;
2692         unsigned char queue_depth;
2693
2694   if (cmd->use_sg > 1)
2695   {
2696     struct scatterlist *sg;
2697
2698     sg = (struct scatterlist *)cmd->request_buffer;
2699     pci_unmap_sg(p->pdev, sg, cmd->use_sg, cmd->sc_data_direction);
2700   }
2701   else if (cmd->request_bufflen)
2702     pci_unmap_single(p->pdev, aic7xxx_mapping(cmd),
2703                      cmd->request_bufflen,
2704                      cmd->sc_data_direction);
2705   if (scb->flags & SCB_SENSE)
2706   {
2707     pci_unmap_single(p->pdev,
2708                      le32_to_cpu(scb->sg_list[0].address),
2709                      sizeof(cmd->sense_buffer),
2710                      PCI_DMA_FROMDEVICE);
2711   }
2712   if (scb->flags & SCB_RECOVERY_SCB)
2713   {
2714     p->flags &= ~AHC_ABORT_PENDING;
2715   }
2716   if (scb->flags & (SCB_RESET|SCB_ABORT))
2717   {
2718     cmd->result |= (DID_RESET << 16);
2719   }
2720
2721   if ((scb->flags & SCB_MSGOUT_BITS) != 0)
2722   {
2723     unsigned short mask;
2724     int message_error = FALSE;
2725
2726     mask = 0x01 << tindex;
2727  
2728     /*
2729      * Check to see if we get an invalid message or a message error
2730      * after failing to negotiate a wide or sync transfer message.
2731      */
2732     if ((scb->flags & SCB_SENSE) && 
2733           ((scb->cmd->sense_buffer[12] == 0x43) ||  /* INVALID_MESSAGE */
2734           (scb->cmd->sense_buffer[12] == 0x49))) /* MESSAGE_ERROR  */
2735     {
2736       message_error = TRUE;
2737     }
2738
2739     if (scb->flags & SCB_MSGOUT_WDTR)
2740     {
2741       if (message_error)
2742       {
2743         if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
2744              (aic_dev->flags & DEVICE_PRINT_DTR) )
2745         {
2746           printk(INFO_LEAD "Device failed to complete Wide Negotiation "
2747             "processing and\n", p->host_no, CTL_OF_SCB(scb));
2748           printk(INFO_LEAD "returned a sense error code for invalid message, "
2749             "disabling future\n", p->host_no, CTL_OF_SCB(scb));
2750           printk(INFO_LEAD "Wide negotiation to this device.\n", p->host_no,
2751             CTL_OF_SCB(scb));
2752         }
2753         aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
2754       }
2755     }
2756     if (scb->flags & SCB_MSGOUT_SDTR)
2757     {
2758       if (message_error)
2759       {
2760         if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
2761              (aic_dev->flags & DEVICE_PRINT_DTR) )
2762         {
2763           printk(INFO_LEAD "Device failed to complete Sync Negotiation "
2764             "processing and\n", p->host_no, CTL_OF_SCB(scb));
2765           printk(INFO_LEAD "returned a sense error code for invalid message, "
2766             "disabling future\n", p->host_no, CTL_OF_SCB(scb));
2767           printk(INFO_LEAD "Sync negotiation to this device.\n", p->host_no,
2768             CTL_OF_SCB(scb));
2769           aic_dev->flags &= ~DEVICE_PRINT_DTR;
2770         }
2771         aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
2772       }
2773     }
2774     if (scb->flags & SCB_MSGOUT_PPR)
2775     {
2776       if(message_error)
2777       {
2778         if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
2779              (aic_dev->flags & DEVICE_PRINT_DTR) )
2780         {
2781           printk(INFO_LEAD "Device failed to complete Parallel Protocol "
2782             "Request processing and\n", p->host_no, CTL_OF_SCB(scb));
2783           printk(INFO_LEAD "returned a sense error code for invalid message, "
2784             "disabling future\n", p->host_no, CTL_OF_SCB(scb));
2785           printk(INFO_LEAD "Parallel Protocol Request negotiation to this "
2786             "device.\n", p->host_no, CTL_OF_SCB(scb));
2787         }
2788         /*
2789          * Disable PPR negotiation and revert back to WDTR and SDTR setup
2790          */
2791         aic_dev->needppr = aic_dev->needppr_copy = 0;
2792         aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
2793         aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
2794       }
2795     }
2796   }
2797
2798   queue_depth = aic_dev->temp_q_depth;
2799   if (queue_depth >= aic_dev->active_cmds)
2800   {
2801     scbp = scbq_remove_head(&aic_dev->delayed_scbs);
2802     if (scbp)
2803     {
2804       if (queue_depth == 1)
2805       {
2806         /*
2807          * Give extra preference to untagged devices, such as CD-R devices
2808          * This makes it more likely that a drive *won't* stuff up while
2809          * waiting on data at a critical time, such as CD-R writing and
2810          * audio CD ripping operations.  Should also benefit tape drives.
2811          */
2812         scbq_insert_head(&p->waiting_scbs, scbp);
2813       }
2814       else
2815       {
2816         scbq_insert_tail(&p->waiting_scbs, scbp);
2817       }
2818 #ifdef AIC7XXX_VERBOSE_DEBUGGING
2819       if (aic7xxx_verbose > 0xffff)
2820         printk(INFO_LEAD "Moving SCB from delayed to waiting queue.\n",
2821                p->host_no, CTL_OF_SCB(scbp));
2822 #endif
2823       if (queue_depth > aic_dev->active_cmds)
2824       {
2825         scbp = scbq_remove_head(&aic_dev->delayed_scbs);
2826         if (scbp)
2827           scbq_insert_tail(&p->waiting_scbs, scbp);
2828       }
2829     }
2830   }
2831   if (!(scb->tag_action))
2832   {
2833     aic7xxx_index_busy_target(p, scb->hscb->target_channel_lun,
2834                               /* unbusy */ TRUE);
2835     if (cmd->device->simple_tags)
2836     {
2837       aic_dev->temp_q_depth = aic_dev->max_q_depth;
2838     }
2839   }
2840   if(scb->flags & SCB_DTR_SCB)
2841   {
2842     aic_dev->dtr_pending = 0;
2843   }
2844   aic_dev->active_cmds--;
2845   p->activescbs--;
2846
2847   if ((scb->sg_length >= 512) && (((cmd->result >> 16) & 0xf) == DID_OK))
2848   {
2849     long *ptr;
2850     int x, i;
2851
2852
2853     if (rq_data_dir(cmd->request) == WRITE)
2854     {
2855       aic_dev->w_total++;
2856       ptr = aic_dev->w_bins;
2857     }
2858     else
2859     {
2860       aic_dev->r_total++;
2861       ptr = aic_dev->r_bins;
2862     }
2863     if(cmd->device->simple_tags && cmd->request->cmd_flags & REQ_HARDBARRIER)
2864     {
2865       aic_dev->barrier_total++;
2866       if(scb->tag_action == MSG_ORDERED_Q_TAG)
2867         aic_dev->ordered_total++;
2868     }
2869     x = scb->sg_length;
2870     x >>= 10;
2871     for(i=0; i<6; i++)
2872     {
2873       x >>= 2;
2874       if(!x) {
2875         ptr[i]++;
2876         break;
2877       }
2878     }
2879     if(i == 6 && x)
2880       ptr[5]++;
2881   }
2882   aic7xxx_free_scb(p, scb);
2883   aic7xxx_queue_cmd_complete(p, cmd);
2884
2885 }
2886
2887 /*+F*************************************************************************
2888  * Function:
2889  *   aic7xxx_run_done_queue
2890  *
2891  * Description:
2892  *   Calls the aic7xxx_done() for the scsi_cmnd of each scb in the
2893  *   aborted list, and adds each scb to the free list.  If complete
2894  *   is TRUE, we also process the commands complete list.
2895  *-F*************************************************************************/
2896 static void
2897 aic7xxx_run_done_queue(struct aic7xxx_host *p, /*complete*/ int complete)
2898 {
2899   struct aic7xxx_scb *scb;
2900   int i, found = 0;
2901
2902   for (i = 0; i < p->scb_data->numscbs; i++)
2903   {
2904     scb = p->scb_data->scb_array[i];
2905     if (scb->flags & SCB_QUEUED_FOR_DONE)
2906     {
2907       if (scb->flags & SCB_QUEUE_FULL)
2908       {
2909         scb->cmd->result = QUEUE_FULL << 1;
2910       }
2911       else
2912       {
2913         if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
2914           printk(INFO_LEAD "Aborting scb %d\n",
2915                p->host_no, CTL_OF_SCB(scb), scb->hscb->tag);
2916         /*
2917          * Clear any residual information since the normal aic7xxx_done() path
2918          * doesn't touch the residuals.
2919          */
2920         scb->hscb->residual_SG_segment_count = 0;
2921         scb->hscb->residual_data_count[0] = 0;
2922         scb->hscb->residual_data_count[1] = 0;
2923         scb->hscb->residual_data_count[2] = 0;
2924       }
2925       found++;
2926       aic7xxx_done(p, scb);
2927     }
2928   }
2929   if (aic7xxx_verbose & (VERBOSE_ABORT_RETURN | VERBOSE_RESET_RETURN))
2930   {
2931     printk(INFO_LEAD "%d commands found and queued for "
2932         "completion.\n", p->host_no, -1, -1, -1, found);
2933   }
2934   if (complete)
2935   {
2936     aic7xxx_done_cmds_complete(p);
2937   }
2938 }
2939
2940 /*+F*************************************************************************
2941  * Function:
2942  *   aic7xxx_abort_waiting_scb
2943  *
2944  * Description:
2945  *   Manipulate the waiting for selection list and return the
2946  *   scb that follows the one that we remove.
2947  *-F*************************************************************************/
2948 static unsigned char
2949 aic7xxx_abort_waiting_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb,
2950     unsigned char scbpos, unsigned char prev)
2951 {
2952   unsigned char curscb, next;
2953
2954   /*
2955    * Select the SCB we want to abort and pull the next pointer out of it.
2956    */
2957   curscb = aic_inb(p, SCBPTR);
2958   aic_outb(p, scbpos, SCBPTR);
2959   next = aic_inb(p, SCB_NEXT);
2960
2961   aic7xxx_add_curscb_to_free_list(p);
2962
2963   /*
2964    * Update the waiting list
2965    */
2966   if (prev == SCB_LIST_NULL)
2967   {
2968     /*
2969      * First in the list
2970      */
2971     aic_outb(p, next, WAITING_SCBH);
2972   }
2973   else
2974   {
2975     /*
2976      * Select the scb that pointed to us and update its next pointer.
2977      */
2978     aic_outb(p, prev, SCBPTR);
2979     aic_outb(p, next, SCB_NEXT);
2980   }
2981   /*
2982    * Point us back at the original scb position and inform the SCSI
2983    * system that the command has been aborted.
2984    */
2985   aic_outb(p, curscb, SCBPTR);
2986   return (next);
2987 }
2988
2989 /*+F*************************************************************************
2990  * Function:
2991  *   aic7xxx_search_qinfifo
2992  *
2993  * Description:
2994  *   Search the queue-in FIFO for matching SCBs and conditionally
2995  *   requeue.  Returns the number of matching SCBs.
2996  *-F*************************************************************************/
2997 static int
2998 aic7xxx_search_qinfifo(struct aic7xxx_host *p, int target, int channel,
2999     int lun, unsigned char tag, int flags, int requeue,
3000     volatile scb_queue_type *queue)
3001 {
3002   int      found;
3003   unsigned char qinpos, qintail;
3004   struct aic7xxx_scb *scbp;
3005
3006   found = 0;
3007   qinpos = aic_inb(p, QINPOS);
3008   qintail = p->qinfifonext;
3009
3010   p->qinfifonext = qinpos;
3011
3012   while (qinpos != qintail)
3013   {
3014     scbp = p->scb_data->scb_array[p->qinfifo[qinpos++]];
3015     if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3016     {
3017        /*
3018         * We found an scb that needs to be removed.
3019         */
3020        if (requeue && (queue != NULL))
3021        {
3022          if (scbp->flags & SCB_WAITINGQ)
3023          {
3024            scbq_remove(queue, scbp);
3025            scbq_remove(&p->waiting_scbs, scbp);
3026            scbq_remove(&AIC_DEV(scbp->cmd)->delayed_scbs, scbp);
3027            AIC_DEV(scbp->cmd)->active_cmds++;
3028            p->activescbs++;
3029          }
3030          scbq_insert_tail(queue, scbp);
3031          AIC_DEV(scbp->cmd)->active_cmds--;
3032          p->activescbs--;
3033          scbp->flags |= SCB_WAITINGQ;
3034          if ( !(scbp->tag_action & TAG_ENB) )
3035          {
3036            aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun,
3037              TRUE);
3038          }
3039        }
3040        else if (requeue)
3041        {
3042          p->qinfifo[p->qinfifonext++] = scbp->hscb->tag;
3043        }
3044        else
3045        {
3046         /*
3047          * Preserve any SCB_RECOVERY_SCB flags on this scb then set the
3048          * flags we were called with, presumeably so aic7xxx_run_done_queue
3049          * can find this scb
3050          */
3051          scbp->flags = flags | (scbp->flags & SCB_RECOVERY_SCB);
3052          if (aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun,
3053                                        FALSE) == scbp->hscb->tag)
3054          {
3055            aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun,
3056              TRUE);
3057          }
3058        }
3059        found++;
3060     }
3061     else
3062     {
3063       p->qinfifo[p->qinfifonext++] = scbp->hscb->tag;
3064     }
3065   }
3066   /*
3067    * Now that we've done the work, clear out any left over commands in the
3068    * qinfifo and update the KERNEL_QINPOS down on the card.
3069    *
3070    *  NOTE: This routine expect the sequencer to already be paused when
3071    *        it is run....make sure it's that way!
3072    */
3073   qinpos = p->qinfifonext;
3074   while(qinpos != qintail)
3075   {
3076     p->qinfifo[qinpos++] = SCB_LIST_NULL;
3077   }
3078   if (p->features & AHC_QUEUE_REGS)
3079     aic_outb(p, p->qinfifonext, HNSCB_QOFF);
3080   else
3081     aic_outb(p, p->qinfifonext, KERNEL_QINPOS);
3082
3083   return (found);
3084 }
3085
3086 /*+F*************************************************************************
3087  * Function:
3088  *   aic7xxx_scb_on_qoutfifo
3089  *
3090  * Description:
3091  *   Is the scb that was passed to us currently on the qoutfifo?
3092  *-F*************************************************************************/
3093 static int
3094 aic7xxx_scb_on_qoutfifo(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
3095 {
3096   int i=0;
3097
3098   while(p->qoutfifo[(p->qoutfifonext + i) & 0xff ] != SCB_LIST_NULL)
3099   {
3100     if(p->qoutfifo[(p->qoutfifonext + i) & 0xff ] == scb->hscb->tag)
3101       return TRUE;
3102     else
3103       i++;
3104   }
3105   return FALSE;
3106 }
3107
3108
3109 /*+F*************************************************************************
3110  * Function:
3111  *   aic7xxx_reset_device
3112  *
3113  * Description:
3114  *   The device at the given target/channel has been reset.  Abort
3115  *   all active and queued scbs for that target/channel.  This function
3116  *   need not worry about linked next pointers because if was a MSG_ABORT_TAG
3117  *   then we had a tagged command (no linked next), if it was MSG_ABORT or
3118  *   MSG_BUS_DEV_RESET then the device won't know about any commands any more
3119  *   and no busy commands will exist, and if it was a bus reset, then nothing
3120  *   knows about any linked next commands any more.  In all cases, we don't
3121  *   need to worry about the linked next or busy scb, we just need to clear
3122  *   them.
3123  *-F*************************************************************************/
3124 static void
3125 aic7xxx_reset_device(struct aic7xxx_host *p, int target, int channel,
3126                      int lun, unsigned char tag)
3127 {
3128   struct aic7xxx_scb *scbp, *prev_scbp;
3129   struct scsi_device *sd;
3130   unsigned char active_scb, tcl, scb_tag;
3131   int i = 0, init_lists = FALSE;
3132   struct aic_dev_data *aic_dev;
3133
3134   /*
3135    * Restore this when we're done
3136    */
3137   active_scb = aic_inb(p, SCBPTR);
3138   scb_tag = aic_inb(p, SCB_TAG);
3139
3140   if (aic7xxx_verbose & (VERBOSE_RESET_PROCESS | VERBOSE_ABORT_PROCESS))
3141   {
3142     printk(INFO_LEAD "Reset device, hardware_scb %d,\n",
3143          p->host_no, channel, target, lun, active_scb);
3144     printk(INFO_LEAD "Current scb %d, SEQADDR 0x%x, LASTPHASE "
3145            "0x%x\n",
3146          p->host_no, channel, target, lun, scb_tag,
3147          aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
3148          aic_inb(p, LASTPHASE));
3149     printk(INFO_LEAD "SG_CACHEPTR 0x%x, SG_COUNT %d, SCSISIGI 0x%x\n",
3150          p->host_no, channel, target, lun,
3151          (p->features & AHC_ULTRA2) ?  aic_inb(p, SG_CACHEPTR) : 0,
3152          aic_inb(p, SG_COUNT), aic_inb(p, SCSISIGI));
3153     printk(INFO_LEAD "SSTAT0 0x%x, SSTAT1 0x%x, SSTAT2 0x%x\n",
3154          p->host_no, channel, target, lun, aic_inb(p, SSTAT0),
3155          aic_inb(p, SSTAT1), aic_inb(p, SSTAT2));
3156   }
3157
3158   /*
3159    * Deal with the busy target and linked next issues.
3160    */
3161   list_for_each_entry(aic_dev, &p->aic_devs, list)
3162   {
3163     if (aic7xxx_verbose & (VERBOSE_RESET_PROCESS | VERBOSE_ABORT_PROCESS))
3164       printk(INFO_LEAD "processing aic_dev %p\n", p->host_no, channel, target,
3165                     lun, aic_dev);
3166     sd = aic_dev->SDptr;
3167
3168     if((target != ALL_TARGETS && target != sd->id) ||
3169        (channel != ALL_CHANNELS && channel != sd->channel))
3170       continue;
3171     if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3172         printk(INFO_LEAD "Cleaning up status information "
3173           "and delayed_scbs.\n", p->host_no, sd->channel, sd->id, sd->lun);
3174     aic_dev->flags &= ~BUS_DEVICE_RESET_PENDING;
3175     if ( tag == SCB_LIST_NULL )
3176     {
3177       aic_dev->dtr_pending = 0;
3178       aic_dev->needppr = aic_dev->needppr_copy;
3179       aic_dev->needsdtr = aic_dev->needsdtr_copy;
3180       aic_dev->needwdtr = aic_dev->needwdtr_copy;
3181       aic_dev->flags = DEVICE_PRINT_DTR;
3182       aic_dev->temp_q_depth = aic_dev->max_q_depth;
3183     }
3184     tcl = (sd->id << 4) | (sd->channel << 3) | sd->lun;
3185     if ( (aic7xxx_index_busy_target(p, tcl, FALSE) == tag) ||
3186          (tag == SCB_LIST_NULL) )
3187       aic7xxx_index_busy_target(p, tcl, /* unbusy */ TRUE);
3188     prev_scbp = NULL; 
3189     scbp = aic_dev->delayed_scbs.head;
3190     while (scbp != NULL)
3191     {
3192       prev_scbp = scbp;
3193       scbp = scbp->q_next;
3194       if (aic7xxx_match_scb(p, prev_scbp, target, channel, lun, tag))
3195       {
3196         scbq_remove(&aic_dev->delayed_scbs, prev_scbp);
3197         if (prev_scbp->flags & SCB_WAITINGQ)
3198         {
3199           aic_dev->active_cmds++;
3200           p->activescbs++;
3201         }
3202         prev_scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3203         prev_scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3204       }
3205     }
3206   }
3207
3208   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3209     printk(INFO_LEAD "Cleaning QINFIFO.\n", p->host_no, channel, target, lun );
3210   aic7xxx_search_qinfifo(p, target, channel, lun, tag,
3211       SCB_RESET | SCB_QUEUED_FOR_DONE, /* requeue */ FALSE, NULL);
3212
3213 /*
3214  *  Search the waiting_scbs queue for matches, this catches any SCB_QUEUED
3215  *  ABORT/RESET commands.
3216  */
3217   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3218     printk(INFO_LEAD "Cleaning waiting_scbs.\n", p->host_no, channel,
3219       target, lun );
3220   {
3221     struct aic7xxx_scb *scbp, *prev_scbp;
3222
3223     prev_scbp = NULL; 
3224     scbp = p->waiting_scbs.head;
3225     while (scbp != NULL)
3226     {
3227       prev_scbp = scbp;
3228       scbp = scbp->q_next;
3229       if (aic7xxx_match_scb(p, prev_scbp, target, channel, lun, tag))
3230       {
3231         scbq_remove(&p->waiting_scbs, prev_scbp);
3232         if (prev_scbp->flags & SCB_WAITINGQ)
3233         {
3234           AIC_DEV(prev_scbp->cmd)->active_cmds++;
3235           p->activescbs++;
3236         }
3237         prev_scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3238         prev_scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3239       }
3240     }
3241   }
3242
3243
3244   /*
3245    * Search waiting for selection list.
3246    */
3247   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3248     printk(INFO_LEAD "Cleaning waiting for selection "
3249       "list.\n", p->host_no, channel, target, lun);
3250   {
3251     unsigned char next, prev, scb_index;
3252
3253     next = aic_inb(p, WAITING_SCBH);  /* Start at head of list. */
3254     prev = SCB_LIST_NULL;
3255     while (next != SCB_LIST_NULL)
3256     {
3257       aic_outb(p, next, SCBPTR);
3258       scb_index = aic_inb(p, SCB_TAG);
3259       if (scb_index >= p->scb_data->numscbs)
3260       {
3261        /*
3262         * No aic7xxx_verbose check here.....we want to see this since it
3263         * means either the kernel driver or the sequencer screwed things up
3264         */
3265         printk(WARN_LEAD "Waiting List inconsistency; SCB index=%d, "
3266           "numscbs=%d\n", p->host_no, channel, target, lun, scb_index,
3267           p->scb_data->numscbs);
3268         next = aic_inb(p, SCB_NEXT);
3269         aic7xxx_add_curscb_to_free_list(p);
3270       }
3271       else
3272       {
3273         scbp = p->scb_data->scb_array[scb_index];
3274         if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3275         {
3276           next = aic7xxx_abort_waiting_scb(p, scbp, next, prev);
3277           if (scbp->flags & SCB_WAITINGQ)
3278           {
3279             AIC_DEV(scbp->cmd)->active_cmds++;
3280             p->activescbs++;
3281           }
3282           scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3283           scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3284           if (prev == SCB_LIST_NULL)
3285           {
3286             /*
3287              * This is either the first scb on the waiting list, or we
3288              * have already yanked the first and haven't left any behind.
3289              * Either way, we need to turn off the selection hardware if
3290              * it isn't already off.
3291              */
3292             aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ);
3293             aic_outb(p, CLRSELTIMEO, CLRSINT1);
3294           }
3295         }
3296         else
3297         {
3298           prev = next;
3299           next = aic_inb(p, SCB_NEXT);
3300         }
3301       }
3302     }
3303   }
3304
3305   /*
3306    * Go through disconnected list and remove any entries we have queued
3307    * for completion, zeroing their control byte too.
3308    */
3309   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3310     printk(INFO_LEAD "Cleaning disconnected scbs "
3311       "list.\n", p->host_no, channel, target, lun);
3312   if (p->flags & AHC_PAGESCBS)
3313   {
3314     unsigned char next, prev, scb_index;
3315
3316     next = aic_inb(p, DISCONNECTED_SCBH);
3317     prev = SCB_LIST_NULL;
3318     while (next != SCB_LIST_NULL)
3319     {
3320       aic_outb(p, next, SCBPTR);
3321       scb_index = aic_inb(p, SCB_TAG);
3322       if (scb_index > p->scb_data->numscbs)
3323       {
3324         printk(WARN_LEAD "Disconnected List inconsistency; SCB index=%d, "
3325           "numscbs=%d\n", p->host_no, channel, target, lun, scb_index,
3326           p->scb_data->numscbs);
3327         next = aic7xxx_rem_scb_from_disc_list(p, next, prev);
3328       }
3329       else
3330       {
3331         scbp = p->scb_data->scb_array[scb_index];
3332         if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3333         {
3334           next = aic7xxx_rem_scb_from_disc_list(p, next, prev);
3335           if (scbp->flags & SCB_WAITINGQ)
3336           {
3337             AIC_DEV(scbp->cmd)->active_cmds++;
3338             p->activescbs++;
3339           }
3340           scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3341           scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3342           scbp->hscb->control = 0;
3343         }
3344         else
3345         {
3346           prev = next;
3347           next = aic_inb(p, SCB_NEXT);
3348         }
3349       }
3350     }
3351   }
3352
3353   /*
3354    * Walk the free list making sure no entries on the free list have
3355    * a valid SCB_TAG value or SCB_CONTROL byte.
3356    */
3357   if (p->flags & AHC_PAGESCBS)
3358   {
3359     unsigned char next;
3360
3361     next = aic_inb(p, FREE_SCBH);
3362     while (next != SCB_LIST_NULL)
3363     {
3364       aic_outb(p, next, SCBPTR);
3365       if (aic_inb(p, SCB_TAG) < p->scb_data->numscbs)
3366       {
3367         printk(WARN_LEAD "Free list inconsistency!.\n", p->host_no, channel,
3368           target, lun);
3369         init_lists = TRUE;
3370         next = SCB_LIST_NULL;
3371       }
3372       else
3373       {
3374         aic_outb(p, SCB_LIST_NULL, SCB_TAG);
3375         aic_outb(p, 0, SCB_CONTROL);
3376         next = aic_inb(p, SCB_NEXT);
3377       }
3378     }
3379   }
3380
3381   /*
3382    * Go through the hardware SCB array looking for commands that
3383    * were active but not on any list.
3384    */
3385   if (init_lists)
3386   {
3387     aic_outb(p, SCB_LIST_NULL, FREE_SCBH);
3388     aic_outb(p, SCB_LIST_NULL, WAITING_SCBH);
3389     aic_outb(p, SCB_LIST_NULL, DISCONNECTED_SCBH);
3390   }
3391   for (i = p->scb_data->maxhscbs - 1; i >= 0; i--)
3392   {
3393     unsigned char scbid;
3394
3395     aic_outb(p, i, SCBPTR);
3396     if (init_lists)
3397     {
3398       aic_outb(p, SCB_LIST_NULL, SCB_TAG);
3399       aic_outb(p, SCB_LIST_NULL, SCB_NEXT);
3400       aic_outb(p, 0, SCB_CONTROL);
3401       aic7xxx_add_curscb_to_free_list(p);
3402     }
3403     else
3404     {
3405       scbid = aic_inb(p, SCB_TAG);
3406       if (scbid < p->scb_data->numscbs)
3407       {
3408         scbp = p->scb_data->scb_array[scbid];
3409         if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3410         {
3411           aic_outb(p, 0, SCB_CONTROL);
3412           aic_outb(p, SCB_LIST_NULL, SCB_TAG);
3413           aic7xxx_add_curscb_to_free_list(p);
3414         }
3415       }
3416     }
3417   }
3418
3419   /*
3420    * Go through the entire SCB array now and look for commands for
3421    * for this target that are stillactive.  These are other (most likely
3422    * tagged) commands that were disconnected when the reset occurred.
3423    * Any commands we find here we know this about, it wasn't on any queue,
3424    * it wasn't in the qinfifo, it wasn't in the disconnected or waiting
3425    * lists, so it really must have been a paged out SCB.  In that case,
3426    * we shouldn't need to bother with updating any counters, just mark
3427    * the correct flags and go on.
3428    */
3429   for (i = 0; i < p->scb_data->numscbs; i++)
3430   {
3431     scbp = p->scb_data->scb_array[i];
3432     if ((scbp->flags & SCB_ACTIVE) &&
3433         aic7xxx_match_scb(p, scbp, target, channel, lun, tag) &&
3434         !aic7xxx_scb_on_qoutfifo(p, scbp))
3435     {
3436       if (scbp->flags & SCB_WAITINGQ)
3437       {
3438         scbq_remove(&p->waiting_scbs, scbp);
3439         scbq_remove(&AIC_DEV(scbp->cmd)->delayed_scbs, scbp);
3440         AIC_DEV(scbp->cmd)->active_cmds++;
3441         p->activescbs++;
3442       }
3443       scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3444       scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3445     }
3446   }
3447
3448   aic_outb(p, active_scb, SCBPTR);
3449 }
3450
3451
3452 /*+F*************************************************************************
3453  * Function:
3454  *   aic7xxx_clear_intstat
3455  *
3456  * Description:
3457  *   Clears the interrupt status.
3458  *-F*************************************************************************/
3459 static void
3460 aic7xxx_clear_intstat(struct aic7xxx_host *p)
3461 {
3462   /* Clear any interrupt conditions this may have caused. */
3463   aic_outb(p, CLRSELDO | CLRSELDI | CLRSELINGO, CLRSINT0);
3464   aic_outb(p, CLRSELTIMEO | CLRATNO | CLRSCSIRSTI | CLRBUSFREE | CLRSCSIPERR |
3465        CLRPHASECHG | CLRREQINIT, CLRSINT1);
3466   aic_outb(p, CLRSCSIINT | CLRSEQINT | CLRBRKADRINT | CLRPARERR, CLRINT);
3467 }
3468
3469 /*+F*************************************************************************
3470  * Function:
3471  *   aic7xxx_reset_current_bus
3472  *
3473  * Description:
3474  *   Reset the current SCSI bus.
3475  *-F*************************************************************************/
3476 static void
3477 aic7xxx_reset_current_bus(struct aic7xxx_host *p)
3478 {
3479
3480   /* Disable reset interrupts. */
3481   aic_outb(p, aic_inb(p, SIMODE1) & ~ENSCSIRST, SIMODE1);
3482
3483   /* Turn off the bus' current operations, after all, we shouldn't have any
3484    * valid commands left to cause a RSELI and SELO once we've tossed the
3485    * bus away with this reset, so we might as well shut down the sequencer
3486    * until the bus is restarted as oppossed to saving the current settings
3487    * and restoring them (which makes no sense to me). */
3488
3489   /* Turn on the bus reset. */
3490   aic_outb(p, aic_inb(p, SCSISEQ) | SCSIRSTO, SCSISEQ);
3491   while ( (aic_inb(p, SCSISEQ) & SCSIRSTO) == 0)
3492     mdelay(5);
3493
3494   /*
3495    * Some of the new Ultra2 chipsets need a longer delay after a chip
3496    * reset than just the init setup creates, so we have to delay here
3497    * before we go into a reset in order to make the chips happy.
3498    */
3499   if (p->features & AHC_ULTRA2)
3500     mdelay(250);
3501   else
3502     mdelay(50);
3503
3504   /* Turn off the bus reset. */
3505   aic_outb(p, 0, SCSISEQ);
3506   mdelay(10);
3507
3508   aic7xxx_clear_intstat(p);
3509   /* Re-enable reset interrupts. */
3510   aic_outb(p, aic_inb(p, SIMODE1) | ENSCSIRST, SIMODE1);
3511
3512 }
3513
3514 /*+F*************************************************************************
3515  * Function:
3516  *   aic7xxx_reset_channel
3517  *
3518  * Description:
3519  *   Reset the channel.
3520  *-F*************************************************************************/
3521 static void
3522 aic7xxx_reset_channel(struct aic7xxx_host *p, int channel, int initiate_reset)
3523 {
3524   unsigned long offset_min, offset_max;
3525   unsigned char sblkctl;
3526   int cur_channel;
3527
3528   if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3529     printk(INFO_LEAD "Reset channel called, %s initiate reset.\n",
3530       p->host_no, channel, -1, -1, (initiate_reset==TRUE) ? "will" : "won't" );
3531
3532
3533   if (channel == 1)
3534   {
3535     offset_min = 8;
3536     offset_max = 16;
3537   }
3538   else
3539   {
3540     if (p->features & AHC_TWIN)
3541     {
3542       /* Channel A */
3543       offset_min = 0;
3544       offset_max = 8;
3545     }
3546     else
3547     {
3548       offset_min = 0;
3549       if (p->features & AHC_WIDE)
3550       {
3551         offset_max = 16;
3552       }
3553       else
3554       {
3555         offset_max = 8;
3556       }
3557     }
3558   }
3559
3560   while (offset_min < offset_max)
3561   {
3562     /*
3563      * Revert to async/narrow transfers until we renegotiate.
3564      */
3565     aic_outb(p, 0, TARG_SCSIRATE + offset_min);
3566     if (p->features & AHC_ULTRA2)
3567     {
3568       aic_outb(p, 0, TARG_OFFSET + offset_min);
3569     }
3570     offset_min++;
3571   }
3572
3573   /*
3574    * Reset the bus and unpause/restart the controller
3575    */
3576   sblkctl = aic_inb(p, SBLKCTL);
3577   if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
3578     cur_channel = (sblkctl & SELBUSB) >> 3;
3579   else
3580     cur_channel = 0;
3581   if ( (cur_channel != channel) && (p->features & AHC_TWIN) )
3582   {
3583     /*
3584      * Case 1: Command for another bus is active
3585      */
3586     if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3587       printk(INFO_LEAD "Stealthily resetting idle channel.\n", p->host_no,
3588         channel, -1, -1);
3589     /*
3590      * Stealthily reset the other bus without upsetting the current bus.
3591      */
3592     aic_outb(p, sblkctl ^ SELBUSB, SBLKCTL);
3593     aic_outb(p, aic_inb(p, SIMODE1) & ~ENBUSFREE, SIMODE1);
3594     if (initiate_reset)
3595     {
3596       aic7xxx_reset_current_bus(p);
3597     }
3598     aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), SCSISEQ);
3599     aic7xxx_clear_intstat(p);
3600     aic_outb(p, sblkctl, SBLKCTL);
3601   }
3602   else
3603   {
3604     /*
3605      * Case 2: A command from this bus is active or we're idle.
3606      */
3607     if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3608       printk(INFO_LEAD "Resetting currently active channel.\n", p->host_no,
3609         channel, -1, -1);
3610     aic_outb(p, aic_inb(p, SIMODE1) & ~(ENBUSFREE|ENREQINIT),
3611       SIMODE1);
3612     p->flags &= ~AHC_HANDLING_REQINITS;
3613     p->msg_type = MSG_TYPE_NONE;
3614     p->msg_len = 0;
3615     if (initiate_reset)
3616     {
3617       aic7xxx_reset_current_bus(p);
3618     }
3619     aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), SCSISEQ);
3620     aic7xxx_clear_intstat(p);
3621   }
3622   if (aic7xxx_verbose & VERBOSE_RESET_RETURN)
3623     printk(INFO_LEAD "Channel reset\n", p->host_no, channel, -1, -1);
3624   /*
3625    * Clean up all the state information for the pending transactions
3626    * on this bus.
3627    */
3628   aic7xxx_reset_device(p, ALL_TARGETS, channel, ALL_LUNS, SCB_LIST_NULL);
3629
3630   if ( !(p->features & AHC_TWIN) )
3631   {
3632     restart_sequencer(p);
3633   }
3634
3635   return;
3636 }
3637
3638 /*+F*************************************************************************
3639  * Function:
3640  *   aic7xxx_run_waiting_queues
3641  *
3642  * Description:
3643  *   Scan the awaiting_scbs queue downloading and starting as many
3644  *   scbs as we can.
3645  *-F*************************************************************************/
3646 static void
3647 aic7xxx_run_waiting_queues(struct aic7xxx_host *p)
3648 {
3649   struct aic7xxx_scb *scb;
3650   struct aic_dev_data *aic_dev;
3651   int sent;
3652
3653
3654   if (p->waiting_scbs.head == NULL)
3655     return;
3656
3657   sent = 0;
3658
3659   /*
3660    * First handle SCBs that are waiting but have been assigned a slot.
3661    */
3662   while ((scb = scbq_remove_head(&p->waiting_scbs)) != NULL)
3663   {
3664     aic_dev = scb->cmd->device->hostdata;
3665     if ( !scb->tag_action )
3666     {
3667       aic_dev->temp_q_depth = 1;
3668     }
3669     if ( aic_dev->active_cmds >= aic_dev->temp_q_depth)
3670     {
3671       scbq_insert_tail(&aic_dev->delayed_scbs, scb);
3672     }
3673     else
3674     {
3675         scb->flags &= ~SCB_WAITINGQ;
3676         aic_dev->active_cmds++;
3677         p->activescbs++;
3678         if ( !(scb->tag_action) )
3679         {
3680           aic7xxx_busy_target(p, scb);
3681         }
3682         p->qinfifo[p->qinfifonext++] = scb->hscb->tag;
3683         sent++;
3684     }
3685   }
3686   if (sent)
3687   {
3688     if (p->features & AHC_QUEUE_REGS)
3689       aic_outb(p, p->qinfifonext, HNSCB_QOFF);
3690     else
3691     {
3692       pause_sequencer(p);
3693       aic_outb(p, p->qinfifonext, KERNEL_QINPOS);
3694       unpause_sequencer(p, FALSE);
3695     }
3696     if (p->activescbs > p->max_activescbs)
3697       p->max_activescbs = p->activescbs;
3698   }
3699 }
3700
3701 #ifdef CONFIG_PCI
3702
3703 #define  DPE 0x80
3704 #define  SSE 0x40
3705 #define  RMA 0x20
3706 #define  RTA 0x10
3707 #define  STA 0x08
3708 #define  DPR 0x01
3709
3710 /*+F*************************************************************************
3711  * Function:
3712  *   aic7xxx_pci_intr
3713  *
3714  * Description:
3715  *   Check the scsi card for PCI errors and clear the interrupt
3716  *
3717  *   NOTE: If you don't have this function and a 2940 card encounters
3718  *         a PCI error condition, the machine will end up locked as the
3719  *         interrupt handler gets slammed with non-stop PCI error interrupts
3720  *-F*************************************************************************/
3721 static void
3722 aic7xxx_pci_intr(struct aic7xxx_host *p)
3723 {
3724   unsigned char status1;
3725
3726   pci_read_config_byte(p->pdev, PCI_STATUS + 1, &status1);
3727
3728   if ( (status1 & DPE) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3729     printk(WARN_LEAD "Data Parity Error during PCI address or PCI write"
3730       "phase.\n", p->host_no, -1, -1, -1);
3731   if ( (status1 & SSE) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3732     printk(WARN_LEAD "Signal System Error Detected\n", p->host_no,
3733       -1, -1, -1);
3734   if ( (status1 & RMA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3735     printk(WARN_LEAD "Received a PCI Master Abort\n", p->host_no,
3736       -1, -1, -1);
3737   if ( (status1 & RTA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3738     printk(WARN_LEAD "Received a PCI Target Abort\n", p->host_no,
3739       -1, -1, -1);
3740   if ( (status1 & STA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3741     printk(WARN_LEAD "Signaled a PCI Target Abort\n", p->host_no,
3742       -1, -1, -1);
3743   if ( (status1 & DPR) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3744     printk(WARN_LEAD "Data Parity Error has been reported via PCI pin "
3745       "PERR#\n", p->host_no, -1, -1, -1);
3746   
3747   pci_write_config_byte(p->pdev, PCI_STATUS + 1, status1);
3748   if (status1 & (DPR|RMA|RTA))
3749     aic_outb(p,  CLRPARERR, CLRINT);
3750
3751   if ( (aic7xxx_panic_on_abort) && (p->spurious_int > 500) )
3752     aic7xxx_panic_abort(p, NULL);
3753
3754 }
3755 #endif /* CONFIG_PCI */
3756
3757 /*+F*************************************************************************
3758  * Function:
3759  *   aic7xxx_construct_ppr
3760  *
3761  * Description:
3762  *   Build up a Parallel Protocol Request message for use with SCSI-3
3763  *   devices.
3764  *-F*************************************************************************/
3765 static void
3766 aic7xxx_construct_ppr(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
3767 {
3768   p->msg_buf[p->msg_index++] = MSG_EXTENDED;
3769   p->msg_buf[p->msg_index++] = MSG_EXT_PPR_LEN;
3770   p->msg_buf[p->msg_index++] = MSG_EXT_PPR;
3771   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.period;
3772   p->msg_buf[p->msg_index++] = 0;
3773   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.offset;
3774   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.width;
3775   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.options;
3776   p->msg_len += 8;
3777 }
3778
3779 /*+F*************************************************************************
3780  * Function:
3781  *   aic7xxx_construct_sdtr
3782  *
3783  * Description:
3784  *   Constucts a synchronous data transfer message in the message
3785  *   buffer on the sequencer.
3786  *-F*************************************************************************/
3787 static void
3788 aic7xxx_construct_sdtr(struct aic7xxx_host *p, unsigned char period,
3789         unsigned char offset)
3790 {
3791   p->msg_buf[p->msg_index++] = MSG_EXTENDED;
3792   p->msg_buf[p->msg_index++] = MSG_EXT_SDTR_LEN;
3793   p->msg_buf[p->msg_index++] = MSG_EXT_SDTR;
3794   p->msg_buf[p->msg_index++] = period;
3795   p->msg_buf[p->msg_index++] = offset;
3796   p->msg_len += 5;
3797 }
3798
3799 /*+F*************************************************************************
3800  * Function:
3801  *   aic7xxx_construct_wdtr
3802  *
3803  * Description:
3804  *   Constucts a wide data transfer message in the message buffer
3805  *   on the sequencer.
3806  *-F*************************************************************************/
3807 static void
3808 aic7xxx_construct_wdtr(struct aic7xxx_host *p, unsigned char bus_width)
3809 {
3810   p->msg_buf[p->msg_index++] = MSG_EXTENDED;
3811   p->msg_buf[p->msg_index++] = MSG_EXT_WDTR_LEN;
3812   p->msg_buf[p->msg_index++] = MSG_EXT_WDTR;
3813   p->msg_buf[p->msg_index++] = bus_width;
3814   p->msg_len += 4;
3815 }
3816
3817 /*+F*************************************************************************
3818  * Function:
3819  *   aic7xxx_calc_residual
3820  *
3821  * Description:
3822  *   Calculate the residual data not yet transferred.
3823  *-F*************************************************************************/
3824 static void
3825 aic7xxx_calculate_residual (struct aic7xxx_host *p, struct aic7xxx_scb *scb)
3826 {
3827         struct aic7xxx_hwscb *hscb;
3828         struct scsi_cmnd *cmd;
3829         int actual, i;
3830
3831   cmd = scb->cmd;
3832   hscb = scb->hscb;
3833
3834   /*
3835    *  Don't destroy valid residual information with
3836    *  residual coming from a check sense operation.
3837    */
3838   if (((scb->hscb->control & DISCONNECTED) == 0) &&
3839       (scb->flags & SCB_SENSE) == 0)
3840   {
3841     /*
3842      *  We had an underflow. At this time, there's only
3843      *  one other driver that bothers to check for this,
3844      *  and cmd->underflow seems to be set rather half-
3845      *  heartedly in the higher-level SCSI code.
3846      */
3847     actual = scb->sg_length;
3848     for (i=1; i < hscb->residual_SG_segment_count; i++)
3849     {
3850       actual -= scb->sg_list[scb->sg_count - i].length;
3851     }
3852     actual -= (hscb->residual_data_count[2] << 16) |
3853               (hscb->residual_data_count[1] <<  8) |
3854               hscb->residual_data_count[0];
3855
3856     if (actual < cmd->underflow)
3857     {
3858       if (aic7xxx_verbose & VERBOSE_MINOR_ERROR)
3859       {
3860         printk(INFO_LEAD "Underflow - Wanted %u, %s %u, residual SG "
3861           "count %d.\n", p->host_no, CTL_OF_SCB(scb), cmd->underflow,
3862           (rq_data_dir(cmd->request) == WRITE) ? "wrote" : "read", actual,
3863           hscb->residual_SG_segment_count);
3864         printk(INFO_LEAD "status 0x%x.\n", p->host_no, CTL_OF_SCB(scb),
3865           hscb->target_status);
3866       }
3867       /*
3868        * In 2.4, only send back the residual information, don't flag this
3869        * as an error.  Before 2.4 we had to flag this as an error because
3870        * the mid layer didn't check residual data counts to see if the
3871        * command needs retried.
3872        */
3873       cmd->resid = scb->sg_length - actual;
3874       aic7xxx_status(cmd) = hscb->target_status;
3875     }
3876   }
3877
3878   /*
3879    * Clean out the residual information in the SCB for the
3880    * next consumer.
3881    */
3882   hscb->residual_data_count[2] = 0;
3883   hscb->residual_data_count[1] = 0;
3884   hscb->residual_data_count[0] = 0;
3885   hscb->residual_SG_segment_count = 0;
3886 }
3887
3888 /*+F*************************************************************************
3889  * Function:
3890  *   aic7xxx_handle_device_reset
3891  *
3892  * Description:
3893  *   Interrupt handler for sequencer interrupts (SEQINT).
3894  *-F*************************************************************************/
3895 static void
3896 aic7xxx_handle_device_reset(struct aic7xxx_host *p, int target, int channel)
3897 {
3898   unsigned char tindex = target;
3899
3900   tindex |= ((channel & 0x01) << 3);
3901
3902   /*
3903    * Go back to async/narrow transfers and renegotiate.
3904    */
3905   aic_outb(p, 0, TARG_SCSIRATE + tindex);
3906   if (p->features & AHC_ULTRA2)
3907     aic_outb(p, 0, TARG_OFFSET + tindex);
3908   aic7xxx_reset_device(p, target, channel, ALL_LUNS, SCB_LIST_NULL);
3909   if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3910     printk(INFO_LEAD "Bus Device Reset delivered.\n", p->host_no, channel,
3911       target, -1);
3912   aic7xxx_run_done_queue(p, /*complete*/ TRUE);
3913 }
3914
3915 /*+F*************************************************************************
3916  * Function:
3917  *   aic7xxx_handle_seqint
3918  *
3919  * Description:
3920  *   Interrupt handler for sequencer interrupts (SEQINT).
3921  *-F*************************************************************************/
3922 static void
3923 aic7xxx_handle_seqint(struct aic7xxx_host *p, unsigned char intstat)
3924 {
3925   struct aic7xxx_scb *scb;
3926   struct aic_dev_data *aic_dev;
3927   unsigned short target_mask;
3928   unsigned char target, lun, tindex;
3929   unsigned char queue_flag = FALSE;
3930   char channel;
3931   int result;
3932
3933   target = ((aic_inb(p, SAVED_TCL) >> 4) & 0x0f);
3934   if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
3935     channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3;
3936   else
3937     channel = 0;
3938   tindex = target + (channel << 3);
3939   lun = aic_inb(p, SAVED_TCL) & 0x07;
3940   target_mask = (0x01 << tindex);
3941
3942   /*
3943    * Go ahead and clear the SEQINT now, that avoids any interrupt race
3944    * conditions later on in case we enable some other interrupt.
3945    */
3946   aic_outb(p, CLRSEQINT, CLRINT);
3947   switch (intstat & SEQINT_MASK)
3948   {
3949     case NO_MATCH:
3950       {
3951         aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP),
3952                  SCSISEQ);
3953         printk(WARN_LEAD "No active SCB for reconnecting target - Issuing "
3954                "BUS DEVICE RESET.\n", p->host_no, channel, target, lun);
3955         printk(WARN_LEAD "      SAVED_TCL=0x%x, ARG_1=0x%x, SEQADDR=0x%x\n",
3956                p->host_no, channel, target, lun,
3957                aic_inb(p, SAVED_TCL), aic_inb(p, ARG_1),
3958                (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0));
3959         if (aic7xxx_panic_on_abort)
3960           aic7xxx_panic_abort(p, NULL);
3961       }
3962       break;
3963
3964     case SEND_REJECT:
3965       {
3966         if (aic7xxx_verbose & VERBOSE_MINOR_ERROR)
3967           printk(INFO_LEAD "Rejecting unknown message (0x%x) received from "
3968             "target, SEQ_FLAGS=0x%x\n", p->host_no, channel, target, lun,
3969             aic_inb(p, ACCUM), aic_inb(p, SEQ_FLAGS));
3970       }
3971       break;
3972
3973     case NO_IDENT:
3974       {
3975         /*
3976          * The reconnecting target either did not send an identify
3977          * message, or did, but we didn't find an SCB to match and
3978          * before it could respond to our ATN/abort, it hit a dataphase.
3979          * The only safe thing to do is to blow it away with a bus
3980          * reset.
3981          */
3982         if (aic7xxx_verbose & (VERBOSE_SEQINT | VERBOSE_RESET_MID))
3983           printk(INFO_LEAD "Target did not send an IDENTIFY message; "
3984             "LASTPHASE 0x%x, SAVED_TCL 0x%x\n", p->host_no, channel, target,
3985             lun, aic_inb(p, LASTPHASE), aic_inb(p, SAVED_TCL));
3986
3987         aic7xxx_reset_channel(p, channel, /*initiate reset*/ TRUE);
3988         aic7xxx_run_done_queue(p, TRUE);
3989
3990       }
3991       break;
3992
3993     case BAD_PHASE:
3994       if (aic_inb(p, LASTPHASE) == P_BUSFREE)
3995       {
3996         if (aic7xxx_verbose & VERBOSE_SEQINT)
3997           printk(INFO_LEAD "Missed busfree.\n", p->host_no, channel,
3998             target, lun);
3999         restart_sequencer(p);
4000       }
4001       else
4002       {
4003         if (aic7xxx_verbose & VERBOSE_SEQINT)
4004           printk(INFO_LEAD "Unknown scsi bus phase, continuing\n", p->host_no,
4005             channel, target, lun);
4006       }
4007       break;
4008
4009     case EXTENDED_MSG:
4010       {
4011         p->msg_type = MSG_TYPE_INITIATOR_MSGIN;
4012         p->msg_len = 0;
4013         p->msg_index = 0;
4014
4015 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4016         if (aic7xxx_verbose > 0xffff)
4017           printk(INFO_LEAD "Enabling REQINITs for MSG_IN\n", p->host_no,
4018                  channel, target, lun);
4019 #endif
4020
4021        /*      
4022         * To actually receive the message, simply turn on
4023         * REQINIT interrupts and let our interrupt handler
4024         * do the rest (REQINIT should already be true).
4025         */
4026         p->flags |= AHC_HANDLING_REQINITS;
4027         aic_outb(p, aic_inb(p, SIMODE1) | ENREQINIT, SIMODE1);
4028
4029        /*
4030         * We don't want the sequencer unpaused yet so we return early
4031         */
4032         return;
4033       }
4034
4035     case REJECT_MSG:
4036       {
4037         /*
4038          * What we care about here is if we had an outstanding SDTR
4039          * or WDTR message for this target. If we did, this is a
4040          * signal that the target is refusing negotiation.
4041          */
4042         unsigned char scb_index;
4043         unsigned char last_msg;
4044
4045         scb_index = aic_inb(p, SCB_TAG);
4046         scb = p->scb_data->scb_array[scb_index];
4047         aic_dev = AIC_DEV(scb->cmd);
4048         last_msg = aic_inb(p, LAST_MSG);
4049
4050         if ( (last_msg == MSG_IDENTIFYFLAG) &&
4051              (scb->tag_action) &&
4052             !(scb->flags & SCB_MSGOUT_BITS) )
4053         {
4054           if (scb->tag_action == MSG_ORDERED_Q_TAG)
4055           {
4056             /*
4057              * OK...the device seems able to accept tagged commands, but
4058              * not ordered tag commands, only simple tag commands.  So, we
4059              * disable ordered tag commands and go on with life just like
4060              * normal.
4061              */
4062             scsi_adjust_queue_depth(scb->cmd->device, MSG_SIMPLE_TAG,
4063                             scb->cmd->device->queue_depth);
4064             scb->tag_action = MSG_SIMPLE_Q_TAG;
4065             scb->hscb->control &= ~SCB_TAG_TYPE;
4066             scb->hscb->control |= MSG_SIMPLE_Q_TAG;
4067             aic_outb(p, scb->hscb->control, SCB_CONTROL);
4068             /*
4069              * OK..we set the tag type to simple tag command, now we re-assert
4070              * ATNO and hope this will take us into the identify phase again
4071              * so we can resend the tag type and info to the device.
4072              */
4073             aic_outb(p, MSG_IDENTIFYFLAG, MSG_OUT);
4074             aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
4075           }
4076           else if (scb->tag_action == MSG_SIMPLE_Q_TAG)
4077           {
4078             unsigned char i;
4079             struct aic7xxx_scb *scbp;
4080             int old_verbose;
4081             /*
4082              * Hmmmm....the device is flaking out on tagged commands.
4083              */
4084             scsi_adjust_queue_depth(scb->cmd->device, 0 /* untagged */,
4085                             p->host->cmd_per_lun);
4086             aic_dev->max_q_depth = aic_dev->temp_q_depth = 1;
4087             /*
4088              * We set this command up as a bus device reset.  However, we have
4089              * to clear the tag type as it's causing us problems.  We shouldnt
4090              * have to worry about any other commands being active, since if
4091              * the device is refusing tagged commands, this should be the
4092              * first tagged command sent to the device, however, we do have
4093              * to worry about any other tagged commands that may already be
4094              * in the qinfifo.  The easiest way to do this, is to issue a BDR,
4095              * send all the commands back to the mid level code, then let them
4096              * come back and get rebuilt as untagged commands.
4097              */
4098             scb->tag_action = 0;
4099             scb->hscb->control &= ~(TAG_ENB | SCB_TAG_TYPE);
4100             aic_outb(p,  scb->hscb->control, SCB_CONTROL);
4101
4102             old_verbose = aic7xxx_verbose;
4103             aic7xxx_verbose &= ~(VERBOSE_RESET|VERBOSE_ABORT);
4104             for (i=0; i < p->scb_data->numscbs; i++)
4105             {
4106               scbp = p->scb_data->scb_array[i];
4107               if ((scbp->flags & SCB_ACTIVE) && (scbp != scb))
4108               {
4109                 if (aic7xxx_match_scb(p, scbp, target, channel, lun, i))
4110                 {
4111                   aic7xxx_reset_device(p, target, channel, lun, i);
4112                 }
4113               }
4114             }
4115             aic7xxx_run_done_queue(p, TRUE);
4116             aic7xxx_verbose = old_verbose;
4117             /*
4118              * Wait until after the for loop to set the busy index since
4119              * aic7xxx_reset_device will clear the busy index during its
4120              * operation.
4121              */
4122             aic7xxx_busy_target(p, scb);
4123             printk(INFO_LEAD "Device is refusing tagged commands, using "
4124               "untagged I/O.\n", p->host_no, channel, target, lun);
4125             aic_outb(p, MSG_IDENTIFYFLAG, MSG_OUT);
4126             aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
4127           }
4128         }
4129         else if (scb->flags & SCB_MSGOUT_PPR)
4130         {
4131           /*
4132            * As per the draft specs, any device capable of supporting any of
4133            * the option values other than 0 are not allowed to reject the
4134            * PPR message.  Instead, they must negotiate out what they do
4135            * support instead of rejecting our offering or else they cause
4136            * a parity error during msg_out phase to signal that they don't
4137            * like our settings.
4138            */
4139           aic_dev->needppr = aic_dev->needppr_copy = 0;
4140           aic7xxx_set_width(p, target, channel, lun, MSG_EXT_WDTR_BUS_8_BIT,
4141             (AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE), aic_dev);
4142           aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
4143                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
4144                                aic_dev);
4145           aic_dev->goal.options = aic_dev->dtr_pending = 0;
4146           scb->flags &= ~SCB_MSGOUT_BITS;
4147           if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4148           {
4149             printk(INFO_LEAD "Device is rejecting PPR messages, falling "
4150               "back.\n", p->host_no, channel, target, lun);
4151           }
4152           if ( aic_dev->goal.width )
4153           {
4154             aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
4155             aic_dev->dtr_pending = 1;
4156             scb->flags |= SCB_MSGOUT_WDTR;
4157           }
4158           if ( aic_dev->goal.offset )
4159           {
4160             aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
4161             if( !aic_dev->dtr_pending )
4162             {
4163               aic_dev->dtr_pending = 1;
4164               scb->flags |= SCB_MSGOUT_SDTR;
4165             }
4166           }
4167           if ( aic_dev->dtr_pending )
4168           {
4169             aic_outb(p, HOST_MSG, MSG_OUT);
4170             aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
4171           }
4172         }
4173         else if (scb->flags & SCB_MSGOUT_WDTR)
4174         {
4175           /*
4176            * note 8bit xfers and clear flag
4177            */
4178           aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
4179           scb->flags &= ~SCB_MSGOUT_BITS;
4180           aic7xxx_set_width(p, target, channel, lun, MSG_EXT_WDTR_BUS_8_BIT,
4181             (AHC_TRANS_ACTIVE|AHC_TRANS_GOAL|AHC_TRANS_CUR), aic_dev);
4182           aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
4183                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
4184                                aic_dev);
4185           if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4186           {
4187             printk(INFO_LEAD "Device is rejecting WDTR messages, using "
4188               "narrow transfers.\n", p->host_no, channel, target, lun);
4189           }
4190           aic_dev->needsdtr = aic_dev->needsdtr_copy;
4191         }
4192         else if (scb->flags & SCB_MSGOUT_SDTR)
4193         {
4194          /*
4195           * note asynch xfers and clear flag
4196           */
4197           aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
4198           scb->flags &= ~SCB_MSGOUT_BITS;
4199           aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
4200             (AHC_TRANS_CUR|AHC_TRANS_ACTIVE|AHC_TRANS_GOAL), aic_dev);
4201           if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4202           {
4203             printk(INFO_LEAD "Device is rejecting SDTR messages, using "
4204               "async transfers.\n", p->host_no, channel, target, lun);
4205           }
4206         }
4207         else if (aic7xxx_verbose & VERBOSE_SEQINT)
4208         {
4209           /*
4210            * Otherwise, we ignore it.
4211            */
4212           printk(INFO_LEAD "Received MESSAGE_REJECT for unknown cause.  "
4213             "Ignoring.\n", p->host_no, channel, target, lun);
4214         }
4215       }
4216       break;
4217
4218     case BAD_STATUS:
4219       {
4220         unsigned char scb_index;
4221         struct aic7xxx_hwscb *hscb;
4222         struct scsi_cmnd *cmd;
4223
4224         /* The sequencer will notify us when a command has an error that
4225          * would be of interest to the kernel.  This allows us to leave
4226          * the sequencer running in the common case of command completes
4227          * without error.  The sequencer will have DMA'd the SCB back
4228          * up to us, so we can reference the drivers SCB array.
4229          *
4230          * Set the default return value to 0 indicating not to send
4231          * sense.  The sense code will change this if needed and this
4232          * reduces code duplication.
4233          */
4234         aic_outb(p, 0, RETURN_1);
4235         scb_index = aic_inb(p, SCB_TAG);
4236         if (scb_index > p->scb_data->numscbs)
4237         {
4238           printk(WARN_LEAD "Invalid SCB during SEQINT 0x%02x, SCB_TAG %d.\n",
4239             p->host_no, channel, target, lun, intstat, scb_index);
4240           break;
4241         }
4242         scb = p->scb_data->scb_array[scb_index];
4243         hscb = scb->hscb;
4244
4245         if (!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
4246         {
4247           printk(WARN_LEAD "Invalid SCB during SEQINT 0x%x, scb %d, flags 0x%x,"
4248             " cmd 0x%lx.\n", p->host_no, channel, target, lun, intstat,
4249             scb_index, scb->flags, (unsigned long) scb->cmd);
4250         }
4251         else
4252         {
4253           cmd = scb->cmd;
4254           aic_dev = AIC_DEV(scb->cmd);
4255           hscb->target_status = aic_inb(p, SCB_TARGET_STATUS);
4256           aic7xxx_status(cmd) = hscb->target_status;
4257
4258           cmd->result = hscb->target_status;
4259
4260           switch (status_byte(hscb->target_status))
4261           {
4262             case GOOD:
4263               if (aic7xxx_verbose & VERBOSE_SEQINT)
4264                 printk(INFO_LEAD "Interrupted for status of GOOD???\n",
4265                   p->host_no, CTL_OF_SCB(scb));
4266               break;
4267
4268             case COMMAND_TERMINATED:
4269             case CHECK_CONDITION:
4270               if ( !(scb->flags & SCB_SENSE) )
4271               {
4272                 /*
4273                  * Send a sense command to the requesting target.
4274                  * XXX - revisit this and get rid of the memcopys.
4275                  */
4276                 memcpy(scb->sense_cmd, &generic_sense[0],
4277                        sizeof(generic_sense));
4278
4279                 scb->sense_cmd[1] = (cmd->device->lun << 5);
4280                 scb->sense_cmd[4] = sizeof(cmd->sense_buffer);
4281
4282                 scb->sg_list[0].length = 
4283                   cpu_to_le32(sizeof(cmd->sense_buffer));
4284                 scb->sg_list[0].address =
4285                         cpu_to_le32(pci_map_single(p->pdev, cmd->sense_buffer,
4286                                                    sizeof(cmd->sense_buffer),
4287                                                    PCI_DMA_FROMDEVICE));
4288
4289                 /*
4290                  * XXX - We should allow disconnection, but can't as it
4291                  * might allow overlapped tagged commands.
4292                  */
4293                 /* hscb->control &= DISCENB; */
4294                 hscb->control = 0;
4295                 hscb->target_status = 0;
4296                 hscb->SG_list_pointer = 
4297                   cpu_to_le32(SCB_DMA_ADDR(scb, scb->sg_list));
4298                 hscb->SCSI_cmd_pointer = 
4299                   cpu_to_le32(SCB_DMA_ADDR(scb, scb->sense_cmd));
4300                 hscb->data_count = scb->sg_list[0].length;
4301                 hscb->data_pointer = scb->sg_list[0].address;
4302                 hscb->SCSI_cmd_length = COMMAND_SIZE(scb->sense_cmd[0]);
4303                 hscb->residual_SG_segment_count = 0;
4304                 hscb->residual_data_count[0] = 0;
4305                 hscb->residual_data_count[1] = 0;
4306                 hscb->residual_data_count[2] = 0;
4307
4308                 scb->sg_count = hscb->SG_segment_count = 1;
4309                 scb->sg_length = sizeof(cmd->sense_buffer);
4310                 scb->tag_action = 0;
4311                 scb->flags |= SCB_SENSE;
4312                 /*
4313                  * Ensure the target is busy since this will be an
4314                  * an untagged request.
4315                  */
4316 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4317                 if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4318                 {
4319                   if (scb->flags & SCB_MSGOUT_BITS)
4320                     printk(INFO_LEAD "Requesting SENSE with %s\n", p->host_no,
4321                            CTL_OF_SCB(scb), (scb->flags & SCB_MSGOUT_SDTR) ?
4322                            "SDTR" : "WDTR");
4323                   else
4324                     printk(INFO_LEAD "Requesting SENSE, no MSG\n", p->host_no,
4325                            CTL_OF_SCB(scb));
4326                 }
4327 #endif
4328                 aic7xxx_busy_target(p, scb);
4329                 aic_outb(p, SEND_SENSE, RETURN_1);
4330                 aic7xxx_error(cmd) = DID_OK;
4331                 break;
4332               }  /* first time sense, no errors */
4333               printk(INFO_LEAD "CHECK_CONDITION on REQUEST_SENSE, returning "
4334                      "an error.\n", p->host_no, CTL_OF_SCB(scb));
4335               aic7xxx_error(cmd) = DID_ERROR;
4336               scb->flags &= ~SCB_SENSE;
4337               break;
4338
4339             case QUEUE_FULL:
4340               queue_flag = TRUE;    /* Mark that this is a QUEUE_FULL and */
4341             case BUSY:              /* drop through to here */
4342             {
4343               struct aic7xxx_scb *next_scbp, *prev_scbp;
4344               unsigned char active_hscb, next_hscb, prev_hscb, scb_index;
4345               /*
4346                * We have to look three places for queued commands:
4347                *  1: p->waiting_scbs queue
4348                *  2: QINFIFO
4349                *  3: WAITING_SCBS list on card (for commands that are started
4350                *     but haven't yet made it to the device)
4351                *
4352                * Of special note here is that commands on 2 or 3 above will
4353                * have already been marked as active, while commands on 1 will
4354                * not.  The aic7xxx_done() function will want to unmark them
4355                * from active, so any commands we pull off of 1 need to
4356                * up the active count.
4357                */
4358               next_scbp = p->waiting_scbs.head;
4359               while ( next_scbp != NULL )
4360               {
4361                 prev_scbp = next_scbp;
4362                 next_scbp = next_scbp->q_next;
4363                 if ( aic7xxx_match_scb(p, prev_scbp, target, channel, lun,
4364                      SCB_LIST_NULL) )
4365                 {
4366                   scbq_remove(&p->waiting_scbs, prev_scbp);
4367                   scb->flags = SCB_QUEUED_FOR_DONE | SCB_QUEUE_FULL;
4368                   p->activescbs++;
4369                   aic_dev->active_cmds++;
4370                 }
4371               }
4372               aic7xxx_search_qinfifo(p, target, channel, lun,
4373                 SCB_LIST_NULL, SCB_QUEUED_FOR_DONE | SCB_QUEUE_FULL,
4374                 FALSE, NULL);
4375               next_scbp = NULL;
4376               active_hscb = aic_inb(p, SCBPTR);
4377               prev_hscb = next_hscb = scb_index = SCB_LIST_NULL;
4378               next_hscb = aic_inb(p, WAITING_SCBH);
4379               while (next_hscb != SCB_LIST_NULL)
4380               {
4381                 aic_outb(p, next_hscb, SCBPTR);
4382                 scb_index = aic_inb(p, SCB_TAG);
4383                 if (scb_index < p->scb_data->numscbs)
4384                 {
4385                   next_scbp = p->scb_data->scb_array[scb_index];
4386                   if (aic7xxx_match_scb(p, next_scbp, target, channel, lun,
4387                       SCB_LIST_NULL) )
4388                   {
4389                     next_scbp->flags = SCB_QUEUED_FOR_DONE | SCB_QUEUE_FULL;
4390                     next_hscb = aic_inb(p, SCB_NEXT);
4391                     aic_outb(p, 0, SCB_CONTROL);
4392                     aic_outb(p, SCB_LIST_NULL, SCB_TAG);
4393                     aic7xxx_add_curscb_to_free_list(p);
4394                     if (prev_hscb == SCB_LIST_NULL)
4395                     {
4396                       /* We were first on the list,
4397                        * so we kill the selection
4398                        * hardware.  Let the sequencer
4399                        * re-init the hardware itself
4400                        */
4401                       aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ);
4402                       aic_outb(p, CLRSELTIMEO, CLRSINT1);
4403                       aic_outb(p, next_hscb, WAITING_SCBH);
4404                     }
4405                     else
4406                     {
4407                       aic_outb(p, prev_hscb, SCBPTR);
4408                       aic_outb(p, next_hscb, SCB_NEXT);
4409                     }
4410                   }
4411                   else
4412                   {
4413                     prev_hscb = next_hscb;
4414                     next_hscb = aic_inb(p, SCB_NEXT);
4415                   }
4416                 } /* scb_index >= p->scb_data->numscbs */
4417               }
4418               aic_outb(p, active_hscb, SCBPTR);
4419               aic7xxx_run_done_queue(p, FALSE);
4420                   
4421 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4422               if( (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ||
4423                   (aic7xxx_verbose > 0xffff) )
4424               {
4425                 if (queue_flag)
4426                   printk(INFO_LEAD "Queue full received; queue depth %d, "
4427                     "active %d\n", p->host_no, CTL_OF_SCB(scb),
4428                     aic_dev->max_q_depth, aic_dev->active_cmds);
4429                 else
4430                   printk(INFO_LEAD "Target busy\n", p->host_no, CTL_OF_SCB(scb));
4431               }
4432 #endif
4433               if (queue_flag)
4434               {
4435                 int diff;
4436                 result = scsi_track_queue_full(cmd->device,
4437                                 aic_dev->active_cmds);
4438                 if ( result < 0 )
4439                 {
4440                   if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4441                     printk(INFO_LEAD "Tagged Command Queueing disabled.\n",
4442                         p->host_no, CTL_OF_SCB(scb));
4443                   diff = aic_dev->max_q_depth - p->host->cmd_per_lun;
4444                   aic_dev->temp_q_depth = 1;
4445                   aic_dev->max_q_depth = 1;
4446                 }
4447                 else if ( result > 0 )
4448                 {
4449                   if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4450                     printk(INFO_LEAD "Queue depth reduced to %d\n", p->host_no,
4451                       CTL_OF_SCB(scb), result);
4452                   diff = aic_dev->max_q_depth - result;
4453                   aic_dev->max_q_depth = result;
4454                   /* temp_q_depth could have been dropped to 1 for an untagged
4455                    * command that might be coming up */
4456                   if(aic_dev->temp_q_depth > result)
4457                     aic_dev->temp_q_depth = result;
4458                 }
4459                 /* We should free up the no unused SCB entries.  But, that's
4460                  * a difficult thing to do because we use a direct indexed
4461                  * array, so we can't just take any entries and free them,
4462                  * we *have* to free the ones at the end of the array, and
4463                  * they very well could be in use right now, which means
4464                  * in order to do this right, we have to add a delayed
4465                  * freeing mechanism tied into the scb_free() code area.
4466                  * We'll add that later.
4467                  */
4468               }
4469               break;
4470             }
4471             
4472             default:
4473               if (aic7xxx_verbose & VERBOSE_SEQINT)
4474                 printk(INFO_LEAD "Unexpected target status 0x%x.\n", p->host_no,
4475                      CTL_OF_SCB(scb), scb->hscb->target_status);
4476               if (!aic7xxx_error(cmd))
4477               {
4478                 aic7xxx_error(cmd) = DID_RETRY_COMMAND;
4479               }
4480               break;
4481           }  /* end switch */
4482         }  /* end else of */
4483       }
4484       break;
4485
4486     case AWAITING_MSG:
4487       {
4488         unsigned char scb_index, msg_out;
4489
4490         scb_index = aic_inb(p, SCB_TAG);
4491         msg_out = aic_inb(p, MSG_OUT);
4492         scb = p->scb_data->scb_array[scb_index];
4493         aic_dev = AIC_DEV(scb->cmd);
4494         p->msg_index = p->msg_len = 0;
4495         /*
4496          * This SCB had a MK_MESSAGE set in its control byte informing
4497          * the sequencer that we wanted to send a special message to
4498          * this target.
4499          */
4500
4501         if ( !(scb->flags & SCB_DEVICE_RESET) &&
4502               (msg_out == MSG_IDENTIFYFLAG) &&
4503               (scb->hscb->control & TAG_ENB) )
4504         {
4505           p->msg_buf[p->msg_index++] = scb->tag_action;
4506           p->msg_buf[p->msg_index++] = scb->hscb->tag;
4507           p->msg_len += 2;
4508         }
4509
4510         if (scb->flags & SCB_DEVICE_RESET)
4511         {
4512           p->msg_buf[p->msg_index++] = MSG_BUS_DEV_RESET;
4513           p->msg_len++;
4514           if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
4515             printk(INFO_LEAD "Bus device reset mailed.\n",
4516                  p->host_no, CTL_OF_SCB(scb));
4517         }
4518         else if (scb->flags & SCB_ABORT)
4519         {
4520           if (scb->tag_action)
4521           {
4522             p->msg_buf[p->msg_index++] = MSG_ABORT_TAG;
4523           }
4524           else
4525           {
4526             p->msg_buf[p->msg_index++] = MSG_ABORT;
4527           }
4528           p->msg_len++;
4529           if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)
4530             printk(INFO_LEAD "Abort message mailed.\n", p->host_no,
4531               CTL_OF_SCB(scb));
4532         }
4533         else if (scb->flags & SCB_MSGOUT_PPR)
4534         {
4535           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4536           {
4537             printk(INFO_LEAD "Sending PPR (%d/%d/%d/%d) message.\n",
4538                    p->host_no, CTL_OF_SCB(scb),
4539                    aic_dev->goal.period,
4540                    aic_dev->goal.offset,
4541                    aic_dev->goal.width,
4542                    aic_dev->goal.options);
4543           }
4544           aic7xxx_construct_ppr(p, scb);
4545         }
4546         else if (scb->flags & SCB_MSGOUT_WDTR)
4547         {
4548           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4549           {
4550             printk(INFO_LEAD "Sending WDTR message.\n", p->host_no,
4551                    CTL_OF_SCB(scb));
4552           }
4553           aic7xxx_construct_wdtr(p, aic_dev->goal.width);
4554         }
4555         else if (scb->flags & SCB_MSGOUT_SDTR)
4556         {
4557           unsigned int max_sync, period;
4558           unsigned char options = 0;
4559           /*
4560            * Now that the device is selected, use the bits in SBLKCTL and
4561            * SSTAT2 to determine the max sync rate for this device.
4562            */
4563           if (p->features & AHC_ULTRA2)
4564           {
4565             if ( (aic_inb(p, SBLKCTL) & ENAB40) &&
4566                 !(aic_inb(p, SSTAT2) & EXP_ACTIVE) )
4567             {
4568               max_sync = AHC_SYNCRATE_ULTRA2;
4569             }
4570             else
4571             {
4572               max_sync = AHC_SYNCRATE_ULTRA;
4573             }
4574           }
4575           else if (p->features & AHC_ULTRA)
4576           {
4577             max_sync = AHC_SYNCRATE_ULTRA;
4578           }
4579           else
4580           {
4581             max_sync = AHC_SYNCRATE_FAST;
4582           }
4583           period = aic_dev->goal.period;
4584           aic7xxx_find_syncrate(p, &period, max_sync, &options);
4585           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4586           {
4587             printk(INFO_LEAD "Sending SDTR %d/%d message.\n", p->host_no,
4588                    CTL_OF_SCB(scb), period,
4589                    aic_dev->goal.offset);
4590           }
4591           aic7xxx_construct_sdtr(p, period, aic_dev->goal.offset);
4592         }
4593         else 
4594         {
4595           panic("aic7xxx: AWAITING_MSG for an SCB that does "
4596                 "not have a waiting message.\n");
4597         }
4598         /*
4599          * We've set everything up to send our message, now to actually do
4600          * so we need to enable reqinit interrupts and let the interrupt
4601          * handler do the rest.  We don't want to unpause the sequencer yet
4602          * though so we'll return early.  We also have to make sure that
4603          * we clear the SEQINT *BEFORE* we set the REQINIT handler active
4604          * or else it's possible on VLB cards to lose the first REQINIT
4605          * interrupt.  Edge triggered EISA cards could also lose this
4606          * interrupt, although PCI and level triggered cards should not
4607          * have this problem since they continually interrupt the kernel
4608          * until we take care of the situation.
4609          */
4610         scb->flags |= SCB_MSGOUT_SENT;
4611         p->msg_index = 0;
4612         p->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
4613         p->flags |= AHC_HANDLING_REQINITS;
4614         aic_outb(p, aic_inb(p, SIMODE1) | ENREQINIT, SIMODE1);
4615         return;
4616       }
4617       break;
4618
4619     case DATA_OVERRUN:
4620       {
4621         unsigned char scb_index = aic_inb(p, SCB_TAG);
4622         unsigned char lastphase = aic_inb(p, LASTPHASE);
4623         unsigned int i;
4624
4625         scb = (p->scb_data->scb_array[scb_index]);
4626         /*
4627          * XXX - What do we really want to do on an overrun?  The
4628          *       mid-level SCSI code should handle this, but for now,
4629          *       we'll just indicate that the command should retried.
4630          *    If we retrieved sense info on this target, then the 
4631          *    base SENSE info should have been saved prior to the
4632          *    overrun error.  In that case, we return DID_OK and let
4633          *    the mid level code pick up on the sense info.  Otherwise
4634          *    we return DID_ERROR so the command will get retried.
4635          */
4636         if ( !(scb->flags & SCB_SENSE) )
4637         {
4638           printk(WARN_LEAD "Data overrun detected in %s phase, tag %d;\n",
4639             p->host_no, CTL_OF_SCB(scb), 
4640             (lastphase == P_DATAIN) ? "Data-In" : "Data-Out", scb->hscb->tag);
4641           printk(KERN_WARNING "  %s seen Data Phase. Length=%d, NumSGs=%d.\n",
4642             (aic_inb(p, SEQ_FLAGS) & DPHASE) ? "Have" : "Haven't",
4643             scb->sg_length, scb->sg_count);
4644           printk(KERN_WARNING "  Raw SCSI Command: 0x");
4645           for (i = 0; i < scb->hscb->SCSI_cmd_length; i++)
4646           {
4647             printk("%02x ", scb->cmd->cmnd[i]);
4648           }
4649           printk("\n");
4650           if(aic7xxx_verbose > 0xffff)
4651           {
4652             for (i = 0; i < scb->sg_count; i++)
4653             {
4654               printk(KERN_WARNING "     sg[%d] - Addr 0x%x : Length %d\n",
4655                  i, 
4656                  le32_to_cpu(scb->sg_list[i].address),
4657                  le32_to_cpu(scb->sg_list[i].length) );
4658             }
4659           }
4660           aic7xxx_error(scb->cmd) = DID_ERROR;
4661         }
4662         else
4663           printk(INFO_LEAD "Data Overrun during SEND_SENSE operation.\n",
4664             p->host_no, CTL_OF_SCB(scb));
4665       }
4666       break;
4667
4668     case WIDE_RESIDUE:
4669       {
4670         unsigned char resid_sgcnt, index;
4671         unsigned char scb_index = aic_inb(p, SCB_TAG);
4672         unsigned int cur_addr, resid_dcnt;
4673         unsigned int native_addr, native_length, sg_addr;
4674         int i;
4675
4676         if(scb_index > p->scb_data->numscbs)
4677         {
4678           printk(WARN_LEAD "invalid scb_index during WIDE_RESIDUE.\n",
4679             p->host_no, -1, -1, -1);
4680           /*
4681            * XXX: Add error handling here
4682            */
4683           break;
4684         }
4685         scb = p->scb_data->scb_array[scb_index];
4686         if(!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
4687         {
4688           printk(WARN_LEAD "invalid scb during WIDE_RESIDUE flags:0x%x "
4689                  "scb->cmd:0x%lx\n", p->host_no, CTL_OF_SCB(scb),
4690                  scb->flags, (unsigned long)scb->cmd);
4691           break;
4692         }
4693         if(aic7xxx_verbose & VERBOSE_MINOR_ERROR)
4694           printk(INFO_LEAD "Got WIDE_RESIDUE message, patching up data "
4695                  "pointer.\n", p->host_no, CTL_OF_SCB(scb));
4696
4697         /*
4698          * We have a valid scb to use on this WIDE_RESIDUE message, so
4699          * we need to walk the sg list looking for this particular sg
4700          * segment, then see if we happen to be at the very beginning of
4701          * the segment.  If we are, then we have to back things up to
4702          * the previous segment.  If not, then we simply need to remove
4703          * one byte from this segments address and add one to the byte
4704          * count.
4705          */
4706         cur_addr = aic_inb(p, SHADDR) | (aic_inb(p, SHADDR + 1) << 8) |
4707           (aic_inb(p, SHADDR + 2) << 16) | (aic_inb(p, SHADDR + 3) << 24);
4708         sg_addr = aic_inb(p, SG_COUNT + 1) | (aic_inb(p, SG_COUNT + 2) << 8) |
4709           (aic_inb(p, SG_COUNT + 3) << 16) | (aic_inb(p, SG_COUNT + 4) << 24);
4710         resid_sgcnt = aic_inb(p, SCB_RESID_SGCNT);
4711         resid_dcnt = aic_inb(p, SCB_RESID_DCNT) |
4712           (aic_inb(p, SCB_RESID_DCNT + 1) << 8) |
4713           (aic_inb(p, SCB_RESID_DCNT + 2) << 16);
4714         index = scb->sg_count - ((resid_sgcnt) ? resid_sgcnt : 1);
4715         native_addr = le32_to_cpu(scb->sg_list[index].address);
4716         native_length = le32_to_cpu(scb->sg_list[index].length);
4717         /*
4718          * If resid_dcnt == native_length, then we just loaded this SG
4719          * segment and we need to back it up one...
4720          */
4721         if(resid_dcnt == native_length)
4722         {
4723           if(index == 0)
4724           {
4725             /*
4726              * Oops, this isn't right, we can't back up to before the
4727              * beginning.  This must be a bogus message, ignore it.
4728              */
4729             break;
4730           }
4731           resid_dcnt = 1;
4732           resid_sgcnt += 1;
4733           native_addr = le32_to_cpu(scb->sg_list[index - 1].address);
4734           native_length = le32_to_cpu(scb->sg_list[index - 1].length);
4735           cur_addr = native_addr + (native_length - 1);
4736           sg_addr -= sizeof(struct hw_scatterlist);
4737         }
4738         else
4739         {
4740           /*
4741            * resid_dcnt != native_length, so we are in the middle of a SG
4742            * element.  Back it up one byte and leave the rest alone.
4743            */
4744           resid_dcnt += 1;
4745           cur_addr -= 1;
4746         }
4747         
4748         /*
4749          * Output the new addresses and counts to the right places on the
4750          * card.
4751          */
4752         aic_outb(p, resid_sgcnt, SG_COUNT);
4753         aic_outb(p, resid_sgcnt, SCB_RESID_SGCNT);
4754         aic_outb(p, sg_addr & 0xff, SG_COUNT + 1);
4755         aic_outb(p, (sg_addr >> 8) & 0xff, SG_COUNT + 2);
4756         aic_outb(p, (sg_addr >> 16) & 0xff, SG_COUNT + 3);
4757         aic_outb(p, (sg_addr >> 24) & 0xff, SG_COUNT + 4);
4758         aic_outb(p, resid_dcnt & 0xff, SCB_RESID_DCNT);
4759         aic_outb(p, (resid_dcnt >> 8) & 0xff, SCB_RESID_DCNT + 1);
4760         aic_outb(p, (resid_dcnt >> 16) & 0xff, SCB_RESID_DCNT + 2);
4761
4762         /*
4763          * The sequencer actually wants to find the new address
4764          * in the SHADDR register set.  On the Ultra2 and later controllers
4765          * this register set is readonly.  In order to get the right number
4766          * into the register, you actually have to enter it in HADDR and then
4767          * use the PRELOADEN bit of DFCNTRL to drop it through from the
4768          * HADDR register to the SHADDR register.  On non-Ultra2 controllers,
4769          * we simply write it direct.
4770          */
4771         if(p->features & AHC_ULTRA2)
4772         {
4773           /*
4774            * We might as well be accurate and drop both the resid_dcnt and
4775            * cur_addr into HCNT and HADDR and have both of them drop
4776            * through to the shadow layer together.
4777            */
4778           aic_outb(p, resid_dcnt & 0xff, HCNT);
4779           aic_outb(p, (resid_dcnt >> 8) & 0xff, HCNT + 1);
4780           aic_outb(p, (resid_dcnt >> 16) & 0xff, HCNT + 2);
4781           aic_outb(p, cur_addr & 0xff, HADDR);
4782           aic_outb(p, (cur_addr >> 8) & 0xff, HADDR + 1);
4783           aic_outb(p, (cur_addr >> 16) & 0xff, HADDR + 2);
4784           aic_outb(p, (cur_addr >> 24) & 0xff, HADDR + 3);
4785           aic_outb(p, aic_inb(p, DMAPARAMS) | PRELOADEN, DFCNTRL);
4786           udelay(1);
4787           aic_outb(p, aic_inb(p, DMAPARAMS) & ~(SCSIEN|HDMAEN), DFCNTRL);
4788           i=0;
4789           while(((aic_inb(p, DFCNTRL) & (SCSIEN|HDMAEN)) != 0) && (i++ < 1000))
4790           {
4791             udelay(1);
4792           }
4793         }
4794         else
4795         {
4796           aic_outb(p, cur_addr & 0xff, SHADDR);
4797           aic_outb(p, (cur_addr >> 8) & 0xff, SHADDR + 1);
4798           aic_outb(p, (cur_addr >> 16) & 0xff, SHADDR + 2);
4799           aic_outb(p, (cur_addr >> 24) & 0xff, SHADDR + 3);
4800         }
4801       }
4802       break;
4803
4804     case SEQ_SG_FIXUP:
4805     {
4806       unsigned char scb_index, tmp;
4807       int sg_addr, sg_length;
4808
4809       scb_index = aic_inb(p, SCB_TAG);
4810
4811       if(scb_index > p->scb_data->numscbs)
4812       {
4813         printk(WARN_LEAD "invalid scb_index during SEQ_SG_FIXUP.\n",
4814           p->host_no, -1, -1, -1);
4815         printk(INFO_LEAD "SCSISIGI 0x%x, SEQADDR 0x%x, SSTAT0 0x%x, SSTAT1 "
4816            "0x%x\n", p->host_no, -1, -1, -1,
4817            aic_inb(p, SCSISIGI),
4818            aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
4819            aic_inb(p, SSTAT0), aic_inb(p, SSTAT1));
4820         printk(INFO_LEAD "SG_CACHEPTR 0x%x, SSTAT2 0x%x, STCNT 0x%x\n",
4821            p->host_no, -1, -1, -1, aic_inb(p, SG_CACHEPTR),
4822            aic_inb(p, SSTAT2), aic_inb(p, STCNT + 2) << 16 |
4823            aic_inb(p, STCNT + 1) << 8 | aic_inb(p, STCNT));
4824         /*
4825          * XXX: Add error handling here
4826          */
4827         break;
4828       }
4829       scb = p->scb_data->scb_array[scb_index];
4830       if(!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
4831       {
4832         printk(WARN_LEAD "invalid scb during SEQ_SG_FIXUP flags:0x%x "
4833                "scb->cmd:0x%p\n", p->host_no, CTL_OF_SCB(scb),
4834                scb->flags, scb->cmd);
4835         printk(INFO_LEAD "SCSISIGI 0x%x, SEQADDR 0x%x, SSTAT0 0x%x, SSTAT1 "
4836            "0x%x\n", p->host_no, CTL_OF_SCB(scb),
4837            aic_inb(p, SCSISIGI),
4838            aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
4839            aic_inb(p, SSTAT0), aic_inb(p, SSTAT1));
4840         printk(INFO_LEAD "SG_CACHEPTR 0x%x, SSTAT2 0x%x, STCNT 0x%x\n",
4841            p->host_no, CTL_OF_SCB(scb), aic_inb(p, SG_CACHEPTR),
4842            aic_inb(p, SSTAT2), aic_inb(p, STCNT + 2) << 16 |
4843            aic_inb(p, STCNT + 1) << 8 | aic_inb(p, STCNT));
4844         break;
4845       }
4846       if(aic7xxx_verbose & VERBOSE_MINOR_ERROR)
4847         printk(INFO_LEAD "Fixing up SG address for sequencer.\n", p->host_no,
4848                CTL_OF_SCB(scb));
4849       /*
4850        * Advance the SG pointer to the next element in the list
4851        */
4852       tmp = aic_inb(p, SG_NEXT);
4853       tmp += SG_SIZEOF;
4854       aic_outb(p, tmp, SG_NEXT);
4855       if( tmp < SG_SIZEOF )
4856         aic_outb(p, aic_inb(p, SG_NEXT + 1) + 1, SG_NEXT + 1);
4857       tmp = aic_inb(p, SG_COUNT) - 1;
4858       aic_outb(p, tmp, SG_COUNT);
4859       sg_addr = le32_to_cpu(scb->sg_list[scb->sg_count - tmp].address);
4860       sg_length = le32_to_cpu(scb->sg_list[scb->sg_count - tmp].length);
4861       /*
4862        * Now stuff the element we just advanced past down onto the
4863        * card so it can be stored in the residual area.
4864        */
4865       aic_outb(p, sg_addr & 0xff, HADDR);
4866       aic_outb(p, (sg_addr >> 8) & 0xff, HADDR + 1);
4867       aic_outb(p, (sg_addr >> 16) & 0xff, HADDR + 2);
4868       aic_outb(p, (sg_addr >> 24) & 0xff, HADDR + 3);
4869       aic_outb(p, sg_length & 0xff, HCNT);
4870       aic_outb(p, (sg_length >> 8) & 0xff, HCNT + 1);
4871       aic_outb(p, (sg_length >> 16) & 0xff, HCNT + 2);
4872       aic_outb(p, (tmp << 2) | ((tmp == 1) ? LAST_SEG : 0), SG_CACHEPTR);
4873       aic_outb(p, aic_inb(p, DMAPARAMS), DFCNTRL);
4874       while(aic_inb(p, SSTAT0) & SDONE) udelay(1);
4875       while(aic_inb(p, DFCNTRL) & (HDMAEN|SCSIEN)) aic_outb(p, 0, DFCNTRL);
4876     }
4877     break;
4878
4879 #ifdef AIC7XXX_NOT_YET 
4880     case TRACEPOINT2:
4881       {
4882         printk(INFO_LEAD "Tracepoint #2 reached.\n", p->host_no,
4883                channel, target, lun);
4884       }
4885       break;
4886
4887     /* XXX Fill these in later */
4888     case MSG_BUFFER_BUSY:
4889       printk("aic7xxx: Message buffer busy.\n");
4890       break;
4891     case MSGIN_PHASEMIS:
4892       printk("aic7xxx: Message-in phasemis.\n");
4893       break;
4894 #endif
4895
4896     default:                   /* unknown */
4897       printk(WARN_LEAD "Unknown SEQINT, INTSTAT 0x%x, SCSISIGI 0x%x.\n",
4898              p->host_no, channel, target, lun, intstat,
4899              aic_inb(p, SCSISIGI));
4900       break;
4901   }
4902
4903   /*
4904    * Clear the sequencer interrupt and unpause the sequencer.
4905    */
4906   unpause_sequencer(p, /* unpause always */ TRUE);
4907 }
4908
4909 /*+F*************************************************************************
4910  * Function:
4911  *   aic7xxx_parse_msg
4912  *
4913  * Description:
4914  *   Parses incoming messages into actions on behalf of
4915  *   aic7xxx_handle_reqinit
4916  *_F*************************************************************************/
4917 static int
4918 aic7xxx_parse_msg(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
4919 {
4920   int reject, reply, done;
4921   unsigned char target_scsirate, tindex;
4922   unsigned short target_mask;
4923   unsigned char target, channel, lun;
4924   unsigned char bus_width, new_bus_width;
4925   unsigned char trans_options, new_trans_options;
4926   unsigned int period, new_period, offset, new_offset, maxsync;
4927   struct aic7xxx_syncrate *syncrate;
4928   struct aic_dev_data *aic_dev;
4929
4930   target = scb->cmd->device->id;
4931   channel = scb->cmd->device->channel;
4932   lun = scb->cmd->device->lun;
4933   reply = reject = done = FALSE;
4934   tindex = TARGET_INDEX(scb->cmd);
4935   aic_dev = AIC_DEV(scb->cmd);
4936   target_scsirate = aic_inb(p, TARG_SCSIRATE + tindex);
4937   target_mask = (0x01 << tindex);
4938
4939   /*
4940    * Parse as much of the message as is available,
4941    * rejecting it if we don't support it.  When
4942    * the entire message is available and has been
4943    * handled, return TRUE indicating that we have
4944    * parsed an entire message.
4945    */
4946
4947   if (p->msg_buf[0] != MSG_EXTENDED)
4948   {
4949     reject = TRUE;
4950   }
4951
4952   /*
4953    * Even if we are an Ultra3 card, don't allow Ultra3 sync rates when
4954    * using the SDTR messages.  We need the PPR messages to enable the
4955    * higher speeds that include things like Dual Edge clocking.
4956    */
4957   if (p->features & AHC_ULTRA2)
4958   {
4959     if ( (aic_inb(p, SBLKCTL) & ENAB40) &&
4960          !(aic_inb(p, SSTAT2) & EXP_ACTIVE) )
4961     {
4962       if (p->features & AHC_ULTRA3)
4963         maxsync = AHC_SYNCRATE_ULTRA3;
4964       else
4965         maxsync = AHC_SYNCRATE_ULTRA2;
4966     }
4967     else
4968     {
4969       maxsync = AHC_SYNCRATE_ULTRA;
4970     }
4971   }
4972   else if (p->features & AHC_ULTRA)
4973   {
4974     maxsync = AHC_SYNCRATE_ULTRA;
4975   }
4976   else
4977   {
4978     maxsync = AHC_SYNCRATE_FAST;
4979   }
4980
4981   /*
4982    * Just accept the length byte outright and perform
4983    * more checking once we know the message type.
4984    */
4985
4986   if ( !reject && (p->msg_len > 2) )
4987   {
4988     switch(p->msg_buf[2])
4989     {
4990       case MSG_EXT_SDTR:
4991       {
4992         
4993         if (p->msg_buf[1] != MSG_EXT_SDTR_LEN)
4994         {
4995           reject = TRUE;
4996           break;
4997         }
4998
4999         if (p->msg_len < (MSG_EXT_SDTR_LEN + 2))
5000         {
5001           break;
5002         }
5003
5004         period = new_period = p->msg_buf[3];
5005         offset = new_offset = p->msg_buf[4];
5006         trans_options = new_trans_options = 0;
5007         bus_width = new_bus_width = target_scsirate & WIDEXFER;
5008
5009         /*
5010          * If our current max syncrate is in the Ultra3 range, bump it back
5011          * down to Ultra2 since we can't negotiate DT transfers using SDTR
5012          */
5013         if(maxsync == AHC_SYNCRATE_ULTRA3)
5014           maxsync = AHC_SYNCRATE_ULTRA2;
5015
5016         /*
5017          * We might have a device that is starting negotiation with us
5018          * before we can start up negotiation with it....be prepared to
5019          * have a device ask for a higher speed then we want to give it
5020          * in that case
5021          */
5022         if ( (scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_SDTR)) !=
5023              (SCB_MSGOUT_SENT|SCB_MSGOUT_SDTR) )
5024         {
5025           if (!(aic_dev->flags & DEVICE_DTR_SCANNED))
5026           {
5027             /*
5028              * We shouldn't get here unless this is a narrow drive, wide
5029              * devices should trigger this same section of code in the WDTR
5030              * handler first instead.
5031              */
5032             aic_dev->goal.width = MSG_EXT_WDTR_BUS_8_BIT;
5033             aic_dev->goal.options = 0;
5034             if(p->user[tindex].offset)
5035             {
5036               aic_dev->needsdtr_copy = 1;
5037               aic_dev->goal.period = max_t(unsigned char, 10,p->user[tindex].period);
5038               if(p->features & AHC_ULTRA2)
5039               {
5040                 aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
5041               }
5042               else
5043               {
5044                 aic_dev->goal.offset = MAX_OFFSET_8BIT;
5045               }
5046             }
5047             else
5048             {
5049               aic_dev->needsdtr_copy = 0;
5050               aic_dev->goal.period = 255;
5051               aic_dev->goal.offset = 0;
5052             }
5053             aic_dev->flags |= DEVICE_DTR_SCANNED | DEVICE_PRINT_DTR;
5054           }
5055           else if (aic_dev->needsdtr_copy == 0)
5056           {
5057             /*
5058              * This is a preemptive message from the target, we've already
5059              * scanned this target and set our options for it, and we
5060              * don't need a SDTR with this target (for whatever reason),
5061              * so reject this incoming SDTR
5062              */
5063             reject = TRUE;
5064             break;
5065           }
5066
5067           /* The device is sending this message first and we have to reply */
5068           reply = TRUE;
5069           
5070           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5071           {
5072             printk(INFO_LEAD "Received pre-emptive SDTR message from "
5073                    "target.\n", p->host_no, CTL_OF_SCB(scb));
5074           }
5075           /*
5076            * Validate the values the device passed to us against our SEEPROM
5077            * settings.  We don't have to do this if we aren't replying since
5078            * the device isn't allowed to send values greater than the ones
5079            * we first sent to it.
5080            */
5081           new_period = max_t(unsigned int, period, aic_dev->goal.period);
5082           new_offset = min_t(unsigned int, offset, aic_dev->goal.offset);
5083         }
5084  
5085         /*
5086          * Use our new_period, new_offset, bus_width, and card options
5087          * to determine the actual syncrate settings
5088          */
5089         syncrate = aic7xxx_find_syncrate(p, &new_period, maxsync,
5090                                          &trans_options);
5091         aic7xxx_validate_offset(p, syncrate, &new_offset, bus_width);
5092
5093         /*
5094          * Did we drop to async?  If so, send a reply regardless of whether
5095          * or not we initiated this negotiation.
5096          */
5097         if ((new_offset == 0) && (new_offset != offset))
5098         {
5099           aic_dev->needsdtr_copy = 0;
5100           reply = TRUE;
5101         }
5102         
5103         /*
5104          * Did we start this, if not, or if we went too low and had to
5105          * go async, then send an SDTR back to the target
5106          */
5107         if(reply)
5108         {
5109           /* when sending a reply, make sure that the goal settings are
5110            * updated along with current and active since the code that
5111            * will actually build the message for the sequencer uses the
5112            * goal settings as its guidelines.
5113            */
5114           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5115                                new_offset, trans_options,
5116                                AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5117                                aic_dev);
5118           scb->flags &= ~SCB_MSGOUT_BITS;
5119           scb->flags |= SCB_MSGOUT_SDTR;
5120           aic_outb(p, HOST_MSG, MSG_OUT);
5121           aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5122         }
5123         else
5124         {
5125           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5126                                new_offset, trans_options,
5127                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5128           aic_dev->needsdtr = 0;
5129         }
5130         done = TRUE;
5131         break;
5132       }
5133       case MSG_EXT_WDTR:
5134       {
5135           
5136         if (p->msg_buf[1] != MSG_EXT_WDTR_LEN)
5137         {
5138           reject = TRUE;
5139           break;
5140         }
5141
5142         if (p->msg_len < (MSG_EXT_WDTR_LEN + 2))
5143         {
5144           break;
5145         }
5146
5147         bus_width = new_bus_width = p->msg_buf[3];
5148
5149         if ( (scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_WDTR)) ==
5150              (SCB_MSGOUT_SENT|SCB_MSGOUT_WDTR) )
5151         {
5152           switch(bus_width)
5153           {
5154             default:
5155             {
5156               reject = TRUE;
5157               if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
5158                    ((aic_dev->flags & DEVICE_PRINT_DTR) ||
5159                     (aic7xxx_verbose > 0xffff)) )
5160               {
5161                 printk(INFO_LEAD "Requesting %d bit transfers, rejecting.\n",
5162                   p->host_no, CTL_OF_SCB(scb), 8 * (0x01 << bus_width));
5163               }
5164             } /* We fall through on purpose */
5165             case MSG_EXT_WDTR_BUS_8_BIT:
5166             {
5167               aic_dev->goal.width = MSG_EXT_WDTR_BUS_8_BIT;
5168               aic_dev->needwdtr_copy &= ~target_mask;
5169               break;
5170             }
5171             case MSG_EXT_WDTR_BUS_16_BIT:
5172             {
5173               break;
5174             }
5175           }
5176           aic_dev->needwdtr = 0;
5177           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5178                             AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5179         }
5180         else
5181         {
5182           if ( !(aic_dev->flags & DEVICE_DTR_SCANNED) )
5183           {
5184             /* 
5185              * Well, we now know the WDTR and SYNC caps of this device since
5186              * it contacted us first, mark it as such and copy the user stuff
5187              * over to the goal stuff.
5188              */
5189             if( (p->features & AHC_WIDE) && p->user[tindex].width )
5190             {
5191               aic_dev->goal.width = MSG_EXT_WDTR_BUS_16_BIT;
5192               aic_dev->needwdtr_copy = 1;
5193             }
5194             
5195             /*
5196              * Devices that support DT transfers don't start WDTR requests
5197              */
5198             aic_dev->goal.options = 0;
5199
5200             if(p->user[tindex].offset)
5201             {
5202               aic_dev->needsdtr_copy = 1;
5203               aic_dev->goal.period = max_t(unsigned char, 10, p->user[tindex].period);
5204               if(p->features & AHC_ULTRA2)
5205               {
5206                 aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
5207               }
5208               else if( aic_dev->goal.width )
5209               {
5210                 aic_dev->goal.offset = MAX_OFFSET_16BIT;
5211               }
5212               else
5213               {
5214                 aic_dev->goal.offset = MAX_OFFSET_8BIT;
5215               }
5216             } else {
5217               aic_dev->needsdtr_copy = 0;
5218               aic_dev->goal.period = 255;
5219               aic_dev->goal.offset = 0;
5220             }
5221             
5222             aic_dev->flags |= DEVICE_DTR_SCANNED | DEVICE_PRINT_DTR;
5223           }
5224           else if (aic_dev->needwdtr_copy == 0)
5225           {
5226             /*
5227              * This is a preemptive message from the target, we've already
5228              * scanned this target and set our options for it, and we
5229              * don't need a WDTR with this target (for whatever reason),
5230              * so reject this incoming WDTR
5231              */
5232             reject = TRUE;
5233             break;
5234           }
5235
5236           /* The device is sending this message first and we have to reply */
5237           reply = TRUE;
5238
5239           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5240           {
5241             printk(INFO_LEAD "Received pre-emptive WDTR message from "
5242                    "target.\n", p->host_no, CTL_OF_SCB(scb));
5243           }
5244           switch(bus_width)
5245           {
5246             case MSG_EXT_WDTR_BUS_16_BIT:
5247             {
5248               if ( (p->features & AHC_WIDE) &&
5249                    (aic_dev->goal.width == MSG_EXT_WDTR_BUS_16_BIT) )
5250               {
5251                 new_bus_width = MSG_EXT_WDTR_BUS_16_BIT;
5252                 break;
5253               }
5254             } /* Fall through if we aren't a wide card */
5255             default:
5256             case MSG_EXT_WDTR_BUS_8_BIT:
5257             {
5258               aic_dev->needwdtr_copy = 0;
5259               new_bus_width = MSG_EXT_WDTR_BUS_8_BIT;
5260               break;
5261             }
5262           }
5263           scb->flags &= ~SCB_MSGOUT_BITS;
5264           scb->flags |= SCB_MSGOUT_WDTR;
5265           aic_dev->needwdtr = 0;
5266           if(aic_dev->dtr_pending == 0)
5267           {
5268             /* there is no other command with SCB_DTR_SCB already set that will
5269              * trigger the release of the dtr_pending bit.  Both set the bit
5270              * and set scb->flags |= SCB_DTR_SCB
5271              */
5272             aic_dev->dtr_pending = 1;
5273             scb->flags |= SCB_DTR_SCB;
5274           }
5275           aic_outb(p, HOST_MSG, MSG_OUT);
5276           aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5277           /* when sending a reply, make sure that the goal settings are
5278            * updated along with current and active since the code that
5279            * will actually build the message for the sequencer uses the
5280            * goal settings as its guidelines.
5281            */
5282           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5283                           AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5284                           aic_dev);
5285         }
5286         
5287         /*
5288          * By virtue of the SCSI spec, a WDTR message negates any existing
5289          * SDTR negotiations.  So, even if needsdtr isn't marked for this
5290          * device, we still have to do a new SDTR message if the device
5291          * supports SDTR at all.  Therefore, we check needsdtr_copy instead
5292          * of needstr.
5293          */
5294         aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
5295                              AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
5296                              aic_dev);
5297         aic_dev->needsdtr = aic_dev->needsdtr_copy;
5298         done = TRUE;
5299         break;
5300       }
5301       case MSG_EXT_PPR:
5302       {
5303         
5304         if (p->msg_buf[1] != MSG_EXT_PPR_LEN)
5305         {
5306           reject = TRUE;
5307           break;
5308         }
5309
5310         if (p->msg_len < (MSG_EXT_PPR_LEN + 2))
5311         {
5312           break;
5313         }
5314
5315         period = new_period = p->msg_buf[3];
5316         offset = new_offset = p->msg_buf[5];
5317         bus_width = new_bus_width = p->msg_buf[6];
5318         trans_options = new_trans_options = p->msg_buf[7] & 0xf;
5319
5320         if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5321         {
5322           printk(INFO_LEAD "Parsing PPR message (%d/%d/%d/%d)\n",
5323                  p->host_no, CTL_OF_SCB(scb), period, offset, bus_width,
5324                  trans_options);
5325         }
5326
5327         /*
5328          * We might have a device that is starting negotiation with us
5329          * before we can start up negotiation with it....be prepared to
5330          * have a device ask for a higher speed then we want to give it
5331          * in that case
5332          */
5333         if ( (scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_PPR)) !=
5334              (SCB_MSGOUT_SENT|SCB_MSGOUT_PPR) )
5335         { 
5336           /* Have we scanned the device yet? */
5337           if (!(aic_dev->flags & DEVICE_DTR_SCANNED))
5338           {
5339             /* The device is electing to use PPR messages, so we will too until
5340              * we know better */
5341             aic_dev->needppr = aic_dev->needppr_copy = 1;
5342             aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
5343             aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
5344           
5345             /* We know the device is SCSI-3 compliant due to PPR */
5346             aic_dev->flags |= DEVICE_SCSI_3;
5347           
5348             /*
5349              * Not only is the device starting this up, but it also hasn't
5350              * been scanned yet, so this would likely be our TUR or our
5351              * INQUIRY command at scan time, so we need to use the
5352              * settings from the SEEPROM if they existed.  Of course, even
5353              * if we didn't find a SEEPROM, we stuffed default values into
5354              * the user settings anyway, so use those in all cases.
5355              */
5356             aic_dev->goal.width = p->user[tindex].width;
5357             if(p->user[tindex].offset)
5358             {
5359               aic_dev->goal.period = p->user[tindex].period;
5360               aic_dev->goal.options = p->user[tindex].options;
5361               if(p->features & AHC_ULTRA2)
5362               {
5363                 aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
5364               }
5365               else if( aic_dev->goal.width &&
5366                        (bus_width == MSG_EXT_WDTR_BUS_16_BIT) &&
5367                        p->features & AHC_WIDE )
5368               {
5369                 aic_dev->goal.offset = MAX_OFFSET_16BIT;
5370               }
5371               else
5372               {
5373                 aic_dev->goal.offset = MAX_OFFSET_8BIT;
5374               }
5375             }
5376             else
5377             {
5378               aic_dev->goal.period = 255;
5379               aic_dev->goal.offset = 0;
5380               aic_dev->goal.options = 0;
5381             }
5382             aic_dev->flags |= DEVICE_DTR_SCANNED | DEVICE_PRINT_DTR;
5383           }
5384           else if (aic_dev->needppr_copy == 0)
5385           {
5386             /*
5387              * This is a preemptive message from the target, we've already
5388              * scanned this target and set our options for it, and we
5389              * don't need a PPR with this target (for whatever reason),
5390              * so reject this incoming PPR
5391              */
5392             reject = TRUE;
5393             break;
5394           }
5395
5396           /* The device is sending this message first and we have to reply */
5397           reply = TRUE;
5398           
5399           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5400           {
5401             printk(INFO_LEAD "Received pre-emptive PPR message from "
5402                    "target.\n", p->host_no, CTL_OF_SCB(scb));
5403           }
5404
5405         }
5406
5407         switch(bus_width)
5408         {
5409           case MSG_EXT_WDTR_BUS_16_BIT:
5410           {
5411             if ( (aic_dev->goal.width == MSG_EXT_WDTR_BUS_16_BIT) &&
5412                             p->features & AHC_WIDE)
5413             {
5414               break;
5415             }
5416           }
5417           default:
5418           {
5419             if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
5420                  ((aic_dev->flags & DEVICE_PRINT_DTR) ||
5421                   (aic7xxx_verbose > 0xffff)) )
5422             {
5423               reply = TRUE;
5424               printk(INFO_LEAD "Requesting %d bit transfers, rejecting.\n",
5425                 p->host_no, CTL_OF_SCB(scb), 8 * (0x01 << bus_width));
5426             }
5427           } /* We fall through on purpose */
5428           case MSG_EXT_WDTR_BUS_8_BIT:
5429           {
5430             /*
5431              * According to the spec, if we aren't wide, we also can't be
5432              * Dual Edge so clear the options byte
5433              */
5434             new_trans_options = 0;
5435             new_bus_width = MSG_EXT_WDTR_BUS_8_BIT;
5436             break;
5437           }
5438         }
5439
5440         if(reply)
5441         {
5442           /* when sending a reply, make sure that the goal settings are
5443            * updated along with current and active since the code that
5444            * will actually build the message for the sequencer uses the
5445            * goal settings as its guidelines.
5446            */
5447           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5448                             AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5449                             aic_dev);
5450           syncrate = aic7xxx_find_syncrate(p, &new_period, maxsync,
5451                                            &new_trans_options);
5452           aic7xxx_validate_offset(p, syncrate, &new_offset, new_bus_width);
5453           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5454                                new_offset, new_trans_options,
5455                                AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5456                                aic_dev);
5457         }
5458         else
5459         {
5460           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5461                             AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5462           syncrate = aic7xxx_find_syncrate(p, &new_period, maxsync,
5463                                            &new_trans_options);
5464           aic7xxx_validate_offset(p, syncrate, &new_offset, new_bus_width);
5465           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5466                                new_offset, new_trans_options,
5467                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5468         }
5469
5470         /*
5471          * As it turns out, if we don't *have* to have PPR messages, then
5472          * configure ourselves not to use them since that makes some
5473          * external drive chassis work (those chassis can't parse PPR
5474          * messages and they mangle the SCSI bus until you send a WDTR
5475          * and SDTR that they can understand).
5476          */
5477         if(new_trans_options == 0)
5478         {
5479           aic_dev->needppr = aic_dev->needppr_copy = 0;
5480           if(new_offset)
5481           {
5482             aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
5483           }
5484           if (new_bus_width)
5485           {
5486             aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
5487           }
5488         }
5489
5490         if((new_offset == 0) && (offset != 0))
5491         {
5492           /*
5493            * Oops, the syncrate went to low for this card and we fell off
5494            * to async (should never happen with a device that uses PPR
5495            * messages, but have to be complete)
5496            */
5497           reply = TRUE;
5498         }
5499
5500         if(reply)
5501         {
5502           scb->flags &= ~SCB_MSGOUT_BITS;
5503           scb->flags |= SCB_MSGOUT_PPR;
5504           aic_outb(p, HOST_MSG, MSG_OUT);
5505           aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5506         }
5507         else
5508         {
5509           aic_dev->needppr = 0;
5510         }
5511         done = TRUE;
5512         break;
5513       }
5514       default:
5515       {
5516         reject = TRUE;
5517         break;
5518       }
5519     } /* end of switch(p->msg_type) */
5520   } /* end of if (!reject && (p->msg_len > 2)) */
5521
5522   if (!reply && reject)
5523   {
5524     aic_outb(p, MSG_MESSAGE_REJECT, MSG_OUT);
5525     aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5526     done = TRUE;
5527   }
5528   return(done);
5529 }
5530
5531
5532 /*+F*************************************************************************
5533  * Function:
5534  *   aic7xxx_handle_reqinit
5535  *
5536  * Description:
5537  *   Interrupt handler for REQINIT interrupts (used to transfer messages to
5538  *    and from devices).
5539  *_F*************************************************************************/
5540 static void
5541 aic7xxx_handle_reqinit(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
5542 {
5543   unsigned char lastbyte;
5544   unsigned char phasemis;
5545   int done = FALSE;
5546
5547   switch(p->msg_type)
5548   {
5549     case MSG_TYPE_INITIATOR_MSGOUT:
5550       {
5551         if (p->msg_len == 0)
5552           panic("aic7xxx: REQINIT with no active message!\n");
5553
5554         lastbyte = (p->msg_index == (p->msg_len - 1));
5555         phasemis = ( aic_inb(p, SCSISIGI) & PHASE_MASK) != P_MESGOUT;
5556
5557         if (lastbyte || phasemis)
5558         {
5559           /* Time to end the message */
5560           p->msg_len = 0;
5561           p->msg_type = MSG_TYPE_NONE;
5562           /*
5563            * NOTE-TO-MYSELF: If you clear the REQINIT after you
5564            * disable REQINITs, then cases of REJECT_MSG stop working
5565            * and hang the bus
5566            */
5567           aic_outb(p, aic_inb(p, SIMODE1) & ~ENREQINIT, SIMODE1);
5568           aic_outb(p, CLRSCSIINT, CLRINT);
5569           p->flags &= ~AHC_HANDLING_REQINITS;
5570
5571           if (phasemis == 0)
5572           {
5573             aic_outb(p, p->msg_buf[p->msg_index], SINDEX);
5574             aic_outb(p, 0, RETURN_1);
5575 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5576             if (aic7xxx_verbose > 0xffff)
5577               printk(INFO_LEAD "Completed sending of REQINIT message.\n",
5578                      p->host_no, CTL_OF_SCB(scb));
5579 #endif
5580           }
5581           else
5582           {
5583             aic_outb(p, MSGOUT_PHASEMIS, RETURN_1);
5584 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5585             if (aic7xxx_verbose > 0xffff)
5586               printk(INFO_LEAD "PHASEMIS while sending REQINIT message.\n",
5587                      p->host_no, CTL_OF_SCB(scb));
5588 #endif
5589           }
5590           unpause_sequencer(p, TRUE);
5591         }
5592         else
5593         {
5594           /*
5595            * Present the byte on the bus (clearing REQINIT) but don't
5596            * unpause the sequencer.
5597            */
5598           aic_outb(p, CLRREQINIT, CLRSINT1);
5599           aic_outb(p, CLRSCSIINT, CLRINT);
5600           aic_outb(p,  p->msg_buf[p->msg_index++], SCSIDATL);
5601         }
5602         break;
5603       }
5604     case MSG_TYPE_INITIATOR_MSGIN:
5605       {
5606         phasemis = ( aic_inb(p, SCSISIGI) & PHASE_MASK ) != P_MESGIN;
5607
5608         if (phasemis == 0)
5609         {
5610           p->msg_len++;
5611           /* Pull the byte in without acking it */
5612           p->msg_buf[p->msg_index] = aic_inb(p, SCSIBUSL);
5613           done = aic7xxx_parse_msg(p, scb);
5614           /* Ack the byte */
5615           aic_outb(p, CLRREQINIT, CLRSINT1);
5616           aic_outb(p, CLRSCSIINT, CLRINT);
5617           aic_inb(p, SCSIDATL);
5618           p->msg_index++;
5619         }
5620         if (phasemis || done)
5621         {
5622 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5623           if (aic7xxx_verbose > 0xffff)
5624           {
5625             if (phasemis)
5626               printk(INFO_LEAD "PHASEMIS while receiving REQINIT message.\n",
5627                      p->host_no, CTL_OF_SCB(scb));
5628             else
5629               printk(INFO_LEAD "Completed receipt of REQINIT message.\n",
5630                      p->host_no, CTL_OF_SCB(scb));
5631           }
5632 #endif
5633           /* Time to end our message session */
5634           p->msg_len = 0;
5635           p->msg_type = MSG_TYPE_NONE;
5636           aic_outb(p, aic_inb(p, SIMODE1) & ~ENREQINIT, SIMODE1);
5637           aic_outb(p, CLRSCSIINT, CLRINT);
5638           p->flags &= ~AHC_HANDLING_REQINITS;
5639           unpause_sequencer(p, TRUE);
5640         }
5641         break;
5642       }
5643     default:
5644       {
5645         panic("aic7xxx: Unknown REQINIT message type.\n");
5646         break;
5647       }
5648   } /* End of switch(p->msg_type) */
5649 }
5650
5651 /*+F*************************************************************************
5652  * Function:
5653  *   aic7xxx_handle_scsiint
5654  *
5655  * Description:
5656  *   Interrupt handler for SCSI interrupts (SCSIINT).
5657  *-F*************************************************************************/
5658 static void
5659 aic7xxx_handle_scsiint(struct aic7xxx_host *p, unsigned char intstat)
5660 {
5661   unsigned char scb_index;
5662   unsigned char status;
5663   struct aic7xxx_scb *scb;
5664   struct aic_dev_data *aic_dev;
5665
5666   scb_index = aic_inb(p, SCB_TAG);
5667   status = aic_inb(p, SSTAT1);
5668
5669   if (scb_index < p->scb_data->numscbs)
5670   {
5671     scb = p->scb_data->scb_array[scb_index];
5672     if ((scb->flags & SCB_ACTIVE) == 0)
5673     {
5674       scb = NULL;
5675     }
5676   }
5677   else
5678   {
5679     scb = NULL;
5680   }
5681
5682
5683   if ((status & SCSIRSTI) != 0)
5684   {
5685     int channel;
5686
5687     if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
5688       channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3;
5689     else
5690       channel = 0;
5691
5692     if (aic7xxx_verbose & VERBOSE_RESET)
5693       printk(WARN_LEAD "Someone else reset the channel!!\n",
5694            p->host_no, channel, -1, -1);
5695     if (aic7xxx_panic_on_abort)
5696       aic7xxx_panic_abort(p, NULL);
5697     /*
5698      * Go through and abort all commands for the channel, but do not
5699      * reset the channel again.
5700      */
5701     aic7xxx_reset_channel(p, channel, /* Initiate Reset */ FALSE);
5702     aic7xxx_run_done_queue(p, TRUE);
5703     scb = NULL;
5704   }
5705   else if ( ((status & BUSFREE) != 0) && ((status & SELTO) == 0) )
5706   {
5707     /*
5708      * First look at what phase we were last in.  If it's message-out,
5709      * chances are pretty good that the bus free was in response to
5710      * one of our abort requests.
5711      */
5712     unsigned char lastphase = aic_inb(p, LASTPHASE);
5713     unsigned char saved_tcl = aic_inb(p, SAVED_TCL);
5714     unsigned char target = (saved_tcl >> 4) & 0x0F;
5715     int channel;
5716     int printerror = TRUE;
5717
5718     if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
5719       channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3;
5720     else
5721       channel = 0;
5722
5723     aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP),
5724              SCSISEQ);
5725     if (lastphase == P_MESGOUT)
5726     {
5727       unsigned char message;
5728
5729       message = aic_inb(p, SINDEX);
5730
5731       if ((message == MSG_ABORT) || (message == MSG_ABORT_TAG))
5732       {
5733         if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)
5734           printk(INFO_LEAD "SCB %d abort delivered.\n", p->host_no,
5735             CTL_OF_SCB(scb), scb->hscb->tag);
5736         aic7xxx_reset_device(p, target, channel, ALL_LUNS,
5737                 (message == MSG_ABORT) ? SCB_LIST_NULL : scb->hscb->tag );
5738         aic7xxx_run_done_queue(p, TRUE);
5739         scb = NULL;
5740         printerror = 0;
5741       }
5742       else if (message == MSG_BUS_DEV_RESET)
5743       {
5744         aic7xxx_handle_device_reset(p, target, channel);
5745         scb = NULL;
5746         printerror = 0;
5747       }
5748     }
5749     if ( (scb != NULL) && (scb->flags & SCB_DTR_SCB) ) 
5750     {
5751       /*
5752        * Hmmm...error during a negotiation command.  Either we have a
5753        * borken bus, or the device doesn't like our negotiation message.
5754        * Since we check the INQUIRY data of a device before sending it
5755        * negotiation messages, assume the bus is borken for whatever
5756        * reason.  Complete the command.
5757        */
5758       printerror = 0;
5759       aic7xxx_reset_device(p, target, channel, ALL_LUNS, scb->hscb->tag);
5760       aic7xxx_run_done_queue(p, TRUE);
5761       scb = NULL;
5762     }
5763     if (printerror != 0)
5764     {
5765       if (scb != NULL)
5766       {
5767         unsigned char tag;
5768
5769         if ((scb->hscb->control & TAG_ENB) != 0)
5770         {
5771           tag = scb->hscb->tag;
5772         }
5773         else
5774         {
5775           tag = SCB_LIST_NULL;
5776         }
5777         aic7xxx_reset_device(p, target, channel, ALL_LUNS, tag);
5778         aic7xxx_run_done_queue(p, TRUE);
5779       }
5780       else
5781       {
5782         aic7xxx_reset_device(p, target, channel, ALL_LUNS, SCB_LIST_NULL);
5783         aic7xxx_run_done_queue(p, TRUE);
5784       }
5785       printk(INFO_LEAD "Unexpected busfree, LASTPHASE = 0x%x, "
5786              "SEQADDR = 0x%x\n", p->host_no, channel, target, -1, lastphase,
5787              (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0));
5788       scb = NULL;
5789     }
5790     aic_outb(p, MSG_NOOP, MSG_OUT);
5791     aic_outb(p, aic_inb(p, SIMODE1) & ~(ENBUSFREE|ENREQINIT),
5792       SIMODE1);
5793     p->flags &= ~AHC_HANDLING_REQINITS;
5794     aic_outb(p, CLRBUSFREE, CLRSINT1);
5795     aic_outb(p, CLRSCSIINT, CLRINT);
5796     restart_sequencer(p);
5797     unpause_sequencer(p, TRUE);
5798   }
5799   else if ((status & SELTO) != 0)
5800   {
5801         unsigned char scbptr;
5802         unsigned char nextscb;
5803         struct scsi_cmnd *cmd;
5804
5805     scbptr = aic_inb(p, WAITING_SCBH);
5806     if (scbptr > p->scb_data->maxhscbs)
5807     {
5808       /*
5809        * I'm still trying to track down exactly how this happens, but until
5810        * I find it, this code will make sure we aren't passing bogus values
5811        * into the SCBPTR register, even if that register will just wrap
5812        * things around, we still don't like having out of range variables.
5813        *
5814        * NOTE: Don't check the aic7xxx_verbose variable, I want this message
5815        * to always be displayed.
5816        */
5817       printk(INFO_LEAD "Invalid WAITING_SCBH value %d, improvising.\n",
5818              p->host_no, -1, -1, -1, scbptr);
5819       if (p->scb_data->maxhscbs > 4)
5820         scbptr &= (p->scb_data->maxhscbs - 1);
5821       else
5822         scbptr &= 0x03;
5823     }
5824     aic_outb(p, scbptr, SCBPTR);
5825     scb_index = aic_inb(p, SCB_TAG);
5826
5827     scb = NULL;
5828     if (scb_index < p->scb_data->numscbs)
5829     {
5830       scb = p->scb_data->scb_array[scb_index];
5831       if ((scb->flags & SCB_ACTIVE) == 0)
5832       {
5833         scb = NULL;
5834       }
5835     }
5836     if (scb == NULL)
5837     {
5838       printk(WARN_LEAD "Referenced SCB %d not valid during SELTO.\n",
5839              p->host_no, -1, -1, -1, scb_index);
5840       printk(KERN_WARNING "        SCSISEQ = 0x%x SEQADDR = 0x%x SSTAT0 = 0x%x "
5841              "SSTAT1 = 0x%x\n", aic_inb(p, SCSISEQ),
5842              aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
5843              aic_inb(p, SSTAT0), aic_inb(p, SSTAT1));
5844       if (aic7xxx_panic_on_abort)
5845         aic7xxx_panic_abort(p, NULL);
5846     }
5847     else
5848     {
5849       cmd = scb->cmd;
5850       cmd->result = (DID_TIME_OUT << 16);
5851
5852       /*
5853        * Clear out this hardware SCB
5854        */
5855       aic_outb(p, 0, SCB_CONTROL);
5856
5857       /*
5858        * Clear out a few values in the card that are in an undetermined
5859        * state.
5860        */
5861       aic_outb(p, MSG_NOOP, MSG_OUT);
5862
5863       /*
5864        * Shift the waiting for selection queue forward
5865        */
5866       nextscb = aic_inb(p, SCB_NEXT);
5867       aic_outb(p, nextscb, WAITING_SCBH);
5868
5869       /*
5870        * Put this SCB back on the free list.
5871        */
5872       aic7xxx_add_curscb_to_free_list(p);
5873 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5874       if (aic7xxx_verbose > 0xffff)
5875         printk(INFO_LEAD "Selection Timeout.\n", p->host_no, CTL_OF_SCB(scb));
5876 #endif
5877       if (scb->flags & SCB_QUEUED_ABORT)
5878       {
5879         /*
5880          * We know that this particular SCB had to be the queued abort since
5881          * the disconnected SCB would have gotten a reconnect instead.
5882          * What we need to do then is to let the command timeout again so
5883          * we get a reset since this abort just failed.
5884          */
5885         cmd->result = 0;
5886         scb = NULL;
5887       }
5888     }
5889     /*
5890      * Keep the sequencer from trying to restart any selections
5891      */
5892     aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ);
5893     /*
5894      * Make sure the data bits on the bus are released
5895      * Don't do this on 7770 chipsets, it makes them give us
5896      * a BRKADDRINT and kills the card.
5897      */
5898     if( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI )
5899       aic_outb(p, 0, SCSIBUSL);
5900
5901     /*
5902      * Delay for the selection timeout delay period then stop the selection
5903      */
5904     udelay(301);
5905     aic_outb(p, CLRSELINGO, CLRSINT0);
5906     /*
5907      * Clear out all the interrupt status bits
5908      */
5909     aic_outb(p, aic_inb(p, SIMODE1) & ~(ENREQINIT|ENBUSFREE), SIMODE1);
5910     p->flags &= ~AHC_HANDLING_REQINITS;
5911     aic_outb(p, CLRSELTIMEO | CLRBUSFREE, CLRSINT1);
5912     aic_outb(p, CLRSCSIINT, CLRINT);
5913     /*
5914      * Restarting the sequencer will stop the selection and make sure devices
5915      * are allowed to reselect in.
5916      */
5917     restart_sequencer(p);
5918     unpause_sequencer(p, TRUE);
5919   }
5920   else if (scb == NULL)
5921   {
5922     printk(WARN_LEAD "aic7xxx_isr - referenced scb not valid "
5923            "during scsiint 0x%x scb(%d)\n"
5924            "      SIMODE0 0x%x, SIMODE1 0x%x, SSTAT0 0x%x, SEQADDR 0x%x\n",
5925            p->host_no, -1, -1, -1, status, scb_index, aic_inb(p, SIMODE0),
5926            aic_inb(p, SIMODE1), aic_inb(p, SSTAT0),
5927            (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0));
5928     /*
5929      * Turn off the interrupt and set status to zero, so that it
5930      * falls through the rest of the SCSIINT code.
5931      */
5932     aic_outb(p, status, CLRSINT1);
5933     aic_outb(p, CLRSCSIINT, CLRINT);
5934     unpause_sequencer(p, /* unpause always */ TRUE);
5935     scb = NULL;
5936   }
5937   else if (status & SCSIPERR)
5938   {
5939     /*
5940      * Determine the bus phase and queue an appropriate message.
5941      */
5942         char  *phase;
5943         struct scsi_cmnd *cmd;
5944         unsigned char mesg_out = MSG_NOOP;
5945         unsigned char lastphase = aic_inb(p, LASTPHASE);
5946         unsigned char sstat2 = aic_inb(p, SSTAT2);
5947
5948     cmd = scb->cmd;
5949     switch (lastphase)
5950     {
5951       case P_DATAOUT:
5952         phase = "Data-Out";
5953         break;
5954       case P_DATAIN:
5955         phase = "Data-In";
5956         mesg_out = MSG_INITIATOR_DET_ERR;
5957         break;
5958       case P_COMMAND:
5959         phase = "Command";
5960         break;
5961       case P_MESGOUT:
5962         phase = "Message-Out";
5963         break;
5964       case P_STATUS:
5965         phase = "Status";
5966         mesg_out = MSG_INITIATOR_DET_ERR;
5967         break;
5968       case P_MESGIN:
5969         phase = "Message-In";
5970         mesg_out = MSG_PARITY_ERROR;
5971         break;
5972       default:
5973         phase = "unknown";
5974         break;
5975     }
5976
5977     /*
5978      * A parity error has occurred during a data
5979      * transfer phase. Flag it and continue.
5980      */
5981     if( (p->features & AHC_ULTRA3) && 
5982         (aic_inb(p, SCSIRATE) & AHC_SYNCRATE_CRC) &&
5983         (lastphase == P_DATAIN) )
5984     {
5985       printk(WARN_LEAD "CRC error during %s phase.\n",
5986              p->host_no, CTL_OF_SCB(scb), phase);
5987       if(sstat2 & CRCVALERR)
5988       {
5989         printk(WARN_LEAD "  CRC error in intermediate CRC packet.\n",
5990                p->host_no, CTL_OF_SCB(scb));
5991       }
5992       if(sstat2 & CRCENDERR)
5993       {
5994         printk(WARN_LEAD "  CRC error in ending CRC packet.\n",
5995                p->host_no, CTL_OF_SCB(scb));
5996       }
5997       if(sstat2 & CRCREQERR)
5998       {
5999         printk(WARN_LEAD "  Target incorrectly requested a CRC packet.\n",
6000                p->host_no, CTL_OF_SCB(scb));
6001       }
6002       if(sstat2 & DUAL_EDGE_ERROR)
6003       {
6004         printk(WARN_LEAD "  Dual Edge transmission error.\n",
6005                p->host_no, CTL_OF_SCB(scb));
6006       }
6007     }
6008     else if( (lastphase == P_MESGOUT) &&
6009              (scb->flags & SCB_MSGOUT_PPR) )
6010     {
6011       /*
6012        * As per the draft specs, any device capable of supporting any of
6013        * the option values other than 0 are not allowed to reject the
6014        * PPR message.  Instead, they must negotiate out what they do
6015        * support instead of rejecting our offering or else they cause
6016        * a parity error during msg_out phase to signal that they don't
6017        * like our settings.
6018        */
6019       aic_dev = AIC_DEV(scb->cmd);
6020       aic_dev->needppr = aic_dev->needppr_copy = 0;
6021       aic7xxx_set_width(p, scb->cmd->device->id, scb->cmd->device->channel, scb->cmd->device->lun,
6022                         MSG_EXT_WDTR_BUS_8_BIT,
6023                         (AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE),
6024                         aic_dev);
6025       aic7xxx_set_syncrate(p, NULL, scb->cmd->device->id, scb->cmd->device->channel, 0, 0,
6026                            0, AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
6027                            aic_dev);
6028       aic_dev->goal.options = 0;
6029       scb->flags &= ~SCB_MSGOUT_BITS;
6030       if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
6031       {
6032         printk(INFO_LEAD "parity error during PPR message, reverting "
6033                "to WDTR/SDTR\n", p->host_no, CTL_OF_SCB(scb));
6034       }
6035       if ( aic_dev->goal.width )
6036       {
6037         aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
6038       }
6039       if ( aic_dev->goal.offset )
6040       {
6041         if( aic_dev->goal.period <= 9 )
6042         {
6043           aic_dev->goal.period = 10;
6044         }
6045         aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
6046       }
6047       scb = NULL;
6048     }
6049
6050     /*
6051      * We've set the hardware to assert ATN if we get a parity
6052      * error on "in" phases, so all we need to do is stuff the
6053      * message buffer with the appropriate message.  "In" phases
6054      * have set mesg_out to something other than MSG_NOP.
6055      */
6056     if (mesg_out != MSG_NOOP)
6057     {
6058       aic_outb(p, mesg_out, MSG_OUT);
6059       aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
6060       scb = NULL;
6061     }
6062     aic_outb(p, CLRSCSIPERR, CLRSINT1);
6063     aic_outb(p, CLRSCSIINT, CLRINT);
6064     unpause_sequencer(p, /* unpause_always */ TRUE);
6065   }
6066   else if ( (status & REQINIT) &&
6067             (p->flags & AHC_HANDLING_REQINITS) )
6068   {
6069 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6070     if (aic7xxx_verbose > 0xffff)
6071       printk(INFO_LEAD "Handling REQINIT, SSTAT1=0x%x.\n", p->host_no,
6072              CTL_OF_SCB(scb), aic_inb(p, SSTAT1));
6073 #endif
6074     aic7xxx_handle_reqinit(p, scb);
6075     return;
6076   }
6077   else
6078   {
6079     /*
6080      * We don't know what's going on. Turn off the
6081      * interrupt source and try to continue.
6082      */
6083     if (aic7xxx_verbose & VERBOSE_SCSIINT)
6084       printk(INFO_LEAD "Unknown SCSIINT status, SSTAT1(0x%x).\n",
6085         p->host_no, -1, -1, -1, status);
6086     aic_outb(p, status, CLRSINT1);
6087     aic_outb(p, CLRSCSIINT, CLRINT);
6088     unpause_sequencer(p, /* unpause always */ TRUE);
6089     scb = NULL;
6090   }
6091   if (scb != NULL)
6092   {
6093     aic7xxx_done(p, scb);
6094   }
6095 }
6096
6097 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6098 static void
6099 aic7xxx_check_scbs(struct aic7xxx_host *p, char *buffer)
6100 {
6101   unsigned char saved_scbptr, free_scbh, dis_scbh, wait_scbh, temp;
6102   int i, bogus, lost;
6103   static unsigned char scb_status[AIC7XXX_MAXSCB];
6104
6105 #define SCB_NO_LIST 0
6106 #define SCB_FREE_LIST 1
6107 #define SCB_WAITING_LIST 2
6108 #define SCB_DISCONNECTED_LIST 4
6109 #define SCB_CURRENTLY_ACTIVE 8
6110
6111   /*
6112    * Note, these checks will fail on a regular basis once the machine moves
6113    * beyond the bus scan phase.  The problem is race conditions concerning
6114    * the scbs and where they are linked in.  When you have 30 or so commands
6115    * outstanding on the bus, and run this twice with every interrupt, the
6116    * chances get pretty good that you'll catch the sequencer with an SCB
6117    * only partially linked in.  Therefore, once we pass the scan phase
6118    * of the bus, we really should disable this function.
6119    */
6120   bogus = FALSE;
6121   memset(&scb_status[0], 0, sizeof(scb_status));
6122   pause_sequencer(p);
6123   saved_scbptr = aic_inb(p, SCBPTR);
6124   if (saved_scbptr >= p->scb_data->maxhscbs)
6125   {
6126     printk("Bogus SCBPTR %d\n", saved_scbptr);
6127     bogus = TRUE;
6128   }
6129   scb_status[saved_scbptr] = SCB_CURRENTLY_ACTIVE;
6130   free_scbh = aic_inb(p, FREE_SCBH);
6131   if ( (free_scbh != SCB_LIST_NULL) &&
6132        (free_scbh >= p->scb_data->maxhscbs) )
6133   {
6134     printk("Bogus FREE_SCBH %d\n", free_scbh);
6135     bogus = TRUE;
6136   }
6137   else
6138   {
6139     temp = free_scbh;
6140     while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) )
6141     {
6142       if(scb_status[temp] & 0x07)
6143       {
6144         printk("HSCB %d on multiple lists, status 0x%02x", temp,
6145                scb_status[temp] | SCB_FREE_LIST);
6146         bogus = TRUE;
6147       }
6148       scb_status[temp] |= SCB_FREE_LIST;
6149       aic_outb(p, temp, SCBPTR);
6150       temp = aic_inb(p, SCB_NEXT);
6151     }
6152   }
6153
6154   dis_scbh = aic_inb(p, DISCONNECTED_SCBH);
6155   if ( (dis_scbh != SCB_LIST_NULL) &&
6156        (dis_scbh >= p->scb_data->maxhscbs) )
6157   {
6158     printk("Bogus DISCONNECTED_SCBH %d\n", dis_scbh);
6159     bogus = TRUE;
6160   }
6161   else
6162   {
6163     temp = dis_scbh;
6164     while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) )
6165     {
6166       if(scb_status[temp] & 0x07)
6167       {
6168         printk("HSCB %d on multiple lists, status 0x%02x", temp,
6169                scb_status[temp] | SCB_DISCONNECTED_LIST);
6170         bogus = TRUE;
6171       }
6172       scb_status[temp] |= SCB_DISCONNECTED_LIST;
6173       aic_outb(p, temp, SCBPTR);
6174       temp = aic_inb(p, SCB_NEXT);
6175     }
6176   }
6177   
6178   wait_scbh = aic_inb(p, WAITING_SCBH);
6179   if ( (wait_scbh != SCB_LIST_NULL) &&
6180        (wait_scbh >= p->scb_data->maxhscbs) )
6181   {
6182     printk("Bogus WAITING_SCBH %d\n", wait_scbh);
6183     bogus = TRUE;
6184   }
6185   else
6186   {
6187     temp = wait_scbh;
6188     while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) )
6189     {
6190       if(scb_status[temp] & 0x07)
6191       {
6192         printk("HSCB %d on multiple lists, status 0x%02x", temp,
6193                scb_status[temp] | SCB_WAITING_LIST);
6194         bogus = TRUE;
6195       }
6196       scb_status[temp] |= SCB_WAITING_LIST;
6197       aic_outb(p, temp, SCBPTR);
6198       temp = aic_inb(p, SCB_NEXT);
6199     }
6200   }
6201
6202   lost=0;
6203   for(i=0; i < p->scb_data->maxhscbs; i++)
6204   {
6205     aic_outb(p, i, SCBPTR);
6206     temp = aic_inb(p, SCB_NEXT);
6207     if ( ((temp != SCB_LIST_NULL) &&
6208           (temp >= p->scb_data->maxhscbs)) )
6209     {
6210       printk("HSCB %d bad, SCB_NEXT invalid(%d).\n", i, temp);
6211       bogus = TRUE;
6212     }
6213     if ( temp == i )
6214     {
6215       printk("HSCB %d bad, SCB_NEXT points to self.\n", i);
6216       bogus = TRUE;
6217     }
6218     if (scb_status[i] == 0)
6219       lost++;
6220     if (lost > 1)
6221     {
6222       printk("Too many lost scbs.\n");
6223       bogus=TRUE;
6224     }
6225   }
6226   aic_outb(p, saved_scbptr, SCBPTR);
6227   unpause_sequencer(p, FALSE);
6228   if (bogus)
6229   {
6230     printk("Bogus parameters found in card SCB array structures.\n");
6231     printk("%s\n", buffer);
6232     aic7xxx_panic_abort(p, NULL);
6233   }
6234   return;
6235 }
6236 #endif
6237
6238
6239 /*+F*************************************************************************
6240  * Function:
6241  *   aic7xxx_handle_command_completion_intr
6242  *
6243  * Description:
6244  *   SCSI command completion interrupt handler.
6245  *-F*************************************************************************/
6246 static void
6247 aic7xxx_handle_command_completion_intr(struct aic7xxx_host *p)
6248 {
6249         struct aic7xxx_scb *scb = NULL;
6250         struct aic_dev_data *aic_dev;
6251         struct scsi_cmnd *cmd;
6252         unsigned char scb_index, tindex;
6253
6254 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6255   if( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) )
6256     printk(INFO_LEAD "Command Complete Int.\n", p->host_no, -1, -1, -1);
6257 #endif
6258     
6259   /*
6260    * Read the INTSTAT location after clearing the CMDINT bit.  This forces
6261    * any posted PCI writes to flush to memory.  Gerard Roudier suggested
6262    * this fix to the possible race of clearing the CMDINT bit but not
6263    * having all command bytes flushed onto the qoutfifo.
6264    */
6265   aic_outb(p, CLRCMDINT, CLRINT);
6266   aic_inb(p, INTSTAT);
6267   /*
6268    * The sequencer will continue running when it
6269    * issues this interrupt. There may be >1 commands
6270    * finished, so loop until we've processed them all.
6271    */
6272
6273   while (p->qoutfifo[p->qoutfifonext] != SCB_LIST_NULL)
6274   {
6275     scb_index = p->qoutfifo[p->qoutfifonext];
6276     p->qoutfifo[p->qoutfifonext++] = SCB_LIST_NULL;
6277     if ( scb_index >= p->scb_data->numscbs )
6278     {
6279       printk(WARN_LEAD "CMDCMPLT with invalid SCB index %d\n", p->host_no,
6280         -1, -1, -1, scb_index);
6281       continue;
6282     }
6283     scb = p->scb_data->scb_array[scb_index];
6284     if (!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
6285     {
6286       printk(WARN_LEAD "CMDCMPLT without command for SCB %d, SCB flags "
6287         "0x%x, cmd 0x%lx\n", p->host_no, -1, -1, -1, scb_index, scb->flags,
6288         (unsigned long) scb->cmd);
6289       continue;
6290     }
6291     tindex = TARGET_INDEX(scb->cmd);
6292     aic_dev = AIC_DEV(scb->cmd);
6293     if (scb->flags & SCB_QUEUED_ABORT)
6294     {
6295       pause_sequencer(p);
6296       if ( ((aic_inb(p, LASTPHASE) & PHASE_MASK) != P_BUSFREE) &&
6297            (aic_inb(p, SCB_TAG) == scb->hscb->tag) )
6298       {
6299         unpause_sequencer(p, FALSE);
6300         continue;
6301       }
6302       aic7xxx_reset_device(p, scb->cmd->device->id, scb->cmd->device->channel,
6303         scb->cmd->device->lun, scb->hscb->tag);
6304       scb->flags &= ~(SCB_QUEUED_FOR_DONE | SCB_RESET | SCB_ABORT |
6305         SCB_QUEUED_ABORT);
6306       unpause_sequencer(p, FALSE);
6307     }
6308     else if (scb->flags & SCB_ABORT)
6309     {
6310       /*
6311        * We started to abort this, but it completed on us, let it
6312        * through as successful
6313        */
6314       scb->flags &= ~(SCB_ABORT|SCB_RESET);
6315     }
6316     else if (scb->flags & SCB_SENSE)
6317     {
6318       char *buffer = &scb->cmd->sense_buffer[0];
6319
6320       if (buffer[12] == 0x47 || buffer[12] == 0x54)
6321       {
6322         /*
6323          * Signal that we need to re-negotiate things.
6324          */
6325         aic_dev->needppr = aic_dev->needppr_copy;
6326         aic_dev->needsdtr = aic_dev->needsdtr_copy;
6327         aic_dev->needwdtr = aic_dev->needwdtr_copy;
6328       }
6329     }
6330     cmd = scb->cmd;
6331     if (scb->hscb->residual_SG_segment_count != 0)
6332     {
6333       aic7xxx_calculate_residual(p, scb);
6334     }
6335     cmd->result |= (aic7xxx_error(cmd) << 16);
6336     aic7xxx_done(p, scb);
6337   }
6338 }
6339
6340 /*+F*************************************************************************
6341  * Function:
6342  *   aic7xxx_isr
6343  *
6344  * Description:
6345  *   SCSI controller interrupt handler.
6346  *-F*************************************************************************/
6347 static void
6348 aic7xxx_isr(int irq, void *dev_id)
6349 {
6350   struct aic7xxx_host *p;
6351   unsigned char intstat;
6352
6353   p = (struct aic7xxx_host *)dev_id;
6354
6355   /*
6356    * Just a few sanity checks.  Make sure that we have an int pending.
6357    * Also, if PCI, then we are going to check for a PCI bus error status
6358    * should we get too many spurious interrupts.
6359    */
6360   if (!((intstat = aic_inb(p, INTSTAT)) & INT_PEND))
6361   {
6362 #ifdef CONFIG_PCI
6363     if ( (p->chip & AHC_PCI) && (p->spurious_int > 500) &&
6364         !(p->flags & AHC_HANDLING_REQINITS) )
6365     {
6366       if ( aic_inb(p, ERROR) & PCIERRSTAT )
6367       {
6368         aic7xxx_pci_intr(p);
6369       }
6370       p->spurious_int = 0;
6371     }
6372     else if ( !(p->flags & AHC_HANDLING_REQINITS) )
6373     {
6374       p->spurious_int++;
6375     }
6376 #endif
6377     return;
6378   }
6379
6380   p->spurious_int = 0;
6381
6382   /*
6383    * Keep track of interrupts for /proc/scsi
6384    */
6385   p->isr_count++;
6386
6387 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6388   if ( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) &&
6389        (aic7xxx_panic_on_abort) && (p->flags & AHC_PAGESCBS) )
6390     aic7xxx_check_scbs(p, "Bogus settings at start of interrupt.");
6391 #endif
6392
6393   /*
6394    * Handle all the interrupt sources - especially for SCSI
6395    * interrupts, we won't get a second chance at them.
6396    */
6397   if (intstat & CMDCMPLT)
6398   {
6399     aic7xxx_handle_command_completion_intr(p);
6400   }
6401
6402   if (intstat & BRKADRINT)
6403   {
6404     int i;
6405     unsigned char errno = aic_inb(p, ERROR);
6406
6407     printk(KERN_ERR "(scsi%d) BRKADRINT error(0x%x):\n", p->host_no, errno);
6408     for (i = 0; i < ARRAY_SIZE(hard_error); i++)
6409     {
6410       if (errno & hard_error[i].errno)
6411       {
6412         printk(KERN_ERR "  %s\n", hard_error[i].errmesg);
6413       }
6414     }
6415     printk(KERN_ERR "(scsi%d)   SEQADDR=0x%x\n", p->host_no,
6416       (((aic_inb(p, SEQADDR1) << 8) & 0x100) | aic_inb(p, SEQADDR0)));
6417     if (aic7xxx_panic_on_abort)
6418       aic7xxx_panic_abort(p, NULL);
6419 #ifdef CONFIG_PCI
6420     if (errno & PCIERRSTAT)
6421       aic7xxx_pci_intr(p);
6422 #endif
6423     if (errno & (SQPARERR | ILLOPCODE | ILLSADDR))
6424     {
6425       panic("aic7xxx: unrecoverable BRKADRINT.\n");
6426     }
6427     if (errno & ILLHADDR)
6428     {
6429       printk(KERN_ERR "(scsi%d) BUG! Driver accessed chip without first "
6430              "pausing controller!\n", p->host_no);
6431     }
6432 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6433     if (errno & DPARERR)
6434     {
6435       if (aic_inb(p, DMAPARAMS) & DIRECTION)
6436         printk("(scsi%d) while DMAing SCB from host to card.\n", p->host_no);
6437       else
6438         printk("(scsi%d) while DMAing SCB from card to host.\n", p->host_no);
6439     }
6440 #endif
6441     aic_outb(p, CLRPARERR | CLRBRKADRINT, CLRINT);
6442     unpause_sequencer(p, FALSE);
6443   }
6444
6445   if (intstat & SEQINT)
6446   {
6447     /*
6448      * Read the CCSCBCTL register to work around a bug in the Ultra2 cards
6449      */
6450     if(p->features & AHC_ULTRA2)
6451     {
6452       aic_inb(p, CCSCBCTL);
6453     }
6454     aic7xxx_handle_seqint(p, intstat);
6455   }
6456
6457   if (intstat & SCSIINT)
6458   {
6459     aic7xxx_handle_scsiint(p, intstat);
6460   }
6461
6462 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6463   if ( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) &&
6464        (aic7xxx_panic_on_abort) && (p->flags & AHC_PAGESCBS) )
6465     aic7xxx_check_scbs(p, "Bogus settings at end of interrupt.");
6466 #endif
6467
6468 }
6469
6470 /*+F*************************************************************************
6471  * Function:
6472  *   do_aic7xxx_isr
6473  *
6474  * Description:
6475  *   This is a gross hack to solve a problem in linux kernels 2.1.85 and
6476  *   above.  Please, children, do not try this at home, and if you ever see
6477  *   anything like it, please inform the Gross Hack Police immediately
6478  *-F*************************************************************************/
6479 static irqreturn_t
6480 do_aic7xxx_isr(int irq, void *dev_id)
6481 {
6482   unsigned long cpu_flags;
6483   struct aic7xxx_host *p;
6484   
6485   p = (struct aic7xxx_host *)dev_id;
6486   if(!p)
6487     return IRQ_NONE;
6488   spin_lock_irqsave(p->host->host_lock, cpu_flags);
6489   p->flags |= AHC_IN_ISR;
6490   do
6491   {
6492     aic7xxx_isr(irq, dev_id);
6493   } while ( (aic_inb(p, INTSTAT) & INT_PEND) );
6494   aic7xxx_done_cmds_complete(p);
6495   aic7xxx_run_waiting_queues(p);
6496   p->flags &= ~AHC_IN_ISR;
6497   spin_unlock_irqrestore(p->host->host_lock, cpu_flags);
6498
6499   return IRQ_HANDLED;
6500 }
6501
6502 /*+F*************************************************************************
6503  * Function:
6504  *   aic7xxx_init_transinfo
6505  *
6506  * Description:
6507  *   Set up the initial aic_dev values from the BIOS settings and from
6508  *   INQUIRY results
6509  *-F*************************************************************************/
6510 static void
6511 aic7xxx_init_transinfo(struct aic7xxx_host *p, struct aic_dev_data *aic_dev)
6512 {
6513   struct scsi_device *sdpnt = aic_dev->SDptr;
6514   unsigned char tindex;
6515
6516   tindex = sdpnt->id | (sdpnt->channel << 3);
6517   if (!(aic_dev->flags & DEVICE_DTR_SCANNED))
6518   {
6519     aic_dev->flags |= DEVICE_DTR_SCANNED;
6520
6521     if ( sdpnt->wdtr && (p->features & AHC_WIDE) )
6522     {
6523       aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
6524       aic_dev->goal.width = p->user[tindex].width;
6525     }
6526     else
6527     {
6528       aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
6529       pause_sequencer(p);
6530       aic7xxx_set_width(p, sdpnt->id, sdpnt->channel, sdpnt->lun,
6531                         MSG_EXT_WDTR_BUS_8_BIT, (AHC_TRANS_ACTIVE |
6532                                                  AHC_TRANS_GOAL |
6533                                                  AHC_TRANS_CUR), aic_dev );
6534       unpause_sequencer(p, FALSE);
6535     }
6536     if ( sdpnt->sdtr && p->user[tindex].offset )
6537     {
6538       aic_dev->goal.period = p->user[tindex].period;
6539       aic_dev->goal.options = p->user[tindex].options;
6540       if (p->features & AHC_ULTRA2)
6541         aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
6542       else if (aic_dev->goal.width == MSG_EXT_WDTR_BUS_16_BIT)
6543         aic_dev->goal.offset = MAX_OFFSET_16BIT;
6544       else
6545         aic_dev->goal.offset = MAX_OFFSET_8BIT;
6546       if ( sdpnt->ppr && p->user[tindex].period <= 9 &&
6547              p->user[tindex].options )
6548       {
6549         aic_dev->needppr = aic_dev->needppr_copy = 1;
6550         aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
6551         aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
6552         aic_dev->flags |= DEVICE_SCSI_3;
6553       }
6554       else
6555       {
6556         aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
6557         aic_dev->goal.period = max_t(unsigned char, 10, aic_dev->goal.period);
6558         aic_dev->goal.options = 0;
6559       }
6560     }
6561     else
6562     {
6563       aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
6564       aic_dev->goal.period = 255;
6565       aic_dev->goal.offset = 0;
6566       aic_dev->goal.options = 0;
6567     }
6568     aic_dev->flags |= DEVICE_PRINT_DTR;
6569   }
6570 }
6571
6572 /*+F*************************************************************************
6573  * Function:
6574  *   aic7xxx_slave_alloc
6575  *
6576  * Description:
6577  *   Set up the initial aic_dev struct pointers
6578  *-F*************************************************************************/
6579 static int
6580 aic7xxx_slave_alloc(struct scsi_device *SDptr)
6581 {
6582   struct aic7xxx_host *p = (struct aic7xxx_host *)SDptr->host->hostdata;
6583   struct aic_dev_data *aic_dev;
6584
6585   aic_dev = kmalloc(sizeof(struct aic_dev_data), GFP_ATOMIC | GFP_KERNEL);
6586   if(!aic_dev)
6587     return 1;
6588   /*
6589    * Check to see if channel was scanned.
6590    */
6591   
6592   if (!(p->flags & AHC_A_SCANNED) && (SDptr->channel == 0))
6593   {
6594     if (aic7xxx_verbose & VERBOSE_PROBE2)
6595       printk(INFO_LEAD "Scanning channel for devices.\n",
6596         p->host_no, 0, -1, -1);
6597     p->flags |= AHC_A_SCANNED;
6598   }
6599   else
6600   {
6601     if (!(p->flags & AHC_B_SCANNED) && (SDptr->channel == 1))
6602     {
6603       if (aic7xxx_verbose & VERBOSE_PROBE2)
6604         printk(INFO_LEAD "Scanning channel for devices.\n",
6605           p->host_no, 1, -1, -1);
6606       p->flags |= AHC_B_SCANNED;
6607     }
6608   }
6609
6610   memset(aic_dev, 0, sizeof(struct aic_dev_data));
6611   SDptr->hostdata = aic_dev;
6612   aic_dev->SDptr = SDptr;
6613   aic_dev->max_q_depth = 1;
6614   aic_dev->temp_q_depth = 1;
6615   scbq_init(&aic_dev->delayed_scbs);
6616   INIT_LIST_HEAD(&aic_dev->list);
6617   list_add_tail(&aic_dev->list, &p->aic_devs);
6618   return 0;
6619 }
6620
6621 /*+F*************************************************************************
6622  * Function:
6623  *   aic7xxx_device_queue_depth
6624  *
6625  * Description:
6626  *   Determines the queue depth for a given device.  There are two ways
6627  *   a queue depth can be obtained for a tagged queueing device.  One
6628  *   way is the default queue depth which is determined by whether
6629  *   aic7xxx_default_queue_depth.  The other is by the aic7xxx_tag_info
6630  *   array.
6631  *
6632  *   If tagged queueing isn't supported on the device, then we set the
6633  *   depth to p->host->hostt->cmd_per_lun for internal driver queueing.
6634  *   as the default queue depth.  Otherwise, we use either 4 or 8 as the
6635  *   default queue depth (dependent on the number of hardware SCBs).
6636  *   The other way we determine queue depth is through the use of the
6637  *   aic7xxx_tag_info array which is enabled by defining
6638  *   AIC7XXX_TAGGED_QUEUEING_BY_DEVICE.  This array can be initialized
6639  *   with queue depths for individual devices.  It also allows tagged
6640  *   queueing to be [en|dis]abled for a specific adapter.
6641  *-F*************************************************************************/
6642 static void
6643 aic7xxx_device_queue_depth(struct aic7xxx_host *p, struct scsi_device *device)
6644 {
6645   int tag_enabled = FALSE;
6646   struct aic_dev_data *aic_dev = device->hostdata;
6647   unsigned char tindex;
6648
6649   tindex = device->id | (device->channel << 3);
6650
6651   if (device->simple_tags)
6652     return; // We've already enabled this device
6653
6654   if (device->tagged_supported)
6655   {
6656     tag_enabled = TRUE;
6657
6658     if (!(p->discenable & (1 << tindex)))
6659     {
6660       if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
6661         printk(INFO_LEAD "Disconnection disabled, unable to "
6662              "enable tagged queueing.\n",
6663              p->host_no, device->channel, device->id, device->lun);
6664       tag_enabled = FALSE;
6665     }
6666     else
6667     {
6668       if (p->instance >= ARRAY_SIZE(aic7xxx_tag_info))
6669       {
6670         static int print_warning = TRUE;
6671         if(print_warning)
6672         {
6673           printk(KERN_INFO "aic7xxx: WARNING, insufficient tag_info instances for"
6674                            " installed controllers.\n");
6675           printk(KERN_INFO "aic7xxx: Please update the aic7xxx_tag_info array in"
6676                            " the aic7xxx.c source file.\n");
6677           print_warning = FALSE;
6678         }
6679         aic_dev->max_q_depth = aic_dev->temp_q_depth =
6680                 aic7xxx_default_queue_depth;
6681       }
6682       else
6683       {
6684
6685         if (aic7xxx_tag_info[p->instance].tag_commands[tindex] == 255)
6686         {
6687           tag_enabled = FALSE;
6688         }
6689         else if (aic7xxx_tag_info[p->instance].tag_commands[tindex] == 0)
6690         {
6691           aic_dev->max_q_depth = aic_dev->temp_q_depth =
6692                   aic7xxx_default_queue_depth;
6693         }
6694         else
6695         {
6696           aic_dev->max_q_depth = aic_dev->temp_q_depth = 
6697             aic7xxx_tag_info[p->instance].tag_commands[tindex];
6698         }
6699       }
6700     }
6701   }
6702   if (tag_enabled)
6703   {
6704     if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
6705     {
6706           printk(INFO_LEAD "Tagged queuing enabled, queue depth %d.\n",
6707             p->host_no, device->channel, device->id,
6708