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