drivers/scsi/fdomain.c

   1 /* fdomain.c -- Future Domain TMC-16x0 SCSI driver
   2  * Created: Sun May  3 18:53:19 1992 by faith@cs.unc.edu
   3  * Revised: Mon Dec 28 21:59:02 1998 by faith@acm.org
   4  * Author: Rickard E. Faith, faith@cs.unc.edu
   5  * Copyright 1992-1996, 1998 Rickard E. Faith (faith@acm.org)
   6  * Shared IRQ supported added 7/7/2001  Alan Cox <alan@redhat.com>
   7
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22  **************************************************************************
  23
  24  SUMMARY:
  25
  26  Future Domain BIOS versions supported for autodetect:
  27     2.0, 3.0, 3.2, 3.4 (1.0), 3.5 (2.0), 3.6, 3.61
  28  Chips are supported:
  29     TMC-1800, TMC-18C50, TMC-18C30, TMC-36C70
  30  Boards supported:
  31     Future Domain TMC-1650, TMC-1660, TMC-1670, TMC-1680, TMC-1610M/MER/MEX
  32     Future Domain TMC-3260 (PCI)
  33     Quantum ISA-200S, ISA-250MG
  34     Adaptec AHA-2920A (PCI) [BUT *NOT* AHA-2920C -- use aic7xxx instead]
  35     IBM ?
  36  LILO/INSMOD command-line options:
  37     fdomain=<PORT_BASE>,<IRQ>[,<ADAPTER_ID>]
  38
  39
  40
  41  NOTE:
  42
  43  The Adaptec AHA-2920C has an Adaptec AIC-7850 chip on it.
  44  Use the aic7xxx driver for this board.
  45
  46  The Adaptec AHA-2920A has a Future Domain chip on it, so this is the right
  47  driver for that card.  Unfortunately, the boxes will probably just say
  48  "2920", so you'll have to look on the card for a Future Domain logo, or a
  49  letter after the 2920.
  50
  51
  52
  53  THANKS:
  54
  55  Thanks to Adaptec for providing PCI boards for testing.  This finally
  56  enabled me to test the PCI detection and correct it for PCI boards that do
  57  not have a BIOS at a standard ISA location.  For PCI boards, LILO/INSMOD
  58  command-line options should no longer be needed.  --RF 18Nov98
  59
  60
  61
  62  DESCRIPTION:
  63
  64  This is the Linux low-level SCSI driver for Future Domain TMC-1660/1680
  65  TMC-1650/1670, and TMC-3260 SCSI host adapters.  The 1650 and 1670 have a
  66  25-pin external connector, whereas the 1660 and 1680 have a SCSI-2 50-pin
  67  high-density external connector.  The 1670 and 1680 have floppy disk
  68  controllers built in.  The TMC-3260 is a PCI bus card.
  69
  70  Future Domain's older boards are based on the TMC-1800 chip, and this
  71  driver was originally written for a TMC-1680 board with the TMC-1800 chip.
  72  More recently, boards are being produced with the TMC-18C50 and TMC-18C30
  73  chips.  The latest and greatest board may not work with this driver.  If
  74  you have to patch this driver so that it will recognize your board's BIOS
  75  signature, then the driver may fail to function after the board is
  76  detected.
  77
  78  Please note that the drive ordering that Future Domain implemented in BIOS
  79  versions 3.4 and 3.5 is the opposite of the order (currently) used by the
  80  rest of the SCSI industry.  If you have BIOS version 3.4 or 3.5, and have
  81  more than one drive, then the drive ordering will be the reverse of that
  82  which you see under DOS.  For example, under DOS SCSI ID 0 will be D: and
  83  SCSI ID 1 will be C: (the boot device).  Under Linux, SCSI ID 0 will be
  84  /dev/sda and SCSI ID 1 will be /dev/sdb.  The Linux ordering is consistent
  85  with that provided by all the other SCSI drivers for Linux.  If you want
  86  this changed, you will probably have to patch the higher level SCSI code.
  87  If you do so, please send me patches that are protected by #ifdefs.
  88
  89  If you have a TMC-8xx or TMC-9xx board, then this is not the driver for
  90  your board.  Please refer to the Seagate driver for more information and
  91  possible support.
  92
  93
  94
  95  HISTORY:
  96
  97  Linux       Driver      Driver
  98  Version     Version     Date         Support/Notes
  99
 100              0.0          3 May 1992  V2.0 BIOS; 1800 chip
 101  0.97        1.9         28 Jul 1992
 102  0.98.6      3.1         27 Nov 1992
 103  0.99        3.2          9 Dec 1992
 104
 105  0.99.3      3.3         10 Jan 1993  V3.0 BIOS
 106  0.99.5      3.5         18 Feb 1993
 107  0.99.10     3.6         15 May 1993  V3.2 BIOS; 18C50 chip
 108  0.99.11     3.17         3 Jul 1993  (now under RCS)
 109  0.99.12     3.18        13 Aug 1993
 110  0.99.14     5.6         31 Oct 1993  (reselection code removed)
 111
 112  0.99.15     5.9         23 Jan 1994  V3.4 BIOS (preliminary)
 113  1.0.8/1.1.1 5.15         1 Apr 1994  V3.4 BIOS; 18C30 chip (preliminary)
 114  1.0.9/1.1.3 5.16         7 Apr 1994  V3.4 BIOS; 18C30 chip
 115  1.1.38      5.18        30 Jul 1994  36C70 chip (PCI version of 18C30)
 116  1.1.62      5.20         2 Nov 1994  V3.5 BIOS
 117  1.1.73      5.22         7 Dec 1994  Quantum ISA-200S board; V2.0 BIOS
 118
 119  1.1.82      5.26        14 Jan 1995  V3.5 BIOS; TMC-1610M/MER/MEX board
 120  1.2.10      5.28         5 Jun 1995  Quantum ISA-250MG board; V2.0, V2.01 BIOS
 121  1.3.4       5.31        23 Jun 1995  PCI BIOS-32 detection (preliminary)
 122  1.3.7       5.33         4 Jul 1995  PCI BIOS-32 detection
 123  1.3.28      5.36        17 Sep 1995  V3.61 BIOS; LILO command-line support
 124  1.3.34      5.39        12 Oct 1995  V3.60 BIOS; /proc
 125  1.3.72      5.39         8 Feb 1996  Adaptec AHA-2920 board
 126  1.3.85      5.41         4 Apr 1996
 127  2.0.12      5.44         8 Aug 1996  Use ID 7 for all PCI cards
 128  2.1.1       5.45         2 Oct 1996  Update ROM accesses for 2.1.x
 129  2.1.97      5.46        23 Apr 1998  Rewritten PCI detection routines [mj]
 130  2.1.11x     5.47         9 Aug 1998  Touched for 8 SCSI disk majors support
 131              5.48        18 Nov 1998  BIOS no longer needed for PCI detection
 132  2.2.0       5.50        28 Dec 1998  Support insmod parameters
 133
 134
 135  REFERENCES USED:
 136
 137  "TMC-1800 SCSI Chip Specification (FDC-1800T)", Future Domain Corporation,
 138  1990.
 139
 140  "Technical Reference Manual: 18C50 SCSI Host Adapter Chip", Future Domain
 141  Corporation, January 1992.
 142
 143  "LXT SCSI Products: Specifications and OEM Technical Manual (Revision
 144  B/September 1991)", Maxtor Corporation, 1991.
 145
 146  "7213S product Manual (Revision P3)", Maxtor Corporation, 1992.
 147
 148  "Draft Proposed American National Standard: Small Computer System
 149  Interface - 2 (SCSI-2)", Global Engineering Documents. (X3T9.2/86-109,
 150  revision 10h, October 17, 1991)
 151
 152  Private communications, Drew Eckhardt (drew@cs.colorado.edu) and Eric
 153  Youngdale (ericy@cais.com), 1992.
 154
 155  Private communication, Tuong Le (Future Domain Engineering department),
 156  1994. (Disk geometry computations for Future Domain BIOS version 3.4, and
 157  TMC-18C30 detection.)
 158
 159  Hogan, Thom. The Programmer's PC Sourcebook. Microsoft Press, 1988. Page
 160  60 (2.39: Disk Partition Table Layout).
 161
 162  "18C30 Technical Reference Manual", Future Domain Corporation, 1993, page
 163  6-1.
 164
 165
 166
 167  NOTES ON REFERENCES:
 168
 169  The Maxtor manuals were free.  Maxtor telephone technical support is
 170  great!
 171
 172  The Future Domain manuals were $25 and $35.  They document the chip, not
 173  the TMC-16x0 boards, so some information I had to guess at.  In 1992,
 174  Future Domain sold DOS BIOS source for $250 and the UN*X driver source was
 175  $750, but these required a non-disclosure agreement, so even if I could
 176  have afforded them, they would *not* have been useful for writing this
 177  publically distributable driver.  Future Domain technical support has
 178  provided some information on the phone and have sent a few useful FAXs.
 179  They have been much more helpful since they started to recognize that the
 180  word "Linux" refers to an operating system :-).
 181
 182
 183
 184  ALPHA TESTERS:
 185
 186  There are many other alpha testers that come and go as the driver
 187  develops.  The people listed here were most helpful in times of greatest
 188  need (mostly early on -- I've probably left out a few worthy people in
 189  more recent times):
 190
 191  Todd Carrico (todd@wutc.wustl.edu), Dan Poirier (poirier@cs.unc.edu ), Ken
 192  Corey (kenc@sol.acs.unt.edu), C. de Bruin (bruin@bruin@sterbbs.nl), Sakari
 193  Aaltonen (sakaria@vipunen.hit.fi), John Rice (rice@xanth.cs.odu.edu), Brad
 194  Yearwood (brad@optilink.com), and Ray Toy (toy@soho.crd.ge.com).
 195
 196  Special thanks to Tien-Wan Yang (twyang@cs.uh.edu), who graciously lent me
 197  his 18C50-based card for debugging.  He is the sole reason that this
 198  driver works with the 18C50 chip.
 199
 200  Thanks to Dave Newman (dnewman@crl.com) for providing initial patches for
 201  the version 3.4 BIOS.
 202
 203  Thanks to James T. McKinley (mckinley@msupa.pa.msu.edu) for providing
 204  patches that support the TMC-3260, a PCI bus card with the 36C70 chip.
 205  The 36C70 chip appears to be "completely compatible" with the 18C30 chip.
 206
 207  Thanks to Eric Kasten (tigger@petroglyph.cl.msu.edu) for providing the
 208  patch for the version 3.5 BIOS.
 209
 210  Thanks for Stephen Henson (shenson@nyx10.cs.du.edu) for providing the
 211  patch for the Quantum ISA-200S SCSI adapter.
 212
 213  Thanks to Adam Bowen for the signature to the 1610M/MER/MEX scsi cards, to
 214  Martin Andrews (andrewm@ccfadm.eeg.ccf.org) for the signature to some
 215  random TMC-1680 repackaged by IBM; and to Mintak Ng (mintak@panix.com) for
 216  the version 3.61 BIOS signature.
 217
 218  Thanks for Mark Singer (elf@netcom.com) and Richard Simpson
 219  (rsimpson@ewrcsdra.demon.co.uk) for more Quantum signatures and detective
 220  work on the Quantum RAM layout.
 221
 222  Special thanks to James T. McKinley (mckinley@msupa.pa.msu.edu) for
 223  providing patches for proper PCI BIOS32-mediated detection of the TMC-3260
 224  card (a PCI bus card with the 36C70 chip).  Please send James PCI-related
 225  bug reports.
 226
 227  Thanks to Tom Cavin (tec@usa1.com) for preliminary command-line option
 228  patches.
 229
 230  New PCI detection code written by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
 231
 232  Insmod parameter code based on patches from Daniel Graham
 233  <graham@balance.uoregon.edu>.
 234
 235  All of the alpha testers deserve much thanks.
 236
 237
 238
 239  NOTES ON USER DEFINABLE OPTIONS:
 240
 241  DEBUG: This turns on the printing of various debug information.
 242
 243  ENABLE_PARITY: This turns on SCSI parity checking.  With the current
 244  driver, all attached devices must support SCSI parity.  If none of your
 245  devices support parity, then you can probably get the driver to work by
 246  turning this option off.  I have no way of testing this, however, and it
 247  would appear that no one ever uses this option.
 248
 249  FIFO_COUNT: The host adapter has an 8K cache (host adapters based on the
 250  18C30 chip have a 2k cache).  When this many 512 byte blocks are filled by
 251  the SCSI device, an interrupt will be raised.  Therefore, this could be as
 252  low as 0, or as high as 16.  Note, however, that values which are too high
 253  or too low seem to prevent any interrupts from occurring, and thereby lock
 254  up the machine.  I have found that 2 is a good number, but throughput may
 255  be increased by changing this value to values which are close to 2.
 256  Please let me know if you try any different values.
 257
 258  RESELECTION: This is no longer an option, since I gave up trying to
 259  implement it in version 4.x of this driver.  It did not improve
 260  performance at all and made the driver unstable (because I never found one
 261  of the two race conditions which were introduced by the multiple
 262  outstanding command code).  The instability seems a very high price to pay
 263  just so that you don't have to wait for the tape to rewind.  If you want
 264  this feature implemented, send me patches.  I'll be happy to send a copy
 265  of my (broken) driver to anyone who would like to see a copy.
 266
 267  **************************************************************************/
 268
 269 #include <linux/config.h>
 270 #include <linux/module.h>
 271 #include <linux/init.h>
 272 #include <linux/interrupt.h>
 273 #include <linux/blkdev.h>
 274 #include <linux/spinlock.h>
 275 #include <linux/errno.h>
 276 #include <linux/string.h>
 277 #include <linux/ioport.h>
 278 #include <linux/proc_fs.h>
 279 #include <linux/pci.h>
 280 #include <linux/stat.h>
 281 #include <linux/delay.h>
 282
 283 #include <asm/io.h>
 284 #include <asm/system.h>
 285
 286 #include "scsi.h"
 287 #include "hosts.h"
 288
 289 MODULE_AUTHOR("Rickard E. Faith");
 290 MODULE_DESCRIPTION("Future domain SCSI driver");
 291 MODULE_LICENSE("GPL");
 292
 293
 294 #define VERSION          "$Revision: 5.51 $"
 295
 296 /* START OF USER DEFINABLE OPTIONS */
 297
 298 #define DEBUG            0      /* Enable debugging output */
 299 #define ENABLE_PARITY    1      /* Enable SCSI Parity */
 300 #define FIFO_COUNT       2      /* Number of 512 byte blocks before INTR */
 301
 302 /* END OF USER DEFINABLE OPTIONS */
 303
 304 #if DEBUG
 305 #define EVERY_ACCESS     0      /* Write a line on every scsi access */
 306 #define ERRORS_ONLY      1      /* Only write a line if there is an error */
 307 #define DEBUG_DETECT     0      /* Debug fdomain_16x0_detect() */
 308 #define DEBUG_MESSAGES   1      /* Debug MESSAGE IN phase */
 309 #define DEBUG_ABORT      1      /* Debug abort() routine */
 310 #define DEBUG_RESET      1      /* Debug reset() routine */
 311 #define DEBUG_RACE       1      /* Debug interrupt-driven race condition */
 312 #else
 313 #define EVERY_ACCESS     0      /* LEAVE THESE ALONE--CHANGE THE ONES ABOVE */
 314 #define ERRORS_ONLY      0
 315 #define DEBUG_DETECT     0
 316 #define DEBUG_MESSAGES   0
 317 #define DEBUG_ABORT      0
 318 #define DEBUG_RESET      0
 319 #define DEBUG_RACE       0
 320 #endif
 321
 322 /* Errors are reported on the line, so we don't need to report them again */
 323 #if EVERY_ACCESS
 324 #undef ERRORS_ONLY
 325 #define ERRORS_ONLY      0
 326 #endif
 327
 328 #if ENABLE_PARITY
 329 #define PARITY_MASK      0x08
 330 #else
 331 #define PARITY_MASK      0x00
 332 #endif
 333
 334 enum chip_type {
 335    unknown          = 0x00,
 336    tmc1800          = 0x01,
 337    tmc18c50         = 0x02,
 338    tmc18c30         = 0x03,
 339 };
 340
 341 enum {
 342    in_arbitration   = 0x02,
 343    in_selection     = 0x04,
 344    in_other         = 0x08,
 345    disconnect       = 0x10,
 346    aborted          = 0x20,
 347    sent_ident       = 0x40,
 348 };
 349
 350 enum in_port_type {
 351    Read_SCSI_Data   =  0,
 352    SCSI_Status      =  1,
 353    TMC_Status       =  2,
 354    FIFO_Status      =  3,       /* tmc18c50/tmc18c30 only */
 355    Interrupt_Cond   =  4,       /* tmc18c50/tmc18c30 only */
 356    LSB_ID_Code      =  5,
 357    MSB_ID_Code      =  6,
 358    Read_Loopback    =  7,
 359    SCSI_Data_NoACK  =  8,
 360    Interrupt_Status =  9,
 361    Configuration1   = 10,
 362    Configuration2   = 11,       /* tmc18c50/tmc18c30 only */
 363    Read_FIFO        = 12,
 364    FIFO_Data_Count  = 14
 365 };
 366
 367 enum out_port_type {
 368    Write_SCSI_Data  =  0,
 369    SCSI_Cntl        =  1,
 370    Interrupt_Cntl   =  2,
 371    SCSI_Mode_Cntl   =  3,
 372    TMC_Cntl         =  4,
 373    Memory_Cntl      =  5,       /* tmc18c50/tmc18c30 only */
 374    Write_Loopback   =  7,
 375    IO_Control       = 11,       /* tmc18c30 only */
 376    Write_FIFO       = 12
 377 };
 378
 379 /* .bss will zero all the static variables below */
 380 static int               port_base;
 381 static unsigned long     bios_base;
 382 static int               bios_major;
 383 static int               bios_minor;
 384 static int               PCI_bus;
 385 static int               Quantum;       /* Quantum board variant */
 386 static int               interrupt_level;
 387 static volatile int      in_command;
 388 static Scsi_Cmnd         *current_SC;
 389 static enum chip_type    chip              = unknown;
 390 static int               adapter_mask;
 391 static int               this_id;
 392 static int               setup_called;
 393
 394 #if DEBUG_RACE
 395 static volatile int      in_interrupt_flag;
 396 #endif
 397
 398 static int               SCSI_Mode_Cntl_port;
 399 static int               FIFO_Data_Count_port;
 400 static int               Interrupt_Cntl_port;
 401 static int               Interrupt_Status_port;
 402 static int               Read_FIFO_port;
 403 static int               Read_SCSI_Data_port;
 404 static int               SCSI_Cntl_port;
 405 static int               SCSI_Data_NoACK_port;
 406 static int               SCSI_Status_port;
 407 static int               TMC_Cntl_port;
 408 static int               TMC_Status_port;
 409 static int               Write_FIFO_port;
 410 static int               Write_SCSI_Data_port;
 411
 412 static int               FIFO_Size = 0x2000; /* 8k FIFO for
 413                                                 pre-tmc18c30 chips */
 414
 415 static irqreturn_t       do_fdomain_16x0_intr( int irq, void *dev_id,
 416                                             struct pt_regs * regs );
 417 int                     fdomain_16x0_bus_reset(Scsi_Cmnd *SCpnt);
 418
 419 /* Allow insmod parameters to be like LILO parameters.  For example:
 420    insmod fdomain fdomain=0x140,11 */
 421 static char * fdomain = NULL;
 422 MODULE_PARM(fdomain, "s");
 423
 424 static unsigned long addresses[] = {
 425    0xc8000,
 426    0xca000,
 427    0xce000,
 428    0xde000,
 429    0xcc000,             /* Extra addresses for PCI boards */
 430    0xd0000,
 431    0xe0000,
 432 };
 433 #define ADDRESS_COUNT (sizeof( addresses ) / sizeof( unsigned ))
 434
 435 static unsigned short ports[] = { 0x140, 0x150, 0x160, 0x170 };
 436 #define PORT_COUNT (sizeof( ports ) / sizeof( unsigned short ))
 437
 438 static unsigned short ints[] = { 3, 5, 10, 11, 12, 14, 15, 0 };
 439
 440 /*
 441
 442   READ THIS BEFORE YOU ADD A SIGNATURE!
 443
 444   READING THIS SHORT NOTE CAN SAVE YOU LOTS OF TIME!
 445
 446   READ EVERY WORD, ESPECIALLY THE WORD *NOT*
 447
 448   This driver works *ONLY* for Future Domain cards using the TMC-1800,
 449   TMC-18C50, or TMC-18C30 chip.  This includes models TMC-1650, 1660, 1670,
 450   and 1680.  These are all 16-bit cards.
 451
 452   The following BIOS signature signatures are for boards which do *NOT*
 453   work with this driver (these TMC-8xx and TMC-9xx boards may work with the
 454   Seagate driver):
 455
 456   FUTURE DOMAIN CORP. (C) 1986-1988 V4.0I 03/16/88
 457   FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89
 458   FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89
 459   FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90
 460   FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90
 461   FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90
 462   FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92
 463
 464   (The cards which do *NOT* work are all 8-bit cards -- although some of
 465   them have a 16-bit form-factor, the upper 8-bits are used only for IRQs
 466   and are *NOT* used for data.  You can tell the difference by following
 467   the tracings on the circuit board -- if only the IRQ lines are involved,
 468   you have a "8-bit" card, and should *NOT* use this driver.)
 469
 470 */
 471
 472 struct signature {
 473    const char *signature;
 474    int  sig_offset;
 475    int  sig_length;
 476    int  major_bios_version;
 477    int  minor_bios_version;
 478    int  flag; /* 1 == PCI_bus, 2 == ISA_200S, 3 == ISA_250MG, 4 == ISA_200S */
 479 } signatures[] = {
 480    /*          1         2         3         4         5         6 */
 481    /* 123456789012345678901234567890123456789012345678901234567890 */
 482    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89",  5, 50,  2,  0, 0 },
 483    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V1.07/28/89",  5, 50,  2,  0, 0 },
 484    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89", 72, 50,  2,  0, 2 },
 485    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.0",        73, 43,  2,  0, 3 },
 486    { "FUTURE DOMAIN CORP. (C) 1991 1800-V2.0.",            72, 39,  2,  0, 4 },
 487    { "FUTURE DOMAIN CORP. (C) 1992 V3.00.004/02/92",        5, 44,  3,  0, 0 },
 488    { "FUTURE DOMAIN TMC-18XX (C) 1993 V3.203/12/93",        5, 44,  3,  2, 0 },
 489    { "IBM F1 P2 BIOS v1.0104/29/93",                        5, 28,  3, -1, 0 },
 490    { "Future Domain Corp. V1.0008/18/93",                   5, 33,  3,  4, 0 },
 491    { "Future Domain Corp. V1.0008/18/93",                  26, 33,  3,  4, 1 },
 492    { "Adaptec AHA-2920 PCI-SCSI Card",                     42, 31,  3, -1, 1 },
 493    { "IBM F1 P264/32",                                      5, 14,  3, -1, 1 },
 494                                 /* This next signature may not be a 3.5 bios */
 495    { "Future Domain Corp. V2.0108/18/93",                   5, 33,  3,  5, 0 },
 496    { "FUTURE DOMAIN CORP.  V3.5008/18/93",                  5, 34,  3,  5, 0 },
 497    { "FUTURE DOMAIN 18c30/18c50/1800 (C) 1994 V3.5",        5, 44,  3,  5, 0 },
 498    { "FUTURE DOMAIN CORP.  V3.6008/18/93",                  5, 34,  3,  6, 0 },
 499    { "FUTURE DOMAIN CORP.  V3.6108/18/93",                  5, 34,  3,  6, 0 },
 500    { "FUTURE DOMAIN TMC-18XX",                              5, 22, -1, -1, 0 },
 501
 502    /* READ NOTICE ABOVE *BEFORE* YOU WASTE YOUR TIME ADDING A SIGNATURE
 503     Also, fix the disk geometry code for your signature and send your
 504     changes for faith@cs.unc.edu.  Above all, do *NOT* change any old
 505     signatures!
 506
 507     Note that the last line will match a "generic" 18XX bios.  Because
 508     Future Domain has changed the host SCSI ID and/or the location of the
 509     geometry information in the on-board RAM area for each of the first
 510     three BIOS's, it is still important to enter a fully qualified
 511     signature in the table for any new BIOS's (after the host SCSI ID and
 512     geometry location are verified). */
 513 };
 514
 515 #define SIGNATURE_COUNT (sizeof( signatures ) / sizeof( struct signature ))
 516
 517 static void print_banner( struct Scsi_Host *shpnt )
 518 {
 519    if (!shpnt) return;          /* This won't ever happen */
 520
 521    if (bios_major < 0 && bios_minor < 0) {
 522       printk(KERN_INFO "scsi%d: <fdomain> No BIOS; using scsi id %d\n",
 523               shpnt->host_no, shpnt->this_id);
 524    } else {
 525       printk(KERN_INFO "scsi%d: <fdomain> BIOS version ", shpnt->host_no);
 526
 527       if (bios_major >= 0) printk("%d.", bios_major);
 528       else                 printk("?.");
 529
 530       if (bios_minor >= 0) printk("%d", bios_minor);
 531       else                 printk("?.");
 532
 533       printk( " at 0x%lx using scsi id %d\n",
 534               bios_base, shpnt->this_id );
 535    }
 536
 537                                 /* If this driver works for later FD PCI
 538                                    boards, we will have to modify banner
 539                                    for additional PCI cards, but for now if
 540                                    it's PCI it's a TMC-3260 - JTM */
 541    printk(KERN_INFO "scsi%d: <fdomain> %s chip at 0x%x irq ",
 542            shpnt->host_no,
 543            chip == tmc1800 ? "TMC-1800" : (chip == tmc18c50 ? "TMC-18C50" : (chip == tmc18c30 ? (PCI_bus ? "TMC-36C70 (PCI bus)" : "TMC-18C30") : "Unknown")),
 544            port_base);
 545
 546    if (interrupt_level)
 547         printk("%d", interrupt_level);
 548    else
 549         printk("<none>");
 550
 551    printk( "\n" );
 552 }
 553
 554 int __init fdomain_setup(char *str)
 555 {
 556         int ints[4];
 557
 558         (void)get_options(str, ARRAY_SIZE(ints), ints);
 559
 560         if (setup_called++ || ints[0] < 2 || ints[0] > 3) {
 561                 printk(KERN_INFO "scsi: <fdomain> Usage: fdomain=<PORT_BASE>,<IRQ>[,<ADAPTER_ID>]\n");
 562                 printk(KERN_ERR "scsi: <fdomain> Bad LILO/INSMOD parameters?\n");
 563                 return 0;
 564         }
 565
 566         port_base       = ints[0] >= 1 ? ints[1] : 0;
 567         interrupt_level = ints[0] >= 2 ? ints[2] : 0;
 568         this_id         = ints[0] >= 3 ? ints[3] : 0;
 569
 570         bios_major = bios_minor = -1; /* Use geometry for BIOS version >= 3.4 */
 571         ++setup_called;
 572         return 1;
 573 }
 574
 575 __setup("fdomain=", fdomain_setup);
 576
 577
 578 static void do_pause(unsigned amount)   /* Pause for amount*10 milliseconds */
 579 {
 580         mdelay(10*amount);
 581 }
 582
 583 inline static void fdomain_make_bus_idle( void )
 584 {
 585    outb( 0, SCSI_Cntl_port );
 586    outb( 0, SCSI_Mode_Cntl_port );
 587    if (chip == tmc18c50 || chip == tmc18c30)
 588          outb( 0x21 | PARITY_MASK, TMC_Cntl_port ); /* Clear forced intr. */
 589    else
 590          outb( 0x01 | PARITY_MASK, TMC_Cntl_port );
 591 }
 592
 593 static int fdomain_is_valid_port( int port )
 594 {
 595 #if DEBUG_DETECT
 596    printk( " (%x%x),",
 597            inb( port + MSB_ID_Code ), inb( port + LSB_ID_Code ) );
 598 #endif
 599
 600    /* The MCA ID is a unique id for each MCA compatible board.  We
 601       are using ISA boards, but Future Domain provides the MCA ID
 602       anyway.  We can use this ID to ensure that this is a Future
 603       Domain TMC-1660/TMC-1680.
 604     */
 605
 606    if (inb( port + LSB_ID_Code ) != 0xe9) { /* test for 0x6127 id */
 607       if (inb( port + LSB_ID_Code ) != 0x27) return 0;
 608       if (inb( port + MSB_ID_Code ) != 0x61) return 0;
 609       chip = tmc1800;
 610    } else {                                 /* test for 0xe960 id */
 611       if (inb( port + MSB_ID_Code ) != 0x60) return 0;
 612       chip = tmc18c50;
 613
 614                                 /* Try to toggle 32-bit mode.  This only
 615                                    works on an 18c30 chip.  (User reports
 616                                    say this works, so we should switch to
 617                                    it in the near future.) */
 618
 619       outb( 0x80, port + IO_Control );
 620       if ((inb( port + Configuration2 ) & 0x80) == 0x80) {
 621          outb( 0x00, port + IO_Control );
 622          if ((inb( port + Configuration2 ) & 0x80) == 0x00) {
 623             chip = tmc18c30;
 624             FIFO_Size = 0x800;  /* 2k FIFO */
 625          }
 626       }
 627                                 /* If that failed, we are an 18c50. */
 628    }
 629
 630    return 1;
 631 }
 632
 633 static int fdomain_test_loopback( void )
 634 {
 635    int i;
 636    int result;
 637
 638    for (i = 0; i < 255; i++) {
 639       outb( i, port_base + Write_Loopback );
 640       result = inb( port_base + Read_Loopback );
 641       if (i != result)
 642             return 1;
 643    }
 644    return 0;
 645 }
 646
 647 /* fdomain_get_irq assumes that we have a valid MCA ID for a
 648    TMC-1660/TMC-1680 Future Domain board.  Now, check to be sure the
 649    bios_base matches these ports.  If someone was unlucky enough to have
 650    purchased more than one Future Domain board, then they will have to
 651    modify this code, as we only detect one board here.  [The one with the
 652    lowest bios_base.]
 653
 654    Note that this routine is only used for systems without a PCI BIOS32
 655    (e.g., ISA bus).  For PCI bus systems, this routine will likely fail
 656    unless one of the IRQs listed in the ints array is used by the board.
 657    Sometimes it is possible to use the computer's BIOS setup screen to
 658    configure a PCI system so that one of these IRQs will be used by the
 659    Future Domain card. */
 660
 661 static int fdomain_get_irq( int base )
 662 {
 663    int options = inb(base + Configuration1);
 664
 665 #if DEBUG_DETECT
 666    printk("scsi: <fdomain> Options = %x\n", options);
 667 #endif
 668
 669    /* Check for board with lowest bios_base --
 670       this isn't valid for the 18c30 or for
 671       boards on the PCI bus, so just assume we
 672       have the right board. */
 673
 674    if (chip != tmc18c30 && !PCI_bus && addresses[(options & 0xc0) >> 6 ] != bios_base)
 675         return 0;
 676    return ints[(options & 0x0e) >> 1];
 677 }
 678
 679 static int fdomain_isa_detect( int *irq, int *iobase )
 680 {
 681    int i, j;
 682    int base = 0xdeadbeef;
 683    int flag = 0;
 684
 685 #if DEBUG_DETECT
 686    printk( "scsi: <fdomain> fdomain_isa_detect:" );
 687 #endif
 688
 689    for (i = 0; !bios_base && i < ADDRESS_COUNT; i++) {
 690 #if DEBUG_DETECT
 691       printk( " %lx(%lx),", addresses[i], bios_base );
 692 #endif
 693       for (j = 0; !bios_base && j < SIGNATURE_COUNT; j++) {
 694          if (isa_check_signature(addresses[i] + signatures[j].sig_offset,
 695                              signatures[j].signature,
 696                              signatures[j].sig_length )) {
 697             bios_major = signatures[j].major_bios_version;
 698             bios_minor = signatures[j].minor_bios_version;
 699             PCI_bus    = (signatures[j].flag == 1);
 700             Quantum    = (signatures[j].flag > 1) ? signatures[j].flag : 0;
 701             bios_base  = addresses[i];
 702          }
 703       }
 704    }
 705
 706    if (bios_major == 2) {
 707       /* The TMC-1660/TMC-1680 has a RAM area just after the BIOS ROM.
 708          Assuming the ROM is enabled (otherwise we wouldn't have been
 709          able to read the ROM signature :-), then the ROM sets up the
 710          RAM area with some magic numbers, such as a list of port
 711          base addresses and a list of the disk "geometry" reported to
 712          DOS (this geometry has nothing to do with physical geometry).
 713        */
 714
 715       switch (Quantum) {
 716       case 2:                   /* ISA_200S */
 717       case 3:                   /* ISA_250MG */
 718          base = isa_readb(bios_base + 0x1fa2) + (isa_readb(bios_base + 0x1fa3) << 8);
 719          break;
 720       case 4:                   /* ISA_200S (another one) */
 721          base = isa_readb(bios_base + 0x1fa3) + (isa_readb(bios_base + 0x1fa4) << 8);
 722          break;
 723       default:
 724          base = isa_readb(bios_base + 0x1fcc) + (isa_readb(bios_base + 0x1fcd) << 8);
 725          break;
 726       }
 727
 728 #if DEBUG_DETECT
 729       printk( " %x,", base );
 730 #endif
 731
 732       for (flag = 0, i = 0; !flag && i < PORT_COUNT; i++) {
 733          if (base == ports[i])
 734                ++flag;
 735       }
 736
 737       if (flag && fdomain_is_valid_port( base )) {
 738          *irq    = fdomain_get_irq( base );
 739          *iobase = base;
 740          return 1;
 741       }
 742
 743       /* This is a bad sign.  It usually means that someone patched the
 744          BIOS signature list (the signatures variable) to contain a BIOS
 745          signature for a board *OTHER THAN* the TMC-1660/TMC-1680. */
 746
 747 #if DEBUG_DETECT
 748       printk( " RAM FAILED, " );
 749 #endif
 750    }
 751
 752    /* Anyway, the alternative to finding the address in the RAM is to just
 753       search through every possible port address for one that is attached
 754       to the Future Domain card.  Don't panic, though, about reading all
 755       these random port addresses -- there are rumors that the Future
 756       Domain BIOS does something very similar.
 757
 758       Do not, however, check ports which the kernel knows are being used by
 759       another driver. */
 760
 761    for (i = 0; i < PORT_COUNT; i++) {
 762       base = ports[i];
 763       if (check_region( base, 0x10 )) {
 764 #if DEBUG_DETECT
 765          printk( " (%x inuse),", base );
 766 #endif
 767          continue;
 768       }
 769 #if DEBUG_DETECT
 770       printk( " %x,", base );
 771 #endif
 772       if ((flag = fdomain_is_valid_port( base ))) break;
 773    }
 774
 775 #if DEBUG_DETECT
 776    if (flag) printk( " SUCCESS\n" );
 777    else      printk( " FAILURE\n" );
 778 #endif
 779
 780    if (!flag) return 0;         /* iobase not found */
 781
 782    *irq    = fdomain_get_irq( base );
 783    *iobase = base;
 784
 785    return 1;                    /* success */
 786 }
 787
 788 /* PCI detection function: int fdomain_pci_bios_detect(int* irq, int*
 789    iobase) This function gets the Interrupt Level and I/O base address from
 790    the PCI configuration registers. */
 791
 792 #ifdef CONFIG_PCI
 793 static int fdomain_pci_bios_detect( int *irq, int *iobase, struct pci_dev **ret_pdev )
 794 {
 795    unsigned int     pci_irq;                /* PCI interrupt line */
 796    unsigned long    pci_base;               /* PCI I/O base address */
 797    struct pci_dev   *pdev = NULL;
 798
 799 #if DEBUG_DETECT
 800    /* Tell how to print a list of the known PCI devices from bios32 and
 801       list vendor and device IDs being used if in debug mode.  */
 802
 803    printk( "scsi: <fdomain> INFO: use lspci -v to see list of PCI devices\n" );
 804    printk( "scsi: <fdomain> TMC-3260 detect:"
 805            " Using Vendor ID: 0x%x and Device ID: 0x%x\n",
 806            PCI_VENDOR_ID_FD,
 807            PCI_DEVICE_ID_FD_36C70 );
 808 #endif
 809
 810    if ((pdev = pci_find_device(PCI_VENDOR_ID_FD, PCI_DEVICE_ID_FD_36C70, pdev)) == NULL)
 811                 return 0;
 812    if (pci_enable_device(pdev)) return 0;
 813
 814 #if DEBUG_DETECT
 815    printk( "scsi: <fdomain> TMC-3260 detect:"
 816            " PCI bus %u, device %u, function %u\n",
 817            pdev->bus->number,
 818            PCI_SLOT(pdev->devfn),
 819            PCI_FUNC(pdev->devfn));
 820 #endif
 821
 822    /* We now have the appropriate device function for the FD board so we
 823       just read the PCI config info from the registers.  */
 824
 825    pci_base = pci_resource_start(pdev, 0);
 826    pci_irq = pdev->irq;
 827
 828    /* Now we have the I/O base address and interrupt from the PCI
 829       configuration registers. */
 830
 831    *irq    = pci_irq;
 832    *iobase = pci_base;
 833    *ret_pdev = pdev;
 834
 835 #if DEBUG_DETECT
 836    printk( "scsi: <fdomain> TMC-3260 detect:"
 837            " IRQ = %d, I/O base = 0x%x [0x%lx]\n", *irq, *iobase, pci_base );
 838 #endif
 839
 840    if (!fdomain_is_valid_port( *iobase )) {
 841       printk(KERN_ERR "scsi: <fdomain> PCI card detected, but driver not loaded (invalid port)\n" );
 842       return 0;
 843    }
 844
 845                                 /* Fill in a few global variables.  Ugh. */
 846    bios_major = bios_minor = -1;
 847    PCI_bus    = 1;
 848    Quantum    = 0;
 849    bios_base  = 0;
 850
 851    return 1;
 852 }
 853 #endif
 854
 855 struct Scsi_Host *__fdomain_16x0_detect( Scsi_Host_Template *tpnt )
 856 {
 857    int              retcode;
 858    struct Scsi_Host *shpnt;
 859    struct pci_dev *pdev = NULL;
 860
 861    if (setup_called) {
 862 #if DEBUG_DETECT
 863       printk( "scsi: <fdomain> No BIOS, using port_base = 0x%x, irq = %d\n",
 864               port_base, interrupt_level );
 865 #endif
 866       if (!fdomain_is_valid_port( port_base )) {
 867          printk( "scsi: <fdomain> Cannot locate chip at port base 0x%x\n",
 868                  port_base );
 869          printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
 870          return NULL;
 871       }
 872    } else {
 873       int flag = 0;
 874
 875 #ifdef CONFIG_PCI
 876                                 /* Try PCI detection first */
 877       flag = fdomain_pci_bios_detect( &interrupt_level, &port_base, &pdev );
 878 #endif
 879       if (!flag) {
 880                                 /* Then try ISA bus detection */
 881          flag = fdomain_isa_detect( &interrupt_level, &port_base );
 882
 883          if (!flag) {
 884             printk( "scsi: <fdomain> Detection failed (no card)\n" );
 885             return NULL;
 886          }
 887       }
 888    }
 889
 890    SCSI_Mode_Cntl_port   = port_base + SCSI_Mode_Cntl;
 891    FIFO_Data_Count_port  = port_base + FIFO_Data_Count;
 892    Interrupt_Cntl_port   = port_base + Interrupt_Cntl;
 893    Interrupt_Status_port = port_base + Interrupt_Status;
 894    Read_FIFO_port        = port_base + Read_FIFO;
 895    Read_SCSI_Data_port   = port_base + Read_SCSI_Data;
 896    SCSI_Cntl_port        = port_base + SCSI_Cntl;
 897    SCSI_Data_NoACK_port  = port_base + SCSI_Data_NoACK;
 898    SCSI_Status_port      = port_base + SCSI_Status;
 899    TMC_Cntl_port         = port_base + TMC_Cntl;
 900    TMC_Status_port       = port_base + TMC_Status;
 901    Write_FIFO_port       = port_base + Write_FIFO;
 902    Write_SCSI_Data_port  = port_base + Write_SCSI_Data;
 903
 904    fdomain_16x0_bus_reset( NULL);
 905
 906    if (fdomain_test_loopback()) {
 907       printk(KERN_ERR  "scsi: <fdomain> Detection failed (loopback test failed at port base 0x%x)\n", port_base);
 908       if (setup_called) {
 909          printk(KERN_ERR "scsi: <fdomain> Bad LILO/INSMOD parameters?\n");
 910       }
 911       return NULL;
 912    }
 913
 914    if (this_id) {
 915       tpnt->this_id = (this_id & 0x07);
 916       adapter_mask  = (1 << tpnt->this_id);
 917    } else {
 918       if (PCI_bus || (bios_major == 3 && bios_minor >= 2) || bios_major < 0) {
 919          tpnt->this_id = 7;
 920          adapter_mask  = 0x80;
 921       } else {
 922          tpnt->this_id = 6;
 923          adapter_mask  = 0x40;
 924       }
 925    }
 926
 927 /* Print out a banner here in case we can't
 928    get resources.  */
 929
 930    shpnt = scsi_register( tpnt, 0 );
 931    if(shpnt == NULL)
 932         return NULL;
 933    shpnt->irq = interrupt_level;
 934    shpnt->io_port = port_base;
 935    scsi_set_device(shpnt, &pdev->dev);
 936    shpnt->n_io_port = 0x10;
 937    print_banner( shpnt );
 938
 939    /* Log IRQ with kernel */
 940    if (!interrupt_level) {
 941       printk(KERN_ERR "scsi: <fdomain> Card Detected, but driver not loaded (no IRQ)\n" );
 942       return NULL;
 943    } else {
 944       /* Register the IRQ with the kernel */
 945
 946       retcode = request_irq( interrupt_level,
 947                              do_fdomain_16x0_intr, pdev?SA_SHIRQ:0, "fdomain", shpnt);
 948
 949       if (retcode < 0) {
 950          if (retcode == -EINVAL) {
 951             printk(KERN_ERR "scsi: <fdomain> IRQ %d is bad!\n", interrupt_level );
 952             printk(KERN_ERR "                This shouldn't happen!\n" );
 953             printk(KERN_ERR "                Send mail to faith@acm.org\n" );
 954          } else if (retcode == -EBUSY) {
 955             printk(KERN_ERR "scsi: <fdomain> IRQ %d is already in use!\n", interrupt_level );
 956             printk(KERN_ERR "                Please use another IRQ!\n" );
 957          } else {
 958             printk(KERN_ERR "scsi: <fdomain> Error getting IRQ %d\n", interrupt_level );
 959             printk(KERN_ERR "                This shouldn't happen!\n" );
 960             printk(KERN_ERR "                Send mail to faith@acm.org\n" );
 961          }
 962          printk(KERN_ERR "scsi: <fdomain> Detected, but driver not loaded (IRQ)\n" );
 963          return NULL;
 964       }
 965    }
 966
 967    /* Log I/O ports with kernel */
 968    request_region( port_base, 0x10, "fdomain" );
 969
 970    return shpnt;
 971 }
 972
 973 static int fdomain_16x0_detect( Scsi_Host_Template *tpnt )
 974 {
 975         if (fdomain)
 976                 fdomain_setup(fdomain);
 977         return (__fdomain_16x0_detect(tpnt) != NULL);
 978 }
 979
 980 static const char *fdomain_16x0_info( struct Scsi_Host *ignore )
 981 {
 982    static char buffer[128];
 983    char        *pt;
 984
 985    strcpy( buffer, "Future Domain 16-bit SCSI Driver Version" );
 986    if (strchr( VERSION, ':')) { /* Assume VERSION is an RCS Revision string */
 987       strcat( buffer, strchr( VERSION, ':' ) + 1 );
 988       pt = strrchr( buffer, '$') - 1;
 989       if (!pt)                  /* Stripped RCS Revision string? */
 990             pt = buffer + strlen( buffer ) - 1;
 991       if (*pt != ' ')
 992             ++pt;
 993       *pt = '\0';
 994    } else {                     /* Assume VERSION is a number */
 995       strcat( buffer, " " VERSION );
 996    }
 997
 998    return buffer;
 999 }
1000
1001 #if 0
1002 static int fdomain_arbitrate( void )
1003 {
1004    int           status = 0;
1005    unsigned long timeout;
1006
1007 #if EVERY_ACCESS
1008    printk( "fdomain_arbitrate()\n" );
1009 #endif
1010
1011    outb( 0x00, SCSI_Cntl_port );              /* Disable data drivers */
1012    outb( adapter_mask, port_base + SCSI_Data_NoACK ); /* Set our id bit */
1013    outb( 0x04 | PARITY_MASK, TMC_Cntl_port ); /* Start arbitration */
1014
1015    timeout = 500;
1016    do {
1017       status = inb( TMC_Status_port );        /* Read adapter status */
1018       if (status & 0x02)                      /* Arbitration complete */
1019             return 0;
1020       mdelay(1);                        /* Wait one millisecond */
1021    } while (--timeout);
1022
1023    /* Make bus idle */
1024    fdomain_make_bus_idle();
1025
1026 #if EVERY_ACCESS
1027    printk( "Arbitration failed, status = %x\n", status );
1028 #endif
1029 #if ERRORS_ONLY
1030    printk( "scsi: <fdomain> Arbitration failed, status = %x\n", status );
1031 #endif
1032    return 1;
1033 }
1034 #endif
1035
1036 static int fdomain_select( int target )
1037 {
1038    int           status;
1039    unsigned long timeout;
1040 #if ERRORS_ONLY
1041    static int    flag = 0;
1042 #endif
1043
1044    outb( 0x82, SCSI_Cntl_port ); /* Bus Enable + Select */
1045    outb( adapter_mask | (1 << target), SCSI_Data_NoACK_port );
1046
1047    /* Stop arbitration and enable parity */
1048    outb( PARITY_MASK, TMC_Cntl_port );
1049
1050    timeout = 350;                       /* 350 msec */
1051
1052    do {
1053       status = inb( SCSI_Status_port ); /* Read adapter status */
1054       if (status & 1) {                 /* Busy asserted */
1055          /* Enable SCSI Bus (on error, should make bus idle with 0) */
1056          outb( 0x80, SCSI_Cntl_port );
1057          return 0;
1058       }
1059       mdelay(1);                        /* wait one msec */
1060    } while (--timeout);
1061    /* Make bus idle */
1062    fdomain_make_bus_idle();
1063 #if EVERY_ACCESS
1064    if (!target) printk( "Selection failed\n" );
1065 #endif
1066 #if ERRORS_ONLY
1067    if (!target) {
1068       if (!flag) /* Skip first failure for all chips. */
1069             ++flag;
1070       else
1071             printk( "scsi: <fdomain> Selection failed\n" );
1072    }
1073 #endif
1074    return 1;
1075 }
1076
1077 static void my_done(int error)
1078 {
1079    if (in_command) {
1080       in_command = 0;
1081       outb( 0x00, Interrupt_Cntl_port );
1082       fdomain_make_bus_idle();
1083       current_SC->result = error;
1084       if (current_SC->scsi_done)
1085             current_SC->scsi_done( current_SC );
1086       else panic( "scsi: <fdomain> current_SC->scsi_done() == NULL" );
1087    } else {
1088       panic( "scsi: <fdomain> my_done() called outside of command\n" );
1089    }
1090 #if DEBUG_RACE
1091    in_interrupt_flag = 0;
1092 #endif
1093 }
1094
1095 static irqreturn_t do_fdomain_16x0_intr(int irq, void *dev_id,
1096                                         struct pt_regs * regs )
1097 {
1098    unsigned long flags;
1099    int      status;
1100    int      done = 0;
1101    unsigned data_count;
1102
1103                                 /* The fdomain_16x0_intr is only called via
1104                                    the interrupt handler.  The goal of the
1105                                    sti() here is to allow other
1106                                    interruptions while this routine is
1107                                    running. */
1108
1109    /* Check for other IRQ sources */
1110    if((inb(TMC_Status_port)&0x01)==0)
1111         return IRQ_NONE;
1112
1113    /* It is our IRQ */
1114    outb( 0x00, Interrupt_Cntl_port );
1115
1116    /* We usually have one spurious interrupt after each command.  Ignore it. */
1117    if (!in_command || !current_SC) {    /* Spurious interrupt */
1118 #if EVERY_ACCESS
1119       printk( "Spurious interrupt, in_command = %d, current_SC = %x\n",
1120               in_command, current_SC );
1121 #endif
1122       return IRQ_NONE;
1123    }
1124
1125    /* Abort calls my_done, so we do nothing here. */
1126    if (current_SC->SCp.phase & aborted) {
1127 #if DEBUG_ABORT
1128       printk( "scsi: <fdomain> Interrupt after abort, ignoring\n" );
1129 #endif
1130       /*
1131       return IRQ_HANDLED; */
1132    }
1133
1134 #if DEBUG_RACE
1135    ++in_interrupt_flag;
1136 #endif
1137
1138    if (current_SC->SCp.phase & in_arbitration) {
1139       status = inb( TMC_Status_port );        /* Read adapter status */
1140       if (!(status & 0x02)) {
1141 #if EVERY_ACCESS
1142          printk( " AFAIL " );
1143 #endif
1144          spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1145          my_done( DID_BUS_BUSY << 16 );
1146          spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1147          return IRQ_HANDLED;
1148       }
1149       current_SC->SCp.phase = in_selection;
1150
1151       outb( 0x40 | FIFO_COUNT, Interrupt_Cntl_port );
1152
1153       outb( 0x82, SCSI_Cntl_port ); /* Bus Enable + Select */
1154       outb( adapter_mask | (1 << current_SC->device->id), SCSI_Data_NoACK_port );
1155
1156       /* Stop arbitration and enable parity */
1157       outb( 0x10 | PARITY_MASK, TMC_Cntl_port );
1158 #if DEBUG_RACE
1159       in_interrupt_flag = 0;
1160 #endif
1161       return IRQ_HANDLED;
1162    } else if (current_SC->SCp.phase & in_selection) {
1163       status = inb( SCSI_Status_port );
1164       if (!(status & 0x01)) {
1165          /* Try again, for slow devices */
1166          if (fdomain_select( current_SC->device->id )) {
1167 #if EVERY_ACCESS
1168             printk( " SFAIL " );
1169 #endif
1170             spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1171             my_done( DID_NO_CONNECT << 16 );
1172             spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1173             return IRQ_HANDLED;
1174          } else {
1175 #if EVERY_ACCESS
1176             printk( " AltSel " );
1177 #endif
1178             /* Stop arbitration and enable parity */
1179             outb( 0x10 | PARITY_MASK, TMC_Cntl_port );
1180          }
1181       }
1182       current_SC->SCp.phase = in_other;
1183       outb( 0x90 | FIFO_COUNT, Interrupt_Cntl_port );
1184       outb( 0x80, SCSI_Cntl_port );
1185 #if DEBUG_RACE
1186       in_interrupt_flag = 0;
1187 #endif
1188       return IRQ_HANDLED;
1189    }
1190
1191    /* current_SC->SCp.phase == in_other: this is the body of the routine */
1192
1193    status = inb( SCSI_Status_port );
1194
1195    if (status & 0x10) { /* REQ */
1196
1197       switch (status & 0x0e) {
1198
1199       case 0x08:                /* COMMAND OUT */
1200          outb( current_SC->cmnd[current_SC->SCp.sent_command++],
1201                Write_SCSI_Data_port );
1202 #if EVERY_ACCESS
1203          printk( "CMD = %x,",
1204                  current_SC->cmnd[ current_SC->SCp.sent_command - 1] );
1205 #endif
1206          break;
1207       case 0x00:                /* DATA OUT -- tmc18c50/tmc18c30 only */
1208          if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1209             current_SC->SCp.have_data_in = -1;
1210             outb( 0xd0 | PARITY_MASK, TMC_Cntl_port );
1211          }
1212          break;
1213       case 0x04:                /* DATA IN -- tmc18c50/tmc18c30 only */
1214          if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1215             current_SC->SCp.have_data_in = 1;
1216             outb( 0x90 | PARITY_MASK, TMC_Cntl_port );
1217          }
1218          break;
1219       case 0x0c:                /* STATUS IN */
1220          current_SC->SCp.Status = inb( Read_SCSI_Data_port );
1221 #if EVERY_ACCESS
1222          printk( "Status = %x, ", current_SC->SCp.Status );
1223 #endif
1224 #if ERRORS_ONLY
1225          if (current_SC->SCp.Status
1226              && current_SC->SCp.Status != 2
1227              && current_SC->SCp.Status != 8) {
1228             printk( "scsi: <fdomain> target = %d, command = %x, status = %x\n",
1229                     current_SC->device->id,
1230                     current_SC->cmnd[0],
1231                     current_SC->SCp.Status );
1232          }
1233 #endif
1234                break;
1235       case 0x0a:                /* MESSAGE OUT */
1236          outb( MESSAGE_REJECT, Write_SCSI_Data_port ); /* Reject */
1237          break;
1238       case 0x0e:                /* MESSAGE IN */
1239          current_SC->SCp.Message = inb( Read_SCSI_Data_port );
1240 #if EVERY_ACCESS
1241          printk( "Message = %x, ", current_SC->SCp.Message );
1242 #endif
1243          if (!current_SC->SCp.Message) ++done;
1244 #if DEBUG_MESSAGES || EVERY_ACCESS
1245          if (current_SC->SCp.Message) {
1246             printk( "scsi: <fdomain> message = %x\n",
1247                     current_SC->SCp.Message );
1248          }
1249 #endif
1250          break;
1251       }
1252    }
1253
1254    if (chip == tmc1800 && !current_SC->SCp.have_data_in
1255        && (current_SC->SCp.sent_command >= current_SC->cmd_len)) {
1256
1257       if(scsi_to_pci_dma_dir(current_SC->sc_data_direction)     == PCI_DMA_TODEVICE)
1258       {
1259          current_SC->SCp.have_data_in = -1;
1260          outb( 0xd0 | PARITY_MASK, TMC_Cntl_port );
1261       }
1262       else
1263       {
1264          current_SC->SCp.have_data_in = 1;
1265          outb( 0x90 | PARITY_MASK, TMC_Cntl_port );
1266       }
1267    }
1268
1269    if (current_SC->SCp.have_data_in == -1) { /* DATA OUT */
1270       while ( (data_count = FIFO_Size - inw( FIFO_Data_Count_port )) > 512 ) {
1271 #if EVERY_ACCESS
1272          printk( "DC=%d, ", data_count ) ;
1273 #endif
1274          if (data_count > current_SC->SCp.this_residual)
1275                data_count = current_SC->SCp.this_residual;
1276          if (data_count > 0) {
1277 #if EVERY_ACCESS
1278             printk( "%d OUT, ", data_count );
1279 #endif
1280             if (data_count == 1) {
1281                outb( *current_SC->SCp.ptr++, Write_FIFO_port );
1282                --current_SC->SCp.this_residual;
1283             } else {
1284                data_count >>= 1;
1285                outsw( Write_FIFO_port, current_SC->SCp.ptr, data_count );
1286                current_SC->SCp.ptr += 2 * data_count;
1287                current_SC->SCp.this_residual -= 2 * data_count;
1288             }
1289          }
1290          if (!current_SC->SCp.this_residual) {
1291             if (current_SC->SCp.buffers_residual) {
1292                --current_SC->SCp.buffers_residual;
1293                ++current_SC->SCp.buffer;
1294                current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1295                current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1296             } else
1297                   break;
1298          }
1299       }
1300    }
1301
1302    if (current_SC->SCp.have_data_in == 1) { /* DATA IN */
1303       while ((data_count = inw( FIFO_Data_Count_port )) > 0) {
1304 #if EVERY_ACCESS
1305          printk( "DC=%d, ", data_count );
1306 #endif
1307          if (data_count > current_SC->SCp.this_residual)
1308                data_count = current_SC->SCp.this_residual;
1309          if (data_count) {
1310 #if EVERY_ACCESS
1311             printk( "%d IN, ", data_count );
1312 #endif
1313             if (data_count == 1) {
1314                *current_SC->SCp.ptr++ = inb( Read_FIFO_port );
1315                --current_SC->SCp.this_residual;
1316             } else {
1317                data_count >>= 1; /* Number of words */
1318                insw( Read_FIFO_port, current_SC->SCp.ptr, data_count );
1319                current_SC->SCp.ptr += 2 * data_count;
1320                current_SC->SCp.this_residual -= 2 * data_count;
1321             }
1322          }
1323          if (!current_SC->SCp.this_residual
1324              && current_SC->SCp.buffers_residual) {
1325             --current_SC->SCp.buffers_residual;
1326             ++current_SC->SCp.buffer;
1327             current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1328             current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1329          }
1330       }
1331    }
1332
1333    if (done) {
1334 #if EVERY_ACCESS
1335       printk( " ** IN DONE %d ** ", current_SC->SCp.have_data_in );
1336 #endif
1337
1338 #if ERRORS_ONLY
1339       if (current_SC->cmnd[0] == REQUEST_SENSE && !current_SC->SCp.Status) {
1340          if ((unsigned char)(*((char *)current_SC->request_buffer+2)) & 0x0f) {
1341             unsigned char key;
1342             unsigned char code;
1343             unsigned char qualifier;
1344
1345             key = (unsigned char)(*((char *)current_SC->request_buffer + 2))
1346                   & 0x0f;
1347             code = (unsigned char)(*((char *)current_SC->request_buffer + 12));
1348             qualifier = (unsigned char)(*((char *)current_SC->request_buffer
1349                                           + 13));
1350
1351             if (key != UNIT_ATTENTION
1352                 && !(key == NOT_READY
1353                      && code == 0x04
1354                      && (!qualifier || qualifier == 0x02 || qualifier == 0x01))
1355                 && !(key == ILLEGAL_REQUEST && (code == 0x25
1356                                                 || code == 0x24
1357                                                 || !code)))
1358
1359                   printk( "scsi: <fdomain> REQUEST SENSE"
1360                           " Key = %x, Code = %x, Qualifier = %x\n",
1361                           key, code, qualifier );
1362          }
1363       }
1364 #endif
1365 #if EVERY_ACCESS
1366       printk( "BEFORE MY_DONE. . ." );
1367 #endif
1368       spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1369       my_done( (current_SC->SCp.Status & 0xff)
1370                | ((current_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16) );
1371       spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1372 #if EVERY_ACCESS
1373       printk( "RETURNING.\n" );
1374 #endif
1375
1376    } else {
1377       if (current_SC->SCp.phase & disconnect) {
1378          outb( 0xd0 | FIFO_COUNT, Interrupt_Cntl_port );
1379          outb( 0x00, SCSI_Cntl_port );
1380       } else {
1381          outb( 0x90 | FIFO_COUNT, Interrupt_Cntl_port );
1382       }
1383    }
1384 #if DEBUG_RACE
1385    in_interrupt_flag = 0;
1386 #endif
1387    return IRQ_HANDLED;
1388 }
1389
1390 static int fdomain_16x0_queue( Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
1391 {
1392    if (in_command) {
1393       panic( "scsi: <fdomain> fdomain_16x0_queue() NOT REENTRANT!\n" );
1394    }
1395 #if EVERY_ACCESS
1396    printk( "queue: target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1397            SCpnt->target,
1398            *(unsigned char *)SCpnt->cmnd,
1399            SCpnt->use_sg,
1400            SCpnt->request_bufflen );
1401 #endif
1402
1403    fdomain_make_bus_idle();
1404
1405    current_SC            = SCpnt; /* Save this for the done function */
1406    current_SC->scsi_done = done;
1407
1408    /* Initialize static data */
1409
1410    if (current_SC->use_sg) {
1411       current_SC->SCp.buffer =
1412             (struct scatterlist *)current_SC->request_buffer;
1413       current_SC->SCp.ptr              = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1414       current_SC->SCp.this_residual    = current_SC->SCp.buffer->length;
1415       current_SC->SCp.buffers_residual = current_SC->use_sg - 1;
1416    } else {
1417       current_SC->SCp.ptr              = (char *)current_SC->request_buffer;
1418       current_SC->SCp.this_residual    = current_SC->request_bufflen;
1419       current_SC->SCp.buffer           = NULL;
1420       current_SC->SCp.buffers_residual = 0;
1421    }
1422
1423
1424    current_SC->SCp.Status              = 0;
1425    current_SC->SCp.Message             = 0;
1426    current_SC->SCp.have_data_in        = 0;
1427    current_SC->SCp.sent_command        = 0;
1428    current_SC->SCp.phase               = in_arbitration;
1429
1430    /* Start arbitration */
1431    outb( 0x00, Interrupt_Cntl_port );
1432    outb( 0x00, SCSI_Cntl_port );              /* Disable data drivers */
1433    outb( adapter_mask, SCSI_Data_NoACK_port ); /* Set our id bit */
1434    ++in_command;
1435    outb( 0x20, Interrupt_Cntl_port );
1436    outb( 0x14 | PARITY_MASK, TMC_Cntl_port ); /* Start arbitration */
1437
1438    return 0;
1439 }
1440
1441 #if DEBUG_ABORT
1442 static void print_info(Scsi_Cmnd *SCpnt)
1443 {
1444    unsigned int imr;
1445    unsigned int irr;
1446    unsigned int isr;
1447
1448    if (!SCpnt || !SCpnt->device || !SCpnt->device->host) {
1449       printk(KERN_WARNING "scsi: <fdomain> Cannot provide detailed information\n");
1450       return;
1451    }
1452
1453    printk(KERN_INFO "%s\n", fdomain_16x0_info( SCpnt->device->host ) );
1454    print_banner(SCpnt->device->host);
1455    switch (SCpnt->SCp.phase) {
1456    case in_arbitration: printk("arbitration"); break;
1457    case in_selection:   printk("selection");   break;
1458    case in_other:       printk("other");       break;
1459    default:             printk("unknown");     break;
1460    }
1461
1462    printk( " (%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1463            SCpnt->SCp.phase,
1464            SCpnt->device->id,
1465            *(unsigned char *)SCpnt->cmnd,
1466            SCpnt->use_sg,
1467            SCpnt->request_bufflen );
1468    printk( "sent_command = %d, have_data_in = %d, timeout = %d\n",
1469            SCpnt->SCp.sent_command,
1470            SCpnt->SCp.have_data_in,
1471            SCpnt->timeout );
1472 #if DEBUG_RACE
1473    printk( "in_interrupt_flag = %d\n", in_interrupt_flag );
1474 #endif
1475
1476    imr = (inb( 0x0a1 ) << 8) + inb( 0x21 );
1477    outb( 0x0a, 0xa0 );
1478    irr = inb( 0xa0 ) << 8;
1479    outb( 0x0a, 0x20 );
1480    irr += inb( 0x20 );
1481    outb( 0x0b, 0xa0 );
1482    isr = inb( 0xa0 ) << 8;
1483    outb( 0x0b, 0x20 );
1484    isr += inb( 0x20 );
1485
1486                                 /* Print out interesting information */
1487    printk( "IMR = 0x%04x", imr );
1488    if (imr & (1 << interrupt_level))
1489          printk( " (masked)" );
1490    printk( ", IRR = 0x%04x, ISR = 0x%04x\n", irr, isr );
1491
1492    printk( "SCSI Status      = 0x%02x\n", inb( SCSI_Status_port ) );
1493    printk( "TMC Status       = 0x%02x", inb( TMC_Status_port ) );
1494    if (inb( TMC_Status_port & 1))
1495          printk( " (interrupt)" );
1496    printk( "\n" );
1497    printk( "Interrupt Status = 0x%02x", inb( Interrupt_Status_port ) );
1498    if (inb( Interrupt_Status_port ) & 0x08)
1499          printk( " (enabled)" );
1500    printk( "\n" );
1501    if (chip == tmc18c50 || chip == tmc18c30) {
1502       printk( "FIFO Status      = 0x%02x\n", inb( port_base + FIFO_Status ) );
1503       printk( "Int. Condition   = 0x%02x\n",
1504               inb( port_base + Interrupt_Cond ) );
1505    }
1506    printk( "Configuration 1  = 0x%02x\n", inb( port_base + Configuration1 ) );
1507    if (chip == tmc18c50 || chip == tmc18c30)
1508          printk( "Configuration 2  = 0x%02x\n",
1509                  inb( port_base + Configuration2 ) );
1510 }
1511 #endif
1512
1513 static int fdomain_16x0_abort( Scsi_Cmnd *SCpnt)
1514 {
1515 #if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
1516    printk( "scsi: <fdomain> abort " );
1517 #endif
1518
1519    if (!in_command) {
1520 #if EVERY_ACCESS || ERRORS_ONLY
1521       printk( " (not in command)\n" );
1522 #endif
1523       return FAILED;
1524    } else printk( "\n" );
1525
1526 #if DEBUG_ABORT
1527    print_info( SCpnt );
1528 #endif
1529
1530    fdomain_make_bus_idle();
1531    current_SC->SCp.phase |= aborted;
1532    current_SC->result = DID_ABORT << 16;
1533
1534    /* Aborts are not done well. . . */
1535    my_done(DID_ABORT << 16);
1536    return SUCCESS;
1537 }
1538
1539 int fdomain_16x0_bus_reset(Scsi_Cmnd *SCpnt)
1540 {
1541    outb( 1, SCSI_Cntl_port );
1542    do_pause( 2 );
1543    outb( 0, SCSI_Cntl_port );
1544    do_pause( 115 );
1545    outb( 0, SCSI_Mode_Cntl_port );
1546    outb( PARITY_MASK, TMC_Cntl_port );
1547    return SUCCESS;
1548 }
1549
1550 static int fdomain_16x0_host_reset(Scsi_Cmnd *SCpnt)
1551 {
1552   return FAILED;
1553 }
1554
1555 static int fdomain_16x0_device_reset(Scsi_Cmnd *SCpnt)
1556 {
1557   return FAILED;
1558 }
1559
1560 #include <scsi/scsi_ioctl.h>
1561
1562 static int fdomain_16x0_biosparam(struct scsi_device *sdev,
1563                 struct block_device *bdev,
1564                 sector_t capacity, int *info_array)
1565 {
1566    int              drive;
1567    unsigned char    buf[512 + sizeof (Scsi_Ioctl_Command)];
1568    Scsi_Ioctl_Command *sic = (Scsi_Ioctl_Command *) buf;
1569    int              size      = capacity;
1570    unsigned char    *data     = sic->data;
1571    unsigned char    do_read[] = { READ_6, 0, 0, 0, 1, 0 };
1572    int              retcode;
1573    unsigned long    offset;
1574    struct drive_info {
1575       unsigned short cylinders;
1576       unsigned char  heads;
1577       unsigned char  sectors;
1578    } i;
1579
1580    /* NOTES:
1581       The RAM area starts at 0x1f00 from the bios_base address.
1582
1583       For BIOS Version 2.0:
1584
1585       The drive parameter table seems to start at 0x1f30.
1586       The first byte's purpose is not known.
1587       Next is the cylinder, head, and sector information.
1588       The last 4 bytes appear to be the drive's size in sectors.
1589       The other bytes in the drive parameter table are unknown.
1590       If anyone figures them out, please send me mail, and I will
1591       update these notes.
1592
1593       Tape drives do not get placed in this table.
1594
1595       There is another table at 0x1fea:
1596       If the byte is 0x01, then the SCSI ID is not in use.
1597       If the byte is 0x18 or 0x48, then the SCSI ID is in use,
1598       although tapes don't seem to be in this table.  I haven't
1599       seen any other numbers (in a limited sample).
1600
1601       0x1f2d is a drive count (i.e., not including tapes)
1602
1603       The table at 0x1fcc are I/O ports addresses for the various
1604       operations.  I calculate these by hand in this driver code.
1605
1606
1607
1608       For the ISA-200S version of BIOS Version 2.0:
1609
1610       The drive parameter table starts at 0x1f33.
1611
1612       WARNING: Assume that the table entry is 25 bytes long.  Someone needs
1613       to check this for the Quantum ISA-200S card.
1614
1615
1616
1617       For BIOS Version 3.2:
1618
1619       The drive parameter table starts at 0x1f70.  Each entry is
1620       0x0a bytes long.  Heads are one less than we need to report.
1621     */
1622
1623    if (MAJOR(bdev->bd_dev) != SCSI_DISK0_MAJOR) {
1624       printk("scsi: <fdomain> fdomain_16x0_biosparam: too many disks");
1625       return 0;
1626    }
1627    drive = MINOR(bdev->bd_dev) >> 4;
1628
1629    if (bios_major == 2) {
1630       switch (Quantum) {
1631       case 2:                   /* ISA_200S */
1632                                 /* The value of 25 has never been verified.
1633                                    It should probably be 15. */
1634          offset = bios_base + 0x1f33 + drive * 25;
1635          break;
1636       case 3:                   /* ISA_250MG */
1637          offset = bios_base + 0x1f36 + drive * 15;
1638          break;
1639       case 4:                   /* ISA_200S (another one) */
1640          offset = bios_base + 0x1f34 + drive * 15;
1641          break;
1642       default:
1643          offset = bios_base + 0x1f31 + drive * 25;
1644          break;
1645       }
1646       isa_memcpy_fromio( &i, offset, sizeof( struct drive_info ) );
1647       info_array[0] = i.heads;
1648       info_array[1] = i.sectors;
1649       info_array[2] = i.cylinders;
1650    } else if (bios_major == 3
1651               && bios_minor >= 0
1652               && bios_minor < 4) { /* 3.0 and 3.2 BIOS */
1653       memcpy_fromio( &i, bios_base + 0x1f71 + drive * 10,
1654                      sizeof( struct drive_info ) );
1655       info_array[0] = i.heads + 1;
1656       info_array[1] = i.sectors;
1657       info_array[2] = i.cylinders;
1658    } else {                     /* 3.4 BIOS (and up?) */
1659       /* This algorithm was provided by Future Domain (much thanks!). */
1660
1661       sic->inlen  = 0;          /* zero bytes out */
1662       sic->outlen = 512;                /* one sector in */
1663       memcpy( data, do_read, sizeof( do_read ) );
1664       retcode = kernel_scsi_ioctl( sdev,
1665                                    SCSI_IOCTL_SEND_COMMAND,
1666                                    sic );
1667       if (!retcode                                  /* SCSI command ok */
1668           && data[511] == 0xaa && data[510] == 0x55 /* Partition table valid */
1669           && data[0x1c2]) {                         /* Partition type */
1670
1671          /* The partition table layout is as follows:
1672
1673             Start: 0x1b3h
1674             Offset: 0 = partition status
1675                     1 = starting head
1676                     2 = starting sector and cylinder (word, encoded)
1677                     4 = partition type
1678                     5 = ending head
1679                     6 = ending sector and cylinder (word, encoded)
1680                     8 = starting absolute sector (double word)
1681                     c = number of sectors (double word)
1682             Signature: 0x1fe = 0x55aa
1683
1684             So, this algorithm assumes:
1685             1) the first partition table is in use,
1686             2) the data in the first entry is correct, and
1687             3) partitions never divide cylinders
1688
1689             Note that (1) may be FALSE for NetBSD (and other BSD flavors),
1690             as well as for Linux.  Note also, that Linux doesn't pay any
1691             attention to the fields that are used by this algorithm -- it
1692             only uses the absolute sector data.  Recent versions of Linux's
1693             fdisk(1) will fill this data in correctly, and forthcoming
1694             versions will check for consistency.
1695
1696             Checking for a non-zero partition type is not part of the
1697             Future Domain algorithm, but it seemed to be a reasonable thing
1698             to do, especially in the Linux and BSD worlds. */
1699
1700          info_array[0] = data[0x1c3] + 1;           /* heads */
1701          info_array[1] = data[0x1c4] & 0x3f;        /* sectors */
1702       } else {
1703
1704          /* Note that this new method guarantees that there will always be
1705             less than 1024 cylinders on a platter.  This is good for drives
1706             up to approximately 7.85GB (where 1GB = 1024 * 1024 kB). */
1707
1708          if ((unsigned int)size >= 0x7e0000U) {
1709             info_array[0] = 0xff; /* heads   = 255 */
1710             info_array[1] = 0x3f; /* sectors =  63 */
1711          } else if ((unsigned int)size >= 0x200000U) {
1712             info_array[0] = 0x80; /* heads   = 128 */
1713             info_array[1] = 0x3f; /* sectors =  63 */
1714          } else {
1715             info_array[0] = 0x40; /* heads   =  64 */
1716             info_array[1] = 0x20; /* sectors =  32 */
1717          }
1718       }
1719                                 /* For both methods, compute the cylinders */
1720       info_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
1721    }
1722
1723    return 0;
1724 }
1725
1726 static int fdomain_16x0_release(struct Scsi_Host *shpnt)
1727 {
1728         if (shpnt->irq)
1729                 free_irq(shpnt->irq, shpnt);
1730         if (shpnt->io_port && shpnt->n_io_port)
1731                 release_region(shpnt->io_port, shpnt->n_io_port);
1732         return 0;
1733 }
1734
1735 Scsi_Host_Template fdomain_driver_template = {
1736         .module                 = THIS_MODULE,
1737         .name                   = "fdomain",
1738         .proc_name              = "fdomain",
1739         .detect                 = fdomain_16x0_detect,
1740         .info                   = fdomain_16x0_info,
1741         .queuecommand           = fdomain_16x0_queue,
1742         .eh_abort_handler       = fdomain_16x0_abort,
1743         .eh_bus_reset_handler   = fdomain_16x0_bus_reset,
1744         .eh_device_reset_handler = fdomain_16x0_device_reset,
1745         .eh_host_reset_handler  = fdomain_16x0_host_reset,
1746         .bios_param             = fdomain_16x0_biosparam,
1747         .release                = fdomain_16x0_release,
1748         .can_queue              = 1,
1749         .this_id                = 6,
1750         .sg_tablesize           = 64,
1751         .cmd_per_lun            = 1,
1752         .use_clustering         = DISABLE_CLUSTERING,
1753 };
1754
1755 #ifndef PCMCIA
1756 #define driver_template fdomain_driver_template
1757 #include "scsi_module.c"
1758 #endif