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