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/version.h>
 228 #include <linux/string.h>
 229 #include <linux/errno.h>
 230 #include <linux/kernel.h>
 231 #include <linux/ioport.h>
 232 #include <linux/delay.h>
 233 #include <linux/sched.h>
 234 #include <linux/pci.h>
 235 #include <linux/proc_fs.h>
 236 #include <linux/blkdev.h>
 237 #include <linux/init.h>
 238 #include <linux/spinlock.h>
 239 #include <linux/smp.h>
 240 #include <linux/interrupt.h>
 241 #include "scsi.h"
 242 #include "hosts.h"
 243 #include "aic7xxx_old/aic7xxx.h"
 244
 245 #include "aic7xxx_old/sequencer.h"
 246 #include "aic7xxx_old/scsi_message.h"
 247 #include "aic7xxx_old/aic7xxx_reg.h"
 248 #include <scsi/scsicam.h>
 249
 250 #include <linux/stat.h>
 251 #include <linux/slab.h>        /* for kmalloc() */
 252
 253 #include <linux/config.h>        /* for CONFIG_PCI */
 254
 255 #define AIC7XXX_C_VERSION  "5.2.6"
 256
 257 #define ALL_TARGETS -1
 258 #define ALL_CHANNELS -1
 259 #define ALL_LUNS -1
 260 #define MAX_TARGETS  16
 261 #define MAX_LUNS     8
 262 #ifndef TRUE
 263 #  define TRUE 1
 264 #endif
 265 #ifndef FALSE
 266 #  define FALSE 0
 267 #endif
 268
 269 #if defined(__powerpc__) || defined(__i386__) || defined(__x86_64__)
 270 #  define MMAPIO
 271 #endif
 272
 273 /*
 274  * You can try raising me for better performance or lowering me if you have
 275  * flaky devices that go off the scsi bus when hit with too many tagged
 276  * commands (like some IBM SCSI-3 LVD drives).
 277  */
 278 #define AIC7XXX_CMDS_PER_DEVICE 32
 279
 280 typedef struct
 281 {
 282   unsigned char tag_commands[16];   /* Allow for wide/twin adapters. */
 283 } adapter_tag_info_t;
 284
 285 /*
 286  * Make a define that will tell the driver not to the default tag depth
 287  * everywhere.
 288  */
 289 #define DEFAULT_TAG_COMMANDS {0, 0, 0, 0, 0, 0, 0, 0,\
 290                               0, 0, 0, 0, 0, 0, 0, 0}
 291
 292 /*
 293  * Modify this as you see fit for your system.  By setting tag_commands
 294  * to 0, the driver will use it's own algorithm for determining the
 295  * number of commands to use (see above).  When 255, the driver will
 296  * not enable tagged queueing for that particular device.  When positive
 297  * (> 0) and (< 255) the values in the array are used for the queue_depth.
 298  * Note that the maximum value for an entry is 254, but you're insane if
 299  * you try to use that many commands on one device.
 300  *
 301  * In this example, the first line will disable tagged queueing for all
 302  * the devices on the first probed aic7xxx adapter.
 303  *
 304  * The second line enables tagged queueing with 4 commands/LUN for IDs
 305  * (1, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
 306  * driver to use its own algorithm for ID 1.
 307  *
 308  * The third line is the same as the first line.
 309  *
 310  * The fourth line disables tagged queueing for devices 0 and 3.  It
 311  * enables tagged queueing for the other IDs, with 16 commands/LUN
 312  * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
 313  * IDs 2, 5-7, and 9-15.
 314  */
 315
 316 /*
 317  * NOTE: The below structure is for reference only, the actual structure
 318  *       to modify in order to change things is found after this fake one.
 319  *
 320 adapter_tag_info_t aic7xxx_tag_info[] =
 321 {
 322   {DEFAULT_TAG_COMMANDS},
 323   {{4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 255, 4, 4, 4}},
 324   {DEFAULT_TAG_COMMANDS},
 325   {{255, 16, 4, 255, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
 326 };
 327 */
 328
 329 static adapter_tag_info_t aic7xxx_tag_info[] =
 330 {
 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   {DEFAULT_TAG_COMMANDS},
 345   {DEFAULT_TAG_COMMANDS},
 346   {DEFAULT_TAG_COMMANDS}
 347 };
 348
 349
 350 /*
 351  * Define an array of board names that can be indexed by aha_type.
 352  * Don't forget to change this when changing the types!
 353  */
 354 static const char *board_names[] = {
 355   "AIC-7xxx Unknown",                                   /* AIC_NONE */
 356   "Adaptec AIC-7810 Hardware RAID Controller",          /* AIC_7810 */
 357   "Adaptec AIC-7770 SCSI host adapter",                 /* AIC_7770 */
 358   "Adaptec AHA-274X SCSI host adapter",                 /* AIC_7771 */
 359   "Adaptec AHA-284X SCSI host adapter",                 /* AIC_284x */
 360   "Adaptec AIC-7850 SCSI host adapter",                 /* AIC_7850 */
 361   "Adaptec AIC-7855 SCSI host adapter",                 /* AIC_7855 */
 362   "Adaptec AIC-7860 Ultra SCSI host adapter",           /* AIC_7860 */
 363   "Adaptec AHA-2940A Ultra SCSI host adapter",          /* AIC_7861 */
 364   "Adaptec AIC-7870 SCSI host adapter",                 /* AIC_7870 */
 365   "Adaptec AHA-294X SCSI host adapter",                 /* AIC_7871 */
 366   "Adaptec AHA-394X SCSI host adapter",                 /* AIC_7872 */
 367   "Adaptec AHA-398X SCSI host adapter",                 /* AIC_7873 */
 368   "Adaptec AHA-2944 SCSI host adapter",                 /* AIC_7874 */
 369   "Adaptec AIC-7880 Ultra SCSI host adapter",           /* AIC_7880 */
 370   "Adaptec AHA-294X Ultra SCSI host adapter",           /* AIC_7881 */
 371   "Adaptec AHA-394X Ultra SCSI host adapter",           /* AIC_7882 */
 372   "Adaptec AHA-398X Ultra SCSI host adapter",           /* AIC_7883 */
 373   "Adaptec AHA-2944 Ultra SCSI host adapter",           /* AIC_7884 */
 374   "Adaptec AHA-2940UW Pro Ultra SCSI host adapter",     /* AIC_7887 */
 375   "Adaptec AIC-7895 Ultra SCSI host adapter",           /* AIC_7895 */
 376   "Adaptec AIC-7890/1 Ultra2 SCSI host adapter",        /* AIC_7890 */
 377   "Adaptec AHA-293X Ultra2 SCSI host adapter",          /* AIC_7890 */
 378   "Adaptec AHA-294X Ultra2 SCSI host adapter",          /* AIC_7890 */
 379   "Adaptec AIC-7896/7 Ultra2 SCSI host adapter",        /* AIC_7896 */
 380   "Adaptec AHA-394X Ultra2 SCSI host adapter",          /* AIC_7897 */
 381   "Adaptec AHA-395X Ultra2 SCSI host adapter",          /* AIC_7897 */
 382   "Adaptec PCMCIA SCSI controller",                     /* card bus stuff */
 383   "Adaptec AIC-7892 Ultra 160/m SCSI host adapter",     /* AIC_7892 */
 384   "Adaptec AIC-7899 Ultra 160/m SCSI host adapter",     /* AIC_7899 */
 385 };
 386
 387 /*
 388  * There should be a specific return value for this in scsi.h, but
 389  * it seems that most drivers ignore it.
 390  */
 391 #define DID_UNDERFLOW   DID_ERROR
 392
 393 /*
 394  *  What we want to do is have the higher level scsi driver requeue
 395  *  the command to us. There is no specific driver status for this
 396  *  condition, but the higher level scsi driver will requeue the
 397  *  command on a DID_BUS_BUSY error.
 398  *
 399  *  Upon further inspection and testing, it seems that DID_BUS_BUSY
 400  *  will *always* retry the command.  We can get into an infinite loop
 401  *  if this happens when we really want some sort of counter that
 402  *  will automatically abort/reset the command after so many retries.
 403  *  Using DID_ERROR will do just that.  (Made by a suggestion by
 404  *  Doug Ledford 8/1/96)
 405  */
 406 #define DID_RETRY_COMMAND DID_ERROR
 407
 408 #define HSCSIID        0x07
 409 #define SCSI_RESET     0x040
 410
 411 /*
 412  * EISA/VL-bus stuff
 413  */
 414 #define MINSLOT                1
 415 #define MAXSLOT                15
 416 #define SLOTBASE(x)        ((x) << 12)
 417 #define BASE_TO_SLOT(x) ((x) >> 12)
 418
 419 /*
 420  * Standard EISA Host ID regs  (Offset from slot base)
 421  */
 422 #define AHC_HID0              0x80   /* 0,1: msb of ID2, 2-7: ID1      */
 423 #define AHC_HID1              0x81   /* 0-4: ID3, 5-7: LSB ID2         */
 424 #define AHC_HID2              0x82   /* product                        */
 425 #define AHC_HID3              0x83   /* firmware revision              */
 426
 427 /*
 428  * AIC-7770 I/O range to reserve for a card
 429  */
 430 #define MINREG                0xC00
 431 #define MAXREG                0xCFF
 432
 433 #define INTDEF                0x5C      /* Interrupt Definition Register */
 434
 435 /*
 436  * AIC-78X0 PCI registers
 437  */
 438 #define        CLASS_PROGIF_REVID        0x08
 439 #define                DEVREVID        0x000000FFul
 440 #define                PROGINFC        0x0000FF00ul
 441 #define                SUBCLASS        0x00FF0000ul
 442 #define                BASECLASS        0xFF000000ul
 443
 444 #define        CSIZE_LATTIME                0x0C
 445 #define                CACHESIZE        0x0000003Ful        /* only 5 bits */
 446 #define                LATTIME                0x0000FF00ul
 447
 448 #define        DEVCONFIG                0x40
 449 #define                SCBSIZE32        0x00010000ul        /* aic789X only */
 450 #define                MPORTMODE        0x00000400ul        /* aic7870 only */
 451 #define                RAMPSM           0x00000200ul        /* aic7870 only */
 452 #define                RAMPSM_ULTRA2    0x00000004
 453 #define                VOLSENSE         0x00000100ul
 454 #define                SCBRAMSEL        0x00000080ul
 455 #define                SCBRAMSEL_ULTRA2 0x00000008
 456 #define                MRDCEN           0x00000040ul
 457 #define                EXTSCBTIME       0x00000020ul        /* aic7870 only */
 458 #define                EXTSCBPEN        0x00000010ul        /* aic7870 only */
 459 #define                BERREN           0x00000008ul
 460 #define                DACEN            0x00000004ul
 461 #define                STPWLEVEL        0x00000002ul
 462 #define                DIFACTNEGEN      0x00000001ul        /* aic7870 only */
 463
 464 #define        SCAMCTL                  0x1a                /* Ultra2 only  */
 465 #define        CCSCBBADDR               0xf0                /* aic7895/6/7  */
 466
 467 /*
 468  * Define the different types of SEEPROMs on aic7xxx adapters
 469  * and make it also represent the address size used in accessing
 470  * its registers.  The 93C46 chips have 1024 bits organized into
 471  * 64 16-bit words, while the 93C56 chips have 2048 bits organized
 472  * into 128 16-bit words.  The C46 chips use 6 bits to address
 473  * each word, while the C56 and C66 (4096 bits) use 8 bits to
 474  * address each word.
 475  */
 476 typedef enum {C46 = 6, C56_66 = 8} seeprom_chip_type;
 477
 478 /*
 479  *
 480  * Define the format of the SEEPROM registers (16 bits).
 481  *
 482  */
 483 struct seeprom_config {
 484
 485 /*
 486  * SCSI ID Configuration Flags
 487  */
 488 #define CFXFER                0x0007      /* synchronous transfer rate */
 489 #define CFSYNCH               0x0008      /* enable synchronous transfer */
 490 #define CFDISC                0x0010      /* enable disconnection */
 491 #define CFWIDEB               0x0020      /* wide bus device (wide card) */
 492 #define CFSYNCHISULTRA        0x0040      /* CFSYNC is an ultra offset */
 493 #define CFNEWULTRAFORMAT      0x0080      /* Use the Ultra2 SEEPROM format */
 494 #define CFSTART               0x0100      /* send start unit SCSI command */
 495 #define CFINCBIOS             0x0200      /* include in BIOS scan */
 496 #define CFRNFOUND             0x0400      /* report even if not found */
 497 #define CFMULTILUN            0x0800      /* probe mult luns in BIOS scan */
 498 #define CFWBCACHEYES          0x4000      /* Enable W-Behind Cache on drive */
 499 #define CFWBCACHENC           0xc000      /* Don't change W-Behind Cache */
 500 /* UNUSED                0x3000 */
 501   unsigned short device_flags[16];        /* words 0-15 */
 502
 503 /*
 504  * BIOS Control Bits
 505  */
 506 #define CFSUPREM        0x0001  /* support all removable drives */
 507 #define CFSUPREMB       0x0002  /* support removable drives for boot only */
 508 #define CFBIOSEN        0x0004  /* BIOS enabled */
 509 /* UNUSED                0x0008 */
 510 #define CFSM2DRV        0x0010  /* support more than two drives */
 511 #define CF284XEXTEND    0x0020  /* extended translation (284x cards) */
 512 /* UNUSED                0x0040 */
 513 #define CFEXTEND        0x0080  /* extended translation enabled */
 514 /* UNUSED                0xFF00 */
 515   unsigned short bios_control;  /* word 16 */
 516
 517 /*
 518  * Host Adapter Control Bits
 519  */
 520 #define CFAUTOTERM      0x0001  /* Perform Auto termination */
 521 #define CFULTRAEN       0x0002  /* Ultra SCSI speed enable (Ultra cards) */
 522 #define CF284XSELTO     0x0003  /* Selection timeout (284x cards) */
 523 #define CF284XFIFO      0x000C  /* FIFO Threshold (284x cards) */
 524 #define CFSTERM         0x0004  /* SCSI low byte termination */
 525 #define CFWSTERM        0x0008  /* SCSI high byte termination (wide card) */
 526 #define CFSPARITY       0x0010  /* SCSI parity */
 527 #define CF284XSTERM     0x0020  /* SCSI low byte termination (284x cards) */
 528 #define CFRESETB        0x0040  /* reset SCSI bus at boot */
 529 #define CFBPRIMARY      0x0100  /* Channel B primary on 7895 chipsets */
 530 #define CFSEAUTOTERM    0x0400  /* aic7890 Perform SE Auto Term */
 531 #define CFLVDSTERM      0x0800  /* aic7890 LVD Termination */
 532 /* UNUSED                0xF280 */
 533   unsigned short adapter_control;        /* word 17 */
 534
 535 /*
 536  * Bus Release, Host Adapter ID
 537  */
 538 #define CFSCSIID        0x000F                /* host adapter SCSI ID */
 539 /* UNUSED                0x00F0 */
 540 #define CFBRTIME        0xFF00                /* bus release time */
 541   unsigned short brtime_id;                /* word 18 */
 542
 543 /*
 544  * Maximum targets
 545  */
 546 #define CFMAXTARG        0x00FF        /* maximum targets */
 547 /* UNUSED                0xFF00 */
 548   unsigned short max_targets;                /* word 19 */
 549
 550   unsigned short res_1[11];                /* words 20-30 */
 551   unsigned short checksum;                /* word 31 */
 552 };
 553
 554 #define SELBUS_MASK                0x0a
 555 #define         SELNARROW        0x00
 556 #define         SELBUSB                0x08
 557 #define SINGLE_BUS                0x00
 558
 559 #define SCB_TARGET(scb)         \
 560        (((scb)->hscb->target_channel_lun & TID) >> 4)
 561 #define SCB_LUN(scb)            \
 562        ((scb)->hscb->target_channel_lun & LID)
 563 #define SCB_IS_SCSIBUS_B(scb)   \
 564        (((scb)->hscb->target_channel_lun & SELBUSB) != 0)
 565
 566 /*
 567  * If an error occurs during a data transfer phase, run the command
 568  * to completion - it's easier that way - making a note of the error
 569  * condition in this location. This then will modify a DID_OK status
 570  * into an appropriate error for the higher-level SCSI code.
 571  */
 572 #define aic7xxx_error(cmd)        ((cmd)->SCp.Status)
 573
 574 /*
 575  * Keep track of the targets returned status.
 576  */
 577 #define aic7xxx_status(cmd)        ((cmd)->SCp.sent_command)
 578
 579 /*
 580  * The position of the SCSI commands scb within the scb array.
 581  */
 582 #define aic7xxx_position(cmd)        ((cmd)->SCp.have_data_in)
 583
 584 /*
 585  * The stored DMA mapping for single-buffer data transfers.
 586  */
 587 #define aic7xxx_mapping(cmd)         ((cmd)->SCp.phase)
 588
 589 /*
 590  * Get out private data area from a scsi cmd pointer
 591  */
 592 #define AIC_DEV(cmd)    ((struct aic_dev_data *)(cmd)->device->hostdata)
 593
 594 /*
 595  * So we can keep track of our host structs
 596  */
 597 static struct aic7xxx_host *first_aic7xxx = NULL;
 598
 599 /*
 600  * As of Linux 2.1, the mid-level SCSI code uses virtual addresses
 601  * in the scatter-gather lists.  We need to convert the virtual
 602  * addresses to physical addresses.
 603  */
 604 struct hw_scatterlist {
 605   unsigned int address;
 606   unsigned int length;
 607 };
 608
 609 /*
 610  * Maximum number of SG segments these cards can support.
 611  */
 612 #define        AIC7XXX_MAX_SG 128
 613
 614 /*
 615  * The maximum number of SCBs we could have for ANY type
 616  * of card. DON'T FORGET TO CHANGE THE SCB MASK IN THE
 617  * SEQUENCER CODE IF THIS IS MODIFIED!
 618  */
 619 #define AIC7XXX_MAXSCB        255
 620
 621
 622 struct aic7xxx_hwscb {
 623 /* ------------    Begin hardware supported fields    ---------------- */
 624 /* 0*/  unsigned char control;
 625 /* 1*/  unsigned char target_channel_lun;       /* 4/1/3 bits */
 626 /* 2*/  unsigned char target_status;
 627 /* 3*/  unsigned char SG_segment_count;
 628 /* 4*/  unsigned int  SG_list_pointer;
 629 /* 8*/  unsigned char residual_SG_segment_count;
 630 /* 9*/  unsigned char residual_data_count[3];
 631 /*12*/  unsigned int  data_pointer;
 632 /*16*/  unsigned int  data_count;
 633 /*20*/  unsigned int  SCSI_cmd_pointer;
 634 /*24*/  unsigned char SCSI_cmd_length;
 635 /*25*/  unsigned char tag;          /* Index into our kernel SCB array.
 636                                      * Also used as the tag for tagged I/O
 637                                      */
 638 #define SCB_PIO_TRANSFER_SIZE  26   /* amount we need to upload/download
 639                                      * via PIO to initialize a transaction.
 640                                      */
 641 /*26*/  unsigned char next;         /* Used to thread SCBs awaiting selection
 642                                      * or disconnected down in the sequencer.
 643                                      */
 644 /*27*/  unsigned char prev;
 645 /*28*/  unsigned int pad;           /*
 646                                      * Unused by the kernel, but we require
 647                                      * the padding so that the array of
 648                                      * hardware SCBs is aligned on 32 byte
 649                                      * boundaries so the sequencer can index
 650                                      */
 651 };
 652
 653 typedef enum {
 654         SCB_FREE                = 0x0000,
 655         SCB_DTR_SCB             = 0x0001,
 656         SCB_WAITINGQ            = 0x0002,
 657         SCB_ACTIVE              = 0x0004,
 658         SCB_SENSE               = 0x0008,
 659         SCB_ABORT               = 0x0010,
 660         SCB_DEVICE_RESET        = 0x0020,
 661         SCB_RESET               = 0x0040,
 662         SCB_RECOVERY_SCB        = 0x0080,
 663         SCB_MSGOUT_PPR          = 0x0100,
 664         SCB_MSGOUT_SENT         = 0x0200,
 665         SCB_MSGOUT_SDTR         = 0x0400,
 666         SCB_MSGOUT_WDTR         = 0x0800,
 667         SCB_MSGOUT_BITS         = SCB_MSGOUT_PPR |
 668                                   SCB_MSGOUT_SENT |
 669                                   SCB_MSGOUT_SDTR |
 670                                   SCB_MSGOUT_WDTR,
 671         SCB_QUEUED_ABORT        = 0x1000,
 672         SCB_QUEUED_FOR_DONE     = 0x2000,
 673         SCB_WAS_BUSY            = 0x4000,
 674         SCB_QUEUE_FULL          = 0x8000
 675 } scb_flag_type;
 676
 677 typedef enum {
 678         AHC_FNONE                 = 0x00000000,
 679         AHC_PAGESCBS              = 0x00000001,
 680         AHC_CHANNEL_B_PRIMARY     = 0x00000002,
 681         AHC_USEDEFAULTS           = 0x00000004,
 682         AHC_INDIRECT_PAGING       = 0x00000008,
 683         AHC_CHNLB                 = 0x00000020,
 684         AHC_CHNLC                 = 0x00000040,
 685         AHC_EXTEND_TRANS_A        = 0x00000100,
 686         AHC_EXTEND_TRANS_B        = 0x00000200,
 687         AHC_TERM_ENB_A            = 0x00000400,
 688         AHC_TERM_ENB_SE_LOW       = 0x00000400,
 689         AHC_TERM_ENB_B            = 0x00000800,
 690         AHC_TERM_ENB_SE_HIGH      = 0x00000800,
 691         AHC_HANDLING_REQINITS     = 0x00001000,
 692         AHC_TARGETMODE            = 0x00002000,
 693         AHC_NEWEEPROM_FMT         = 0x00004000,
 694  /*
 695   *  Here ends the FreeBSD defined flags and here begins the linux defined
 696   *  flags.  NOTE: I did not preserve the old flag name during this change
 697   *  specifically to force me to evaluate what flags were being used properly
 698   *  and what flags weren't.  This way, I could clean up the flag usage on
 699   *  a use by use basis.  Doug Ledford
 700   */
 701         AHC_MOTHERBOARD           = 0x00020000,
 702         AHC_NO_STPWEN             = 0x00040000,
 703         AHC_RESET_DELAY           = 0x00080000,
 704         AHC_A_SCANNED             = 0x00100000,
 705         AHC_B_SCANNED             = 0x00200000,
 706         AHC_MULTI_CHANNEL         = 0x00400000,
 707         AHC_BIOS_ENABLED          = 0x00800000,
 708         AHC_SEEPROM_FOUND         = 0x01000000,
 709         AHC_TERM_ENB_LVD          = 0x02000000,
 710         AHC_ABORT_PENDING         = 0x04000000,
 711         AHC_RESET_PENDING         = 0x08000000,
 712 #define AHC_IN_ISR_BIT              28
 713         AHC_IN_ISR                = 0x10000000,
 714         AHC_IN_ABORT              = 0x20000000,
 715         AHC_IN_RESET              = 0x40000000,
 716         AHC_EXTERNAL_SRAM         = 0x80000000
 717 } ahc_flag_type;
 718
 719 typedef enum {
 720   AHC_NONE             = 0x0000,
 721   AHC_CHIPID_MASK      = 0x00ff,
 722   AHC_AIC7770          = 0x0001,
 723   AHC_AIC7850          = 0x0002,
 724   AHC_AIC7860          = 0x0003,
 725   AHC_AIC7870          = 0x0004,
 726   AHC_AIC7880          = 0x0005,
 727   AHC_AIC7890          = 0x0006,
 728   AHC_AIC7895          = 0x0007,
 729   AHC_AIC7896          = 0x0008,
 730   AHC_AIC7892          = 0x0009,
 731   AHC_AIC7899          = 0x000a,
 732   AHC_VL               = 0x0100,
 733   AHC_EISA             = 0x0200,
 734   AHC_PCI              = 0x0400,
 735 } ahc_chip;
 736
 737 typedef enum {
 738   AHC_FENONE           = 0x0000,
 739   AHC_ULTRA            = 0x0001,
 740   AHC_ULTRA2           = 0x0002,
 741   AHC_WIDE             = 0x0004,
 742   AHC_TWIN             = 0x0008,
 743   AHC_MORE_SRAM        = 0x0010,
 744   AHC_CMD_CHAN         = 0x0020,
 745   AHC_QUEUE_REGS       = 0x0040,
 746   AHC_SG_PRELOAD       = 0x0080,
 747   AHC_SPIOCAP          = 0x0100,
 748   AHC_ULTRA3           = 0x0200,
 749   AHC_NEW_AUTOTERM     = 0x0400,
 750   AHC_AIC7770_FE       = AHC_FENONE,
 751   AHC_AIC7850_FE       = AHC_SPIOCAP,
 752   AHC_AIC7860_FE       = AHC_ULTRA|AHC_SPIOCAP,
 753   AHC_AIC7870_FE       = AHC_FENONE,
 754   AHC_AIC7880_FE       = AHC_ULTRA,
 755   AHC_AIC7890_FE       = AHC_MORE_SRAM|AHC_CMD_CHAN|AHC_ULTRA2|
 756                          AHC_QUEUE_REGS|AHC_SG_PRELOAD|AHC_NEW_AUTOTERM,
 757   AHC_AIC7895_FE       = AHC_MORE_SRAM|AHC_CMD_CHAN|AHC_ULTRA,
 758   AHC_AIC7896_FE       = AHC_AIC7890_FE,
 759   AHC_AIC7892_FE       = AHC_AIC7890_FE|AHC_ULTRA3,
 760   AHC_AIC7899_FE       = AHC_AIC7890_FE|AHC_ULTRA3,
 761 } ahc_feature;
 762
 763 #define SCB_DMA_ADDR(scb, addr) ((unsigned long)(addr) + (scb)->scb_dma->dma_offset)
 764
 765 struct aic7xxx_scb_dma {
 766         unsigned long          dma_offset;    /* Correction you have to add
 767                                                * to virtual address to get
 768                                                * dma handle in this region */
 769         dma_addr_t             dma_address;   /* DMA handle of the start,
 770                                                * for unmap */
 771         unsigned int           dma_len;       /* DMA length */
 772 };
 773
 774 typedef enum {
 775   AHC_BUG_NONE            = 0x0000,
 776   AHC_BUG_TMODE_WIDEODD   = 0x0001,
 777   AHC_BUG_AUTOFLUSH       = 0x0002,
 778   AHC_BUG_CACHETHEN       = 0x0004,
 779   AHC_BUG_CACHETHEN_DIS   = 0x0008,
 780   AHC_BUG_PCI_2_1_RETRY   = 0x0010,
 781   AHC_BUG_PCI_MWI         = 0x0020,
 782   AHC_BUG_SCBCHAN_UPLOAD  = 0x0040,
 783 } ahc_bugs;
 784
 785 struct aic7xxx_scb {
 786         struct aic7xxx_hwscb  *hscb;          /* corresponding hardware scb */
 787         Scsi_Cmnd             *cmd;              /* Scsi_Cmnd for this scb */
 788         struct aic7xxx_scb    *q_next;        /* next scb in queue */
 789         volatile scb_flag_type flags;         /* current state of scb */
 790         struct hw_scatterlist *sg_list;       /* SG list in adapter format */
 791         unsigned char          tag_action;
 792         unsigned char          sg_count;
 793         unsigned char          *sense_cmd;    /*
 794                                                * Allocate 6 characters for
 795                                                * sense command.
 796                                                */
 797         unsigned char          *cmnd;
 798         unsigned int           sg_length; /* We init this during buildscb so we
 799                                            * don't have to calculate anything
 800                                            * during underflow/overflow/stat code
 801                                            */
 802         void                  *kmalloc_ptr;
 803         struct aic7xxx_scb_dma *scb_dma;
 804 };
 805
 806 /*
 807  * Define a linked list of SCBs.
 808  */
 809 typedef struct {
 810   struct aic7xxx_scb *head;
 811   struct aic7xxx_scb *tail;
 812 } scb_queue_type;
 813
 814 static struct {
 815   unsigned char errno;
 816   const char *errmesg;
 817 } hard_error[] = {
 818   { ILLHADDR,  "Illegal Host Access" },
 819   { ILLSADDR,  "Illegal Sequencer Address referenced" },
 820   { ILLOPCODE, "Illegal Opcode in sequencer program" },
 821   { SQPARERR,  "Sequencer Ram Parity Error" },
 822   { DPARERR,   "Data-Path Ram Parity Error" },
 823   { MPARERR,   "Scratch Ram/SCB Array Ram Parity Error" },
 824   { PCIERRSTAT,"PCI Error detected" },
 825   { CIOPARERR, "CIOBUS Parity Error" }
 826 };
 827
 828 static unsigned char
 829 generic_sense[] = { REQUEST_SENSE, 0, 0, 0, 255, 0 };
 830
 831 typedef struct {
 832   scb_queue_type free_scbs;        /*
 833                                     * SCBs assigned to free slot on
 834                                     * card (no paging required)
 835                                     */
 836   struct aic7xxx_scb   *scb_array[AIC7XXX_MAXSCB];
 837   struct aic7xxx_hwscb *hscbs;
 838   unsigned char  numscbs;          /* current number of scbs */
 839   unsigned char  maxhscbs;         /* hardware scbs */
 840   unsigned char  maxscbs;          /* max scbs including pageable scbs */
 841   dma_addr_t     hscbs_dma;        /* DMA handle to hscbs */
 842   unsigned int   hscbs_dma_len;    /* length of the above DMA area */
 843   void          *hscb_kmalloc_ptr;
 844 } scb_data_type;
 845
 846 struct target_cmd {
 847   unsigned char mesg_bytes[4];
 848   unsigned char command[28];
 849 };
 850
 851 #define AHC_TRANS_CUR    0x0001
 852 #define AHC_TRANS_ACTIVE 0x0002
 853 #define AHC_TRANS_GOAL   0x0004
 854 #define AHC_TRANS_USER   0x0008
 855 #define AHC_TRANS_QUITE  0x0010
 856 typedef struct {
 857   unsigned char width;
 858   unsigned char period;
 859   unsigned char offset;
 860   unsigned char options;
 861 } transinfo_type;
 862
 863 struct aic_dev_data {
 864   volatile scb_queue_type  delayed_scbs;
 865   volatile unsigned short  temp_q_depth;
 866   unsigned short           max_q_depth;
 867   volatile unsigned char   active_cmds;
 868   /*
 869    * Statistics Kept:
 870    *
 871    * Total Xfers (count for each command that has a data xfer),
 872    * broken down by reads && writes.
 873    *
 874    * Further sorted into a few bins for keeping tabs on how many commands
 875    * we get of various sizes.
 876    *
 877    */
 878   long w_total;                          /* total writes */
 879   long r_total;                          /* total reads */
 880   long barrier_total;                    /* total num of REQ_BARRIER commands */
 881   long ordered_total;                    /* How many REQ_BARRIER commands we
 882                                             used ordered tags to satisfy */
 883   long w_bins[6];                       /* binned write */
 884   long r_bins[6];                       /* binned reads */
 885   transinfo_type        cur;
 886   transinfo_type        goal;
 887 #define  BUS_DEVICE_RESET_PENDING       0x01
 888 #define  DEVICE_RESET_DELAY             0x02
 889 #define  DEVICE_PRINT_DTR               0x04
 890 #define  DEVICE_WAS_BUSY                0x08
 891 #define  DEVICE_DTR_SCANNED             0x10
 892 #define  DEVICE_SCSI_3                  0x20
 893   volatile unsigned char   flags;
 894   unsigned needppr:1;
 895   unsigned needppr_copy:1;
 896   unsigned needsdtr:1;
 897   unsigned needsdtr_copy:1;
 898   unsigned needwdtr:1;
 899   unsigned needwdtr_copy:1;
 900   unsigned dtr_pending:1;
 901   struct scsi_device *SDptr;
 902   struct list_head list;
 903 };
 904
 905 /*
 906  * Define a structure used for each host adapter.  Note, in order to avoid
 907  * problems with architectures I can't test on (because I don't have one,
 908  * such as the Alpha based systems) which happen to give faults for
 909  * non-aligned memory accesses, care was taken to align this structure
 910  * in a way that gauranteed all accesses larger than 8 bits were aligned
 911  * on the appropriate boundary.  It's also organized to try and be more
 912  * cache line efficient.  Be careful when changing this lest you might hurt
 913  * overall performance and bring down the wrath of the masses.
 914  */
 915 struct aic7xxx_host {
 916   /*
 917    *  This is the first 64 bytes in the host struct
 918    */
 919
 920   /*
 921    * We are grouping things here....first, items that get either read or
 922    * written with nearly every interrupt
 923    */
 924   volatile long            flags;
 925   ahc_feature              features;         /* chip features */
 926   unsigned long            base;             /* card base address */
 927   volatile unsigned char  *maddr;            /* memory mapped address */
 928   unsigned long            isr_count;        /* Interrupt count */
 929   unsigned long            spurious_int;
 930   scb_data_type           *scb_data;
 931   struct aic7xxx_cmd_queue {
 932     Scsi_Cmnd *head;
 933     Scsi_Cmnd *tail;
 934   } completeq;
 935
 936   /*
 937    * Things read/written on nearly every entry into aic7xxx_queue()
 938    */
 939   volatile scb_queue_type  waiting_scbs;
 940   unsigned char            unpause;          /* unpause value for HCNTRL */
 941   unsigned char            pause;            /* pause value for HCNTRL */
 942   volatile unsigned char   qoutfifonext;
 943   volatile unsigned char   activescbs;       /* active scbs */
 944   volatile unsigned char   max_activescbs;
 945   volatile unsigned char   qinfifonext;
 946   volatile unsigned char  *untagged_scbs;
 947   volatile unsigned char  *qoutfifo;
 948   volatile unsigned char  *qinfifo;
 949
 950   unsigned char            dev_last_queue_full[MAX_TARGETS];
 951   unsigned char            dev_last_queue_full_count[MAX_TARGETS];
 952   unsigned short           ultraenb;         /* Gets downloaded to card as a
 953                                                 bitmap */
 954   unsigned short           discenable;       /* Gets downloaded to card as a
 955                                                 bitmap */
 956   transinfo_type           user[MAX_TARGETS];
 957
 958   unsigned char            msg_buf[13];      /* The message for the target */
 959   unsigned char            msg_type;
 960 #define MSG_TYPE_NONE              0x00
 961 #define MSG_TYPE_INITIATOR_MSGOUT  0x01
 962 #define MSG_TYPE_INITIATOR_MSGIN   0x02
 963   unsigned char            msg_len;          /* Length of message */
 964   unsigned char            msg_index;        /* Index into msg_buf array */
 965
 966
 967   /*
 968    * We put the less frequently used host structure items after the more
 969    * frequently used items to try and ease the burden on the cache subsystem.
 970    * These entries are not *commonly* accessed, whereas the preceding entries
 971    * are accessed very often.
 972    */
 973
 974   unsigned int             irq;              /* IRQ for this adapter */
 975   int                      instance;         /* aic7xxx instance number */
 976   int                      scsi_id;          /* host adapter SCSI ID */
 977   int                      scsi_id_b;        /* channel B for twin adapters */
 978   unsigned int             bios_address;
 979   int                      board_name_index;
 980   unsigned short           bios_control;     /* bios control - SEEPROM */
 981   unsigned short           adapter_control;  /* adapter control - SEEPROM */
 982   struct pci_dev          *pdev;
 983   unsigned char            pci_bus;
 984   unsigned char            pci_device_fn;
 985   struct seeprom_config    sc;
 986   unsigned short           sc_type;
 987   unsigned short           sc_size;
 988   struct aic7xxx_host     *next;             /* allow for multiple IRQs */
 989   struct Scsi_Host        *host;             /* pointer to scsi host */
 990   struct list_head         aic_devs;         /* all aic_dev structs on host */
 991   int                      host_no;          /* SCSI host number */
 992   unsigned long            mbase;            /* I/O memory address */
 993   ahc_chip                 chip;             /* chip type */
 994   ahc_bugs                 bugs;
 995   dma_addr_t               fifo_dma;         /* DMA handle for fifo arrays */
 996
 997 };
 998
 999 /*
1000  * Valid SCSIRATE values. (p. 3-17)
1001  * Provides a mapping of transfer periods in ns/4 to the proper value to
1002  * stick in the SCSIRATE reg to use that transfer rate.
1003  */
1004 #define AHC_SYNCRATE_ULTRA3 0
1005 #define AHC_SYNCRATE_ULTRA2 1
1006 #define AHC_SYNCRATE_ULTRA  3
1007 #define AHC_SYNCRATE_FAST   6
1008 #define AHC_SYNCRATE_CRC 0x40
1009 #define AHC_SYNCRATE_SE  0x10
1010 static struct aic7xxx_syncrate {
1011   /* Rates in Ultra mode have bit 8 of sxfr set */
1012 #define                ULTRA_SXFR 0x100
1013   int sxfr_ultra2;
1014   int sxfr;
1015   unsigned char period;
1016   const char *rate[2];
1017 } aic7xxx_syncrates[] = {
1018   { 0x42,  0x000,   9,  {"80.0", "160.0"} },
1019   { 0x13,  0x000,  10,  {"40.0", "80.0"} },
1020   { 0x14,  0x000,  11,  {"33.0", "66.6"} },
1021   { 0x15,  0x100,  12,  {"20.0", "40.0"} },
1022   { 0x16,  0x110,  15,  {"16.0", "32.0"} },
1023   { 0x17,  0x120,  18,  {"13.4", "26.8"} },
1024   { 0x18,  0x000,  25,  {"10.0", "20.0"} },
1025   { 0x19,  0x010,  31,  {"8.0",  "16.0"} },
1026   { 0x1a,  0x020,  37,  {"6.67", "13.3"} },
1027   { 0x1b,  0x030,  43,  {"5.7",  "11.4"} },
1028   { 0x10,  0x040,  50,  {"5.0",  "10.0"} },
1029   { 0x00,  0x050,  56,  {"4.4",  "8.8" } },
1030   { 0x00,  0x060,  62,  {"4.0",  "8.0" } },
1031   { 0x00,  0x070,  68,  {"3.6",  "7.2" } },
1032   { 0x00,  0x000,  0,   {NULL, NULL}   },
1033 };
1034
1035 #define CTL_OF_SCB(scb) (((scb->hscb)->target_channel_lun >> 3) & 0x1),  \
1036                         (((scb->hscb)->target_channel_lun >> 4) & 0xf), \
1037                         ((scb->hscb)->target_channel_lun & 0x07)
1038
1039 #define CTL_OF_CMD(cmd) ((cmd->device->channel) & 0x01),  \
1040                         ((cmd->device->id) & 0x0f), \
1041                         ((cmd->device->lun) & 0x07)
1042
1043 #define TARGET_INDEX(cmd)  ((cmd)->device->id | ((cmd)->device->channel << 3))
1044
1045 /*
1046  * A nice little define to make doing our printks a little easier
1047  */
1048
1049 #define WARN_LEAD KERN_WARNING "(scsi%d:%d:%d:%d) "
1050 #define INFO_LEAD KERN_INFO "(scsi%d:%d:%d:%d) "
1051
1052 /*
1053  * XXX - these options apply unilaterally to _all_ 274x/284x/294x
1054  *       cards in the system.  This should be fixed.  Exceptions to this
1055  *       rule are noted in the comments.
1056  */
1057
1058 /*
1059  * Use this as the default queue depth when setting tagged queueing on.
1060  */
1061 static unsigned int aic7xxx_default_queue_depth = AIC7XXX_CMDS_PER_DEVICE;
1062
1063 /*
1064  * Skip the scsi bus reset.  Non 0 make us skip the reset at startup.  This
1065  * has no effect on any later resets that might occur due to things like
1066  * SCSI bus timeouts.
1067  */
1068 static unsigned int aic7xxx_no_reset = 0;
1069 /*
1070  * Certain PCI motherboards will scan PCI devices from highest to lowest,
1071  * others scan from lowest to highest, and they tend to do all kinds of
1072  * strange things when they come into contact with PCI bridge chips.  The
1073  * net result of all this is that the PCI card that is actually used to boot
1074  * the machine is very hard to detect.  Most motherboards go from lowest
1075  * PCI slot number to highest, and the first SCSI controller found is the
1076  * one you boot from.  The only exceptions to this are when a controller
1077  * has its BIOS disabled.  So, we by default sort all of our SCSI controllers
1078  * from lowest PCI slot number to highest PCI slot number.  We also force
1079  * all controllers with their BIOS disabled to the end of the list.  This
1080  * works on *almost* all computers.  Where it doesn't work, we have this
1081  * option.  Setting this option to non-0 will reverse the order of the sort
1082  * to highest first, then lowest, but will still leave cards with their BIOS
1083  * disabled at the very end.  That should fix everyone up unless there are
1084  * really strange cirumstances.
1085  */
1086 static int aic7xxx_reverse_scan = 0;
1087 /*
1088  * Should we force EXTENDED translation on a controller.
1089  *     0 == Use whatever is in the SEEPROM or default to off
1090  *     1 == Use whatever is in the SEEPROM or default to on
1091  */
1092 static unsigned int aic7xxx_extended = 0;
1093 /*
1094  * The IRQ trigger method used on EISA controllers. Does not effect PCI cards.
1095  *   -1 = Use detected settings.
1096  *    0 = Force Edge triggered mode.
1097  *    1 = Force Level triggered mode.
1098  */
1099 static int aic7xxx_irq_trigger = -1;
1100 /*
1101  * This variable is used to override the termination settings on a controller.
1102  * This should not be used under normal conditions.  However, in the case
1103  * that a controller does not have a readable SEEPROM (so that we can't
1104  * read the SEEPROM settings directly) and that a controller has a buggered
1105  * version of the cable detection logic, this can be used to force the
1106  * correct termination.  It is preferable to use the manual termination
1107  * settings in the BIOS if possible, but some motherboard controllers store
1108  * those settings in a format we can't read.  In other cases, auto term
1109  * should also work, but the chipset was put together with no auto term
1110  * logic (common on motherboard controllers).  In those cases, we have
1111  * 32 bits here to work with.  That's good for 8 controllers/channels.  The
1112  * bits are organized as 4 bits per channel, with scsi0 getting the lowest
1113  * 4 bits in the int.  A 1 in a bit position indicates the termination setting
1114  * that corresponds to that bit should be enabled, a 0 is disabled.
1115  * It looks something like this:
1116  *
1117  *    0x0f =  1111-Single Ended Low Byte Termination on/off
1118  *            ||\-Single Ended High Byte Termination on/off
1119  *            |\-LVD Low Byte Termination on/off
1120  *            \-LVD High Byte Termination on/off
1121  *
1122  * For non-Ultra2 controllers, the upper 2 bits are not important.  So, to
1123  * enable both high byte and low byte termination on scsi0, I would need to
1124  * make sure that the override_term variable was set to 0x03 (bits 0011).
1125  * To make sure that all termination is enabled on an Ultra2 controller at
1126  * scsi2 and only high byte termination on scsi1 and high and low byte
1127  * termination on scsi0, I would set override_term=0xf23 (bits 1111 0010 0011)
1128  *
1129  * For the most part, users should never have to use this, that's why I
1130  * left it fairly cryptic instead of easy to understand.  If you need it,
1131  * most likely someone will be telling you what your's needs to be set to.
1132  */
1133 static int aic7xxx_override_term = -1;
1134 /*
1135  * Certain motherboard chipset controllers tend to screw
1136  * up the polarity of the term enable output pin.  Use this variable
1137  * to force the correct polarity for your system.  This is a bitfield variable
1138  * similar to the previous one, but this one has one bit per channel instead
1139  * of four.
1140  *    0 = Force the setting to active low.
1141  *    1 = Force setting to active high.
1142  * Most Adaptec cards are active high, several motherboards are active low.
1143  * To force a 2940 card at SCSI 0 to active high and a motherboard 7895
1144  * controller at scsi1 and scsi2 to active low, and a 2910 card at scsi3
1145  * to active high, you would need to set stpwlev=0x9 (bits 1001).
1146  *
1147  * People shouldn't need to use this, but if you are experiencing lots of
1148  * SCSI timeout problems, this may help.  There is one sure way to test what
1149  * this option needs to be.  Using a boot floppy to boot the system, configure
1150  * your system to enable all SCSI termination (in the Adaptec SCSI BIOS) and
1151  * if needed then also pass a value to override_term to make sure that the
1152  * driver is enabling SCSI termination, then set this variable to either 0
1153  * or 1.  When the driver boots, make sure there are *NO* SCSI cables
1154  * connected to your controller.  If it finds and inits the controller
1155  * without problem, then the setting you passed to stpwlev was correct.  If
1156  * the driver goes into a reset loop and hangs the system, then you need the
1157  * other setting for this variable.  If neither setting lets the machine
1158  * boot then you have definite termination problems that may not be fixable.
1159  */
1160 static int aic7xxx_stpwlev = -1;
1161 /*
1162  * Set this to non-0 in order to force the driver to panic the kernel
1163  * and print out debugging info on a SCSI abort or reset cycle.
1164  */
1165 static int aic7xxx_panic_on_abort = 0;
1166 /*
1167  * PCI bus parity checking of the Adaptec controllers.  This is somewhat
1168  * dubious at best.  To my knowledge, this option has never actually
1169  * solved a PCI parity problem, but on certain machines with broken PCI
1170  * chipset configurations, it can generate tons of false error messages.
1171  * It's included in the driver for completeness.
1172  *   0 = Shut off PCI parity check
1173  *  -1 = Normal polarity pci parity checking
1174  *   1 = reverse polarity pci parity checking
1175  *
1176  * NOTE: you can't actually pass -1 on the lilo prompt.  So, to set this
1177  * variable to -1 you would actually want to simply pass the variable
1178  * name without a number.  That will invert the 0 which will result in
1179  * -1.
1180  */
1181 static int aic7xxx_pci_parity = 0;
1182 /*
1183  * Set this to any non-0 value to cause us to dump the contents of all
1184  * the card's registers in a hex dump format tailored to each model of
1185  * controller.
1186  *
1187  * NOTE: THE CONTROLLER IS LEFT IN AN UNUSEABLE STATE BY THIS OPTION.
1188  *       YOU CANNOT BOOT UP WITH THIS OPTION, IT IS FOR DEBUGGING PURPOSES
1189  *       ONLY
1190  */
1191 static int aic7xxx_dump_card = 0;
1192 /*
1193  * Set this to a non-0 value to make us dump out the 32 bit instruction
1194  * registers on the card after completing the sequencer download.  This
1195  * allows the actual sequencer download to be verified.  It is possible
1196  * to use this option and still boot up and run your system.  This is
1197  * only intended for debugging purposes.
1198  */
1199 static int aic7xxx_dump_sequencer = 0;
1200 /*
1201  * Certain newer motherboards have put new PCI based devices into the
1202  * IO spaces that used to typically be occupied by VLB or EISA cards.
1203  * This overlap can cause these newer motherboards to lock up when scanned
1204  * for older EISA and VLB devices.  Setting this option to non-0 will
1205  * cause the driver to skip scanning for any VLB or EISA controllers and
1206  * only support the PCI controllers.  NOTE: this means that if the kernel
1207  * os compiled with PCI support disabled, then setting this to non-0
1208  * would result in never finding any devices :)
1209  */
1210 static int aic7xxx_no_probe = 0;
1211 /*
1212  * On some machines, enabling the external SCB RAM isn't reliable yet.  I
1213  * haven't had time to make test patches for things like changing the
1214  * timing mode on that external RAM either.  Some of those changes may
1215  * fix the problem.  Until then though, we default to external SCB RAM
1216  * off and give a command line option to enable it.
1217  */
1218 static int aic7xxx_scbram = 0;
1219 /*
1220  * So that we can set how long each device is given as a selection timeout.
1221  * The table of values goes like this:
1222  *   0 - 256ms
1223  *   1 - 128ms
1224  *   2 - 64ms
1225  *   3 - 32ms
1226  * We default to 64ms because it's fast.  Some old SCSI-I devices need a
1227  * longer time.  The final value has to be left shifted by 3, hence 0x10
1228  * is the final value.
1229  */
1230 static int aic7xxx_seltime = 0x10;
1231 /*
1232  * So that insmod can find the variable and make it point to something
1233  */
1234 #ifdef MODULE
1235 static char * aic7xxx = NULL;
1236 MODULE_PARM(aic7xxx, "s");
1237 #endif
1238
1239 #define VERBOSE_NORMAL         0x0000
1240 #define VERBOSE_NEGOTIATION    0x0001
1241 #define VERBOSE_SEQINT         0x0002
1242 #define VERBOSE_SCSIINT        0x0004
1243 #define VERBOSE_PROBE          0x0008
1244 #define VERBOSE_PROBE2         0x0010
1245 #define VERBOSE_NEGOTIATION2   0x0020
1246 #define VERBOSE_MINOR_ERROR    0x0040
1247 #define VERBOSE_TRACING        0x0080
1248 #define VERBOSE_ABORT          0x0f00
1249 #define VERBOSE_ABORT_MID      0x0100
1250 #define VERBOSE_ABORT_FIND     0x0200
1251 #define VERBOSE_ABORT_PROCESS  0x0400
1252 #define VERBOSE_ABORT_RETURN   0x0800
1253 #define VERBOSE_RESET          0xf000
1254 #define VERBOSE_RESET_MID      0x1000
1255 #define VERBOSE_RESET_FIND     0x2000
1256 #define VERBOSE_RESET_PROCESS  0x4000
1257 #define VERBOSE_RESET_RETURN   0x8000
1258 static int aic7xxx_verbose = VERBOSE_NORMAL | VERBOSE_NEGOTIATION |
1259            VERBOSE_PROBE;                     /* verbose messages */
1260
1261
1262 /****************************************************************************
1263  *
1264  * We're going to start putting in function declarations so that order of
1265  * functions is no longer important.  As needed, they are added here.
1266  *
1267  ***************************************************************************/
1268
1269 static int aic7xxx_release(struct Scsi_Host *host);
1270 static void aic7xxx_set_syncrate(struct aic7xxx_host *p,
1271                 struct aic7xxx_syncrate *syncrate, int target, int channel,
1272                 unsigned int period, unsigned int offset, unsigned char options,
1273                 unsigned int type, struct aic_dev_data *aic_dev);
1274 static void aic7xxx_set_width(struct aic7xxx_host *p, int target, int channel,
1275                 int lun, unsigned int width, unsigned int type,
1276                 struct aic_dev_data *aic_dev);
1277 static void aic7xxx_panic_abort(struct aic7xxx_host *p, Scsi_Cmnd *cmd);
1278 static void aic7xxx_print_card(struct aic7xxx_host *p);
1279 static void aic7xxx_print_scratch_ram(struct aic7xxx_host *p);
1280 static void aic7xxx_print_sequencer(struct aic7xxx_host *p, int downloaded);
1281 #ifdef AIC7XXX_VERBOSE_DEBUGGING
1282 static void aic7xxx_check_scbs(struct aic7xxx_host *p, char *buffer);
1283 #endif
1284
1285 /****************************************************************************
1286  *
1287  * These functions are now used.  They happen to be wrapped in useless
1288  * inb/outb port read/writes around the real reads and writes because it
1289  * seems that certain very fast CPUs have a problem dealing with us when
1290  * going at full speed.
1291  *
1292  ***************************************************************************/
1293
1294 static inline unsigned char
1295 aic_inb(struct aic7xxx_host *p, long port)
1296 {
1297 #ifdef MMAPIO
1298   unsigned char x;
1299   if(p->maddr)
1300   {
1301     x = readb(p->maddr + port);
1302   }
1303   else
1304   {
1305     x = inb(p->base + port);
1306   }
1307   return(x);
1308 #else
1309   return(inb(p->base + port));
1310 #endif
1311 }
1312
1313 static inline void
1314 aic_outb(struct aic7xxx_host *p, unsigned char val, long port)
1315 {
1316 #ifdef MMAPIO
1317   if(p->maddr)
1318   {
1319     writeb(val, p->maddr + port);
1320     mb(); /* locked operation in order to force CPU ordering */
1321     readb(p->maddr + HCNTRL); /* dummy read to flush the PCI write */
1322   }
1323   else
1324   {
1325     outb(val, p->base + port);
1326     mb(); /* locked operation in order to force CPU ordering */
1327   }
1328 #else
1329   outb(val, p->base + port);
1330   mb(); /* locked operation in order to force CPU ordering */
1331 #endif
1332 }
1333
1334 /*+F*************************************************************************
1335  * Function:
1336  *   aic7xxx_setup
1337  *
1338  * Description:
1339  *   Handle Linux boot parameters. This routine allows for assigning a value
1340  *   to a parameter with a ':' between the parameter and the value.
1341  *   ie. aic7xxx=unpause:0x0A,extended
1342  *-F*************************************************************************/
1343 static int
1344 aic7xxx_setup(char *s)
1345 {
1346   int   i, n;
1347   char *p;
1348   char *end;
1349
1350   static struct {
1351     const char *name;
1352     unsigned int *flag;
1353   } options[] = {
1354     { "extended",    &aic7xxx_extended },
1355     { "no_reset",    &aic7xxx_no_reset },
1356     { "irq_trigger", &aic7xxx_irq_trigger },
1357     { "verbose",     &aic7xxx_verbose },
1358     { "reverse_scan",&aic7xxx_reverse_scan },
1359     { "override_term", &aic7xxx_override_term },
1360     { "stpwlev", &aic7xxx_stpwlev },
1361     { "no_probe", &aic7xxx_no_probe },
1362     { "panic_on_abort", &aic7xxx_panic_on_abort },
1363     { "pci_parity", &aic7xxx_pci_parity },
1364     { "dump_card", &aic7xxx_dump_card },
1365     { "dump_sequencer", &aic7xxx_dump_sequencer },
1366     { "default_queue_depth", &aic7xxx_default_queue_depth },
1367     { "scbram", &aic7xxx_scbram },
1368     { "seltime", &aic7xxx_seltime },
1369     { "tag_info",    NULL }
1370   };
1371
1372   end = strchr(s, '\0');
1373
1374   while ((p = strsep(&s, ",.")) != NULL)
1375   {
1376     for (i = 0; i < ARRAY_SIZE(options); i++)
1377     {
1378       n = strlen(options[i].name);
1379       if (!strncmp(options[i].name, p, n))
1380       {
1381         if (!strncmp(p, "tag_info", n))
1382         {
1383           if (p[n] == ':')
1384           {
1385             char *base;
1386             char *tok, *tok_end, *tok_end2;
1387             char tok_list[] = { '.', ',', '{', '}', '\0' };
1388             int i, instance = -1, device = -1;
1389             unsigned char done = FALSE;
1390
1391             base = p;
1392             tok = base + n + 1;  /* Forward us just past the ':' */
1393             tok_end = strchr(tok, '\0');
1394             if (tok_end < end)
1395               *tok_end = ',';
1396             while(!done)
1397             {
1398               switch(*tok)
1399               {
1400                 case '{':
1401                   if (instance == -1)
1402                     instance = 0;
1403                   else if (device == -1)
1404                     device = 0;
1405                   tok++;
1406                   break;
1407                 case '}':
1408                   if (device != -1)
1409                     device = -1;
1410                   else if (instance != -1)
1411                     instance = -1;
1412                   tok++;
1413                   break;
1414                 case ',':
1415                 case '.':
1416                   if (instance == -1)
1417                     done = TRUE;
1418                   else if (device >= 0)
1419                     device++;
1420                   else if (instance >= 0)
1421                     instance++;
1422                   if ( (device >= MAX_TARGETS) ||
1423                        (instance >= ARRAY_SIZE(aic7xxx_tag_info)) )
1424                     done = TRUE;
1425                   tok++;
1426                   if (!done)
1427                   {
1428                     base = tok;
1429                   }
1430                   break;
1431                 case '\0':
1432                   done = TRUE;
1433                   break;
1434                 default:
1435                   done = TRUE;
1436                   tok_end = strchr(tok, '\0');
1437                   for(i=0; tok_list[i]; i++)
1438                   {
1439                     tok_end2 = strchr(tok, tok_list[i]);
1440                     if ( (tok_end2) && (tok_end2 < tok_end) )
1441                     {
1442                       tok_end = tok_end2;
1443                       done = FALSE;
1444                     }
1445                   }
1446                   if ( (instance >= 0) && (device >= 0) &&
1447                        (instance < ARRAY_SIZE(aic7xxx_tag_info)) &&
1448                        (device < MAX_TARGETS) )
1449                     aic7xxx_tag_info[instance].tag_commands[device] =
1450                       simple_strtoul(tok, NULL, 0) & 0xff;
1451                   tok = tok_end;
1452                   break;
1453               }
1454             }
1455             while((p != base) && (p != NULL))
1456               p = strsep(&s, ",.");
1457           }
1458         }
1459         else if (p[n] == ':')
1460         {
1461           *(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0);
1462           if(!strncmp(p, "seltime", n))
1463           {
1464             *(options[i].flag) = (*(options[i].flag) % 4) << 3;
1465           }
1466         }
1467         else if (!strncmp(p, "verbose", n))
1468         {
1469           *(options[i].flag) = 0xff29;
1470         }
1471         else
1472         {
1473           *(options[i].flag) = ~(*(options[i].flag));
1474           if(!strncmp(p, "seltime", n))
1475           {
1476             *(options[i].flag) = (*(options[i].flag) % 4) << 3;
1477           }
1478         }
1479       }
1480     }
1481   }
1482   return 1;
1483 }
1484
1485 __setup("aic7xxx=", aic7xxx_setup);
1486
1487 /*+F*************************************************************************
1488  * Function:
1489  *   pause_sequencer
1490  *
1491  * Description:
1492  *   Pause the sequencer and wait for it to actually stop - this
1493  *   is important since the sequencer can disable pausing for critical
1494  *   sections.
1495  *-F*************************************************************************/
1496 static void
1497 pause_sequencer(struct aic7xxx_host *p)
1498 {
1499   aic_outb(p, p->pause, HCNTRL);
1500   while ((aic_inb(p, HCNTRL) & PAUSE) == 0)
1501   {
1502     ;
1503   }
1504   if(p->features & AHC_ULTRA2)
1505   {
1506     aic_inb(p, CCSCBCTL);
1507   }
1508 }
1509
1510 /*+F*************************************************************************
1511  * Function:
1512  *   unpause_sequencer
1513  *
1514  * Description:
1515  *   Unpause the sequencer. Unremarkable, yet done often enough to
1516  *   warrant an easy way to do it.
1517  *-F*************************************************************************/
1518 static void
1519 unpause_sequencer(struct aic7xxx_host *p, int unpause_always)
1520 {
1521   if (unpause_always ||
1522       ( !(aic_inb(p, INTSTAT) & (SCSIINT | SEQINT | BRKADRINT)) &&
1523         !(p->flags & AHC_HANDLING_REQINITS) ) )
1524   {
1525     aic_outb(p, p->unpause, HCNTRL);
1526   }
1527 }
1528
1529 /*+F*************************************************************************
1530  * Function:
1531  *   restart_sequencer
1532  *
1533  * Description:
1534  *   Restart the sequencer program from address zero.  This assumes
1535  *   that the sequencer is already paused.
1536  *-F*************************************************************************/
1537 static void
1538 restart_sequencer(struct aic7xxx_host *p)
1539 {
1540   aic_outb(p, 0, SEQADDR0);
1541   aic_outb(p, 0, SEQADDR1);
1542   aic_outb(p, FASTMODE, SEQCTL);
1543 }
1544
1545 /*
1546  * We include the aic7xxx_seq.c file here so that the other defines have
1547  * already been made, and so that it comes before the code that actually
1548  * downloads the instructions (since we don't typically use function
1549  * prototype, our code has to be ordered that way, it's a left-over from
1550  * the original driver days.....I should fix it some time DL).
1551  */
1552 #include "aic7xxx_old/aic7xxx_seq.c"
1553
1554 /*+F*************************************************************************
1555  * Function:
1556  *   aic7xxx_check_patch
1557  *
1558  * Description:
1559  *   See if the next patch to download should be downloaded.
1560  *-F*************************************************************************/
1561 static int
1562 aic7xxx_check_patch(struct aic7xxx_host *p,
1563   struct sequencer_patch **start_patch, int start_instr, int *skip_addr)
1564 {
1565   struct sequencer_patch *cur_patch;
1566   struct sequencer_patch *last_patch;
1567   int num_patches;
1568
1569   num_patches = sizeof(sequencer_patches)/sizeof(struct sequencer_patch);
1570   last_patch = &sequencer_patches[num_patches];
1571   cur_patch = *start_patch;
1572
1573   while ((cur_patch < last_patch) && (start_instr == cur_patch->begin))
1574   {
1575     if (cur_patch->patch_func(p) == 0)
1576     {
1577       /*
1578        * Start rejecting code.
1579        */
1580       *skip_addr = start_instr + cur_patch->skip_instr;
1581       cur_patch += cur_patch->skip_patch;
1582     }
1583     else
1584     {
1585       /*
1586        * Found an OK patch.  Advance the patch pointer to the next patch
1587        * and wait for our instruction pointer to get here.
1588        */
1589       cur_patch++;
1590     }
1591   }
1592
1593   *start_patch = cur_patch;
1594   if (start_instr < *skip_addr)
1595     /*
1596      * Still skipping
1597      */
1598     return (0);
1599   return(1);
1600 }
1601
1602
1603 /*+F*************************************************************************
1604  * Function:
1605  *   aic7xxx_download_instr
1606  *
1607  * Description:
1608  *   Find the next patch to download.
1609  *-F*************************************************************************/
1610 static void
1611 aic7xxx_download_instr(struct aic7xxx_host *p, int instrptr,
1612   unsigned char *dconsts)
1613 {
1614   union ins_formats instr;
1615   struct ins_format1 *fmt1_ins;
1616   struct ins_format3 *fmt3_ins;
1617   unsigned char opcode;
1618
1619   instr = *(union ins_formats*) &seqprog[instrptr * 4];
1620
1621   instr.integer = le32_to_cpu(instr.integer);
1622
1623   fmt1_ins = &instr.format1;
1624   fmt3_ins = NULL;
1625
1626   /* Pull the opcode */
1627   opcode = instr.format1.opcode;
1628   switch (opcode)
1629   {
1630     case AIC_OP_JMP:
1631     case AIC_OP_JC:
1632     case AIC_OP_JNC:
1633     case AIC_OP_CALL:
1634     case AIC_OP_JNE:
1635     case AIC_OP_JNZ:
1636     case AIC_OP_JE:
1637     case AIC_OP_JZ:
1638     {
1639       struct sequencer_patch *cur_patch;
1640       int address_offset;
1641       unsigned int address;
1642       int skip_addr;
1643       int i;
1644
1645       fmt3_ins = &instr.format3;
1646       address_offset = 0;
1647       address = fmt3_ins->address;
1648       cur_patch = sequencer_patches;
1649       skip_addr = 0;
1650
1651       for (i = 0; i < address;)
1652       {
1653         aic7xxx_check_patch(p, &cur_patch, i, &skip_addr);
1654         if (skip_addr > i)
1655         {
1656           int end_addr;
1657
1658           end_addr = min_t(int, address, skip_addr);
1659           address_offset += end_addr - i;
1660           i = skip_addr;
1661         }
1662         else
1663         {
1664           i++;
1665         }
1666       }
1667       address -= address_offset;
1668       fmt3_ins->address = address;
1669       /* Fall Through to the next code section */
1670     }
1671     case AIC_OP_OR:
1672     case AIC_OP_AND:
1673     case AIC_OP_XOR:
1674     case AIC_OP_ADD:
1675     case AIC_OP_ADC:
1676     case AIC_OP_BMOV:
1677       if (fmt1_ins->parity != 0)
1678       {
1679         fmt1_ins->immediate = dconsts[fmt1_ins->immediate];
1680       }
1681       fmt1_ins->parity = 0;
1682       /* Fall Through to the next code section */
1683     case AIC_OP_ROL:
1684       if ((p->features & AHC_ULTRA2) != 0)
1685       {
1686         int i, count;
1687
1688         /* Calculate odd parity for the instruction */
1689         for ( i=0, count=0; i < 31; i++)
1690         {
1691           unsigned int mask;
1692
1693           mask = 0x01 << i;
1694           if ((instr.integer & mask) != 0)
1695             count++;
1696         }
1697         if (!(count & 0x01))
1698           instr.format1.parity = 1;
1699       }
1700       else
1701       {
1702         if (fmt3_ins != NULL)
1703         {
1704           instr.integer =  fmt3_ins->immediate |
1705                           (fmt3_ins->source << 8) |
1706                           (fmt3_ins->address << 16) |
1707                           (fmt3_ins->opcode << 25);
1708         }
1709         else
1710         {
1711           instr.integer =  fmt1_ins->immediate |
1712                           (fmt1_ins->source << 8) |
1713                           (fmt1_ins->destination << 16) |
1714                           (fmt1_ins->ret << 24) |
1715                           (fmt1_ins->opcode << 25);
1716         }
1717       }
1718       aic_outb(p, (instr.integer & 0xff), SEQRAM);
1719       aic_outb(p, ((instr.integer >> 8) & 0xff), SEQRAM);
1720       aic_outb(p, ((instr.integer >> 16) & 0xff), SEQRAM);
1721       aic_outb(p, ((instr.integer >> 24) & 0xff), SEQRAM);
1722       udelay(10);
1723       break;
1724
1725     default:
1726       panic("aic7xxx: Unknown opcode encountered in sequencer program.");
1727       break;
1728   }
1729 }
1730
1731
1732 /*+F*************************************************************************
1733  * Function:
1734  *   aic7xxx_loadseq
1735  *
1736  * Description:
1737  *   Load the sequencer code into the controller memory.
1738  *-F*************************************************************************/
1739 static void
1740 aic7xxx_loadseq(struct aic7xxx_host *p)
1741 {
1742   struct sequencer_patch *cur_patch;
1743   int i;
1744   int downloaded;
1745   int skip_addr;
1746   unsigned char download_consts[4] = {0, 0, 0, 0};
1747
1748   if (aic7xxx_verbose & VERBOSE_PROBE)
1749   {
1750     printk(KERN_INFO "(scsi%d) Downloading sequencer code...", p->host_no);
1751   }
1752 #if 0
1753   download_consts[TMODE_NUMCMDS] = p->num_targetcmds;
1754 #endif
1755   download_consts[TMODE_NUMCMDS] = 0;
1756   cur_patch = &sequencer_patches[0];
1757   downloaded = 0;
1758   skip_addr = 0;
1759
1760   aic_outb(p, PERRORDIS|LOADRAM|FAILDIS|FASTMODE, SEQCTL);
1761   aic_outb(p, 0, SEQADDR0);
1762   aic_outb(p, 0, SEQADDR1);
1763
1764   for (i = 0; i < sizeof(seqprog) / 4;  i++)
1765   {
1766     if (aic7xxx_check_patch(p, &cur_patch, i, &skip_addr) == 0)
1767     {
1768       /* Skip this instruction for this configuration. */
1769       continue;
1770     }
1771     aic7xxx_download_instr(p, i, &download_consts[0]);
1772     downloaded++;
1773   }
1774
1775   aic_outb(p, 0, SEQADDR0);
1776   aic_outb(p, 0, SEQADDR1);
1777   aic_outb(p, FASTMODE | FAILDIS, SEQCTL);
1778   unpause_sequencer(p, TRUE);
1779   mdelay(1);
1780   pause_sequencer(p);
1781   aic_outb(p, FASTMODE, SEQCTL);
1782   if (aic7xxx_verbose & VERBOSE_PROBE)
1783   {
1784     printk(" %d instructions downloaded\n", downloaded);
1785   }
1786   if (aic7xxx_dump_sequencer)
1787     aic7xxx_print_sequencer(p, downloaded);
1788 }
1789
1790 /*+F*************************************************************************
1791  * Function:
1792  *   aic7xxx_print_sequencer
1793  *
1794  * Description:
1795  *   Print the contents of the sequencer memory to the screen.
1796  *-F*************************************************************************/
1797 static void
1798 aic7xxx_print_sequencer(struct aic7xxx_host *p, int downloaded)
1799 {
1800   int i, k, temp;
1801
1802   aic_outb(p, PERRORDIS|LOADRAM|FAILDIS|FASTMODE, SEQCTL);
1803   aic_outb(p, 0, SEQADDR0);
1804   aic_outb(p, 0, SEQADDR1);
1805
1806   k = 0;
1807   for (i=0; i < downloaded; i++)
1808   {
1809     if ( k == 0 )
1810       printk("%03x: ", i);
1811     temp = aic_inb(p, SEQRAM);
1812     temp |= (aic_inb(p, SEQRAM) << 8);
1813     temp |= (aic_inb(p, SEQRAM) << 16);
1814     temp |= (aic_inb(p, SEQRAM) << 24);
1815     printk("%08x", temp);
1816     if ( ++k == 8 )
1817     {
1818       printk("\n");
1819       k = 0;
1820     }
1821     else
1822       printk(" ");
1823   }
1824   aic_outb(p, 0, SEQADDR0);
1825   aic_outb(p, 0, SEQADDR1);
1826   aic_outb(p, FASTMODE | FAILDIS, SEQCTL);
1827   unpause_sequencer(p, TRUE);
1828   mdelay(1);
1829   pause_sequencer(p);
1830   aic_outb(p, FASTMODE, SEQCTL);
1831   printk("\n");
1832 }
1833
1834 /*+F*************************************************************************
1835  * Function:
1836  *   aic7xxx_info
1837  *
1838  * Description:
1839  *   Return a string describing the driver.
1840  *-F*************************************************************************/
1841 const char *
1842 aic7xxx_info(struct Scsi_Host *dooh)
1843 {
1844   static char buffer[256];
1845   char *bp;
1846   struct aic7xxx_host *p;
1847
1848   bp = &buffer[0];
1849   p = (struct aic7xxx_host *)dooh->hostdata;
1850   memset(bp, 0, sizeof(buffer));
1851   strcpy(bp, "Adaptec AHA274x/284x/294x (EISA/VLB/PCI-Fast SCSI) ");
1852   strcat(bp, AIC7XXX_C_VERSION);
1853   strcat(bp, "/");
1854   strcat(bp, AIC7XXX_H_VERSION);
1855   strcat(bp, "\n");
1856   strcat(bp, "       <");
1857   strcat(bp, board_names[p->board_name_index]);
1858   strcat(bp, ">");
1859
1860   return(bp);
1861 }
1862
1863 /*+F*************************************************************************
1864  * Function:
1865  *   aic7xxx_find_syncrate
1866  *
1867  * Description:
1868  *   Look up the valid period to SCSIRATE conversion in our table
1869  *-F*************************************************************************/
1870 static struct aic7xxx_syncrate *
1871 aic7xxx_find_syncrate(struct aic7xxx_host *p, unsigned int *period,
1872   unsigned int maxsync, unsigned char *options)
1873 {
1874   struct aic7xxx_syncrate *syncrate;
1875   int done = FALSE;
1876
1877   switch(*options)
1878   {
1879     case MSG_EXT_PPR_OPTION_DT_CRC:
1880     case MSG_EXT_PPR_OPTION_DT_UNITS:
1881       if(!(p->features & AHC_ULTRA3))
1882       {
1883         *options = 0;
1884         maxsync = max_t(unsigned int, maxsync, AHC_SYNCRATE_ULTRA2);
1885       }
1886       break;
1887     case MSG_EXT_PPR_OPTION_DT_CRC_QUICK:
1888     case MSG_EXT_PPR_OPTION_DT_UNITS_QUICK:
1889       if(!(p->features & AHC_ULTRA3))
1890       {
1891         *options = 0;
1892         maxsync = max_t(unsigned int, maxsync, AHC_SYNCRATE_ULTRA2);
1893       }
1894       else
1895       {
1896         /*
1897          * we don't support the Quick Arbitration variants of dual edge
1898          * clocking.  As it turns out, we want to send back the
1899          * same basic option, but without the QA attribute.
1900          * We know that we are responding because we would never set
1901          * these options ourself, we would only respond to them.
1902          */
1903         switch(*options)
1904         {
1905           case MSG_EXT_PPR_OPTION_DT_CRC_QUICK:
1906             *options = MSG_EXT_PPR_OPTION_DT_CRC;
1907             break;
1908           case MSG_EXT_PPR_OPTION_DT_UNITS_QUICK:
1909             *options = MSG_EXT_PPR_OPTION_DT_UNITS;
1910             break;
1911         }
1912       }
1913       break;
1914     default:
1915       *options = 0;
1916       maxsync = max_t(unsigned int, maxsync, AHC_SYNCRATE_ULTRA2);
1917       break;
1918   }
1919   syncrate = &aic7xxx_syncrates[maxsync];
1920   while ( (syncrate->rate[0] != NULL) &&
1921          (!(p->features & AHC_ULTRA2) || syncrate->sxfr_ultra2) )
1922   {
1923     if (*period <= syncrate->period)
1924     {
1925       switch(*options)
1926       {
1927         case MSG_EXT_PPR_OPTION_DT_CRC:
1928         case MSG_EXT_PPR_OPTION_DT_UNITS:
1929           if(!(syncrate->sxfr_ultra2 & AHC_SYNCRATE_CRC))
1930           {
1931             done = TRUE;
1932             /*
1933              * oops, we went too low for the CRC/DualEdge signalling, so
1934              * clear the options byte
1935              */
1936             *options = 0;
1937             /*
1938              * We'll be sending a reply to this packet to set the options
1939              * properly, so unilaterally set the period as well.
1940              */
1941             *period = syncrate->period;
1942           }
1943           else
1944           {
1945             done = TRUE;
1946             if(syncrate == &aic7xxx_syncrates[maxsync])
1947             {
1948               *period = syncrate->period;
1949             }
1950           }
1951           break;
1952         default:
1953           if(!(syncrate->sxfr_ultra2 & AHC_SYNCRATE_CRC))
1954           {
1955             done = TRUE;
1956             if(syncrate == &aic7xxx_syncrates[maxsync])
1957             {
1958               *period = syncrate->period;
1959             }
1960           }
1961           break;
1962       }
1963       if(done)
1964       {
1965         break;
1966       }
1967     }
1968     syncrate++;
1969   }
1970   if ( (*period == 0) || (syncrate->rate[0] == NULL) ||
1971        ((p->features & AHC_ULTRA2) && (syncrate->sxfr_ultra2 == 0)) )
1972   {
1973     /*
1974      * Use async transfers for this target
1975      */
1976     *options = 0;
1977     *period = 255;
1978     syncrate = NULL;
1979   }
1980   return (syncrate);
1981 }
1982
1983
1984 /*+F*************************************************************************
1985  * Function:
1986  *   aic7xxx_find_period
1987  *
1988  * Description:
1989  *   Look up the valid SCSIRATE to period conversion in our table
1990  *-F*************************************************************************/
1991 static unsigned int
1992 aic7xxx_find_period(struct aic7xxx_host *p, unsigned int scsirate,
1993   unsigned int maxsync)
1994 {
1995   struct aic7xxx_syncrate *syncrate;
1996
1997   if (p->features & AHC_ULTRA2)
1998   {
1999     scsirate &= SXFR_ULTRA2;
2000   }
2001   else
2002   {
2003     scsirate &= SXFR;
2004   }
2005
2006   syncrate = &aic7xxx_syncrates[maxsync];
2007   while (syncrate->rate[0] != NULL)
2008   {
2009     if (p->features & AHC_ULTRA2)
2010     {
2011       if (syncrate->sxfr_ultra2 == 0)
2012         break;
2013       else if (scsirate == syncrate->sxfr_ultra2)
2014         return (syncrate->period);
2015       else if (scsirate == (syncrate->sxfr_ultra2 & ~AHC_SYNCRATE_CRC))
2016         return (syncrate->period);
2017     }
2018     else if (scsirate == (syncrate->sxfr & ~ULTRA_SXFR))
2019     {
2020       return (syncrate->period);
2021     }
2022     syncrate++;
2023   }
2024   return (0); /* async */
2025 }
2026
2027 /*+F*************************************************************************
2028  * Function:
2029  *   aic7xxx_validate_offset
2030  *
2031  * Description:
2032  *   Set a valid offset value for a particular card in use and transfer
2033  *   settings in use.
2034  *-F*************************************************************************/
2035 static void
2036 aic7xxx_validate_offset(struct aic7xxx_host *p,
2037   struct aic7xxx_syncrate *syncrate, unsigned int *offset, int wide)
2038 {
2039   unsigned int maxoffset;
2040
2041   /* Limit offset to what the card (and device) can do */
2042   if (syncrate == NULL)
2043   {
2044     maxoffset = 0;
2045   }
2046   else if (p->features & AHC_ULTRA2)
2047   {
2048     maxoffset = MAX_OFFSET_ULTRA2;
2049   }
2050   else
2051   {
2052     if (wide)
2053       maxoffset = MAX_OFFSET_16BIT;
2054     else
2055       maxoffset = MAX_OFFSET_8BIT;
2056   }
2057   *offset = min(*offset, maxoffset);
2058 }
2059
2060 /*+F*************************************************************************
2061  * Function:
2062  *   aic7xxx_set_syncrate
2063  *
2064  * Description:
2065  *   Set the actual syncrate down in the card and in our host structs
2066  *-F*************************************************************************/
2067 static void
2068 aic7xxx_set_syncrate(struct aic7xxx_host *p, struct aic7xxx_syncrate *syncrate,
2069     int target, int channel, unsigned int period, unsigned int offset,
2070     unsigned char options, unsigned int type, struct aic_dev_data *aic_dev)
2071 {
2072   unsigned char tindex;
2073   unsigned short target_mask;
2074   unsigned char lun, old_options;
2075   unsigned int old_period, old_offset;
2076
2077   tindex = target | (channel << 3);
2078   target_mask = 0x01 << tindex;
2079   lun = aic_inb(p, SCB_TCL) & 0x07;
2080
2081   if (syncrate == NULL)
2082   {
2083     period = 0;
2084     offset = 0;
2085   }
2086
2087   old_period = aic_dev->cur.period;
2088   old_offset = aic_dev->cur.offset;
2089   old_options = aic_dev->cur.options;
2090
2091
2092   if (type & AHC_TRANS_CUR)
2093   {
2094     unsigned int scsirate;
2095
2096     scsirate = aic_inb(p, TARG_SCSIRATE + tindex);
2097     if (p->features & AHC_ULTRA2)
2098     {
2099       scsirate &= ~SXFR_ULTRA2;
2100       if (syncrate != NULL)
2101       {
2102         switch(options)
2103         {
2104           case MSG_EXT_PPR_OPTION_DT_UNITS:
2105             /*
2106              * mask off the CRC bit in the xfer settings
2107              */
2108             scsirate |= (syncrate->sxfr_ultra2 & ~AHC_SYNCRATE_CRC);
2109             break;
2110           default:
2111             scsirate |= syncrate->sxfr_ultra2;
2112             break;
2113         }
2114       }
2115       if (type & AHC_TRANS_ACTIVE)
2116       {
2117         aic_outb(p, offset, SCSIOFFSET);
2118       }
2119       aic_outb(p, offset, TARG_OFFSET + tindex);
2120     }
2121     else /* Not an Ultra2 controller */
2122     {
2123       scsirate &= ~(SXFR|SOFS);
2124       p->ultraenb &= ~target_mask;
2125       if (syncrate != NULL)
2126       {
2127         if (syncrate->sxfr & ULTRA_SXFR)
2128         {
2129           p->ultraenb |= target_mask;
2130         }
2131         scsirate |= (syncrate->sxfr & SXFR);
2132         scsirate |= (offset & SOFS);
2133       }
2134       if (type & AHC_TRANS_ACTIVE)
2135       {
2136         unsigned char sxfrctl0;
2137
2138         sxfrctl0 = aic_inb(p, SXFRCTL0);
2139         sxfrctl0 &= ~FAST20;
2140         if (p->ultraenb & target_mask)
2141           sxfrctl0 |= FAST20;
2142         aic_outb(p, sxfrctl0, SXFRCTL0);
2143       }
2144       aic_outb(p, p->ultraenb & 0xff, ULTRA_ENB);
2145       aic_outb(p, (p->ultraenb >> 8) & 0xff, ULTRA_ENB + 1 );
2146     }
2147     if (type & AHC_TRANS_ACTIVE)
2148     {
2149       aic_outb(p, scsirate, SCSIRATE);
2150     }
2151     aic_outb(p, scsirate, TARG_SCSIRATE + tindex);
2152     aic_dev->cur.period = period;
2153     aic_dev->cur.offset = offset;
2154     aic_dev->cur.options = options;
2155     if ( !(type & AHC_TRANS_QUITE) &&
2156          (aic7xxx_verbose & VERBOSE_NEGOTIATION) &&
2157          (aic_dev->flags & DEVICE_PRINT_DTR) )
2158     {
2159       if (offset)
2160       {
2161         int rate_mod = (scsirate & WIDEXFER) ? 1 : 0;
2162
2163         printk(INFO_LEAD "Synchronous at %s Mbyte/sec, "
2164                "offset %d.\n", p->host_no, channel, target, lun,
2165                syncrate->rate[rate_mod], offset);
2166       }
2167       else
2168       {
2169         printk(INFO_LEAD "Using asynchronous transfers.\n",
2170                p->host_no, channel, target, lun);
2171       }
2172       aic_dev->flags &= ~DEVICE_PRINT_DTR;
2173     }
2174   }
2175
2176   if (type & AHC_TRANS_GOAL)
2177   {
2178     aic_dev->goal.period = period;
2179     aic_dev->goal.offset = offset;
2180     aic_dev->goal.options = options;
2181   }
2182
2183   if (type & AHC_TRANS_USER)
2184   {
2185     p->user[tindex].period = period;
2186     p->user[tindex].offset = offset;
2187     p->user[tindex].options = options;
2188   }
2189 }
2190
2191 /*+F*************************************************************************
2192  * Function:
2193  *   aic7xxx_set_width
2194  *
2195  * Description:
2196  *   Set the actual width down in the card and in our host structs
2197  *-F*************************************************************************/
2198 static void
2199 aic7xxx_set_width(struct aic7xxx_host *p, int target, int channel, int lun,
2200     unsigned int width, unsigned int type, struct aic_dev_data *aic_dev)
2201 {
2202   unsigned char tindex;
2203   unsigned short target_mask;
2204   unsigned int old_width;
2205
2206   tindex = target | (channel << 3);
2207   target_mask = 1 << tindex;
2208
2209   old_width = aic_dev->cur.width;
2210
2211   if (type & AHC_TRANS_CUR)
2212   {
2213     unsigned char scsirate;
2214
2215     scsirate = aic_inb(p, TARG_SCSIRATE + tindex);
2216
2217     scsirate &= ~WIDEXFER;
2218     if (width == MSG_EXT_WDTR_BUS_16_BIT)
2219       scsirate |= WIDEXFER;
2220
2221     aic_outb(p, scsirate, TARG_SCSIRATE + tindex);
2222
2223     if (type & AHC_TRANS_ACTIVE)
2224       aic_outb(p, scsirate, SCSIRATE);
2225
2226     aic_dev->cur.width = width;
2227
2228     if ( !(type & AHC_TRANS_QUITE) &&
2229           (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
2230           (aic_dev->flags & DEVICE_PRINT_DTR) )
2231     {
2232       printk(INFO_LEAD "Using %s transfers\n", p->host_no, channel, target,
2233         lun, (scsirate & WIDEXFER) ? "Wide(16bit)" : "Narrow(8bit)" );
2234     }
2235   }
2236
2237   if (type & AHC_TRANS_GOAL)
2238     aic_dev->goal.width = width;
2239   if (type & AHC_TRANS_USER)
2240     p->user[tindex].width = width;
2241
2242   if (aic_dev->goal.offset)
2243   {
2244     if (p->features & AHC_ULTRA2)
2245     {
2246       aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
2247     }
2248     else if (width == MSG_EXT_WDTR_BUS_16_BIT)
2249     {
2250       aic_dev->goal.offset = MAX_OFFSET_16BIT;
2251     }
2252     else
2253     {
2254       aic_dev->goal.offset = MAX_OFFSET_8BIT;
2255     }
2256   }
2257 }
2258
2259 /*+F*************************************************************************
2260  * Function:
2261  *   scbq_init
2262  *
2263  * Description:
2264  *   SCB queue initialization.
2265  *
2266  *-F*************************************************************************/
2267 static void
2268 scbq_init(volatile scb_queue_type *queue)
2269 {
2270   queue->head = NULL;
2271   queue->tail = NULL;
2272 }
2273
2274 /*+F*************************************************************************
2275  * Function:
2276  *   scbq_insert_head
2277  *
2278  * Description:
2279  *   Add an SCB to the head of the list.
2280  *
2281  *-F*************************************************************************/
2282 static inline void
2283 scbq_insert_head(volatile scb_queue_type *queue, struct aic7xxx_scb *scb)
2284 {
2285   scb->q_next = queue->head;
2286   queue->head = scb;
2287   if (queue->tail == NULL)       /* If list was empty, update tail. */
2288     queue->tail = queue->head;
2289 }
2290
2291 /*+F*************************************************************************
2292  * Function:
2293  *   scbq_remove_head
2294  *
2295  * Description:
2296  *   Remove an SCB from the head of the list.
2297  *
2298  *-F*************************************************************************/
2299 static inline struct aic7xxx_scb *
2300 scbq_remove_head(volatile scb_queue_type *queue)
2301 {
2302   struct aic7xxx_scb * scbp;
2303
2304   scbp = queue->head;
2305   if (queue->head != NULL)
2306     queue->head = queue->head->q_next;
2307   if (queue->head == NULL)       /* If list is now empty, update tail. */
2308     queue->tail = NULL;
2309   return(scbp);
2310 }
2311
2312 /*+F*************************************************************************
2313  * Function:
2314  *   scbq_remove
2315  *
2316  * Description:
2317  *   Removes an SCB from the list.
2318  *
2319  *-F*************************************************************************/
2320 static inline void
2321 scbq_remove(volatile scb_queue_type *queue, struct aic7xxx_scb *scb)
2322 {
2323   if (queue->head == scb)
2324   {
2325     /* At beginning of queue, remove from head. */
2326     scbq_remove_head(queue);
2327   }
2328   else
2329   {
2330     struct aic7xxx_scb *curscb = queue->head;
2331
2332     /*
2333      * Search until the next scb is the one we're looking for, or
2334      * we run out of queue.
2335      */
2336     while ((curscb != NULL) && (curscb->q_next != scb))
2337     {
2338       curscb = curscb->q_next;
2339     }
2340     if (curscb != NULL)
2341     {
2342       /* Found it. */
2343       curscb->q_next = scb->q_next;
2344       if (scb->q_next == NULL)
2345       {
2346         /* Update the tail when removing the tail. */
2347         queue->tail = curscb;
2348       }
2349     }
2350   }
2351 }
2352
2353 /*+F*************************************************************************
2354  * Function:
2355  *   scbq_insert_tail
2356  *
2357  * Description:
2358  *   Add an SCB at the tail of the list.
2359  *
2360  *-F*************************************************************************/
2361 static inline void
2362 scbq_insert_tail(volatile scb_queue_type *queue, struct aic7xxx_scb *scb)
2363 {
2364   scb->q_next = NULL;
2365   if (queue->tail != NULL)       /* Add the scb at the end of the list. */
2366     queue->tail->q_next = scb;
2367   queue->tail = scb;             /* Update the tail. */
2368   if (queue->head == NULL)       /* If list was empty, update head. */
2369     queue->head = queue->tail;
2370 }
2371
2372 /*+F*************************************************************************
2373  * Function:
2374  *   aic7xxx_match_scb
2375  *
2376  * Description:
2377  *   Checks to see if an scb matches the target/channel as specified.
2378  *   If target is ALL_TARGETS (-1), then we're looking for any device
2379  *   on the specified channel; this happens when a channel is going
2380  *   to be reset and all devices on that channel must be aborted.
2381  *-F*************************************************************************/
2382 static int
2383 aic7xxx_match_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb,
2384     int target, int channel, int lun, unsigned char tag)
2385 {
2386   int targ = (scb->hscb->target_channel_lun >> 4) & 0x0F;
2387   int chan = (scb->hscb->target_channel_lun >> 3) & 0x01;
2388   int slun = scb->hscb->target_channel_lun & 0x07;
2389   int match;
2390
2391   match = ((chan == channel) || (channel == ALL_CHANNELS));
2392   if (match != 0)
2393     match = ((targ == target) || (target == ALL_TARGETS));
2394   if (match != 0)
2395     match = ((lun == slun) || (lun == ALL_LUNS));
2396   if (match != 0)
2397     match = ((tag == scb->hscb->tag) || (tag == SCB_LIST_NULL));
2398
2399   return (match);
2400 }
2401
2402 /*+F*************************************************************************
2403  * Function:
2404  *   aic7xxx_add_curscb_to_free_list
2405  *
2406  * Description:
2407  *   Adds the current scb (in SCBPTR) to the list of free SCBs.
2408  *-F*************************************************************************/
2409 static void
2410 aic7xxx_add_curscb_to_free_list(struct aic7xxx_host *p)
2411 {
2412   /*
2413    * Invalidate the tag so that aic7xxx_find_scb doesn't think
2414    * it's active
2415    */
2416   aic_outb(p, SCB_LIST_NULL, SCB_TAG);
2417   aic_outb(p, 0, SCB_CONTROL);
2418
2419   aic_outb(p, aic_inb(p, FREE_SCBH), SCB_NEXT);
2420   aic_outb(p, aic_inb(p, SCBPTR), FREE_SCBH);
2421 }
2422
2423 /*+F*************************************************************************
2424  * Function:
2425  *   aic7xxx_rem_scb_from_disc_list
2426  *
2427  * Description:
2428  *   Removes the current SCB from the disconnected list and adds it
2429  *   to the free list.
2430  *-F*************************************************************************/
2431 static unsigned char
2432 aic7xxx_rem_scb_from_disc_list(struct aic7xxx_host *p, unsigned char scbptr,
2433                                unsigned char prev)
2434 {
2435   unsigned char next;
2436
2437   aic_outb(p, scbptr, SCBPTR);
2438   next = aic_inb(p, SCB_NEXT);
2439   aic7xxx_add_curscb_to_free_list(p);
2440
2441   if (prev != SCB_LIST_NULL)
2442   {
2443     aic_outb(p, prev, SCBPTR);
2444     aic_outb(p, next, SCB_NEXT);
2445   }
2446   else
2447   {
2448     aic_outb(p, next, DISCONNECTED_SCBH);
2449   }
2450
2451   return next;
2452 }
2453
2454 /*+F*************************************************************************
2455  * Function:
2456  *   aic7xxx_busy_target
2457  *
2458  * Description:
2459  *   Set the specified target busy.
2460  *-F*************************************************************************/
2461 static inline void
2462 aic7xxx_busy_target(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2463 {
2464   p->untagged_scbs[scb->hscb->target_channel_lun] = scb->hscb->tag;
2465 }
2466
2467 /*+F*************************************************************************
2468  * Function:
2469  *   aic7xxx_index_busy_target
2470  *
2471  * Description:
2472  *   Returns the index of the busy target, and optionally sets the
2473  *   target inactive.
2474  *-F*************************************************************************/
2475 static inline unsigned char
2476 aic7xxx_index_busy_target(struct aic7xxx_host *p, unsigned char tcl,
2477     int unbusy)
2478 {
2479   unsigned char busy_scbid;
2480
2481   busy_scbid = p->untagged_scbs[tcl];
2482   if (unbusy)
2483   {
2484     p->untagged_scbs[tcl] = SCB_LIST_NULL;
2485   }
2486   return (busy_scbid);
2487 }
2488
2489 /*+F*************************************************************************
2490  * Function:
2491  *   aic7xxx_find_scb
2492  *
2493  * Description:
2494  *   Look through the SCB array of the card and attempt to find the
2495  *   hardware SCB that corresponds to the passed in SCB.  Return
2496  *   SCB_LIST_NULL if unsuccessful.  This routine assumes that the
2497  *   card is already paused.
2498  *-F*************************************************************************/
2499 static unsigned char
2500 aic7xxx_find_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2501 {
2502   unsigned char saved_scbptr;
2503   unsigned char curindex;
2504
2505   saved_scbptr = aic_inb(p, SCBPTR);
2506   curindex = 0;
2507   for (curindex = 0; curindex < p->scb_data->maxhscbs; curindex++)
2508   {
2509     aic_outb(p, curindex, SCBPTR);
2510     if (aic_inb(p, SCB_TAG) == scb->hscb->tag)
2511     {
2512       break;
2513     }
2514   }
2515   aic_outb(p, saved_scbptr, SCBPTR);
2516   if (curindex >= p->scb_data->maxhscbs)
2517   {
2518     curindex = SCB_LIST_NULL;
2519   }
2520
2521   return (curindex);
2522 }
2523
2524 /*+F*************************************************************************
2525  * Function:
2526  *   aic7xxx_allocate_scb
2527  *
2528  * Description:
2529  *   Get an SCB from the free list or by allocating a new one.
2530  *-F*************************************************************************/
2531 static int
2532 aic7xxx_allocate_scb(struct aic7xxx_host *p)
2533 {
2534   struct aic7xxx_scb   *scbp = NULL;
2535   int scb_size = (sizeof (struct hw_scatterlist) * AIC7XXX_MAX_SG) + 12 + 6;
2536   int i;
2537   int step = PAGE_SIZE / 1024;
2538   unsigned long scb_count = 0;
2539   struct hw_scatterlist *hsgp;
2540   struct aic7xxx_scb *scb_ap;
2541   struct aic7xxx_scb_dma *scb_dma;
2542   unsigned char *bufs;
2543
2544   if (p->scb_data->numscbs < p->scb_data->maxscbs)
2545   {
2546     /*
2547      * Calculate the optimal number of SCBs to allocate.
2548      *
2549      * NOTE: This formula works because the sizeof(sg_array) is always
2550      * 1024.  Therefore, scb_size * i would always be > PAGE_SIZE *
2551      * (i/step).  The (i-1) allows the left hand side of the equation
2552      * to grow into the right hand side to a point of near perfect
2553      * efficiency since scb_size * (i -1) is growing slightly faster
2554      * than the right hand side.  If the number of SG array elements
2555      * is changed, this function may not be near so efficient any more.
2556      *
2557      * Since the DMA'able buffers are now allocated in a separate
2558      * chunk this algorithm has been modified to match.  The '12'
2559      * and '6' factors in scb_size are for the DMA'able command byte
2560      * and sensebuffers respectively.  -DaveM
2561      */
2562     for ( i=step;; i *= 2 )
2563     {
2564       if ( (scb_size * (i-1)) >= ( (PAGE_SIZE * (i/step)) - 64 ) )
2565       {
2566         i /= 2;
2567         break;
2568       }
2569     }
2570     scb_count = min( (i-1), p->scb_data->maxscbs - p->scb_data->numscbs);
2571     scb_ap = (struct aic7xxx_scb *)kmalloc(sizeof (struct aic7xxx_scb) * scb_count
2572                                            + sizeof(struct aic7xxx_scb_dma), GFP_ATOMIC);
2573     if (scb_ap == NULL)
2574       return(0);
2575     scb_dma = (struct aic7xxx_scb_dma *)&scb_ap[scb_count];
2576     hsgp = (struct hw_scatterlist *)
2577       pci_alloc_consistent(p->pdev, scb_size * scb_count,
2578                            &scb_dma->dma_address);
2579     if (hsgp == NULL)
2580     {
2581       kfree(scb_ap);
2582       return(0);
2583     }
2584     bufs = (unsigned char *)&hsgp[scb_count * AIC7XXX_MAX_SG];
2585 #ifdef AIC7XXX_VERBOSE_DEBUGGING
2586     if (aic7xxx_verbose > 0xffff)
2587     {
2588       if (p->scb_data->numscbs == 0)
2589         printk(INFO_LEAD "Allocating initial %ld SCB structures.\n",
2590           p->host_no, -1, -1, -1, scb_count);
2591       else
2592         printk(INFO_LEAD "Allocating %ld additional SCB structures.\n",
2593           p->host_no, -1, -1, -1, scb_count);
2594     }
2595 #endif
2596     memset(scb_ap, 0, sizeof (struct aic7xxx_scb) * scb_count);
2597     scb_dma->dma_offset = (unsigned long)scb_dma->dma_address
2598                           - (unsigned long)hsgp;
2599     scb_dma->dma_len = scb_size * scb_count;
2600     for (i=0; i < scb_count; i++)
2601     {
2602       scbp = &scb_ap[i];
2603       scbp->hscb = &p->scb_data->hscbs[p->scb_data->numscbs];
2604       scbp->sg_list = &hsgp[i * AIC7XXX_MAX_SG];
2605       scbp->sense_cmd = bufs;
2606       scbp->cmnd = bufs + 6;
2607       bufs += 12 + 6;
2608       scbp->scb_dma = scb_dma;
2609       memset(scbp->hscb, 0, sizeof(struct aic7xxx_hwscb));
2610       scbp->hscb->tag = p->scb_data->numscbs;
2611       /*
2612        * Place in the scb array; never is removed
2613        */
2614       p->scb_data->scb_array[p->scb_data->numscbs++] = scbp;
2615       scbq_insert_tail(&p->scb_data->free_scbs, scbp);
2616     }
2617     scbp->kmalloc_ptr = scb_ap;
2618   }
2619   return(scb_count);
2620 }
2621
2622 /*+F*************************************************************************
2623  * Function:
2624  *   aic7xxx_queue_cmd_complete
2625  *
2626  * Description:
2627  *   Due to race conditions present in the SCSI subsystem, it is easier
2628  *   to queue completed commands, then call scsi_done() on them when
2629  *   we're finished.  This function queues the completed commands.
2630  *-F*************************************************************************/
2631 static void
2632 aic7xxx_queue_cmd_complete(struct aic7xxx_host *p, Scsi_Cmnd *cmd)
2633 {
2634   aic7xxx_position(cmd) = SCB_LIST_NULL;
2635   cmd->host_scribble = (char *)p->completeq.head;
2636   p->completeq.head = cmd;
2637 }
2638
2639 /*+F*************************************************************************
2640  * Function:
2641  *   aic7xxx_done_cmds_complete
2642  *
2643  * Description:
2644  *   Process the completed command queue.
2645  *-F*************************************************************************/
2646 static void
2647 aic7xxx_done_cmds_complete(struct aic7xxx_host *p)
2648 {
2649   Scsi_Cmnd *cmd;
2650
2651   while (p->completeq.head != NULL)
2652   {
2653     cmd = p->completeq.head;
2654     p->completeq.head = (Scsi_Cmnd *)cmd->host_scribble;
2655     cmd->host_scribble = NULL;
2656     cmd->scsi_done(cmd);
2657   }
2658 }
2659
2660 /*+F*************************************************************************
2661  * Function:
2662  *   aic7xxx_free_scb
2663  *
2664  * Description:
2665  *   Free the scb and insert into the free scb list.
2666  *-F*************************************************************************/
2667 static void
2668 aic7xxx_free_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2669 {
2670
2671   scb->flags = SCB_FREE;
2672   scb->cmd = NULL;
2673   scb->sg_count = 0;
2674   scb->sg_length = 0;
2675   scb->tag_action = 0;
2676   scb->hscb->control = 0;
2677   scb->hscb->target_status = 0;
2678   scb->hscb->target_channel_lun = SCB_LIST_NULL;
2679
2680   scbq_insert_head(&p->scb_data->free_scbs, scb);
2681 }
2682
2683 /*+F*************************************************************************
2684  * Function:
2685  *   aic7xxx_done
2686  *
2687  * Description:
2688  *   Calls the higher level scsi done function and frees the scb.
2689  *-F*************************************************************************/
2690 static void
2691 aic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
2692 {
2693   Scsi_Cmnd *cmd = scb->cmd;
2694   struct aic_dev_data *aic_dev = cmd->device->hostdata;
2695   int tindex = TARGET_INDEX(cmd);
2696   struct aic7xxx_scb *scbp;
2697   unsigned char queue_depth;
2698
2699   if (cmd->use_sg > 1)
2700   {
2701     struct scatterlist *sg;
2702
2703     sg = (struct scatterlist *)cmd->request_buffer;
2704     pci_unmap_sg(p->pdev, sg, cmd->use_sg, scsi_to_pci_dma_dir(cmd->sc_data_direction));
2705   }
2706   else if (cmd->request_bufflen)
2707     pci_unmap_single(p->pdev, aic7xxx_mapping(cmd),
2708                      cmd->request_bufflen,
2709                      scsi_to_pci_dma_dir(cmd->sc_data_direction));
2710   if (scb->flags & SCB_SENSE)
2711   {
2712     pci_unmap_single(p->pdev,
2713                      le32_to_cpu(scb->sg_list[0].address),
2714                      sizeof(cmd->sense_buffer),
2715                      PCI_DMA_FROMDEVICE);
2716   }
2717   if (scb->flags & SCB_RECOVERY_SCB)
2718   {
2719     p->flags &= ~AHC_ABORT_PENDING;
2720   }
2721   if (scb->flags & (SCB_RESET|SCB_ABORT))
2722   {
2723     cmd->result |= (DID_RESET << 16);
2724   }
2725
2726   if ((scb->flags & SCB_MSGOUT_BITS) != 0)
2727   {
2728     unsigned short mask;
2729     int message_error = FALSE;
2730
2731     mask = 0x01 << tindex;
2732
2733     /*
2734      * Check to see if we get an invalid message or a message error
2735      * after failing to negotiate a wide or sync transfer message.
2736      */
2737     if ((scb->flags & SCB_SENSE) &&
2738           ((scb->cmd->sense_buffer[12] == 0x43) ||  /* INVALID_MESSAGE */
2739           (scb->cmd->sense_buffer[12] == 0x49))) /* MESSAGE_ERROR  */
2740     {
2741       message_error = TRUE;
2742     }
2743
2744     if (scb->flags & SCB_MSGOUT_WDTR)
2745     {
2746       if (message_error)
2747       {
2748         if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
2749              (aic_dev->flags & DEVICE_PRINT_DTR) )
2750         {
2751           printk(INFO_LEAD "Device failed to complete Wide Negotiation "
2752             "processing and\n", p->host_no, CTL_OF_SCB(scb));
2753           printk(INFO_LEAD "returned a sense error code for invalid message, "
2754             "disabling future\n", p->host_no, CTL_OF_SCB(scb));
2755           printk(INFO_LEAD "Wide negotiation to this device.\n", p->host_no,
2756             CTL_OF_SCB(scb));
2757         }
2758         aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
2759       }
2760     }
2761     if (scb->flags & SCB_MSGOUT_SDTR)
2762     {
2763       if (message_error)
2764       {
2765         if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
2766              (aic_dev->flags & DEVICE_PRINT_DTR) )
2767         {
2768           printk(INFO_LEAD "Device failed to complete Sync Negotiation "
2769             "processing and\n", p->host_no, CTL_OF_SCB(scb));
2770           printk(INFO_LEAD "returned a sense error code for invalid message, "
2771             "disabling future\n", p->host_no, CTL_OF_SCB(scb));
2772           printk(INFO_LEAD "Sync negotiation to this device.\n", p->host_no,
2773             CTL_OF_SCB(scb));
2774           aic_dev->flags &= ~DEVICE_PRINT_DTR;
2775         }
2776         aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
2777       }
2778     }
2779     if (scb->flags & SCB_MSGOUT_PPR)
2780     {
2781       if(message_error)
2782       {
2783         if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
2784              (aic_dev->flags & DEVICE_PRINT_DTR) )
2785         {
2786           printk(INFO_LEAD "Device failed to complete Parallel Protocol "
2787             "Request processing and\n", p->host_no, CTL_OF_SCB(scb));
2788           printk(INFO_LEAD "returned a sense error code for invalid message, "
2789             "disabling future\n", p->host_no, CTL_OF_SCB(scb));
2790           printk(INFO_LEAD "Parallel Protocol Request negotiation to this "
2791             "device.\n", p->host_no, CTL_OF_SCB(scb));
2792         }
2793         /*
2794          * Disable PPR negotiation and revert back to WDTR and SDTR setup
2795          */
2796         aic_dev->needppr = aic_dev->needppr_copy = 0;
2797         aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
2798         aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
2799       }
2800     }
2801   }
2802
2803   queue_depth = aic_dev->temp_q_depth;
2804   if (queue_depth >= aic_dev->active_cmds)
2805   {
2806     scbp = scbq_remove_head(&aic_dev->delayed_scbs);
2807     if (scbp)
2808     {
2809       if (queue_depth == 1)
2810       {
2811         /*
2812          * Give extra preference to untagged devices, such as CD-R devices
2813          * This makes it more likely that a drive *won't* stuff up while
2814          * waiting on data at a critical time, such as CD-R writing and
2815          * audio CD ripping operations.  Should also benefit tape drives.
2816          */
2817         scbq_insert_head(&p->waiting_scbs, scbp);
2818       }
2819       else
2820       {
2821         scbq_insert_tail(&p->waiting_scbs, scbp);
2822       }
2823 #ifdef AIC7XXX_VERBOSE_DEBUGGING
2824       if (aic7xxx_verbose > 0xffff)
2825         printk(INFO_LEAD "Moving SCB from delayed to waiting queue.\n",
2826                p->host_no, CTL_OF_SCB(scbp));
2827 #endif
2828       if (queue_depth > aic_dev->active_cmds)
2829       {
2830         scbp = scbq_remove_head(&aic_dev->delayed_scbs);
2831         if (scbp)
2832           scbq_insert_tail(&p->waiting_scbs, scbp);
2833       }
2834     }
2835   }
2836   if (!(scb->tag_action))
2837   {
2838     aic7xxx_index_busy_target(p, scb->hscb->target_channel_lun,
2839                               /* unbusy */ TRUE);
2840     if (cmd->device->simple_tags)
2841     {
2842       aic_dev->temp_q_depth = aic_dev->max_q_depth;
2843     }
2844   }
2845   if(scb->flags & SCB_DTR_SCB)
2846   {
2847     aic_dev->dtr_pending = 0;
2848   }
2849   aic_dev->active_cmds--;
2850   p->activescbs--;
2851
2852   if ((scb->sg_length >= 512) && (((cmd->result >> 16) & 0xf) == DID_OK))
2853   {
2854     long *ptr;
2855     int x, i;
2856
2857
2858     if (rq_data_dir(cmd->request) == WRITE)
2859     {
2860       aic_dev->w_total++;
2861       ptr = aic_dev->w_bins;
2862     }
2863     else
2864     {
2865       aic_dev->r_total++;
2866       ptr = aic_dev->r_bins;
2867     }
2868     if(cmd->device->simple_tags && cmd->request->flags & REQ_HARDBARRIER)
2869     {
2870       aic_dev->barrier_total++;
2871       if(scb->tag_action == MSG_ORDERED_Q_TAG)
2872         aic_dev->ordered_total++;
2873     }
2874     x = scb->sg_length;
2875     x >>= 10;
2876     for(i=0; i<6; i++)
2877     {
2878       x >>= 2;
2879       if(!x) {
2880         ptr[i]++;
2881         break;
2882       }
2883     }
2884     if(i == 6 && x)
2885       ptr[5]++;
2886   }
2887   aic7xxx_free_scb(p, scb);
2888   aic7xxx_queue_cmd_complete(p, cmd);
2889
2890 }
2891
2892 /*+F*************************************************************************
2893  * Function:
2894  *   aic7xxx_run_done_queue
2895  *
2896  * Description:
2897  *   Calls the aic7xxx_done() for the Scsi_Cmnd of each scb in the
2898  *   aborted list, and adds each scb to the free list.  If complete
2899  *   is TRUE, we also process the commands complete list.
2900  *-F*************************************************************************/
2901 static void
2902 aic7xxx_run_done_queue(struct aic7xxx_host *p, /*complete*/ int complete)
2903 {
2904   struct aic7xxx_scb *scb;
2905   int i, found = 0;
2906
2907   for (i = 0; i < p->scb_data->numscbs; i++)
2908   {
2909     scb = p->scb_data->scb_array[i];
2910     if (scb->flags & SCB_QUEUED_FOR_DONE)
2911     {
2912       if (scb->flags & SCB_QUEUE_FULL)
2913       {
2914         scb->cmd->result = QUEUE_FULL << 1;
2915       }
2916       else
2917       {
2918         if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
2919           printk(INFO_LEAD "Aborting scb %d\n",
2920                p->host_no, CTL_OF_SCB(scb), scb->hscb->tag);
2921         /*
2922          * Clear any residual information since the normal aic7xxx_done() path
2923          * doesn't touch the residuals.
2924          */
2925         scb->hscb->residual_SG_segment_count = 0;
2926         scb->hscb->residual_data_count[0] = 0;
2927         scb->hscb->residual_data_count[1] = 0;
2928         scb->hscb->residual_data_count[2] = 0;
2929       }
2930       found++;
2931       aic7xxx_done(p, scb);
2932     }
2933   }
2934   if (aic7xxx_verbose & (VERBOSE_ABORT_RETURN | VERBOSE_RESET_RETURN))
2935   {
2936     printk(INFO_LEAD "%d commands found and queued for "
2937         "completion.\n", p->host_no, -1, -1, -1, found);
2938   }
2939   if (complete)
2940   {
2941     aic7xxx_done_cmds_complete(p);
2942   }
2943 }
2944
2945 /*+F*************************************************************************
2946  * Function:
2947  *   aic7xxx_abort_waiting_scb
2948  *
2949  * Description:
2950  *   Manipulate the waiting for selection list and return the
2951  *   scb that follows the one that we remove.
2952  *-F*************************************************************************/
2953 static unsigned char
2954 aic7xxx_abort_waiting_scb(struct aic7xxx_host *p, struct aic7xxx_scb *scb,
2955     unsigned char scbpos, unsigned char prev)
2956 {
2957   unsigned char curscb, next;
2958
2959   /*
2960    * Select the SCB we want to abort and pull the next pointer out of it.
2961    */
2962   curscb = aic_inb(p, SCBPTR);
2963   aic_outb(p, scbpos, SCBPTR);
2964   next = aic_inb(p, SCB_NEXT);
2965
2966   aic7xxx_add_curscb_to_free_list(p);
2967
2968   /*
2969    * Update the waiting list
2970    */
2971   if (prev == SCB_LIST_NULL)
2972   {
2973     /*
2974      * First in the list
2975      */
2976     aic_outb(p, next, WAITING_SCBH);
2977   }
2978   else
2979   {
2980     /*
2981      * Select the scb that pointed to us and update its next pointer.
2982      */
2983     aic_outb(p, prev, SCBPTR);
2984     aic_outb(p, next, SCB_NEXT);
2985   }
2986   /*
2987    * Point us back at the original scb position and inform the SCSI
2988    * system that the command has been aborted.
2989    */
2990   aic_outb(p, curscb, SCBPTR);
2991   return (next);
2992 }
2993
2994 /*+F*************************************************************************
2995  * Function:
2996  *   aic7xxx_search_qinfifo
2997  *
2998  * Description:
2999  *   Search the queue-in FIFO for matching SCBs and conditionally
3000  *   requeue.  Returns the number of matching SCBs.
3001  *-F*************************************************************************/
3002 static int
3003 aic7xxx_search_qinfifo(struct aic7xxx_host *p, int target, int channel,
3004     int lun, unsigned char tag, int flags, int requeue,
3005     volatile scb_queue_type *queue)
3006 {
3007   int      found;
3008   unsigned char qinpos, qintail;
3009   struct aic7xxx_scb *scbp;
3010
3011   found = 0;
3012   qinpos = aic_inb(p, QINPOS);
3013   qintail = p->qinfifonext;
3014
3015   p->qinfifonext = qinpos;
3016
3017   while (qinpos != qintail)
3018   {
3019     scbp = p->scb_data->scb_array[p->qinfifo[qinpos++]];
3020     if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3021     {
3022        /*
3023         * We found an scb that needs to be removed.
3024         */
3025        if (requeue && (queue != NULL))
3026        {
3027          if (scbp->flags & SCB_WAITINGQ)
3028          {
3029            scbq_remove(queue, scbp);
3030            scbq_remove(&p->waiting_scbs, scbp);
3031            scbq_remove(&AIC_DEV(scbp->cmd)->delayed_scbs, scbp);
3032            AIC_DEV(scbp->cmd)->active_cmds++;
3033            p->activescbs++;
3034          }
3035          scbq_insert_tail(queue, scbp);
3036          AIC_DEV(scbp->cmd)->active_cmds--;
3037          p->activescbs--;
3038          scbp->flags |= SCB_WAITINGQ;
3039          if ( !(scbp->tag_action & TAG_ENB) )
3040          {
3041            aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun,
3042              TRUE);
3043          }
3044        }
3045        else if (requeue)
3046        {
3047          p->qinfifo[p->qinfifonext++] = scbp->hscb->tag;
3048        }
3049        else
3050        {
3051         /*
3052          * Preserve any SCB_RECOVERY_SCB flags on this scb then set the
3053          * flags we were called with, presumeably so aic7xxx_run_done_queue
3054          * can find this scb
3055          */
3056          scbp->flags = flags | (scbp->flags & SCB_RECOVERY_SCB);
3057          if (aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun,
3058                                        FALSE) == scbp->hscb->tag)
3059          {
3060            aic7xxx_index_busy_target(p, scbp->hscb->target_channel_lun,
3061              TRUE);
3062          }
3063        }
3064        found++;
3065     }
3066     else
3067     {
3068       p->qinfifo[p->qinfifonext++] = scbp->hscb->tag;
3069     }
3070   }
3071   /*
3072    * Now that we've done the work, clear out any left over commands in the
3073    * qinfifo and update the KERNEL_QINPOS down on the card.
3074    *
3075    *  NOTE: This routine expect the sequencer to already be paused when
3076    *        it is run....make sure it's that way!
3077    */
3078   qinpos = p->qinfifonext;
3079   while(qinpos != qintail)
3080   {
3081     p->qinfifo[qinpos++] = SCB_LIST_NULL;
3082   }
3083   if (p->features & AHC_QUEUE_REGS)
3084     aic_outb(p, p->qinfifonext, HNSCB_QOFF);
3085   else
3086     aic_outb(p, p->qinfifonext, KERNEL_QINPOS);
3087
3088   return (found);
3089 }
3090
3091 /*+F*************************************************************************
3092  * Function:
3093  *   aic7xxx_scb_on_qoutfifo
3094  *
3095  * Description:
3096  *   Is the scb that was passed to us currently on the qoutfifo?
3097  *-F*************************************************************************/
3098 static int
3099 aic7xxx_scb_on_qoutfifo(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
3100 {
3101   int i=0;
3102
3103   while(p->qoutfifo[(p->qoutfifonext + i) & 0xff ] != SCB_LIST_NULL)
3104   {
3105     if(p->qoutfifo[(p->qoutfifonext + i) & 0xff ] == scb->hscb->tag)
3106       return TRUE;
3107     else
3108       i++;
3109   }
3110   return FALSE;
3111 }
3112
3113
3114 /*+F*************************************************************************
3115  * Function:
3116  *   aic7xxx_reset_device
3117  *
3118  * Description:
3119  *   The device at the given target/channel has been reset.  Abort
3120  *   all active and queued scbs for that target/channel.  This function
3121  *   need not worry about linked next pointers because if was a MSG_ABORT_TAG
3122  *   then we had a tagged command (no linked next), if it was MSG_ABORT or
3123  *   MSG_BUS_DEV_RESET then the device won't know about any commands any more
3124  *   and no busy commands will exist, and if it was a bus reset, then nothing
3125  *   knows about any linked next commands any more.  In all cases, we don't
3126  *   need to worry about the linked next or busy scb, we just need to clear
3127  *   them.
3128  *-F*************************************************************************/
3129 static void
3130 aic7xxx_reset_device(struct aic7xxx_host *p, int target, int channel,
3131                      int lun, unsigned char tag)
3132 {
3133   struct aic7xxx_scb *scbp, *prev_scbp;
3134   struct scsi_device *sd;
3135   unsigned char active_scb, tcl, scb_tag;
3136   int i = 0, init_lists = FALSE;
3137   struct aic_dev_data *aic_dev;
3138
3139   /*
3140    * Restore this when we're done
3141    */
3142   active_scb = aic_inb(p, SCBPTR);
3143   scb_tag = aic_inb(p, SCB_TAG);
3144
3145   if (aic7xxx_verbose & (VERBOSE_RESET_PROCESS | VERBOSE_ABORT_PROCESS))
3146   {
3147     printk(INFO_LEAD "Reset device, hardware_scb %d,\n",
3148          p->host_no, channel, target, lun, active_scb);
3149     printk(INFO_LEAD "Current scb %d, SEQADDR 0x%x, LASTPHASE "
3150            "0x%x\n",
3151          p->host_no, channel, target, lun, scb_tag,
3152          aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
3153          aic_inb(p, LASTPHASE));
3154     printk(INFO_LEAD "SG_CACHEPTR 0x%x, SG_COUNT %d, SCSISIGI 0x%x\n",
3155          p->host_no, channel, target, lun,
3156          (p->features & AHC_ULTRA2) ?  aic_inb(p, SG_CACHEPTR) : 0,
3157          aic_inb(p, SG_COUNT), aic_inb(p, SCSISIGI));
3158     printk(INFO_LEAD "SSTAT0 0x%x, SSTAT1 0x%x, SSTAT2 0x%x\n",
3159          p->host_no, channel, target, lun, aic_inb(p, SSTAT0),
3160          aic_inb(p, SSTAT1), aic_inb(p, SSTAT2));
3161   }
3162
3163   /*
3164    * Deal with the busy target and linked next issues.
3165    */
3166   list_for_each_entry(aic_dev, &p->aic_devs, list)
3167   {
3168     if (aic7xxx_verbose & (VERBOSE_RESET_PROCESS | VERBOSE_ABORT_PROCESS))
3169       printk(INFO_LEAD "processing aic_dev %p\n", p->host_no, channel, target,
3170                     lun, aic_dev);
3171     sd = aic_dev->SDptr;
3172
3173     if((target != ALL_TARGETS && target != sd->id) ||
3174        (channel != ALL_CHANNELS && channel != sd->channel))
3175       continue;
3176     if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3177         printk(INFO_LEAD "Cleaning up status information "
3178           "and delayed_scbs.\n", p->host_no, sd->channel, sd->id, sd->lun);
3179     aic_dev->flags &= ~BUS_DEVICE_RESET_PENDING;
3180     if ( tag == SCB_LIST_NULL )
3181     {
3182       aic_dev->dtr_pending = 0;
3183       aic_dev->needppr = aic_dev->needppr_copy;
3184       aic_dev->needsdtr = aic_dev->needsdtr_copy;
3185       aic_dev->needwdtr = aic_dev->needwdtr_copy;
3186       aic_dev->flags = DEVICE_PRINT_DTR;
3187       aic_dev->temp_q_depth = aic_dev->max_q_depth;
3188     }
3189     tcl = (sd->id << 4) | (sd->channel << 3) | sd->lun;
3190     if ( (aic7xxx_index_busy_target(p, tcl, FALSE) == tag) ||
3191          (tag == SCB_LIST_NULL) )
3192       aic7xxx_index_busy_target(p, tcl, /* unbusy */ TRUE);
3193     prev_scbp = NULL;
3194     scbp = aic_dev->delayed_scbs.head;
3195     while (scbp != NULL)
3196     {
3197       prev_scbp = scbp;
3198       scbp = scbp->q_next;
3199       if (aic7xxx_match_scb(p, prev_scbp, target, channel, lun, tag))
3200       {
3201         scbq_remove(&aic_dev->delayed_scbs, prev_scbp);
3202         if (prev_scbp->flags & SCB_WAITINGQ)
3203         {
3204           aic_dev->active_cmds++;
3205           p->activescbs++;
3206         }
3207         prev_scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3208         prev_scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3209       }
3210     }
3211   }
3212
3213   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3214     printk(INFO_LEAD "Cleaning QINFIFO.\n", p->host_no, channel, target, lun );
3215   aic7xxx_search_qinfifo(p, target, channel, lun, tag,
3216       SCB_RESET | SCB_QUEUED_FOR_DONE, /* requeue */ FALSE, NULL);
3217
3218 /*
3219  *  Search the waiting_scbs queue for matches, this catches any SCB_QUEUED
3220  *  ABORT/RESET commands.
3221  */
3222   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3223     printk(INFO_LEAD "Cleaning waiting_scbs.\n", p->host_no, channel,
3224       target, lun );
3225   {
3226     struct aic7xxx_scb *scbp, *prev_scbp;
3227
3228     prev_scbp = NULL;
3229     scbp = p->waiting_scbs.head;
3230     while (scbp != NULL)
3231     {
3232       prev_scbp = scbp;
3233       scbp = scbp->q_next;
3234       if (aic7xxx_match_scb(p, prev_scbp, target, channel, lun, tag))
3235       {
3236         scbq_remove(&p->waiting_scbs, prev_scbp);
3237         if (prev_scbp->flags & SCB_WAITINGQ)
3238         {
3239           AIC_DEV(prev_scbp->cmd)->active_cmds++;
3240           p->activescbs++;
3241         }
3242         prev_scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3243         prev_scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3244       }
3245     }
3246   }
3247
3248
3249   /*
3250    * Search waiting for selection list.
3251    */
3252   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3253     printk(INFO_LEAD "Cleaning waiting for selection "
3254       "list.\n", p->host_no, channel, target, lun);
3255   {
3256     unsigned char next, prev, scb_index;
3257
3258     next = aic_inb(p, WAITING_SCBH);  /* Start at head of list. */
3259     prev = SCB_LIST_NULL;
3260     while (next != SCB_LIST_NULL)
3261     {
3262       aic_outb(p, next, SCBPTR);
3263       scb_index = aic_inb(p, SCB_TAG);
3264       if (scb_index >= p->scb_data->numscbs)
3265       {
3266        /*
3267         * No aic7xxx_verbose check here.....we want to see this since it
3268         * means either the kernel driver or the sequencer screwed things up
3269         */
3270         printk(WARN_LEAD "Waiting List inconsistency; SCB index=%d, "
3271           "numscbs=%d\n", p->host_no, channel, target, lun, scb_index,
3272           p->scb_data->numscbs);
3273         next = aic_inb(p, SCB_NEXT);
3274         aic7xxx_add_curscb_to_free_list(p);
3275       }
3276       else
3277       {
3278         scbp = p->scb_data->scb_array[scb_index];
3279         if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3280         {
3281           next = aic7xxx_abort_waiting_scb(p, scbp, next, prev);
3282           if (scbp->flags & SCB_WAITINGQ)
3283           {
3284             AIC_DEV(scbp->cmd)->active_cmds++;
3285             p->activescbs++;
3286           }
3287           scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3288           scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3289           if (prev == SCB_LIST_NULL)
3290           {
3291             /*
3292              * This is either the first scb on the waiting list, or we
3293              * have already yanked the first and haven't left any behind.
3294              * Either way, we need to turn off the selection hardware if
3295              * it isn't already off.
3296              */
3297             aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ);
3298             aic_outb(p, CLRSELTIMEO, CLRSINT1);
3299           }
3300         }
3301         else
3302         {
3303           prev = next;
3304           next = aic_inb(p, SCB_NEXT);
3305         }
3306       }
3307     }
3308   }
3309
3310   /*
3311    * Go through disconnected list and remove any entries we have queued
3312    * for completion, zeroing their control byte too.
3313    */
3314   if (aic7xxx_verbose & (VERBOSE_ABORT_PROCESS | VERBOSE_RESET_PROCESS))
3315     printk(INFO_LEAD "Cleaning disconnected scbs "
3316       "list.\n", p->host_no, channel, target, lun);
3317   if (p->flags & AHC_PAGESCBS)
3318   {
3319     unsigned char next, prev, scb_index;
3320
3321     next = aic_inb(p, DISCONNECTED_SCBH);
3322     prev = SCB_LIST_NULL;
3323     while (next != SCB_LIST_NULL)
3324     {
3325       aic_outb(p, next, SCBPTR);
3326       scb_index = aic_inb(p, SCB_TAG);
3327       if (scb_index > p->scb_data->numscbs)
3328       {
3329         printk(WARN_LEAD "Disconnected List inconsistency; SCB index=%d, "
3330           "numscbs=%d\n", p->host_no, channel, target, lun, scb_index,
3331           p->scb_data->numscbs);
3332         next = aic7xxx_rem_scb_from_disc_list(p, next, prev);
3333       }
3334       else
3335       {
3336         scbp = p->scb_data->scb_array[scb_index];
3337         if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3338         {
3339           next = aic7xxx_rem_scb_from_disc_list(p, next, prev);
3340           if (scbp->flags & SCB_WAITINGQ)
3341           {
3342             AIC_DEV(scbp->cmd)->active_cmds++;
3343             p->activescbs++;
3344           }
3345           scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3346           scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3347           scbp->hscb->control = 0;
3348         }
3349         else
3350         {
3351           prev = next;
3352           next = aic_inb(p, SCB_NEXT);
3353         }
3354       }
3355     }
3356   }
3357
3358   /*
3359    * Walk the free list making sure no entries on the free list have
3360    * a valid SCB_TAG value or SCB_CONTROL byte.
3361    */
3362   if (p->flags & AHC_PAGESCBS)
3363   {
3364     unsigned char next;
3365
3366     next = aic_inb(p, FREE_SCBH);
3367     while (next != SCB_LIST_NULL)
3368     {
3369       aic_outb(p, next, SCBPTR);
3370       if (aic_inb(p, SCB_TAG) < p->scb_data->numscbs)
3371       {
3372         printk(WARN_LEAD "Free list inconsistency!.\n", p->host_no, channel,
3373           target, lun);
3374         init_lists = TRUE;
3375         next = SCB_LIST_NULL;
3376       }
3377       else
3378       {
3379         aic_outb(p, SCB_LIST_NULL, SCB_TAG);
3380         aic_outb(p, 0, SCB_CONTROL);
3381         next = aic_inb(p, SCB_NEXT);
3382       }
3383     }
3384   }
3385
3386   /*
3387    * Go through the hardware SCB array looking for commands that
3388    * were active but not on any list.
3389    */
3390   if (init_lists)
3391   {
3392     aic_outb(p, SCB_LIST_NULL, FREE_SCBH);
3393     aic_outb(p, SCB_LIST_NULL, WAITING_SCBH);
3394     aic_outb(p, SCB_LIST_NULL, DISCONNECTED_SCBH);
3395   }
3396   for (i = p->scb_data->maxhscbs - 1; i >= 0; i--)
3397   {
3398     unsigned char scbid;
3399
3400     aic_outb(p, i, SCBPTR);
3401     if (init_lists)
3402     {
3403       aic_outb(p, SCB_LIST_NULL, SCB_TAG);
3404       aic_outb(p, SCB_LIST_NULL, SCB_NEXT);
3405       aic_outb(p, 0, SCB_CONTROL);
3406       aic7xxx_add_curscb_to_free_list(p);
3407     }
3408     else
3409     {
3410       scbid = aic_inb(p, SCB_TAG);
3411       if (scbid < p->scb_data->numscbs)
3412       {
3413         scbp = p->scb_data->scb_array[scbid];
3414         if (aic7xxx_match_scb(p, scbp, target, channel, lun, tag))
3415         {
3416           aic_outb(p, 0, SCB_CONTROL);
3417           aic_outb(p, SCB_LIST_NULL, SCB_TAG);
3418           aic7xxx_add_curscb_to_free_list(p);
3419         }
3420       }
3421     }
3422   }
3423
3424   /*
3425    * Go through the entire SCB array now and look for commands for
3426    * for this target that are stillactive.  These are other (most likely
3427    * tagged) commands that were disconnected when the reset occurred.
3428    * Any commands we find here we know this about, it wasn't on any queue,
3429    * it wasn't in the qinfifo, it wasn't in the disconnected or waiting
3430    * lists, so it really must have been a paged out SCB.  In that case,
3431    * we shouldn't need to bother with updating any counters, just mark
3432    * the correct flags and go on.
3433    */
3434   for (i = 0; i < p->scb_data->numscbs; i++)
3435   {
3436     scbp = p->scb_data->scb_array[i];
3437     if ((scbp->flags & SCB_ACTIVE) &&
3438         aic7xxx_match_scb(p, scbp, target, channel, lun, tag) &&
3439         !aic7xxx_scb_on_qoutfifo(p, scbp))
3440     {
3441       if (scbp->flags & SCB_WAITINGQ)
3442       {
3443         scbq_remove(&p->waiting_scbs, scbp);
3444         scbq_remove(&AIC_DEV(scbp->cmd)->delayed_scbs, scbp);
3445         AIC_DEV(scbp->cmd)->active_cmds++;
3446         p->activescbs++;
3447       }
3448       scbp->flags |= SCB_RESET | SCB_QUEUED_FOR_DONE;
3449       scbp->flags &= ~(SCB_ACTIVE | SCB_WAITINGQ);
3450     }
3451   }
3452
3453   aic_outb(p, active_scb, SCBPTR);
3454 }
3455
3456
3457 /*+F*************************************************************************
3458  * Function:
3459  *   aic7xxx_clear_intstat
3460  *
3461  * Description:
3462  *   Clears the interrupt status.
3463  *-F*************************************************************************/
3464 static void
3465 aic7xxx_clear_intstat(struct aic7xxx_host *p)
3466 {
3467   /* Clear any interrupt conditions this may have caused. */
3468   aic_outb(p, CLRSELDO | CLRSELDI | CLRSELINGO, CLRSINT0);
3469   aic_outb(p, CLRSELTIMEO | CLRATNO | CLRSCSIRSTI | CLRBUSFREE | CLRSCSIPERR |
3470        CLRPHASECHG | CLRREQINIT, CLRSINT1);
3471   aic_outb(p, CLRSCSIINT | CLRSEQINT | CLRBRKADRINT | CLRPARERR, CLRINT);
3472 }
3473
3474 /*+F*************************************************************************
3475  * Function:
3476  *   aic7xxx_reset_current_bus
3477  *
3478  * Description:
3479  *   Reset the current SCSI bus.
3480  *-F*************************************************************************/
3481 static void
3482 aic7xxx_reset_current_bus(struct aic7xxx_host *p)
3483 {
3484
3485   /* Disable reset interrupts. */
3486   aic_outb(p, aic_inb(p, SIMODE1) & ~ENSCSIRST, SIMODE1);
3487
3488   /* Turn off the bus' current operations, after all, we shouldn't have any
3489    * valid commands left to cause a RSELI and SELO once we've tossed the
3490    * bus away with this reset, so we might as well shut down the sequencer
3491    * until the bus is restarted as oppossed to saving the current settings
3492    * and restoring them (which makes no sense to me). */
3493
3494   /* Turn on the bus reset. */
3495   aic_outb(p, aic_inb(p, SCSISEQ) | SCSIRSTO, SCSISEQ);
3496   while ( (aic_inb(p, SCSISEQ) & SCSIRSTO) == 0)
3497     mdelay(5);
3498
3499   /*
3500    * Some of the new Ultra2 chipsets need a longer delay after a chip
3501    * reset than just the init setup creates, so we have to delay here
3502    * before we go into a reset in order to make the chips happy.
3503    */
3504   if (p->features & AHC_ULTRA2)
3505     mdelay(250);
3506   else
3507     mdelay(50);
3508
3509   /* Turn off the bus reset. */
3510   aic_outb(p, 0, SCSISEQ);
3511   mdelay(10);
3512
3513   aic7xxx_clear_intstat(p);
3514   /* Re-enable reset interrupts. */
3515   aic_outb(p, aic_inb(p, SIMODE1) | ENSCSIRST, SIMODE1);
3516
3517 }
3518
3519 /*+F*************************************************************************
3520  * Function:
3521  *   aic7xxx_reset_channel
3522  *
3523  * Description:
3524  *   Reset the channel.
3525  *-F*************************************************************************/
3526 static void
3527 aic7xxx_reset_channel(struct aic7xxx_host *p, int channel, int initiate_reset)
3528 {
3529   unsigned long offset_min, offset_max;
3530   unsigned char sblkctl;
3531   int cur_channel;
3532
3533   if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3534     printk(INFO_LEAD "Reset channel called, %s initiate reset.\n",
3535       p->host_no, channel, -1, -1, (initiate_reset==TRUE) ? "will" : "won't" );
3536
3537
3538   if (channel == 1)
3539   {
3540     offset_min = 8;
3541     offset_max = 16;
3542   }
3543   else
3544   {
3545     if (p->features & AHC_TWIN)
3546     {
3547       /* Channel A */
3548       offset_min = 0;
3549       offset_max = 8;
3550     }
3551     else
3552     {
3553       offset_min = 0;
3554       if (p->features & AHC_WIDE)
3555       {
3556         offset_max = 16;
3557       }
3558       else
3559       {
3560         offset_max = 8;
3561       }
3562     }
3563   }
3564
3565   while (offset_min < offset_max)
3566   {
3567     /*
3568      * Revert to async/narrow transfers until we renegotiate.
3569      */
3570     aic_outb(p, 0, TARG_SCSIRATE + offset_min);
3571     if (p->features & AHC_ULTRA2)
3572     {
3573       aic_outb(p, 0, TARG_OFFSET + offset_min);
3574     }
3575     offset_min++;
3576   }
3577
3578   /*
3579    * Reset the bus and unpause/restart the controller
3580    */
3581   sblkctl = aic_inb(p, SBLKCTL);
3582   if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
3583     cur_channel = (sblkctl & SELBUSB) >> 3;
3584   else
3585     cur_channel = 0;
3586   if ( (cur_channel != channel) && (p->features & AHC_TWIN) )
3587   {
3588     /*
3589      * Case 1: Command for another bus is active
3590      */
3591     if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3592       printk(INFO_LEAD "Stealthily resetting idle channel.\n", p->host_no,
3593         channel, -1, -1);
3594     /*
3595      * Stealthily reset the other bus without upsetting the current bus.
3596      */
3597     aic_outb(p, sblkctl ^ SELBUSB, SBLKCTL);
3598     aic_outb(p, aic_inb(p, SIMODE1) & ~ENBUSFREE, SIMODE1);
3599     if (initiate_reset)
3600     {
3601       aic7xxx_reset_current_bus(p);
3602     }
3603     aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), SCSISEQ);
3604     aic7xxx_clear_intstat(p);
3605     aic_outb(p, sblkctl, SBLKCTL);
3606   }
3607   else
3608   {
3609     /*
3610      * Case 2: A command from this bus is active or we're idle.
3611      */
3612     if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3613       printk(INFO_LEAD "Resetting currently active channel.\n", p->host_no,
3614         channel, -1, -1);
3615     aic_outb(p, aic_inb(p, SIMODE1) & ~(ENBUSFREE|ENREQINIT),
3616       SIMODE1);
3617     p->flags &= ~AHC_HANDLING_REQINITS;
3618     p->msg_type = MSG_TYPE_NONE;
3619     p->msg_len = 0;
3620     if (initiate_reset)
3621     {
3622       aic7xxx_reset_current_bus(p);
3623     }
3624     aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP), SCSISEQ);
3625     aic7xxx_clear_intstat(p);
3626   }
3627   if (aic7xxx_verbose & VERBOSE_RESET_RETURN)
3628     printk(INFO_LEAD "Channel reset\n", p->host_no, channel, -1, -1);
3629   /*
3630    * Clean up all the state information for the pending transactions
3631    * on this bus.
3632    */
3633   aic7xxx_reset_device(p, ALL_TARGETS, channel, ALL_LUNS, SCB_LIST_NULL);
3634
3635   if ( !(p->features & AHC_TWIN) )
3636   {
3637     restart_sequencer(p);
3638   }
3639
3640   return;
3641 }
3642
3643 /*+F*************************************************************************
3644  * Function:
3645  *   aic7xxx_run_waiting_queues
3646  *
3647  * Description:
3648  *   Scan the awaiting_scbs queue downloading and starting as many
3649  *   scbs as we can.
3650  *-F*************************************************************************/
3651 static void
3652 aic7xxx_run_waiting_queues(struct aic7xxx_host *p)
3653 {
3654   struct aic7xxx_scb *scb;
3655   struct aic_dev_data *aic_dev;
3656   int sent;
3657
3658
3659   if (p->waiting_scbs.head == NULL)
3660     return;
3661
3662   sent = 0;
3663
3664   /*
3665    * First handle SCBs that are waiting but have been assigned a slot.
3666    */
3667   while ((scb = scbq_remove_head(&p->waiting_scbs)) != NULL)
3668   {
3669     aic_dev = scb->cmd->device->hostdata;
3670     if ( !scb->tag_action )
3671     {
3672       aic_dev->temp_q_depth = 1;
3673     }
3674     if ( aic_dev->active_cmds >= aic_dev->temp_q_depth)
3675     {
3676       scbq_insert_tail(&aic_dev->delayed_scbs, scb);
3677     }
3678     else
3679     {
3680         scb->flags &= ~SCB_WAITINGQ;
3681         aic_dev->active_cmds++;
3682         p->activescbs++;
3683         if ( !(scb->tag_action) )
3684         {
3685           aic7xxx_busy_target(p, scb);
3686         }
3687         p->qinfifo[p->qinfifonext++] = scb->hscb->tag;
3688         sent++;
3689     }
3690   }
3691   if (sent)
3692   {
3693     if (p->features & AHC_QUEUE_REGS)
3694       aic_outb(p, p->qinfifonext, HNSCB_QOFF);
3695     else
3696     {
3697       pause_sequencer(p);
3698       aic_outb(p, p->qinfifonext, KERNEL_QINPOS);
3699       unpause_sequencer(p, FALSE);
3700     }
3701     if (p->activescbs > p->max_activescbs)
3702       p->max_activescbs = p->activescbs;
3703   }
3704 }
3705
3706 #ifdef CONFIG_PCI
3707
3708 #define  DPE 0x80
3709 #define  SSE 0x40
3710 #define  RMA 0x20
3711 #define  RTA 0x10
3712 #define  STA 0x08
3713 #define  DPR 0x01
3714
3715 /*+F*************************************************************************
3716  * Function:
3717  *   aic7xxx_pci_intr
3718  *
3719  * Description:
3720  *   Check the scsi card for PCI errors and clear the interrupt
3721  *
3722  *   NOTE: If you don't have this function and a 2940 card encounters
3723  *         a PCI error condition, the machine will end up locked as the
3724  *         interrupt handler gets slammed with non-stop PCI error interrupts
3725  *-F*************************************************************************/
3726 static void
3727 aic7xxx_pci_intr(struct aic7xxx_host *p)
3728 {
3729   unsigned char status1;
3730
3731   pci_read_config_byte(p->pdev, PCI_STATUS + 1, &status1);
3732
3733   if ( (status1 & DPE) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3734     printk(WARN_LEAD "Data Parity Error during PCI address or PCI write"
3735       "phase.\n", p->host_no, -1, -1, -1);
3736   if ( (status1 & SSE) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3737     printk(WARN_LEAD "Signal System Error Detected\n", p->host_no,
3738       -1, -1, -1);
3739   if ( (status1 & RMA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3740     printk(WARN_LEAD "Received a PCI Master Abort\n", p->host_no,
3741       -1, -1, -1);
3742   if ( (status1 & RTA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3743     printk(WARN_LEAD "Received a PCI Target Abort\n", p->host_no,
3744       -1, -1, -1);
3745   if ( (status1 & STA) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3746     printk(WARN_LEAD "Signaled a PCI Target Abort\n", p->host_no,
3747       -1, -1, -1);
3748   if ( (status1 & DPR) && (aic7xxx_verbose & VERBOSE_MINOR_ERROR) )
3749     printk(WARN_LEAD "Data Parity Error has been reported via PCI pin "
3750       "PERR#\n", p->host_no, -1, -1, -1);
3751
3752   pci_write_config_byte(p->pdev, PCI_STATUS + 1, status1);
3753   if (status1 & (DPR|RMA|RTA))
3754     aic_outb(p,  CLRPARERR, CLRINT);
3755
3756   if ( (aic7xxx_panic_on_abort) && (p->spurious_int > 500) )
3757     aic7xxx_panic_abort(p, NULL);
3758
3759 }
3760 #endif /* CONFIG_PCI */
3761
3762 /*+F*************************************************************************
3763  * Function:
3764  *   aic7xxx_construct_ppr
3765  *
3766  * Description:
3767  *   Build up a Parallel Protocol Request message for use with SCSI-3
3768  *   devices.
3769  *-F*************************************************************************/
3770 static void
3771 aic7xxx_construct_ppr(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
3772 {
3773   p->msg_buf[p->msg_index++] = MSG_EXTENDED;
3774   p->msg_buf[p->msg_index++] = MSG_EXT_PPR_LEN;
3775   p->msg_buf[p->msg_index++] = MSG_EXT_PPR;
3776   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.period;
3777   p->msg_buf[p->msg_index++] = 0;
3778   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.offset;
3779   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.width;
3780   p->msg_buf[p->msg_index++] = AIC_DEV(scb->cmd)->goal.options;
3781   p->msg_len += 8;
3782 }
3783
3784 /*+F*************************************************************************
3785  * Function:
3786  *   aic7xxx_construct_sdtr
3787  *
3788  * Description:
3789  *   Constucts a synchronous data transfer message in the message
3790  *   buffer on the sequencer.
3791  *-F*************************************************************************/
3792 static void
3793 aic7xxx_construct_sdtr(struct aic7xxx_host *p, unsigned char period,
3794         unsigned char offset)
3795 {
3796   p->msg_buf[p->msg_index++] = MSG_EXTENDED;
3797   p->msg_buf[p->msg_index++] = MSG_EXT_SDTR_LEN;
3798   p->msg_buf[p->msg_index++] = MSG_EXT_SDTR;
3799   p->msg_buf[p->msg_index++] = period;
3800   p->msg_buf[p->msg_index++] = offset;
3801   p->msg_len += 5;
3802 }
3803
3804 /*+F*************************************************************************
3805  * Function:
3806  *   aic7xxx_construct_wdtr
3807  *
3808  * Description:
3809  *   Constucts a wide data transfer message in the message buffer
3810  *   on the sequencer.
3811  *-F*************************************************************************/
3812 static void
3813 aic7xxx_construct_wdtr(struct aic7xxx_host *p, unsigned char bus_width)
3814 {
3815   p->msg_buf[p->msg_index++] = MSG_EXTENDED;
3816   p->msg_buf[p->msg_index++] = MSG_EXT_WDTR_LEN;
3817   p->msg_buf[p->msg_index++] = MSG_EXT_WDTR;
3818   p->msg_buf[p->msg_index++] = bus_width;
3819   p->msg_len += 4;
3820 }
3821
3822 /*+F*************************************************************************
3823  * Function:
3824  *   aic7xxx_calc_residual
3825  *
3826  * Description:
3827  *   Calculate the residual data not yet transferred.
3828  *-F*************************************************************************/
3829 static void
3830 aic7xxx_calculate_residual (struct aic7xxx_host *p, struct aic7xxx_scb *scb)
3831 {
3832   struct aic7xxx_hwscb *hscb;
3833   Scsi_Cmnd *cmd;
3834   int actual, i;
3835
3836   cmd = scb->cmd;
3837   hscb = scb->hscb;
3838
3839   /*
3840    *  Don't destroy valid residual information with
3841    *  residual coming from a check sense operation.
3842    */
3843   if (((scb->hscb->control & DISCONNECTED) == 0) &&
3844       (scb->flags & SCB_SENSE) == 0)
3845   {
3846     /*
3847      *  We had an underflow. At this time, there's only
3848      *  one other driver that bothers to check for this,
3849      *  and cmd->underflow seems to be set rather half-
3850      *  heartedly in the higher-level SCSI code.
3851      */
3852     actual = scb->sg_length;
3853     for (i=1; i < hscb->residual_SG_segment_count; i++)
3854     {
3855       actual -= scb->sg_list[scb->sg_count - i].length;
3856     }
3857     actual -= (hscb->residual_data_count[2] << 16) |
3858               (hscb->residual_data_count[1] <<  8) |
3859               hscb->residual_data_count[0];
3860
3861     if (actual < cmd->underflow)
3862     {
3863       if (aic7xxx_verbose & VERBOSE_MINOR_ERROR)
3864       {
3865         printk(INFO_LEAD "Underflow - Wanted %u, %s %u, residual SG "
3866           "count %d.\n", p->host_no, CTL_OF_SCB(scb), cmd->underflow,
3867           (rq_data_dir(cmd->request) == WRITE) ? "wrote" : "read", actual,
3868           hscb->residual_SG_segment_count);
3869         printk(INFO_LEAD "status 0x%x.\n", p->host_no, CTL_OF_SCB(scb),
3870           hscb->target_status);
3871       }
3872       /*
3873        * In 2.4, only send back the residual information, don't flag this
3874        * as an error.  Before 2.4 we had to flag this as an error because
3875        * the mid layer didn't check residual data counts to see if the
3876        * command needs retried.
3877        */
3878       cmd->resid = scb->sg_length - actual;
3879       aic7xxx_status(cmd) = hscb->target_status;
3880     }
3881   }
3882
3883   /*
3884    * Clean out the residual information in the SCB for the
3885    * next consumer.
3886    */
3887   hscb->residual_data_count[2] = 0;
3888   hscb->residual_data_count[1] = 0;
3889   hscb->residual_data_count[0] = 0;
3890   hscb->residual_SG_segment_count = 0;
3891 }
3892
3893 /*+F*************************************************************************
3894  * Function:
3895  *   aic7xxx_handle_device_reset
3896  *
3897  * Description:
3898  *   Interrupt handler for sequencer interrupts (SEQINT).
3899  *-F*************************************************************************/
3900 static void
3901 aic7xxx_handle_device_reset(struct aic7xxx_host *p, int target, int channel)
3902 {
3903   unsigned char tindex = target;
3904
3905   tindex |= ((channel & 0x01) << 3);
3906
3907   /*
3908    * Go back to async/narrow transfers and renegotiate.
3909    */
3910   aic_outb(p, 0, TARG_SCSIRATE + tindex);
3911   if (p->features & AHC_ULTRA2)
3912     aic_outb(p, 0, TARG_OFFSET + tindex);
3913   aic7xxx_reset_device(p, target, channel, ALL_LUNS, SCB_LIST_NULL);
3914   if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
3915     printk(INFO_LEAD "Bus Device Reset delivered.\n", p->host_no, channel,
3916       target, -1);
3917   aic7xxx_run_done_queue(p, /*complete*/ TRUE);
3918 }
3919
3920 /*+F*************************************************************************
3921  * Function:
3922  *   aic7xxx_handle_seqint
3923  *
3924  * Description:
3925  *   Interrupt handler for sequencer interrupts (SEQINT).
3926  *-F*************************************************************************/
3927 static void
3928 aic7xxx_handle_seqint(struct aic7xxx_host *p, unsigned char intstat)
3929 {
3930   struct aic7xxx_scb *scb;
3931   struct aic_dev_data *aic_dev;
3932   unsigned short target_mask;
3933   unsigned char target, lun, tindex;
3934   unsigned char queue_flag = FALSE;
3935   char channel;
3936   int result;
3937
3938   target = ((aic_inb(p, SAVED_TCL) >> 4) & 0x0f);
3939   if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
3940     channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3;
3941   else
3942     channel = 0;
3943   tindex = target + (channel << 3);
3944   lun = aic_inb(p, SAVED_TCL) & 0x07;
3945   target_mask = (0x01 << tindex);
3946
3947   /*
3948    * Go ahead and clear the SEQINT now, that avoids any interrupt race
3949    * conditions later on in case we enable some other interrupt.
3950    */
3951   aic_outb(p, CLRSEQINT, CLRINT);
3952   switch (intstat & SEQINT_MASK)
3953   {
3954     case NO_MATCH:
3955       {
3956         aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP),
3957                  SCSISEQ);
3958         printk(WARN_LEAD "No active SCB for reconnecting target - Issuing "
3959                "BUS DEVICE RESET.\n", p->host_no, channel, target, lun);
3960         printk(WARN_LEAD "      SAVED_TCL=0x%x, ARG_1=0x%x, SEQADDR=0x%x\n",
3961                p->host_no, channel, target, lun,
3962                aic_inb(p, SAVED_TCL), aic_inb(p, ARG_1),
3963                (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0));
3964         if (aic7xxx_panic_on_abort)
3965           aic7xxx_panic_abort(p, NULL);
3966       }
3967       break;
3968
3969     case SEND_REJECT:
3970       {
3971         if (aic7xxx_verbose & VERBOSE_MINOR_ERROR)
3972           printk(INFO_LEAD "Rejecting unknown message (0x%x) received from "
3973             "target, SEQ_FLAGS=0x%x\n", p->host_no, channel, target, lun,
3974             aic_inb(p, ACCUM), aic_inb(p, SEQ_FLAGS));
3975       }
3976       break;
3977
3978     case NO_IDENT:
3979       {
3980         /*
3981          * The reconnecting target either did not send an identify
3982          * message, or did, but we didn't find an SCB to match and
3983          * before it could respond to our ATN/abort, it hit a dataphase.
3984          * The only safe thing to do is to blow it away with a bus
3985          * reset.
3986          */
3987         if (aic7xxx_verbose & (VERBOSE_SEQINT | VERBOSE_RESET_MID))
3988           printk(INFO_LEAD "Target did not send an IDENTIFY message; "
3989             "LASTPHASE 0x%x, SAVED_TCL 0x%x\n", p->host_no, channel, target,
3990             lun, aic_inb(p, LASTPHASE), aic_inb(p, SAVED_TCL));
3991
3992         aic7xxx_reset_channel(p, channel, /*initiate reset*/ TRUE);
3993         aic7xxx_run_done_queue(p, TRUE);
3994
3995       }
3996       break;
3997
3998     case BAD_PHASE:
3999       if (aic_inb(p, LASTPHASE) == P_BUSFREE)
4000       {
4001         if (aic7xxx_verbose & VERBOSE_SEQINT)
4002           printk(INFO_LEAD "Missed busfree.\n", p->host_no, channel,
4003             target, lun);
4004         restart_sequencer(p);
4005       }
4006       else
4007       {
4008         if (aic7xxx_verbose & VERBOSE_SEQINT)
4009           printk(INFO_LEAD "Unknown scsi bus phase, continuing\n", p->host_no,
4010             channel, target, lun);
4011       }
4012       break;
4013
4014     case EXTENDED_MSG:
4015       {
4016         p->msg_type = MSG_TYPE_INITIATOR_MSGIN;
4017         p->msg_len = 0;
4018         p->msg_index = 0;
4019
4020 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4021         if (aic7xxx_verbose > 0xffff)
4022           printk(INFO_LEAD "Enabling REQINITs for MSG_IN\n", p->host_no,
4023                  channel, target, lun);
4024 #endif
4025
4026        /*
4027         * To actually receive the message, simply turn on
4028         * REQINIT interrupts and let our interrupt handler
4029         * do the rest (REQINIT should already be true).
4030         */
4031         p->flags |= AHC_HANDLING_REQINITS;
4032         aic_outb(p, aic_inb(p, SIMODE1) | ENREQINIT, SIMODE1);
4033
4034        /*
4035         * We don't want the sequencer unpaused yet so we return early
4036         */
4037         return;
4038       }
4039
4040     case REJECT_MSG:
4041       {
4042         /*
4043          * What we care about here is if we had an outstanding SDTR
4044          * or WDTR message for this target. If we did, this is a
4045          * signal that the target is refusing negotiation.
4046          */
4047         unsigned char scb_index;
4048         unsigned char last_msg;
4049
4050         scb_index = aic_inb(p, SCB_TAG);
4051         scb = p->scb_data->scb_array[scb_index];
4052         aic_dev = AIC_DEV(scb->cmd);
4053         last_msg = aic_inb(p, LAST_MSG);
4054
4055         if ( (last_msg == MSG_IDENTIFYFLAG) &&
4056              (scb->tag_action) &&
4057             !(scb->flags & SCB_MSGOUT_BITS) )
4058         {
4059           if (scb->tag_action == MSG_ORDERED_Q_TAG)
4060           {
4061             /*
4062              * OK...the device seems able to accept tagged commands, but
4063              * not ordered tag commands, only simple tag commands.  So, we
4064              * disable ordered tag commands and go on with life just like
4065              * normal.
4066              */
4067             scsi_adjust_queue_depth(scb->cmd->device, MSG_SIMPLE_TAG,
4068                             scb->cmd->device->queue_depth);
4069             scb->tag_action = MSG_SIMPLE_Q_TAG;
4070             scb->hscb->control &= ~SCB_TAG_TYPE;
4071             scb->hscb->control |= MSG_SIMPLE_Q_TAG;
4072             aic_outb(p, scb->hscb->control, SCB_CONTROL);
4073             /*
4074              * OK..we set the tag type to simple tag command, now we re-assert
4075              * ATNO and hope this will take us into the identify phase again
4076              * so we can resend the tag type and info to the device.
4077              */
4078             aic_outb(p, MSG_IDENTIFYFLAG, MSG_OUT);
4079             aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
4080           }
4081           else if (scb->tag_action == MSG_SIMPLE_Q_TAG)
4082           {
4083             unsigned char i;
4084             struct aic7xxx_scb *scbp;
4085             int old_verbose;
4086             /*
4087              * Hmmmm....the device is flaking out on tagged commands.
4088              */
4089             scsi_adjust_queue_depth(scb->cmd->device, 0 /* untagged */,
4090                             p->host->cmd_per_lun);
4091             aic_dev->max_q_depth = aic_dev->temp_q_depth = 1;
4092             /*
4093              * We set this command up as a bus device reset.  However, we have
4094              * to clear the tag type as it's causing us problems.  We shouldnt
4095              * have to worry about any other commands being active, since if
4096              * the device is refusing tagged commands, this should be the
4097              * first tagged command sent to the device, however, we do have
4098              * to worry about any other tagged commands that may already be
4099              * in the qinfifo.  The easiest way to do this, is to issue a BDR,
4100              * send all the commands back to the mid level code, then let them
4101              * come back and get rebuilt as untagged commands.
4102              */
4103             scb->tag_action = 0;
4104             scb->hscb->control &= ~(TAG_ENB | SCB_TAG_TYPE);
4105             aic_outb(p,  scb->hscb->control, SCB_CONTROL);
4106
4107             old_verbose = aic7xxx_verbose;
4108             aic7xxx_verbose &= ~(VERBOSE_RESET|VERBOSE_ABORT);
4109             for (i=0; i < p->scb_data->numscbs; i++)
4110             {
4111               scbp = p->scb_data->scb_array[i];
4112               if ((scbp->flags & SCB_ACTIVE) && (scbp != scb))
4113               {
4114                 if (aic7xxx_match_scb(p, scbp, target, channel, lun, i))
4115                 {
4116                   aic7xxx_reset_device(p, target, channel, lun, i);
4117                 }
4118               }
4119             }
4120             aic7xxx_run_done_queue(p, TRUE);
4121             aic7xxx_verbose = old_verbose;
4122             /*
4123              * Wait until after the for loop to set the busy index since
4124              * aic7xxx_reset_device will clear the busy index during its
4125              * operation.
4126              */
4127             aic7xxx_busy_target(p, scb);
4128             printk(INFO_LEAD "Device is refusing tagged commands, using "
4129               "untagged I/O.\n", p->host_no, channel, target, lun);
4130             aic_outb(p, MSG_IDENTIFYFLAG, MSG_OUT);
4131             aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
4132           }
4133         }
4134         else if (scb->flags & SCB_MSGOUT_PPR)
4135         {
4136           /*
4137            * As per the draft specs, any device capable of supporting any of
4138            * the option values other than 0 are not allowed to reject the
4139            * PPR message.  Instead, they must negotiate out what they do
4140            * support instead of rejecting our offering or else they cause
4141            * a parity error during msg_out phase to signal that they don't
4142            * like our settings.
4143            */
4144           aic_dev->needppr = aic_dev->needppr_copy = 0;
4145           aic7xxx_set_width(p, target, channel, lun, MSG_EXT_WDTR_BUS_8_BIT,
4146             (AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE), aic_dev);
4147           aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
4148                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
4149                                aic_dev);
4150           aic_dev->goal.options = aic_dev->dtr_pending = 0;
4151           scb->flags &= ~SCB_MSGOUT_BITS;
4152           if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4153           {
4154             printk(INFO_LEAD "Device is rejecting PPR messages, falling "
4155               "back.\n", p->host_no, channel, target, lun);
4156           }
4157           if ( aic_dev->goal.width )
4158           {
4159             aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
4160             aic_dev->dtr_pending = 1;
4161             scb->flags |= SCB_MSGOUT_WDTR;
4162           }
4163           if ( aic_dev->goal.offset )
4164           {
4165             aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
4166             if( !aic_dev->dtr_pending )
4167             {
4168               aic_dev->dtr_pending = 1;
4169               scb->flags |= SCB_MSGOUT_SDTR;
4170             }
4171           }
4172           if ( aic_dev->dtr_pending )
4173           {
4174             aic_outb(p, HOST_MSG, MSG_OUT);
4175             aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
4176           }
4177         }
4178         else if (scb->flags & SCB_MSGOUT_WDTR)
4179         {
4180           /*
4181            * note 8bit xfers and clear flag
4182            */
4183           aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
4184           scb->flags &= ~SCB_MSGOUT_BITS;
4185           aic7xxx_set_width(p, target, channel, lun, MSG_EXT_WDTR_BUS_8_BIT,
4186             (AHC_TRANS_ACTIVE|AHC_TRANS_GOAL|AHC_TRANS_CUR), aic_dev);
4187           aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
4188                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
4189                                aic_dev);
4190           if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4191           {
4192             printk(INFO_LEAD "Device is rejecting WDTR messages, using "
4193               "narrow transfers.\n", p->host_no, channel, target, lun);
4194           }
4195           aic_dev->needsdtr = aic_dev->needsdtr_copy;
4196         }
4197         else if (scb->flags & SCB_MSGOUT_SDTR)
4198         {
4199          /*
4200           * note asynch xfers and clear flag
4201           */
4202           aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
4203           scb->flags &= ~SCB_MSGOUT_BITS;
4204           aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
4205             (AHC_TRANS_CUR|AHC_TRANS_ACTIVE|AHC_TRANS_GOAL), aic_dev);
4206           if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4207           {
4208             printk(INFO_LEAD "Device is rejecting SDTR messages, using "
4209               "async transfers.\n", p->host_no, channel, target, lun);
4210           }
4211         }
4212         else if (aic7xxx_verbose & VERBOSE_SEQINT)
4213         {
4214           /*
4215            * Otherwise, we ignore it.
4216            */
4217           printk(INFO_LEAD "Received MESSAGE_REJECT for unknown cause.  "
4218             "Ignoring.\n", p->host_no, channel, target, lun);
4219         }
4220       }
4221       break;
4222
4223     case BAD_STATUS:
4224       {
4225         unsigned char scb_index;
4226         struct aic7xxx_hwscb *hscb;
4227         Scsi_Cmnd *cmd;
4228
4229         /* The sequencer will notify us when a command has an error that
4230          * would be of interest to the kernel.  This allows us to leave
4231          * the sequencer running in the common case of command completes
4232          * without error.  The sequencer will have DMA'd the SCB back
4233          * up to us, so we can reference the drivers SCB array.
4234          *
4235          * Set the default return value to 0 indicating not to send
4236          * sense.  The sense code will change this if needed and this
4237          * reduces code duplication.
4238          */
4239         aic_outb(p, 0, RETURN_1);
4240         scb_index = aic_inb(p, SCB_TAG);
4241         if (scb_index > p->scb_data->numscbs)
4242         {
4243           printk(WARN_LEAD "Invalid SCB during SEQINT 0x%02x, SCB_TAG %d.\n",
4244             p->host_no, channel, target, lun, intstat, scb_index);
4245           break;
4246         }
4247         scb = p->scb_data->scb_array[scb_index];
4248         hscb = scb->hscb;
4249
4250         if (!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
4251         {
4252           printk(WARN_LEAD "Invalid SCB during SEQINT 0x%x, scb %d, flags 0x%x,"
4253             " cmd 0x%lx.\n", p->host_no, channel, target, lun, intstat,
4254             scb_index, scb->flags, (unsigned long) scb->cmd);
4255         }
4256         else
4257         {
4258           cmd = scb->cmd;
4259           aic_dev = AIC_DEV(scb->cmd);
4260           hscb->target_status = aic_inb(p, SCB_TARGET_STATUS);
4261           aic7xxx_status(cmd) = hscb->target_status;
4262
4263           cmd->result = hscb->target_status;
4264
4265           switch (status_byte(hscb->target_status))
4266           {
4267             case GOOD:
4268               if (aic7xxx_verbose & VERBOSE_SEQINT)
4269                 printk(INFO_LEAD "Interrupted for status of GOOD???\n",
4270                   p->host_no, CTL_OF_SCB(scb));
4271               break;
4272
4273             case COMMAND_TERMINATED:
4274             case CHECK_CONDITION:
4275               if ( !(scb->flags & SCB_SENSE) )
4276               {
4277                 /*
4278                  * Send a sense command to the requesting target.
4279                  * XXX - revisit this and get rid of the memcopys.
4280                  */
4281                 memcpy(scb->sense_cmd, &generic_sense[0],
4282                        sizeof(generic_sense));
4283
4284                 scb->sense_cmd[1] = (cmd->device->lun << 5);
4285                 scb->sense_cmd[4] = sizeof(cmd->sense_buffer);
4286
4287                 scb->sg_list[0].length =
4288                   cpu_to_le32(sizeof(cmd->sense_buffer));
4289                 scb->sg_list[0].address =
4290                         cpu_to_le32(pci_map_single(p->pdev, cmd->sense_buffer,
4291                                                    sizeof(cmd->sense_buffer),
4292                                                    PCI_DMA_FROMDEVICE));
4293
4294                 /*
4295                  * XXX - We should allow disconnection, but can't as it
4296                  * might allow overlapped tagged commands.
4297                  */
4298                 /* hscb->control &= DISCENB; */
4299                 hscb->control = 0;
4300                 hscb->target_status = 0;
4301                 hscb->SG_list_pointer =
4302                   cpu_to_le32(SCB_DMA_ADDR(scb, scb->sg_list));
4303                 hscb->SCSI_cmd_pointer =
4304                   cpu_to_le32(SCB_DMA_ADDR(scb, scb->sense_cmd));
4305                 hscb->data_count = scb->sg_list[0].length;
4306                 hscb->data_pointer = scb->sg_list[0].address;
4307                 hscb->SCSI_cmd_length = COMMAND_SIZE(scb->sense_cmd[0]);
4308                 hscb->residual_SG_segment_count = 0;
4309                 hscb->residual_data_count[0] = 0;
4310                 hscb->residual_data_count[1] = 0;
4311                 hscb->residual_data_count[2] = 0;
4312
4313                 scb->sg_count = hscb->SG_segment_count = 1;
4314                 scb->sg_length = sizeof(cmd->sense_buffer);
4315                 scb->tag_action = 0;
4316                 scb->flags |= SCB_SENSE;
4317                 /*
4318                  * Ensure the target is busy since this will be an
4319                  * an untagged request.
4320                  */
4321 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4322                 if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4323                 {
4324                   if (scb->flags & SCB_MSGOUT_BITS)
4325                     printk(INFO_LEAD "Requesting SENSE with %s\n", p->host_no,
4326                            CTL_OF_SCB(scb), (scb->flags & SCB_MSGOUT_SDTR) ?
4327                            "SDTR" : "WDTR");
4328                   else
4329                     printk(INFO_LEAD "Requesting SENSE, no MSG\n", p->host_no,
4330                            CTL_OF_SCB(scb));
4331                 }
4332 #endif
4333                 aic7xxx_busy_target(p, scb);
4334                 aic_outb(p, SEND_SENSE, RETURN_1);
4335                 aic7xxx_error(cmd) = DID_OK;
4336                 break;
4337               }  /* first time sense, no errors */
4338               printk(INFO_LEAD "CHECK_CONDITION on REQUEST_SENSE, returning "
4339                      "an error.\n", p->host_no, CTL_OF_SCB(scb));
4340               aic7xxx_error(cmd) = DID_ERROR;
4341               scb->flags &= ~SCB_SENSE;
4342               break;
4343
4344             case QUEUE_FULL:
4345               queue_flag = TRUE;    /* Mark that this is a QUEUE_FULL and */
4346             case BUSY:              /* drop through to here */
4347             {
4348               struct aic7xxx_scb *next_scbp, *prev_scbp;
4349               unsigned char active_hscb, next_hscb, prev_hscb, scb_index;
4350               /*
4351                * We have to look three places for queued commands:
4352                *  1: p->waiting_scbs queue
4353                *  2: QINFIFO
4354                *  3: WAITING_SCBS list on card (for commands that are started
4355                *     but haven't yet made it to the device)
4356                *
4357                * Of special note here is that commands on 2 or 3 above will
4358                * have already been marked as active, while commands on 1 will
4359                * not.  The aic7xxx_done() function will want to unmark them
4360                * from active, so any commands we pull off of 1 need to
4361                * up the active count.
4362                */
4363               next_scbp = p->waiting_scbs.head;
4364               while ( next_scbp != NULL )
4365               {
4366                 prev_scbp = next_scbp;
4367                 next_scbp = next_scbp->q_next;
4368                 if ( aic7xxx_match_scb(p, prev_scbp, target, channel, lun,
4369                      SCB_LIST_NULL) )
4370                 {
4371                   scbq_remove(&p->waiting_scbs, prev_scbp);
4372                   scb->flags = SCB_QUEUED_FOR_DONE | SCB_QUEUE_FULL;
4373                   p->activescbs++;
4374                   aic_dev->active_cmds++;
4375                 }
4376               }
4377               aic7xxx_search_qinfifo(p, target, channel, lun,
4378                 SCB_LIST_NULL, SCB_QUEUED_FOR_DONE | SCB_QUEUE_FULL,
4379                 FALSE, NULL);
4380               next_scbp = NULL;
4381               active_hscb = aic_inb(p, SCBPTR);
4382               prev_hscb = next_hscb = scb_index = SCB_LIST_NULL;
4383               next_hscb = aic_inb(p, WAITING_SCBH);
4384               while (next_hscb != SCB_LIST_NULL)
4385               {
4386                 aic_outb(p, next_hscb, SCBPTR);
4387                 scb_index = aic_inb(p, SCB_TAG);
4388                 if (scb_index < p->scb_data->numscbs)
4389                 {
4390                   next_scbp = p->scb_data->scb_array[scb_index];
4391                   if (aic7xxx_match_scb(p, next_scbp, target, channel, lun,
4392                       SCB_LIST_NULL) )
4393                   {
4394                     next_scbp->flags = SCB_QUEUED_FOR_DONE | SCB_QUEUE_FULL;
4395                     next_hscb = aic_inb(p, SCB_NEXT);
4396                     aic_outb(p, 0, SCB_CONTROL);
4397                     aic_outb(p, SCB_LIST_NULL, SCB_TAG);
4398                     aic7xxx_add_curscb_to_free_list(p);
4399                     if (prev_hscb == SCB_LIST_NULL)
4400                     {
4401                       /* We were first on the list,
4402                        * so we kill the selection
4403                        * hardware.  Let the sequencer
4404                        * re-init the hardware itself
4405                        */
4406                       aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ);
4407                       aic_outb(p, CLRSELTIMEO, CLRSINT1);
4408                       aic_outb(p, next_hscb, WAITING_SCBH);
4409                     }
4410                     else
4411                     {
4412                       aic_outb(p, prev_hscb, SCBPTR);
4413                       aic_outb(p, next_hscb, SCB_NEXT);
4414                     }
4415                   }
4416                   else
4417                   {
4418                     prev_hscb = next_hscb;
4419                     next_hscb = aic_inb(p, SCB_NEXT);
4420                   }
4421                 } /* scb_index >= p->scb_data->numscbs */
4422               }
4423               aic_outb(p, active_hscb, SCBPTR);
4424               aic7xxx_run_done_queue(p, FALSE);
4425
4426 #ifdef AIC7XXX_VERBOSE_DEBUGGING
4427               if( (aic7xxx_verbose & VERBOSE_MINOR_ERROR) ||
4428                   (aic7xxx_verbose > 0xffff) )
4429               {
4430                 if (queue_flag)
4431                   printk(INFO_LEAD "Queue full received; queue depth %d, "
4432                     "active %d\n", p->host_no, CTL_OF_SCB(scb),
4433                     aic_dev->max_q_depth, aic_dev->active_cmds);
4434                 else
4435                   printk(INFO_LEAD "Target busy\n", p->host_no, CTL_OF_SCB(scb));
4436               }
4437 #endif
4438               if (queue_flag)
4439               {
4440                 int diff;
4441                 result = scsi_track_queue_full(cmd->device,
4442                                 aic_dev->active_cmds);
4443                 if ( result < 0 )
4444                 {
4445                   if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4446                     printk(INFO_LEAD "Tagged Command Queueing disabled.\n",
4447                         p->host_no, CTL_OF_SCB(scb));
4448                   diff = aic_dev->max_q_depth - p->host->cmd_per_lun;
4449                   aic_dev->temp_q_depth = 1;
4450                   aic_dev->max_q_depth = 1;
4451                 }
4452                 else if ( result > 0 )
4453                 {
4454                   if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4455                     printk(INFO_LEAD "Queue depth reduced to %d\n", p->host_no,
4456                       CTL_OF_SCB(scb), result);
4457                   diff = aic_dev->max_q_depth - result;
4458                   aic_dev->max_q_depth = result;
4459                   /* temp_q_depth could have been dropped to 1 for an untagged
4460                    * command that might be coming up */
4461                   if(aic_dev->temp_q_depth > result)
4462                     aic_dev->temp_q_depth = result;
4463                 }
4464                 /* We should free up the no unused SCB entries.  But, that's
4465                  * a difficult thing to do because we use a direct indexed
4466                  * array, so we can't just take any entries and free them,
4467                  * we *have* to free the ones at the end of the array, and
4468                  * they very well could be in use right now, which means
4469                  * in order to do this right, we have to add a delayed
4470                  * freeing mechanism tied into the scb_free() code area.
4471                  * We'll add that later.
4472                  */
4473               }
4474               break;
4475             }
4476
4477             default:
4478               if (aic7xxx_verbose & VERBOSE_SEQINT)
4479                 printk(INFO_LEAD "Unexpected target status 0x%x.\n", p->host_no,
4480                      CTL_OF_SCB(scb), scb->hscb->target_status);
4481               if (!aic7xxx_error(cmd))
4482               {
4483                 aic7xxx_error(cmd) = DID_RETRY_COMMAND;
4484               }
4485               break;
4486           }  /* end switch */
4487         }  /* end else of */
4488       }
4489       break;
4490
4491     case AWAITING_MSG:
4492       {
4493         unsigned char scb_index, msg_out;
4494
4495         scb_index = aic_inb(p, SCB_TAG);
4496         msg_out = aic_inb(p, MSG_OUT);
4497         scb = p->scb_data->scb_array[scb_index];
4498         aic_dev = AIC_DEV(scb->cmd);
4499         p->msg_index = p->msg_len = 0;
4500         /*
4501          * This SCB had a MK_MESSAGE set in its control byte informing
4502          * the sequencer that we wanted to send a special message to
4503          * this target.
4504          */
4505
4506         if ( !(scb->flags & SCB_DEVICE_RESET) &&
4507               (msg_out == MSG_IDENTIFYFLAG) &&
4508               (scb->hscb->control & TAG_ENB) )
4509         {
4510           p->msg_buf[p->msg_index++] = scb->tag_action;
4511           p->msg_buf[p->msg_index++] = scb->hscb->tag;
4512           p->msg_len += 2;
4513         }
4514
4515         if (scb->flags & SCB_DEVICE_RESET)
4516         {
4517           p->msg_buf[p->msg_index++] = MSG_BUS_DEV_RESET;
4518           p->msg_len++;
4519           if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
4520             printk(INFO_LEAD "Bus device reset mailed.\n",
4521                  p->host_no, CTL_OF_SCB(scb));
4522         }
4523         else if (scb->flags & SCB_ABORT)
4524         {
4525           if (scb->tag_action)
4526           {
4527             p->msg_buf[p->msg_index++] = MSG_ABORT_TAG;
4528           }
4529           else
4530           {
4531             p->msg_buf[p->msg_index++] = MSG_ABORT;
4532           }
4533           p->msg_len++;
4534           if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)
4535             printk(INFO_LEAD "Abort message mailed.\n", p->host_no,
4536               CTL_OF_SCB(scb));
4537         }
4538         else if (scb->flags & SCB_MSGOUT_PPR)
4539         {
4540           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4541           {
4542             printk(INFO_LEAD "Sending PPR (%d/%d/%d/%d) message.\n",
4543                    p->host_no, CTL_OF_SCB(scb),
4544                    aic_dev->goal.period,
4545                    aic_dev->goal.offset,
4546                    aic_dev->goal.width,
4547                    aic_dev->goal.options);
4548           }
4549           aic7xxx_construct_ppr(p, scb);
4550         }
4551         else if (scb->flags & SCB_MSGOUT_WDTR)
4552         {
4553           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4554           {
4555             printk(INFO_LEAD "Sending WDTR message.\n", p->host_no,
4556                    CTL_OF_SCB(scb));
4557           }
4558           aic7xxx_construct_wdtr(p, aic_dev->goal.width);
4559         }
4560         else if (scb->flags & SCB_MSGOUT_SDTR)
4561         {
4562           unsigned int max_sync, period;
4563           unsigned char options = 0;
4564           /*
4565            * Now that the device is selected, use the bits in SBLKCTL and
4566            * SSTAT2 to determine the max sync rate for this device.
4567            */
4568           if (p->features & AHC_ULTRA2)
4569           {
4570             if ( (aic_inb(p, SBLKCTL) & ENAB40) &&
4571                 !(aic_inb(p, SSTAT2) & EXP_ACTIVE) )
4572             {
4573               max_sync = AHC_SYNCRATE_ULTRA2;
4574             }
4575             else
4576             {
4577               max_sync = AHC_SYNCRATE_ULTRA;
4578             }
4579           }
4580           else if (p->features & AHC_ULTRA)
4581           {
4582             max_sync = AHC_SYNCRATE_ULTRA;
4583           }
4584           else
4585           {
4586             max_sync = AHC_SYNCRATE_FAST;
4587           }
4588           period = aic_dev->goal.period;
4589           aic7xxx_find_syncrate(p, &period, max_sync, &options);
4590           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
4591           {
4592             printk(INFO_LEAD "Sending SDTR %d/%d message.\n", p->host_no,
4593                    CTL_OF_SCB(scb), period,
4594                    aic_dev->goal.offset);
4595           }
4596           aic7xxx_construct_sdtr(p, period, aic_dev->goal.offset);
4597         }
4598         else
4599         {
4600           panic("aic7xxx: AWAITING_MSG for an SCB that does "
4601                 "not have a waiting message.\n");
4602         }
4603         /*
4604          * We've set everything up to send our message, now to actually do
4605          * so we need to enable reqinit interrupts and let the interrupt
4606          * handler do the rest.  We don't want to unpause the sequencer yet
4607          * though so we'll return early.  We also have to make sure that
4608          * we clear the SEQINT *BEFORE* we set the REQINIT handler active
4609          * or else it's possible on VLB cards to lose the first REQINIT
4610          * interrupt.  Edge triggered EISA cards could also lose this
4611          * interrupt, although PCI and level triggered cards should not
4612          * have this problem since they continually interrupt the kernel
4613          * until we take care of the situation.
4614          */
4615         scb->flags |= SCB_MSGOUT_SENT;
4616         p->msg_index = 0;
4617         p->msg_type = MSG_TYPE_INITIATOR_MSGOUT;
4618         p->flags |= AHC_HANDLING_REQINITS;
4619         aic_outb(p, aic_inb(p, SIMODE1) | ENREQINIT, SIMODE1);
4620         return;
4621       }
4622       break;
4623
4624     case DATA_OVERRUN:
4625       {
4626         unsigned char scb_index = aic_inb(p, SCB_TAG);
4627         unsigned char lastphase = aic_inb(p, LASTPHASE);
4628         unsigned int i;
4629
4630         scb = (p->scb_data->scb_array[scb_index]);
4631         /*
4632          * XXX - What do we really want to do on an overrun?  The
4633          *       mid-level SCSI code should handle this, but for now,
4634          *       we'll just indicate that the command should retried.
4635          *    If we retrieved sense info on this target, then the
4636          *    base SENSE info should have been saved prior to the
4637          *    overrun error.  In that case, we return DID_OK and let
4638          *    the mid level code pick up on the sense info.  Otherwise
4639          *    we return DID_ERROR so the command will get retried.
4640          */
4641         if ( !(scb->flags & SCB_SENSE) )
4642         {
4643           printk(WARN_LEAD "Data overrun detected in %s phase, tag %d;\n",
4644             p->host_no, CTL_OF_SCB(scb),
4645             (lastphase == P_DATAIN) ? "Data-In" : "Data-Out", scb->hscb->tag);
4646           printk(KERN_WARNING "  %s seen Data Phase. Length=%d, NumSGs=%d.\n",
4647             (aic_inb(p, SEQ_FLAGS) & DPHASE) ? "Have" : "Haven't",
4648             scb->sg_length, scb->sg_count);
4649           printk(KERN_WARNING "  Raw SCSI Command: 0x");
4650           for (i = 0; i < scb->hscb->SCSI_cmd_length; i++)
4651           {
4652             printk("%02x ", scb->cmd->cmnd[i]);
4653           }
4654           printk("\n");
4655           if(aic7xxx_verbose > 0xffff)
4656           {
4657             for (i = 0; i < scb->sg_count; i++)
4658             {
4659               printk(KERN_WARNING "     sg[%d] - Addr 0x%x : Length %d\n",
4660                  i,
4661                  le32_to_cpu(scb->sg_list[i].address),
4662                  le32_to_cpu(scb->sg_list[i].length) );
4663             }
4664           }
4665           aic7xxx_error(scb->cmd) = DID_ERROR;
4666         }
4667         else
4668           printk(INFO_LEAD "Data Overrun during SEND_SENSE operation.\n",
4669             p->host_no, CTL_OF_SCB(scb));
4670       }
4671       break;
4672
4673     case WIDE_RESIDUE:
4674       {
4675         unsigned char resid_sgcnt, index;
4676         unsigned char scb_index = aic_inb(p, SCB_TAG);
4677         unsigned int cur_addr, resid_dcnt;
4678         unsigned int native_addr, native_length, sg_addr;
4679         int i;
4680
4681         if(scb_index > p->scb_data->numscbs)
4682         {
4683           printk(WARN_LEAD "invalid scb_index during WIDE_RESIDUE.\n",
4684             p->host_no, -1, -1, -1);
4685           /*
4686            * XXX: Add error handling here
4687            */
4688           break;
4689         }
4690         scb = p->scb_data->scb_array[scb_index];
4691         if(!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
4692         {
4693           printk(WARN_LEAD "invalid scb during WIDE_RESIDUE flags:0x%x "
4694                  "scb->cmd:0x%lx\n", p->host_no, CTL_OF_SCB(scb),
4695                  scb->flags, (unsigned long)scb->cmd);
4696           break;
4697         }
4698         if(aic7xxx_verbose & VERBOSE_MINOR_ERROR)
4699           printk(INFO_LEAD "Got WIDE_RESIDUE message, patching up data "
4700                  "pointer.\n", p->host_no, CTL_OF_SCB(scb));
4701
4702         /*
4703          * We have a valid scb to use on this WIDE_RESIDUE message, so
4704          * we need to walk the sg list looking for this particular sg
4705          * segment, then see if we happen to be at the very beginning of
4706          * the segment.  If we are, then we have to back things up to
4707          * the previous segment.  If not, then we simply need to remove
4708          * one byte from this segments address and add one to the byte
4709          * count.
4710          */
4711         cur_addr = aic_inb(p, SHADDR) | (aic_inb(p, SHADDR + 1) << 8) |
4712           (aic_inb(p, SHADDR + 2) << 16) | (aic_inb(p, SHADDR + 3) << 24);
4713         sg_addr = aic_inb(p, SG_COUNT + 1) | (aic_inb(p, SG_COUNT + 2) << 8) |
4714           (aic_inb(p, SG_COUNT + 3) << 16) | (aic_inb(p, SG_COUNT + 4) << 24);
4715         resid_sgcnt = aic_inb(p, SCB_RESID_SGCNT);
4716         resid_dcnt = aic_inb(p, SCB_RESID_DCNT) |
4717           (aic_inb(p, SCB_RESID_DCNT + 1) << 8) |
4718           (aic_inb(p, SCB_RESID_DCNT + 2) << 16);
4719         index = scb->sg_count - ((resid_sgcnt) ? resid_sgcnt : 1);
4720         native_addr = le32_to_cpu(scb->sg_list[index].address);
4721         native_length = le32_to_cpu(scb->sg_list[index].length);
4722         /*
4723          * If resid_dcnt == native_length, then we just loaded this SG
4724          * segment and we need to back it up one...
4725          */
4726         if(resid_dcnt == native_length)
4727         {
4728           if(index == 0)
4729           {
4730             /*
4731              * Oops, this isn't right, we can't back up to before the
4732              * beginning.  This must be a bogus message, ignore it.
4733              */
4734             break;
4735           }
4736           resid_dcnt = 1;
4737           resid_sgcnt += 1;
4738           native_addr = le32_to_cpu(scb->sg_list[index - 1].address);
4739           native_length = le32_to_cpu(scb->sg_list[index - 1].length);
4740           cur_addr = native_addr + (native_length - 1);
4741           sg_addr -= sizeof(struct hw_scatterlist);
4742         }
4743         else
4744         {
4745           /*
4746            * resid_dcnt != native_length, so we are in the middle of a SG
4747            * element.  Back it up one byte and leave the rest alone.
4748            */
4749           resid_dcnt += 1;
4750           cur_addr -= 1;
4751         }
4752
4753         /*
4754          * Output the new addresses and counts to the right places on the
4755          * card.
4756          */
4757         aic_outb(p, resid_sgcnt, SG_COUNT);
4758         aic_outb(p, resid_sgcnt, SCB_RESID_SGCNT);
4759         aic_outb(p, sg_addr & 0xff, SG_COUNT + 1);
4760         aic_outb(p, (sg_addr >> 8) & 0xff, SG_COUNT + 2);
4761         aic_outb(p, (sg_addr >> 16) & 0xff, SG_COUNT + 3);
4762         aic_outb(p, (sg_addr >> 24) & 0xff, SG_COUNT + 4);
4763         aic_outb(p, resid_dcnt & 0xff, SCB_RESID_DCNT);
4764         aic_outb(p, (resid_dcnt >> 8) & 0xff, SCB_RESID_DCNT + 1);
4765         aic_outb(p, (resid_dcnt >> 16) & 0xff, SCB_RESID_DCNT + 2);
4766
4767         /*
4768          * The sequencer actually wants to find the new address
4769          * in the SHADDR register set.  On the Ultra2 and later controllers
4770          * this register set is readonly.  In order to get the right number
4771          * into the register, you actually have to enter it in HADDR and then
4772          * use the PRELOADEN bit of DFCNTRL to drop it through from the
4773          * HADDR register to the SHADDR register.  On non-Ultra2 controllers,
4774          * we simply write it direct.
4775          */
4776         if(p->features & AHC_ULTRA2)
4777         {
4778           /*
4779            * We might as well be accurate and drop both the resid_dcnt and
4780            * cur_addr into HCNT and HADDR and have both of them drop
4781            * through to the shadow layer together.
4782            */
4783           aic_outb(p, resid_dcnt & 0xff, HCNT);
4784           aic_outb(p, (resid_dcnt >> 8) & 0xff, HCNT + 1);
4785           aic_outb(p, (resid_dcnt >> 16) & 0xff, HCNT + 2);
4786           aic_outb(p, cur_addr & 0xff, HADDR);
4787           aic_outb(p, (cur_addr >> 8) & 0xff, HADDR + 1);
4788           aic_outb(p, (cur_addr >> 16) & 0xff, HADDR + 2);
4789           aic_outb(p, (cur_addr >> 24) & 0xff, HADDR + 3);
4790           aic_outb(p, aic_inb(p, DMAPARAMS) | PRELOADEN, DFCNTRL);
4791           udelay(1);
4792           aic_outb(p, aic_inb(p, DMAPARAMS) & ~(SCSIEN|HDMAEN), DFCNTRL);
4793           i=0;
4794           while(((aic_inb(p, DFCNTRL) & (SCSIEN|HDMAEN)) != 0) && (i++ < 1000))
4795           {
4796             udelay(1);
4797           }
4798         }
4799         else
4800         {
4801           aic_outb(p, cur_addr & 0xff, SHADDR);
4802           aic_outb(p, (cur_addr >> 8) & 0xff, SHADDR + 1);
4803           aic_outb(p, (cur_addr >> 16) & 0xff, SHADDR + 2);
4804           aic_outb(p, (cur_addr >> 24) & 0xff, SHADDR + 3);
4805         }
4806       }
4807       break;
4808
4809     case SEQ_SG_FIXUP:
4810     {
4811       unsigned char scb_index, tmp;
4812       int sg_addr, sg_length;
4813
4814       scb_index = aic_inb(p, SCB_TAG);
4815
4816       if(scb_index > p->scb_data->numscbs)
4817       {
4818         printk(WARN_LEAD "invalid scb_index during SEQ_SG_FIXUP.\n",
4819           p->host_no, -1, -1, -1);
4820         printk(INFO_LEAD "SCSISIGI 0x%x, SEQADDR 0x%x, SSTAT0 0x%x, SSTAT1 "
4821            "0x%x\n", p->host_no, -1, -1, -1,
4822            aic_inb(p, SCSISIGI),
4823            aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
4824            aic_inb(p, SSTAT0), aic_inb(p, SSTAT1));
4825         printk(INFO_LEAD "SG_CACHEPTR 0x%x, SSTAT2 0x%x, STCNT 0x%x\n",
4826            p->host_no, -1, -1, -1, aic_inb(p, SG_CACHEPTR),
4827            aic_inb(p, SSTAT2), aic_inb(p, STCNT + 2) << 16 |
4828            aic_inb(p, STCNT + 1) << 8 | aic_inb(p, STCNT));
4829         /*
4830          * XXX: Add error handling here
4831          */
4832         break;
4833       }
4834       scb = p->scb_data->scb_array[scb_index];
4835       if(!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
4836       {
4837         printk(WARN_LEAD "invalid scb during SEQ_SG_FIXUP flags:0x%x "
4838                "scb->cmd:0x%p\n", p->host_no, CTL_OF_SCB(scb),
4839                scb->flags, scb->cmd);
4840         printk(INFO_LEAD "SCSISIGI 0x%x, SEQADDR 0x%x, SSTAT0 0x%x, SSTAT1 "
4841            "0x%x\n", p->host_no, CTL_OF_SCB(scb),
4842            aic_inb(p, SCSISIGI),
4843            aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
4844            aic_inb(p, SSTAT0), aic_inb(p, SSTAT1));
4845         printk(INFO_LEAD "SG_CACHEPTR 0x%x, SSTAT2 0x%x, STCNT 0x%x\n",
4846            p->host_no, CTL_OF_SCB(scb), aic_inb(p, SG_CACHEPTR),
4847            aic_inb(p, SSTAT2), aic_inb(p, STCNT + 2) << 16 |
4848            aic_inb(p, STCNT + 1) << 8 | aic_inb(p, STCNT));
4849         break;
4850       }
4851       if(aic7xxx_verbose & VERBOSE_MINOR_ERROR)
4852         printk(INFO_LEAD "Fixing up SG address for sequencer.\n", p->host_no,
4853                CTL_OF_SCB(scb));
4854       /*
4855        * Advance the SG pointer to the next element in the list
4856        */
4857       tmp = aic_inb(p, SG_NEXT);
4858       tmp += SG_SIZEOF;
4859       aic_outb(p, tmp, SG_NEXT);
4860       if( tmp < SG_SIZEOF )
4861         aic_outb(p, aic_inb(p, SG_NEXT + 1) + 1, SG_NEXT + 1);
4862       tmp = aic_inb(p, SG_COUNT) - 1;
4863       aic_outb(p, tmp, SG_COUNT);
4864       sg_addr = le32_to_cpu(scb->sg_list[scb->sg_count - tmp].address);
4865       sg_length = le32_to_cpu(scb->sg_list[scb->sg_count - tmp].length);
4866       /*
4867        * Now stuff the element we just advanced past down onto the
4868        * card so it can be stored in the residual area.
4869        */
4870       aic_outb(p, sg_addr & 0xff, HADDR);
4871       aic_outb(p, (sg_addr >> 8) & 0xff, HADDR + 1);
4872       aic_outb(p, (sg_addr >> 16) & 0xff, HADDR + 2);
4873       aic_outb(p, (sg_addr >> 24) & 0xff, HADDR + 3);
4874       aic_outb(p, sg_length & 0xff, HCNT);
4875       aic_outb(p, (sg_length >> 8) & 0xff, HCNT + 1);
4876       aic_outb(p, (sg_length >> 16) & 0xff, HCNT + 2);
4877       aic_outb(p, (tmp << 2) | ((tmp == 1) ? LAST_SEG : 0), SG_CACHEPTR);
4878       aic_outb(p, aic_inb(p, DMAPARAMS), DFCNTRL);
4879       while(aic_inb(p, SSTAT0) & SDONE) udelay(1);
4880       while(aic_inb(p, DFCNTRL) & (HDMAEN|SCSIEN)) aic_outb(p, 0, DFCNTRL);
4881     }
4882     break;
4883
4884 #if AIC7XXX_NOT_YET
4885     case TRACEPOINT2:
4886       {
4887         printk(INFO_LEAD "Tracepoint #2 reached.\n", p->host_no,
4888                channel, target, lun);
4889       }
4890       break;
4891
4892     /* XXX Fill these in later */
4893     case MSG_BUFFER_BUSY:
4894       printk("aic7xxx: Message buffer busy.\n");
4895       break;
4896     case MSGIN_PHASEMIS:
4897       printk("aic7xxx: Message-in phasemis.\n");
4898       break;
4899 #endif
4900
4901     default:                   /* unknown */
4902       printk(WARN_LEAD "Unknown SEQINT, INTSTAT 0x%x, SCSISIGI 0x%x.\n",
4903              p->host_no, channel, target, lun, intstat,
4904              aic_inb(p, SCSISIGI));
4905       break;
4906   }
4907
4908   /*
4909    * Clear the sequencer interrupt and unpause the sequencer.
4910    */
4911   unpause_sequencer(p, /* unpause always */ TRUE);
4912 }
4913
4914 /*+F*************************************************************************
4915  * Function:
4916  *   aic7xxx_parse_msg
4917  *
4918  * Description:
4919  *   Parses incoming messages into actions on behalf of
4920  *   aic7xxx_handle_reqinit
4921  *_F*************************************************************************/
4922 static int
4923 aic7xxx_parse_msg(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
4924 {
4925   int reject, reply, done;
4926   unsigned char target_scsirate, tindex;
4927   unsigned short target_mask;
4928   unsigned char target, channel, lun;
4929   unsigned char bus_width, new_bus_width;
4930   unsigned char trans_options, new_trans_options;
4931   unsigned int period, new_period, offset, new_offset, maxsync;
4932   struct aic7xxx_syncrate *syncrate;
4933   struct aic_dev_data *aic_dev;
4934
4935   target = scb->cmd->device->id;
4936   channel = scb->cmd->device->channel;
4937   lun = scb->cmd->device->lun;
4938   reply = reject = done = FALSE;
4939   tindex = TARGET_INDEX(scb->cmd);
4940   aic_dev = AIC_DEV(scb->cmd);
4941   target_scsirate = aic_inb(p, TARG_SCSIRATE + tindex);
4942   target_mask = (0x01 << tindex);
4943
4944   /*
4945    * Parse as much of the message as is available,
4946    * rejecting it if we don't support it.  When
4947    * the entire message is available and has been
4948    * handled, return TRUE indicating that we have
4949    * parsed an entire message.
4950    */
4951
4952   if (p->msg_buf[0] != MSG_EXTENDED)
4953   {
4954     reject = TRUE;
4955   }
4956
4957   /*
4958    * Even if we are an Ultra3 card, don't allow Ultra3 sync rates when
4959    * using the SDTR messages.  We need the PPR messages to enable the
4960    * higher speeds that include things like Dual Edge clocking.
4961    */
4962   if (p->features & AHC_ULTRA2)
4963   {
4964     if ( (aic_inb(p, SBLKCTL) & ENAB40) &&
4965          !(aic_inb(p, SSTAT2) & EXP_ACTIVE) )
4966     {
4967       if (p->features & AHC_ULTRA3)
4968         maxsync = AHC_SYNCRATE_ULTRA3;
4969       else
4970         maxsync = AHC_SYNCRATE_ULTRA2;
4971     }
4972     else
4973     {
4974       maxsync = AHC_SYNCRATE_ULTRA;
4975     }
4976   }
4977   else if (p->features & AHC_ULTRA)
4978   {
4979     maxsync = AHC_SYNCRATE_ULTRA;
4980   }
4981   else
4982   {
4983     maxsync = AHC_SYNCRATE_FAST;
4984   }
4985
4986   /*
4987    * Just accept the length byte outright and perform
4988    * more checking once we know the message type.
4989    */
4990
4991   if ( !reject && (p->msg_len > 2) )
4992   {
4993     switch(p->msg_buf[2])
4994     {
4995       case MSG_EXT_SDTR:
4996       {
4997
4998         if (p->msg_buf[1] != MSG_EXT_SDTR_LEN)
4999         {
5000           reject = TRUE;
5001           break;
5002         }
5003
5004         if (p->msg_len < (MSG_EXT_SDTR_LEN + 2))
5005         {
5006           break;
5007         }
5008
5009         period = new_period = p->msg_buf[3];
5010         offset = new_offset = p->msg_buf[4];
5011         trans_options = new_trans_options = 0;
5012         bus_width = new_bus_width = target_scsirate & WIDEXFER;
5013
5014         /*
5015          * If our current max syncrate is in the Ultra3 range, bump it back
5016          * down to Ultra2 since we can't negotiate DT transfers using SDTR
5017          */
5018         if(maxsync == AHC_SYNCRATE_ULTRA3)
5019           maxsync = AHC_SYNCRATE_ULTRA2;
5020
5021         /*
5022          * We might have a device that is starting negotiation with us
5023          * before we can start up negotiation with it....be prepared to
5024          * have a device ask for a higher speed then we want to give it
5025          * in that case
5026          */
5027         if ( (scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_SDTR)) !=
5028              (SCB_MSGOUT_SENT|SCB_MSGOUT_SDTR) )
5029         {
5030           if (!(aic_dev->flags & DEVICE_DTR_SCANNED))
5031           {
5032             /*
5033              * We shouldn't get here unless this is a narrow drive, wide
5034              * devices should trigger this same section of code in the WDTR
5035              * handler first instead.
5036              */
5037             aic_dev->goal.width = MSG_EXT_WDTR_BUS_8_BIT;
5038             aic_dev->goal.options = 0;
5039             if(p->user[tindex].offset)
5040             {
5041               aic_dev->needsdtr_copy = 1;
5042               aic_dev->goal.period = max_t(unsigned char, 10,p->user[tindex].period);
5043               if(p->features & AHC_ULTRA2)
5044               {
5045                 aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
5046               }
5047               else
5048               {
5049                 aic_dev->goal.offset = MAX_OFFSET_8BIT;
5050               }
5051             }
5052             else
5053             {
5054               aic_dev->needsdtr_copy = 0;
5055               aic_dev->goal.period = 255;
5056               aic_dev->goal.offset = 0;
5057             }
5058             aic_dev->flags |= DEVICE_DTR_SCANNED | DEVICE_PRINT_DTR;
5059           }
5060           else if (aic_dev->needsdtr_copy == 0)
5061           {
5062             /*
5063              * This is a preemptive message from the target, we've already
5064              * scanned this target and set our options for it, and we
5065              * don't need a SDTR with this target (for whatever reason),
5066              * so reject this incoming SDTR
5067              */
5068             reject = TRUE;
5069             break;
5070           }
5071
5072           /* The device is sending this message first and we have to reply */
5073           reply = TRUE;
5074
5075           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5076           {
5077             printk(INFO_LEAD "Received pre-emptive SDTR message from "
5078                    "target.\n", p->host_no, CTL_OF_SCB(scb));
5079           }
5080           /*
5081            * Validate the values the device passed to us against our SEEPROM
5082            * settings.  We don't have to do this if we aren't replying since
5083            * the device isn't allowed to send values greater than the ones
5084            * we first sent to it.
5085            */
5086           new_period = max_t(unsigned int, period, aic_dev->goal.period);
5087           new_offset = min_t(unsigned int, offset, aic_dev->goal.offset);
5088         }
5089
5090         /*
5091          * Use our new_period, new_offset, bus_width, and card options
5092          * to determine the actual syncrate settings
5093          */
5094         syncrate = aic7xxx_find_syncrate(p, &new_period, maxsync,
5095                                          &trans_options);
5096         aic7xxx_validate_offset(p, syncrate, &new_offset, bus_width);
5097
5098         /*
5099          * Did we drop to async?  If so, send a reply regardless of whether
5100          * or not we initiated this negotiation.
5101          */
5102         if ((new_offset == 0) && (new_offset != offset))
5103         {
5104           aic_dev->needsdtr_copy = 0;
5105           reply = TRUE;
5106         }
5107
5108         /*
5109          * Did we start this, if not, or if we went too low and had to
5110          * go async, then send an SDTR back to the target
5111          */
5112         if(reply)
5113         {
5114           /* when sending a reply, make sure that the goal settings are
5115            * updated along with current and active since the code that
5116            * will actually build the message for the sequencer uses the
5117            * goal settings as its guidelines.
5118            */
5119           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5120                                new_offset, trans_options,
5121                                AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5122                                aic_dev);
5123           scb->flags &= ~SCB_MSGOUT_BITS;
5124           scb->flags |= SCB_MSGOUT_SDTR;
5125           aic_outb(p, HOST_MSG, MSG_OUT);
5126           aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5127         }
5128         else
5129         {
5130           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5131                                new_offset, trans_options,
5132                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5133           aic_dev->needsdtr = 0;
5134         }
5135         done = TRUE;
5136         break;
5137       }
5138       case MSG_EXT_WDTR:
5139       {
5140
5141         if (p->msg_buf[1] != MSG_EXT_WDTR_LEN)
5142         {
5143           reject = TRUE;
5144           break;
5145         }
5146
5147         if (p->msg_len < (MSG_EXT_WDTR_LEN + 2))
5148         {
5149           break;
5150         }
5151
5152         bus_width = new_bus_width = p->msg_buf[3];
5153
5154         if ( (scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_WDTR)) ==
5155              (SCB_MSGOUT_SENT|SCB_MSGOUT_WDTR) )
5156         {
5157           switch(bus_width)
5158           {
5159             default:
5160             {
5161               reject = TRUE;
5162               if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
5163                    ((aic_dev->flags & DEVICE_PRINT_DTR) ||
5164                     (aic7xxx_verbose > 0xffff)) )
5165               {
5166                 printk(INFO_LEAD "Requesting %d bit transfers, rejecting.\n",
5167                   p->host_no, CTL_OF_SCB(scb), 8 * (0x01 << bus_width));
5168               }
5169             } /* We fall through on purpose */
5170             case MSG_EXT_WDTR_BUS_8_BIT:
5171             {
5172               aic_dev->goal.width = MSG_EXT_WDTR_BUS_8_BIT;
5173               aic_dev->needwdtr_copy &= ~target_mask;
5174               break;
5175             }
5176             case MSG_EXT_WDTR_BUS_16_BIT:
5177             {
5178               break;
5179             }
5180           }
5181           aic_dev->needwdtr = 0;
5182           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5183                             AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5184         }
5185         else
5186         {
5187           if ( !(aic_dev->flags & DEVICE_DTR_SCANNED) )
5188           {
5189             /*
5190              * Well, we now know the WDTR and SYNC caps of this device since
5191              * it contacted us first, mark it as such and copy the user stuff
5192              * over to the goal stuff.
5193              */
5194             if( (p->features & AHC_WIDE) && p->user[tindex].width )
5195             {
5196               aic_dev->goal.width = MSG_EXT_WDTR_BUS_16_BIT;
5197               aic_dev->needwdtr_copy = 1;
5198             }
5199
5200             /*
5201              * Devices that support DT transfers don't start WDTR requests
5202              */
5203             aic_dev->goal.options = 0;
5204
5205             if(p->user[tindex].offset)
5206             {
5207               aic_dev->needsdtr_copy = 1;
5208               aic_dev->goal.period = max_t(unsigned char, 10, p->user[tindex].period);
5209               if(p->features & AHC_ULTRA2)
5210               {
5211                 aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
5212               }
5213               else if( aic_dev->goal.width )
5214               {
5215                 aic_dev->goal.offset = MAX_OFFSET_16BIT;
5216               }
5217               else
5218               {
5219                 aic_dev->goal.offset = MAX_OFFSET_8BIT;
5220               }
5221             } else {
5222               aic_dev->needsdtr_copy = 0;
5223               aic_dev->goal.period = 255;
5224               aic_dev->goal.offset = 0;
5225             }
5226
5227             aic_dev->flags |= DEVICE_DTR_SCANNED | DEVICE_PRINT_DTR;
5228           }
5229           else if (aic_dev->needwdtr_copy == 0)
5230           {
5231             /*
5232              * This is a preemptive message from the target, we've already
5233              * scanned this target and set our options for it, and we
5234              * don't need a WDTR with this target (for whatever reason),
5235              * so reject this incoming WDTR
5236              */
5237             reject = TRUE;
5238             break;
5239           }
5240
5241           /* The device is sending this message first and we have to reply */
5242           reply = TRUE;
5243
5244           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5245           {
5246             printk(INFO_LEAD "Received pre-emptive WDTR message from "
5247                    "target.\n", p->host_no, CTL_OF_SCB(scb));
5248           }
5249           switch(bus_width)
5250           {
5251             case MSG_EXT_WDTR_BUS_16_BIT:
5252             {
5253               if ( (p->features & AHC_WIDE) &&
5254                    (aic_dev->goal.width == MSG_EXT_WDTR_BUS_16_BIT) )
5255               {
5256                 new_bus_width = MSG_EXT_WDTR_BUS_16_BIT;
5257                 break;
5258               }
5259             } /* Fall through if we aren't a wide card */
5260             default:
5261             case MSG_EXT_WDTR_BUS_8_BIT:
5262             {
5263               aic_dev->needwdtr_copy = 0;
5264               new_bus_width = MSG_EXT_WDTR_BUS_8_BIT;
5265               break;
5266             }
5267           }
5268           scb->flags &= ~SCB_MSGOUT_BITS;
5269           scb->flags |= SCB_MSGOUT_WDTR;
5270           aic_dev->needwdtr = 0;
5271           if(aic_dev->dtr_pending == 0)
5272           {
5273             /* there is no other command with SCB_DTR_SCB already set that will
5274              * trigger the release of the dtr_pending bit.  Both set the bit
5275              * and set scb->flags |= SCB_DTR_SCB
5276              */
5277             aic_dev->dtr_pending = 1;
5278             scb->flags |= SCB_DTR_SCB;
5279           }
5280           aic_outb(p, HOST_MSG, MSG_OUT);
5281           aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5282           /* when sending a reply, make sure that the goal settings are
5283            * updated along with current and active since the code that
5284            * will actually build the message for the sequencer uses the
5285            * goal settings as its guidelines.
5286            */
5287           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5288                           AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5289                           aic_dev);
5290         }
5291
5292         /*
5293          * By virtue of the SCSI spec, a WDTR message negates any existing
5294          * SDTR negotiations.  So, even if needsdtr isn't marked for this
5295          * device, we still have to do a new SDTR message if the device
5296          * supports SDTR at all.  Therefore, we check needsdtr_copy instead
5297          * of needstr.
5298          */
5299         aic7xxx_set_syncrate(p, NULL, target, channel, 0, 0, 0,
5300                              AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
5301                              aic_dev);
5302         aic_dev->needsdtr = aic_dev->needsdtr_copy;
5303         done = TRUE;
5304         break;
5305       }
5306       case MSG_EXT_PPR:
5307       {
5308
5309         if (p->msg_buf[1] != MSG_EXT_PPR_LEN)
5310         {
5311           reject = TRUE;
5312           break;
5313         }
5314
5315         if (p->msg_len < (MSG_EXT_PPR_LEN + 2))
5316         {
5317           break;
5318         }
5319
5320         period = new_period = p->msg_buf[3];
5321         offset = new_offset = p->msg_buf[5];
5322         bus_width = new_bus_width = p->msg_buf[6];
5323         trans_options = new_trans_options = p->msg_buf[7] & 0xf;
5324
5325         if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5326         {
5327           printk(INFO_LEAD "Parsing PPR message (%d/%d/%d/%d)\n",
5328                  p->host_no, CTL_OF_SCB(scb), period, offset, bus_width,
5329                  trans_options);
5330         }
5331
5332         /*
5333          * We might have a device that is starting negotiation with us
5334          * before we can start up negotiation with it....be prepared to
5335          * have a device ask for a higher speed then we want to give it
5336          * in that case
5337          */
5338         if ( (scb->flags & (SCB_MSGOUT_SENT|SCB_MSGOUT_PPR)) !=
5339              (SCB_MSGOUT_SENT|SCB_MSGOUT_PPR) )
5340         {
5341           /* Have we scanned the device yet? */
5342           if (!(aic_dev->flags & DEVICE_DTR_SCANNED))
5343           {
5344             /* The device is electing to use PPR messages, so we will too until
5345              * we know better */
5346             aic_dev->needppr = aic_dev->needppr_copy = 1;
5347             aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
5348             aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
5349
5350             /* We know the device is SCSI-3 compliant due to PPR */
5351             aic_dev->flags |= DEVICE_SCSI_3;
5352
5353             /*
5354              * Not only is the device starting this up, but it also hasn't
5355              * been scanned yet, so this would likely be our TUR or our
5356              * INQUIRY command at scan time, so we need to use the
5357              * settings from the SEEPROM if they existed.  Of course, even
5358              * if we didn't find a SEEPROM, we stuffed default values into
5359              * the user settings anyway, so use those in all cases.
5360              */
5361             aic_dev->goal.width = p->user[tindex].width;
5362             if(p->user[tindex].offset)
5363             {
5364               aic_dev->goal.period = p->user[tindex].period;
5365               aic_dev->goal.options = p->user[tindex].options;
5366               if(p->features & AHC_ULTRA2)
5367               {
5368                 aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
5369               }
5370               else if( aic_dev->goal.width &&
5371                        (bus_width == MSG_EXT_WDTR_BUS_16_BIT) &&
5372                        p->features & AHC_WIDE )
5373               {
5374                 aic_dev->goal.offset = MAX_OFFSET_16BIT;
5375               }
5376               else
5377               {
5378                 aic_dev->goal.offset = MAX_OFFSET_8BIT;
5379               }
5380             }
5381             else
5382             {
5383               aic_dev->goal.period = 255;
5384               aic_dev->goal.offset = 0;
5385               aic_dev->goal.options = 0;
5386             }
5387             aic_dev->flags |= DEVICE_DTR_SCANNED | DEVICE_PRINT_DTR;
5388           }
5389           else if (aic_dev->needppr_copy == 0)
5390           {
5391             /*
5392              * This is a preemptive message from the target, we've already
5393              * scanned this target and set our options for it, and we
5394              * don't need a PPR with this target (for whatever reason),
5395              * so reject this incoming PPR
5396              */
5397             reject = TRUE;
5398             break;
5399           }
5400
5401           /* The device is sending this message first and we have to reply */
5402           reply = TRUE;
5403
5404           if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
5405           {
5406             printk(INFO_LEAD "Received pre-emptive PPR message from "
5407                    "target.\n", p->host_no, CTL_OF_SCB(scb));
5408           }
5409
5410         }
5411
5412         switch(bus_width)
5413         {
5414           case MSG_EXT_WDTR_BUS_16_BIT:
5415           {
5416             if ( (aic_dev->goal.width == MSG_EXT_WDTR_BUS_16_BIT) &&
5417                             p->features & AHC_WIDE)
5418             {
5419               break;
5420             }
5421           }
5422           default:
5423           {
5424             if ( (aic7xxx_verbose & VERBOSE_NEGOTIATION2) &&
5425                  ((aic_dev->flags & DEVICE_PRINT_DTR) ||
5426                   (aic7xxx_verbose > 0xffff)) )
5427             {
5428               reply = TRUE;
5429               printk(INFO_LEAD "Requesting %d bit transfers, rejecting.\n",
5430                 p->host_no, CTL_OF_SCB(scb), 8 * (0x01 << bus_width));
5431             }
5432           } /* We fall through on purpose */
5433           case MSG_EXT_WDTR_BUS_8_BIT:
5434           {
5435             /*
5436              * According to the spec, if we aren't wide, we also can't be
5437              * Dual Edge so clear the options byte
5438              */
5439             new_trans_options = 0;
5440             new_bus_width = MSG_EXT_WDTR_BUS_8_BIT;
5441             break;
5442           }
5443         }
5444
5445         if(reply)
5446         {
5447           /* when sending a reply, make sure that the goal settings are
5448            * updated along with current and active since the code that
5449            * will actually build the message for the sequencer uses the
5450            * goal settings as its guidelines.
5451            */
5452           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5453                             AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5454                             aic_dev);
5455           syncrate = aic7xxx_find_syncrate(p, &new_period, maxsync,
5456                                            &new_trans_options);
5457           aic7xxx_validate_offset(p, syncrate, &new_offset, new_bus_width);
5458           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5459                                new_offset, new_trans_options,
5460                                AHC_TRANS_GOAL|AHC_TRANS_ACTIVE|AHC_TRANS_CUR,
5461                                aic_dev);
5462         }
5463         else
5464         {
5465           aic7xxx_set_width(p, target, channel, lun, new_bus_width,
5466                             AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5467           syncrate = aic7xxx_find_syncrate(p, &new_period, maxsync,
5468                                            &new_trans_options);
5469           aic7xxx_validate_offset(p, syncrate, &new_offset, new_bus_width);
5470           aic7xxx_set_syncrate(p, syncrate, target, channel, new_period,
5471                                new_offset, new_trans_options,
5472                                AHC_TRANS_ACTIVE|AHC_TRANS_CUR, aic_dev);
5473         }
5474
5475         /*
5476          * As it turns out, if we don't *have* to have PPR messages, then
5477          * configure ourselves not to use them since that makes some
5478          * external drive chassis work (those chassis can't parse PPR
5479          * messages and they mangle the SCSI bus until you send a WDTR
5480          * and SDTR that they can understand).
5481          */
5482         if(new_trans_options == 0)
5483         {
5484           aic_dev->needppr = aic_dev->needppr_copy = 0;
5485           if(new_offset)
5486           {
5487             aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
5488           }
5489           if (new_bus_width)
5490           {
5491             aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
5492           }
5493         }
5494
5495         if((new_offset == 0) && (offset != 0))
5496         {
5497           /*
5498            * Oops, the syncrate went to low for this card and we fell off
5499            * to async (should never happen with a device that uses PPR
5500            * messages, but have to be complete)
5501            */
5502           reply = TRUE;
5503         }
5504
5505         if(reply)
5506         {
5507           scb->flags &= ~SCB_MSGOUT_BITS;
5508           scb->flags |= SCB_MSGOUT_PPR;
5509           aic_outb(p, HOST_MSG, MSG_OUT);
5510           aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5511         }
5512         else
5513         {
5514           aic_dev->needppr = 0;
5515         }
5516         done = TRUE;
5517         break;
5518       }
5519       default:
5520       {
5521         reject = TRUE;
5522         break;
5523       }
5524     } /* end of switch(p->msg_type) */
5525   } /* end of if (!reject && (p->msg_len > 2)) */
5526
5527   if (!reply && reject)
5528   {
5529     aic_outb(p, MSG_MESSAGE_REJECT, MSG_OUT);
5530     aic_outb(p, aic_inb(p, SCSISIGO) | ATNO, SCSISIGO);
5531     done = TRUE;
5532   }
5533   return(done);
5534 }
5535
5536
5537 /*+F*************************************************************************
5538  * Function:
5539  *   aic7xxx_handle_reqinit
5540  *
5541  * Description:
5542  *   Interrupt handler for REQINIT interrupts (used to transfer messages to
5543  *    and from devices).
5544  *_F*************************************************************************/
5545 static void
5546 aic7xxx_handle_reqinit(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
5547 {
5548   unsigned char lastbyte;
5549   unsigned char phasemis;
5550   int done = FALSE;
5551
5552   switch(p->msg_type)
5553   {
5554     case MSG_TYPE_INITIATOR_MSGOUT:
5555       {
5556         if (p->msg_len == 0)
5557           panic("aic7xxx: REQINIT with no active message!\n");
5558
5559         lastbyte = (p->msg_index == (p->msg_len - 1));
5560         phasemis = ( aic_inb(p, SCSISIGI) & PHASE_MASK) != P_MESGOUT;
5561
5562         if (lastbyte || phasemis)
5563         {
5564           /* Time to end the message */
5565           p->msg_len = 0;
5566           p->msg_type = MSG_TYPE_NONE;
5567           /*
5568            * NOTE-TO-MYSELF: If you clear the REQINIT after you
5569            * disable REQINITs, then cases of REJECT_MSG stop working
5570            * and hang the bus
5571            */
5572           aic_outb(p, aic_inb(p, SIMODE1) & ~ENREQINIT, SIMODE1);
5573           aic_outb(p, CLRSCSIINT, CLRINT);
5574           p->flags &= ~AHC_HANDLING_REQINITS;
5575
5576           if (phasemis == 0)
5577           {
5578             aic_outb(p, p->msg_buf[p->msg_index], SINDEX);
5579             aic_outb(p, 0, RETURN_1);
5580 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5581             if (aic7xxx_verbose > 0xffff)
5582               printk(INFO_LEAD "Completed sending of REQINIT message.\n",
5583                      p->host_no, CTL_OF_SCB(scb));
5584 #endif
5585           }
5586           else
5587           {
5588             aic_outb(p, MSGOUT_PHASEMIS, RETURN_1);
5589 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5590             if (aic7xxx_verbose > 0xffff)
5591               printk(INFO_LEAD "PHASEMIS while sending REQINIT message.\n",
5592                      p->host_no, CTL_OF_SCB(scb));
5593 #endif
5594           }
5595           unpause_sequencer(p, TRUE);
5596         }
5597         else
5598         {
5599           /*
5600            * Present the byte on the bus (clearing REQINIT) but don't
5601            * unpause the sequencer.
5602            */
5603           aic_outb(p, CLRREQINIT, CLRSINT1);
5604           aic_outb(p, CLRSCSIINT, CLRINT);
5605           aic_outb(p,  p->msg_buf[p->msg_index++], SCSIDATL);
5606         }
5607         break;
5608       }
5609     case MSG_TYPE_INITIATOR_MSGIN:
5610       {
5611         phasemis = ( aic_inb(p, SCSISIGI) & PHASE_MASK ) != P_MESGIN;
5612
5613         if (phasemis == 0)
5614         {
5615           p->msg_len++;
5616           /* Pull the byte in without acking it */
5617           p->msg_buf[p->msg_index] = aic_inb(p, SCSIBUSL);
5618           done = aic7xxx_parse_msg(p, scb);
5619           /* Ack the byte */
5620           aic_outb(p, CLRREQINIT, CLRSINT1);
5621           aic_outb(p, CLRSCSIINT, CLRINT);
5622           aic_inb(p, SCSIDATL);
5623           p->msg_index++;
5624         }
5625         if (phasemis || done)
5626         {
5627 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5628           if (aic7xxx_verbose > 0xffff)
5629           {
5630             if (phasemis)
5631               printk(INFO_LEAD "PHASEMIS while receiving REQINIT message.\n",
5632                      p->host_no, CTL_OF_SCB(scb));
5633             else
5634               printk(INFO_LEAD "Completed receipt of REQINIT message.\n",
5635                      p->host_no, CTL_OF_SCB(scb));
5636           }
5637 #endif
5638           /* Time to end our message session */
5639           p->msg_len = 0;
5640           p->msg_type = MSG_TYPE_NONE;
5641           aic_outb(p, aic_inb(p, SIMODE1) & ~ENREQINIT, SIMODE1);
5642           aic_outb(p, CLRSCSIINT, CLRINT);
5643           p->flags &= ~AHC_HANDLING_REQINITS;
5644           unpause_sequencer(p, TRUE);
5645         }
5646         break;
5647       }
5648     default:
5649       {
5650         panic("aic7xxx: Unknown REQINIT message type.\n");
5651         break;
5652       }
5653   } /* End of switch(p->msg_type) */
5654 }
5655
5656 /*+F*************************************************************************
5657  * Function:
5658  *   aic7xxx_handle_scsiint
5659  *
5660  * Description:
5661  *   Interrupt handler for SCSI interrupts (SCSIINT).
5662  *-F*************************************************************************/
5663 static void
5664 aic7xxx_handle_scsiint(struct aic7xxx_host *p, unsigned char intstat)
5665 {
5666   unsigned char scb_index;
5667   unsigned char status;
5668   struct aic7xxx_scb *scb;
5669   struct aic_dev_data *aic_dev;
5670
5671   scb_index = aic_inb(p, SCB_TAG);
5672   status = aic_inb(p, SSTAT1);
5673
5674   if (scb_index < p->scb_data->numscbs)
5675   {
5676     scb = p->scb_data->scb_array[scb_index];
5677     if ((scb->flags & SCB_ACTIVE) == 0)
5678     {
5679       scb = NULL;
5680     }
5681   }
5682   else
5683   {
5684     scb = NULL;
5685   }
5686
5687
5688   if ((status & SCSIRSTI) != 0)
5689   {
5690     int channel;
5691
5692     if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
5693       channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3;
5694     else
5695       channel = 0;
5696
5697     if (aic7xxx_verbose & VERBOSE_RESET)
5698       printk(WARN_LEAD "Someone else reset the channel!!\n",
5699            p->host_no, channel, -1, -1);
5700     if (aic7xxx_panic_on_abort)
5701       aic7xxx_panic_abort(p, NULL);
5702     /*
5703      * Go through and abort all commands for the channel, but do not
5704      * reset the channel again.
5705      */
5706     aic7xxx_reset_channel(p, channel, /* Initiate Reset */ FALSE);
5707     aic7xxx_run_done_queue(p, TRUE);
5708     scb = NULL;
5709   }
5710   else if ( ((status & BUSFREE) != 0) && ((status & SELTO) == 0) )
5711   {
5712     /*
5713      * First look at what phase we were last in.  If it's message-out,
5714      * chances are pretty good that the bus free was in response to
5715      * one of our abort requests.
5716      */
5717     unsigned char lastphase = aic_inb(p, LASTPHASE);
5718     unsigned char saved_tcl = aic_inb(p, SAVED_TCL);
5719     unsigned char target = (saved_tcl >> 4) & 0x0F;
5720     int channel;
5721     int printerror = TRUE;
5722
5723     if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
5724       channel = (aic_inb(p, SBLKCTL) & SELBUSB) >> 3;
5725     else
5726       channel = 0;
5727
5728     aic_outb(p, aic_inb(p, SCSISEQ) & (ENSELI|ENRSELI|ENAUTOATNP),
5729              SCSISEQ);
5730     if (lastphase == P_MESGOUT)
5731     {
5732       unsigned char message;
5733
5734       message = aic_inb(p, SINDEX);
5735
5736       if ((message == MSG_ABORT) || (message == MSG_ABORT_TAG))
5737       {
5738         if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)
5739           printk(INFO_LEAD "SCB %d abort delivered.\n", p->host_no,
5740             CTL_OF_SCB(scb), scb->hscb->tag);
5741         aic7xxx_reset_device(p, target, channel, ALL_LUNS,
5742                 (message == MSG_ABORT) ? SCB_LIST_NULL : scb->hscb->tag );
5743         aic7xxx_run_done_queue(p, TRUE);
5744         scb = NULL;
5745         printerror = 0;
5746       }
5747       else if (message == MSG_BUS_DEV_RESET)
5748       {
5749         aic7xxx_handle_device_reset(p, target, channel);
5750         scb = NULL;
5751         printerror = 0;
5752       }
5753     }
5754     if ( (scb != NULL) && (scb->flags & SCB_DTR_SCB) )
5755     {
5756       /*
5757        * Hmmm...error during a negotiation command.  Either we have a
5758        * borken bus, or the device doesn't like our negotiation message.
5759        * Since we check the INQUIRY data of a device before sending it
5760        * negotiation messages, assume the bus is borken for whatever
5761        * reason.  Complete the command.
5762        */
5763       printerror = 0;
5764       aic7xxx_reset_device(p, target, channel, ALL_LUNS, scb->hscb->tag);
5765       aic7xxx_run_done_queue(p, TRUE);
5766       scb = NULL;
5767     }
5768     if (printerror != 0)
5769     {
5770       if (scb != NULL)
5771       {
5772         unsigned char tag;
5773
5774         if ((scb->hscb->control & TAG_ENB) != 0)
5775         {
5776           tag = scb->hscb->tag;
5777         }
5778         else
5779         {
5780           tag = SCB_LIST_NULL;
5781         }
5782         aic7xxx_reset_device(p, target, channel, ALL_LUNS, tag);
5783         aic7xxx_run_done_queue(p, TRUE);
5784       }
5785       else
5786       {
5787         aic7xxx_reset_device(p, target, channel, ALL_LUNS, SCB_LIST_NULL);
5788         aic7xxx_run_done_queue(p, TRUE);
5789       }
5790       printk(INFO_LEAD "Unexpected busfree, LASTPHASE = 0x%x, "
5791              "SEQADDR = 0x%x\n", p->host_no, channel, target, -1, lastphase,
5792              (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0));
5793       scb = NULL;
5794     }
5795     aic_outb(p, MSG_NOOP, MSG_OUT);
5796     aic_outb(p, aic_inb(p, SIMODE1) & ~(ENBUSFREE|ENREQINIT),
5797       SIMODE1);
5798     p->flags &= ~AHC_HANDLING_REQINITS;
5799     aic_outb(p, CLRBUSFREE, CLRSINT1);
5800     aic_outb(p, CLRSCSIINT, CLRINT);
5801     restart_sequencer(p);
5802     unpause_sequencer(p, TRUE);
5803   }
5804   else if ((status & SELTO) != 0)
5805   {
5806     unsigned char scbptr;
5807     unsigned char nextscb;
5808     Scsi_Cmnd *cmd;
5809
5810     scbptr = aic_inb(p, WAITING_SCBH);
5811     if (scbptr > p->scb_data->maxhscbs)
5812     {
5813       /*
5814        * I'm still trying to track down exactly how this happens, but until
5815        * I find it, this code will make sure we aren't passing bogus values
5816        * into the SCBPTR register, even if that register will just wrap
5817        * things around, we still don't like having out of range variables.
5818        *
5819        * NOTE: Don't check the aic7xxx_verbose variable, I want this message
5820        * to always be displayed.
5821        */
5822       printk(INFO_LEAD "Invalid WAITING_SCBH value %d, improvising.\n",
5823              p->host_no, -1, -1, -1, scbptr);
5824       if (p->scb_data->maxhscbs > 4)
5825         scbptr &= (p->scb_data->maxhscbs - 1);
5826       else
5827         scbptr &= 0x03;
5828     }
5829     aic_outb(p, scbptr, SCBPTR);
5830     scb_index = aic_inb(p, SCB_TAG);
5831
5832     scb = NULL;
5833     if (scb_index < p->scb_data->numscbs)
5834     {
5835       scb = p->scb_data->scb_array[scb_index];
5836       if ((scb->flags & SCB_ACTIVE) == 0)
5837       {
5838         scb = NULL;
5839       }
5840     }
5841     if (scb == NULL)
5842     {
5843       printk(WARN_LEAD "Referenced SCB %d not valid during SELTO.\n",
5844              p->host_no, -1, -1, -1, scb_index);
5845       printk(KERN_WARNING "        SCSISEQ = 0x%x SEQADDR = 0x%x SSTAT0 = 0x%x "
5846              "SSTAT1 = 0x%x\n", aic_inb(p, SCSISEQ),
5847              aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
5848              aic_inb(p, SSTAT0), aic_inb(p, SSTAT1));
5849       if (aic7xxx_panic_on_abort)
5850         aic7xxx_panic_abort(p, NULL);
5851     }
5852     else
5853     {
5854       cmd = scb->cmd;
5855       cmd->result = (DID_TIME_OUT << 16);
5856
5857       /*
5858        * Clear out this hardware SCB
5859        */
5860       aic_outb(p, 0, SCB_CONTROL);
5861
5862       /*
5863        * Clear out a few values in the card that are in an undetermined
5864        * state.
5865        */
5866       aic_outb(p, MSG_NOOP, MSG_OUT);
5867
5868       /*
5869        * Shift the waiting for selection queue forward
5870        */
5871       nextscb = aic_inb(p, SCB_NEXT);
5872       aic_outb(p, nextscb, WAITING_SCBH);
5873
5874       /*
5875        * Put this SCB back on the free list.
5876        */
5877       aic7xxx_add_curscb_to_free_list(p);
5878 #ifdef AIC7XXX_VERBOSE_DEBUGGING
5879       if (aic7xxx_verbose > 0xffff)
5880         printk(INFO_LEAD "Selection Timeout.\n", p->host_no, CTL_OF_SCB(scb));
5881 #endif
5882       if (scb->flags & SCB_QUEUED_ABORT)
5883       {
5884         /*
5885          * We know that this particular SCB had to be the queued abort since
5886          * the disconnected SCB would have gotten a reconnect instead.
5887          * What we need to do then is to let the command timeout again so
5888          * we get a reset since this abort just failed.
5889          */
5890         cmd->result = 0;
5891         scb = NULL;
5892       }
5893     }
5894     /*
5895      * Keep the sequencer from trying to restart any selections
5896      */
5897     aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ);
5898     /*
5899      * Make sure the data bits on the bus are released
5900      * Don't do this on 7770 chipsets, it makes them give us
5901      * a BRKADDRINT and kills the card.
5902      */
5903     if( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI )
5904       aic_outb(p, 0, SCSIBUSL);
5905
5906     /*
5907      * Delay for the selection timeout delay period then stop the selection
5908      */
5909     udelay(301);
5910     aic_outb(p, CLRSELINGO, CLRSINT0);
5911     /*
5912      * Clear out all the interrupt status bits
5913      */
5914     aic_outb(p, aic_inb(p, SIMODE1) & ~(ENREQINIT|ENBUSFREE), SIMODE1);
5915     p->flags &= ~AHC_HANDLING_REQINITS;
5916     aic_outb(p, CLRSELTIMEO | CLRBUSFREE, CLRSINT1);
5917     aic_outb(p, CLRSCSIINT, CLRINT);
5918     /*
5919      * Restarting the sequencer will stop the selection and make sure devices
5920      * are allowed to reselect in.
5921      */
5922     restart_sequencer(p);
5923     unpause_sequencer(p, TRUE);
5924   }
5925   else if (scb == NULL)
5926   {
5927     printk(WARN_LEAD "aic7xxx_isr - referenced scb not valid "
5928            "during scsiint 0x%x scb(%d)\n"
5929            "      SIMODE0 0x%x, SIMODE1 0x%x, SSTAT0 0x%x, SEQADDR 0x%x\n",
5930            p->host_no, -1, -1, -1, status, scb_index, aic_inb(p, SIMODE0),
5931            aic_inb(p, SIMODE1), aic_inb(p, SSTAT0),
5932            (aic_inb(p, SEQADDR1) << 8) | aic_inb(p, SEQADDR0));
5933     /*
5934      * Turn off the interrupt and set status to zero, so that it
5935      * falls through the rest of the SCSIINT code.
5936      */
5937     aic_outb(p, status, CLRSINT1);
5938     aic_outb(p, CLRSCSIINT, CLRINT);
5939     unpause_sequencer(p, /* unpause always */ TRUE);
5940     scb = NULL;
5941   }
5942   else if (status & SCSIPERR)
5943   {
5944     /*
5945      * Determine the bus phase and queue an appropriate message.
5946      */
5947     char  *phase;
5948     Scsi_Cmnd *cmd;
5949     unsigned char mesg_out = MSG_NOOP;
5950     unsigned char lastphase = aic_inb(p, LASTPHASE);
5951     unsigned char sstat2 = aic_inb(p, SSTAT2);
5952
5953     cmd = scb->cmd;
5954     switch (lastphase)
5955     {
5956       case P_DATAOUT:
5957         phase = "Data-Out";
5958         break;
5959       case P_DATAIN:
5960         phase = "Data-In";
5961         mesg_out = MSG_INITIATOR_DET_ERR;
5962         break;
5963       case P_COMMAND:
5964         phase = "Command";
5965         break;
5966       case P_MESGOUT:
5967         phase = "Message-Out";
5968         break;
5969       case P_STATUS:
5970         phase = "Status";
5971         mesg_out = MSG_INITIATOR_DET_ERR;
5972         break;
5973       case P_MESGIN:
5974         phase = "Message-In";
5975         mesg_out = MSG_PARITY_ERROR;
5976         break;
5977       default:
5978         phase = "unknown";
5979         break;
5980     }
5981
5982     /*
5983      * A parity error has occurred during a data
5984      * transfer phase. Flag it and continue.
5985      */
5986     if( (p->features & AHC_ULTRA3) &&
5987         (aic_inb(p, SCSIRATE) & AHC_SYNCRATE_CRC) &&
5988         (lastphase == P_DATAIN) )
5989     {
5990       printk(WARN_LEAD "CRC error during %s phase.\n",
5991              p->host_no, CTL_OF_SCB(scb), phase);
5992       if(sstat2 & CRCVALERR)
5993       {
5994         printk(WARN_LEAD "  CRC error in intermediate CRC packet.\n",
5995                p->host_no, CTL_OF_SCB(scb));
5996       }
5997       if(sstat2 & CRCENDERR)
5998       {
5999         printk(WARN_LEAD "  CRC error in ending CRC packet.\n",
6000                p->host_no, CTL_OF_SCB(scb));
6001       }
6002       if(sstat2 & CRCREQERR)
6003       {
6004         printk(WARN_LEAD "  Target incorrectly requested a CRC packet.\n",
6005                p->host_no, CTL_OF_SCB(scb));
6006       }
6007       if(sstat2 & DUAL_EDGE_ERROR)
6008       {
6009         printk(WARN_LEAD "  Dual Edge transmission error.\n",
6010                p->host_no, CTL_OF_SCB(scb));
6011       }
6012     }
6013     else if( (lastphase == P_MESGOUT) &&
6014              (scb->flags & SCB_MSGOUT_PPR) )
6015     {
6016       /*
6017        * As per the draft specs, any device capable of supporting any of
6018        * the option values other than 0 are not allowed to reject the
6019        * PPR message.  Instead, they must negotiate out what they do
6020        * support instead of rejecting our offering or else they cause
6021        * a parity error during msg_out phase to signal that they don't
6022        * like our settings.
6023        */
6024       aic_dev = AIC_DEV(scb->cmd);
6025       aic_dev->needppr = aic_dev->needppr_copy = 0;
6026       aic7xxx_set_width(p, scb->cmd->device->id, scb->cmd->device->channel, scb->cmd->device->lun,
6027                         MSG_EXT_WDTR_BUS_8_BIT,
6028                         (AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE),
6029                         aic_dev);
6030       aic7xxx_set_syncrate(p, NULL, scb->cmd->device->id, scb->cmd->device->channel, 0, 0,
6031                            0, AHC_TRANS_ACTIVE|AHC_TRANS_CUR|AHC_TRANS_QUITE,
6032                            aic_dev);
6033       aic_dev->goal.options = 0;
6034       scb->flags &= ~SCB_MSGOUT_BITS;
6035       if(aic7xxx_verbose & VERBOSE_NEGOTIATION2)
6036       {
6037         printk(INFO_LEAD "parity error during PPR message, reverting "
6038                "to WDTR/SDTR\n", p->host_no, CTL_OF_SCB(scb));
6039       }
6040       if ( aic_dev->goal.width )
6041       {
6042         aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
6043       }
6044       if ( aic_dev->goal.offset )
6045       {
6046         if( aic_dev->goal.period <= 9 )
6047         {
6048           aic_dev->goal.period = 10;
6049         }
6050         aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
6051       }
6052       scb = NULL;
6053     }
6054
6055     /*
6056      * We've set the hardware to assert ATN if we get a parity
6057      * error on "in" phases, so all we need to do is stuff the
6058      * message buffer with the appropriate message.  "In" phases
6059      * have set mesg_out to something other than MSG_NOP.
6060      */
6061     if (mesg_out != MSG_NOOP)
6062     {
6063       aic_outb(p, mesg_out, MSG_OUT);
6064       aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
6065       scb = NULL;
6066     }
6067     aic_outb(p, CLRSCSIPERR, CLRSINT1);
6068     aic_outb(p, CLRSCSIINT, CLRINT);
6069     unpause_sequencer(p, /* unpause_always */ TRUE);
6070   }
6071   else if ( (status & REQINIT) &&
6072             (p->flags & AHC_HANDLING_REQINITS) )
6073   {
6074 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6075     if (aic7xxx_verbose > 0xffff)
6076       printk(INFO_LEAD "Handling REQINIT, SSTAT1=0x%x.\n", p->host_no,
6077              CTL_OF_SCB(scb), aic_inb(p, SSTAT1));
6078 #endif
6079     aic7xxx_handle_reqinit(p, scb);
6080     return;
6081   }
6082   else
6083   {
6084     /*
6085      * We don't know what's going on. Turn off the
6086      * interrupt source and try to continue.
6087      */
6088     if (aic7xxx_verbose & VERBOSE_SCSIINT)
6089       printk(INFO_LEAD "Unknown SCSIINT status, SSTAT1(0x%x).\n",
6090         p->host_no, -1, -1, -1, status);
6091     aic_outb(p, status, CLRSINT1);
6092     aic_outb(p, CLRSCSIINT, CLRINT);
6093     unpause_sequencer(p, /* unpause always */ TRUE);
6094     scb = NULL;
6095   }
6096   if (scb != NULL)
6097   {
6098     aic7xxx_done(p, scb);
6099   }
6100 }
6101
6102 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6103 static void
6104 aic7xxx_check_scbs(struct aic7xxx_host *p, char *buffer)
6105 {
6106   unsigned char saved_scbptr, free_scbh, dis_scbh, wait_scbh, temp;
6107   int i, bogus, lost;
6108   static unsigned char scb_status[AIC7XXX_MAXSCB];
6109
6110 #define SCB_NO_LIST 0
6111 #define SCB_FREE_LIST 1
6112 #define SCB_WAITING_LIST 2
6113 #define SCB_DISCONNECTED_LIST 4
6114 #define SCB_CURRENTLY_ACTIVE 8
6115
6116   /*
6117    * Note, these checks will fail on a regular basis once the machine moves
6118    * beyond the bus scan phase.  The problem is race conditions concerning
6119    * the scbs and where they are linked in.  When you have 30 or so commands
6120    * outstanding on the bus, and run this twice with every interrupt, the
6121    * chances get pretty good that you'll catch the sequencer with an SCB
6122    * only partially linked in.  Therefore, once we pass the scan phase
6123    * of the bus, we really should disable this function.
6124    */
6125   bogus = FALSE;
6126   memset(&scb_status[0], 0, sizeof(scb_status));
6127   pause_sequencer(p);
6128   saved_scbptr = aic_inb(p, SCBPTR);
6129   if (saved_scbptr >= p->scb_data->maxhscbs)
6130   {
6131     printk("Bogus SCBPTR %d\n", saved_scbptr);
6132     bogus = TRUE;
6133   }
6134   scb_status[saved_scbptr] = SCB_CURRENTLY_ACTIVE;
6135   free_scbh = aic_inb(p, FREE_SCBH);
6136   if ( (free_scbh != SCB_LIST_NULL) &&
6137        (free_scbh >= p->scb_data->maxhscbs) )
6138   {
6139     printk("Bogus FREE_SCBH %d\n", free_scbh);
6140     bogus = TRUE;
6141   }
6142   else
6143   {
6144     temp = free_scbh;
6145     while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) )
6146     {
6147       if(scb_status[temp] & 0x07)
6148       {
6149         printk("HSCB %d on multiple lists, status 0x%02x", temp,
6150                scb_status[temp] | SCB_FREE_LIST);
6151         bogus = TRUE;
6152       }
6153       scb_status[temp] |= SCB_FREE_LIST;
6154       aic_outb(p, temp, SCBPTR);
6155       temp = aic_inb(p, SCB_NEXT);
6156     }
6157   }
6158
6159   dis_scbh = aic_inb(p, DISCONNECTED_SCBH);
6160   if ( (dis_scbh != SCB_LIST_NULL) &&
6161        (dis_scbh >= p->scb_data->maxhscbs) )
6162   {
6163     printk("Bogus DISCONNECTED_SCBH %d\n", dis_scbh);
6164     bogus = TRUE;
6165   }
6166   else
6167   {
6168     temp = dis_scbh;
6169     while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) )
6170     {
6171       if(scb_status[temp] & 0x07)
6172       {
6173         printk("HSCB %d on multiple lists, status 0x%02x", temp,
6174                scb_status[temp] | SCB_DISCONNECTED_LIST);
6175         bogus = TRUE;
6176       }
6177       scb_status[temp] |= SCB_DISCONNECTED_LIST;
6178       aic_outb(p, temp, SCBPTR);
6179       temp = aic_inb(p, SCB_NEXT);
6180     }
6181   }
6182
6183   wait_scbh = aic_inb(p, WAITING_SCBH);
6184   if ( (wait_scbh != SCB_LIST_NULL) &&
6185        (wait_scbh >= p->scb_data->maxhscbs) )
6186   {
6187     printk("Bogus WAITING_SCBH %d\n", wait_scbh);
6188     bogus = TRUE;
6189   }
6190   else
6191   {
6192     temp = wait_scbh;
6193     while( (temp != SCB_LIST_NULL) && (temp < p->scb_data->maxhscbs) )
6194     {
6195       if(scb_status[temp] & 0x07)
6196       {
6197         printk("HSCB %d on multiple lists, status 0x%02x", temp,
6198                scb_status[temp] | SCB_WAITING_LIST);
6199         bogus = TRUE;
6200       }
6201       scb_status[temp] |= SCB_WAITING_LIST;
6202       aic_outb(p, temp, SCBPTR);
6203       temp = aic_inb(p, SCB_NEXT);
6204     }
6205   }
6206
6207   lost=0;
6208   for(i=0; i < p->scb_data->maxhscbs; i++)
6209   {
6210     aic_outb(p, i, SCBPTR);
6211     temp = aic_inb(p, SCB_NEXT);
6212     if ( ((temp != SCB_LIST_NULL) &&
6213           (temp >= p->scb_data->maxhscbs)) )
6214     {
6215       printk("HSCB %d bad, SCB_NEXT invalid(%d).\n", i, temp);
6216       bogus = TRUE;
6217     }
6218     if ( temp == i )
6219     {
6220       printk("HSCB %d bad, SCB_NEXT points to self.\n", i);
6221       bogus = TRUE;
6222     }
6223     if (scb_status[i] == 0)
6224       lost++;
6225     if (lost > 1)
6226     {
6227       printk("Too many lost scbs.\n");
6228       bogus=TRUE;
6229     }
6230   }
6231   aic_outb(p, saved_scbptr, SCBPTR);
6232   unpause_sequencer(p, FALSE);
6233   if (bogus)
6234   {
6235     printk("Bogus parameters found in card SCB array structures.\n");
6236     printk("%s\n", buffer);
6237     aic7xxx_panic_abort(p, NULL);
6238   }
6239   return;
6240 }
6241 #endif
6242
6243
6244 /*+F*************************************************************************
6245  * Function:
6246  *   aic7xxx_handle_command_completion_intr
6247  *
6248  * Description:
6249  *   SCSI command completion interrupt handler.
6250  *-F*************************************************************************/
6251 static void
6252 aic7xxx_handle_command_completion_intr(struct aic7xxx_host *p)
6253 {
6254   struct aic7xxx_scb *scb = NULL;
6255   struct aic_dev_data *aic_dev;
6256   Scsi_Cmnd *cmd;
6257   unsigned char scb_index, tindex;
6258
6259 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6260   if( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) )
6261     printk(INFO_LEAD "Command Complete Int.\n", p->host_no, -1, -1, -1);
6262 #endif
6263
6264   /*
6265    * Read the INTSTAT location after clearing the CMDINT bit.  This forces
6266    * any posted PCI writes to flush to memory.  Gerard Roudier suggested
6267    * this fix to the possible race of clearing the CMDINT bit but not
6268    * having all command bytes flushed onto the qoutfifo.
6269    */
6270   aic_outb(p, CLRCMDINT, CLRINT);
6271   aic_inb(p, INTSTAT);
6272   /*
6273    * The sequencer will continue running when it
6274    * issues this interrupt. There may be >1 commands
6275    * finished, so loop until we've processed them all.
6276    */
6277
6278   while (p->qoutfifo[p->qoutfifonext] != SCB_LIST_NULL)
6279   {
6280     scb_index = p->qoutfifo[p->qoutfifonext];
6281     p->qoutfifo[p->qoutfifonext++] = SCB_LIST_NULL;
6282     if ( scb_index >= p->scb_data->numscbs )
6283     {
6284       printk(WARN_LEAD "CMDCMPLT with invalid SCB index %d\n", p->host_no,
6285         -1, -1, -1, scb_index);
6286       continue;
6287     }
6288     scb = p->scb_data->scb_array[scb_index];
6289     if (!(scb->flags & SCB_ACTIVE) || (scb->cmd == NULL))
6290     {
6291       printk(WARN_LEAD "CMDCMPLT without command for SCB %d, SCB flags "
6292         "0x%x, cmd 0x%lx\n", p->host_no, -1, -1, -1, scb_index, scb->flags,
6293         (unsigned long) scb->cmd);
6294       continue;
6295     }
6296     tindex = TARGET_INDEX(scb->cmd);
6297     aic_dev = AIC_DEV(scb->cmd);
6298     if (scb->flags & SCB_QUEUED_ABORT)
6299     {
6300       pause_sequencer(p);
6301       if ( ((aic_inb(p, LASTPHASE) & PHASE_MASK) != P_BUSFREE) &&
6302            (aic_inb(p, SCB_TAG) == scb->hscb->tag) )
6303       {
6304         unpause_sequencer(p, FALSE);
6305         continue;
6306       }
6307       aic7xxx_reset_device(p, scb->cmd->device->id, scb->cmd->device->channel,
6308         scb->cmd->device->lun, scb->hscb->tag);
6309       scb->flags &= ~(SCB_QUEUED_FOR_DONE | SCB_RESET | SCB_ABORT |
6310         SCB_QUEUED_ABORT);
6311       unpause_sequencer(p, FALSE);
6312     }
6313     else if (scb->flags & SCB_ABORT)
6314     {
6315       /*
6316        * We started to abort this, but it completed on us, let it
6317        * through as successful
6318        */
6319       scb->flags &= ~(SCB_ABORT|SCB_RESET);
6320     }
6321     else if (scb->flags & SCB_SENSE)
6322     {
6323       char *buffer = &scb->cmd->sense_buffer[0];
6324
6325       if (buffer[12] == 0x47 || buffer[12] == 0x54)
6326       {
6327         /*
6328          * Signal that we need to re-negotiate things.
6329          */
6330         aic_dev->needppr = aic_dev->needppr_copy;
6331         aic_dev->needsdtr = aic_dev->needsdtr_copy;
6332         aic_dev->needwdtr = aic_dev->needwdtr_copy;
6333       }
6334     }
6335     cmd = scb->cmd;
6336     if (scb->hscb->residual_SG_segment_count != 0)
6337     {
6338       aic7xxx_calculate_residual(p, scb);
6339     }
6340     cmd->result |= (aic7xxx_error(cmd) << 16);
6341     aic7xxx_done(p, scb);
6342   }
6343 }
6344
6345 /*+F*************************************************************************
6346  * Function:
6347  *   aic7xxx_isr
6348  *
6349  * Description:
6350  *   SCSI controller interrupt handler.
6351  *-F*************************************************************************/
6352 static void
6353 aic7xxx_isr(int irq, void *dev_id, struct pt_regs *regs)
6354 {
6355   struct aic7xxx_host *p;
6356   unsigned char intstat;
6357
6358   p = (struct aic7xxx_host *)dev_id;
6359
6360   /*
6361    * Just a few sanity checks.  Make sure that we have an int pending.
6362    * Also, if PCI, then we are going to check for a PCI bus error status
6363    * should we get too many spurious interrupts.
6364    */
6365   if (!((intstat = aic_inb(p, INTSTAT)) & INT_PEND))
6366   {
6367 #ifdef CONFIG_PCI
6368     if ( (p->chip & AHC_PCI) && (p->spurious_int > 500) &&
6369         !(p->flags & AHC_HANDLING_REQINITS) )
6370     {
6371       if ( aic_inb(p, ERROR) & PCIERRSTAT )
6372       {
6373         aic7xxx_pci_intr(p);
6374       }
6375       p->spurious_int = 0;
6376     }
6377     else if ( !(p->flags & AHC_HANDLING_REQINITS) )
6378     {
6379       p->spurious_int++;
6380     }
6381 #endif
6382     return;
6383   }
6384
6385   p->spurious_int = 0;
6386
6387   /*
6388    * Keep track of interrupts for /proc/scsi
6389    */
6390   p->isr_count++;
6391
6392 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6393   if ( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) &&
6394        (aic7xxx_panic_on_abort) && (p->flags & AHC_PAGESCBS) )
6395     aic7xxx_check_scbs(p, "Bogus settings at start of interrupt.");
6396 #endif
6397
6398   /*
6399    * Handle all the interrupt sources - especially for SCSI
6400    * interrupts, we won't get a second chance at them.
6401    */
6402   if (intstat & CMDCMPLT)
6403   {
6404     aic7xxx_handle_command_completion_intr(p);
6405   }
6406
6407   if (intstat & BRKADRINT)
6408   {
6409     int i;
6410     unsigned char errno = aic_inb(p, ERROR);
6411
6412     printk(KERN_ERR "(scsi%d) BRKADRINT error(0x%x):\n", p->host_no, errno);
6413     for (i = 0; i < ARRAY_SIZE(hard_error); i++)
6414     {
6415       if (errno & hard_error[i].errno)
6416       {
6417         printk(KERN_ERR "  %s\n", hard_error[i].errmesg);
6418       }
6419     }
6420     printk(KERN_ERR "(scsi%d)   SEQADDR=0x%x\n", p->host_no,
6421       (((aic_inb(p, SEQADDR1) << 8) & 0x100) | aic_inb(p, SEQADDR0)));
6422     if (aic7xxx_panic_on_abort)
6423       aic7xxx_panic_abort(p, NULL);
6424 #ifdef CONFIG_PCI
6425     if (errno & PCIERRSTAT)
6426       aic7xxx_pci_intr(p);
6427 #endif
6428     if (errno & (SQPARERR | ILLOPCODE | ILLSADDR))
6429     {
6430       panic("aic7xxx: unrecoverable BRKADRINT.\n");
6431     }
6432     if (errno & ILLHADDR)
6433     {
6434       printk(KERN_ERR "(scsi%d) BUG! Driver accessed chip without first "
6435              "pausing controller!\n", p->host_no);
6436     }
6437 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6438     if (errno & DPARERR)
6439     {
6440       if (aic_inb(p, DMAPARAMS) & DIRECTION)
6441         printk("(scsi%d) while DMAing SCB from host to card.\n", p->host_no);
6442       else
6443         printk("(scsi%d) while DMAing SCB from card to host.\n", p->host_no);
6444     }
6445 #endif
6446     aic_outb(p, CLRPARERR | CLRBRKADRINT, CLRINT);
6447     unpause_sequencer(p, FALSE);
6448   }
6449
6450   if (intstat & SEQINT)
6451   {
6452     /*
6453      * Read the CCSCBCTL register to work around a bug in the Ultra2 cards
6454      */
6455     if(p->features & AHC_ULTRA2)
6456     {
6457       aic_inb(p, CCSCBCTL);
6458     }
6459     aic7xxx_handle_seqint(p, intstat);
6460   }
6461
6462   if (intstat & SCSIINT)
6463   {
6464     aic7xxx_handle_scsiint(p, intstat);
6465   }
6466
6467 #ifdef AIC7XXX_VERBOSE_DEBUGGING
6468   if ( (p->isr_count < 16) && (aic7xxx_verbose > 0xffff) &&
6469        (aic7xxx_panic_on_abort) && (p->flags & AHC_PAGESCBS) )
6470     aic7xxx_check_scbs(p, "Bogus settings at end of interrupt.");
6471 #endif
6472
6473 }
6474
6475 /*+F*************************************************************************
6476  * Function:
6477  *   do_aic7xxx_isr
6478  *
6479  * Description:
6480  *   This is a gross hack to solve a problem in linux kernels 2.1.85 and
6481  *   above.  Please, children, do not try this at home, and if you ever see
6482  *   anything like it, please inform the Gross Hack Police immediately
6483  *-F*************************************************************************/
6484 static irqreturn_t
6485 do_aic7xxx_isr(int irq, void *dev_id, struct pt_regs *regs)
6486 {
6487   unsigned long cpu_flags;
6488   struct aic7xxx_host *p;
6489
6490   p = (struct aic7xxx_host *)dev_id;
6491   if(!p)
6492     return IRQ_NONE;
6493   spin_lock_irqsave(p->host->host_lock, cpu_flags);
6494   p->flags |= AHC_IN_ISR;
6495   do
6496   {
6497     aic7xxx_isr(irq, dev_id, regs);
6498   } while ( (aic_inb(p, INTSTAT) & INT_PEND) );
6499   aic7xxx_done_cmds_complete(p);
6500   aic7xxx_run_waiting_queues(p);
6501   p->flags &= ~AHC_IN_ISR;
6502   spin_unlock_irqrestore(p->host->host_lock, cpu_flags);
6503
6504   return IRQ_HANDLED;
6505 }
6506
6507 /*+F*************************************************************************
6508  * Function:
6509  *   aic7xxx_init_transinfo
6510  *
6511  * Description:
6512  *   Set up the initial aic_dev values from the BIOS settings and from
6513  *   INQUIRY results
6514  *-F*************************************************************************/
6515 static void
6516 aic7xxx_init_transinfo(struct aic7xxx_host *p, struct aic_dev_data *aic_dev)
6517 {
6518   Scsi_Device *sdpnt = aic_dev->SDptr;
6519   unsigned char tindex;
6520
6521   tindex = sdpnt->id | (sdpnt->channel << 3);
6522   if (!(aic_dev->flags & DEVICE_DTR_SCANNED))
6523   {
6524     aic_dev->flags |= DEVICE_DTR_SCANNED;
6525
6526     if ( sdpnt->wdtr && (p->features & AHC_WIDE) )
6527     {
6528       aic_dev->needwdtr = aic_dev->needwdtr_copy = 1;
6529       aic_dev->goal.width = p->user[tindex].width;
6530     }
6531     else
6532     {
6533       aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
6534       pause_sequencer(p);
6535       aic7xxx_set_width(p, sdpnt->id, sdpnt->channel, sdpnt->lun,
6536                         MSG_EXT_WDTR_BUS_8_BIT, (AHC_TRANS_ACTIVE |
6537                                                  AHC_TRANS_GOAL |
6538                                                  AHC_TRANS_CUR), aic_dev );
6539       unpause_sequencer(p, FALSE);
6540     }
6541     if ( sdpnt->sdtr && p->user[tindex].offset )
6542     {
6543       aic_dev->goal.period = p->user[tindex].period;
6544       aic_dev->goal.options = p->user[tindex].options;
6545       if (p->features & AHC_ULTRA2)
6546         aic_dev->goal.offset = MAX_OFFSET_ULTRA2;
6547       else if (aic_dev->goal.width == MSG_EXT_WDTR_BUS_16_BIT)
6548         aic_dev->goal.offset = MAX_OFFSET_16BIT;
6549       else
6550         aic_dev->goal.offset = MAX_OFFSET_8BIT;
6551       if ( sdpnt->ppr && p->user[tindex].period <= 9 &&
6552              p->user[tindex].options )
6553       {
6554         aic_dev->needppr = aic_dev->needppr_copy = 1;
6555         aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
6556         aic_dev->needwdtr = aic_dev->needwdtr_copy = 0;
6557         aic_dev->flags |= DEVICE_SCSI_3;
6558       }
6559       else
6560       {
6561         aic_dev->needsdtr = aic_dev->needsdtr_copy = 1;
6562         aic_dev->goal.period = max_t(unsigned char, 10, aic_dev->goal.period);
6563         aic_dev->goal.options = 0;
6564       }
6565     }
6566     else
6567     {
6568       aic_dev->needsdtr = aic_dev->needsdtr_copy = 0;
6569       aic_dev->goal.period = 255;
6570       aic_dev->goal.offset = 0;
6571       aic_dev->goal.options = 0;
6572     }
6573     aic_dev->flags |= DEVICE_PRINT_DTR;
6574   }
6575 }
6576
6577 /*+F*************************************************************************
6578  * Function:
6579  *   aic7xxx_slave_alloc
6580  *
6581  * Description:
6582  *   Set up the initial aic_dev struct pointers
6583  *-F*************************************************************************/
6584 static int
6585 aic7xxx_slave_alloc(Scsi_Device *SDptr)
6586 {
6587   struct aic7xxx_host *p = (struct aic7xxx_host *)SDptr->host->hostdata;
6588   struct aic_dev_data *aic_dev;
6589
6590   aic_dev = kmalloc(sizeof(struct aic_dev_data), GFP_ATOMIC | GFP_KERNEL);
6591   if(!aic_dev)
6592     return 1;
6593   /*
6594    * Check to see if channel was scanned.
6595    */
6596
6597   if (!(p->flags & AHC_A_SCANNED) && (SDptr->channel == 0))
6598   {
6599     if (aic7xxx_verbose & VERBOSE_PROBE2)
6600       printk(INFO_LEAD "Scanning channel for devices.\n",
6601         p->host_no, 0, -1, -1);
6602     p->flags |= AHC_A_SCANNED;
6603   }
6604   else
6605   {
6606     if (!(p->flags & AHC_B_SCANNED) && (SDptr->channel == 1))
6607     {
6608       if (aic7xxx_verbose & VERBOSE_PROBE2)
6609         printk(INFO_LEAD "Scanning channel for devices.\n",
6610           p->host_no, 1, -1, -1);
6611       p->flags |= AHC_B_SCANNED;
6612     }
6613   }
6614
6615   memset(aic_dev, 0, sizeof(struct aic_dev_data));
6616   SDptr->hostdata = aic_dev;
6617   aic_dev->SDptr = SDptr;
6618   aic_dev->max_q_depth = 1;
6619   aic_dev->temp_q_depth = 1;
6620   scbq_init(&aic_dev->delayed_scbs);
6621   INIT_LIST_HEAD(&aic_dev->list);
6622   list_add_tail(&aic_dev->list, &p->aic_devs);
6623   return 0;
6624 }
6625
6626 /*+F*************************************************************************
6627  * Function:
6628  *   aic7xxx_device_queue_depth
6629  *
6630  * Description:
6631  *   Determines the queue depth for a given device.  There are two ways
6632  *   a queue depth can be obtained for a tagged queueing device.  One
6633  *   way is the default queue depth which is determined by whether
6634  *   aic7xxx_default_queue_depth.  The other is by the aic7xxx_tag_info
6635  *   array.
6636  *
6637  *   If tagged queueing isn't supported on the device, then we set the
6638  *   depth to p->host->hostt->cmd_per_lun for internal driver queueing.
6639  *   as the default queue depth.  Otherwise, we use either 4 or 8 as the
6640  *   default queue depth (dependent on the number of hardware SCBs).
6641  *   The other way we determine queue depth is through the use of the
6642  *   aic7xxx_tag_info array which is enabled by defining
6643  *   AIC7XXX_TAGGED_QUEUEING_BY_DEVICE.  This array can be initialized
6644  *   with queue depths for individual devices.  It also allows tagged
6645  *   queueing to be [en|dis]abled for a specific adapter.
6646  *-F*************************************************************************/
6647 static void
6648 aic7xxx_device_queue_depth(struct aic7xxx_host *p, Scsi_Device *device)
6649 {
6650   int tag_enabled = FALSE;
6651   struct aic_dev_data *aic_dev = device->hostdata;
6652   unsigned char tindex;
6653
6654   tindex = device->id | (device->channel << 3);
6655
6656   if (device->simple_tags)
6657     return; // We've already enabled this device
6658
6659   if (device->tagged_supported)
6660   {
6661     tag_enabled = TRUE;
6662
6663     if (!(p->discenable & (1 << tindex)))
6664     {
6665       if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
6666         printk(INFO_LEAD "Disconnection disabled, unable to "
6667              "enable tagged queueing.\n",
6668              p->host_no, device->channel, device->id, device->lun);
6669       tag_enabled = FALSE;
6670     }
6671     else
6672     {
6673       if (p->instance >= ARRAY_SIZE(aic7xxx_tag_info))
6674       {
6675         static int print_warning = TRUE;
6676         if(print_warning)
6677         {
6678           printk(KERN_INFO "aic7xxx: WARNING, insufficient tag_info instances for"
6679                            " installed controllers.\n");
6680           printk(KERN_INFO "aic7xxx: Please update the aic7xxx_tag_info array in"
6681                            " the aic7xxx.c source file.\n");
6682           print_warning = FALSE;
6683         }
6684         aic_dev->max_q_depth = aic_dev->temp_q_depth =
6685                 aic7xxx_default_queue_depth;
6686       }
6687       else
6688       {
6689
6690         if (aic7xxx_tag_info[p->instance].tag_commands[tindex] == 255)
6691         {
6692           tag_enabled = FALSE;
6693         }
6694         else if (aic7xxx_tag_info[p->instance].tag_commands[tindex] == 0)
6695         {
6696           aic_dev->max_q_depth = aic_dev->temp_q_depth =
6697                   aic7xxx_default_queue_depth;
6698         }
6699         else
6700         {
6701           aic_dev->max_q_depth = aic_dev->temp_q_depth =
6702             aic7xxx_tag_info[p->instance].tag_commands[tindex];
6703         }
6704       }
6705     }
6706   }
6707   if (tag_enabled)
6708   {
6709     if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
6710     {
6711           printk(INFO_LEAD "Tagged queuing enabled, queue depth %d.\n",
6712             p->host_no, device->channel, device->id,
6713             device->lun, aic_dev->max_q_depth);
6714     }
6715     scsi_adjust_queue_depth(device, MSG_ORDERED_TAG, aic_dev->max_q_depth);
6716   }
6717   else
6718   {
6719     if (aic7xxx_verbose & VERBOSE_NEGOTIATION2)
6720     {
6721           printk(INFO_LEAD "Tagged queuing disabled, queue depth %d.\n",
6722             p->host_no, device->channel, device->id,
6723             device->lun, device->host->cmd_per_lun);
6724     }
6725     scsi_adjust_queue_depth(device, 0, device->host->cmd_per_lun);
6726   }
6727   return;
6728 }
6729
6730 /*+F*************************************************************************
6731  * Function:
6732  *   aic7xxx_slave_destroy
6733  *
6734  * Description:
6735  *   prepare for this device to go away
6736  *-F*************************************************************************/
6737 static void
6738 aic7xxx_slave_destroy(Scsi_Device *SDptr)
6739 {
6740   struct aic_dev_data *aic_dev = SDptr->hostdata;
6741
6742   list_del(&aic_dev->list);
6743   SDptr->hostdata = NULL;
6744   kfree(aic_dev);
6745   return;
6746 }
6747
6748 /*+F*************************************************************************
6749  * Function:
6750  *   aic7xxx_slave_configure
6751  *
6752  * Description:
6753  *   Configure the device we are attaching to the controller.  This is
6754  *   where we get to do things like scan the INQUIRY data, set queue
6755  *   depths, allocate command structs, etc.
6756  *-F*************************************************************************/
6757 static int
6758 aic7xxx_slave_configure(Scsi_Device *SDptr)
6759 {
6760   struct aic7xxx_host *p = (struct aic7xxx_host *) SDptr->host->hostdata;
6761   struct aic_dev_data *aic_dev;
6762   int scbnum;
6763
6764   aic_dev = (struct aic_dev_data *)SDptr->hostdata;
6765
6766   aic7xxx_init_transinfo(p, aic_dev);
6767   aic7xxx_device_queue_depth(p, SDptr);
6768   if(list_empty(&aic_dev->list))
6769     list_add_tail(&aic_dev->list, &p->aic_devs);
6770
6771   scbnum = 0;
6772   list_for_each_entry(aic_dev, &p->aic_devs, list) {
6773     scbnum += aic_dev->max_q_depth;
6774   }
6775   while (scbnum > p->scb_data->numscbs)
6776   {
6777     /*
6778      * Pre-allocate the needed SCBs to get around the possibility of having
6779      * to allocate some when memory is more or less exhausted and we need
6780      * the SCB in order to perform a swap operation (possible deadlock)
6781      */
6782     if ( aic7xxx_allocate_scb(p) == 0 )
6783       break;
6784   }
6785
6786
6787   return(0);
6788 }
6789
6790 /*+F*************************************************************************
6791  * Function:
6792  *   aic7xxx_probe
6793  *
6794  * Description:
6795  *   Probing for EISA boards: it looks like the first two bytes
6796  *   are a manufacturer code - three characters, five bits each:
6797  *
6798  *               BYTE 0   BYTE 1   BYTE 2   BYTE 3
6799  *              ?1111122 22233333 PPPPPPPP RRRRRRRR
6800  *
6801  *   The characters are baselined off ASCII '@', so add that value
6802  *   to each to get the real ASCII code for it. The next two bytes
6803  *   appear to be a product and revision number, probably vendor-
6804  *   specific. This is what is being searched for at each port,
6805  *   and what should probably correspond to the ID= field in the
6806  *   ECU's .cfg file for the card - if your card is not detected,
6807  *   make sure your signature is listed in the array.
6808  *
6809  *   The fourth byte's lowest bit seems to be an enabled/disabled
6810  *   flag (rest of the bits are reserved?).
6811  *
6812  * NOTE:  This function is only needed on Intel and Alpha platforms,
6813  *   the other platforms we support don't have EISA/VLB busses.  So,
6814  *   we #ifdef this entire function to avoid compiler warnings about
6815  *   an unused function.
6816  *-F*************************************************************************/
6817 #if defined(__i386__) || defined(__alpha__)
6818 static int
6819 aic7xxx_probe(int slot, int base, ahc_flag_type *flags)
6820 {
6821   int i;
6822   unsigned char buf[4];
6823
6824   static struct {
6825     int n;
6826     unsigned char signature[sizeof(buf)];
6827     ahc_chip type;
6828     int bios_disabled;
6829   } AIC7xxx[] = {
6830     { 4, { 0x04, 0x90, 0x77, 0x70 },
6831       AHC_AIC7770|AHC_EISA, FALSE },  /* mb 7770  */
6832     { 4, { 0x04, 0x90, 0x77, 0x71 },
6833       AHC_AIC7770|AHC_EISA, FALSE }, /* host adapter 274x */
6834     { 4, { 0x04, 0x90, 0x77, 0x56 },
6835       AHC_AIC7770|AHC_VL, FALSE }, /* 284x BIOS enabled */
6836     { 4, { 0x04, 0x90, 0x77, 0x57 },
6837       AHC_AIC7770|AHC_VL, TRUE }   /* 284x BIOS disabled */
6838   };
6839
6840   /*
6841    * The VL-bus cards need to be primed by
6842    * writing before a signature check.
6843    */
6844   for (i = 0; i < sizeof(buf); i++)
6845   {
6846     outb(0x80 + i, base);
6847     buf[i] = inb(base + i);
6848   }
6849
6850   for (i = 0; i < ARRAY_SIZE(AIC7xxx); i++)
6851   {
6852     /*
6853      * Signature match on enabled card?
6854      */
6855     if (!memcmp(buf, AIC7xxx[i].signature, AIC7xxx[i].n))
6856     {
6857       if (inb(base + 4) & 1)
6858       {
6859         if (AIC7xxx[i].bios_disabled)
6860         {
6861           *flags |= AHC_USEDEFAULTS;
6862         }
6863         else
6864         {
6865           *flags |= AHC_BIOS_ENABLED;
6866         }
6867         return (i);
6868       }
6869
6870       printk("aic7xxx: <Adaptec 7770 SCSI Host Adapter> "
6871              "disabled at slot %d, ignored.\n", slot);
6872     }
6873   }
6874
6875   return (-1);
6876 }
6877 #endif /* (__i386__) || (__alpha__) */
6878
6879
6880 /*+F*************************************************************************
6881  * Function:
6882  *   read_2840_seeprom
6883  *
6884  * Description:
6885  *   Reads the 2840 serial EEPROM and returns 1 if successful and 0 if
6886  *   not successful.
6887  *
6888  *   See read_seeprom (for the 2940) for the instruction set of the 93C46
6889  *   chip.
6890  *
6891  *   The 2840 interface to the 93C46 serial EEPROM is through the
6892  *   STATUS_2840 and SEECTL_2840 registers.  The CS_2840, CK_2840, and
6893  *   DO_2840 bits of the SEECTL_2840 register are connected to the chip
6894  *   select, clock, and data out lines respectively of the serial EEPROM.
6895  *   The DI_2840 bit of the STATUS_2840 is connected to the data in line
6896  *   of the serial EEPROM.  The EEPROM_TF bit of STATUS_2840 register is
6897  *   useful in that it gives us an 800 nsec timer.  After a read from the
6898  *   SEECTL_2840 register the timing flag is cleared and goes high 800 nsec
6899  *   later.
6900  *-F*************************************************************************/
6901 static int
6902 read_284x_seeprom(struct aic7xxx_host *p, struct seeprom_config *sc)
6903 {
6904   int i = 0, k = 0;
6905   unsigned char temp;
6906   unsigned short checksum = 0;
6907   unsigned short *seeprom = (unsigned short *) sc;
6908   struct seeprom_cmd {
6909     unsigned char len;
6910     unsigned char bits[3];
6911   };
6912   struct seeprom_cmd seeprom_read = {3, {1, 1, 0}};
6913
6914 #define CLOCK_PULSE(p) \
6915   while ((aic_inb(p, STATUS_2840) & EEPROM_TF) == 0)        \
6916   {                                                \
6917     ;  /* Do nothing */                                \
6918   }                                                \
6919   (void) aic_inb(p, SEECTL_2840);
6920
6921   /*
6922    * Read the first 32 registers of the seeprom.  For the 2840,
6923    * the 93C46 SEEPROM is a 1024-bit device with 64 16-bit registers
6924    * but only the first 32 are used by Adaptec BIOS.  The loop
6925    * will range from 0 to 31.
6926    */
6927   for (k = 0; k < (sizeof(*sc) / 2); k++)
6928   {
6929     /*
6930      * Send chip select for one clock cycle.
6931      */
6932     aic_outb(p, CK_2840 | CS_2840, SEECTL_2840);
6933     CLOCK_PULSE(p);
6934
6935     /*
6936      * Now we're ready to send the read command followed by the
6937      * address of the 16-bit register we want to read.
6938      */
6939     for (i = 0; i < seeprom_read.len; i++)
6940     {
6941       temp = CS_2840 | seeprom_read.bits[i];
6942       aic_outb(p, temp, SEECTL_2840);
6943       CLOCK_PULSE(p);
6944       temp = temp ^ CK_2840;
6945       aic_outb(p, temp, SEECTL_2840);
6946       CLOCK_PULSE(p);
6947     }
6948     /*
6949      * Send the 6 bit address (MSB first, LSB last).
6950      */
6951     for (i = 5; i >= 0; i--)
6952     {
6953       temp = k;
6954       temp = (temp >> i) & 1;  /* Mask out all but lower bit. */
6955       temp = CS_2840 | temp;
6956       aic_outb(p, temp, SEECTL_2840);
6957       CLOCK_PULSE(p);
6958       temp = temp ^ CK_2840;
6959       aic_outb(p, temp, SEECTL_2840);
6960       CLOCK_PULSE(p);
6961     }
6962
6963     /*
6964      * Now read the 16 bit register.  An initial 0 precedes the
6965      * register contents which begins with bit 15 (MSB) and ends
6966      * with bit 0 (LSB).  The initial 0 will be shifted off the
6967      * top of our word as we let the loop run from 0 to 16.
6968      */
6969     for (i = 0; i <= 16; i++)
6970     {
6971       temp = CS_2840;
6972       aic_outb(p, temp, SEECTL_2840);
6973       CLOCK_PULSE(p);
6974       temp = temp ^ CK_2840;
6975       seeprom[k] = (seeprom[k] << 1) | (aic_inb(p, STATUS_2840) & DI_2840);
6976       aic_outb(p, temp, SEECTL_2840);
6977       CLOCK_PULSE(p);
6978     }
6979     /*
6980      * The serial EEPROM has a checksum in the last word.  Keep a
6981      * running checksum for all words read except for the last
6982      * word.  We'll verify the checksum after all words have been
6983      * read.
6984      */
6985     if (k < (sizeof(*sc) / 2) - 1)
6986     {
6987       checksum = checksum + seeprom[k];
6988     }
6989
6990     /*
6991      * Reset the chip select for the next command cycle.
6992      */
6993     aic_outb(p, 0, SEECTL_2840);
6994     CLOCK_PULSE(p);
6995     aic_outb(p, CK_2840, SEECTL_2840);
6996     CLOCK_PULSE(p);
6997     aic_outb(p, 0, SEECTL_2840);
6998     CLOCK_PULSE(p);
6999   }
7000
7001 #if 0
7002   printk("Computed checksum 0x%x, checksum read 0x%x\n", checksum, sc->checksum);
7003   printk("Serial EEPROM:");
7004   for (k = 0; k < (sizeof(*sc) / 2); k++)
7005   {
7006     if (((k % 8) == 0) && (k != 0))
7007     {
7008       printk("\n              ");
7009     }
7010     printk(" 0x%x", seeprom[k]);
7011   }
7012   printk("\n");
7013 #endif
7014
7015   if (checksum != sc->checksum)
7016   {
7017     printk("aic7xxx: SEEPROM checksum error, ignoring SEEPROM settings.\n");
7018     return (0);
7019   }
7020
7021   return (1);
7022 #undef CLOCK_PULSE
7023 }
7024
7025 #define CLOCK_PULSE(p)                                               \
7026   do {                                                               \
7027     int limit = 0;                                                   \
7028     do {                                                             \
7029       mb();                                                          \
7030       pause_sequencer(p);  /* This is just to generate some PCI */   \
7031                            /* traffic so the PCI read is flushed */  \
7032                            /* it shouldn't be needed, but some */    \
7033                            /* chipsets do indeed appear to need */   \
7034                            /* something to force PCI reads to get */ \
7035                            /* flushed */                             \
7036       udelay(1);           /* Do nothing */                          \
7037     } while (((aic_inb(p, SEECTL) & SEERDY) == 0) && (++limit < 1000)); \
7038   } while(0)
7039
7040 /*+F*************************************************************************
7041  * Function:
7042  *   acquire_seeprom
7043  *
7044  * Description:
7045  *   Acquires access to the memory port on PCI controllers.
7046  *-F*************************************************************************/
7047 static int
7048 acquire_seeprom(struct aic7xxx_host *p)
7049 {
7050
7051   /*
7052    * Request access of the memory port.  When access is
7053    * granted, SEERDY will go high.  We use a 1 second
7054    * timeout which should be near 1 second more than
7055    * is needed.  Reason: after the 7870 chip reset, there
7056    * should be no contention.
7057    */
7058   aic_outb(p, SEEMS, SEECTL);
7059   CLOCK_PULSE(p);
7060   if ((aic_inb(p, SEECTL) & SEERDY) == 0)
7061   {
7062     aic_outb(p, 0, SEECTL);
7063     return (0);
7064   }
7065   return (1);
7066 }
7067
7068 /*+F*************************************************************************
7069  * Function:
7070  *   release_seeprom
7071  *
7072  * Description:
7073  *   Releases access to the memory port on PCI controllers.
7074  *-F*************************************************************************/
7075 static void
7076 release_seeprom(struct aic7xxx_host *p)
7077 {
7078   /*
7079    * Make sure the SEEPROM is ready before we release it.
7080    */
7081   CLOCK_PULSE(p);
7082   aic_outb(p, 0, SEECTL);
7083 }
7084
7085 /*+F*************************************************************************
7086  * Function:
7087  *   read_seeprom
7088  *
7089  * Description:
7090  *   Reads the serial EEPROM and returns 1 if successful and 0 if
7091  *   not successful.
7092  *
7093  *   The instruction set of the 93C46/56/66 chips is as follows:
7094  *
7095  *               Start  OP
7096  *     Function   Bit  Code  Address    Data     Description
7097  *     -------------------------------------------------------------------
7098  *     READ        1    10   A5 - A0             Reads data stored in memory,
7099  *                                               starting at specified address
7100  *     EWEN        1    00   11XXXX              Write enable must precede
7101  *                                               all programming modes
7102  *     ERASE       1    11   A5 - A0             Erase register A5A4A3A2A1A0
7103  *     WRITE       1    01   A5 - A0   D15 - D0  Writes register
7104  *     ERAL        1    00   10XXXX              Erase all registers
7105  *     WRAL        1    00   01XXXX    D15 - D0  Writes to all registers
7106  *     EWDS        1    00   00XXXX              Disables all programming
7107  *                                               instructions
7108  *     *Note: A value of X for address is a don't care condition.
7109  *     *Note: The 93C56 and 93C66 have 8 address bits.
7110  *
7111  *
7112  *   The 93C46 has a four wire interface: clock, chip select, data in, and
7113  *   data out.  In order to perform one of the above functions, you need
7114  *   to enable the chip select for a clock period (typically a minimum of
7115  *   1 usec, with the clock high and low a minimum of 750 and 250 nsec
7116  *   respectively.  While the chip select remains high, you can clock in
7117  *   the instructions (above) starting with the start bit, followed by the
7118  *   OP code, Address, and Data (if needed).  For the READ instruction, the
7119  *   requested 16-bit register contents is read from the data out line but
7120  *   is preceded by an initial zero (leading 0, followed by 16-bits, MSB
7121  *   first).  The clock cycling from low to high initiates the next data
7122  *   bit to be sent from the chip.
7123  *
7124  *   The 78xx interface to the 93C46 serial EEPROM is through the SEECTL
7125  *   register.  After successful arbitration for the memory port, the
7126  *   SEECS bit of the SEECTL register is connected to the chip select.
7127  *   The SEECK, SEEDO, and SEEDI are connected to the clock, data out,
7128  *   and data in lines respectively.  The SEERDY bit of SEECTL is useful
7129  *   in that it gives us an 800 nsec timer.  After a write to the SEECTL
7130  *   register, the SEERDY goes high 800 nsec later.  The one exception
7131  *   to this is when we first request access to the memory port.  The
7132  *   SEERDY goes high to signify that access has been granted and, for
7133  *   this case, has no implied timing.
7134  *-F*************************************************************************/
7135 static int
7136 read_seeprom(struct aic7xxx_host *p, int offset,
7137     unsigned short *scarray, unsigned int len, seeprom_chip_type chip)
7138 {
7139   int i = 0, k;
7140   unsigned char temp;
7141   unsigned short checksum = 0;
7142   struct seeprom_cmd {
7143     unsigned char len;
7144     unsigned char bits[3];
7145   };
7146   struct seeprom_cmd seeprom_read = {3, {1, 1, 0}};
7147
7148   /*
7149    * Request access of the memory port.
7150    */
7151   if (acquire_seeprom(p) == 0)
7152   {
7153     return (0);
7154   }
7155
7156   /*
7157    * Read 'len' registers of the seeprom.  For the 7870, the 93C46
7158    * SEEPROM is a 1024-bit device with 64 16-bit registers but only
7159    * the first 32 are used by Adaptec BIOS.  Some adapters use the
7160    * 93C56 SEEPROM which is a 2048-bit device.  The loop will range
7161    * from 0 to 'len' - 1.
7162    */
7163   for (k = 0; k < len; k++)
7164   {
7165     /*
7166      * Send chip select for one clock cycle.
7167      */
7168     aic_outb(p, SEEMS | SEECK | SEECS, SEECTL);
7169     CLOCK_PULSE(p);
7170
7171     /*
7172      * Now we're ready to send the read command followed by the
7173      * address of the 16-bit register we want to read.
7174      */
7175     for (i = 0; i < seeprom_read.len; i++)
7176     {
7177       temp = SEEMS | SEECS | (seeprom_read.bits[i] << 1);
7178       aic_outb(p, temp, SEECTL);
7179       CLOCK_PULSE(p);
7180       temp = temp ^ SEECK;
7181       aic_outb(p, temp, SEECTL);
7182       CLOCK_PULSE(p);
7183     }
7184     /*
7185      * Send the 6 or 8 bit address (MSB first, LSB last).
7186      */
7187     for (i = ((int) chip - 1); i >= 0; i--)
7188     {
7189       temp = k + offset;
7190       temp = (temp >> i) & 1;  /* Mask out all but lower bit. */
7191       temp = SEEMS | SEECS | (temp << 1);
7192       aic_outb(p, temp, SEECTL);
7193       CLOCK_PULSE(p);
7194       temp = temp ^ SEECK;
7195       aic_outb(p, temp, SEECTL);
7196       CLOCK_PULSE(p);
7197     }
7198
7199     /*
7200      * Now read the 16 bit register.  An initial 0 precedes the
7201      * register contents which begins with bit 15 (MSB) and ends
7202      * with bit 0 (LSB).  The initial 0 will be shifted off the
7203      * top of our word as we let the loop run from 0 to 16.
7204      */
7205     for (i = 0; i <= 16; i++)
7206     {
7207       temp = SEEMS | SEECS;
7208       aic_outb(p, temp, SEECTL);
7209       CLOCK_PULSE(p);
7210       temp = temp ^ SEECK;
7211       scarray[k] = (scarray[k] << 1) | (aic_inb(p, SEECTL) & SEEDI);
7212       aic_outb(p, temp, SEECTL);
7213       CLOCK_PULSE(p);
7214     }
7215
7216     /*
7217      * The serial EEPROM should have a checksum in the last word.
7218      * Keep a running checksum for all words read except for the
7219      * last word.  We'll verify the checksum after all words have
7220      * been read.
7221      */
7222     if (k < (len - 1))
7223     {
7224       checksum = checksum + scarray[k];
7225     }
7226
7227     /*
7228      * Reset the chip select for the next command cycle.
7229      */
7230     aic_outb(p, SEEMS, SEECTL);
7231     CLOCK_PULSE(p);
7232     aic_outb(p, SEEMS | SEECK, SEECTL);
7233     CLOCK_PULSE(p);
7234     aic_outb(p, SEEMS, SEECTL);
7235     CLOCK_PULSE(p);
7236   }
7237
7238   /*
7239    * Release access to the memory port and the serial EEPROM.
7240    */
7241   release_seeprom(p);
7242
7243 #if 0
7244   printk("Computed checksum 0x%x, checksum read 0x%x\n",
7245          checksum, scarray[len - 1]);
7246   printk("Serial EEPROM:");
7247   for (k = 0; k < len; k++)
7248   {
7249     if (((k % 8) == 0) && (k != 0))
7250     {
7251       printk("\n              ");
7252     }
7253     printk(" 0x%x", scarray[k]);
7254   }
7255   printk("\n");
7256 #endif
7257   if ( (checksum != scarray[len - 1]) || (checksum == 0) )
7258   {
7259     return (0);
7260   }
7261
7262   return (1);
7263 }
7264
7265 /*+F*************************************************************************
7266  * Function:
7267  *   read_brdctl
7268  *
7269  * Description:
7270  *   Reads the BRDCTL register.
7271  *-F*************************************************************************/
7272 static unsigned char
7273 read_brdctl(struct aic7xxx_host *p)
7274 {
7275   unsigned char brdctl, value;
7276
7277   /*
7278    * Make sure the SEEPROM is ready before we access it
7279    */
7280   CLOCK_PULSE(p);
7281   if (p->features & AHC_ULTRA2)
7282   {
7283     brdctl = BRDRW_ULTRA2;
7284     aic_outb(p, brdctl, BRDCTL);
7285     CLOCK_PULSE(p);
7286     value = aic_inb(p, BRDCTL);
7287     CLOCK_PULSE(p);
7288     return(value);
7289   }
7290   brdctl = BRDRW;
7291   if ( !((p->chip & AHC_CHIPID_MASK) == AHC_AIC7895) ||
7292         (p->flags & AHC_CHNLB) )
7293   {
7294     brdctl |= BRDCS;
7295   }
7296   aic_outb(p, brdctl, BRDCTL);
7297   CLOCK_PULSE(p);
7298   value = aic_inb(p, BRDCTL);
7299   CLOCK_PULSE(p);
7300   aic_outb(p, 0, BRDCTL);
7301   CLOCK_PULSE(p);
7302   return (value);
7303 }
7304
7305 /*+F*************************************************************************
7306  * Function:
7307  *   write_brdctl
7308  *
7309  * Description:
7310  *   Writes a value to the BRDCTL register.
7311  *-F*************************************************************************/
7312 static void
7313 write_brdctl(struct aic7xxx_host *p, unsigned char value)
7314 {
7315   unsigned char brdctl;
7316
7317   /*
7318    * Make sure the SEEPROM is ready before we access it
7319    */
7320   CLOCK_PULSE(p);
7321   if (p->features & AHC_ULTRA2)
7322   {
7323     brdctl = value;
7324     aic_outb(p, brdctl, BRDCTL);
7325     CLOCK_PULSE(p);
7326     brdctl |= BRDSTB_ULTRA2;
7327     aic_outb(p, brdctl, BRDCTL);
7328     CLOCK_PULSE(p);
7329     brdctl &= ~BRDSTB_ULTRA2;
7330     aic_outb(p, brdctl, BRDCTL);
7331     CLOCK_PULSE(p);
7332     read_brdctl(p);
7333     CLOCK_PULSE(p);
7334   }
7335   else
7336   {
7337     brdctl = BRDSTB;
7338     if ( !((p->chip & AHC_CHIPID_MASK) == AHC_AIC7895) ||
7339           (p->flags & AHC_CHNLB) )
7340     {
7341       brdctl |= BRDCS;
7342     }
7343     brdctl = BRDSTB | BRDCS;
7344     aic_outb(p, brdctl, BRDCTL);
7345     CLOCK_PULSE(p);
7346     brdctl |= value;
7347     aic_outb(p, brdctl, BRDCTL);
7348     CLOCK_PULSE(p);
7349     brdctl &= ~BRDSTB;
7350     aic_outb(p, brdctl, BRDCTL);
7351     CLOCK_PULSE(p);
7352     brdctl &= ~BRDCS;
7353     aic_outb(p, brdctl, BRDCTL);
7354     CLOCK_PULSE(p);
7355   }
7356 }
7357
7358 /*+F*************************************************************************
7359  * Function:
7360  *   aic785x_cable_detect
7361  *
7362  * Description:
7363  *   Detect the cables that are present on aic785x class controller chips
7364  *-F*************************************************************************/
7365 static void
7366 aic785x_cable_detect(struct aic7xxx_host *p, int *int_50,
7367     int *ext_present, int *eeprom)
7368 {
7369   unsigned char brdctl;
7370
7371   aic_outb(p, BRDRW | BRDCS, BRDCTL);
7372   CLOCK_PULSE(p);
7373   aic_outb(p, 0, BRDCTL);
7374   CLOCK_PULSE(p);
7375   brdctl = aic_inb(p, BRDCTL);
7376   CLOCK_PULSE(p);
7377   *int_50 = !(brdctl & BRDDAT5);
7378   *ext_present = !(brdctl & BRDDAT6);
7379   *eeprom = (aic_inb(p, SPIOCAP) & EEPROM);
7380 }
7381
7382 #undef CLOCK_PULSE
7383
7384 /*+F*************************************************************************
7385  * Function:
7386  *   aic2940_uwpro_cable_detect
7387  *
7388  * Description:
7389  *   Detect the cables that are present on the 2940-UWPro cards
7390  *
7391  * NOTE: This function assumes the SEEPROM will have already been acquired
7392  *       prior to invocation of this function.
7393  *-F*************************************************************************/
7394 static void
7395 aic2940_uwpro_wide_cable_detect(struct aic7xxx_host *p, int *int_68,
7396     int *ext_68, int *eeprom)
7397 {
7398   unsigned char brdctl;
7399
7400   /*
7401    * First read the status of our cables.  Set the rom bank to
7402    * 0 since the bank setting serves as a multiplexor for the
7403    * cable detection logic.  BRDDAT5 controls the bank switch.
7404    */
7405   write_brdctl(p, 0);
7406
7407   /*
7408    * Now we read the state of the internal 68 connector.  BRDDAT6
7409    * is don't care, BRDDAT7 is internal 68.  The cable is
7410    * present if the bit is 0
7411    */
7412   brdctl = read_brdctl(p);
7413   *int_68 = !(brdctl & BRDDAT7);
7414
7415   /*
7416    * Set the bank bit in brdctl and then read the external cable state
7417    * and the EEPROM status
7418    */
7419   write_brdctl(p, BRDDAT5);
7420   brdctl = read_brdctl(p);
7421
7422   *ext_68 = !(brdctl & BRDDAT6);
7423   *eeprom = !(brdctl & BRDDAT7);
7424
7425   /*
7426    * We're done, the calling function will release the SEEPROM for us
7427    */
7428 }
7429
7430 /*+F*************************************************************************
7431  * Function:
7432  *   aic787x_cable_detect
7433  *
7434  * Description:
7435  *   Detect the cables that are present on aic787x class controller chips
7436  *
7437  * NOTE: This function assumes the SEEPROM will have already been acquired
7438  *       prior to invocation of this function.
7439  *-F*************************************************************************/
7440 static void
7441 aic787x_cable_detect(struct aic7xxx_host *p, int *int_50, int *int_68,
7442     int *ext_present, int *eeprom)
7443 {
7444   unsigned char brdctl;
7445
7446   /*
7447    * First read the status of our cables.  Set the rom bank to
7448    * 0 since the bank setting serves as a multiplexor for the
7449    * cable detection logic.  BRDDAT5 controls the bank switch.
7450    */
7451   write_brdctl(p, 0);
7452
7453   /*
7454    * Now we read the state of the two internal connectors.  BRDDAT6
7455    * is internal 50, BRDDAT7 is internal 68.  For each, the cable is
7456    * present if the bit is 0
7457    */
7458   brdctl = read_brdctl(p);
7459   *int_50 = !(brdctl & BRDDAT6);
7460   *int_68 = !(brdctl & BRDDAT7);
7461
7462   /*
7463    * Set the bank bit in brdctl and then read the external cable state
7464    * and the EEPROM status
7465    */
7466   write_brdctl(p, BRDDAT5);
7467   brdctl = read_brdctl(p);
7468
7469   *ext_present = !(brdctl & BRDDAT6);
7470   *eeprom = !(brdctl & BRDDAT7);
7471
7472   /*
7473    * We're done, the calling function will release the SEEPROM for us
7474    */
7475 }
7476
7477 /*+F*************************************************************************
7478  * Function:
7479  *   aic787x_ultra2_term_detect
7480  *
7481  * Description:
7482  *   Detect the termination settings present on ultra2 class controllers
7483  *
7484  * NOTE: This function assumes the SEEPROM will have already been acquired
7485  *       prior to invocation of this function.
7486  *-F*************************************************************************/
7487 static void
7488 aic7xxx_ultra2_term_detect(struct aic7xxx_host *p, int *enableSE_low,
7489                            int *enableSE_high, int *enableLVD_low,
7490                            int *enableLVD_high, int *eprom_present)
7491 {
7492   unsigned char brdctl;
7493
7494   brdctl = read_brdctl(p);
7495
7496   *eprom_present  = (brdctl & BRDDAT7);
7497   *enableSE_high  = (brdctl & BRDDAT6);
7498   *enableSE_low   = (brdctl & BRDDAT5);
7499   *enableLVD_high = (brdctl & BRDDAT4);
7500   *enableLVD_low  = (brdctl & BRDDAT3);
7501 }
7502
7503 /*+F*************************************************************************
7504  * Function:
7505  *   configure_termination
7506  *
7507  * Description:
7508  *   Configures the termination settings on PCI adapters that have
7509  *   SEEPROMs available.
7510  *-F*************************************************************************/
7511 static void
7512 configure_termination(struct aic7xxx_host *p)
7513 {
7514   int internal50_present = 0;
7515   int internal68_present = 0;
7516   int external_present = 0;
7517   int eprom_present = 0;
7518   int enableSE_low = 0;
7519   int enableSE_high = 0;
7520   int enableLVD_low = 0;
7521   int enableLVD_high = 0;
7522   unsigned char brddat = 0;
7523   unsigned char max_target = 0;
7524   unsigned char sxfrctl1 = aic_inb(p, SXFRCTL1);
7525
7526   if (acquire_seeprom(p))
7527   {
7528     if (p->features & (AHC_WIDE|AHC_TWIN))
7529       max_target = 16;
7530     else
7531       max_target = 8;
7532     aic_outb(p, SEEMS | SEECS, SEECTL);
7533     sxfrctl1 &= ~STPWEN;
7534     /*
7535      * The termination/cable detection logic is split into three distinct
7536      * groups.  Ultra2 and later controllers, 2940UW-Pro controllers, and
7537      * older 7850, 7860, 7870, 7880, and 7895 controllers.  Each has its
7538      * own unique way of detecting their cables and writing the results
7539      * back to the card.
7540      */
7541     if (p->features & AHC_ULTRA2)
7542     {
7543       /*
7544        * As long as user hasn't overridden term settings, always check the
7545        * cable detection logic
7546        */
7547       if (aic7xxx_override_term == -1)
7548       {
7549         aic7xxx_ultra2_term_detect(p, &enableSE_low, &enableSE_high,
7550                                    &enableLVD_low, &enableLVD_high,
7551                                    &eprom_present);
7552       }
7553
7554       /*
7555        * If the user is overriding settings, then they have been preserved
7556        * to here as fake adapter_control entries.  Parse them and allow
7557        * them to override the detected settings (if we even did detection).
7558        */
7559       if (!(p->adapter_control & CFSEAUTOTERM))
7560       {
7561         enableSE_low = (p->adapter_control & CFSTERM);
7562         enableSE_high = (p->adapter_control & CFWSTERM);
7563       }
7564       if (!(p->adapter_control & CFAUTOTERM))
7565       {
7566         enableLVD_low = enableLVD_high = (p->adapter_control & CFLVDSTERM);
7567       }
7568
7569       /*
7570        * Now take those settings that we have and translate them into the
7571        * values that must be written into the registers.
7572        *
7573        * Flash Enable = BRDDAT7
7574        * Secondary High Term Enable = BRDDAT6
7575        * Secondary Low Term Enable = BRDDAT5
7576        * LVD/Primary High Term Enable = BRDDAT4
7577        * LVD/Primary Low Term Enable = STPWEN bit in SXFRCTL1
7578        */
7579       if (enableLVD_low != 0)
7580       {
7581         sxfrctl1 |= STPWEN;
7582         p->flags |= AHC_TERM_ENB_LVD;
7583         if (aic7xxx_verbose & VERBOSE_PROBE2)
7584           printk(KERN_INFO "(scsi%d) LVD/Primary Low byte termination "
7585                  "Enabled\n", p->host_no);
7586       }
7587
7588       if (enableLVD_high != 0)
7589       {
7590         brddat |= BRDDAT4;
7591         if (aic7xxx_verbose & VERBOSE_PROBE2)
7592           printk(KERN_INFO "(scsi%d) LVD/Primary High byte termination "
7593                  "Enabled\n", p->host_no);
7594       }
7595
7596       if (enableSE_low != 0)
7597       {
7598         brddat |= BRDDAT5;
7599         if (aic7xxx_verbose & VERBOSE_PROBE2)
7600           printk(KERN_INFO "(scsi%d) Secondary Low byte termination "
7601                  "Enabled\n", p->host_no);
7602       }
7603
7604       if (enableSE_high != 0)
7605       {
7606         brddat |= BRDDAT6;
7607         if (aic7xxx_verbose & VERBOSE_PROBE2)
7608           printk(KERN_INFO "(scsi%d) Secondary High byte termination "
7609                  "Enabled\n", p->host_no);
7610       }
7611     }
7612     else if (p->features & AHC_NEW_AUTOTERM)
7613     {
7614       /*
7615        * The 50 pin connector termination is controlled by STPWEN in the
7616        * SXFRCTL1 register.  Since the Adaptec docs typically say the
7617        * controller is not allowed to be in the middle of a cable and
7618        * this is the only connection on that stub of the bus, there is
7619        * no need to even check for narrow termination, it's simply
7620        * always on.
7621        */
7622       sxfrctl1 |= STPWEN;
7623       if (aic7xxx_verbose & VERBOSE_PROBE2)
7624         printk(KERN_INFO "(scsi%d) Narrow channel termination Enabled\n",
7625                p->host_no);
7626
7627       if (p->adapter_control & CFAUTOTERM)
7628       {
7629         aic2940_uwpro_wide_cable_detect(p, &internal68_present,
7630                                         &external_present,
7631                                         &eprom_present);
7632         printk(KERN_INFO "(scsi%d) Cables present (Int-50 %s, Int-68 %s, "
7633                "Ext-68 %s)\n", p->host_no,
7634                "Don't Care",
7635                internal68_present ? "YES" : "NO",
7636                external_present ? "YES" : "NO");
7637         if (aic7xxx_verbose & VERBOSE_PROBE2)
7638           printk(KERN_INFO "(scsi%d) EEPROM %s present.\n", p->host_no,
7639                eprom_present ? "is" : "is not");
7640         if (internal68_present && external_present)
7641         {
7642           brddat = 0;
7643           p->flags &= ~AHC_TERM_ENB_SE_HIGH;
7644           if (aic7xxx_verbose & VERBOSE_PROBE2)
7645             printk(KERN_INFO "(scsi%d) Wide channel termination Disabled\n",
7646                    p->host_no);
7647         }
7648         else
7649         {
7650           brddat = BRDDAT6;
7651           p->flags |= AHC_TERM_ENB_SE_HIGH;
7652           if (aic7xxx_verbose & VERBOSE_PROBE2)
7653             printk(KERN_INFO "(scsi%d) Wide channel termination Enabled\n",
7654                    p->host_no);
7655         }
7656       }
7657       else
7658       {
7659         /*
7660          * The termination of the Wide channel is done more like normal
7661          * though, and the setting of this termination is done by writing
7662          * either a 0 or 1 to BRDDAT6 of the BRDDAT register
7663          */
7664         if (p->adapter_control & CFWSTERM)
7665         {
7666           brddat = BRDDAT6;
7667           p->flags |= AHC_TERM_ENB_SE_HIGH;
7668           if (aic7xxx_verbose & VERBOSE_PROBE2)
7669             printk(KERN_INFO "(scsi%d) Wide channel termination Enabled\n",
7670                    p->host_no);
7671         }
7672         else
7673         {
7674           brddat = 0;
7675         }
7676       }
7677     }
7678     else
7679     {
7680       if (p->adapter_control & CFAUTOTERM)
7681       {
7682         if (p->flags & AHC_MOTHERBOARD)
7683         {
7684           printk(KERN_INFO "(scsi%d) Warning - detected auto-termination\n",
7685                  p->host_no);
7686           printk(KERN_INFO "(scsi%d) Please verify driver detected settings "
7687             "are correct.\n", p->host_no);
7688           printk(KERN_INFO "(scsi%d) If not, then please properly set the "
7689             "device termination\n", p->host_no);
7690           printk(KERN_INFO "(scsi%d) in the Adaptec SCSI BIOS by hitting "
7691             "CTRL-A when prompted\n", p->host_no);
7692           printk(KERN_INFO "(scsi%d) during machine bootup.\n", p->host_no);
7693         }
7694         /* Configure auto termination. */
7695
7696         if ( (p->chip & AHC_CHIPID_MASK) >= AHC_AIC7870 )
7697         {
7698           aic787x_cable_detect(p, &internal50_present, &internal68_present,
7699             &external_present, &eprom_present);
7700         }
7701         else
7702         {
7703           aic785x_cable_detect(p, &internal50_present, &external_present,
7704             &eprom_present);
7705         }
7706
7707         if (max_target <= 8)
7708           internal68_present = 0;
7709
7710         if (max_target > 8)
7711         {
7712           printk(KERN_INFO "(scsi%d) Cables present (Int-50 %s, Int-68 %s, "
7713                  "Ext-68 %s)\n", p->host_no,
7714                  internal50_present ? "YES" : "NO",
7715                  internal68_present ? "YES" : "NO",
7716                  external_present ? "YES" : "NO");
7717         }
7718         else
7719         {
7720           printk(KERN_INFO "(scsi%d) Cables present (Int-50 %s, Ext-50 %s)\n",
7721                  p->host_no,
7722                  internal50_present ? "YES" : "NO",
7723                  external_present ? "YES" : "NO");
7724         }
7725         if (aic7xxx_verbose & VERBOSE_PROBE2)
7726           printk(KERN_INFO "(scsi%d) EEPROM %s present.\n", p->host_no,
7727                eprom_present ? "is" : "is not");
7728
7729         /*
7730          * Now set the termination based on what we found.  BRDDAT6
7731          * controls wide termination enable.
7732          * Flash Enable = BRDDAT7
7733          * SE High Term Enable = BRDDAT6
7734          */
7735         if (internal50_present && internal68_present && external_present)
7736         {
7737           printk(KERN_INFO "(scsi%d) Illegal cable configuration!!  Only two\n",
7738                  p->host_no);
7739           printk(KERN_INFO "(scsi%d) connectors on the SCSI controller may be "
7740                  "in use at a time!\n", p->host_no);
7741           /*
7742            * Force termination (low and high byte) on.  This is safer than
7743            * leaving it completely off, especially since this message comes
7744            * most often from motherboard controllers that don't even have 3
7745            * connectors, but instead are failing the cable detection.
7746            */
7747           internal50_present = external_present = 0;
7748           enableSE_high = enableSE_low = 1;
7749         }
7750
7751         if ((max_target > 8) &&
7752             ((external_present == 0) || (internal68_present == 0)) )
7753         {
7754           brddat |= BRDDAT6;
7755           p->flags |= AHC_TERM_ENB_SE_HIGH;
7756           if (aic7xxx_verbose & VERBOSE_PROBE2)
7757             printk(KERN_INFO "(scsi%d) SE High byte termination Enabled\n",
7758                    p->host_no);
7759         }
7760
7761         if ( ((internal50_present ? 1 : 0) +
7762               (internal68_present ? 1 : 0) +
7763               (external_present   ? 1 : 0)) <= 1 )
7764         {
7765           sxfrctl1 |= STPWEN;
7766           p->flags |= AHC_TERM_ENB_SE_LOW;
7767           if (aic7xxx_verbose & VERBOSE_PROBE2)
7768             printk(KERN_INFO "(scsi%d) SE Low byte termination Enabled\n",
7769                    p->host_no);
7770         }
7771       }
7772       else /* p->adapter_control & CFAUTOTERM */
7773       {
7774         if (p->adapter_control & CFSTERM)
7775         {
7776           sxfrctl1 |= STPWEN;
7777           if (aic7xxx_verbose & VERBOSE_PROBE2)
7778             printk(KERN_INFO "(scsi%d) SE Low byte termination Enabled\n",
7779                    p->host_no);
7780         }
7781
7782         if (p->adapter_control & CFWSTERM)
7783         {
7784           brddat |= BRDDAT6;
7785           if (aic7xxx_verbose & VERBOSE_PROBE2)
7786             printk(KERN_INFO "(scsi%d) SE High byte termination Enabled\n",
7787                    p->host_no);
7788         }
7789       }
7790     }
7791
7792     aic_outb(p, sxfrctl1, SXFRCTL1);
7793     write_brdctl(p, brddat);
7794     release_seeprom(p);
7795   }
7796 }
7797
7798 /*+F*************************************************************************
7799  * Function:
7800  *   detect_maxscb
7801  *
7802  * Description:
7803  *   Detects the maximum number of SCBs for the controller and returns
7804  *   the count and a mask in p (p->maxscbs, p->qcntmask).
7805  *-F*************************************************************************/
7806 static void
7807 detect_maxscb(struct aic7xxx_host *p)
7808 {
7809   int i;
7810
7811   /*
7812    * It's possible that we've already done this for multichannel
7813    * adapters.
7814    */
7815   if (p->scb_data->maxhscbs == 0)
7816   {
7817     /*
7818      * We haven't initialized the SCB settings yet.  Walk the SCBs to
7819      * determince how many there are.
7820      */
7821     aic_outb(p, 0, FREE_SCBH);
7822
7823     for (i = 0; i < AIC7XXX_MAXSCB; i++)
7824     {
7825       aic_outb(p, i, SCBPTR);
7826       aic_outb(p, i, SCB_CONTROL);
7827       if (aic_inb(p, SCB_CONTROL) != i)
7828         break;
7829       aic_outb(p, 0, SCBPTR);
7830       if (aic_inb(p, SCB_CONTROL) != 0)
7831         break;
7832
7833       aic_outb(p, i, SCBPTR);
7834       aic_outb(p, 0, SCB_CONTROL);   /* Clear the control byte. */
7835       aic_outb(p, i + 1, SCB_NEXT);  /* Set the next pointer. */
7836       aic_outb(p, SCB_LIST_NULL, SCB_TAG);  /* Make the tag invalid. */
7837       aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS);  /* no busy untagged */
7838       aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS+1);/* targets active yet */
7839       aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS+2);
7840       aic_outb(p, SCB_LIST_NULL, SCB_BUSYTARGETS+3);
7841     }
7842
7843     /* Make sure the last SCB terminates the free list. */
7844     aic_outb(p, i - 1, SCBPTR);
7845     aic_outb(p, SCB_LIST_NULL, SCB_NEXT);
7846
7847     /* Ensure we clear the first (0) SCBs control byte. */
7848     aic_outb(p, 0, SCBPTR);
7849     aic_outb(p, 0, SCB_CONTROL);
7850
7851     p->scb_data->maxhscbs = i;
7852     /*
7853      * Use direct indexing instead for speed
7854      */
7855     if ( i == AIC7XXX_MAXSCB )
7856       p->flags &= ~AHC_PAGESCBS;
7857   }
7858
7859 }
7860
7861 /*+F*************************************************************************
7862  * Function:
7863  *   aic7xxx_register
7864  *
7865  * Description:
7866  *   Register a Adaptec aic7xxx chip SCSI controller with the kernel.
7867  *-F*************************************************************************/
7868 static int
7869 aic7xxx_register(Scsi_Host_Template *template, struct aic7xxx_host *p,
7870   int reset_delay)
7871 {
7872   int i, result;
7873   int max_targets;
7874   int found = 1;
7875   unsigned char term, scsi_conf;
7876   struct Scsi_Host *host;
7877
7878   host = p->host;
7879
7880   p->scb_data->maxscbs = AIC7XXX_MAXSCB;
7881   host->can_queue = AIC7XXX_MAXSCB;
7882   host->cmd_per_lun = 3;
7883   host->sg_tablesize = AIC7XXX_MAX_SG;
7884   host->this_id = p->scsi_id;
7885   host->io_port = p->base;
7886   host->n_io_port = 0xFF;
7887   host->base = p->mbase;
7888   host->irq = p->irq;
7889   if (p->features & AHC_WIDE)
7890   {
7891     host->max_id = 16;
7892   }
7893   if (p->features & AHC_TWIN)
7894   {
7895     host->max_channel = 1;
7896   }
7897
7898   p->host = host;
7899   p->host_no = host->host_no;
7900   host->unique_id = p->instance;
7901   p->isr_count = 0;
7902   p->next = NULL;
7903   p->completeq.head = NULL;
7904   p->completeq.tail = NULL;
7905   scbq_init(&p->scb_data->free_scbs);
7906   scbq_init(&p->waiting_scbs);
7907   INIT_LIST_HEAD(&p->aic_devs);
7908
7909   /*
7910    * We currently have no commands of any type
7911    */
7912   p->qinfifonext = 0;
7913   p->qoutfifonext = 0;
7914
7915   printk(KERN_INFO "(scsi%d) <%s> found at ", p->host_no,
7916     board_names[p->board_name_index]);
7917   switch(p->chip)
7918   {
7919     case (AHC_AIC7770|AHC_EISA):
7920       printk("EISA slot %d\n", p->pci_device_fn);
7921       break;
7922     case (AHC_AIC7770|AHC_VL):
7923       printk("VLB slot %d\n", p->pci_device_fn);
7924       break;
7925     default:
7926       printk("PCI %d/%d/%d\n", p->pci_bus, PCI_SLOT(p->pci_device_fn),
7927         PCI_FUNC(p->pci_device_fn));
7928       break;
7929   }
7930   if (p->features & AHC_TWIN)
7931   {
7932     printk(KERN_INFO "(scsi%d) Twin Channel, A SCSI ID %d, B SCSI ID %d, ",
7933            p->host_no, p->scsi_id, p->scsi_id_b);
7934   }
7935   else
7936   {
7937     char *channel;
7938
7939     channel = "";
7940
7941     if ((p->flags & AHC_MULTI_CHANNEL) != 0)
7942     {
7943       channel = " A";
7944
7945       if ( (p->flags & (AHC_CHNLB|AHC_CHNLC)) != 0 )
7946       {
7947         channel = (p->flags & AHC_CHNLB) ? " B" : " C";
7948       }
7949     }
7950     if (p->features & AHC_WIDE)
7951     {
7952       printk(KERN_INFO "(scsi%d) Wide ", p->host_no);
7953     }
7954     else
7955     {
7956       printk(KERN_INFO "(scsi%d) Narrow ", p->host_no);
7957     }
7958     printk("Channel%s, SCSI ID=%d, ", channel, p->scsi_id);
7959   }
7960   aic_outb(p, 0, SEQ_FLAGS);
7961
7962   detect_maxscb(p);
7963
7964   printk("%d/%d SCBs\n", p->scb_data->maxhscbs, p->scb_data->maxscbs);
7965   if (aic7xxx_verbose & VERBOSE_PROBE2)
7966   {
7967     printk(KERN_INFO "(scsi%d) BIOS %sabled, IO Port 0x%lx, IRQ %d\n",
7968       p->host_no, (p->flags & AHC_BIOS_ENABLED) ? "en" : "dis",
7969       p->base, p->irq);
7970     printk(KERN_INFO "(scsi%d) IO Memory at 0x%lx, MMAP Memory at 0x%lx\n",
7971       p->host_no, p->mbase, (unsigned long)p->maddr);
7972   }
7973
7974 #ifdef CONFIG_PCI
7975   /*
7976    * Now that we know our instance number, we can set the flags we need to
7977    * force termination if need be.
7978    */
7979   if (aic7xxx_stpwlev != -1)
7980   {
7981     /*
7982      * This option only applies to PCI controllers.
7983      */
7984     if ( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI)
7985     {
7986       unsigned char devconfig;
7987
7988       pci_read_config_byte(p->pdev, DEVCONFIG, &devconfig);
7989       if ( (aic7xxx_stpwlev >> p->instance) & 0x01 )
7990       {
7991         devconfig |= STPWLEVEL;
7992         if (aic7xxx_verbose & VERBOSE_PROBE2)
7993           printk("(scsi%d) Force setting STPWLEVEL bit\n", p->host_no);
7994       }
7995       else
7996       {
7997         devconfig &= ~STPWLEVEL;
7998         if (aic7xxx_verbose & VERBOSE_PROBE2)
7999           printk("(scsi%d) Force clearing STPWLEVEL bit\n", p->host_no);
8000       }
8001       pci_write_config_byte(p->pdev, DEVCONFIG, devconfig);
8002     }
8003   }
8004 #endif
8005
8006   /*
8007    * That took care of devconfig and stpwlev, now for the actual termination
8008    * settings.
8009    */
8010   if (aic7xxx_override_term != -1)
8011   {
8012     /*
8013      * Again, this only applies to PCI controllers.  We don't have problems
8014      * with the termination on 274x controllers to the best of my knowledge.
8015      */
8016     if ( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI)
8017     {
8018       unsigned char term_override;
8019
8020       term_override = ( (aic7xxx_override_term >> (p->instance * 4)) & 0x0f);
8021       p->adapter_control &=
8022         ~(CFSTERM|CFWSTERM|CFLVDSTERM|CFAUTOTERM|CFSEAUTOTERM);
8023       if ( (p->features & AHC_ULTRA2) && (term_override & 0x0c) )
8024       {
8025         p->adapter_control |= CFLVDSTERM;
8026       }
8027       if (term_override & 0x02)
8028       {
8029         p->adapter_control |= CFWSTERM;
8030       }
8031       if (term_override & 0x01)
8032       {
8033         p->adapter_control |= CFSTERM;
8034       }
8035     }
8036   }
8037
8038   if ( (p->flags & AHC_SEEPROM_FOUND) || (aic7xxx_override_term != -1) )
8039   {
8040     if (p->features & AHC_SPIOCAP)
8041     {
8042       if ( aic_inb(p, SPIOCAP) & SSPIOCPS )
8043       /*
8044        * Update the settings in sxfrctl1 to match the termination
8045        * settings.
8046        */
8047         configure_termination(p);
8048     }
8049     else if ((p->chip & AHC_CHIPID_MASK) >= AHC_AIC7870)
8050     {
8051       configure_termination(p);
8052     }
8053   }
8054
8055   /*
8056    * Set the SCSI Id, SXFRCTL0, SXFRCTL1, and SIMODE1, for both channels
8057    */
8058   if (p->features & AHC_TWIN)
8059   {
8060     /* Select channel B */
8061     aic_outb(p, aic_inb(p, SBLKCTL) | SELBUSB, SBLKCTL);
8062
8063     if ((p->flags & AHC_SEEPROM_FOUND) || (aic7xxx_override_term != -1))
8064       term = (aic_inb(p, SXFRCTL1) & STPWEN);
8065     else
8066       term = ((p->flags & AHC_TERM_ENB_B) ? STPWEN : 0);
8067
8068     aic_outb(p, p->scsi_id_b, SCSIID);
8069     scsi_conf = aic_inb(p, SCSICONF + 1);
8070     aic_outb(p, DFON | SPIOEN, SXFRCTL0);
8071     aic_outb(p, (scsi_conf & ENSPCHK) | aic7xxx_seltime | term |
8072          ENSTIMER | ACTNEGEN, SXFRCTL1);
8073     aic_outb(p, 0, SIMODE0);
8074     aic_outb(p, ENSELTIMO | ENSCSIRST | ENSCSIPERR, SIMODE1);
8075     aic_outb(p, 0, SCSIRATE);
8076
8077     /* Select channel A */
8078     aic_outb(p, aic_inb(p, SBLKCTL) & ~SELBUSB, SBLKCTL);
8079   }
8080
8081   if (p->features & AHC_ULTRA2)
8082   {
8083     aic_outb(p, p->scsi_id, SCSIID_ULTRA2);
8084   }
8085   else
8086   {
8087     aic_outb(p, p->scsi_id, SCSIID);
8088   }
8089   if ((p->flags & AHC_SEEPROM_FOUND) || (aic7xxx_override_term != -1))
8090     term = (aic_inb(p, SXFRCTL1) & STPWEN);
8091   else
8092     term = ((p->flags & (AHC_TERM_ENB_A|AHC_TERM_ENB_LVD)) ? STPWEN : 0);
8093   scsi_conf = aic_inb(p, SCSICONF);
8094   aic_outb(p, DFON | SPIOEN, SXFRCTL0);
8095   aic_outb(p, (scsi_conf & ENSPCHK) | aic7xxx_seltime | term |
8096        ENSTIMER | ACTNEGEN, SXFRCTL1);
8097   aic_outb(p, 0, SIMODE0);
8098   /*
8099    * If we are a cardbus adapter then don't enable SCSI reset detection.
8100    * We shouldn't likely be sharing SCSI busses with someone else, and
8101    * if we don't have a cable currently plugged into the controller then
8102    * we won't have a power source for the SCSI termination, which means
8103    * we'll see infinite incoming bus resets.
8104    */
8105   if(p->flags & AHC_NO_STPWEN)
8106     aic_outb(p, ENSELTIMO | ENSCSIPERR, SIMODE1);
8107   else
8108     aic_outb(p, ENSELTIMO | ENSCSIRST | ENSCSIPERR, SIMODE1);
8109   aic_outb(p, 0, SCSIRATE);
8110   if ( p->features & AHC_ULTRA2)
8111     aic_outb(p, 0, SCSIOFFSET);
8112
8113   /*
8114    * Look at the information that board initialization or the board
8115    * BIOS has left us. In the lower four bits of each target's
8116    * scratch space any value other than 0 indicates that we should
8117    * initiate synchronous transfers. If it's zero, the user or the
8118    * BIOS has decided to disable synchronous negotiation to that
8119    * target so we don't activate the needsdtr flag.
8120    */
8121   if ((p->features & (AHC_TWIN|AHC_WIDE)) == 0)
8122   {
8123     max_targets = 8;
8124   }
8125   else
8126   {
8127     max_targets = 16;
8128   }
8129
8130   if (!(aic7xxx_no_reset))
8131   {
8132     /*
8133      * If we reset the bus, then clear the transfer settings, else leave
8134      * them be.
8135      */
8136     aic_outb(p, 0, ULTRA_ENB);
8137     aic_outb(p, 0, ULTRA_ENB + 1);
8138     p->ultraenb = 0;
8139   }
8140
8141   /*
8142    * Allocate enough hardware scbs to handle the maximum number of
8143    * concurrent transactions we can have.  We have to make sure that
8144    * the allocated memory is contiguous memory.  The Linux kmalloc
8145    * routine should only allocate contiguous memory, but note that
8146    * this could be a problem if kmalloc() is changed.
8147    */
8148   {
8149     size_t array_size;
8150     unsigned int hscb_physaddr;
8151
8152     array_size = p->scb_data->maxscbs * sizeof(struct aic7xxx_hwscb);
8153     if (p->scb_data->hscbs == NULL)
8154     {
8155       /* pci_alloc_consistent enforces the alignment already and
8156        * clears the area as well.
8157        */
8158       p->scb_data->hscbs = pci_alloc_consistent(p->pdev, array_size,
8159                                                 &p->scb_data->hscbs_dma);
8160       /* We have to use pci_free_consistent, not kfree */
8161       p->scb_data->hscb_kmalloc_ptr = NULL;
8162       p->scb_data->hscbs_dma_len = array_size;
8163     }
8164     if (p->scb_data->hscbs == NULL)
8165     {
8166       printk("(scsi%d) Unable to allocate hardware SCB array; "
8167              "failing detection.\n", p->host_no);
8168       aic_outb(p, 0, SIMODE1);
8169       p->irq = 0;
8170       return(0);
8171     }
8172
8173     hscb_physaddr = p->scb_data->hscbs_dma;
8174     aic_outb(p, hscb_physaddr & 0xFF, HSCB_ADDR);
8175     aic_outb(p, (hscb_physaddr >> 8) & 0xFF, HSCB_ADDR + 1);
8176     aic_outb(p, (hscb_physaddr >> 16) & 0xFF, HSCB_ADDR + 2);
8177     aic_outb(p, (hscb_physaddr >> 24) & 0xFF, HSCB_ADDR + 3);
8178
8179     /* Set up the fifo areas at the same time */
8180     p->untagged_scbs = pci_alloc_consistent(p->pdev, 3*256, &p->fifo_dma);
8181     if (p->untagged_scbs == NULL)
8182     {
8183       printk("(scsi%d) Unable to allocate hardware FIFO arrays; "
8184              "failing detection.\n", p->host_no);
8185       p->irq = 0;
8186       return(0);
8187     }
8188
8189     p->qoutfifo = p->untagged_scbs + 256;
8190     p->qinfifo = p->qoutfifo + 256;
8191     for (i = 0; i < 256; i++)
8192     {
8193       p->untagged_scbs[i] = SCB_LIST_NULL;
8194       p->qinfifo[i] = SCB_LIST_NULL;
8195       p->qoutfifo[i] = SCB_LIST_NULL;
8196     }
8197
8198     hscb_physaddr = p->fifo_dma;
8199     aic_outb(p, hscb_physaddr & 0xFF, SCBID_ADDR);
8200     aic_outb(p, (hscb_physaddr >> 8) & 0xFF, SCBID_ADDR + 1);
8201     aic_outb(p, (hscb_physaddr >> 16) & 0xFF, SCBID_ADDR + 2);
8202     aic_outb(p, (hscb_physaddr >> 24) & 0xFF, SCBID_ADDR + 3);
8203   }
8204
8205   /* The Q-FIFOs we just set up are all empty */
8206   aic_outb(p, 0, QINPOS);
8207   aic_outb(p, 0, KERNEL_QINPOS);
8208   aic_outb(p, 0, QOUTPOS);
8209
8210   if(p->features & AHC_QUEUE_REGS)
8211   {
8212     aic_outb(p, SCB_QSIZE_256, QOFF_CTLSTA);
8213     aic_outb(p, 0, SDSCB_QOFF);
8214     aic_outb(p, 0, SNSCB_QOFF);
8215     aic_outb(p, 0, HNSCB_QOFF);
8216   }
8217
8218   /*
8219    * We don't have any waiting selections or disconnected SCBs.
8220    */
8221   aic_outb(p, SCB_LIST_NULL, WAITING_SCBH);
8222   aic_outb(p, SCB_LIST_NULL, DISCONNECTED_SCBH);
8223
8224   /*
8225    * Message out buffer starts empty
8226    */
8227   aic_outb(p, MSG_NOOP, MSG_OUT);
8228   aic_outb(p, MSG_NOOP, LAST_MSG);
8229
8230   /*
8231    * Set all the other asundry items that haven't been set yet.
8232    * This includes just dumping init values to a lot of registers simply
8233    * to make sure they've been touched and are ready for use parity wise
8234    * speaking.
8235    */
8236   aic_outb(p, 0, TMODE_CMDADDR);
8237   aic_outb(p, 0, TMODE_CMDADDR + 1);
8238   aic_outb(p, 0, TMODE_CMDADDR + 2);
8239   aic_outb(p, 0, TMODE_CMDADDR + 3);
8240   aic_outb(p, 0, TMODE_CMDADDR_NEXT);
8241
8242   /*
8243    * Link us into the list of valid hosts
8244    */
8245   p->next = first_aic7xxx;
8246   first_aic7xxx = p;
8247
8248   /*
8249    * Allocate the first set of scbs for this controller.  This is to stream-
8250    * line code elsewhere in the driver.  If we have to check for the existence
8251    * of scbs in certain code sections, it slows things down.  However, as
8252    * soon as we register the IRQ for this card, we could get an interrupt that
8253    * includes possibly the SCSI_RSTI interrupt.  If we catch that interrupt
8254    * then we are likely to segfault if we don't have at least one chunk of
8255    * SCBs allocated or add checks all through the reset code to make sure
8256    * that the SCBs have been allocated which is an invalid running condition
8257    * and therefore I think it's preferable to simply pre-allocate the first
8258    * chunk of SCBs.
8259    */
8260   aic7xxx_allocate_scb(p);
8261
8262   /*
8263    * Load the sequencer program, then re-enable the board -
8264    * resetting the AIC-7770 disables it, leaving the lights
8265    * on with nobody home.
8266    */
8267   aic7xxx_loadseq(p);
8268
8269   /*
8270    * Make sure the AUTOFLUSHDIS bit is *not* set in the SBLKCTL register
8271    */
8272   aic_outb(p, aic_inb(p, SBLKCTL) & ~AUTOFLUSHDIS, SBLKCTL);
8273
8274   if ( (p->chip & AHC_CHIPID_MASK) == AHC_AIC7770 )
8275   {
8276     aic_outb(p, ENABLE, BCTL);  /* Enable the boards BUS drivers. */
8277   }
8278
8279   if ( !(aic7xxx_no_reset) )
8280   {
8281     if (p->features & AHC_TWIN)
8282     {
8283       if (aic7xxx_verbose & VERBOSE_PROBE2)
8284         printk(KERN_INFO "(scsi%d) Resetting channel B\n", p->host_no);
8285       aic_outb(p, aic_inb(p, SBLKCTL) | SELBUSB, SBLKCTL);
8286       aic7xxx_reset_current_bus(p);
8287       aic_outb(p, aic_inb(p, SBLKCTL) & ~SELBUSB, SBLKCTL);
8288     }
8289     /* Reset SCSI bus A. */
8290     if (aic7xxx_verbose & VERBOSE_PROBE2)
8291     {  /* In case we are a 3940, 3985, or 7895, print the right channel */
8292       char *channel = "";
8293       if (p->flags & AHC_MULTI_CHANNEL)
8294       {
8295         channel = " A";
8296         if (p->flags & (AHC_CHNLB|AHC_CHNLC))
8297           channel = (p->flags & AHC_CHNLB) ? " B" : " C";
8298       }
8299       printk(KERN_INFO "(scsi%d) Resetting channel%s\n", p->host_no, channel);
8300     }
8301
8302     aic7xxx_reset_current_bus(p);
8303
8304   }
8305   else
8306   {
8307     if (!reset_delay)
8308     {
8309       printk(KERN_INFO "(scsi%d) Not resetting SCSI bus.  Note: Don't use "
8310              "the no_reset\n", p->host_no);
8311       printk(KERN_INFO "(scsi%d) option unless you have a verifiable need "
8312              "for it.\n", p->host_no);
8313     }
8314   }
8315
8316   /*
8317    * Register IRQ with the kernel.  Only allow sharing IRQs with
8318    * PCI devices.
8319    */
8320   if (!(p->chip & AHC_PCI))
8321   {
8322     result = (request_irq(p->irq, do_aic7xxx_isr, 0, "aic7xxx", p));
8323   }
8324   else
8325   {
8326     result = (request_irq(p->irq, do_aic7xxx_isr, SA_SHIRQ,
8327               "aic7xxx", p));
8328     if (result < 0)
8329     {
8330       result = (request_irq(p->irq, do_aic7xxx_isr, SA_INTERRUPT | SA_SHIRQ,
8331               "aic7xxx", p));
8332     }
8333   }
8334   if (result < 0)
8335   {
8336     printk(KERN_WARNING "(scsi%d) Couldn't register IRQ %d, ignoring "
8337            "controller.\n", p->host_no, p->irq);
8338     aic_outb(p, 0, SIMODE1);
8339     p->irq = 0;
8340     return (0);
8341   }
8342
8343   if(aic_inb(p, INTSTAT) & INT_PEND)
8344     printk(INFO_LEAD "spurious interrupt during configuration, cleared.\n",
8345       p->host_no, -1, -1 , -1);
8346   aic7xxx_clear_intstat(p);
8347
8348   unpause_sequencer(p, /* unpause_always */ TRUE);
8349
8350   return (found);
8351 }
8352
8353 /*+F*************************************************************************
8354  * Function:
8355  *   aic7xxx_chip_reset
8356  *
8357  * Description:
8358  *   Perform a chip reset on the aic7xxx SCSI controller.  The controller
8359  *   is paused upon return.
8360  *-F*************************************************************************/
8361 static int
8362 aic7xxx_chip_reset(struct aic7xxx_host *p)
8363 {
8364   unsigned char sblkctl;
8365   int wait;
8366
8367   /*
8368    * For some 274x boards, we must clear the CHIPRST bit and pause
8369    * the sequencer. For some reason, this makes the driver work.
8370    */
8371   aic_outb(p, PAUSE | CHIPRST, HCNTRL);
8372
8373   /*
8374    * In the future, we may call this function as a last resort for
8375    * error handling.  Let's be nice and not do any unnecessary delays.
8376    */
8377   wait = 1000;  /* 1 msec (1000 * 1 msec) */
8378   while (--wait && !(aic_inb(p, HCNTRL) & CHIPRSTACK))
8379   {
8380     udelay(1);  /* 1 usec */
8381   }
8382
8383   pause_sequencer(p);
8384
8385   sblkctl = aic_inb(p, SBLKCTL) & (SELBUSB|SELWIDE);
8386   if (p->chip & AHC_PCI)
8387     sblkctl &= ~SELBUSB;
8388   switch( sblkctl )
8389   {
8390     case 0:  /* normal narrow card */
8391       break;
8392     case 2:  /* Wide card */
8393       p->features |= AHC_WIDE;
8394       break;
8395     case 8:  /* Twin card */
8396       p->features |= AHC_TWIN;
8397       p->flags |= AHC_MULTI_CHANNEL;
8398       break;
8399     default: /* hmmm...we don't know what this is */
8400       printk(KERN_WARNING "aic7xxx: Unsupported adapter type %d, ignoring.\n",
8401         aic_inb(p, SBLKCTL) & 0x0a);
8402       return(-1);
8403   }
8404   return(0);
8405 }
8406
8407 /*+F*************************************************************************
8408  * Function:
8409  *   aic7xxx_alloc
8410  *
8411  * Description:
8412  *   Allocate and initialize a host structure.  Returns NULL upon error
8413  *   and a pointer to a aic7xxx_host struct upon success.
8414  *-F*************************************************************************/
8415 static struct aic7xxx_host *
8416 aic7xxx_alloc(Scsi_Host_Template *sht, struct aic7xxx_host *temp)
8417 {
8418   struct aic7xxx_host *p = NULL;
8419   struct Scsi_Host *host;
8420
8421   /*
8422    * Allocate a storage area by registering us with the mid-level
8423    * SCSI layer.
8424    */
8425   host = scsi_register(sht, sizeof(struct aic7xxx_host));
8426
8427   if (host != NULL)
8428   {
8429     p = (struct aic7xxx_host *) host->hostdata;
8430     memset(p, 0, sizeof(struct aic7xxx_host));
8431     *p = *temp;
8432     p->host = host;
8433
8434     p->scb_data = kmalloc(sizeof(scb_data_type), GFP_ATOMIC);
8435     if (p->scb_data != NULL)
8436     {
8437       memset(p->scb_data, 0, sizeof(scb_data_type));
8438       scbq_init (&p->scb_data->free_scbs);
8439     }
8440     else
8441     {
8442       /*
8443        * For some reason we don't have enough memory.  Free the
8444        * allocated memory for the aic7xxx_host struct, and return NULL.
8445        */
8446       release_region(p->base, MAXREG - MINREG);
8447       scsi_unregister(host);
8448       return(NULL);
8449     }
8450     p->host_no = host->host_no;
8451   }
8452   scsi_set_device(host, &p->pdev->dev);
8453   return (p);
8454 }
8455
8456 /*+F*************************************************************************
8457  * Function:
8458  *   aic7xxx_free
8459  *
8460  * Description:
8461  *   Frees and releases all resources associated with an instance of
8462  *   the driver (struct aic7xxx_host *).
8463  *-F*************************************************************************/
8464 static void
8465 aic7xxx_free(struct aic7xxx_host *p)
8466 {
8467   int i;
8468
8469   /*
8470    * Free the allocated hardware SCB space.
8471    */
8472   if (p->scb_data != NULL)
8473   {
8474     struct aic7xxx_scb_dma *scb_dma = NULL;
8475     if (p->scb_data->hscbs != NULL)
8476     {
8477       pci_free_consistent(p->pdev, p->scb_data->hscbs_dma_len,
8478                           p->scb_data->hscbs, p->scb_data->hscbs_dma);
8479       p->scb_data->hscbs = p->scb_data->hscb_kmalloc_ptr = NULL;
8480     }
8481     /*
8482      * Free the driver SCBs.  These were allocated on an as-need
8483      * basis.  We allocated these in groups depending on how many
8484      * we could fit into a given amount of RAM.  The tail SCB for
8485      * these allocations has a pointer to the alloced area.
8486      */
8487     for (i = 0; i < p->scb_data->numscbs; i++)
8488     {
8489       if (p->scb_data->scb_array[i]->scb_dma != scb_dma)
8490       {
8491         scb_dma = p->scb_data->scb_array[i]->scb_dma;
8492         pci_free_consistent(p->pdev, scb_dma->dma_len,
8493                             (void *)((unsigned long)scb_dma->dma_address
8494                                      - scb_dma->dma_offset),
8495                             scb_dma->dma_address);
8496       }
8497       if (p->scb_data->scb_array[i]->kmalloc_ptr != NULL)
8498         kfree(p->scb_data->scb_array[i]->kmalloc_ptr);
8499       p->scb_data->scb_array[i] = NULL;
8500     }
8501
8502     /*
8503      * Free the SCB data area.
8504      */
8505     kfree(p->scb_data);
8506   }
8507
8508   pci_free_consistent(p->pdev, 3*256, (void *)p->untagged_scbs, p->fifo_dma);
8509 }
8510
8511 /*+F*************************************************************************
8512  * Function:
8513  *   aic7xxx_load_seeprom
8514  *
8515  * Description:
8516  *   Load the seeprom and configure adapter and target settings.
8517  *   Returns 1 if the load was successful and 0 otherwise.
8518  *-F*************************************************************************/
8519 static void
8520 aic7xxx_load_seeprom(struct aic7xxx_host *p, unsigned char *sxfrctl1)
8521 {
8522   int have_seeprom = 0;
8523   int i, max_targets, mask;
8524   unsigned char scsirate, scsi_conf;
8525   unsigned short scarray[128];
8526   struct seeprom_config *sc = (struct seeprom_config *) scarray;
8527
8528   if (aic7xxx_verbose & VERBOSE_PROBE2)
8529   {
8530     printk(KERN_INFO "aic7xxx: Loading serial EEPROM...");
8531   }
8532   switch (p->chip)
8533   {
8534     case (AHC_AIC7770|AHC_EISA):  /* None of these adapters have seeproms. */
8535       if (aic_inb(p, SCSICONF) & TERM_ENB)
8536         p->flags |= AHC_TERM_ENB_A;
8537       if ( (p->features & AHC_TWIN) && (aic_inb(p, SCSICONF + 1) & TERM_ENB) )
8538         p->flags |= AHC_TERM_ENB_B;
8539       break;
8540
8541     case (AHC_AIC7770|AHC_VL):
8542       have_seeprom = read_284x_seeprom(p, (struct seeprom_config *) scarray);
8543       break;
8544
8545     default:
8546       have_seeprom = read_seeprom(p, (p->flags & (AHC_CHNLB|AHC_CHNLC)),
8547                                   scarray, p->sc_size, p->sc_type);
8548       if (!have_seeprom)
8549       {
8550         if(p->sc_type == C46)
8551           have_seeprom = read_seeprom(p, (p->flags & (AHC_CHNLB|AHC_CHNLC)),
8552                                       scarray, p->sc_size, C56_66);
8553         else
8554           have_seeprom = read_seeprom(p, (p->flags & (AHC_CHNLB|AHC_CHNLC)),
8555                                       scarray, p->sc_size, C46);
8556       }
8557       if (!have_seeprom)
8558       {
8559         p->sc_size = 128;
8560         have_seeprom = read_seeprom(p, 4*(p->flags & (AHC_CHNLB|AHC_CHNLC)),
8561                                     scarray, p->sc_size, p->sc_type);
8562         if (!have_seeprom)
8563         {
8564           if(p->sc_type == C46)
8565             have_seeprom = read_seeprom(p, 4*(p->flags & (AHC_CHNLB|AHC_CHNLC)),
8566                                         scarray, p->sc_size, C56_66);
8567           else
8568             have_seeprom = read_seeprom(p, 4*(p->flags & (AHC_CHNLB|AHC_CHNLC)),
8569                                         scarray, p->sc_size, C46);
8570         }
8571       }
8572       break;
8573   }
8574
8575   if (!have_seeprom)
8576   {
8577     if (aic7xxx_verbose & VERBOSE_PROBE2)
8578     {
8579       printk("\naic7xxx: No SEEPROM available.\n");
8580     }
8581     p->flags |= AHC_NEWEEPROM_FMT;
8582     if (aic_inb(p, SCSISEQ) == 0)
8583     {
8584       p->flags |= AHC_USEDEFAULTS;
8585       p->flags &= ~AHC_BIOS_ENABLED;
8586       p->scsi_id = p->scsi_id_b = 7;
8587       *sxfrctl1 |= STPWEN;
8588       if (aic7xxx_verbose & VERBOSE_PROBE2)
8589       {
8590         printk("aic7xxx: Using default values.\n");
8591       }
8592     }
8593     else if (aic7xxx_verbose & VERBOSE_PROBE2)
8594     {
8595       printk("aic7xxx: Using leftover BIOS values.\n");
8596     }
8597     if ( ((p->chip & ~AHC_CHIPID_MASK) == AHC_PCI) && (*sxfrctl1 & STPWEN) )
8598     {
8599       p->flags |= AHC_TERM_ENB_SE_LOW | AHC_TERM_ENB_SE_HIGH;
8600       sc->adapter_control &= ~CFAUTOTERM;
8601       sc->adapter_control |= CFSTERM | CFWSTERM | CFLVDSTERM;
8602     }
8603     if (aic7xxx_extended)
8604       p->flags |= (AHC_EXTEND_TRANS_A | AHC_EXTEND_TRANS_B);
8605     else
8606       p->flags &= ~(AHC_EXTEND_TRANS_A | AHC_EXTEND_TRANS_B);
8607   }
8608   else
8609   {
8610     if (aic7xxx_verbose & VERBOSE_PROBE2)
8611     {
8612       printk("done\n");
8613     }
8614
8615     /*
8616      * Note things in our flags
8617      */
8618     p->flags |= AHC_SEEPROM_FOUND;
8619
8620     /*
8621      * Update the settings in sxfrctl1 to match the termination settings.
8622      */
8623     *sxfrctl1 = 0;
8624
8625     /*
8626      * Get our SCSI ID from the SEEPROM setting...
8627      */
8628     p->scsi_id = (sc->brtime_id & CFSCSIID);
8629
8630     /*
8631      * First process the settings that are different between the VLB
8632      * and PCI adapter seeproms.
8633      */
8634     if ((p->chip & AHC_CHIPID_MASK) == AHC_AIC7770)
8635     {
8636       /* VLB adapter seeproms */
8637       if (sc->bios_control & CF284XEXTEND)
8638         p->flags |= AHC_EXTEND_TRANS_A;
8639
8640       if (sc->adapter_control & CF284XSTERM)
8641       {
8642         *sxfrctl1 |= STPWEN;
8643         p->flags |= AHC_TERM_ENB_SE_LOW | AHC_TERM_ENB_SE_HIGH;
8644       }
8645     }
8646     else
8647     {
8648       /* PCI adapter seeproms */
8649       if (sc->bios_control & CFEXTEND)
8650         p->flags |= AHC_EXTEND_TRANS_A;
8651       if (sc->bios_control & CFBIOSEN)
8652         p->flags |= AHC_BIOS_ENABLED;
8653       else
8654         p->flags &= ~AHC_BIOS_ENABLED;
8655
8656       if (sc->adapter_control & CFSTERM)
8657       {
8658         *sxfrctl1 |= STPWEN;
8659         p->flags |= AHC_TERM_ENB_SE_LOW | AHC_TERM_ENB_SE_HIGH;
8660       }
8661     }
8662     memcpy(&p->sc, sc, sizeof(struct seeprom_config));
8663   }
8664
8665   p->discenable = 0;
8666
8667   /*
8668    * Limit to 16 targets just in case.  The 2842 for one is known to
8669    * blow the max_targets setting, future cards might also.
8670    */
8671   max_targets = ((p->features & (AHC_TWIN | AHC_WIDE)) ? 16 : 8);
8672
8673   if (have_seeprom)
8674   {
8675     for (i = 0; i < max_targets; i++)
8676     {
8677       if( ((p->features & AHC_ULTRA) &&
8678           !(sc->adapter_control & CFULTRAEN) &&
8679            (sc->device_flags[i] & CFSYNCHISULTRA)) ||
8680           (sc->device_flags[i] & CFNEWULTRAFORMAT) )
8681       {
8682         p->flags |= AHC_NEWEEPROM_FMT;
8683         break;
8684       }
8685     }
8686   }
8687
8688   for (i = 0; i < max_targets; i++)
8689   {
8690     mask = (0x01 << i);
8691     if (!have_seeprom)
8692     {
8693       if (aic_inb(p, SCSISEQ) != 0)
8694       {
8695         /*
8696          * OK...the BIOS set things up and left behind the settings we need.
8697          * Just make our sc->device_flags[i] entry match what the card has
8698          * set for this device.
8699          */
8700         p->discenable =
8701           ~(aic_inb(p, DISC_DSB) | (aic_inb(p, DISC_DSB + 1) << 8) );
8702         p->ultraenb =
8703           (aic_inb(p, ULTRA_ENB) | (aic_inb(p, ULTRA_ENB + 1) << 8) );
8704         sc->device_flags[i] = (p->discenable & mask) ? CFDISC : 0;
8705         if (aic_inb(p, TARG_SCSIRATE + i) & WIDEXFER)
8706           sc->device_flags[i] |= CFWIDEB;
8707         if (p->features & AHC_ULTRA2)
8708         {
8709           if (aic_inb(p, TARG_OFFSET + i))
8710           {
8711             sc->device_flags[i] |= CFSYNCH;
8712             sc->device_flags[i] |= (aic_inb(p, TARG_SCSIRATE + i) & 0x07);
8713             if ( (aic_inb(p, TARG_SCSIRATE + i) & 0x18) == 0x18 )
8714               sc->device_flags[i] |= CFSYNCHISULTRA;
8715           }
8716         }
8717         else
8718         {
8719           if (aic_inb(p, TARG_SCSIRATE + i) & ~WIDEXFER)
8720           {
8721             sc->device_flags[i] |= CFSYNCH;
8722             if (p->features & AHC_ULTRA)
8723               sc->device_flags[i] |= ((p->ultraenb & mask) ?
8724                                       CFSYNCHISULTRA : 0);
8725           }
8726         }
8727       }
8728       else
8729       {
8730         /*
8731          * Assume the BIOS has NOT been run on this card and nothing between
8732          * the card and the devices is configured yet.
8733          */
8734         sc->device_flags[i] = CFDISC;
8735         if (p->features & AHC_WIDE)
8736           sc->device_flags[i] |= CFWIDEB;
8737         if (p->features & AHC_ULTRA3)
8738           sc->device_flags[i] |= 2;
8739         else if (p->features & AHC_ULTRA2)
8740           sc->device_flags[i] |= 3;
8741         else if (p->features & AHC_ULTRA)
8742           sc->device_flags[i] |= CFSYNCHISULTRA;
8743         sc->device_flags[i] |= CFSYNCH;
8744         aic_outb(p, 0, TARG_SCSIRATE + i);
8745         if (p->features & AHC_ULTRA2)
8746           aic_outb(p, 0, TARG_OFFSET + i);
8747       }
8748     }
8749     if (sc->device_flags[i] & CFDISC)
8750     {
8751       p->discenable |= mask;
8752     }
8753     if (p->flags & AHC_NEWEEPROM_FMT)
8754     {
8755       if ( !(p->features & AHC_ULTRA2) )
8756       {
8757         /*
8758          * I know of two different Ultra BIOSes that do this differently.
8759          * One on the Gigabyte 6BXU mb that wants flags[i] & CFXFER to
8760          * be == to 0x03 and SYNCHISULTRA to be true to mean 40MByte/s
8761          * while on the IBM Netfinity 5000 they want the same thing
8762          * to be something else, while flags[i] & CFXFER == 0x03 and
8763          * SYNCHISULTRA false should be 40MByte/s.  So, we set both to
8764          * 40MByte/s and the lower speeds be damned.  People will have
8765          * to select around the conversely mapped lower speeds in order
8766          * to select lower speeds on these boards.
8767          */
8768         if ( (sc->device_flags[i] & CFNEWULTRAFORMAT) &&
8769             ((sc->device_flags[i] & CFXFER) == 0x03) )
8770         {
8771           sc->device_flags[i] &= ~CFXFER;
8772           sc->device_flags[i] |= CFSYNCHISULTRA;
8773         }
8774         if (sc->device_flags[i] & CFSYNCHISULTRA)
8775         {
8776           p->ultraenb |= mask;
8777         }
8778       }
8779       else if ( !(sc->device_flags[i] & CFNEWULTRAFORMAT) &&
8780                  (p->features & AHC_ULTRA2) &&
8781                  (sc->device_flags[i] & CFSYNCHISULTRA) )
8782       {
8783         p->ultraenb |= mask;
8784       }
8785     }
8786     else if (sc->adapter_control & CFULTRAEN)
8787     {
8788       p->ultraenb |= mask;
8789     }
8790     if ( (sc->device_flags[i] & CFSYNCH) == 0)
8791     {
8792       sc->device_flags[i] &= ~CFXFER;
8793       p->ultraenb &= ~mask;
8794       p->user[i].offset = 0;
8795       p->user[i].period = 0;
8796       p->user[i].options = 0;
8797     }
8798     else
8799     {
8800       if (p->features & AHC_ULTRA3)
8801       {
8802         p->user[i].offset = MAX_OFFSET_ULTRA2;
8803         if( (sc->device_flags[i] & CFXFER) < 0x03 )
8804         {
8805           scsirate = (sc->device_flags[i] & CFXFER);
8806           p->user[i].options = MSG_EXT_PPR_OPTION_DT_CRC;
8807         }
8808         else
8809         {
8810           scsirate = (sc->device_flags[i] & CFXFER) |
8811                      ((p->ultraenb & mask) ? 0x18 : 0x10);
8812           p->user[i].options = 0;
8813         }
8814         p->user[i].period = aic7xxx_find_period(p, scsirate,
8815                                        AHC_SYNCRATE_ULTRA3);
8816       }
8817       else if (p->features & AHC_ULTRA2)
8818       {
8819         p->user[i].offset = MAX_OFFSET_ULTRA2;
8820         scsirate = (sc->device_flags[i] & CFXFER) |
8821                    ((p->ultraenb & mask) ? 0x18 : 0x10);
8822         p->user[i].options = 0;
8823         p->user[i].period = aic7xxx_find_period(p, scsirate,
8824                                        AHC_SYNCRATE_ULTRA2);
8825       }
8826       else
8827       {
8828         scsirate = (sc->device_flags[i] & CFXFER) << 4;
8829         p->user[i].options = 0;
8830         p->user[i].offset = MAX_OFFSET_8BIT;
8831         if (p->features & AHC_ULTRA)
8832         {
8833           short ultraenb;
8834           ultraenb = aic_inb(p, ULTRA_ENB) |
8835             (aic_inb(p, ULTRA_ENB + 1) << 8);
8836           p->user[i].period = aic7xxx_find_period(p, scsirate,
8837                                           (p->ultraenb & mask) ?
8838                                           AHC_SYNCRATE_ULTRA :
8839                                           AHC_SYNCRATE_FAST);
8840         }
8841         else
8842           p->user[i].period = aic7xxx_find_period(p, scsirate,
8843                                           AHC_SYNCRATE_FAST);
8844       }
8845     }
8846     if ( (sc->device_flags[i] & CFWIDEB) && (p->features & AHC_WIDE) )
8847     {
8848       p->user[i].width = MSG_EXT_WDTR_BUS_16_BIT;
8849     }
8850     else
8851     {
8852       p->user[i].width = MSG_EXT_WDTR_BUS_8_BIT;
8853     }
8854   }
8855   aic_outb(p, ~(p->discenable & 0xFF), DISC_DSB);
8856   aic_outb(p, ~((p->discenable >> 8) & 0xFF), DISC_DSB + 1);
8857
8858   /*
8859    * We set the p->ultraenb from the SEEPROM to begin with, but now we make
8860    * it match what is already down in the card.  If we are doing a reset
8861    * on the card then this will get put back to a default state anyway.
8862    * This allows us to not have to pre-emptively negotiate when using the
8863    * no_reset option.
8864    */
8865   if (p->features & AHC_ULTRA)
8866     p->ultraenb = aic_inb(p, ULTRA_ENB) | (aic_inb(p, ULTRA_ENB + 1) << 8);
8867
8868
8869   scsi_conf = (p->scsi_id & HSCSIID);
8870
8871   if(have_seeprom)
8872   {
8873     p->adapter_control = sc->adapter_control;
8874     p->bios_control = sc->bios_control;
8875
8876     switch (p->chip & AHC_CHIPID_MASK)
8877     {
8878       case AHC_AIC7895:
8879       case AHC_AIC7896:
8880       case AHC_AIC7899:
8881         if (p->adapter_control & CFBPRIMARY)
8882           p->flags |= AHC_CHANNEL_B_PRIMARY;
8883       default:
8884         break;
8885     }
8886
8887     if (sc->adapter_control & CFSPARITY)
8888       scsi_conf |= ENSPCHK;
8889   }
8890   else
8891   {
8892     scsi_conf |= ENSPCHK | RESET_SCSI;
8893   }
8894
8895   /*
8896    * Only set the SCSICONF and SCSICONF + 1 registers if we are a PCI card.
8897    * The 2842 and 2742 cards already have these registers set and we don't
8898    * want to muck with them since we don't set all the bits they do.
8899    */
8900   if ( (p->chip & ~AHC_CHIPID_MASK) == AHC_PCI )
8901   {
8902     /* Set the host ID */
8903     aic_outb(p, scsi_conf, SCSICONF);
8904     /* In case we are a wide card */
8905     aic_outb(p, p->scsi_id, SCSICONF + 1);
8906   }
8907 }
8908
8909 /*+F*************************************************************************
8910  * Function:
8911  *   aic7xxx_configure_bugs
8912  *
8913  * Description:
8914  *   Take the card passed in and set the appropriate bug flags based upon
8915  *   the card model.  Also make any changes needed to device registers or
8916  *   PCI registers while we are here.
8917  *-F*************************************************************************/
8918 static void
8919 aic7xxx_configure_bugs(struct aic7xxx_host *p)
8920 {
8921   unsigned short tmp_word;
8922
8923   switch(p->chip & AHC_CHIPID_MASK)
8924   {
8925     case AHC_AIC7860:
8926       p->bugs |= AHC_BUG_PCI_2_1_RETRY;
8927       /* fall through */
8928     case AHC_AIC7850:
8929     case AHC_AIC7870:
8930       p->bugs |= AHC_BUG_TMODE_WIDEODD | AHC_BUG_CACHETHEN | AHC_BUG_PCI_MWI;
8931       break;
8932     case AHC_AIC7880:
8933       p->bugs |= AHC_BUG_TMODE_WIDEODD | AHC_BUG_PCI_2_1_RETRY |
8934                  AHC_BUG_CACHETHEN | AHC_BUG_PCI_MWI;
8935       break;
8936     case AHC_AIC7890:
8937       p->bugs |= AHC_BUG_AUTOFLUSH | AHC_BUG_CACHETHEN;
8938       break;
8939     case AHC_AIC7892:
8940       p->bugs |= AHC_BUG_SCBCHAN_UPLOAD;
8941       break;
8942     case AHC_AIC7895:
8943       p->bugs |= AHC_BUG_TMODE_WIDEODD | AHC_BUG_PCI_2_1_RETRY |
8944                  AHC_BUG_CACHETHEN | AHC_BUG_PCI_MWI;
8945       break;
8946     case AHC_AIC7896:
8947       p->bugs |= AHC_BUG_CACHETHEN_DIS;
8948       break;
8949     case AHC_AIC7899:
8950       p->bugs |= AHC_BUG_SCBCHAN_UPLOAD;
8951       break;
8952     default:
8953       /* Nothing to do */
8954       break;
8955   }
8956
8957   /*
8958    * Now handle the bugs that require PCI register or card register tweaks
8959    */
8960   pci_read_config_word(p->pdev, PCI_COMMAND, &tmp_word);
8961   if(p->bugs & AHC_BUG_PCI_MWI)
8962   {
8963     tmp_word &= ~PCI_COMMAND_INVALIDATE;
8964   }
8965   else
8966   {
8967     tmp_word |= PCI_COMMAND_INVALIDATE;
8968   }
8969   pci_write_config_word(p->pdev, PCI_COMMAND, tmp_word);
8970
8971   if(p->bugs & AHC_BUG_CACHETHEN)
8972   {
8973     aic_outb(p, aic_inb(p, DSCOMMAND0) & ~CACHETHEN, DSCOMMAND0);
8974   }
8975   else if (p->bugs & AHC_BUG_CACHETHEN_DIS)
8976   {
8977     aic_outb(p, aic_inb(p, DSCOMMAND0) | CACHETHEN, DSCOMMAND0);
8978   }
8979
8980   return;
8981 }
8982
8983
8984 /*+F*************************************************************************
8985  * Function:
8986  *   aic7xxx_detect
8987  *
8988  * Description:
8989  *   Try to detect and register an Adaptec 7770 or 7870 SCSI controller.
8990  *
8991  * XXX - This should really be called aic7xxx_probe().  A sequence of
8992  *       probe(), attach()/detach(), and init() makes more sense than
8993  *       one do-it-all function.  This may be useful when (and if) the
8994  *       mid-level SCSI code is overhauled.
8995  *-F*************************************************************************/
8996 static int
8997 aic7xxx_detect(Scsi_Host_Template *template)
8998 {
8999   struct aic7xxx_host *temp_p = NULL;
9000   struct aic7xxx_host *current_p = NULL;
9001   struct aic7xxx_host *list_p = NULL;
9002   int found = 0;
9003 #if defined(__i386__) || defined(__alpha__)
9004   ahc_flag_type flags = 0;
9005   int type;
9006 #endif
9007   unsigned char sxfrctl1;
9008 #if defined(__i386__) || defined(__alpha__)
9009   unsigned char hcntrl, hostconf;
9010   unsigned int slot, base;
9011 #endif
9012
9013 #ifdef MODULE
9014   /*
9015    * If we are called as a module, the aic7xxx pointer may not be null
9016    * and it would point to our bootup string, just like on the lilo
9017    * command line.  IF not NULL, then process this config string with
9018    * aic7xxx_setup
9019    */
9020   if(aic7xxx)
9021     aic7xxx_setup(aic7xxx);
9022 #endif
9023
9024   template->proc_name = "aic7xxx";
9025   template->sg_tablesize = AIC7XXX_MAX_SG;
9026
9027
9028 #ifdef CONFIG_PCI
9029   /*
9030    * PCI-bus probe.
9031    */
9032   {
9033     static struct
9034     {
9035       unsigned short      vendor_id;
9036       unsigned short      device_id;
9037       ahc_chip            chip;
9038       ahc_flag_type       flags;
9039       ahc_feature         features;
9040       int                 board_name_index;
9041       unsigned short      seeprom_size;
9042       unsigned short      seeprom_type;
9043     } const aic_pdevs[] = {
9044       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7810, AHC_NONE,
9045        AHC_FNONE, AHC_FENONE,                                1,
9046        32, C46 },
9047       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7850, AHC_AIC7850,
9048        AHC_PAGESCBS, AHC_AIC7850_FE,                         5,
9049        32, C46 },
9050       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7855, AHC_AIC7850,
9051        AHC_PAGESCBS, AHC_AIC7850_FE,                         6,
9052        32, C46 },
9053       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7821, AHC_AIC7860,
9054        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9055        AHC_AIC7860_FE,                                       7,
9056        32, C46 },
9057       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_3860, AHC_AIC7860,
9058        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9059        AHC_AIC7860_FE,                                       7,
9060        32, C46 },
9061       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_38602, AHC_AIC7860,
9062        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9063        AHC_AIC7860_FE,                                       7,
9064        32, C46 },
9065       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_38602, AHC_AIC7860,
9066        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9067        AHC_AIC7860_FE,                                       7,
9068        32, C46 },
9069       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7860, AHC_AIC7860,
9070        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MOTHERBOARD,
9071        AHC_AIC7860_FE,                                       7,
9072        32, C46 },
9073       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7861, AHC_AIC7860,
9074        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9075        AHC_AIC7860_FE,                                       8,
9076        32, C46 },
9077       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7870, AHC_AIC7870,
9078        AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MOTHERBOARD,
9079        AHC_AIC7870_FE,                                       9,
9080        32, C46 },
9081       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7871, AHC_AIC7870,
9082        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7870_FE,     10,
9083        32, C46 },
9084       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7872, AHC_AIC7870,
9085        AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9086        AHC_AIC7870_FE,                                      11,
9087        32, C56_66 },
9088       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7873, AHC_AIC7870,
9089        AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9090        AHC_AIC7870_FE,                                      12,
9091        32, C56_66 },
9092       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7874, AHC_AIC7870,
9093        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7870_FE,     13,
9094        32, C46 },
9095       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7880, AHC_AIC7880,
9096        AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MOTHERBOARD,
9097        AHC_AIC7880_FE,                                      14,
9098        32, C46 },
9099       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7881, AHC_AIC7880,
9100        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE,     15,
9101        32, C46 },
9102       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7882, AHC_AIC7880,
9103        AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9104        AHC_AIC7880_FE,                                      16,
9105        32, C56_66 },
9106       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7883, AHC_AIC7880,
9107        AHC_PAGESCBS | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9108        AHC_AIC7880_FE,                                      17,
9109        32, C56_66 },
9110       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7884, AHC_AIC7880,
9111        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE,     18,
9112        32, C46 },
9113       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7885, AHC_AIC7880,
9114        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE,     18,
9115        32, C46 },
9116       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7886, AHC_AIC7880,
9117        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE,     18,
9118        32, C46 },
9119       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7887, AHC_AIC7880,
9120        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE | AHC_NEW_AUTOTERM, 19,
9121        32, C46 },
9122       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7888, AHC_AIC7880,
9123        AHC_PAGESCBS | AHC_BIOS_ENABLED, AHC_AIC7880_FE,     18,
9124        32, C46 },
9125       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_7895, AHC_AIC7895,
9126        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9127        AHC_AIC7895_FE,                                      20,
9128        32, C56_66 },
9129       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7890, AHC_AIC7890,
9130        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9131        AHC_AIC7890_FE,                                      21,
9132        32, C46 },
9133       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7890B, AHC_AIC7890,
9134        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9135        AHC_AIC7890_FE,                                      21,
9136        32, C46 },
9137       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_2930U2, AHC_AIC7890,
9138        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9139        AHC_AIC7890_FE,                                      22,
9140        32, C46 },
9141       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_2940U2, AHC_AIC7890,
9142        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9143        AHC_AIC7890_FE,                                      23,
9144        32, C46 },
9145       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7896, AHC_AIC7896,
9146        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9147        AHC_AIC7896_FE,                                      24,
9148        32, C56_66 },
9149       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_3940U2, AHC_AIC7896,
9150        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9151        AHC_AIC7896_FE,                                      25,
9152        32, C56_66 },
9153       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_3950U2D, AHC_AIC7896,
9154        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9155        AHC_AIC7896_FE,                                      26,
9156        32, C56_66 },
9157       {PCI_VENDOR_ID_ADAPTEC, PCI_DEVICE_ID_ADAPTEC_1480A, AHC_AIC7860,
9158        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_NO_STPWEN,
9159        AHC_AIC7860_FE,                                      27,
9160        32, C46 },
9161       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7892A, AHC_AIC7892,
9162        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9163        AHC_AIC7892_FE,                                      28,
9164        32, C46 },
9165       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7892B, AHC_AIC7892,
9166        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9167        AHC_AIC7892_FE,                                      28,
9168        32, C46 },
9169       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7892D, AHC_AIC7892,
9170        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9171        AHC_AIC7892_FE,                                      28,
9172        32, C46 },
9173       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7892P, AHC_AIC7892,
9174        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED,
9175        AHC_AIC7892_FE,                                      28,
9176        32, C46 },
9177       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7899A, AHC_AIC7899,
9178        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9179        AHC_AIC7899_FE,                                      29,
9180        32, C56_66 },
9181       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7899B, AHC_AIC7899,
9182        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9183        AHC_AIC7899_FE,                                      29,
9184        32, C56_66 },
9185       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7899D, AHC_AIC7899,
9186        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9187        AHC_AIC7899_FE,                                      29,
9188        32, C56_66 },
9189       {PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_7899P, AHC_AIC7899,
9190        AHC_PAGESCBS | AHC_NEWEEPROM_FMT | AHC_BIOS_ENABLED | AHC_MULTI_CHANNEL,
9191        AHC_AIC7899_FE,                                      29,
9192        32, C56_66 },
9193     };
9194
9195     unsigned short command;
9196     unsigned int  devconfig, i, oldverbose;
9197     struct pci_dev *pdev = NULL;
9198
9199     for (i = 0; i < ARRAY_SIZE(aic_pdevs); i++)
9200     {
9201       pdev = NULL;
9202       while ((pdev = pci_find_device(aic_pdevs[i].vendor_id,
9203                                      aic_pdevs[i].device_id,
9204                                      pdev))) {
9205         if (pci_enable_device(pdev))
9206                 continue;
9207         if ( i == 0 ) /* We found one, but it's the 7810 RAID cont. */
9208         {
9209           if (aic7xxx_verbose & (VERBOSE_PROBE|VERBOSE_PROBE2))
9210           {
9211             printk(KERN_INFO "aic7xxx: The 7810 RAID controller is not "
9212               "supported by\n");
9213             printk(KERN_INFO "         this driver, we are ignoring it.\n");
9214           }
9215         }
9216         else if ( (temp_p = kmalloc(sizeof(struct aic7xxx_host),
9217                                     GFP_ATOMIC)) != NULL )
9218         {
9219           memset(temp_p, 0, sizeof(struct aic7xxx_host));
9220           temp_p->chip = aic_pdevs[i].chip | AHC_PCI;
9221           temp_p->flags = aic_pdevs[i].flags;
9222           temp_p->features = aic_pdevs[i].features;
9223           temp_p->board_name_index = aic_pdevs[i].board_name_index;
9224           temp_p->sc_size = aic_pdevs[i].seeprom_size;
9225           temp_p->sc_type = aic_pdevs[i].seeprom_type;
9226
9227           /*
9228            * Read sundry information from PCI BIOS.
9229            */
9230           temp_p->irq = pdev->irq;
9231           temp_p->pdev = pdev;
9232           temp_p->pci_bus = pdev->bus->number;
9233           temp_p->pci_device_fn = pdev->devfn;
9234           temp_p->base = pci_resource_start(pdev, 0);
9235           temp_p->mbase = pci_resource_start(pdev, 1);
9236           current_p = list_p;
9237           while(current_p && temp_p)
9238           {
9239             if ( ((current_p->pci_bus == temp_p->pci_bus) &&
9240                   (current_p->pci_device_fn == temp_p->pci_device_fn)) ||
9241                  (temp_p->base && (current_p->base == temp_p->base)) ||
9242                  (temp_p->mbase && (current_p->mbase == temp_p->mbase)) )
9243             {
9244               /* duplicate PCI entry, skip it */
9245               kfree(temp_p);
9246               continue;
9247             }
9248             current_p = current_p->next;
9249           }
9250           if(pci_request_regions(temp_p->pdev, "aic7xxx"))
9251           {
9252             printk("aic7xxx: <%s> at PCI %d/%d/%d\n",
9253               board_names[aic_pdevs[i].board_name_index],
9254               temp_p->pci_bus,
9255               PCI_SLOT(temp_p->pci_device_fn),
9256               PCI_FUNC(temp_p->pci_device_fn));
9257             printk("aic7xxx: I/O ports already in use, ignoring.\n");
9258             kfree(temp_p);
9259             continue;
9260           }
9261
9262           if (aic7xxx_verbose & VERBOSE_PROBE2)
9263             printk("aic7xxx: <%s> at PCI %d/%d\n",
9264               board_names[aic_pdevs[i].board_name_index],
9265               PCI_SLOT(pdev->devfn),
9266               PCI_FUNC(pdev->devfn));
9267           pci_read_config_word(pdev, PCI_COMMAND, &command);
9268           if (aic7xxx_verbose & VERBOSE_PROBE2)
9269           {
9270             printk("aic7xxx: Initial PCI_COMMAND value was 0x%x\n",
9271               (int)command);
9272           }
9273 #ifdef AIC7XXX_STRICT_PCI_SETUP
9274           command |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY |
9275             PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY | PCI_COMMAND_IO;
9276 #else
9277           command |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY | PCI_COMMAND_IO;
9278 #endif
9279           command &= ~PCI_COMMAND_INVALIDATE;
9280           if (aic7xxx_pci_parity == 0)
9281             command &= ~(PCI_COMMAND_SERR | PCI_COMMAND_PARITY);
9282           pci_write_config_word(pdev, PCI_COMMAND, command);
9283 #ifdef AIC7XXX_STRICT_PCI_SETUP
9284           pci_read_config_dword(pdev, DEVCONFIG, &devconfig);
9285           if (aic7xxx_verbose & VERBOSE_PROBE2)
9286           {
9287             printk("aic7xxx: Initial DEVCONFIG value was 0x%x\n", devconfig);
9288           }
9289           devconfig |= 0x80000040;
9290           pci_write_config_dword(pdev, DEVCONFIG, devconfig);
9291 #endif /* AIC7XXX_STRICT_PCI_SETUP */
9292
9293           temp_p->unpause = INTEN;
9294           temp_p->pause = temp_p->unpause | PAUSE;
9295           if ( ((temp_p->base == 0) &&
9296                 (temp_p->mbase == 0)) ||
9297                (temp_p->irq == 0) )
9298           {
9299             printk("aic7xxx: <%s> at PCI %d/%d/%d\n",
9300               board_names[aic_pdevs[i].board_name_index],
9301               temp_p->pci_bus,
9302               PCI_SLOT(temp_p->pci_device_fn),
9303               PCI_FUNC(temp_p->pci_device_fn));
9304             printk("aic7xxx: Controller disabled by BIOS, ignoring.\n");
9305             goto skip_pci_controller;
9306           }
9307
9308 #ifdef MMAPIO
9309           if ( !(temp_p->base) || !(temp_p->flags & AHC_MULTI_CHANNEL) ||
9310                ((temp_p->chip != (AHC_AIC7870 | AHC_PCI)) &&
9311                 (temp_p->chip != (AHC_AIC7880 | AHC_PCI))) )
9312           {
9313             unsigned long page_offset, base;
9314
9315             base = temp_p->mbase & PAGE_MASK;
9316             page_offset = temp_p->mbase - base;
9317             temp_p->maddr = ioremap_nocache(base, page_offset + 256);
9318             if(temp_p->maddr)
9319             {
9320               temp_p->maddr += page_offset;
9321               /*
9322                * We need to check the I/O with the MMAPed address.  Some machines
9323                * simply fail to work with MMAPed I/O and certain controllers.
9324                */
9325               if(aic_inb(temp_p, HCNTRL) == 0xff)
9326               {
9327                 /*
9328                  * OK.....we failed our test....go back to programmed I/O
9329                  */
9330                 printk(KERN_INFO "aic7xxx: <%s> at PCI %d/%d/%d\n",
9331                   board_names[aic_pdevs[i].board_name_index],
9332                   temp_p->pci_bus,
9333                   PCI_SLOT(temp_p->pci_device_fn),
9334                   PCI_FUNC(temp_p->pci_device_fn));
9335                 printk(KERN_INFO "aic7xxx: MMAPed I/O failed, reverting to "
9336                                  "Programmed I/O.\n");
9337                 iounmap((void *) (((unsigned long) temp_p->maddr) & PAGE_MASK));
9338                 temp_p->maddr = 0;
9339                 if(temp_p->base == 0)
9340                 {
9341                   printk("aic7xxx: <%s> at PCI %d/%d/%d\n",
9342                     board_names[aic_pdevs[i].board_name_index],
9343                     temp_p->pci_bus,
9344                     PCI_SLOT(temp_p->pci_device_fn),
9345                     PCI_FUNC(temp_p->pci_device_fn));
9346                   printk("aic7xxx: Controller disabled by BIOS, ignoring.\n");
9347                   goto skip_pci_controller;
9348                 }
9349               }
9350             }
9351           }
9352 #endif
9353
9354           /*
9355            * We HAVE to make sure the first pause_sequencer() and all other
9356            * subsequent I/O that isn't PCI config space I/O takes place
9357            * after the MMAPed I/O region is configured and tested.  The
9358            * problem is the PowerPC architecture that doesn't support
9359            * programmed I/O at all, so we have to have the MMAP I/O set up
9360            * for this pause to even work on those machines.
9361            */
9362           pause_sequencer(temp_p);
9363
9364           /*
9365            * Clear out any pending PCI error status messages.  Also set
9366            * verbose to 0 so that we don't emit strange PCI error messages
9367            * while cleaning out the current status bits.
9368            */
9369           oldverbose = aic7xxx_verbose;
9370           aic7xxx_verbose = 0;
9371           aic7xxx_pci_intr(temp_p);
9372           aic7xxx_verbose = oldverbose;
9373
9374           temp_p->bios_address = 0;
9375
9376           /*
9377            * Remember how the card was setup in case there is no seeprom.
9378            */
9379           if (temp_p->features & AHC_ULTRA2)
9380             temp_p->scsi_id = aic_inb(temp_p, SCSIID_ULTRA2) & OID;
9381           else
9382             temp_p->scsi_id = aic_inb(temp_p, SCSIID) & OID;
9383           /*
9384            * Get current termination setting
9385            */
9386           sxfrctl1 = aic_inb(temp_p, SXFRCTL1);
9387
9388           if (aic7xxx_chip_reset(temp_p) == -1)
9389           {
9390             goto skip_pci_controller;
9391           }
9392           /*
9393            * Very quickly put the term setting back into the register since
9394            * the chip reset may cause odd things to happen.  This is to keep
9395            * LVD busses with lots of drives from draining the power out of
9396            * the diffsense line before we get around to running the
9397            * configure_termination() function.  Also restore the STPWLEVEL
9398            * bit of DEVCONFIG
9399            */
9400           aic_outb(temp_p, sxfrctl1, SXFRCTL1);
9401           pci_write_config_dword(temp_p->pdev, DEVCONFIG, devconfig);
9402           sxfrctl1 &= STPWEN;
9403
9404           /*
9405            * We need to set the CHNL? assignments before loading the SEEPROM
9406            * The 3940 and 3985 cards (original stuff, not any of the later
9407            * stuff) are 7870 and 7880 class chips.  The Ultra2 stuff falls
9408            * under 7896 and 7897.  The 7895 is in a class by itself :)
9409            */
9410           switch (temp_p->chip & AHC_CHIPID_MASK)
9411           {
9412             case AHC_AIC7870: /* 3840 / 3985 */
9413             case AHC_AIC7880: /* 3840 UW / 3985 UW */
9414               if(temp_p->flags & AHC_MULTI_CHANNEL)
9415               {
9416                 switch(PCI_SLOT(temp_p->pci_device_fn))
9417                 {
9418                   case 5:
9419                     temp_p->flags |= AHC_CHNLB;
9420                     break;
9421                   case 8:
9422                     temp_p->flags |= AHC_CHNLB;
9423                     break;
9424                   case 12:
9425                     temp_p->flags |= AHC_CHNLC;
9426                     break;
9427                   default:
9428                     break;
9429                 }
9430               }
9431               break;
9432
9433             case AHC_AIC7895: /* 7895 */
9434             case AHC_AIC7896: /* 7896/7 */
9435             case AHC_AIC7899: /* 7899 */
9436               if (PCI_FUNC(pdev->devfn) != 0)
9437               {
9438                 temp_p->flags |= AHC_CHNLB;
9439               }
9440               /*
9441                * The 7895 is the only chipset that sets the SCBSIZE32 param
9442                * in the DEVCONFIG register.  The Ultra2 chipsets use
9443                * the DSCOMMAND0 register instead.
9444                */
9445               if ((temp_p->chip & AHC_CHIPID_MASK) == AHC_AIC7895)
9446               {
9447                 pci_read_config_dword(pdev, DEVCONFIG, &devconfig);
9448                 devconfig |= SCBSIZE32;
9449                 pci_write_config_dword(pdev, DEVCONFIG, devconfig);
9450               }
9451               break;
9452             default:
9453               break;
9454           }
9455
9456           /*
9457            * Loading of the SEEPROM needs to come after we've set the flags
9458            * to indicate possible CHNLB and CHNLC assigments.  Otherwise,
9459            * on 394x and 398x cards we'll end up reading the wrong settings
9460            * for channels B and C
9461            */
9462           switch (temp_p->chip & AHC_CHIPID_MASK)
9463           {
9464             case AHC_AIC7892:
9465             case AHC_AIC7899:
9466               aic_outb(temp_p, 0, SCAMCTL);
9467               /*
9468                * Switch to the alt mode of the chip...
9469                */
9470               aic_outb(temp_p, aic_inb(temp_p, SFUNCT) | ALT_MODE, SFUNCT);
9471               /*
9472                * Set our options...the last two items set our CRC after x byte
9473                * count in target mode...
9474                */
9475               aic_outb(temp_p, AUTO_MSGOUT_DE | DIS_MSGIN_DUALEDGE, OPTIONMODE);
9476               aic_outb(temp_p, 0x00, 0x0b);
9477               aic_outb(temp_p, 0x10, 0x0a);
9478               /*
9479                * switch back to normal mode...
9480                */
9481               aic_outb(temp_p, aic_inb(temp_p, SFUNCT) & ~ALT_MODE, SFUNCT);
9482               aic_outb(temp_p, CRCVALCHKEN | CRCENDCHKEN | CRCREQCHKEN |
9483                                TARGCRCENDEN | TARGCRCCNTEN,
9484                        CRCCONTROL1);
9485               aic_outb(temp_p, ((aic_inb(temp_p, DSCOMMAND0) | USCBSIZE32 |
9486                                  MPARCKEN | CIOPARCKEN | CACHETHEN) &
9487                                ~DPARCKEN), DSCOMMAND0);
9488               aic7xxx_load_seeprom(temp_p, &sxfrctl1);
9489               break;
9490             case AHC_AIC7890:
9491             case AHC_AIC7896:
9492               aic_outb(temp_p, 0, SCAMCTL);
9493               aic_outb(temp_p, (aic_inb(temp_p, DSCOMMAND0) |
9494                                 CACHETHEN | MPARCKEN | USCBSIZE32 |
9495                                 CIOPARCKEN) & ~DPARCKEN, DSCOMMAND0);
9496               aic7xxx_load_seeprom(temp_p, &sxfrctl1);
9497               break;
9498             case AHC_AIC7850:
9499             case AHC_AIC7860:
9500               /*
9501                * Set the DSCOMMAND0 register on these cards different from
9502                * on the 789x cards.  Also, read the SEEPROM as well.
9503                */
9504               aic_outb(temp_p, (aic_inb(temp_p, DSCOMMAND0) |
9505                                 CACHETHEN | MPARCKEN) & ~DPARCKEN,
9506                        DSCOMMAND0);
9507               /* FALLTHROUGH */
9508             default:
9509               aic7xxx_load_seeprom(temp_p, &sxfrctl1);
9510               break;
9511             case AHC_AIC7880:
9512               /*
9513                * Check the rev of the chipset before we change DSCOMMAND0
9514                */
9515               pci_read_config_dword(pdev, DEVCONFIG, &devconfig);
9516               if ((devconfig & 0xff) >= 1)
9517               {
9518                 aic_outb(temp_p, (aic_inb(temp_p, DSCOMMAND0) |
9519                                   CACHETHEN | MPARCKEN) & ~DPARCKEN,
9520                          DSCOMMAND0);
9521               }
9522               aic7xxx_load_seeprom(temp_p, &sxfrctl1);
9523               break;
9524           }
9525
9526
9527           /*
9528            * and then we need another switch based on the type in order to
9529            * make sure the channel B primary flag is set properly on 7895
9530            * controllers....Arrrgggghhh!!!  We also have to catch the fact
9531            * that when you disable the BIOS on the 7895 on the Intel DK440LX
9532            * motherboard, and possibly others, it only sets the BIOS disabled
9533            * bit on the A channel...I think I'm starting to lean towards
9534            * going postal....
9535            */
9536           switch(temp_p->chip & AHC_CHIPID_MASK)
9537           {
9538             case AHC_AIC7895:
9539             case AHC_AIC7896:
9540             case AHC_AIC7899:
9541               current_p = list_p;
9542               while(current_p != NULL)
9543               {
9544                 if ( (current_p->pci_bus == temp_p->pci_bus) &&
9545                      (PCI_SLOT(current_p->pci_device_fn) ==
9546                       PCI_SLOT(temp_p->pci_device_fn)) )
9547                 {
9548                   if ( PCI_FUNC(current_p->pci_device_fn) == 0 )
9549                   {
9550                     temp_p->flags |=
9551                       (current_p->flags & AHC_CHANNEL_B_PRIMARY);
9552                     temp_p->flags &= ~(AHC_BIOS_ENABLED|AHC_USEDEFAULTS);
9553                     temp_p->flags |=
9554                       (current_p->flags & (AHC_BIOS_ENABLED|AHC_USEDEFAULTS));
9555                   }
9556                   else
9557                   {
9558                     current_p->flags |=
9559                       (temp_p->flags & AHC_CHANNEL_B_PRIMARY);
9560                     current_p->flags &= ~(AHC_BIOS_ENABLED|AHC_USEDEFAULTS);
9561                     current_p->flags |=
9562                       (temp_p->flags & (AHC_BIOS_ENABLED|AHC_USEDEFAULTS));
9563                   }
9564                 }
9565                 current_p = current_p->next;
9566               }
9567               break;
9568             default:
9569               break;
9570           }
9571
9572           /*
9573            * We only support external SCB RAM on the 7895/6/7 chipsets.
9574            * We could support it on the 7890/1 easy enough, but I don't
9575            * know of any 7890/1 based cards that have it.  I do know
9576            * of 7895/6/7 cards that have it and they work properly.
9577            */
9578           switch(temp_p->chip & AHC_CHIPID_MASK)
9579           {
9580             default:
9581               break;
9582             case AHC_AIC7895:
9583             case AHC_AIC7896:
9584             case AHC_AIC7899:
9585               pci_read_config_dword(pdev, DEVCONFIG, &devconfig);
9586               if (temp_p->features & AHC_ULTRA2)
9587               {
9588                 if ( (aic_inb(temp_p, DSCOMMAND0) & RAMPSM_ULTRA2) &&
9589                      (aic7xxx_scbram) )
9590                 {
9591                   aic_outb(temp_p,
9592                            aic_inb(temp_p, DSCOMMAND0) & ~SCBRAMSEL_ULTRA2,
9593                            DSCOMMAND0);
9594                   temp_p->flags |= AHC_EXTERNAL_SRAM;
9595                   devconfig |= EXTSCBPEN;
9596                 }
9597                 else if (aic_inb(temp_p, DSCOMMAND0) & RAMPSM_ULTRA2)
9598                 {
9599                   printk(KERN_INFO "aic7xxx: <%s> at PCI %d/%d/%d\n",
9600                     board_names[aic_pdevs[i].board_name_index],
9601                     temp_p->pci_bus,
9602                     PCI_SLOT(temp_p->pci_device_fn),
9603                     PCI_FUNC(temp_p->pci_device_fn));
9604                   printk("aic7xxx: external SCB RAM detected, "
9605                          "but not enabled\n");
9606                 }
9607               }
9608               else
9609               {
9610                 if ((devconfig & RAMPSM) && (aic7xxx_scbram))
9611                 {
9612                   devconfig &= ~SCBRAMSEL;
9613                   devconfig |= EXTSCBPEN;
9614                   temp_p->flags |= AHC_EXTERNAL_SRAM;
9615                 }
9616                 else if (devconfig & RAMPSM)
9617                 {
9618                   printk(KERN_INFO "aic7xxx: <%s> at PCI %d/%d/%d\n",
9619                     board_names[aic_pdevs[i].board_name_index],
9620                     temp_p->pci_bus,
9621                     PCI_SLOT(temp_p->pci_device_fn),
9622                     PCI_FUNC(temp_p->pci_device_fn));
9623                   printk("aic7xxx: external SCB RAM detected, "
9624                          "but not enabled\n");
9625                 }
9626               }
9627               pci_write_config_dword(pdev, DEVCONFIG, devconfig);
9628               if ( (temp_p->flags & AHC_EXTERNAL_SRAM) &&
9629                    (temp_p->flags & AHC_CHNLB) )
9630                 aic_outb(temp_p, 1, CCSCBBADDR);
9631               break;
9632           }
9633
9634           /*
9635            * Take the LED out of diagnostic mode
9636            */
9637           aic_outb(temp_p,
9638             (aic_inb(temp_p, SBLKCTL) & ~(DIAGLEDEN | DIAGLEDON)),
9639             SBLKCTL);
9640
9641           /*
9642            * We don't know where this is set in the SEEPROM or by the
9643            * BIOS, so we default to 100%.  On Ultra2 controllers, use 75%
9644            * instead.
9645            */
9646           if (temp_p->features & AHC_ULTRA2)
9647           {
9648             aic_outb(temp_p, RD_DFTHRSH_MAX | WR_DFTHRSH_MAX, DFF_THRSH);
9649           }
9650           else
9651           {
9652             aic_outb(temp_p, DFTHRSH_100, DSPCISTATUS);
9653           }
9654
9655           /*
9656            * Call our function to fixup any bugs that exist on this chipset.
9657            * This may muck with PCI settings and other device settings, so
9658            * make sure it's after all the other PCI and device register
9659            * tweaks so it can back out bad settings on specific broken cards.
9660            */
9661           aic7xxx_configure_bugs(temp_p);
9662
9663           if ( list_p == NULL )
9664           {
9665             list_p = current_p = temp_p;
9666           }
9667           else
9668           {
9669             current_p = list_p;
9670             while(current_p->next != NULL)
9671               current_p = current_p->next;
9672             current_p->next = temp_p;
9673           }
9674           temp_p->next = NULL;
9675           found++;
9676           continue;
9677 skip_pci_controller:
9678 #ifdef CONFIG_PCI
9679           pci_release_regions(temp_p->pdev);
9680 #endif
9681           kfree(temp_p);
9682         }  /* Found an Adaptec PCI device. */
9683         else /* Well, we found one, but we couldn't get any memory */
9684         {
9685           printk("aic7xxx: Found <%s>\n",
9686             board_names[aic_pdevs[i].board_name_index]);
9687           printk(KERN_INFO "aic7xxx: Unable to allocate device memory, "
9688             "skipping.\n");
9689         }
9690       } /* while(pdev=....) */
9691     } /* for PCI_DEVICES */
9692   }
9693 #endif /* CONFIG_PCI */
9694
9695 #if defined(__i386__) || defined(__alpha__)
9696   /*
9697    * EISA/VL-bus card signature probe.
9698    */
9699   slot = MINSLOT;
9700   while ( (slot <= MAXSLOT) &&
9701          !(aic7xxx_no_probe) )
9702   {
9703     base = SLOTBASE(slot) + MINREG;
9704
9705     if (!request_region(base, MAXREG - MINREG, "aic7xxx"))
9706     {
9707       /*
9708        * Some other driver has staked a
9709        * claim to this i/o region already.
9710        */
9711       slot++;
9712       continue; /* back to the beginning of the for loop */
9713     }
9714     flags = 0;
9715     type = aic7xxx_probe(slot, base + AHC_HID0, &flags);
9716     if (type == -1)
9717     {
9718       release_region(base, MAXREG - MINREG);
9719       slot++;
9720       continue;
9721     }
9722     temp_p = kmalloc(sizeof(struct aic7xxx_host), GFP_ATOMIC);
9723     if (temp_p == NULL)
9724     {
9725       printk(KERN_WARNING "aic7xxx: Unable to allocate device space.\n");
9726       release_region(base, MAXREG - MINREG);
9727       slot++;
9728       continue; /* back to the beginning of the while loop */
9729     }
9730
9731     /*
9732      * Pause the card preserving the IRQ type.  Allow the operator
9733      * to override the IRQ trigger.
9734      */
9735     if (aic7xxx_irq_trigger == 1)
9736       hcntrl = IRQMS;  /* Level */
9737     else if (aic7xxx_irq_trigger == 0)
9738       hcntrl = 0;  /* Edge */
9739     else
9740       hcntrl = inb(base + HCNTRL) & IRQMS;  /* Default */
9741     memset(temp_p, 0, sizeof(struct aic7xxx_host));
9742     temp_p->unpause = hcntrl | INTEN;
9743     temp_p->pause = hcntrl | PAUSE | INTEN;
9744     temp_p->base = base;
9745     temp_p->mbase = 0;
9746     temp_p->maddr = 0;
9747     temp_p->pci_bus = 0;
9748     temp_p->pci_device_fn = slot;
9749     aic_outb(temp_p, hcntrl | PAUSE, HCNTRL);
9750     while( (aic_inb(temp_p, HCNTRL) & PAUSE) == 0 ) ;
9751     if (aic7xxx_chip_reset(temp_p) == -1)
9752       temp_p->irq = 0;
9753     else
9754       temp_p->irq = aic_inb(temp_p, INTDEF) & 0x0F;
9755     temp_p->flags |= AHC_PAGESCBS;
9756
9757     switch (temp_p->irq)
9758     {
9759       case 9:
9760       case 10:
9761       case 11:
9762       case 12:
9763       case 14:
9764       case 15:
9765         break;
9766
9767       default:
9768         printk(KERN_WARNING "aic7xxx: Host adapter uses unsupported IRQ "
9769           "level %d, ignoring.\n", temp_p->irq);
9770         kfree(temp_p);
9771         release_region(base, MAXREG - MINREG);
9772         slot++;
9773         continue; /* back to the beginning of the while loop */
9774     }
9775
9776     /*
9777      * We are commited now, everything has been checked and this card
9778      * has been found, now we just set it up
9779      */
9780
9781     /*
9782      * Insert our new struct into the list at the end
9783      */
9784     if (list_p == NULL)
9785     {
9786       list_p = current_p = temp_p;
9787     }
9788     else
9789     {
9790       current_p = list_p;
9791       while (current_p->next != NULL)
9792         current_p = current_p->next;
9793       current_p->next = temp_p;
9794     }
9795
9796     switch (type)
9797     {
9798       case 0:
9799         temp_p->board_name_index = 2;
9800         if (aic7xxx_verbose & VERBOSE_PROBE2)
9801           printk("aic7xxx: <%s> at EISA %d\n",
9802                board_names[2], slot);
9803         /* FALLTHROUGH */
9804       case 1:
9805       {
9806         temp_p->chip = AHC_AIC7770 | AHC_EISA;
9807         temp_p->features |= AHC_AIC7770_FE;
9808         temp_p->bios_control = aic_inb(temp_p, HA_274_BIOSCTRL);
9809
9810         /*
9811          * Get the primary channel information.  Right now we don't
9812          * do anything with this, but someday we will be able to inform
9813          * the mid-level SCSI code which channel is primary.
9814          */
9815         if (temp_p->board_name_index == 0)
9816         {
9817           temp_p->board_name_index = 3;
9818           if (aic7xxx_verbose & VERBOSE_PROBE2)
9819             printk("aic7xxx: <%s> at EISA %d\n",
9820                  board_names[3], slot);
9821         }
9822         if (temp_p->bios_control & CHANNEL_B_PRIMARY)
9823         {
9824           temp_p->flags |= AHC_CHANNEL_B_PRIMARY;
9825         }
9826
9827         if ((temp_p->bios_control & BIOSMODE) == BIOSDISABLED)
9828         {
9829           temp_p->flags &= ~AHC_BIOS_ENABLED;
9830         }
9831         else
9832         {
9833           temp_p->flags &= ~AHC_USEDEFAULTS;
9834           temp_p->flags |= AHC_BIOS_ENABLED;
9835           if ( (temp_p->bios_control & 0x20) == 0 )
9836           {
9837             temp_p->bios_address = 0xcc000;
9838             temp_p->bios_address += (0x4000 * (temp_p->bios_control & 0x07));
9839           }
9840           else
9841           {
9842             temp_p->bios_address = 0xd0000;
9843             temp_p->bios_address += (0x8000 * (temp_p->bios_control & 0x06));
9844           }
9845         }
9846         temp_p->adapter_control = aic_inb(temp_p, SCSICONF) << 8;
9847         temp_p->adapter_control |= aic_inb(temp_p, SCSICONF + 1);
9848         if (temp_p->features & AHC_WIDE)
9849         {
9850           temp_p->scsi_id = temp_p->adapter_control & HWSCSIID;
9851           temp_p->scsi_id_b = temp_p->scsi_id;
9852         }
9853         else
9854         {
9855           temp_p->scsi_id = (temp_p->adapter_control >> 8) & HSCSIID;
9856           temp_p->scsi_id_b = temp_p->adapter_control & HSCSIID;
9857         }
9858         aic7xxx_load_seeprom(temp_p, &sxfrctl1);
9859         break;
9860       }
9861
9862       case 2:
9863       case 3:
9864         temp_p->chip = AHC_AIC7770 | AHC_VL;
9865         temp_p->features |= AHC_AIC7770_FE;
9866         if (type == 2)
9867           temp_p->flags |= AHC_BIOS_ENABLED;
9868         else
9869           temp_p->flags &= ~AHC_BIOS_ENABLED;
9870         if (aic_inb(temp_p, SCSICONF) & TERM_ENB)
9871           sxfrctl1 = STPWEN;
9872         aic7xxx_load_seeprom(temp_p, &sxfrctl1);
9873         temp_p->board_name_index = 4;
9874         if (aic7xxx_verbose & VERBOSE_PROBE2)
9875           printk("aic7xxx: <%s> at VLB %d\n",
9876                board_names[2], slot);
9877         switch( aic_inb(temp_p, STATUS_2840) & BIOS_SEL )
9878         {
9879           case 0x00:
9880             temp_p->bios_address = 0xe0000;
9881             break;
9882           case 0x20:
9883             temp_p->bios_address = 0xc8000;
9884             break;
9885           case 0x40:
9886             temp_p->bios_address = 0xd0000;
9887             break;
9888           case 0x60:
9889             temp_p->bios_address = 0xd8000;
9890             break;
9891           default:
9892             break; /* can't get here */
9893         }
9894         break;
9895
9896       default:  /* Won't get here. */
9897         break;
9898     }
9899     if (aic7xxx_verbose & VERBOSE_PROBE2)
9900     {
9901       printk(KERN_INFO "aic7xxx: BIOS %sabled, IO Port 0x%lx, IRQ %d (%s)\n",
9902         (temp_p->flags & AHC_USEDEFAULTS) ? "dis" : "en", temp_p->base,
9903         temp_p->irq,
9904         (temp_p->pause & IRQMS) ? "level sensitive" : "edge triggered");
9905       printk(KERN_INFO "aic7xxx: Extended translation %sabled.\n",
9906              (temp_p->flags & AHC_EXTEND_TRANS_A) ? "en" : "dis");
9907     }
9908
9909     /*
9910      * All the 7770 based chipsets have this bug
9911      */
9912     temp_p->bugs |= AHC_BUG_TMODE_WIDEODD;
9913
9914     /*
9915      * Set the FIFO threshold and the bus off time.
9916      */
9917     hostconf = aic_inb(temp_p, HOSTCONF);
9918     aic_outb(temp_p, hostconf & DFTHRSH, BUSSPD);
9919     aic_outb(temp_p, (hostconf << 2) & BOFF, BUSTIME);
9920     slot++;
9921     found++;
9922   }
9923
9924 #endif /* defined(__i386__) || defined(__alpha__) */
9925
9926   /*
9927    * Now, we re-order the probed devices by BIOS address and BUS class.
9928    * In general, we follow this algorithm to make the adapters show up
9929    * in the same order under linux that the computer finds them.
9930    *  1: All VLB/EISA cards with BIOS_ENABLED first, according to BIOS
9931    *     address, going from lowest to highest.
9932    *  2: All PCI controllers with BIOS_ENABLED next, according to BIOS
9933    *     address, going from lowest to highest.
9934    *  3: Remaining VLB/EISA controllers going in slot order.
9935    *  4: Remaining PCI controllers, going in PCI device order (reversable)
9936    */
9937
9938   {
9939     struct aic7xxx_host *sort_list[4] = { NULL, NULL, NULL, NULL };
9940     struct aic7xxx_host *vlb, *pci;
9941     struct aic7xxx_host *prev_p;
9942     struct aic7xxx_host *p;
9943     unsigned char left;
9944
9945     prev_p = vlb = pci = NULL;
9946
9947     temp_p = list_p;
9948     while (temp_p != NULL)
9949     {
9950       switch(temp_p->chip & ~AHC_CHIPID_MASK)
9951       {
9952         case AHC_EISA:
9953         case AHC_VL:
9954         {
9955           p = temp_p;
9956           if (p->flags & AHC_BIOS_ENABLED)
9957             vlb = sort_list[0];
9958           else
9959             vlb = sort_list[2];
9960
9961           if (vlb == NULL)
9962           {
9963             vlb = temp_p;
9964             temp_p = temp_p->next;
9965             vlb->next = NULL;
9966           }
9967           else
9968           {
9969             current_p = vlb;
9970             prev_p = NULL;
9971             while ( (current_p != NULL) &&
9972                     (current_p->bios_address < temp_p->bios_address))
9973             {
9974               prev_p = current_p;
9975               current_p = current_p->next;
9976             }
9977             if (prev_p != NULL)
9978             {
9979               prev_p->next = temp_p;
9980               temp_p = temp_p->next;
9981               prev_p->next->next = current_p;
9982             }
9983             else
9984             {
9985               vlb = temp_p;
9986               temp_p = temp_p->next;
9987               vlb->next = current_p;
9988             }
9989           }
9990
9991           if (p->flags & AHC_BIOS_ENABLED)
9992             sort_list[0] = vlb;
9993           else
9994             sort_list[2] = vlb;
9995
9996           break;
9997         }
9998         default:  /* All PCI controllers fall through to default */
9999         {
10000
10001           p = temp_p;
10002           if (p->flags & AHC_BIOS_ENABLED)
10003             pci = sort_list[1];
10004           else
10005             pci = sort_list[3];
10006
10007           if (pci == NULL)
10008           {
10009             pci = temp_p;
10010             temp_p = temp_p->next;
10011             pci->next = NULL;
10012           }
10013           else
10014           {
10015             current_p = pci;
10016             prev_p = NULL;
10017             if (!aic7xxx_reverse_scan)
10018             {
10019               while ( (current_p != NULL) &&
10020                       ( (PCI_SLOT(current_p->pci_device_fn) |
10021                         (current_p->pci_bus << 8)) <
10022                         (PCI_SLOT(temp_p->pci_device_fn) |
10023                         (temp_p->pci_bus << 8)) ) )
10024               {
10025                 prev_p = current_p;
10026                 current_p = current_p->next;
10027               }
10028             }
10029             else
10030             {
10031               while ( (current_p != NULL) &&
10032                       ( (PCI_SLOT(current_p->pci_device_fn) |
10033                         (current_p->pci_bus << 8)) >
10034                         (PCI_SLOT(temp_p->pci_device_fn) |
10035                         (temp_p->pci_bus << 8)) ) )
10036               {
10037                 prev_p = current_p;
10038                 current_p = current_p->next;
10039               }
10040             }
10041             /*
10042              * Are we dealing with a 7895/6/7/9 where we need to sort the
10043              * channels as well, if so, the bios_address values should
10044              * be the same
10045              */
10046             if ( (current_p) && (temp_p->flags & AHC_MULTI_CHANNEL) &&
10047                  (temp_p->pci_bus == current_p->pci_bus) &&
10048                  (PCI_SLOT(temp_p->pci_device_fn) ==
10049                   PCI_SLOT(current_p->pci_device_fn)) )
10050             {
10051               if (temp_p->flags & AHC_CHNLB)
10052               {
10053                 if ( !(temp_p->flags & AHC_CHANNEL_B_PRIMARY) )
10054                 {
10055                   prev_p = current_p;
10056                   current_p = current_p->next;
10057                 }
10058               }
10059               else
10060               {
10061                 if (temp_p->flags & AHC_CHANNEL_B_PRIMARY)
10062                 {
10063                   prev_p = current_p;
10064                   current_p = current_p->next;
10065                 }
10066               }
10067             }
10068             if (prev_p != NULL)
10069             {
10070               prev_p->next = temp_p;
10071               temp_p = temp_p->next;
10072               prev_p->next->next = current_p;
10073             }
10074             else
10075             {
10076               pci = temp_p;
10077               temp_p = temp_p->next;
10078               pci->next = current_p;
10079             }
10080           }
10081
10082           if (p->flags & AHC_BIOS_ENABLED)
10083             sort_list[1] = pci;
10084           else
10085             sort_list[3] = pci;
10086
10087           break;
10088         }
10089       }  /* End of switch(temp_p->type) */
10090     } /* End of while (temp_p != NULL) */
10091     /*
10092      * At this point, the cards have been broken into 4 sorted lists, now
10093      * we run through the lists in order and register each controller
10094      */
10095     {
10096       int i;
10097
10098       left = found;
10099       for (i=0; i<ARRAY_SIZE(sort_list); i++)
10100       {
10101         temp_p = sort_list[i];
10102         while(temp_p != NULL)
10103         {
10104           template->name = board_names[temp_p->board_name_index];
10105           p = aic7xxx_alloc(template, temp_p);
10106           if (p != NULL)
10107           {
10108             p->instance = found - left;
10109             if (aic7xxx_register(template, p, (--left)) == 0)
10110             {
10111               found--;
10112               aic7xxx_release(p->host);
10113               scsi_unregister(p->host);
10114             }
10115             else if (aic7xxx_dump_card)
10116             {
10117               pause_sequencer(p);
10118               aic7xxx_print_card(p);
10119               aic7xxx_print_scratch_ram(p);
10120               unpause_sequencer(p, TRUE);
10121             }
10122           }
10123           current_p = temp_p;
10124           temp_p = (struct aic7xxx_host *)temp_p->next;
10125           kfree(current_p);
10126         }
10127       }
10128     }
10129   }
10130   return (found);
10131 }
10132
10133 /*+F*************************************************************************
10134  * Function:
10135  *   aic7xxx_buildscb
10136  *
10137  * Description:
10138  *   Build a SCB.
10139  *-F*************************************************************************/
10140 static void
10141 aic7xxx_buildscb(struct aic7xxx_host *p, Scsi_Cmnd *cmd,
10142     struct aic7xxx_scb *scb)
10143 {
10144   unsigned short mask;
10145   struct aic7xxx_hwscb *hscb;
10146   struct aic_dev_data *aic_dev = cmd->device->hostdata;
10147   struct scsi_device *sdptr = cmd->device;
10148   unsigned char tindex = TARGET_INDEX(cmd);
10149   struct request *req = cmd->request;
10150
10151   mask = (0x01 << tindex);
10152   hscb = scb->hscb;
10153
10154   /*
10155    * Setup the control byte if we need negotiation and have not
10156    * already requested it.
10157    */
10158   hscb->control = 0;
10159   scb->tag_action = 0;
10160
10161   if (p->discenable & mask)
10162   {
10163     hscb->control |= DISCENB;
10164     /* We always force TEST_UNIT_READY to untagged */
10165     if (cmd->cmnd[0] != TEST_UNIT_READY && sdptr->simple_tags)
10166     {
10167       if (req->flags & REQ_HARDBARRIER)
10168       {
10169         if(sdptr->ordered_tags)
10170         {
10171           hscb->control |= MSG_ORDERED_Q_TAG;
10172           scb->tag_action = MSG_ORDERED_Q_TAG;
10173         }
10174       }
10175       else
10176       {
10177         hscb->control |= MSG_SIMPLE_Q_TAG;
10178         scb->tag_action = MSG_SIMPLE_Q_TAG;
10179       }
10180     }
10181   }
10182   if ( !(aic_dev->dtr_pending) &&
10183         (aic_dev->needppr || aic_dev->needwdtr || aic_dev->needsdtr) &&
10184         (aic_dev->flags & DEVICE_DTR_SCANNED) )
10185   {
10186     aic_dev->dtr_pending = 1;
10187     scb->tag_action = 0;
10188     hscb->control &= DISCENB;
10189     hscb->control |= MK_MESSAGE;
10190     if(aic_dev->needppr)
10191     {
10192       scb->flags |= SCB_MSGOUT_PPR;
10193     }
10194     else if(aic_dev->needwdtr)
10195     {
10196       scb->flags |= SCB_MSGOUT_WDTR;
10197     }
10198     else if(aic_dev->needsdtr)
10199     {
10200       scb->flags |= SCB_MSGOUT_SDTR;
10201     }
10202     scb->flags |= SCB_DTR_SCB;
10203   }
10204   hscb->target_channel_lun = ((cmd->device->id << 4) & 0xF0) |
10205         ((cmd->device->channel & 0x01) << 3) | (cmd->device->lun & 0x07);
10206
10207   /*
10208    * The interpretation of request_buffer and request_bufflen
10209    * changes depending on whether or not use_sg is zero; a
10210    * non-zero use_sg indicates the number of elements in the
10211    * scatter-gather array.
10212    */
10213
10214   /*
10215    * XXX - this relies on the host data being stored in a
10216    *       little-endian format.
10217    */
10218   hscb->SCSI_cmd_length = cmd->cmd_len;
10219   memcpy(scb->cmnd, cmd->cmnd, cmd->cmd_len);
10220   hscb->SCSI_cmd_pointer = cpu_to_le32(SCB_DMA_ADDR(scb, scb->cmnd));
10221
10222   if (cmd->use_sg)
10223   {
10224     struct scatterlist *sg;  /* Must be mid-level SCSI code scatterlist */
10225
10226     /*
10227      * We must build an SG list in adapter format, as the kernel's SG list
10228      * cannot be used directly because of data field size (__alpha__)
10229      * differences and the kernel SG list uses virtual addresses where
10230      * we need physical addresses.
10231      */
10232     int i, use_sg;
10233
10234     sg = (struct scatterlist *)cmd->request_buffer;
10235     scb->sg_length = 0;
10236     use_sg = pci_map_sg(p->pdev, sg, cmd->use_sg, scsi_to_pci_dma_dir(cmd->sc_data_direction));
10237     /*
10238      * Copy the segments into the SG array.  NOTE!!! - We used to
10239      * have the first entry both in the data_pointer area and the first
10240      * SG element.  That has changed somewhat.  We still have the first
10241      * entry in both places, but now we download the address of
10242      * scb->sg_list[1] instead of 0 to the sg pointer in the hscb.
10243      */
10244     for (i = 0; i < use_sg; i++)
10245     {
10246       unsigned int len = sg_dma_len(sg+i);
10247       scb->sg_list[i].address = cpu_to_le32(sg_dma_address(sg+i));
10248       scb->sg_list[i].length = cpu_to_le32(len);
10249       scb->sg_length += len;
10250     }
10251     /* Copy the first SG into the data pointer area. */
10252     hscb->data_pointer = scb->sg_list[0].address;
10253     hscb->data_count = scb->sg_list[0].length;
10254     scb->sg_count = i;
10255     hscb->SG_segment_count = i;
10256     hscb->SG_list_pointer = cpu_to_le32(SCB_DMA_ADDR(scb, &scb->sg_list[1]));
10257   }
10258   else
10259   {
10260     if (cmd->request_bufflen)
10261     {
10262       unsigned int address = pci_map_single(p->pdev, cmd->request_buffer,
10263                                             cmd->request_bufflen,
10264                                             scsi_to_pci_dma_dir(cmd->sc_data_direction));
10265       aic7xxx_mapping(cmd) = address;
10266       scb->sg_list[0].address = cpu_to_le32(address);
10267       scb->sg_list[0].length = cpu_to_le32(cmd->request_bufflen);
10268       scb->sg_count = 1;
10269       scb->sg_length = cmd->request_bufflen;
10270       hscb->SG_segment_count = 1;
10271       hscb->SG_list_pointer = cpu_to_le32(SCB_DMA_ADDR(scb, &scb->sg_list[0]));
10272       hscb->data_count = scb->sg_list[0].length;
10273       hscb->data_pointer = scb->sg_list[0].address;
10274     }
10275     else
10276     {
10277       scb->sg_count = 0;
10278       scb->sg_length = 0;
10279       hscb->SG_segment_count = 0;
10280       hscb->SG_list_pointer = 0;
10281       hscb->data_count = 0;
10282       hscb->data_pointer = 0;
10283     }
10284   }
10285 }
10286
10287 /*+F*************************************************************************
10288  * Function:
10289  *   aic7xxx_queue
10290  *
10291  * Description:
10292  *   Queue a SCB to the controller.
10293  *-F*************************************************************************/
10294 static int
10295 aic7xxx_queue(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
10296 {
10297   struct aic7xxx_host *p;
10298   struct aic7xxx_scb *scb;
10299   struct aic_dev_data *aic_dev;
10300
10301   p = (struct aic7xxx_host *) cmd->device->host->hostdata;
10302
10303   aic_dev = cmd->device->hostdata;
10304 #ifdef AIC7XXX_VERBOSE_DEBUGGING
10305   if (aic_dev->active_cmds > aic_dev->max_q_depth)
10306   {
10307     printk(WARN_LEAD "Commands queued exceeds queue "
10308            "depth, active=%d\n",
10309            p->host_no, CTL_OF_CMD(cmd),
10310            aic_dev->active_cmds);
10311   }
10312 #endif
10313
10314   scb = scbq_remove_head(&p->scb_data->free_scbs);
10315   if (scb == NULL)
10316   {
10317     aic7xxx_allocate_scb(p);
10318     scb = scbq_remove_head(&p->scb_data->free_scbs);
10319     if(scb == NULL)
10320     {
10321       printk(WARN_LEAD "Couldn't get a free SCB.\n", p->host_no,
10322              CTL_OF_CMD(cmd));
10323       return 1;
10324     }
10325   }
10326   scb->cmd = cmd;
10327
10328   /*
10329    * Make sure the Scsi_Cmnd pointer is saved, the struct it points to
10330    * is set up properly, and the parity error flag is reset, then send
10331    * the SCB to the sequencer and watch the fun begin.
10332    */
10333   aic7xxx_position(cmd) = scb->hscb->tag;
10334   cmd->scsi_done = fn;
10335   cmd->result = DID_OK;
10336   memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
10337   aic7xxx_error(cmd) = DID_OK;
10338   aic7xxx_status(cmd) = 0;
10339   cmd->host_scribble = NULL;
10340
10341   /*
10342    * Construct the SCB beforehand, so the sequencer is
10343    * paused a minimal amount of time.
10344    */
10345   aic7xxx_buildscb(p, cmd, scb);
10346
10347   scb->flags |= SCB_ACTIVE | SCB_WAITINGQ;
10348
10349   scbq_insert_tail(&p->waiting_scbs, scb);
10350   aic7xxx_run_waiting_queues(p);
10351   return (0);
10352 }
10353
10354 /*+F*************************************************************************
10355  * Function:
10356  *   aic7xxx_bus_device_reset
10357  *
10358  * Description:
10359  *   Abort or reset the current SCSI command(s).  If the scb has not
10360  *   previously been aborted, then we attempt to send a BUS_DEVICE_RESET
10361  *   message to the target.  If the scb has previously been unsuccessfully
10362  *   aborted, then we will reset the channel and have all devices renegotiate.
10363  *   Returns an enumerated type that indicates the status of the operation.
10364  *-F*************************************************************************/
10365 static int
10366 aic7xxx_bus_device_reset(Scsi_Cmnd *cmd)
10367 {
10368   struct aic7xxx_host  *p;
10369   struct aic7xxx_scb   *scb;
10370   struct aic7xxx_hwscb *hscb;
10371   int channel;
10372   unsigned char saved_scbptr, lastphase;
10373   unsigned char hscb_index;
10374   int disconnected;
10375   struct aic_dev_data *aic_dev;
10376
10377   if(cmd == NULL)
10378   {
10379     printk(KERN_ERR "aic7xxx_bus_device_reset: called with NULL cmd!\n");
10380     return FAILED;
10381   }
10382   p = (struct aic7xxx_host *)cmd->device->host->hostdata;
10383   aic_dev = AIC_DEV(cmd);
10384   if(aic7xxx_position(cmd) < p->scb_data->numscbs)
10385     scb = (p->scb_data->scb_array[aic7xxx_position(cmd)]);
10386   else
10387     return FAILED;
10388
10389   hscb = scb->hscb;
10390
10391   aic7xxx_isr(p->irq, (void *)p, NULL);
10392   aic7xxx_done_cmds_complete(p);
10393   /* If the command was already complete or just completed, then we didn't
10394    * do a reset, return FAILED */
10395   if(!(scb->flags & SCB_ACTIVE))
10396     return FAILED;
10397
10398   pause_sequencer(p);
10399   lastphase = aic_inb(p, LASTPHASE);
10400   if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
10401   {
10402     printk(INFO_LEAD "Bus Device reset, scb flags 0x%x, ",
10403          p->host_no, CTL_OF_SCB(scb), scb->flags);
10404     switch (lastphase)
10405     {
10406       case P_DATAOUT:
10407         printk("Data-Out phase\n");
10408         break;
10409       case P_DATAIN:
10410         printk("Data-In phase\n");
10411         break;
10412       case P_COMMAND:
10413         printk("Command phase\n");
10414         break;
10415       case P_MESGOUT:
10416         printk("Message-Out phase\n");
10417         break;
10418       case P_STATUS:
10419         printk("Status phase\n");
10420         break;
10421       case P_MESGIN:
10422         printk("Message-In phase\n");
10423         break;
10424       default:
10425       /*
10426        * We're not in a valid phase, so assume we're idle.
10427        */
10428         printk("while idle, LASTPHASE = 0x%x\n", lastphase);
10429         break;
10430     }
10431     printk(INFO_LEAD "SCSISIGI 0x%x, SEQADDR 0x%x, SSTAT0 0x%x, SSTAT1 "
10432          "0x%x\n", p->host_no, CTL_OF_SCB(scb),
10433          aic_inb(p, SCSISIGI),
10434          aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
10435          aic_inb(p, SSTAT0), aic_inb(p, SSTAT1));
10436     printk(INFO_LEAD "SG_CACHEPTR 0x%x, SSTAT2 0x%x, STCNT 0x%x\n", p->host_no,
10437          CTL_OF_SCB(scb),
10438          (p->features & AHC_ULTRA2) ? aic_inb(p, SG_CACHEPTR) : 0,
10439          aic_inb(p, SSTAT2),
10440          aic_inb(p, STCNT + 2) << 16 | aic_inb(p, STCNT + 1) << 8 |
10441          aic_inb(p, STCNT));
10442   }
10443
10444   channel = cmd->device->channel;
10445
10446     /*
10447      * Send a Device Reset Message:
10448      * The target that is holding up the bus may not be the same as
10449      * the one that triggered this timeout (different commands have
10450      * different timeout lengths).  Our strategy here is to queue an
10451      * abort message to the timed out target if it is disconnected.
10452      * Otherwise, if we have an active target we stuff the message buffer
10453      * with an abort message and assert ATN in the hopes that the target
10454      * will let go of the bus and go to the mesgout phase.  If this
10455      * fails, we'll get another timeout a few seconds later which will
10456      * attempt a bus reset.
10457      */
10458   saved_scbptr = aic_inb(p, SCBPTR);
10459   disconnected = FALSE;
10460
10461   if (lastphase != P_BUSFREE)
10462   {
10463     if (aic_inb(p, SCB_TAG) >= p->scb_data->numscbs)
10464     {
10465       printk(WARN_LEAD "Invalid SCB ID %d is active, "
10466              "SCB flags = 0x%x.\n", p->host_no,
10467             CTL_OF_CMD(cmd), scb->hscb->tag, scb->flags);
10468       unpause_sequencer(p, FALSE);
10469       return FAILED;
10470     }
10471     if (scb->hscb->tag == aic_inb(p, SCB_TAG))
10472     {
10473       if ( (lastphase == P_MESGOUT) || (lastphase == P_MESGIN) )
10474       {
10475         printk(WARN_LEAD "Device reset, Message buffer "
10476                 "in use\n", p->host_no, CTL_OF_SCB(scb));
10477         unpause_sequencer(p, FALSE);
10478         return FAILED;
10479       }
10480
10481       if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
10482         printk(INFO_LEAD "Device reset message in "
10483               "message buffer\n", p->host_no, CTL_OF_SCB(scb));
10484       scb->flags |= SCB_RESET | SCB_DEVICE_RESET;
10485       aic7xxx_error(cmd) = DID_RESET;
10486       aic_dev->flags |= BUS_DEVICE_RESET_PENDING;
10487       /* Send the abort message to the active SCB. */
10488       aic_outb(p, HOST_MSG, MSG_OUT);
10489       aic_outb(p, lastphase | ATNO, SCSISIGO);
10490       unpause_sequencer(p, FALSE);
10491       spin_unlock_irq(p->host->host_lock);
10492       scsi_sleep(HZ);
10493       spin_lock_irq(p->host->host_lock);
10494       if(aic_dev->flags & BUS_DEVICE_RESET_PENDING)
10495         return FAILED;
10496       else
10497         return SUCCESS;
10498     }
10499   } /* if (last_phase != P_BUSFREE).....indicates we are idle and can work */
10500   /*
10501    * Simply set the MK_MESSAGE flag and the SEQINT handler will do
10502    * the rest on a reconnect/connect.
10503    */
10504   scb->hscb->control |= MK_MESSAGE;
10505   scb->flags |= SCB_RESET | SCB_DEVICE_RESET;
10506   aic_dev->flags |= BUS_DEVICE_RESET_PENDING;
10507   /*
10508    * Check to see if the command is on the qinfifo.  If it is, then we will
10509    * not need to queue the command again since the card should start it soon
10510    */
10511   if (aic7xxx_search_qinfifo(p, cmd->device->channel, cmd->device->id, cmd->device->lun, hscb->tag,
10512                           0, TRUE, NULL) == 0)
10513   {
10514     disconnected = TRUE;
10515     if ((hscb_index = aic7xxx_find_scb(p, scb)) != SCB_LIST_NULL)
10516     {
10517       unsigned char scb_control;
10518
10519       aic_outb(p, hscb_index, SCBPTR);
10520       scb_control = aic_inb(p, SCB_CONTROL);
10521       /*
10522        * If the DISCONNECTED bit is not set in SCB_CONTROL, then we are
10523        * actually on the waiting list, not disconnected, and we don't
10524        * need to requeue the command.
10525        */
10526       disconnected = (scb_control & DISCONNECTED);
10527       aic_outb(p, scb_control | MK_MESSAGE, SCB_CONTROL);
10528     }
10529     if (disconnected)
10530     {
10531       /*
10532        * Actually requeue this SCB in case we can select the
10533        * device before it reconnects.  This can result in the command
10534        * being on the qinfifo twice, but we don't care because it will
10535        * all get cleaned up if/when the reset takes place.
10536        */
10537       if (aic7xxx_verbose & VERBOSE_RESET_PROCESS)
10538         printk(INFO_LEAD "Queueing device reset command.\n", p->host_no,
10539                       CTL_OF_SCB(scb));
10540       p->qinfifo[p->qinfifonext++] = scb->hscb->tag;
10541       if (p->features & AHC_QUEUE_REGS)
10542         aic_outb(p, p->qinfifonext, HNSCB_QOFF);
10543       else
10544         aic_outb(p, p->qinfifonext, KERNEL_QINPOS);
10545       scb->flags |= SCB_QUEUED_ABORT;
10546     }
10547   }
10548   aic_outb(p, saved_scbptr, SCBPTR);
10549   unpause_sequencer(p, FALSE);
10550   spin_unlock_irq(p->host->host_lock);
10551   scsi_sleep(HZ/4);
10552   spin_lock_irq(p->host->host_lock);
10553   if(aic_dev->flags & BUS_DEVICE_RESET_PENDING)
10554     return FAILED;
10555   else
10556     return SUCCESS;
10557 }
10558
10559
10560 /*+F*************************************************************************
10561  * Function:
10562  *   aic7xxx_panic_abort
10563  *
10564  * Description:
10565  *   Abort the current SCSI command(s).
10566  *-F*************************************************************************/
10567 static void
10568 aic7xxx_panic_abort(struct aic7xxx_host *p, Scsi_Cmnd *cmd)
10569 {
10570
10571   printk("aic7xxx driver version %s/%s\n", AIC7XXX_C_VERSION,
10572          UTS_RELEASE);
10573   printk("Controller type:\n    %s\n", board_names[p->board_name_index]);
10574   printk("p->flags=0x%lx, p->chip=0x%x, p->features=0x%x, "
10575          "sequencer %s paused\n",
10576      p->flags, p->chip, p->features,
10577     (aic_inb(p, HCNTRL) & PAUSE) ? "is" : "isn't" );
10578   pause_sequencer(p);
10579   disable_irq(p->irq);
10580   aic7xxx_print_card(p);
10581   aic7xxx_print_scratch_ram(p);
10582   spin_unlock_irq(p->host->host_lock);
10583   for(;;) barrier();
10584 }
10585
10586 /*+F*************************************************************************
10587  * Function:
10588  *   aic7xxx_abort
10589  *
10590  * Description:
10591  *   Abort the current SCSI command(s).
10592  *-F*************************************************************************/
10593 static int
10594 aic7xxx_abort(Scsi_Cmnd *cmd)
10595 {
10596   struct aic7xxx_scb  *scb = NULL;
10597   struct aic7xxx_host *p;
10598   int    found=0, disconnected;
10599   unsigned char saved_hscbptr, hscbptr, scb_control;
10600   struct aic_dev_data *aic_dev;
10601
10602   if(cmd == NULL)
10603   {
10604     printk(KERN_ERR "aic7xxx_abort: called with NULL cmd!\n");
10605     return FAILED;
10606   }
10607   p = (struct aic7xxx_host *)cmd->device->host->hostdata;
10608   aic_dev = AIC_DEV(cmd);
10609   if(aic7xxx_position(cmd) < p->scb_data->numscbs)
10610     scb = (p->scb_data->scb_array[aic7xxx_position(cmd)]);
10611   else
10612     return FAILED;
10613
10614   aic7xxx_isr(p->irq, (void *)p, NULL);
10615   aic7xxx_done_cmds_complete(p);
10616   /* If the command was already complete or just completed, then we didn't
10617    * do a reset, return FAILED */
10618   if(!(scb->flags & SCB_ACTIVE))
10619     return FAILED;
10620
10621   pause_sequencer(p);
10622
10623   /*
10624    * I added a new config option to the driver: "panic_on_abort" that will
10625    * cause the driver to panic and the machine to stop on the first abort
10626    * or reset call into the driver.  At that point, it prints out a lot of
10627    * useful information for me which I can then use to try and debug the
10628    * problem.  Simply enable the boot time prompt in order to activate this
10629    * code.
10630    */
10631   if (aic7xxx_panic_on_abort)
10632     aic7xxx_panic_abort(p, cmd);
10633
10634   if (aic7xxx_verbose & VERBOSE_ABORT)
10635   {
10636     printk(INFO_LEAD "Aborting scb %d, flags 0x%x, SEQADDR 0x%x, LASTPHASE "
10637            "0x%x\n",
10638          p->host_no, CTL_OF_SCB(scb), scb->hscb->tag, scb->flags,
10639          aic_inb(p, SEQADDR0) | (aic_inb(p, SEQADDR1) << 8),
10640          aic_inb(p, LASTPHASE));
10641     printk(INFO_LEAD "SG_CACHEPTR 0x%x, SG_COUNT %d, SCSISIGI 0x%x\n",
10642          p->host_no, CTL_OF_SCB(scb), (p->features & AHC_ULTRA2) ?
10643          aic_inb(p, SG_CACHEPTR) : 0, aic_inb(p, SG_COUNT),
10644          aic_inb(p, SCSISIGI));
10645     printk(INFO_LEAD "SSTAT0 0x%x, SSTAT1 0x%x, SSTAT2 0x%x\n",
10646          p->host_no, CTL_OF_SCB(scb), aic_inb(p, SSTAT0),
10647          aic_inb(p, SSTAT1), aic_inb(p, SSTAT2));
10648   }
10649
10650   if (scb->flags & SCB_WAITINGQ)
10651   {
10652     if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)
10653       printk(INFO_LEAD "SCB found on waiting list and "
10654           "aborted.\n", p->host_no, CTL_OF_SCB(scb));
10655     scbq_remove(&p->waiting_scbs, scb);
10656     scbq_remove(&aic_dev->delayed_scbs, scb);
10657     aic_dev->active_cmds++;
10658     p->activescbs++;
10659     scb->flags &= ~(SCB_WAITINGQ | SCB_ACTIVE);
10660     scb->flags |= SCB_ABORT | SCB_QUEUED_FOR_DONE;
10661     goto success;
10662   }
10663
10664 /*
10665  *  We just checked the waiting_q, now for the QINFIFO
10666  */
10667   if ( ((found = aic7xxx_search_qinfifo(p, cmd->device->id, cmd->device->channel,
10668                      cmd->device->lun, scb->hscb->tag, SCB_ABORT | SCB_QUEUED_FOR_DONE,
10669                      FALSE, NULL)) != 0) &&
10670                     (aic7xxx_verbose & VERBOSE_ABORT_PROCESS))
10671   {
10672     printk(INFO_LEAD "SCB found in QINFIFO and aborted.\n", p->host_no,
10673                     CTL_OF_SCB(scb));
10674     goto success;
10675   }
10676
10677 /*
10678  *  QINFIFO, waitingq, completeq done.  Next, check WAITING_SCB list in card
10679  */
10680
10681   saved_hscbptr = aic_inb(p, SCBPTR);
10682   if ((hscbptr = aic7xxx_find_scb(p, scb)) != SCB_LIST_NULL)
10683   {
10684     aic_outb(p, hscbptr, SCBPTR);
10685     scb_control = aic_inb(p, SCB_CONTROL);
10686     disconnected = scb_control & DISCONNECTED;
10687     /*
10688      * If the DISCONNECTED bit is not set in SCB_CONTROL, then we are
10689      * either currently active or on the waiting list.
10690      */
10691     if(!disconnected && aic_inb(p, LASTPHASE) == P_BUSFREE) {
10692       if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)
10693         printk(INFO_LEAD "SCB found on hardware waiting"
10694           " list and aborted.\n", p->host_no, CTL_OF_SCB(scb));
10695       /* If we are the only waiting command, stop the selection engine */
10696       if (aic_inb(p, WAITING_SCBH) == hscbptr && aic_inb(p, SCB_NEXT) ==
10697                         SCB_LIST_NULL)
10698       {
10699         aic_outb(p, aic_inb(p, SCSISEQ) & ~ENSELO, SCSISEQ);
10700         aic_outb(p, CLRSELTIMEO, CLRSINT1);
10701         aic_outb(p, SCB_LIST_NULL, WAITING_SCBH);
10702       }
10703       else
10704       {
10705         unsigned char prev, next;
10706         prev = SCB_LIST_NULL;
10707         next = aic_inb(p, WAITING_SCBH);
10708         while(next != SCB_LIST_NULL)
10709         {
10710           aic_outb(p, next, SCBPTR);
10711           if (next == hscbptr)
10712           {
10713             next = aic_inb(p, SCB_NEXT);
10714             if (prev != SCB_LIST_NULL)
10715             {
10716               aic_outb(p, prev, SCBPTR);
10717               aic_outb(p, next, SCB_NEXT);
10718             }
10719             else
10720               aic_outb(p, next, WAITING_SCBH);
10721             aic_outb(p, hscbptr, SCBPTR);
10722             next = SCB_LIST_NULL;
10723           }
10724           else
10725           {
10726             prev = next;
10727             next = aic_inb(p, SCB_NEXT);
10728           }
10729         }
10730       }
10731       aic_outb(p, SCB_LIST_NULL, SCB_TAG);
10732       aic_outb(p, 0, SCB_CONTROL);
10733       aic7xxx_add_curscb_to_free_list(p);
10734       scb->flags = SCB_ABORT | SCB_QUEUED_FOR_DONE;
10735       goto success;
10736     }
10737     else if (!disconnected)
10738     {
10739       /*
10740        * We are the currently active command
10741        */
10742       if((aic_inb(p, LASTPHASE) == P_MESGIN) ||
10743          (aic_inb(p, LASTPHASE) == P_MESGOUT))
10744       {
10745         /*
10746          * Message buffer busy, unable to abort
10747          */
10748         printk(INFO_LEAD "message buffer busy, unable to abort.\n",
10749                           p->host_no, CTL_OF_SCB(scb));
10750         unpause_sequencer(p, FALSE);
10751         return FAILED;
10752       }
10753       /* Fallthrough to below, set ATNO after we set SCB_CONTROL */
10754     }
10755     aic_outb(p,  scb_control | MK_MESSAGE, SCB_CONTROL);
10756     if(!disconnected)
10757     {
10758       aic_outb(p, HOST_MSG, MSG_OUT);
10759       aic_outb(p, aic_inb(p, SCSISIGI) | ATNO, SCSISIGO);
10760     }
10761     aic_outb(p, saved_hscbptr, SCBPTR);
10762   }
10763   else
10764   {
10765     /*
10766      * The scb isn't in the card at all and it is active and it isn't in
10767      * any of the queues, so it must be disconnected and paged out.  Fall
10768      * through to the code below.
10769      */
10770     disconnected = 1;
10771   }
10772
10773   p->flags |= AHC_ABORT_PENDING;
10774   scb->flags |= SCB_QUEUED_ABORT | SCB_ABORT | SCB_RECOVERY_SCB;
10775   scb->hscb->control |= MK_MESSAGE;
10776   if(disconnected)
10777   {
10778     if (aic7xxx_verbose & VERBOSE_ABORT_PROCESS)
10779       printk(INFO_LEAD "SCB disconnected.  Queueing Abort"
10780         " SCB.\n", p->host_no, CTL_OF_SCB(scb));
10781     p->qinfifo[p->qinfifonext++] = scb->hscb->tag;
10782     if (p->features & AHC_QUEUE_REGS)
10783       aic_outb(p, p->qinfifonext, HNSCB_QOFF);
10784     else
10785       aic_outb(p, p->qinfifonext, KERNEL_QINPOS);
10786   }
10787   unpause_sequencer(p, FALSE);
10788   spin_unlock_irq(p->host->host_lock);
10789   scsi_sleep(HZ/4);
10790   spin_lock_irq(p->host->host_lock);
10791   if (p->flags & AHC_ABORT_PENDING)
10792   {
10793     if (aic7xxx_verbose & VERBOSE_ABORT_RETURN)
10794       printk(INFO_LEAD "Abort never delivered, returning FAILED\n", p->host_no,
10795                     CTL_OF_CMD(cmd));
10796     p->flags &= ~AHC_ABORT_PENDING;
10797     return FAILED;
10798   }
10799   if (aic7xxx_verbose & VERBOSE_ABORT_RETURN)
10800     printk(INFO_LEAD "Abort successful.\n", p->host_no, CTL_OF_CMD(cmd));
10801   return SUCCESS;
10802
10803 success:
10804   if (aic7xxx_verbose & VERBOSE_ABORT_RETURN)
10805     printk(INFO_LEAD "Abort successful.\n", p->host_no, CTL_OF_CMD(cmd));
10806   aic7xxx_run_done_queue(p, TRUE);
10807   unpause_sequencer(p, FALSE);
10808   return SUCCESS;
10809 }
10810
10811 /*+F*************************************************************************
10812  * Function:
10813  *   aic7xxx_reset
10814  *
10815  * Description:
10816  *   Resetting the bus always succeeds - is has to, otherwise the
10817  *   kernel will panic! Try a surgical technique - sending a BUS
10818  *   DEVICE RESET message - on the offending target before pulling
10819  *   the SCSI bus reset line.
10820  *-F*************************************************************************/
10821 static int
10822 aic7xxx_reset(Scsi_Cmnd *cmd)
10823 {
10824   struct aic7xxx_scb *scb;
10825   struct aic7xxx_host *p;
10826   struct aic_dev_data *aic_dev;
10827
10828   p = (struct aic7xxx_host *) cmd->device->host->hostdata;
10829   aic_dev = AIC_DEV(cmd);
10830   if(aic7xxx_position(cmd) < p->scb_data->numscbs)
10831   {
10832     scb = (p->scb_data->scb_array[aic7xxx_position(cmd)]);
10833     if (scb->cmd != cmd)
10834       scb = NULL;
10835   }
10836   else
10837   {
10838     scb = NULL;
10839   }
10840
10841   /*
10842    * I added a new config option to the driver: "panic_on_abort" that will
10843    * cause the driver to panic and the machine to stop on the first abort
10844    * or reset call into the driver.  At that point, it prints out a lot of
10845    * useful information for me which I can then use to try and debug the
10846    * problem.  Simply enable the boot time prompt in order to activate this
10847    * code.
10848    */
10849   if (aic7xxx_panic_on_abort)
10850     aic7xxx_panic_abort(p, cmd);
10851
10852   pause_sequencer(p);
10853
10854   while((aic_inb(p, INTSTAT) & INT_PEND) && !(p->flags & AHC_IN_ISR))
10855   {
10856     aic7xxx_isr(p->irq, p, (void *)NULL );
10857     pause_sequencer(p);
10858   }
10859   aic7xxx_done_cmds_complete(p);
10860
10861   if(scb && (scb->cmd == NULL))
10862   {
10863     /*
10864      * We just completed the command when we ran the isr stuff, so we no
10865      * longer have it.
10866      */
10867     unpause_sequencer(p, FALSE);
10868     return SUCCESS;
10869   }
10870
10871 /*
10872  *  By this point, we want to already know what we are going to do and
10873  *  only have the following code implement our course of action.
10874  */
10875   aic7xxx_reset_channel(p, cmd->device->channel, TRUE);
10876   if (p->features & AHC_TWIN)
10877   {
10878     aic7xxx_reset_channel(p, cmd->device->channel ^ 0x01, TRUE);
10879     restart_sequencer(p);
10880   }
10881   aic_outb(p,  aic_inb(p, SIMODE1) & ~(ENREQINIT|ENBUSFREE), SIMODE1);
10882   aic7xxx_clear_intstat(p);
10883   p->flags &= ~AHC_HANDLING_REQINITS;
10884   p->msg_type = MSG_TYPE_NONE;
10885   p->msg_index = 0;
10886   p->msg_len = 0;
10887   aic7xxx_run_done_queue(p, TRUE);
10888   unpause_sequencer(p, FALSE);
10889   spin_unlock_irq(p->host->host_lock);
10890   scsi_sleep(2 * HZ);
10891   spin_lock_irq(p->host->host_lock);
10892   return SUCCESS;
10893 }
10894
10895 /*+F*************************************************************************
10896  * Function:
10897  *   aic7xxx_biosparam
10898  *
10899  * Description:
10900  *   Return the disk geometry for the given SCSI device.
10901  *
10902  * Note:
10903  *   This function is broken for today's really large drives and needs
10904  *   fixed.
10905  *-F*************************************************************************/
10906 static int
10907 aic7xxx_biosparam(struct scsi_device *sdev, struct block_device *bdev,
10908                 sector_t capacity, int geom[])
10909 {
10910   sector_t heads, sectors, cylinders;
10911   int ret;
10912   struct aic7xxx_host *p;
10913   unsigned char *buf;
10914
10915   p = (struct aic7xxx_host *) sdev->host->hostdata;
10916   buf = scsi_bios_ptable(bdev);
10917
10918   if ( buf )
10919   {
10920     ret = scsi_partsize(buf, capacity, &geom[2], &geom[0], &geom[1]);
10921     kfree(buf);
10922     if ( ret != -1 )
10923       return(ret);
10924   }
10925
10926   heads = 64;
10927   sectors = 32;
10928   cylinders = capacity >> 11;
10929
10930   if ((p->flags & AHC_EXTEND_TRANS_A) && (cylinders > 1024))
10931   {
10932     heads = 255;
10933     sectors = 63;
10934     cylinders = capacity >> 14;
10935     if(capacity > (65535 * heads * sectors))
10936       cylinders = 65535;
10937     else
10938       cylinders = ((unsigned int)capacity) / (unsigned int)(heads * sectors);
10939   }
10940
10941   geom[0] = (int)heads;
10942   geom[1] = (int)sectors;
10943   geom[2] = (int)cylinders;
10944
10945   return (0);
10946 }
10947
10948 /*+F*************************************************************************
10949  * Function:
10950  *   aic7xxx_release
10951  *
10952  * Description:
10953  *   Free the passed in Scsi_Host memory structures prior to unloading the
10954  *   module.
10955  *-F*************************************************************************/
10956 static int
10957 aic7xxx_release(struct Scsi_Host *host)
10958 {
10959   struct aic7xxx_host *p = (struct aic7xxx_host *) host->hostdata;
10960   struct aic7xxx_host *next, *prev;
10961
10962   if(p->irq)
10963     free_irq(p->irq, p);
10964 #ifdef MMAPIO
10965   if(p->maddr)
10966   {
10967     iounmap((void *) (((unsigned long) p->maddr) & PAGE_MASK));
10968   }
10969 #endif /* MMAPIO */
10970   if(!p->pdev)
10971     release_region(p->base, MAXREG - MINREG);
10972 #ifdef CONFIG_PCI
10973   else
10974     pci_release_regions(p->pdev);
10975 #endif
10976   prev = NULL;
10977   next = first_aic7xxx;
10978   while(next != NULL)
10979   {
10980     if(next == p)
10981     {
10982       if(prev == NULL)
10983         first_aic7xxx = next->next;
10984       else
10985         prev->next = next->next;
10986     }
10987     else
10988     {
10989       prev = next;
10990     }
10991     next = next->next;
10992   }
10993   aic7xxx_free(p);
10994   return(0);
10995 }
10996
10997 /*+F*************************************************************************
10998  * Function:
10999  *   aic7xxx_print_card
11000  *
11001  * Description:
11002  *   Print out all of the control registers on the card
11003  *
11004  *   NOTE: This function is not yet safe for use on the VLB and EISA
11005  *   controllers, so it isn't used on those controllers at all.
11006  *-F*************************************************************************/
11007 static void
11008 aic7xxx_print_card(struct aic7xxx_host *p)
11009 {
11010   int i, j, k, chip;
11011   static struct register_ranges {
11012     int num_ranges;
11013     int range_val[32];
11014   } cards_ds[] = {
11015     { 0, {0,} }, /* none */
11016     {10, {0x00, 0x05, 0x08, 0x11, 0x18, 0x19, 0x1f, 0x1f, 0x60, 0x60, /*7771*/
11017           0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9b, 0x9f} },
11018     { 9, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7850*/
11019           0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} },
11020     { 9, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7860*/
11021           0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} },
11022     {10, {0x00, 0x05, 0x08, 0x11, 0x18, 0x19, 0x1c, 0x1f, 0x60, 0x60, /*7870*/
11023           0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} },
11024     {10, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1a, 0x1c, 0x1f, 0x60, 0x60, /*7880*/
11025           0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9f} },
11026     {16, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7890*/
11027           0x84, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a, 0x9f, 0x9f,
11028           0xe0, 0xf1, 0xf4, 0xf4, 0xf6, 0xf6, 0xf8, 0xf8, 0xfa, 0xfc,
11029           0xfe, 0xff} },
11030     {12, {0x00, 0x05, 0x08, 0x11, 0x18, 0x19, 0x1b, 0x1f, 0x60, 0x60, /*7895*/
11031           0x62, 0x66, 0x80, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a,
11032           0x9f, 0x9f, 0xe0, 0xf1} },
11033     {16, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7896*/
11034           0x84, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a, 0x9f, 0x9f,
11035           0xe0, 0xf1, 0xf4, 0xf4, 0xf6, 0xf6, 0xf8, 0xf8, 0xfa, 0xfc,
11036           0xfe, 0xff} },
11037     {12, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7892*/
11038           0x84, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a, 0x9c, 0x9f,
11039           0xe0, 0xf1, 0xf4, 0xfc} },
11040     {12, {0x00, 0x05, 0x08, 0x11, 0x18, 0x1f, 0x60, 0x60, 0x62, 0x66, /*7899*/
11041           0x84, 0x8e, 0x90, 0x95, 0x97, 0x97, 0x9a, 0x9a, 0x9c, 0x9f,
11042           0xe0, 0xf1, 0xf4, 0xfc} },
11043   };
11044   chip = p->chip & AHC_CHIPID_MASK;
11045   printk("%s at ",
11046          board_names[p->board_name_index]);
11047   switch(p->chip & ~AHC_CHIPID_MASK)
11048   {
11049     case AHC_VL:
11050       printk("VLB Slot %d.\n", p->pci_device_fn);
11051       break;
11052     case AHC_EISA:
11053       printk("EISA Slot %d.\n", p->pci_device_fn);
11054       break;
11055     case AHC_PCI:
11056     default:
11057       printk("PCI %d/%d/%d.\n", p->pci_bus, PCI_SLOT(p->pci_device_fn),
11058              PCI_FUNC(p->pci_device_fn));
11059       break;
11060   }
11061
11062   /*
11063    * the registers on the card....
11064    */
11065   printk("Card Dump:\n");
11066   k = 0;
11067   for(i=0; i<cards_ds[chip].num_ranges; i++)
11068   {
11069     for(j  = cards_ds[chip].range_val[ i * 2 ];
11070         j <= cards_ds[chip].range_val[ i * 2 + 1 ] ;
11071         j++)
11072     {
11073       printk("%02x:%02x ", j, aic_inb(p, j));
11074       if(++k == 13)
11075       {
11076         printk("\n");
11077         k=0;
11078       }
11079     }
11080   }
11081   if(k != 0)
11082     printk("\n");
11083
11084   /*
11085    * If this was an Ultra2 controller, then we just hosed the card in terms
11086    * of the QUEUE REGS.  This function is only called at init time or by
11087    * the panic_abort function, so it's safe to assume a generic init time
11088    * setting here
11089    */
11090
11091   if(p->features & AHC_QUEUE_REGS)
11092   {
11093     aic_outb(p, 0, SDSCB_QOFF);
11094     aic_outb(p, 0, SNSCB_QOFF);
11095     aic_outb(p, 0, HNSCB_QOFF);
11096   }
11097
11098 }
11099
11100 /*+F*************************************************************************
11101  * Function:
11102  *   aic7xxx_print_scratch_ram
11103  *
11104  * Description:
11105  *   Print out the scratch RAM values on the card.
11106  *-F*************************************************************************/
11107 static void
11108 aic7xxx_print_scratch_ram(struct aic7xxx_host *p)
11109 {
11110   int i, k;
11111
11112   k = 0;
11113   printk("Scratch RAM:\n");
11114   for(i = SRAM_BASE; i < SEQCTL; i++)
11115   {
11116     printk("%02x:%02x ", i, aic_inb(p, i));
11117     if(++k == 13)
11118     {
11119       printk("\n");
11120       k=0;
11121     }
11122   }
11123   if (p->features & AHC_MORE_SRAM)
11124   {
11125     for(i = TARG_OFFSET; i < 0x80; i++)
11126     {
11127       printk("%02x:%02x ", i, aic_inb(p, i));
11128       if(++k == 13)
11129       {
11130         printk("\n");
11131         k=0;
11132       }
11133     }
11134   }
11135   printk("\n");
11136 }
11137
11138
11139 #include "aic7xxx_old/aic7xxx_proc.c"
11140
11141 MODULE_LICENSE("Dual BSD/GPL");
11142
11143
11144 static Scsi_Host_Template driver_template = {
11145         .proc_info              = aic7xxx_proc_info,
11146         .detect                 = aic7xxx_detect,
11147         .release                = aic7xxx_release,
11148         .info                   = aic7xxx_info,
11149         .queuecommand           = aic7xxx_queue,
11150         .slave_alloc            = aic7xxx_slave_alloc,
11151         .slave_configure        = aic7xxx_slave_configure,
11152         .slave_destroy          = aic7xxx_slave_destroy,
11153         .bios_param             = aic7xxx_biosparam,
11154         .eh_abort_handler       = aic7xxx_abort,
11155         .eh_device_reset_handler        = aic7xxx_bus_device_reset,
11156         .eh_host_reset_handler  = aic7xxx_reset,
11157         .can_queue              = 255,
11158         .this_id                = -1,
11159         .max_sectors            = 2048,
11160         .cmd_per_lun            = 3,
11161         .use_clustering         = ENABLE_CLUSTERING,
11162 };
11163
11164 #include "scsi_module.c"
11165
11166 /*
11167  * Overrides for Emacs so that we almost follow Linus's tabbing style.
11168  * Emacs will notice this stuff at the end of the file and automatically
11169  * adjust the settings for this buffer only.  This must remain at the end
11170  * of the file.
11171  * ---------------------------------------------------------------------------
11172  * Local variables:
11173  * c-indent-level: 2
11174  * c-brace-imaginary-offset: 0
11175  * c-brace-offset: -2
11176  * c-argdecl-indent: 2
11177  * c-label-offset: -2
11178  * c-continued-statement-offset: 2
11179  * c-continued-brace-offset: 0
11180  * indent-tabs-mode: nil
11181  * tab-width: 8
11182  * End:
11183  */