drivers/scsi/fdomain.c

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