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 #include <scsi/scsicam.h>
 283
 284 #include <asm/io.h>
 285 #include <asm/system.h>
 286
 287 #include <scsi/scsi.h>
 288 #include <scsi/scsi_cmnd.h>
 289 #include <scsi/scsi_device.h>
 290 #include <scsi/scsi_host.h>
 291 #include <scsi/scsi_ioctl.h>
 292 #include "fdomain.h"
 293
 294 MODULE_AUTHOR("Rickard E. Faith");
 295 MODULE_DESCRIPTION("Future domain SCSI driver");
 296 MODULE_LICENSE("GPL");
 297
 298
 299 #define VERSION          "$Revision: 5.51 $"
 300
 301 /* START OF USER DEFINABLE OPTIONS */
 302
 303 #define DEBUG            0      /* Enable debugging output */
 304 #define ENABLE_PARITY    1      /* Enable SCSI Parity */
 305 #define FIFO_COUNT       2      /* Number of 512 byte blocks before INTR */
 306
 307 /* END OF USER DEFINABLE OPTIONS */
 308
 309 #if DEBUG
 310 #define EVERY_ACCESS     0      /* Write a line on every scsi access */
 311 #define ERRORS_ONLY      1      /* Only write a line if there is an error */
 312 #define DEBUG_DETECT     0      /* Debug fdomain_16x0_detect() */
 313 #define DEBUG_MESSAGES   1      /* Debug MESSAGE IN phase */
 314 #define DEBUG_ABORT      1      /* Debug abort() routine */
 315 #define DEBUG_RESET      1      /* Debug reset() routine */
 316 #define DEBUG_RACE       1      /* Debug interrupt-driven race condition */
 317 #else
 318 #define EVERY_ACCESS     0      /* LEAVE THESE ALONE--CHANGE THE ONES ABOVE */
 319 #define ERRORS_ONLY      0
 320 #define DEBUG_DETECT     0
 321 #define DEBUG_MESSAGES   0
 322 #define DEBUG_ABORT      0
 323 #define DEBUG_RESET      0
 324 #define DEBUG_RACE       0
 325 #endif
 326
 327 /* Errors are reported on the line, so we don't need to report them again */
 328 #if EVERY_ACCESS
 329 #undef ERRORS_ONLY
 330 #define ERRORS_ONLY      0
 331 #endif
 332
 333 #if ENABLE_PARITY
 334 #define PARITY_MASK      0x08
 335 #else
 336 #define PARITY_MASK      0x00
 337 #endif
 338
 339 enum chip_type {
 340    unknown          = 0x00,
 341    tmc1800          = 0x01,
 342    tmc18c50         = 0x02,
 343    tmc18c30         = 0x03,
 344 };
 345
 346 enum {
 347    in_arbitration   = 0x02,
 348    in_selection     = 0x04,
 349    in_other         = 0x08,
 350    disconnect       = 0x10,
 351    aborted          = 0x20,
 352    sent_ident       = 0x40,
 353 };
 354
 355 enum in_port_type {
 356    Read_SCSI_Data   =  0,
 357    SCSI_Status      =  1,
 358    TMC_Status       =  2,
 359    FIFO_Status      =  3,       /* tmc18c50/tmc18c30 only */
 360    Interrupt_Cond   =  4,       /* tmc18c50/tmc18c30 only */
 361    LSB_ID_Code      =  5,
 362    MSB_ID_Code      =  6,
 363    Read_Loopback    =  7,
 364    SCSI_Data_NoACK  =  8,
 365    Interrupt_Status =  9,
 366    Configuration1   = 10,
 367    Configuration2   = 11,       /* tmc18c50/tmc18c30 only */
 368    Read_FIFO        = 12,
 369    FIFO_Data_Count  = 14
 370 };
 371
 372 enum out_port_type {
 373    Write_SCSI_Data  =  0,
 374    SCSI_Cntl        =  1,
 375    Interrupt_Cntl   =  2,
 376    SCSI_Mode_Cntl   =  3,
 377    TMC_Cntl         =  4,
 378    Memory_Cntl      =  5,       /* tmc18c50/tmc18c30 only */
 379    Write_Loopback   =  7,
 380    IO_Control       = 11,       /* tmc18c30 only */
 381    Write_FIFO       = 12
 382 };
 383
 384 /* .bss will zero all the static variables below */
 385 static int               port_base;
 386 static unsigned long     bios_base;
 387 static void __iomem *    bios_mem;
 388 static int               bios_major;
 389 static int               bios_minor;
 390 static int               PCI_bus;
 391 static int               Quantum;       /* Quantum board variant */
 392 static int               interrupt_level;
 393 static volatile int      in_command;
 394 static struct scsi_cmnd  *current_SC;
 395 static enum chip_type    chip              = unknown;
 396 static int               adapter_mask;
 397 static int               this_id;
 398 static int               setup_called;
 399
 400 #if DEBUG_RACE
 401 static volatile int      in_interrupt_flag;
 402 #endif
 403
 404 static int               FIFO_Size = 0x2000; /* 8k FIFO for
 405                                                 pre-tmc18c30 chips */
 406
 407 static irqreturn_t       do_fdomain_16x0_intr( int irq, void *dev_id,
 408                                             struct pt_regs * regs );
 409 /* Allow insmod parameters to be like LILO parameters.  For example:
 410    insmod fdomain fdomain=0x140,11 */
 411 static char * fdomain = NULL;
 412 module_param(fdomain, charp, 0);
 413
 414 static unsigned long addresses[] = {
 415    0xc8000,
 416    0xca000,
 417    0xce000,
 418    0xde000,
 419    0xcc000,             /* Extra addresses for PCI boards */
 420    0xd0000,
 421    0xe0000,
 422 };
 423 #define ADDRESS_COUNT (sizeof( addresses ) / sizeof( unsigned ))
 424
 425 static unsigned short ports[] = { 0x140, 0x150, 0x160, 0x170 };
 426 #define PORT_COUNT (sizeof( ports ) / sizeof( unsigned short ))
 427
 428 static unsigned short ints[] = { 3, 5, 10, 11, 12, 14, 15, 0 };
 429
 430 /*
 431
 432   READ THIS BEFORE YOU ADD A SIGNATURE!
 433
 434   READING THIS SHORT NOTE CAN SAVE YOU LOTS OF TIME!
 435
 436   READ EVERY WORD, ESPECIALLY THE WORD *NOT*
 437
 438   This driver works *ONLY* for Future Domain cards using the TMC-1800,
 439   TMC-18C50, or TMC-18C30 chip.  This includes models TMC-1650, 1660, 1670,
 440   and 1680.  These are all 16-bit cards.
 441
 442   The following BIOS signature signatures are for boards which do *NOT*
 443   work with this driver (these TMC-8xx and TMC-9xx boards may work with the
 444   Seagate driver):
 445
 446   FUTURE DOMAIN CORP. (C) 1986-1988 V4.0I 03/16/88
 447   FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89
 448   FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89
 449   FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90
 450   FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90
 451   FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90
 452   FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92
 453
 454   (The cards which do *NOT* work are all 8-bit cards -- although some of
 455   them have a 16-bit form-factor, the upper 8-bits are used only for IRQs
 456   and are *NOT* used for data.  You can tell the difference by following
 457   the tracings on the circuit board -- if only the IRQ lines are involved,
 458   you have a "8-bit" card, and should *NOT* use this driver.)
 459
 460 */
 461
 462 static struct signature {
 463    const char *signature;
 464    int  sig_offset;
 465    int  sig_length;
 466    int  major_bios_version;
 467    int  minor_bios_version;
 468    int  flag; /* 1 == PCI_bus, 2 == ISA_200S, 3 == ISA_250MG, 4 == ISA_200S */
 469 } signatures[] = {
 470    /*          1         2         3         4         5         6 */
 471    /* 123456789012345678901234567890123456789012345678901234567890 */
 472    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89",  5, 50,  2,  0, 0 },
 473    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V1.07/28/89",  5, 50,  2,  0, 0 },
 474    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89", 72, 50,  2,  0, 2 },
 475    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.0",        73, 43,  2,  0, 3 },
 476    { "FUTURE DOMAIN CORP. (C) 1991 1800-V2.0.",            72, 39,  2,  0, 4 },
 477    { "FUTURE DOMAIN CORP. (C) 1992 V3.00.004/02/92",        5, 44,  3,  0, 0 },
 478    { "FUTURE DOMAIN TMC-18XX (C) 1993 V3.203/12/93",        5, 44,  3,  2, 0 },
 479    { "IBM F1 P2 BIOS v1.0104/29/93",                        5, 28,  3, -1, 0 },
 480    { "Future Domain Corp. V1.0008/18/93",                   5, 33,  3,  4, 0 },
 481    { "Future Domain Corp. V1.0008/18/93",                  26, 33,  3,  4, 1 },
 482    { "Adaptec AHA-2920 PCI-SCSI Card",                     42, 31,  3, -1, 1 },
 483    { "IBM F1 P264/32",                                      5, 14,  3, -1, 1 },
 484                                 /* This next signature may not be a 3.5 bios */
 485    { "Future Domain Corp. V2.0108/18/93",                   5, 33,  3,  5, 0 },
 486    { "FUTURE DOMAIN CORP.  V3.5008/18/93",                  5, 34,  3,  5, 0 },
 487    { "FUTURE DOMAIN 18c30/18c50/1800 (C) 1994 V3.5",        5, 44,  3,  5, 0 },
 488    { "FUTURE DOMAIN CORP.  V3.6008/18/93",                  5, 34,  3,  6, 0 },
 489    { "FUTURE DOMAIN CORP.  V3.6108/18/93",                  5, 34,  3,  6, 0 },
 490    { "FUTURE DOMAIN TMC-18XX",                              5, 22, -1, -1, 0 },
 491
 492    /* READ NOTICE ABOVE *BEFORE* YOU WASTE YOUR TIME ADDING A SIGNATURE
 493     Also, fix the disk geometry code for your signature and send your
 494     changes for faith@cs.unc.edu.  Above all, do *NOT* change any old
 495     signatures!
 496
 497     Note that the last line will match a "generic" 18XX bios.  Because
 498     Future Domain has changed the host SCSI ID and/or the location of the
 499     geometry information in the on-board RAM area for each of the first
 500     three BIOS's, it is still important to enter a fully qualified
 501     signature in the table for any new BIOS's (after the host SCSI ID and
 502     geometry location are verified). */
 503 };
 504
 505 #define SIGNATURE_COUNT (sizeof( signatures ) / sizeof( struct signature ))
 506
 507 static void print_banner( struct Scsi_Host *shpnt )
 508 {
 509    if (!shpnt) return;          /* This won't ever happen */
 510
 511    if (bios_major < 0 && bios_minor < 0) {
 512       printk(KERN_INFO "scsi%d: <fdomain> No BIOS; using scsi id %d\n",
 513               shpnt->host_no, shpnt->this_id);
 514    } else {
 515       printk(KERN_INFO "scsi%d: <fdomain> BIOS version ", shpnt->host_no);
 516
 517       if (bios_major >= 0) printk("%d.", bios_major);
 518       else                 printk("?.");
 519
 520       if (bios_minor >= 0) printk("%d", bios_minor);
 521       else                 printk("?.");
 522
 523       printk( " at 0x%lx using scsi id %d\n",
 524               bios_base, shpnt->this_id );
 525    }
 526
 527                                 /* If this driver works for later FD PCI
 528                                    boards, we will have to modify banner
 529                                    for additional PCI cards, but for now if
 530                                    it's PCI it's a TMC-3260 - JTM */
 531    printk(KERN_INFO "scsi%d: <fdomain> %s chip at 0x%x irq ",
 532            shpnt->host_no,
 533            chip == tmc1800 ? "TMC-1800" : (chip == tmc18c50 ? "TMC-18C50" : (chip == tmc18c30 ? (PCI_bus ? "TMC-36C70 (PCI bus)" : "TMC-18C30") : "Unknown")),
 534            port_base);
 535
 536    if (interrupt_level)
 537         printk("%d", interrupt_level);
 538    else
 539         printk("<none>");
 540
 541    printk( "\n" );
 542 }
 543
 544 int fdomain_setup(char *str)
 545 {
 546         int ints[4];
 547
 548         (void)get_options(str, ARRAY_SIZE(ints), ints);
 549
 550         if (setup_called++ || ints[0] < 2 || ints[0] > 3) {
 551                 printk(KERN_INFO "scsi: <fdomain> Usage: fdomain=<PORT_BASE>,<IRQ>[,<ADAPTER_ID>]\n");
 552                 printk(KERN_ERR "scsi: <fdomain> Bad LILO/INSMOD parameters?\n");
 553                 return 0;
 554         }
 555
 556         port_base       = ints[0] >= 1 ? ints[1] : 0;
 557         interrupt_level = ints[0] >= 2 ? ints[2] : 0;
 558         this_id         = ints[0] >= 3 ? ints[3] : 0;
 559
 560         bios_major = bios_minor = -1; /* Use geometry for BIOS version >= 3.4 */
 561         ++setup_called;
 562         return 1;
 563 }
 564
 565 __setup("fdomain=", fdomain_setup);
 566
 567
 568 static void do_pause(unsigned amount)   /* Pause for amount*10 milliseconds */
 569 {
 570         mdelay(10*amount);
 571 }
 572
 573 static inline void fdomain_make_bus_idle( void )
 574 {
 575    outb(0, port_base + SCSI_Cntl);
 576    outb(0, port_base + SCSI_Mode_Cntl);
 577    if (chip == tmc18c50 || chip == tmc18c30)
 578          outb(0x21 | PARITY_MASK, port_base + TMC_Cntl); /* Clear forced intr. */
 579    else
 580          outb(0x01 | PARITY_MASK, port_base + TMC_Cntl);
 581 }
 582
 583 static int fdomain_is_valid_port( int port )
 584 {
 585 #if DEBUG_DETECT
 586    printk( " (%x%x),",
 587            inb( port + MSB_ID_Code ), inb( port + LSB_ID_Code ) );
 588 #endif
 589
 590    /* The MCA ID is a unique id for each MCA compatible board.  We
 591       are using ISA boards, but Future Domain provides the MCA ID
 592       anyway.  We can use this ID to ensure that this is a Future
 593       Domain TMC-1660/TMC-1680.
 594     */
 595
 596    if (inb( port + LSB_ID_Code ) != 0xe9) { /* test for 0x6127 id */
 597       if (inb( port + LSB_ID_Code ) != 0x27) return 0;
 598       if (inb( port + MSB_ID_Code ) != 0x61) return 0;
 599       chip = tmc1800;
 600    } else {                                 /* test for 0xe960 id */
 601       if (inb( port + MSB_ID_Code ) != 0x60) return 0;
 602       chip = tmc18c50;
 603
 604                                 /* Try to toggle 32-bit mode.  This only
 605                                    works on an 18c30 chip.  (User reports
 606                                    say this works, so we should switch to
 607                                    it in the near future.) */
 608
 609       outb( 0x80, port + IO_Control );
 610       if ((inb( port + Configuration2 ) & 0x80) == 0x80) {
 611          outb( 0x00, port + IO_Control );
 612          if ((inb( port + Configuration2 ) & 0x80) == 0x00) {
 613             chip = tmc18c30;
 614             FIFO_Size = 0x800;  /* 2k FIFO */
 615          }
 616       }
 617                                 /* If that failed, we are an 18c50. */
 618    }
 619
 620    return 1;
 621 }
 622
 623 static int fdomain_test_loopback( void )
 624 {
 625    int i;
 626    int result;
 627
 628    for (i = 0; i < 255; i++) {
 629       outb( i, port_base + Write_Loopback );
 630       result = inb( port_base + Read_Loopback );
 631       if (i != result)
 632             return 1;
 633    }
 634    return 0;
 635 }
 636
 637 /* fdomain_get_irq assumes that we have a valid MCA ID for a
 638    TMC-1660/TMC-1680 Future Domain board.  Now, check to be sure the
 639    bios_base matches these ports.  If someone was unlucky enough to have
 640    purchased more than one Future Domain board, then they will have to
 641    modify this code, as we only detect one board here.  [The one with the
 642    lowest bios_base.]
 643
 644    Note that this routine is only used for systems without a PCI BIOS32
 645    (e.g., ISA bus).  For PCI bus systems, this routine will likely fail
 646    unless one of the IRQs listed in the ints array is used by the board.
 647    Sometimes it is possible to use the computer's BIOS setup screen to
 648    configure a PCI system so that one of these IRQs will be used by the
 649    Future Domain card. */
 650
 651 static int fdomain_get_irq( int base )
 652 {
 653    int options = inb(base + Configuration1);
 654
 655 #if DEBUG_DETECT
 656    printk("scsi: <fdomain> Options = %x\n", options);
 657 #endif
 658
 659    /* Check for board with lowest bios_base --
 660       this isn't valid for the 18c30 or for
 661       boards on the PCI bus, so just assume we
 662       have the right board. */
 663
 664    if (chip != tmc18c30 && !PCI_bus && addresses[(options & 0xc0) >> 6 ] != bios_base)
 665         return 0;
 666    return ints[(options & 0x0e) >> 1];
 667 }
 668
 669 static int fdomain_isa_detect( int *irq, int *iobase )
 670 {
 671 #ifndef PCMCIA
 672    int i, j;
 673    int base = 0xdeadbeef;
 674    int flag = 0;
 675
 676 #if DEBUG_DETECT
 677    printk( "scsi: <fdomain> fdomain_isa_detect:" );
 678 #endif
 679
 680    for (i = 0; i < ADDRESS_COUNT; i++) {
 681       void __iomem *p = ioremap(addresses[i], 0x2000);
 682       if (!p)
 683         continue;
 684 #if DEBUG_DETECT
 685       printk( " %lx(%lx),", addresses[i], bios_base );
 686 #endif
 687       for (j = 0; j < SIGNATURE_COUNT; j++) {
 688          if (check_signature(p + signatures[j].sig_offset,
 689                              signatures[j].signature,
 690                              signatures[j].sig_length )) {
 691             bios_major = signatures[j].major_bios_version;
 692             bios_minor = signatures[j].minor_bios_version;
 693             PCI_bus    = (signatures[j].flag == 1);
 694             Quantum    = (signatures[j].flag > 1) ? signatures[j].flag : 0;
 695             bios_base  = addresses[i];
 696             bios_mem   = p;
 697             goto found;
 698          }
 699       }
 700       iounmap(p);
 701    }
 702
 703 found:
 704    if (bios_major == 2) {
 705       /* The TMC-1660/TMC-1680 has a RAM area just after the BIOS ROM.
 706          Assuming the ROM is enabled (otherwise we wouldn't have been
 707          able to read the ROM signature :-), then the ROM sets up the
 708          RAM area with some magic numbers, such as a list of port
 709          base addresses and a list of the disk "geometry" reported to
 710          DOS (this geometry has nothing to do with physical geometry).
 711        */
 712
 713       switch (Quantum) {
 714       case 2:                   /* ISA_200S */
 715       case 3:                   /* ISA_250MG */
 716          base = readb(bios_mem + 0x1fa2) + (readb(bios_mem + 0x1fa3) << 8);
 717          break;
 718       case 4:                   /* ISA_200S (another one) */
 719          base = readb(bios_mem + 0x1fa3) + (readb(bios_mem + 0x1fa4) << 8);
 720          break;
 721       default:
 722          base = readb(bios_mem + 0x1fcc) + (readb(bios_mem + 0x1fcd) << 8);
 723          break;
 724       }
 725
 726 #if DEBUG_DETECT
 727       printk( " %x,", base );
 728 #endif
 729
 730       for (i = 0; i < PORT_COUNT; i++) {
 731         if (base == ports[i]) {
 732                 if (!request_region(base, 0x10, "fdomain"))
 733                         break;
 734                 if (!fdomain_is_valid_port(base)) {
 735                         release_region(base, 0x10);
 736                         break;
 737                 }
 738                 *irq    = fdomain_get_irq( base );
 739                 *iobase = base;
 740                 return 1;
 741         }
 742       }
 743
 744       /* This is a bad sign.  It usually means that someone patched the
 745          BIOS signature list (the signatures variable) to contain a BIOS
 746          signature for a board *OTHER THAN* the TMC-1660/TMC-1680. */
 747
 748 #if DEBUG_DETECT
 749       printk( " RAM FAILED, " );
 750 #endif
 751    }
 752
 753    /* Anyway, the alternative to finding the address in the RAM is to just
 754       search through every possible port address for one that is attached
 755       to the Future Domain card.  Don't panic, though, about reading all
 756       these random port addresses -- there are rumors that the Future
 757       Domain BIOS does something very similar.
 758
 759       Do not, however, check ports which the kernel knows are being used by
 760       another driver. */
 761
 762    for (i = 0; i < PORT_COUNT; i++) {
 763       base = ports[i];
 764       if (!request_region(base, 0x10, "fdomain")) {
 765 #if DEBUG_DETECT
 766          printk( " (%x inuse),", base );
 767 #endif
 768          continue;
 769       }
 770 #if DEBUG_DETECT
 771       printk( " %x,", base );
 772 #endif
 773       flag = fdomain_is_valid_port(base);
 774       if (flag)
 775         break;
 776       release_region(base, 0x10);
 777    }
 778
 779 #if DEBUG_DETECT
 780    if (flag) printk( " SUCCESS\n" );
 781    else      printk( " FAILURE\n" );
 782 #endif
 783
 784    if (!flag) return 0;         /* iobase not found */
 785
 786    *irq    = fdomain_get_irq( base );
 787    *iobase = base;
 788
 789    return 1;                    /* success */
 790 #else
 791    return 0;
 792 #endif
 793 }
 794
 795 /* PCI detection function: int fdomain_pci_bios_detect(int* irq, int*
 796    iobase) This function gets the Interrupt Level and I/O base address from
 797    the PCI configuration registers. */
 798
 799 #ifdef CONFIG_PCI
 800 static int fdomain_pci_bios_detect( int *irq, int *iobase, struct pci_dev **ret_pdev )
 801 {
 802    unsigned int     pci_irq;                /* PCI interrupt line */
 803    unsigned long    pci_base;               /* PCI I/O base address */
 804    struct pci_dev   *pdev = NULL;
 805
 806 #if DEBUG_DETECT
 807    /* Tell how to print a list of the known PCI devices from bios32 and
 808       list vendor and device IDs being used if in debug mode.  */
 809
 810    printk( "scsi: <fdomain> INFO: use lspci -v to see list of PCI devices\n" );
 811    printk( "scsi: <fdomain> TMC-3260 detect:"
 812            " Using Vendor ID: 0x%x and Device ID: 0x%x\n",
 813            PCI_VENDOR_ID_FD,
 814            PCI_DEVICE_ID_FD_36C70 );
 815 #endif
 816
 817    if ((pdev = pci_find_device(PCI_VENDOR_ID_FD, PCI_DEVICE_ID_FD_36C70, pdev)) == NULL)
 818                 return 0;
 819    if (pci_enable_device(pdev)) return 0;
 820
 821 #if DEBUG_DETECT
 822    printk( "scsi: <fdomain> TMC-3260 detect:"
 823            " PCI bus %u, device %u, function %u\n",
 824            pdev->bus->number,
 825            PCI_SLOT(pdev->devfn),
 826            PCI_FUNC(pdev->devfn));
 827 #endif
 828
 829    /* We now have the appropriate device function for the FD board so we
 830       just read the PCI config info from the registers.  */
 831
 832    pci_base = pci_resource_start(pdev, 0);
 833    pci_irq = pdev->irq;
 834
 835    if (!request_region( pci_base, 0x10, "fdomain" ))
 836         return 0;
 837
 838    /* Now we have the I/O base address and interrupt from the PCI
 839       configuration registers. */
 840
 841    *irq    = pci_irq;
 842    *iobase = pci_base;
 843    *ret_pdev = pdev;
 844
 845 #if DEBUG_DETECT
 846    printk( "scsi: <fdomain> TMC-3260 detect:"
 847            " IRQ = %d, I/O base = 0x%x [0x%lx]\n", *irq, *iobase, pci_base );
 848 #endif
 849
 850    if (!fdomain_is_valid_port(pci_base)) {
 851       printk(KERN_ERR "scsi: <fdomain> PCI card detected, but driver not loaded (invalid port)\n" );
 852       release_region(pci_base, 0x10);
 853       return 0;
 854    }
 855
 856                                 /* Fill in a few global variables.  Ugh. */
 857    bios_major = bios_minor = -1;
 858    PCI_bus    = 1;
 859    Quantum    = 0;
 860    bios_base  = 0;
 861
 862    return 1;
 863 }
 864 #endif
 865
 866 struct Scsi_Host *__fdomain_16x0_detect(struct scsi_host_template *tpnt )
 867 {
 868    int              retcode;
 869    struct Scsi_Host *shpnt;
 870    struct pci_dev *pdev = NULL;
 871
 872    if (setup_called) {
 873 #if DEBUG_DETECT
 874       printk( "scsi: <fdomain> No BIOS, using port_base = 0x%x, irq = %d\n",
 875               port_base, interrupt_level );
 876 #endif
 877       if (!request_region(port_base, 0x10, "fdomain")) {
 878          printk( "scsi: <fdomain> port 0x%x is busy\n", port_base );
 879          printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
 880          return NULL;
 881       }
 882       if (!fdomain_is_valid_port( port_base )) {
 883          printk( "scsi: <fdomain> Cannot locate chip at port base 0x%x\n",
 884                  port_base );
 885          printk( "scsi: <fdomain> Bad LILO/INSMOD parameters?\n" );
 886          release_region(port_base, 0x10);
 887          return NULL;
 888       }
 889    } else {
 890       int flag = 0;
 891
 892 #ifdef CONFIG_PCI
 893                                 /* Try PCI detection first */
 894       flag = fdomain_pci_bios_detect( &interrupt_level, &port_base, &pdev );
 895 #endif
 896       if (!flag) {
 897                                 /* Then try ISA bus detection */
 898          flag = fdomain_isa_detect( &interrupt_level, &port_base );
 899
 900          if (!flag) {
 901             printk( "scsi: <fdomain> Detection failed (no card)\n" );
 902             return NULL;
 903          }
 904       }
 905    }
 906
 907    fdomain_16x0_bus_reset(NULL);
 908
 909    if (fdomain_test_loopback()) {
 910       printk(KERN_ERR  "scsi: <fdomain> Detection failed (loopback test failed at port base 0x%x)\n", port_base);
 911       if (setup_called) {
 912          printk(KERN_ERR "scsi: <fdomain> Bad LILO/INSMOD parameters?\n");
 913       }
 914       release_region(port_base, 0x10);
 915       return NULL;
 916    }
 917
 918    if (this_id) {
 919       tpnt->this_id = (this_id & 0x07);
 920       adapter_mask  = (1 << tpnt->this_id);
 921    } else {
 922       if (PCI_bus || (bios_major == 3 && bios_minor >= 2) || bios_major < 0) {
 923          tpnt->this_id = 7;
 924          adapter_mask  = 0x80;
 925       } else {
 926          tpnt->this_id = 6;
 927          adapter_mask  = 0x40;
 928       }
 929    }
 930
 931 /* Print out a banner here in case we can't
 932    get resources.  */
 933
 934    shpnt = scsi_register( tpnt, 0 );
 935    if(shpnt == NULL) {
 936         release_region(port_base, 0x10);
 937         return NULL;
 938    }
 939    shpnt->irq = interrupt_level;
 940    shpnt->io_port = port_base;
 941    shpnt->n_io_port = 0x10;
 942    print_banner( shpnt );
 943
 944    /* Log IRQ with kernel */
 945    if (!interrupt_level) {
 946       printk(KERN_ERR "scsi: <fdomain> Card Detected, but driver not loaded (no IRQ)\n" );
 947       release_region(port_base, 0x10);
 948       return NULL;
 949    } else {
 950       /* Register the IRQ with the kernel */
 951
 952       retcode = request_irq( interrupt_level,
 953                              do_fdomain_16x0_intr, pdev?SA_SHIRQ:0, "fdomain", shpnt);
 954
 955       if (retcode < 0) {
 956          if (retcode == -EINVAL) {
 957             printk(KERN_ERR "scsi: <fdomain> IRQ %d is bad!\n", interrupt_level );
 958             printk(KERN_ERR "                This shouldn't happen!\n" );
 959             printk(KERN_ERR "                Send mail to faith@acm.org\n" );
 960          } else if (retcode == -EBUSY) {
 961             printk(KERN_ERR "scsi: <fdomain> IRQ %d is already in use!\n", interrupt_level );
 962             printk(KERN_ERR "                Please use another IRQ!\n" );
 963          } else {
 964             printk(KERN_ERR "scsi: <fdomain> Error getting IRQ %d\n", interrupt_level );
 965             printk(KERN_ERR "                This shouldn't happen!\n" );
 966             printk(KERN_ERR "                Send mail to faith@acm.org\n" );
 967          }
 968          printk(KERN_ERR "scsi: <fdomain> Detected, but driver not loaded (IRQ)\n" );
 969          release_region(port_base, 0x10);
 970          return NULL;
 971       }
 972    }
 973    return shpnt;
 974 }
 975
 976 static int fdomain_16x0_detect(struct scsi_host_template *tpnt)
 977 {
 978         if (fdomain)
 979                 fdomain_setup(fdomain);
 980         return (__fdomain_16x0_detect(tpnt) != NULL);
 981 }
 982
 983 static const char *fdomain_16x0_info( struct Scsi_Host *ignore )
 984 {
 985    static char buffer[128];
 986    char        *pt;
 987
 988    strcpy( buffer, "Future Domain 16-bit SCSI Driver Version" );
 989    if (strchr( VERSION, ':')) { /* Assume VERSION is an RCS Revision string */
 990       strcat( buffer, strchr( VERSION, ':' ) + 1 );
 991       pt = strrchr( buffer, '$') - 1;
 992       if (!pt)                  /* Stripped RCS Revision string? */
 993             pt = buffer + strlen( buffer ) - 1;
 994       if (*pt != ' ')
 995             ++pt;
 996       *pt = '\0';
 997    } else {                     /* Assume VERSION is a number */
 998       strcat( buffer, " " VERSION );
 999    }
1000
1001    return buffer;
1002 }
1003
1004 #if 0
1005 static int fdomain_arbitrate( void )
1006 {
1007    int           status = 0;
1008    unsigned long timeout;
1009
1010 #if EVERY_ACCESS
1011    printk( "fdomain_arbitrate()\n" );
1012 #endif
1013
1014    outb(0x00, port_base + SCSI_Cntl);              /* Disable data drivers */
1015    outb(adapter_mask, port_base + SCSI_Data_NoACK); /* Set our id bit */
1016    outb(0x04 | PARITY_MASK, port_base + TMC_Cntl); /* Start arbitration */
1017
1018    timeout = 500;
1019    do {
1020       status = inb(port_base + TMC_Status);        /* Read adapter status */
1021       if (status & 0x02)                      /* Arbitration complete */
1022             return 0;
1023       mdelay(1);                        /* Wait one millisecond */
1024    } while (--timeout);
1025
1026    /* Make bus idle */
1027    fdomain_make_bus_idle();
1028
1029 #if EVERY_ACCESS
1030    printk( "Arbitration failed, status = %x\n", status );
1031 #endif
1032 #if ERRORS_ONLY
1033    printk( "scsi: <fdomain> Arbitration failed, status = %x\n", status );
1034 #endif
1035    return 1;
1036 }
1037 #endif
1038
1039 static int fdomain_select( int target )
1040 {
1041    int           status;
1042    unsigned long timeout;
1043 #if ERRORS_ONLY
1044    static int    flag = 0;
1045 #endif
1046
1047    outb(0x82, port_base + SCSI_Cntl); /* Bus Enable + Select */
1048    outb(adapter_mask | (1 << target), port_base + SCSI_Data_NoACK);
1049
1050    /* Stop arbitration and enable parity */
1051    outb(PARITY_MASK, port_base + TMC_Cntl);
1052
1053    timeout = 350;                       /* 350 msec */
1054
1055    do {
1056       status = inb(port_base + SCSI_Status); /* Read adapter status */
1057       if (status & 1) {                 /* Busy asserted */
1058          /* Enable SCSI Bus (on error, should make bus idle with 0) */
1059          outb(0x80, port_base + SCSI_Cntl);
1060          return 0;
1061       }
1062       mdelay(1);                        /* wait one msec */
1063    } while (--timeout);
1064    /* Make bus idle */
1065    fdomain_make_bus_idle();
1066 #if EVERY_ACCESS
1067    if (!target) printk( "Selection failed\n" );
1068 #endif
1069 #if ERRORS_ONLY
1070    if (!target) {
1071       if (!flag) /* Skip first failure for all chips. */
1072             ++flag;
1073       else
1074             printk( "scsi: <fdomain> Selection failed\n" );
1075    }
1076 #endif
1077    return 1;
1078 }
1079
1080 static void my_done(int error)
1081 {
1082    if (in_command) {
1083       in_command = 0;
1084       outb(0x00, port_base + Interrupt_Cntl);
1085       fdomain_make_bus_idle();
1086       current_SC->result = error;
1087       if (current_SC->scsi_done)
1088             current_SC->scsi_done( current_SC );
1089       else panic( "scsi: <fdomain> current_SC->scsi_done() == NULL" );
1090    } else {
1091       panic( "scsi: <fdomain> my_done() called outside of command\n" );
1092    }
1093 #if DEBUG_RACE
1094    in_interrupt_flag = 0;
1095 #endif
1096 }
1097
1098 static irqreturn_t do_fdomain_16x0_intr(int irq, void *dev_id,
1099                                         struct pt_regs * regs )
1100 {
1101    unsigned long flags;
1102    int      status;
1103    int      done = 0;
1104    unsigned data_count;
1105
1106                                 /* The fdomain_16x0_intr is only called via
1107                                    the interrupt handler.  The goal of the
1108                                    sti() here is to allow other
1109                                    interruptions while this routine is
1110                                    running. */
1111
1112    /* Check for other IRQ sources */
1113    if ((inb(port_base + TMC_Status) & 0x01) == 0)
1114         return IRQ_NONE;
1115
1116    /* It is our IRQ */
1117    outb(0x00, port_base + Interrupt_Cntl);
1118
1119    /* We usually have one spurious interrupt after each command.  Ignore it. */
1120    if (!in_command || !current_SC) {    /* Spurious interrupt */
1121 #if EVERY_ACCESS
1122       printk( "Spurious interrupt, in_command = %d, current_SC = %x\n",
1123               in_command, current_SC );
1124 #endif
1125       return IRQ_NONE;
1126    }
1127
1128    /* Abort calls my_done, so we do nothing here. */
1129    if (current_SC->SCp.phase & aborted) {
1130 #if DEBUG_ABORT
1131       printk( "scsi: <fdomain> Interrupt after abort, ignoring\n" );
1132 #endif
1133       /*
1134       return IRQ_HANDLED; */
1135    }
1136
1137 #if DEBUG_RACE
1138    ++in_interrupt_flag;
1139 #endif
1140
1141    if (current_SC->SCp.phase & in_arbitration) {
1142       status = inb(port_base + TMC_Status);        /* Read adapter status */
1143       if (!(status & 0x02)) {
1144 #if EVERY_ACCESS
1145          printk( " AFAIL " );
1146 #endif
1147          spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1148          my_done( DID_BUS_BUSY << 16 );
1149          spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1150          return IRQ_HANDLED;
1151       }
1152       current_SC->SCp.phase = in_selection;
1153
1154       outb(0x40 | FIFO_COUNT, port_base + Interrupt_Cntl);
1155
1156       outb(0x82, port_base + SCSI_Cntl); /* Bus Enable + Select */
1157       outb(adapter_mask | (1 << current_SC->device->id), port_base + SCSI_Data_NoACK);
1158
1159       /* Stop arbitration and enable parity */
1160       outb(0x10 | PARITY_MASK, port_base + TMC_Cntl);
1161 #if DEBUG_RACE
1162       in_interrupt_flag = 0;
1163 #endif
1164       return IRQ_HANDLED;
1165    } else if (current_SC->SCp.phase & in_selection) {
1166       status = inb(port_base + SCSI_Status);
1167       if (!(status & 0x01)) {
1168          /* Try again, for slow devices */
1169          if (fdomain_select( current_SC->device->id )) {
1170 #if EVERY_ACCESS
1171             printk( " SFAIL " );
1172 #endif
1173             spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1174             my_done( DID_NO_CONNECT << 16 );
1175             spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1176             return IRQ_HANDLED;
1177          } else {
1178 #if EVERY_ACCESS
1179             printk( " AltSel " );
1180 #endif
1181             /* Stop arbitration and enable parity */
1182             outb(0x10 | PARITY_MASK, port_base + TMC_Cntl);
1183          }
1184       }
1185       current_SC->SCp.phase = in_other;
1186       outb(0x90 | FIFO_COUNT, port_base + Interrupt_Cntl);
1187       outb(0x80, port_base + SCSI_Cntl);
1188 #if DEBUG_RACE
1189       in_interrupt_flag = 0;
1190 #endif
1191       return IRQ_HANDLED;
1192    }
1193
1194    /* current_SC->SCp.phase == in_other: this is the body of the routine */
1195
1196    status = inb(port_base + SCSI_Status);
1197
1198    if (status & 0x10) { /* REQ */
1199
1200       switch (status & 0x0e) {
1201
1202       case 0x08:                /* COMMAND OUT */
1203          outb(current_SC->cmnd[current_SC->SCp.sent_command++],
1204               port_base + Write_SCSI_Data);
1205 #if EVERY_ACCESS
1206          printk( "CMD = %x,",
1207                  current_SC->cmnd[ current_SC->SCp.sent_command - 1] );
1208 #endif
1209          break;
1210       case 0x00:                /* DATA OUT -- tmc18c50/tmc18c30 only */
1211          if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1212             current_SC->SCp.have_data_in = -1;
1213             outb(0xd0 | PARITY_MASK, port_base + TMC_Cntl);
1214          }
1215          break;
1216       case 0x04:                /* DATA IN -- tmc18c50/tmc18c30 only */
1217          if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1218             current_SC->SCp.have_data_in = 1;
1219             outb(0x90 | PARITY_MASK, port_base + TMC_Cntl);
1220          }
1221          break;
1222       case 0x0c:                /* STATUS IN */
1223          current_SC->SCp.Status = inb(port_base + Read_SCSI_Data);
1224 #if EVERY_ACCESS
1225          printk( "Status = %x, ", current_SC->SCp.Status );
1226 #endif
1227 #if ERRORS_ONLY
1228          if (current_SC->SCp.Status
1229              && current_SC->SCp.Status != 2
1230              && current_SC->SCp.Status != 8) {
1231             printk( "scsi: <fdomain> target = %d, command = %x, status = %x\n",
1232                     current_SC->device->id,
1233                     current_SC->cmnd[0],
1234                     current_SC->SCp.Status );
1235          }
1236 #endif
1237                break;
1238       case 0x0a:                /* MESSAGE OUT */
1239          outb(MESSAGE_REJECT, port_base + Write_SCSI_Data); /* Reject */
1240          break;
1241       case 0x0e:                /* MESSAGE IN */
1242          current_SC->SCp.Message = inb(port_base + Read_SCSI_Data);
1243 #if EVERY_ACCESS
1244          printk( "Message = %x, ", current_SC->SCp.Message );
1245 #endif
1246          if (!current_SC->SCp.Message) ++done;
1247 #if DEBUG_MESSAGES || EVERY_ACCESS
1248          if (current_SC->SCp.Message) {
1249             printk( "scsi: <fdomain> message = %x\n",
1250                     current_SC->SCp.Message );
1251          }
1252 #endif
1253          break;
1254       }
1255    }
1256
1257    if (chip == tmc1800 && !current_SC->SCp.have_data_in
1258        && (current_SC->SCp.sent_command >= current_SC->cmd_len)) {
1259
1260       if(current_SC->sc_data_direction == DMA_TO_DEVICE)
1261       {
1262          current_SC->SCp.have_data_in = -1;
1263          outb(0xd0 | PARITY_MASK, port_base + TMC_Cntl);
1264       }
1265       else
1266       {
1267          current_SC->SCp.have_data_in = 1;
1268          outb(0x90 | PARITY_MASK, port_base + TMC_Cntl);
1269       }
1270    }
1271
1272    if (current_SC->SCp.have_data_in == -1) { /* DATA OUT */
1273       while ((data_count = FIFO_Size - inw(port_base + FIFO_Data_Count)) > 512) {
1274 #if EVERY_ACCESS
1275          printk( "DC=%d, ", data_count ) ;
1276 #endif
1277          if (data_count > current_SC->SCp.this_residual)
1278                data_count = current_SC->SCp.this_residual;
1279          if (data_count > 0) {
1280 #if EVERY_ACCESS
1281             printk( "%d OUT, ", data_count );
1282 #endif
1283             if (data_count == 1) {
1284                outb(*current_SC->SCp.ptr++, port_base + Write_FIFO);
1285                --current_SC->SCp.this_residual;
1286             } else {
1287                data_count >>= 1;
1288                outsw(port_base + Write_FIFO, current_SC->SCp.ptr, data_count);
1289                current_SC->SCp.ptr += 2 * data_count;
1290                current_SC->SCp.this_residual -= 2 * data_count;
1291             }
1292          }
1293          if (!current_SC->SCp.this_residual) {
1294             if (current_SC->SCp.buffers_residual) {
1295                --current_SC->SCp.buffers_residual;
1296                ++current_SC->SCp.buffer;
1297                current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1298                current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1299             } else
1300                   break;
1301          }
1302       }
1303    }
1304
1305    if (current_SC->SCp.have_data_in == 1) { /* DATA IN */
1306       while ((data_count = inw(port_base + FIFO_Data_Count)) > 0) {
1307 #if EVERY_ACCESS
1308          printk( "DC=%d, ", data_count );
1309 #endif
1310          if (data_count > current_SC->SCp.this_residual)
1311                data_count = current_SC->SCp.this_residual;
1312          if (data_count) {
1313 #if EVERY_ACCESS
1314             printk( "%d IN, ", data_count );
1315 #endif
1316             if (data_count == 1) {
1317                *current_SC->SCp.ptr++ = inb(port_base + Read_FIFO);
1318                --current_SC->SCp.this_residual;
1319             } else {
1320                data_count >>= 1; /* Number of words */
1321                insw(port_base + Read_FIFO, current_SC->SCp.ptr, data_count);
1322                current_SC->SCp.ptr += 2 * data_count;
1323                current_SC->SCp.this_residual -= 2 * data_count;
1324             }
1325          }
1326          if (!current_SC->SCp.this_residual
1327              && current_SC->SCp.buffers_residual) {
1328             --current_SC->SCp.buffers_residual;
1329             ++current_SC->SCp.buffer;
1330             current_SC->SCp.ptr = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1331             current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1332          }
1333       }
1334    }
1335
1336    if (done) {
1337 #if EVERY_ACCESS
1338       printk( " ** IN DONE %d ** ", current_SC->SCp.have_data_in );
1339 #endif
1340
1341 #if ERRORS_ONLY
1342       if (current_SC->cmnd[0] == REQUEST_SENSE && !current_SC->SCp.Status) {
1343          if ((unsigned char)(*((char *)current_SC->request_buffer+2)) & 0x0f) {
1344             unsigned char key;
1345             unsigned char code;
1346             unsigned char qualifier;
1347
1348             key = (unsigned char)(*((char *)current_SC->request_buffer + 2))
1349                   & 0x0f;
1350             code = (unsigned char)(*((char *)current_SC->request_buffer + 12));
1351             qualifier = (unsigned char)(*((char *)current_SC->request_buffer
1352                                           + 13));
1353
1354             if (key != UNIT_ATTENTION
1355                 && !(key == NOT_READY
1356                      && code == 0x04
1357                      && (!qualifier || qualifier == 0x02 || qualifier == 0x01))
1358                 && !(key == ILLEGAL_REQUEST && (code == 0x25
1359                                                 || code == 0x24
1360                                                 || !code)))
1361
1362                   printk( "scsi: <fdomain> REQUEST SENSE"
1363                           " Key = %x, Code = %x, Qualifier = %x\n",
1364                           key, code, qualifier );
1365          }
1366       }
1367 #endif
1368 #if EVERY_ACCESS
1369       printk( "BEFORE MY_DONE. . ." );
1370 #endif
1371       spin_lock_irqsave(current_SC->device->host->host_lock, flags);
1372       my_done( (current_SC->SCp.Status & 0xff)
1373                | ((current_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16) );
1374       spin_unlock_irqrestore(current_SC->device->host->host_lock, flags);
1375 #if EVERY_ACCESS
1376       printk( "RETURNING.\n" );
1377 #endif
1378
1379    } else {
1380       if (current_SC->SCp.phase & disconnect) {
1381          outb(0xd0 | FIFO_COUNT, port_base + Interrupt_Cntl);
1382          outb(0x00, port_base + SCSI_Cntl);
1383       } else {
1384          outb(0x90 | FIFO_COUNT, port_base + Interrupt_Cntl);
1385       }
1386    }
1387 #if DEBUG_RACE
1388    in_interrupt_flag = 0;
1389 #endif
1390    return IRQ_HANDLED;
1391 }
1392
1393 static int fdomain_16x0_queue(struct scsi_cmnd *SCpnt,
1394                 void (*done)(struct scsi_cmnd *))
1395 {
1396    if (in_command) {
1397       panic( "scsi: <fdomain> fdomain_16x0_queue() NOT REENTRANT!\n" );
1398    }
1399 #if EVERY_ACCESS
1400    printk( "queue: target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1401            SCpnt->target,
1402            *(unsigned char *)SCpnt->cmnd,
1403            SCpnt->use_sg,
1404            SCpnt->request_bufflen );
1405 #endif
1406
1407    fdomain_make_bus_idle();
1408
1409    current_SC            = SCpnt; /* Save this for the done function */
1410    current_SC->scsi_done = done;
1411
1412    /* Initialize static data */
1413
1414    if (current_SC->use_sg) {
1415       current_SC->SCp.buffer =
1416             (struct scatterlist *)current_SC->request_buffer;
1417       current_SC->SCp.ptr              = page_address(current_SC->SCp.buffer->page) + current_SC->SCp.buffer->offset;
1418       current_SC->SCp.this_residual    = current_SC->SCp.buffer->length;
1419       current_SC->SCp.buffers_residual = current_SC->use_sg - 1;
1420    } else {
1421       current_SC->SCp.ptr              = (char *)current_SC->request_buffer;
1422       current_SC->SCp.this_residual    = current_SC->request_bufflen;
1423       current_SC->SCp.buffer           = NULL;
1424       current_SC->SCp.buffers_residual = 0;
1425    }
1426
1427
1428    current_SC->SCp.Status              = 0;
1429    current_SC->SCp.Message             = 0;
1430    current_SC->SCp.have_data_in        = 0;
1431    current_SC->SCp.sent_command        = 0;
1432    current_SC->SCp.phase               = in_arbitration;
1433
1434    /* Start arbitration */
1435    outb(0x00, port_base + Interrupt_Cntl);
1436    outb(0x00, port_base + SCSI_Cntl);              /* Disable data drivers */
1437    outb(adapter_mask, port_base + SCSI_Data_NoACK); /* Set our id bit */
1438    ++in_command;
1439    outb(0x20, port_base + Interrupt_Cntl);
1440    outb(0x14 | PARITY_MASK, port_base + TMC_Cntl); /* Start arbitration */
1441
1442    return 0;
1443 }
1444
1445 #if DEBUG_ABORT
1446 static void print_info(struct scsi_cmnd *SCpnt)
1447 {
1448    unsigned int imr;
1449    unsigned int irr;
1450    unsigned int isr;
1451
1452    if (!SCpnt || !SCpnt->device || !SCpnt->device->host) {
1453       printk(KERN_WARNING "scsi: <fdomain> Cannot provide detailed information\n");
1454       return;
1455    }
1456
1457    printk(KERN_INFO "%s\n", fdomain_16x0_info( SCpnt->device->host ) );
1458    print_banner(SCpnt->device->host);
1459    switch (SCpnt->SCp.phase) {
1460    case in_arbitration: printk("arbitration"); break;
1461    case in_selection:   printk("selection");   break;
1462    case in_other:       printk("other");       break;
1463    default:             printk("unknown");     break;
1464    }
1465
1466    printk( " (%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1467            SCpnt->SCp.phase,
1468            SCpnt->device->id,
1469            *(unsigned char *)SCpnt->cmnd,
1470            SCpnt->use_sg,
1471            SCpnt->request_bufflen );
1472    printk( "sent_command = %d, have_data_in = %d, timeout = %d\n",
1473            SCpnt->SCp.sent_command,
1474            SCpnt->SCp.have_data_in,
1475            SCpnt->timeout );
1476 #if DEBUG_RACE
1477    printk( "in_interrupt_flag = %d\n", in_interrupt_flag );
1478 #endif
1479
1480    imr = (inb( 0x0a1 ) << 8) + inb( 0x21 );
1481    outb( 0x0a, 0xa0 );
1482    irr = inb( 0xa0 ) << 8;
1483    outb( 0x0a, 0x20 );
1484    irr += inb( 0x20 );
1485    outb( 0x0b, 0xa0 );
1486    isr = inb( 0xa0 ) << 8;
1487    outb( 0x0b, 0x20 );
1488    isr += inb( 0x20 );
1489
1490                                 /* Print out interesting information */
1491    printk( "IMR = 0x%04x", imr );
1492    if (imr & (1 << interrupt_level))
1493          printk( " (masked)" );
1494    printk( ", IRR = 0x%04x, ISR = 0x%04x\n", irr, isr );
1495
1496    printk( "SCSI Status      = 0x%02x\n", inb(port_base + SCSI_Status));
1497    printk( "TMC Status       = 0x%02x", inb(port_base + TMC_Status));
1498    if (inb((port_base + TMC_Status) & 1))
1499          printk( " (interrupt)" );
1500    printk( "\n" );
1501    printk("Interrupt Status = 0x%02x", inb(port_base + Interrupt_Status));
1502    if (inb(port_base + Interrupt_Status) & 0x08)
1503          printk( " (enabled)" );
1504    printk( "\n" );
1505    if (chip == tmc18c50 || chip == tmc18c30) {
1506       printk("FIFO Status      = 0x%02x\n", inb(port_base + FIFO_Status));
1507       printk( "Int. Condition   = 0x%02x\n",
1508               inb( port_base + Interrupt_Cond ) );
1509    }
1510    printk( "Configuration 1  = 0x%02x\n", inb( port_base + Configuration1 ) );
1511    if (chip == tmc18c50 || chip == tmc18c30)
1512          printk( "Configuration 2  = 0x%02x\n",
1513                  inb( port_base + Configuration2 ) );
1514 }
1515 #endif
1516
1517 static int fdomain_16x0_abort(struct scsi_cmnd *SCpnt)
1518 {
1519 #if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
1520    printk( "scsi: <fdomain> abort " );
1521 #endif
1522
1523    if (!in_command) {
1524 #if EVERY_ACCESS || ERRORS_ONLY
1525       printk( " (not in command)\n" );
1526 #endif
1527       return FAILED;
1528    } else printk( "\n" );
1529
1530 #if DEBUG_ABORT
1531    print_info( SCpnt );
1532 #endif
1533
1534    fdomain_make_bus_idle();
1535    current_SC->SCp.phase |= aborted;
1536    current_SC->result = DID_ABORT << 16;
1537
1538    /* Aborts are not done well. . . */
1539    my_done(DID_ABORT << 16);
1540    return SUCCESS;
1541 }
1542
1543 int fdomain_16x0_bus_reset(struct scsi_cmnd *SCpnt)
1544 {
1545    unsigned long flags;
1546
1547    local_irq_save(flags);
1548
1549    outb(1, port_base + SCSI_Cntl);
1550    do_pause( 2 );
1551    outb(0, port_base + SCSI_Cntl);
1552    do_pause( 115 );
1553    outb(0, port_base + SCSI_Mode_Cntl);
1554    outb(PARITY_MASK, port_base + TMC_Cntl);
1555
1556    local_irq_restore(flags);
1557    return SUCCESS;
1558 }
1559
1560 static int fdomain_16x0_biosparam(struct scsi_device *sdev,
1561                 struct block_device *bdev,
1562                 sector_t capacity, int *info_array)
1563 {
1564    int              drive;
1565    int              size      = capacity;
1566    unsigned long    offset;
1567    struct drive_info {
1568       unsigned short cylinders;
1569       unsigned char  heads;
1570       unsigned char  sectors;
1571    } i;
1572
1573    /* NOTES:
1574       The RAM area starts at 0x1f00 from the bios_base address.
1575
1576       For BIOS Version 2.0:
1577
1578       The drive parameter table seems to start at 0x1f30.
1579       The first byte's purpose is not known.
1580       Next is the cylinder, head, and sector information.
1581       The last 4 bytes appear to be the drive's size in sectors.
1582       The other bytes in the drive parameter table are unknown.
1583       If anyone figures them out, please send me mail, and I will
1584       update these notes.
1585
1586       Tape drives do not get placed in this table.
1587
1588       There is another table at 0x1fea:
1589       If the byte is 0x01, then the SCSI ID is not in use.
1590       If the byte is 0x18 or 0x48, then the SCSI ID is in use,
1591       although tapes don't seem to be in this table.  I haven't
1592       seen any other numbers (in a limited sample).
1593
1594       0x1f2d is a drive count (i.e., not including tapes)
1595
1596       The table at 0x1fcc are I/O ports addresses for the various
1597       operations.  I calculate these by hand in this driver code.
1598
1599
1600
1601       For the ISA-200S version of BIOS Version 2.0:
1602
1603       The drive parameter table starts at 0x1f33.
1604
1605       WARNING: Assume that the table entry is 25 bytes long.  Someone needs
1606       to check this for the Quantum ISA-200S card.
1607
1608
1609
1610       For BIOS Version 3.2:
1611
1612       The drive parameter table starts at 0x1f70.  Each entry is
1613       0x0a bytes long.  Heads are one less than we need to report.
1614     */
1615
1616    if (MAJOR(bdev->bd_dev) != SCSI_DISK0_MAJOR) {
1617       printk("scsi: <fdomain> fdomain_16x0_biosparam: too many disks");
1618       return 0;
1619    }
1620    drive = MINOR(bdev->bd_dev) >> 4;
1621
1622    if (bios_major == 2) {
1623       switch (Quantum) {
1624       case 2:                   /* ISA_200S */
1625                                 /* The value of 25 has never been verified.
1626                                    It should probably be 15. */
1627          offset = 0x1f33 + drive * 25;
1628          break;
1629       case 3:                   /* ISA_250MG */
1630          offset = 0x1f36 + drive * 15;
1631          break;
1632       case 4:                   /* ISA_200S (another one) */
1633          offset = 0x1f34 + drive * 15;
1634          break;
1635       default:
1636          offset = 0x1f31 + drive * 25;
1637          break;
1638       }
1639       memcpy_fromio( &i, bios_mem + offset, sizeof( struct drive_info ) );
1640       info_array[0] = i.heads;
1641       info_array[1] = i.sectors;
1642       info_array[2] = i.cylinders;
1643    } else if (bios_major == 3
1644               && bios_minor >= 0
1645               && bios_minor < 4) { /* 3.0 and 3.2 BIOS */
1646       memcpy_fromio( &i, bios_mem + 0x1f71 + drive * 10,
1647                      sizeof( struct drive_info ) );
1648       info_array[0] = i.heads + 1;
1649       info_array[1] = i.sectors;
1650       info_array[2] = i.cylinders;
1651    } else {                     /* 3.4 BIOS (and up?) */
1652       /* This algorithm was provided by Future Domain (much thanks!). */
1653       unsigned char *p = scsi_bios_ptable(bdev);
1654
1655       if (p && p[65] == 0xaa && p[64] == 0x55 /* Partition table valid */
1656           && p[4]) {                        /* Partition type */
1657
1658          /* The partition table layout is as follows:
1659
1660             Start: 0x1b3h
1661             Offset: 0 = partition status
1662                     1 = starting head
1663                     2 = starting sector and cylinder (word, encoded)
1664                     4 = partition type
1665                     5 = ending head
1666                     6 = ending sector and cylinder (word, encoded)
1667                     8 = starting absolute sector (double word)
1668                     c = number of sectors (double word)
1669             Signature: 0x1fe = 0x55aa
1670
1671             So, this algorithm assumes:
1672             1) the first partition table is in use,
1673             2) the data in the first entry is correct, and
1674             3) partitions never divide cylinders
1675
1676             Note that (1) may be FALSE for NetBSD (and other BSD flavors),
1677             as well as for Linux.  Note also, that Linux doesn't pay any
1678             attention to the fields that are used by this algorithm -- it
1679             only uses the absolute sector data.  Recent versions of Linux's
1680             fdisk(1) will fill this data in correctly, and forthcoming
1681             versions will check for consistency.
1682
1683             Checking for a non-zero partition type is not part of the
1684             Future Domain algorithm, but it seemed to be a reasonable thing
1685             to do, especially in the Linux and BSD worlds. */
1686
1687          info_array[0] = p[5] + 1;          /* heads */
1688          info_array[1] = p[6] & 0x3f;       /* sectors */
1689       } else {
1690
1691          /* Note that this new method guarantees that there will always be
1692             less than 1024 cylinders on a platter.  This is good for drives
1693             up to approximately 7.85GB (where 1GB = 1024 * 1024 kB). */
1694
1695          if ((unsigned int)size >= 0x7e0000U) {
1696             info_array[0] = 0xff; /* heads   = 255 */
1697             info_array[1] = 0x3f; /* sectors =  63 */
1698          } else if ((unsigned int)size >= 0x200000U) {
1699             info_array[0] = 0x80; /* heads   = 128 */
1700             info_array[1] = 0x3f; /* sectors =  63 */
1701          } else {
1702             info_array[0] = 0x40; /* heads   =  64 */
1703             info_array[1] = 0x20; /* sectors =  32 */
1704          }
1705       }
1706                                 /* For both methods, compute the cylinders */
1707       info_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
1708       kfree(p);
1709    }
1710
1711    return 0;
1712 }
1713
1714 static int fdomain_16x0_release(struct Scsi_Host *shpnt)
1715 {
1716         if (shpnt->irq)
1717                 free_irq(shpnt->irq, shpnt);
1718         if (shpnt->io_port && shpnt->n_io_port)
1719                 release_region(shpnt->io_port, shpnt->n_io_port);
1720         return 0;
1721 }
1722
1723 struct scsi_host_template fdomain_driver_template = {
1724         .module                 = THIS_MODULE,
1725         .name                   = "fdomain",
1726         .proc_name              = "fdomain",
1727         .detect                 = fdomain_16x0_detect,
1728         .info                   = fdomain_16x0_info,
1729         .queuecommand           = fdomain_16x0_queue,
1730         .eh_abort_handler       = fdomain_16x0_abort,
1731         .eh_bus_reset_handler   = fdomain_16x0_bus_reset,
1732         .bios_param             = fdomain_16x0_biosparam,
1733         .release                = fdomain_16x0_release,
1734         .can_queue              = 1,
1735         .this_id                = 6,
1736         .sg_tablesize           = 64,
1737         .cmd_per_lun            = 1,
1738         .use_clustering         = DISABLE_CLUSTERING,
1739 };
1740
1741 #ifndef PCMCIA
1742 #define driver_template fdomain_driver_template
1743 #include "scsi_module.c"
1744 #endif