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