drivers/scsi/fdomain.c

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