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