root/drivers/scsi/fdomain.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. fdomain_setup
  2. do_pause
  3. fdomain_make_bus_idle
  4. fdomain_is_valid_port
  5. fdomain_test_loopback
  6. fdomain_get_irq
  7. fdomain_isa_detect
  8. fdomain_pci_nobios_detect
  9. fdomain_pci_bios_detect
  10. fdomain_16x0_detect
  11. fdomain_16x0_info
  12. fdomain_16x0_proc_info
  13. fdomain_arbitrate
  14. fdomain_select
  15. my_done
  16. fdomain_16x0_intr
  17. fdomain_16x0_queue
  18. internal_done
  19. fdomain_16x0_command
  20. print_info
  21. fdomain_16x0_abort
  22. fdomain_16x0_reset
  23. fdomain_16x0_biosparam

   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: Thu Oct 12 15:59:37 1995 by r.faith@ieee.org
   4  * Author: Rickard E. Faith, faith@cs.unc.edu
   5  * Copyright 1992, 1993, 1994, 1995 Rickard E. Faith
   6  *
   7  * $Id: fdomain.c,v 5.39 1995/10/12 20:31:47 root Exp $
   8 
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by the
  11  * Free Software Foundation; either version 2, or (at your option) any
  12  * later version.
  13 
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18 
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write to the Free Software Foundation, Inc.,
  21  * 675 Mass Ave, Cambridge, MA 02139, USA.
  22 
  23  **************************************************************************
  24  
  25  DESCRIPTION:
  26 
  27  This is the Linux low-level SCSI driver for Future Domain TMC-1660/1680
  28  TMC-1650/1670, and TMC-3260 SCSI host adapters.  The 1650 and 1670 have a
  29  25-pin external connector, whereas the 1660 and 1680 have a SCSI-2 50-pin
  30  high-density external connector.  The 1670 and 1680 have floppy disk
  31  controllers built in.  The TMC-3260 is a PCI bus card.
  32 
  33  Future Domain's older boards are based on the TMC-1800 chip, and this
  34  driver was originally written for a TMC-1680 board with the TMC-1800 chip.
  35  More recently, boards are being produced with the TMC-18C50 and TMC-18C30
  36  chips.  The latest and greatest board may not work with this driver.  If
  37  you have to patch this driver so that it will recognize your board's BIOS
  38  signature, then the driver may fail to function after the board is
  39  detected.
  40 
  41  The following BIOS versions are supported: 2.0, 3.0, 3.2, 3.4, and 3.5.
  42  The following chips are supported: TMC-1800, TMC-18C50, TMC-18C30.
  43  Reports suggest that the driver will also work with the 36C70 chip and
  44  with the Quantum ISA-200S and ISA-250MG SCSI adapters.
  45 
  46  Please note that the drive ordering that Future Domain implemented in BIOS
  47  versions 3.4 and 3.5 is the opposite of the order (currently) used by the
  48  rest of the SCSI industry.  If you have BIOS version 3.4 or 3.5, and have
  49  more then one drive, then the drive ordering will be the reverse of that
  50  which you see under DOS.  For example, under DOS SCSI ID 0 will be D: and
  51  SCSI ID 1 will be C: (the boot device).  Under Linux, SCSI ID 0 will be
  52  /dev/sda and SCSI ID 1 will be /dev/sdb.  The Linux ordering is consistent
  53  with that provided by all the other SCSI drivers for Linux.  If you want
  54  this changed, send me patches that are protected by #ifdefs.
  55 
  56  If you have a TMC-8xx or TMC-9xx board, then this is not the driver for
  57  your board.  Please refer to the Seagate driver for more information and
  58  possible support.
  59 
  60  
  61 
  62  REFERENCES USED:
  63 
  64  "TMC-1800 SCSI Chip Specification (FDC-1800T)", Future Domain Corporation,
  65  1990.
  66 
  67  "Technical Reference Manual: 18C50 SCSI Host Adapter Chip", Future Domain
  68  Corporation, January 1992.
  69 
  70  "LXT SCSI Products: Specifications and OEM Technical Manual (Revision
  71  B/September 1991)", Maxtor Corporation, 1991.
  72 
  73  "7213S product Manual (Revision P3)", Maxtor Corporation, 1992.
  74 
  75  "Draft Proposed American National Standard: Small Computer System
  76  Interface - 2 (SCSI-2)", Global Engineering Documents. (X3T9.2/86-109,
  77  revision 10h, October 17, 1991)
  78 
  79  Private communications, Drew Eckhardt (drew@cs.colorado.edu) and Eric
  80  Youngdale (ericy@cais.com), 1992.
  81 
  82  Private communication, Tuong Le (Future Domain Engineering department),
  83  1994. (Disk geometry computations for Future Domain BIOS version 3.4, and
  84  TMC-18C30 detection.)
  85 
  86  Hogan, Thom. The Programmer's PC Sourcebook. Microsoft Press, 1988. Page
  87  60 (2.39: Disk Partition Table Layout).
  88 
  89  "18C30 Technical Reference Manual", Future Domain Corporation, 1993, page
  90  6-1.
  91 
  92 
  93  
  94  NOTES ON REFERENCES:
  95 
  96  The Maxtor manuals were free.  Maxtor telephone technical support is
  97  great!
  98 
  99  The Future Domain manuals were $25 and $35.  They document the chip, not
 100  the TMC-16x0 boards, so some information I had to guess at.  In 1992,
 101  Future Domain sold DOS BIOS source for $250 and the UN*X driver source was
 102  $750, but these required a non-disclosure agreement, so even if I could
 103  have afforded them, they would *not* have been useful for writing this
 104  publically distributable driver.  Future Domain technical support has
 105  provided some information on the phone and have sent a few useful FAXs.
 106  They have been much more helpful since they started to recognize that the
 107  word "Linux" refers to an operating system :-).
 108 
 109  
 110 
 111  ALPHA TESTERS:
 112 
 113  There are many other alpha testers that come and go as the driver
 114  develops.  The people listed here were most helpful in times of greatest
 115  need (mostly early on -- I've probably left out a few worthy people in
 116  more recent times):
 117 
 118  Todd Carrico (todd@wutc.wustl.edu), Dan Poirier (poirier@cs.unc.edu ), Ken
 119  Corey (kenc@sol.acs.unt.edu), C. de Bruin (bruin@bruin@sterbbs.nl), Sakari
 120  Aaltonen (sakaria@vipunen.hit.fi), John Rice (rice@xanth.cs.odu.edu), Brad
 121  Yearwood (brad@optilink.com), and Ray Toy (toy@soho.crd.ge.com).
 122 
 123  Special thanks to Tien-Wan Yang (twyang@cs.uh.edu), who graciously lent me
 124  his 18C50-based card for debugging.  He is the sole reason that this
 125  driver works with the 18C50 chip.
 126 
 127  Thanks to Dave Newman (dnewman@crl.com) for providing initial patches for
 128  the version 3.4 BIOS.
 129 
 130  Thanks to James T. McKinley (mckinley@msupa.pa.msu.edu) for providing
 131  patches that support the TMC-3260, a PCI bus card with the 36C70 chip.
 132  The 36C70 chip appears to be "completely compatible" with the 18C30 chip.
 133 
 134  Thanks to Eric Kasten (tigger@petroglyph.cl.msu.edu) for providing the
 135  patch for the version 3.5 BIOS.
 136 
 137  Thanks for Stephen Henson (shenson@nyx10.cs.du.edu) for providing the
 138  patch for the Quantum ISA-200S SCSI adapter.
 139  
 140  Thanks to Adam Bowen for the signature to the 1610M/MER/MEX scsi cards, to
 141  Martin Andrews (andrewm@ccfadm.eeg.ccf.org) for the signature to some
 142  random TMC-1680 repackaged by IBM; and to Mintak Ng (mintak@panix.com) for
 143  the version 3.61 BIOS siganture.
 144 
 145  Thanks for Mark Singer (elf@netcom.com) and Richard Simpson
 146  (rsimpson@ewrcsdra.demon.co.uk) for more Quantum signatures and detective
 147  work on the Quantum RAM layout.
 148 
 149  Special thanks to James T. McKinley (mckinley@msupa.pa.msu.edu) for
 150  providing patches for proper PCI BIOS32-mediated detection of the TMC-3260
 151  card (a PCI bus card with the 36C70 chip).  Please send James PCI-related
 152  bug reports.
 153 
 154  Thanks to Tom Cavin (tec@usa1.com) for preliminary command-line option
 155  patches.
 156  
 157  All of the alpha testers deserve much thanks.
 158 
 159 
 160 
 161  NOTES ON USER DEFINABLE OPTIONS:
 162 
 163  DEBUG: This turns on the printing of various debug information.
 164 
 165  ENABLE_PARITY: This turns on SCSI parity checking.  With the current
 166  driver, all attached devices must support SCSI parity.  If none of your
 167  devices support parity, then you can probably get the driver to work by
 168  turning this option off.  I have no way of testing this, however.
 169 
 170  FIFO_COUNT: The host adapter has an 8K cache (host adapters based on the
 171  18C30 chip have a 2k cache).  When this many 512 byte blocks are filled by
 172  the SCSI device, an interrupt will be raised.  Therefore, this could be as
 173  low as 0, or as high as 16.  Note, however, that values which are too high
 174  or too low seem to prevent any interrupts from occurring, and thereby lock
 175  up the machine.  I have found that 2 is a good number, but throughput may
 176  be increased by changing this value to values which are close to 2.
 177  Please let me know if you try any different values.
 178 
 179  DO_DETECT: This activates some old scan code which was needed before the
 180  high level drivers got fixed.  If you are having trouble with the driver,
 181  turning this on should not hurt, and might help.  Please let me know if
 182  this is the case, since this code will be removed from future drivers.
 183 
 184  RESELECTION: This is no longer an option, since I gave up trying to
 185  implement it in version 4.x of this driver.  It did not improve
 186  performance at all and made the driver unstable (because I never found one
 187  of the two race conditions which were introduced by the multiple
 188  outstanding command code).  The instability seems a very high price to pay
 189  just so that you don't have to wait for the tape to rewind.  If you want
 190  this feature implemented, send me patches.  I'll be happy to send a copy
 191  of my (broken) driver to anyone who would like to see a copy.
 192 
 193  **************************************************************************/
 194 
 195 #ifdef MODULE
 196 #include <linux/module.h>
 197 #endif
 198 
 199 #include <linux/sched.h>
 200 #include <asm/io.h>
 201 #include <linux/blk.h>
 202 #include "scsi.h"
 203 #include "hosts.h"
 204 #include "fdomain.h"
 205 #include <asm/system.h>
 206 #include <linux/errno.h>
 207 #include <linux/string.h>
 208 #include <linux/ioport.h>
 209 #include <linux/proc_fs.h>
 210 #include <linux/bios32.h>
 211 #include <linux/pci.h>
 212 #include <linux/stat.h>
 213 
 214 #include <linux/config.h>       /* for CONFIG_PCI */
 215 
 216 struct proc_dir_entry proc_scsi_fdomain = {
 217     PROC_SCSI_FDOMAIN, 7, "fdomain",
 218     S_IFDIR | S_IRUGO | S_IXUGO, 2
 219 };
 220   
 221 #define VERSION          "$Revision: 5.39 $"
 222 
 223 /* START OF USER DEFINABLE OPTIONS */
 224 
 225 #define DEBUG            1      /* Enable debugging output */
 226 #define ENABLE_PARITY    1      /* Enable SCSI Parity */
 227 #define FIFO_COUNT       2      /* Number of 512 byte blocks before INTR */
 228 #define DO_DETECT        0      /* Do device detection here (see scsi.c) */
 229 
 230 /* END OF USER DEFINABLE OPTIONS */
 231 
 232 #if DEBUG
 233 #define EVERY_ACCESS     0      /* Write a line on every scsi access */
 234 #define ERRORS_ONLY      1      /* Only write a line if there is an error */
 235 #define DEBUG_DETECT     0      /* Debug fdomain_16x0_detect() */
 236 #define DEBUG_MESSAGES   1      /* Debug MESSAGE IN phase */
 237 #define DEBUG_ABORT      1      /* Debug abort() routine */
 238 #define DEBUG_RESET      1      /* Debug reset() routine */
 239 #define DEBUG_RACE       1      /* Debug interrupt-driven race condition */
 240 #else
 241 #define EVERY_ACCESS     0      /* LEAVE THESE ALONE--CHANGE THE ONES ABOVE */
 242 #define ERRORS_ONLY      0
 243 #define DEBUG_DETECT     0
 244 #define DEBUG_MESSAGES   0
 245 #define DEBUG_ABORT      0
 246 #define DEBUG_RESET      0
 247 #define DEBUG_RACE       0
 248 #endif
 249 
 250 /* Errors are reported on the line, so we don't need to report them again */
 251 #if EVERY_ACCESS
 252 #undef ERRORS_ONLY
 253 #define ERRORS_ONLY      0
 254 #endif
 255 
 256 #if ENABLE_PARITY
 257 #define PARITY_MASK      0x08
 258 #else
 259 #define PARITY_MASK      0x00
 260 #endif
 261 
 262 enum chip_type {
 263    unknown          = 0x00,
 264    tmc1800          = 0x01,
 265    tmc18c50         = 0x02,
 266    tmc18c30         = 0x03,
 267 };
 268 
 269 enum {
 270    in_arbitration   = 0x02,
 271    in_selection     = 0x04,
 272    in_other         = 0x08,
 273    disconnect       = 0x10,
 274    aborted          = 0x20,
 275    sent_ident       = 0x40,
 276 };
 277 
 278 enum in_port_type {
 279    Read_SCSI_Data   =  0,
 280    SCSI_Status      =  1,
 281    TMC_Status       =  2,
 282    FIFO_Status      =  3,       /* tmc18c50/tmc18c30 only */
 283    Interrupt_Cond   =  4,       /* tmc18c50/tmc18c30 only */
 284    LSB_ID_Code      =  5,
 285    MSB_ID_Code      =  6,
 286    Read_Loopback    =  7,
 287    SCSI_Data_NoACK  =  8,
 288    Interrupt_Status =  9,
 289    Configuration1   = 10,
 290    Configuration2   = 11,       /* tmc18c50/tmc18c30 only */
 291    Read_FIFO        = 12,
 292    FIFO_Data_Count  = 14
 293 };
 294 
 295 enum out_port_type {
 296    Write_SCSI_Data  =  0,
 297    SCSI_Cntl        =  1,
 298    Interrupt_Cntl   =  2,
 299    SCSI_Mode_Cntl   =  3,
 300    TMC_Cntl         =  4,
 301    Memory_Cntl      =  5,       /* tmc18c50/tmc18c30 only */
 302    Write_Loopback   =  7,
 303    IO_Control       = 11,       /* tmc18c30 only */
 304    Write_FIFO       = 12
 305 };
 306 
 307 static int               port_base         = 0;
 308 static void              *bios_base        = NULL;
 309 static int               bios_major        = 0;
 310 static int               bios_minor        = 0;
 311 static int               PCI_bus           = 0;
 312 static int               Quantum           = 0; /* Quantum board variant */
 313 static int               interrupt_level   = 0;
 314 static volatile int      in_command        = 0;
 315 static Scsi_Cmnd         *current_SC       = NULL;
 316 static enum chip_type    chip              = unknown;
 317 static int               adapter_mask      = 0;
 318 static int               this_id           = 0;
 319 static int               setup_called      = 0;
 320 
 321 #if DEBUG_RACE
 322 static volatile int      in_interrupt_flag = 0;
 323 #endif
 324 
 325 static int               SCSI_Mode_Cntl_port;
 326 static int               FIFO_Data_Count_port;
 327 static int               Interrupt_Cntl_port;
 328 static int               Interrupt_Status_port;
 329 static int               Read_FIFO_port;
 330 static int               Read_SCSI_Data_port;
 331 static int               SCSI_Cntl_port;
 332 static int               SCSI_Data_NoACK_port;
 333 static int               SCSI_Status_port;
 334 static int               TMC_Cntl_port;
 335 static int               TMC_Status_port;
 336 static int               Write_FIFO_port;
 337 static int               Write_SCSI_Data_port;
 338 
 339 static int               FIFO_Size = 0x2000; /* 8k FIFO for
 340                                                 pre-tmc18c30 chips */
 341 
 342 extern void              fdomain_16x0_intr( int irq, struct pt_regs * regs );
 343 
 344 static void *addresses[] = {
 345    (void *)0xc8000,
 346    (void *)0xca000,
 347    (void *)0xce000,
 348    (void *)0xde000,
 349    (void *)0xd0000,             /* Extra addresses for PCI boards */
 350    (void *)0xe0000,
 351 };
 352 #define ADDRESS_COUNT (sizeof( addresses ) / sizeof( unsigned ))
 353                        
 354 static unsigned short ports[] = { 0x140, 0x150, 0x160, 0x170 };
 355 #define PORT_COUNT (sizeof( ports ) / sizeof( unsigned short ))
 356 
 357 static unsigned short ints[] = { 3, 5, 10, 11, 12, 14, 15, 0 };
 358 
 359 /*
 360 
 361   READ THIS BEFORE YOU ADD A SIGNATURE!
 362 
 363   READING THIS SHORT NOTE CAN SAVE YOU LOTS OF TIME!
 364 
 365   READ EVERY WORD, ESPECIALLY THE WORD *NOT*
 366 
 367   This driver works *ONLY* for Future Domain cards using the TMC-1800,
 368   TMC-18C50, or TMC-18C30 chip.  This includes models TMC-1650, 1660, 1670,
 369   and 1680.
 370 
 371   The following BIOS signature signatures are for boards which do *NOT*
 372   work with this driver (these TMC-8xx and TMC-9xx boards may work with the
 373   Seagate driver):
 374 
 375   FUTURE DOMAIN CORP. (C) 1986-1988 V4.0I 03/16/88
 376   FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89
 377   FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89
 378   FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90
 379   FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90
 380   FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90
 381   FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92
 382 
 383 */
 384 
 385 struct signature {
 386    const char *signature;
 387    int  sig_offset;
 388    int  sig_length;
 389    int  major_bios_version;
 390    int  minor_bios_version;
 391    int  flag; /* 1 == PCI_bus, 2 == ISA_200S, 3 == ISA_250MG, 4 == ISA_200S */
 392 } signatures[] = {
 393    /*          1         2         3         4         5         6 */
 394    /* 123456789012345678901234567890123456789012345678901234567890 */
 395    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89",  5, 50,  2,  0, 0 },
 396    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V1.07/28/89",  5, 50,  2,  0, 0 },
 397    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.07/28/89", 72, 50,  2,  0, 2 },
 398    { "FUTURE DOMAIN CORP. (C) 1986-1990 1800-V2.0",        73, 43,  2,  0, 3 },
 399    { "FUTURE DOMAIN CORP. (C) 1991 1800-V2.0.",            72, 39,  2,  0, 4 },
 400    { "FUTURE DOMAIN CORP. (C) 1992 V3.00.004/02/92",        5, 44,  3,  0, 0 },
 401    { "FUTURE DOMAIN TMC-18XX (C) 1993 V3.203/12/93",        5, 44,  3,  2, 0 },
 402    { "IBM F1 P2 BIOS v1.0104/29/93",                        5, 28,  3, -1, 0 },
 403    { "Future Domain Corp. V1.0008/18/93",                   5, 33,  3,  4, 0 },
 404    { "Future Domain Corp. V1.0008/18/93",                  26, 33,  3,  4, 1 },
 405                                 /* This next signature may not be a 3.5 bios */
 406    { "Future Domain Corp. V2.0108/18/93",                   5, 33,  3,  5, 0 },
 407    { "FUTURE DOMAIN CORP.  V3.5008/18/93",                  5, 34,  3,  5, 0 },
 408    { "FUTURE DOMAIN 18c30/18c50/1800 (C) 1994 V3.5",        5, 44,  3,  5, 0 },
 409    { "FUTURE DOMAIN CORP.  V3.6008/18/93",                  5, 34,  3,  6, 0 },
 410    { "FUTURE DOMAIN CORP.  V3.6108/18/93",                  5, 34,  3,  6, 0 },
 411    { "FUTURE DOMAIN TMC-18XX",                              5, 22, -1, -1, 0 },
 412 
 413    /* READ NOTICE ABOVE *BEFORE* YOU WASTE YOUR TIME ADDING A SIGNATURE
 414     Also, fix the disk geometry code for your signature and send your
 415     changes for faith@cs.unc.edu.  Above all, do *NOT* change any old
 416     signatures!
 417 
 418     Note that the last line will match a "generic" 18XX bios.  Because
 419     Future Domain has changed the host SCSI ID and/or the location of the
 420     geometry information in the on-board RAM area for each of the first
 421     three BIOS's, it is still important to enter a fully qualified
 422     signature in the table for any new BIOS's (after the host SCSI ID and
 423     geometry location are verified). */
 424 };
 425 
 426 #define SIGNATURE_COUNT (sizeof( signatures ) / sizeof( struct signature ))
 427 
 428 static void print_banner( struct Scsi_Host *shpnt )
 429 {
 430    if (!shpnt) return;          /* This won't ever happen */
 431 
 432    if (bios_major < 0 && bios_minor < 0) {
 433       printk( "scsi%d <fdomain>: No BIOS; using scsi id %d\n",
 434               shpnt->host_no, shpnt->this_id );
 435    } else {
 436       printk( "scsi%d <fdomain>: BIOS version ", shpnt->host_no );
 437 
 438       if (bios_major >= 0) printk( "%d.", bios_major );
 439       else                 printk( "?." );
 440 
 441       if (bios_minor >= 0) printk( "%d", bios_minor );
 442       else                 printk( "?." );
 443    
 444       printk( " at 0x%x using scsi id %d\n",
 445               (unsigned)bios_base, shpnt->this_id );
 446    }
 447 
 448                                 /* If this driver works for later FD PCI
 449                                    boards, we will have to modify banner
 450                                    for additional PCI cards, but for now if
 451                                    it's PCI it's a TMC-3260 - JTM */
 452    printk( "scsi%d <fdomain>: %s chip at 0x%x irq ",
 453            shpnt->host_no,
 454            chip == tmc1800 ? "TMC-1800"
 455            : (chip == tmc18c50 ? "TMC-18C50"
 456               : (chip == tmc18c30 ?
 457                  (PCI_bus ? "TMC-36C70 (PCI bus)" : "TMC-18C30")
 458                  : "Unknown")),
 459            port_base );
 460 
 461    if (interrupt_level) printk( "%d", interrupt_level );
 462    else                 printk( "<none>" );
 463 
 464    printk( "\n" );
 465 }
 466 
 467 void fdomain_setup( char *str, int *ints )
     /* [previous][next][first][last][top][bottom][index][help] */
 468 {
 469    if (setup_called++ || ints[0] < 2 || ints[0] > 3) {
 470       printk( "fdomain: usage: fdomain=<PORT_BASE>,<IRQ>[,<ADAPTER_ID>]\n" );
 471       printk( "fdomain: bad LILO parameters?\n" );
 472    }
 473 
 474    port_base       = ints[0] >= 1 ? ints[1] : 0;
 475    interrupt_level = ints[0] >= 2 ? ints[2] : 0;
 476    this_id         = ints[0] >= 3 ? ints[3] : 0;
 477    
 478    bios_major = bios_minor = -1; /* Use geometry for BIOS version >= 3.4 */
 479 }
 480 
 481 
 482 static void do_pause( unsigned amount ) /* Pause for amount*10 milliseconds */
     /* [previous][next][first][last][top][bottom][index][help] */
 483 {
 484    unsigned long the_time = jiffies + amount; /* 0.01 seconds per jiffy */
 485 
 486    while (jiffies < the_time);
 487 }
 488 
 489 inline static void fdomain_make_bus_idle( void )
     /* [previous][next][first][last][top][bottom][index][help] */
 490 {
 491    outb( 0, SCSI_Cntl_port );
 492    outb( 0, SCSI_Mode_Cntl_port );
 493    if (chip == tmc18c50 || chip == tmc18c30)
 494          outb( 0x21 | PARITY_MASK, TMC_Cntl_port ); /* Clear forced intr. */
 495    else
 496          outb( 0x01 | PARITY_MASK, TMC_Cntl_port );
 497 }
 498 
 499 static int fdomain_is_valid_port( int port )
     /* [previous][next][first][last][top][bottom][index][help] */
 500 {
 501 #if DEBUG_DETECT 
 502    printk( " (%x%x),",
 503            inb( port + MSB_ID_Code ), inb( port + LSB_ID_Code ) );
 504 #endif
 505 
 506    /* The MCA ID is a unique id for each MCA compatible board.  We
 507       are using ISA boards, but Future Domain provides the MCA ID
 508       anyway.  We can use this ID to ensure that this is a Future
 509       Domain TMC-1660/TMC-1680.
 510     */
 511 
 512    if (inb( port + LSB_ID_Code ) != 0xe9) { /* test for 0x6127 id */
 513       if (inb( port + LSB_ID_Code ) != 0x27) return 0;
 514       if (inb( port + MSB_ID_Code ) != 0x61) return 0;
 515       chip = tmc1800;
 516    } else {                                 /* test for 0xe960 id */
 517       if (inb( port + MSB_ID_Code ) != 0x60) return 0;
 518       chip = tmc18c50;
 519 
 520 #if 0
 521 
 522                                 /* Try to toggle 32-bit mode.  This only
 523                                    works on an 18c30 chip.  (User reports
 524                                    say that this doesn't work at all, so
 525                                    we'll use the other method.) */
 526 
 527       outb( 0x80, port + IO_Control );
 528       if ((inb( port + Configuration2 ) & 0x80) == 0x80) {
 529          outb( 0x00, port + IO_Control );
 530          if ((inb( port + Configuration2 ) & 0x80) == 0x00) {
 531             chip = tmc18c30;
 532             FIFO_Size = 0x800;  /* 2k FIFO */
 533          }
 534       }
 535 #else
 536 
 537                                 /* That should have worked, but appears to
 538                                    have problems.  Lets assume it is an
 539                                    18c30 if the RAM is disabled. */
 540 
 541       if (inb( port + Configuration2 ) & 0x02) {
 542          chip      = tmc18c30;
 543          FIFO_Size = 0x800;     /* 2k FIFO */
 544       }
 545 #endif
 546                                 /* If that failed, we are an 18c50. */
 547    }
 548 
 549    return 1;
 550 }
 551 
 552 static int fdomain_test_loopback( void )
     /* [previous][next][first][last][top][bottom][index][help] */
 553 {
 554    int i;
 555    int result;
 556 
 557    for (i = 0; i < 255; i++) {
 558       outb( i, port_base + Write_Loopback );
 559       result = inb( port_base + Read_Loopback );
 560       if (i != result)
 561             return 1;
 562    }
 563    return 0;
 564 }
 565 
 566 /* fdomain_get_irq assumes that we have a valid MCA ID for a
 567    TMC-1660/TMC-1680 Future Domain board.  Now, check to be sure the
 568    bios_base matches these ports.  If someone was unlucky enough to have
 569    purchased more than one Future Domain board, then they will have to
 570    modify this code, as we only detect one board here.  [The one with the
 571    lowest bios_base.]
 572 
 573    Note that this routine is only used for systems without a PCI BIOS32
 574    (e.g., ISA bus).  For PCI bus systems, this routine will likely fail
 575    unless one of the IRQs listed in the ints array is used by the board.
 576    Sometimes it is possible to use the computer's BIOS setup screen to
 577    configure a PCI system so that one of these IRQs will be used by the
 578    Future Domain card. */
 579 
 580 static int fdomain_get_irq( int base )
     /* [previous][next][first][last][top][bottom][index][help] */
 581 {
 582    int options = inb( base + Configuration1 );
 583 
 584 #if DEBUG_DETECT
 585    printk( " Options = %x\n", options );
 586 #endif
 587    
 588                                 /* Check for board with lowest bios_base --
 589                                    this isn't valid for the 18c30 or for
 590                                    boards on the PCI bus, so just assume we
 591                                    have the right board. */
 592 
 593    if (chip != tmc18c30
 594        && !PCI_bus
 595        && addresses[ (options & 0xc0) >> 6 ] != bios_base) return 0;
 596 
 597    return ints[ (options & 0x0e) >> 1 ];
 598 }
 599 
 600 static int fdomain_isa_detect( int *irq, int *iobase )
     /* [previous][next][first][last][top][bottom][index][help] */
 601 {
 602    int i;
 603    int base;
 604    int flag = 0;
 605 
 606    if (bios_major == 2) {
 607       /* The TMC-1660/TMC-1680 has a RAM area just after the BIOS ROM.
 608          Assuming the ROM is enabled (otherwise we wouldn't have been
 609          able to read the ROM signature :-), then the ROM sets up the
 610          RAM area with some magic numbers, such as a list of port
 611          base addresses and a list of the disk "geometry" reported to
 612          DOS (this geometry has nothing to do with physical geometry).
 613        */
 614 
 615       switch (Quantum) {
 616       case 2:                   /* ISA_200S */
 617       case 3:                   /* ISA_250MG */
 618          base = *((char *)bios_base + 0x1fa2)
 619                + (*((char *)bios_base + 0x1fa3) << 8);
 620          break;
 621       case 4:                   /* ISA_200S (another one) */
 622          base = *((char *)bios_base + 0x1fa3)
 623                + (*((char *)bios_base + 0x1fa4) << 8);
 624          break;
 625       default:
 626          base = *((char *)bios_base + 0x1fcc)
 627                + (*((char *)bios_base + 0x1fcd) << 8);
 628          break;
 629       }
 630    
 631 #if DEBUG_DETECT
 632       printk( " %x,", base );
 633 #endif
 634 
 635       for (flag = 0, i = 0; !flag && i < PORT_COUNT; i++) {
 636          if (base == ports[i])
 637                ++flag;
 638       }
 639 
 640       if (flag && fdomain_is_valid_port( base )) {
 641          *irq    = fdomain_get_irq( base );
 642          *iobase = base;
 643          return 1;
 644       }
 645       
 646       /* This is a bad sign.  It usually means that someone patched the
 647          BIOS signature list (the signatures variable) to contain a BIOS
 648          signature for a board *OTHER THAN* the TMC-1660/TMC-1680. */
 649       
 650 #if DEBUG_DETECT
 651       printk( " RAM FAILED, " );
 652 #endif
 653    }
 654 
 655    /* Anyway, the alternative to finding the address in the RAM is to just
 656       search through every possible port address for one that is attached
 657       to the Future Domain card.  Don't panic, though, about reading all
 658       these random port addresses -- there are rumors that the Future
 659       Domain BIOS does something very similar.
 660 
 661       Do not, however, check ports which the kernel knows are being used by
 662       another driver. */
 663 
 664    for (i = 0; i < PORT_COUNT; i++) {
 665       base = ports[i];
 666       if (check_region( base, 0x10 )) {
 667 #if DEBUG_DETECT
 668          printk( " (%x inuse),", base );
 669 #endif
 670          continue;
 671       }
 672 #if DEBUG_DETECT
 673       printk( " %x,", base );
 674 #endif
 675       if ((flag = fdomain_is_valid_port( base ))) break;
 676    }
 677 
 678    if (!flag) return 0;         /* iobase not found */
 679 
 680    *irq    = fdomain_get_irq( base );
 681    *iobase = base;
 682 
 683    return 1;                    /* success */
 684 }
 685 
 686 static int fdomain_pci_nobios_detect( int *irq, int *iobase )
     /* [previous][next][first][last][top][bottom][index][help] */
 687 {
 688    int i;
 689    int flag = 0;
 690 
 691    /* The proper way of doing this is to use ask the PCI bus for the device
 692       IRQ and interrupt level.  But we can't do that if PCI BIOS32 support
 693       isn't compiled into the kernel, or if a PCI BIOS32 isn't present.
 694 
 695       Instead, we scan down a bunch of addresses (Future Domain tech
 696       support says we will probably find the address before we get to
 697       0xf800).  This works fine on some systems -- other systems may have
 698       to scan more addresses.  If you have to modify this section for your
 699       installation, please send mail to faith@cs.unc.edu. */
 700 
 701    for (i = 0xfff8; i > 0xe000; i -= 8) {
 702       if (check_region( i, 0x10 )) {
 703 #if DEBUG_DETECT
 704          printk( " (%x inuse)," , i );
 705 #endif
 706          continue;
 707       }
 708       if ((flag = fdomain_is_valid_port( i ))) break;
 709    }
 710 
 711    if (!flag) return 0;         /* iobase not found */
 712 
 713    *irq    = fdomain_get_irq( i );
 714    *iobase = i;
 715 
 716    return 1;                    /* success */
 717 }
 718 
 719 /* PCI detection function: int fdomain_pci_bios_detect(int* irq, int*
 720    iobase) This function gets the Interrupt Level and I/O base address from
 721    the PCI configuration registers.  The I/O base address is masked with
 722    0xfff8 since on my card the address read from the PCI config registers
 723    is off by one from the actual I/O base address necessary for accessing
 724    the status and control registers on the card (PCI config register gives
 725    0xf801, actual address is 0xf800).  This is likely a bug in the FD
 726    config code that writes to the PCI registers, however using a mask
 727    should be safe since I think the scan done by the card to determine the
 728    I/O base is done in increments of 8 (i.e., 0xf800, 0xf808, ...), at
 729    least the old scan code we used to use to get the I/O base did...  Also,
 730    the device ID from the PCI config registers is 0x0 and should be 0x60e9
 731    as it is in the status registers (offset 5 from I/O base).  If this is
 732    changed in future hardware/BIOS changes it will need to be fixed in this
 733    detection function.  Comments, bug reports, etc... on this function
 734    should be sent to mckinley@msupa.pa.msu.edu - James T. McKinley.  */
 735 
 736 #ifdef CONFIG_PCI
 737 static int fdomain_pci_bios_detect( int *irq, int *iobase )
     /* [previous][next][first][last][top][bottom][index][help] */
 738 {
 739    int              error;
 740    unsigned char    pci_bus, pci_dev_fn;    /* PCI bus & device function */
 741    unsigned char    pci_irq;                /* PCI interrupt line */
 742    unsigned int     pci_base;               /* PCI I/O base address */
 743    unsigned short   pci_vendor, pci_device; /* PCI vendor & device IDs */
 744 
 745    /* If the PCI BIOS doesn't exist, use the old-style detection routines.
 746       Otherwise, get the I/O base address and interrupt from the PCI config
 747       registers. */
 748    
 749    if (!pcibios_present()) return fdomain_pci_nobios_detect( irq, iobase );
 750 
 751 #if DEBUG_DETECT
 752    /* Tell how to print a list of the known PCI devices from bios32 and
 753       list vendor and device IDs being used if in debug mode.  */
 754       
 755    printk( "\nINFO: cat /proc/pci to see list of PCI devices from bios32\n" );
 756    printk( "\nTMC-3260 detect:"
 757            " Using PCI Vendor ID: 0x%x, PCI Device ID: 0x%x\n",
 758            PCI_VENDOR_ID_FD, 
 759            PCI_DEVICE_ID_FD_36C70 );
 760 #endif 
 761 
 762    /* We will have to change this if more than 1 PCI bus is present and the
 763       FD scsi host is not on the first bus (i.e., a PCI to PCI bridge,
 764       which is not supported by bios32 right now anyway).  This should
 765       probably be done by a call to pcibios_find_device but I can't get it
 766       to work...  Also the device ID reported from the PCI config registers
 767       does not match the device ID quoted in the tech manual or available
 768       from offset 5 from the I/O base address.  It should be 0x60E9, but it
 769       is 0x0 if read from the PCI config registers.  I guess the FD folks
 770       neglected to write it to the PCI registers...  This loop is necessary
 771       to get the device function (at least until someone can get
 772       pcibios_find_device to work, I cannot but 53c7,8xx.c uses it...). */
 773     
 774    pci_bus = 0;
 775 
 776    for (pci_dev_fn = 0x0; pci_dev_fn < 0xff; pci_dev_fn++) {
 777       pcibios_read_config_word( pci_bus,
 778                                 pci_dev_fn,
 779                                 PCI_VENDOR_ID,
 780                                 &pci_vendor );
 781 
 782       if (pci_vendor == PCI_VENDOR_ID_FD) {
 783          pcibios_read_config_word( pci_bus,
 784                                    pci_dev_fn,
 785                                    PCI_DEVICE_ID,
 786                                    &pci_device );
 787 
 788          if (pci_device == PCI_DEVICE_ID_FD_36C70) {
 789             /* Break out once we have the correct device.  If other FD
 790                PCI devices are added to this driver we will need to add
 791                an or of the other PCI_DEVICE_ID_FD_XXXXX's here. */
 792             break;
 793          } else {
 794             /* If we can't find an FD scsi card we give up. */
 795             return 0;
 796          }
 797       }
 798    }
 799        
 800 #if DEBUG_DETECT
 801    printk( "Future Domain 36C70 : at PCI bus %u, device %u, function %u\n",
 802            pci_bus,
 803            (pci_dev_fn & 0xf8) >> 3, 
 804            pci_dev_fn & 7 );
 805 #endif
 806 
 807    /* We now have the appropriate device function for the FD board so we
 808       just read the PCI config info from the registers.  */
 809 
 810    if ((error = pcibios_read_config_dword( pci_bus,
 811                                            pci_dev_fn, 
 812                                            PCI_BASE_ADDRESS_0,
 813                                            &pci_base ))
 814        || (error = pcibios_read_config_byte( pci_bus,
 815                                              pci_dev_fn, 
 816                                              PCI_INTERRUPT_LINE,
 817                                              &pci_irq ))) {
 818       printk ( "PCI ERROR: Future Domain 36C70 not initializing"
 819                " due to error reading configuration space\n" );
 820       return 0;
 821    } else {
 822 #if DEBUG_DETECT
 823       printk( "TMC-3260 PCI: IRQ = %u, I/O base = 0x%lx\n", 
 824               pci_irq, pci_base );
 825 #endif
 826 
 827       /* Now we have the I/O base address and interrupt from the PCI
 828          configuration registers.  Unfortunately it seems that the I/O base
 829          address is off by one on my card so I mask it with 0xfff8.  This
 830          must be some kind of goof in the FD code that does the autoconfig
 831          and writes to the PCI registers (or maybe I just don't understand
 832          something).  If they fix it in later versions of the card or BIOS
 833          we may have to adjust the address based on the signature or
 834          something...  */
 835 
 836       *irq    = pci_irq;
 837       *iobase = (pci_base & 0xfff8);
 838 
 839 #if DEBUG_DETECT
 840       printk( "TMC-3260 fix: Masking I/O base address with 0xff00.\n" ); 
 841       printk( "TMC-3260: IRQ = %d, I/O base = 0x%x\n", *irq, *iobase );
 842 #endif
 843 
 844       if (!fdomain_is_valid_port( *iobase )) return 0;
 845       return 1;
 846    }
 847    return 0;
 848 }
 849 #endif
 850 
 851 int fdomain_16x0_detect( Scsi_Host_Template *tpnt )
     /* [previous][next][first][last][top][bottom][index][help] */
 852 {
 853    int              i, j;
 854    int              retcode;
 855    struct Scsi_Host *shpnt;
 856 #if DO_DETECT
 857    const int        buflen = 255;
 858    Scsi_Cmnd        SCinit;
 859    unsigned char    do_inquiry[] =       { INQUIRY, 0, 0, 0, buflen, 0 };
 860    unsigned char    do_request_sense[] = { REQUEST_SENSE, 0, 0, 0, buflen, 0 };
 861    unsigned char    do_read_capacity[] = { READ_CAPACITY,
 862                                            0, 0, 0, 0, 0, 0, 0, 0, 0 };
 863    unsigned char    buf[buflen];
 864 #endif
 865 
 866 #if DEBUG_DETECT
 867    printk( "fdomain_16x0_detect()," );
 868 #endif
 869    tpnt->proc_dir = &proc_scsi_fdomain;
 870 
 871    if (setup_called) {
 872 #if DEBUG_DETECT
 873       printk( "no BIOS, using port_base = 0x%x, irq = %d\n",
 874               port_base, interrupt_level );
 875 #endif
 876       if (!fdomain_is_valid_port( port_base )) {
 877          printk( "fdomain: cannot locate chip at port base 0x%x\n",
 878                  port_base );
 879          printk( "fdomain: bad LILO parameters?\n" );
 880          return 0;
 881       }
 882    } else {
 883       int flag = 0;
 884       
 885       for (i = 0; !bios_base && i < ADDRESS_COUNT; i++) {
 886 #if DEBUG_DETECT
 887          printk( " %x(%x),", (unsigned)addresses[i], (unsigned)bios_base );
 888 #endif
 889          for (j = 0; !bios_base && j < SIGNATURE_COUNT; j++) {
 890             if (!memcmp( ((char *)addresses[i] + signatures[j].sig_offset),
 891                          signatures[j].signature, signatures[j].sig_length )) {
 892                bios_major = signatures[j].major_bios_version;
 893                bios_minor = signatures[j].minor_bios_version;
 894                PCI_bus    = (signatures[j].flag == 1);
 895                Quantum    = (signatures[j].flag > 1) ? signatures[j].flag : 0;
 896                bios_base  = addresses[i];
 897             }
 898          }
 899       }
 900 
 901       if (!bios_base) {
 902 #if DEBUG_DETECT
 903          printk( " FAILED: NO BIOS\n" );
 904 #endif
 905          return 0;
 906       }
 907 
 908       if (!PCI_bus) {
 909          flag = fdomain_isa_detect( &interrupt_level, &port_base );
 910       } else {
 911 #ifdef CONFIG_PCI
 912          flag = fdomain_pci_bios_detect( &interrupt_level, &port_base );
 913 #else
 914          flag = fdomain_pci_nobios_detect( &interrupt_level, &port_base );
 915 #endif
 916       }
 917          
 918       if (!flag) {
 919 #if DEBUG_DETECT
 920          printk( " FAILED: NO PORT\n" );
 921 #endif
 922 #ifdef CONFIG_PCI
 923          printk( "\nTMC-3260 36C70 PCI scsi chip detection failed.\n" );
 924          printk( "Send mail to mckinley@msupa.pa.msu.edu.\n" );
 925 #endif
 926          return 0;              /* Cannot find valid set of ports */
 927       }
 928    }
 929 
 930    SCSI_Mode_Cntl_port   = port_base + SCSI_Mode_Cntl;
 931    FIFO_Data_Count_port  = port_base + FIFO_Data_Count;
 932    Interrupt_Cntl_port   = port_base + Interrupt_Cntl;
 933    Interrupt_Status_port = port_base + Interrupt_Status;
 934    Read_FIFO_port        = port_base + Read_FIFO;
 935    Read_SCSI_Data_port   = port_base + Read_SCSI_Data;
 936    SCSI_Cntl_port        = port_base + SCSI_Cntl;
 937    SCSI_Data_NoACK_port  = port_base + SCSI_Data_NoACK;
 938    SCSI_Status_port      = port_base + SCSI_Status;
 939    TMC_Cntl_port         = port_base + TMC_Cntl;
 940    TMC_Status_port       = port_base + TMC_Status;
 941    Write_FIFO_port       = port_base + Write_FIFO;
 942    Write_SCSI_Data_port  = port_base + Write_SCSI_Data;
 943 
 944    fdomain_16x0_reset( NULL );
 945 
 946    if (fdomain_test_loopback()) {
 947 #if DEBUG_DETECT
 948       printk( "fdomain: LOOPBACK TEST FAILED, FAILING DETECT!\n" );
 949 #endif
 950       if (setup_called) {
 951          printk( "fdomain: loopback test failed at port base 0x%x\n",
 952                  port_base );
 953          printk( "fdomain: bad LILO parameters?\n" );
 954       }
 955       return 0;
 956    }
 957 
 958    if (this_id) {
 959       tpnt->this_id = (this_id & 0x07);
 960       adapter_mask  = (1 << tpnt->this_id);
 961    } else {
 962       if ((bios_major == 3 && bios_minor >= 2) || bios_major < 0) {
 963          tpnt->this_id = 7;
 964          adapter_mask  = 0x80;
 965       } else {
 966          tpnt->this_id = 6;
 967          adapter_mask  = 0x40;
 968       }
 969    }
 970 
 971                                 /* Print out a banner here in case we can't
 972                                    get resources.  */
 973 
 974    shpnt = scsi_register( tpnt, 0 );
 975    print_banner( shpnt );
 976 
 977                                 /* Log IRQ with kernel */   
 978    if (!interrupt_level) {
 979       panic( "fdomain: *NO* interrupt level selected!\n" );
 980    } else {
 981       /* Register the IRQ with the kernel */
 982 
 983       retcode = request_irq( interrupt_level,
 984                              fdomain_16x0_intr, SA_INTERRUPT, "fdomain" );
 985 
 986       if (retcode < 0) {
 987          if (retcode == -EINVAL) {
 988             printk( "fdomain: IRQ %d is bad!\n", interrupt_level );
 989             printk( "         This shouldn't happen!\n" );
 990             printk( "         Send mail to faith@cs.unc.edu\n" );
 991          } else if (retcode == -EBUSY) {
 992             printk( "fdomain: IRQ %d is already in use!\n", interrupt_level );
 993             printk( "         Please use another IRQ!\n" );
 994          } else {
 995             printk( "fdomain: Error getting IRQ %d\n", interrupt_level );
 996             printk( "         This shouldn't happen!\n" );
 997             printk( "         Send mail to faith@cs.unc.edu\n" );
 998          }
 999          panic( "fdomain: Driver requires interruptions\n" );
1000       }
1001    }
1002 
1003                                 /* Log I/O ports with kernel */
1004    request_region( port_base, 0x10, "fdomain" );
1005 
1006 #if DO_DETECT
1007 
1008    /* These routines are here because of the way the SCSI bus behaves after
1009       a reset.  This appropriate behavior was not handled correctly by the
1010       higher level SCSI routines when I first wrote this driver.  Now,
1011       however, correct scan routines are part of scsi.c and these routines
1012       are no longer needed.  However, this code is still good for
1013       debugging.  */
1014 
1015    SCinit.request_buffer  = SCinit.buffer = buf;
1016    SCinit.request_bufflen = SCinit.bufflen = sizeof(buf)-1;
1017    SCinit.use_sg          = 0;
1018    SCinit.lun             = 0;
1019 
1020    printk( "fdomain: detection routine scanning for devices:\n" );
1021    for (i = 0; i < 8; i++) {
1022       SCinit.target = i;
1023       if (i == tpnt->this_id)   /* Skip host adapter */
1024             continue;
1025       memcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
1026       retcode = fdomain_16x0_command(&SCinit);
1027       if (!retcode) {
1028          memcpy(SCinit.cmnd, do_inquiry, sizeof(do_inquiry));
1029          retcode = fdomain_16x0_command(&SCinit);
1030          if (!retcode) {
1031             printk( "     SCSI ID %d: ", i );
1032             for (j = 8; j < (buf[4] < 32 ? buf[4] : 32); j++)
1033                   printk( "%c", buf[j] >= 20 ? buf[j] : ' ' );
1034             memcpy(SCinit.cmnd, do_read_capacity, sizeof(do_read_capacity));
1035             retcode = fdomain_16x0_command(&SCinit);
1036             if (!retcode) {
1037                unsigned long blocks, size, capacity;
1038                
1039                blocks = (buf[0] << 24) | (buf[1] << 16)
1040                      | (buf[2] << 8) | buf[3];
1041                size = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
1042                capacity = +( +(blocks / 1024L) * +(size * 10L)) / 1024L;
1043                
1044                printk( "%lu MB (%lu byte blocks)",
1045                        ((capacity + 5L) / 10L), size );
1046             } else {
1047                memcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
1048                retcode = fdomain_16x0_command(&SCinit);
1049             }
1050             printk ("\n" );
1051          } else {
1052             memcpy(SCinit.cmnd, do_request_sense, sizeof(do_request_sense));
1053             retcode = fdomain_16x0_command(&SCinit);
1054          }
1055       }
1056    }
1057 #endif
1058 
1059    return 1;                    /* Maximum of one adapter will be detected. */
1060 }
1061 
1062 const char *fdomain_16x0_info( struct Scsi_Host *ignore )
     /* [previous][next][first][last][top][bottom][index][help] */
1063 {
1064    static char buffer[80];
1065    char        *pt;
1066    
1067    strcpy( buffer, "Future Domain TMC-16x0 SCSI driver, version" );
1068    if (strchr( VERSION, ':')) { /* Assume VERSION is an RCS Revision string */
1069       strcat( buffer, strchr( VERSION, ':' ) + 1 );
1070       pt = strrchr( buffer, '$') - 1;
1071       if (!pt)                  /* Stripped RCS Revision string? */
1072             pt = buffer + strlen( buffer ) - 1;
1073       if (*pt != ' ')
1074             ++pt;
1075       *pt = '\0';
1076    } else {                     /* Assume VERSION is a number */
1077       strcat( buffer, " " VERSION );
1078    }
1079       
1080    return buffer;
1081 }
1082 
1083                                 /* First pass at /proc information routine. */
1084 /*
1085  * inout : decides on the direction of the dataflow and the meaning of the 
1086  *         variables
1087  * buffer: If inout==FALSE data is beeing written to it else read from it
1088  * *start: If inout==FALSE start of the valid data in the buffer
1089  * offset: If inout==FALSE offset from the beginning of the imaginary file 
1090  *         from which we start writing into the buffer
1091  * length: If inout==FALSE max number of bytes to be written into the buffer 
1092  *         else number of bytes in the buffer
1093  */
1094 int fdomain_16x0_proc_info( char *buffer, char **start, off_t offset,
     /* [previous][next][first][last][top][bottom][index][help] */
1095                             int length, int hostno, int inout )
1096 {
1097    const char *info = fdomain_16x0_info( NULL );
1098    int        len;
1099    int        pos;
1100    int        begin;
1101 
1102    if (inout) return(-ENOSYS);
1103     
1104    begin = 0;
1105    strcpy( buffer, info );
1106    strcat( buffer, "\n" );
1107 
1108    pos = len = strlen( buffer );
1109 
1110    if(pos < offset) {
1111       len = 0;
1112       begin = pos;
1113    }
1114     
1115    *start = buffer + (offset - begin);   /* Start of wanted data */
1116    len -= (offset - begin);
1117    if(len > length) len = length;
1118    
1119    return(len);
1120 }
1121    
1122 #if 0
1123 static int fdomain_arbitrate( void )
     /* [previous][next][first][last][top][bottom][index][help] */
1124 {
1125    int           status = 0;
1126    unsigned long timeout;
1127 
1128 #if EVERY_ACCESS
1129    printk( "fdomain_arbitrate()\n" );
1130 #endif
1131    
1132    outb( 0x00, SCSI_Cntl_port );              /* Disable data drivers */
1133    outb( adapter_mask, port_base + SCSI_Data_NoACK ); /* Set our id bit */
1134    outb( 0x04 | PARITY_MASK, TMC_Cntl_port ); /* Start arbitration */
1135 
1136    timeout = jiffies + 50;                    /* 500 mS */
1137    while (jiffies < timeout) {
1138       status = inb( TMC_Status_port );        /* Read adapter status */
1139       if (status & 0x02)                      /* Arbitration complete */
1140             return 0;   
1141    }
1142 
1143    /* Make bus idle */
1144    fdomain_make_bus_idle();
1145 
1146 #if EVERY_ACCESS
1147    printk( "Arbitration failed, status = %x\n", status );
1148 #endif
1149 #if ERRORS_ONLY
1150    printk( "fdomain: Arbitration failed, status = %x\n", status );
1151 #endif
1152    return 1;
1153 }
1154 #endif
1155 
1156 static int fdomain_select( int target )
     /* [previous][next][first][last][top][bottom][index][help] */
1157 {
1158    int           status;
1159    unsigned long timeout;
1160    static int    flag = 0;
1161 
1162 
1163    outb( 0x82, SCSI_Cntl_port ); /* Bus Enable + Select */
1164    outb( adapter_mask | (1 << target), SCSI_Data_NoACK_port );
1165 
1166    /* Stop arbitration and enable parity */
1167    outb( PARITY_MASK, TMC_Cntl_port ); 
1168 
1169    timeout = jiffies + 35;              /* 350mS -- because of timeouts
1170                                            (was 250mS) */
1171 
1172    while (jiffies < timeout) {
1173       status = inb( SCSI_Status_port ); /* Read adapter status */
1174       if (status & 1) {                 /* Busy asserted */
1175          /* Enable SCSI Bus (on error, should make bus idle with 0) */
1176          outb( 0x80, SCSI_Cntl_port );
1177          return 0;
1178       }
1179    }
1180    /* Make bus idle */
1181    fdomain_make_bus_idle();
1182 #if EVERY_ACCESS
1183    if (!target) printk( "Selection failed\n" );
1184 #endif
1185 #if ERRORS_ONLY
1186    if (!target) {
1187       if (chip == tmc18c30 && !flag) /* Skip first failure for 18C30 chips. */
1188             ++flag;
1189       else
1190             printk( "fdomain: Selection failed\n" );
1191    }
1192 #endif
1193    return 1;
1194 }
1195 
1196 void my_done( int error )
     /* [previous][next][first][last][top][bottom][index][help] */
1197 {
1198    if (in_command) {
1199       in_command = 0;
1200       outb( 0x00, Interrupt_Cntl_port );
1201       fdomain_make_bus_idle();
1202       current_SC->result = error;
1203       if (current_SC->scsi_done)
1204             current_SC->scsi_done( current_SC );
1205       else panic( "fdomain: current_SC->scsi_done() == NULL" );
1206    } else {
1207       panic( "fdomain: my_done() called outside of command\n" );
1208    }
1209 #if DEBUG_RACE
1210    in_interrupt_flag = 0;
1211 #endif
1212 }
1213 
1214 void fdomain_16x0_intr( int irq, struct pt_regs * regs )
     /* [previous][next][first][last][top][bottom][index][help] */
1215 {
1216    int      status;
1217    int      done = 0;
1218    unsigned data_count;
1219 
1220                                 /* The fdomain_16x0_intr is only called via
1221                                    the interrupt handler.  The goal of the
1222                                    sti() here is to allow other
1223                                    interruptions while this routine is
1224                                    running. */
1225 
1226    sti();                       /* Yes, we really want sti() here */
1227    
1228    outb( 0x00, Interrupt_Cntl_port );
1229 
1230    /* We usually have one spurious interrupt after each command.  Ignore it. */
1231    if (!in_command || !current_SC) {    /* Spurious interrupt */
1232 #if EVERY_ACCESS
1233       printk( "Spurious interrupt, in_command = %d, current_SC = %x\n",
1234               in_command, current_SC );
1235 #endif
1236       return;
1237    }
1238 
1239    /* Abort calls my_done, so we do nothing here. */
1240    if (current_SC->SCp.phase & aborted) {
1241 #if DEBUG_ABORT
1242       printk( "Interrupt after abort, ignoring\n" );
1243 #endif
1244       /*
1245       return; */
1246    }
1247 
1248 #if DEBUG_RACE
1249    ++in_interrupt_flag;
1250 #endif
1251 
1252    if (current_SC->SCp.phase & in_arbitration) {
1253       status = inb( TMC_Status_port );        /* Read adapter status */
1254       if (!(status & 0x02)) {
1255 #if EVERY_ACCESS
1256          printk( " AFAIL " );
1257 #endif
1258          my_done( DID_BUS_BUSY << 16 );
1259          return;
1260       }
1261       current_SC->SCp.phase = in_selection;
1262       
1263       outb( 0x40 | FIFO_COUNT, Interrupt_Cntl_port );
1264 
1265       outb( 0x82, SCSI_Cntl_port ); /* Bus Enable + Select */
1266       outb( adapter_mask | (1 << current_SC->target), SCSI_Data_NoACK_port );
1267       
1268       /* Stop arbitration and enable parity */
1269       outb( 0x10 | PARITY_MASK, TMC_Cntl_port );
1270 #if DEBUG_RACE
1271       in_interrupt_flag = 0;
1272 #endif
1273       return;
1274    } else if (current_SC->SCp.phase & in_selection) {
1275       status = inb( SCSI_Status_port );
1276       if (!(status & 0x01)) {
1277          /* Try again, for slow devices */
1278          if (fdomain_select( current_SC->target )) {
1279 #if EVERY_ACCESS
1280             printk( " SFAIL " );
1281 #endif
1282             my_done( DID_NO_CONNECT << 16 );
1283             return;
1284          } else {
1285 #if EVERY_ACCESS
1286             printk( " AltSel " );
1287 #endif
1288             /* Stop arbitration and enable parity */
1289             outb( 0x10 | PARITY_MASK, TMC_Cntl_port );
1290          }
1291       }
1292       current_SC->SCp.phase = in_other;
1293       outb( 0x90 | FIFO_COUNT, Interrupt_Cntl_port );
1294       outb( 0x80, SCSI_Cntl_port );
1295 #if DEBUG_RACE
1296       in_interrupt_flag = 0;
1297 #endif
1298       return;
1299    }
1300    
1301    /* current_SC->SCp.phase == in_other: this is the body of the routine */
1302    
1303    status = inb( SCSI_Status_port );
1304    
1305    if (status & 0x10) { /* REQ */
1306       
1307       switch (status & 0x0e) {
1308        
1309       case 0x08:                /* COMMAND OUT */
1310          outb( current_SC->cmnd[current_SC->SCp.sent_command++],
1311                Write_SCSI_Data_port );
1312 #if EVERY_ACCESS
1313          printk( "CMD = %x,",
1314                  current_SC->cmnd[ current_SC->SCp.sent_command - 1] );
1315 #endif
1316          break;
1317       case 0x00:                /* DATA OUT -- tmc18c50/tmc18c30 only */
1318          if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1319             current_SC->SCp.have_data_in = -1;
1320             outb( 0xd0 | PARITY_MASK, TMC_Cntl_port );
1321          }
1322          break;
1323       case 0x04:                /* DATA IN -- tmc18c50/tmc18c30 only */
1324          if (chip != tmc1800 && !current_SC->SCp.have_data_in) {
1325             current_SC->SCp.have_data_in = 1;
1326             outb( 0x90 | PARITY_MASK, TMC_Cntl_port );
1327          }
1328          break;
1329       case 0x0c:                /* STATUS IN */
1330          current_SC->SCp.Status = inb( Read_SCSI_Data_port );
1331 #if EVERY_ACCESS
1332          printk( "Status = %x, ", current_SC->SCp.Status );
1333 #endif
1334 #if ERRORS_ONLY
1335          if (current_SC->SCp.Status && current_SC->SCp.Status != 2) {
1336             printk( "fdomain: target = %d, command = %x, status = %x\n",
1337                     current_SC->target,
1338                     current_SC->cmnd[0],
1339                     current_SC->SCp.Status );
1340          }
1341 #endif
1342                break;
1343       case 0x0a:                /* MESSAGE OUT */
1344          outb( MESSAGE_REJECT, Write_SCSI_Data_port ); /* Reject */
1345          break;
1346       case 0x0e:                /* MESSAGE IN */
1347          current_SC->SCp.Message = inb( Read_SCSI_Data_port );
1348 #if EVERY_ACCESS
1349          printk( "Message = %x, ", current_SC->SCp.Message );
1350 #endif
1351          if (!current_SC->SCp.Message) ++done;
1352 #if DEBUG_MESSAGES || EVERY_ACCESS
1353          if (current_SC->SCp.Message) {
1354             printk( "fdomain: message = %x\n", current_SC->SCp.Message );
1355          }
1356 #endif
1357          break;
1358       }
1359    }
1360 
1361    if (chip == tmc1800
1362        && !current_SC->SCp.have_data_in
1363        && (current_SC->SCp.sent_command
1364            >= current_SC->cmd_len)) {
1365                                 /* We have to get the FIFO direction
1366                                    correct, so I've made a table based
1367                                    on the SCSI Standard of which commands
1368                                    appear to require a DATA OUT phase.
1369                                  */
1370       /*
1371         p. 94: Command for all device types
1372         CHANGE DEFINITION            40 DATA OUT
1373         COMPARE                      39 DATA OUT
1374         COPY                         18 DATA OUT
1375         COPY AND VERIFY              3a DATA OUT
1376         INQUIRY                      12 
1377         LOG SELECT                   4c DATA OUT
1378         LOG SENSE                    4d
1379         MODE SELECT (6)              15 DATA OUT
1380         MODE SELECT (10)             55 DATA OUT
1381         MODE SENSE (6)               1a
1382         MODE SENSE (10)              5a
1383         READ BUFFER                  3c
1384         RECEIVE DIAGNOSTIC RESULTS   1c
1385         REQUEST SENSE                03
1386         SEND DIAGNOSTIC              1d DATA OUT
1387         TEST UNIT READY              00
1388         WRITE BUFFER                 3b DATA OUT
1389 
1390         p.178: Commands for direct-access devices (not listed on p. 94)
1391         FORMAT UNIT                  04 DATA OUT
1392         LOCK-UNLOCK CACHE            36
1393         PRE-FETCH                    34
1394         PREVENT-ALLOW MEDIUM REMOVAL 1e
1395         READ (6)/RECEIVE             08
1396         READ (10)                    3c
1397         READ CAPACITY                25
1398         READ DEFECT DATA (10)        37
1399         READ LONG                    3e
1400         REASSIGN BLOCKS              07 DATA OUT
1401         RELEASE                      17
1402         RESERVE                      16 DATA OUT
1403         REZERO UNIT/REWIND           01
1404         SEARCH DATA EQUAL (10)       31 DATA OUT
1405         SEARCH DATA HIGH (10)        30 DATA OUT
1406         SEARCH DATA LOW (10)         32 DATA OUT
1407         SEEK (6)                     0b
1408         SEEK (10)                    2b
1409         SET LIMITS (10)              33
1410         START STOP UNIT              1b
1411         SYNCHRONIZE CACHE            35
1412         VERIFY (10)                  2f
1413         WRITE (6)/PRINT/SEND         0a DATA OUT
1414         WRITE (10)/SEND              2a DATA OUT
1415         WRITE AND VERIFY (10)        2e DATA OUT
1416         WRITE LONG                   3f DATA OUT
1417         WRITE SAME                   41 DATA OUT ?
1418 
1419         p. 261: Commands for sequential-access devices (not previously listed)
1420         ERASE                        19
1421         LOAD UNLOAD                  1b
1422         LOCATE                       2b
1423         READ BLOCK LIMITS            05
1424         READ POSITION                34
1425         READ REVERSE                 0f
1426         RECOVER BUFFERED DATA        14
1427         SPACE                        11
1428         WRITE FILEMARKS              10 ?
1429 
1430         p. 298: Commands for printer devices (not previously listed)
1431         ****** NOT SUPPORTED BY THIS DRIVER, since 0b is SEEK (6) *****
1432         SLEW AND PRINT               0b DATA OUT  -- same as seek
1433         STOP PRINT                   1b
1434         SYNCHRONIZE BUFFER           10
1435 
1436         p. 315: Commands for processor devices (not previously listed)
1437         
1438         p. 321: Commands for write-once devices (not previously listed)
1439         MEDIUM SCAN                  38
1440         READ (12)                    a8
1441         SEARCH DATA EQUAL (12)       b1 DATA OUT
1442         SEARCH DATA HIGH (12)        b0 DATA OUT
1443         SEARCH DATA LOW (12)         b2 DATA OUT
1444         SET LIMITS (12)              b3
1445         VERIFY (12)                  af
1446         WRITE (12)                   aa DATA OUT
1447         WRITE AND VERIFY (12)        ae DATA OUT
1448 
1449         p. 332: Commands for CD-ROM devices (not previously listed)
1450         PAUSE/RESUME                 4b
1451         PLAY AUDIO (10)              45
1452         PLAY AUDIO (12)              a5
1453         PLAY AUDIO MSF               47
1454         PLAY TRACK RELATIVE (10)     49
1455         PLAY TRACK RELATIVE (12)     a9
1456         READ HEADER                  44
1457         READ SUB-CHANNEL             42
1458         READ TOC                     43
1459 
1460         p. 370: Commands for scanner devices (not previously listed)
1461         GET DATA BUFFER STATUS       34
1462         GET WINDOW                   25
1463         OBJECT POSITION              31
1464         SCAN                         1b
1465         SET WINDOW                   24 DATA OUT
1466 
1467         p. 391: Commands for optical memory devices (not listed)
1468         ERASE (10)                   2c
1469         ERASE (12)                   ac
1470         MEDIUM SCAN                  38 DATA OUT
1471         READ DEFECT DATA (12)        b7
1472         READ GENERATION              29
1473         READ UPDATED BLOCK           2d
1474         UPDATE BLOCK                 3d DATA OUT
1475 
1476         p. 419: Commands for medium changer devices (not listed)
1477         EXCHANGE MEDIUM              46
1478         INITIALIZE ELEMENT STATUS    07
1479         MOVE MEDIUM                  a5
1480         POSITION TO ELEMENT          2b
1481         READ ELEMENT STATUS          b8
1482         REQUEST VOL. ELEMENT ADDRESS b5
1483         SEND VOLUME TAG              b6 DATA OUT
1484 
1485         p. 454: Commands for communications devices (not listed previously)
1486         GET MESSAGE (6)              08
1487         GET MESSAGE (10)             28
1488         GET MESSAGE (12)             a8
1489       */
1490         
1491       switch (current_SC->cmnd[0]) {
1492       case CHANGE_DEFINITION: case COMPARE:         case COPY:
1493       case COPY_VERIFY:       case LOG_SELECT:      case MODE_SELECT:
1494       case MODE_SELECT_10:    case SEND_DIAGNOSTIC: case WRITE_BUFFER:
1495 
1496       case FORMAT_UNIT:       case REASSIGN_BLOCKS: case RESERVE:
1497       case SEARCH_EQUAL:      case SEARCH_HIGH:     case SEARCH_LOW:
1498       case WRITE_6:           case WRITE_10:        case WRITE_VERIFY:
1499       case 0x3f:              case 0x41:
1500 
1501       case 0xb1:              case 0xb0:            case 0xb2:
1502       case 0xaa:              case 0xae:
1503 
1504       case 0x24:
1505 
1506       case 0x38:              case 0x3d:
1507 
1508       case 0xb6:
1509          
1510       case 0xea:                /* alternate number for WRITE LONG */
1511          
1512          current_SC->SCp.have_data_in = -1;
1513          outb( 0xd0 | PARITY_MASK, TMC_Cntl_port );
1514          break;
1515 
1516       case 0x00:
1517       default:
1518          
1519          current_SC->SCp.have_data_in = 1;
1520          outb( 0x90 | PARITY_MASK, TMC_Cntl_port );
1521          break;
1522       }
1523    }
1524 
1525    if (current_SC->SCp.have_data_in == -1) { /* DATA OUT */
1526       while ( (data_count = FIFO_Size - inw( FIFO_Data_Count_port )) > 512 ) {
1527 #if EVERY_ACCESS
1528          printk( "DC=%d, ", data_count ) ;
1529 #endif
1530          if (data_count > current_SC->SCp.this_residual)
1531                data_count = current_SC->SCp.this_residual;
1532          if (data_count > 0) {
1533 #if EVERY_ACCESS
1534             printk( "%d OUT, ", data_count );
1535 #endif
1536             if (data_count == 1) {
1537                outb( *current_SC->SCp.ptr++, Write_FIFO_port );
1538                --current_SC->SCp.this_residual;
1539             } else {
1540                data_count >>= 1;
1541                outsw( Write_FIFO_port, current_SC->SCp.ptr, data_count );
1542                current_SC->SCp.ptr += 2 * data_count;
1543                current_SC->SCp.this_residual -= 2 * data_count;
1544             }
1545          }
1546          if (!current_SC->SCp.this_residual) {
1547             if (current_SC->SCp.buffers_residual) {
1548                --current_SC->SCp.buffers_residual;
1549                ++current_SC->SCp.buffer;
1550                current_SC->SCp.ptr = current_SC->SCp.buffer->address;
1551                current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1552             } else
1553                   break;
1554          }
1555       }
1556    }
1557    
1558    if (current_SC->SCp.have_data_in == 1) { /* DATA IN */
1559       while ((data_count = inw( FIFO_Data_Count_port )) > 0) {
1560 #if EVERY_ACCESS
1561          printk( "DC=%d, ", data_count );
1562 #endif
1563          if (data_count > current_SC->SCp.this_residual)
1564                data_count = current_SC->SCp.this_residual;
1565          if (data_count) {
1566 #if EVERY_ACCESS
1567             printk( "%d IN, ", data_count );
1568 #endif
1569             if (data_count == 1) {
1570                *current_SC->SCp.ptr++ = inb( Read_FIFO_port );
1571                --current_SC->SCp.this_residual;
1572             } else {
1573                data_count >>= 1; /* Number of words */
1574                insw( Read_FIFO_port, current_SC->SCp.ptr, data_count );
1575                current_SC->SCp.ptr += 2 * data_count;
1576                current_SC->SCp.this_residual -= 2 * data_count;
1577             }
1578          }
1579          if (!current_SC->SCp.this_residual
1580              && current_SC->SCp.buffers_residual) {
1581             --current_SC->SCp.buffers_residual;
1582             ++current_SC->SCp.buffer;
1583             current_SC->SCp.ptr = current_SC->SCp.buffer->address;
1584             current_SC->SCp.this_residual = current_SC->SCp.buffer->length;
1585          }
1586       }
1587    }
1588    
1589    if (done) {
1590 #if EVERY_ACCESS
1591       printk( " ** IN DONE %d ** ", current_SC->SCp.have_data_in );
1592 #endif
1593 
1594 #if ERRORS_ONLY
1595       if (current_SC->cmnd[0] == REQUEST_SENSE && !current_SC->SCp.Status) {
1596          if ((unsigned char)(*((char *)current_SC->request_buffer+2)) & 0x0f) {
1597             unsigned char key;
1598             unsigned char code;
1599             unsigned char qualifier;
1600 
1601             key = (unsigned char)(*((char *)current_SC->request_buffer + 2))
1602                   & 0x0f;
1603             code = (unsigned char)(*((char *)current_SC->request_buffer + 12));
1604             qualifier = (unsigned char)(*((char *)current_SC->request_buffer
1605                                           + 13));
1606 
1607             if (!(key == UNIT_ATTENTION && (code == 0x29 || !code))
1608                 && !(key == NOT_READY
1609                      && code == 0x04
1610                      && (!qualifier || qualifier == 0x02 || qualifier == 0x01))
1611                 && !(key == ILLEGAL_REQUEST && (code == 0x25
1612                                                 || code == 0x24
1613                                                 || !code)))
1614                   
1615                   printk( "fdomain: REQUEST SENSE "
1616                           "Key = %x, Code = %x, Qualifier = %x\n",
1617                           key, code, qualifier );
1618          }
1619       }
1620 #endif
1621 #if EVERY_ACCESS
1622       printk( "BEFORE MY_DONE. . ." );
1623 #endif
1624       my_done( (current_SC->SCp.Status & 0xff)
1625                | ((current_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16) );
1626 #if EVERY_ACCESS
1627       printk( "RETURNING.\n" );
1628 #endif
1629       
1630    } else {
1631       if (current_SC->SCp.phase & disconnect) {
1632          outb( 0xd0 | FIFO_COUNT, Interrupt_Cntl_port );
1633          outb( 0x00, SCSI_Cntl_port );
1634       } else {
1635          outb( 0x90 | FIFO_COUNT, Interrupt_Cntl_port );
1636       }
1637    }
1638 #if DEBUG_RACE
1639    in_interrupt_flag = 0;
1640 #endif
1641    return;
1642 }
1643 
1644 int fdomain_16x0_queue( Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
     /* [previous][next][first][last][top][bottom][index][help] */
1645 {
1646    if (in_command) {
1647       panic( "fdomain: fdomain_16x0_queue() NOT REENTRANT!\n" );
1648    }
1649 #if EVERY_ACCESS
1650    printk( "queue: target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1651            SCpnt->target,
1652            *(unsigned char *)SCpnt->cmnd,
1653            SCpnt->use_sg,
1654            SCpnt->request_bufflen );
1655 #endif
1656 
1657    fdomain_make_bus_idle();
1658 
1659    current_SC            = SCpnt; /* Save this for the done function */
1660    current_SC->scsi_done = done;
1661 
1662    /* Initialize static data */
1663 
1664    if (current_SC->use_sg) {
1665       current_SC->SCp.buffer =
1666             (struct scatterlist *)current_SC->request_buffer;
1667       current_SC->SCp.ptr              = current_SC->SCp.buffer->address;
1668       current_SC->SCp.this_residual    = current_SC->SCp.buffer->length;
1669       current_SC->SCp.buffers_residual = current_SC->use_sg - 1;
1670    } else {
1671       current_SC->SCp.ptr              = (char *)current_SC->request_buffer;
1672       current_SC->SCp.this_residual    = current_SC->request_bufflen;
1673       current_SC->SCp.buffer           = NULL;
1674       current_SC->SCp.buffers_residual = 0;
1675    }
1676          
1677    
1678    current_SC->SCp.Status              = 0;
1679    current_SC->SCp.Message             = 0;
1680    current_SC->SCp.have_data_in        = 0;
1681    current_SC->SCp.sent_command        = 0;
1682    current_SC->SCp.phase               = in_arbitration;
1683 
1684    /* Start arbitration */
1685    outb( 0x00, Interrupt_Cntl_port );
1686    outb( 0x00, SCSI_Cntl_port );              /* Disable data drivers */
1687    outb( adapter_mask, SCSI_Data_NoACK_port ); /* Set our id bit */
1688    ++in_command;
1689    outb( 0x20, Interrupt_Cntl_port );
1690    outb( 0x14 | PARITY_MASK, TMC_Cntl_port ); /* Start arbitration */
1691 
1692    return 0;
1693 }
1694 
1695 /* The following code, which simulates the old-style command function, was
1696    taken from Tommy Thorn's aha1542.c file.  This code is Copyright (C)
1697    1992 Tommy Thorn. */
1698 
1699 static volatile int internal_done_flag    = 0;
1700 static volatile int internal_done_errcode = 0;
1701 
1702 static void internal_done( Scsi_Cmnd *SCpnt )
     /* [previous][next][first][last][top][bottom][index][help] */
1703 {
1704     internal_done_errcode = SCpnt->result;
1705     ++internal_done_flag;
1706 }
1707 
1708 int fdomain_16x0_command( Scsi_Cmnd *SCpnt )
     /* [previous][next][first][last][top][bottom][index][help] */
1709 {
1710     fdomain_16x0_queue( SCpnt, internal_done );
1711 
1712     while (!internal_done_flag)
1713           ;
1714     internal_done_flag = 0;
1715     return internal_done_errcode;
1716 }
1717 
1718 /* End of code derived from Tommy Thorn's work. */
1719 
1720 void print_info( Scsi_Cmnd *SCpnt )
     /* [previous][next][first][last][top][bottom][index][help] */
1721 {
1722    unsigned int imr;
1723    unsigned int irr;
1724    unsigned int isr;
1725 
1726    if (!SCpnt || !SCpnt->host) {
1727       printk( "fdomain: cannot provide detailed information\n" );
1728    }
1729    
1730    printk( "%s\n", fdomain_16x0_info( SCpnt->host ) );
1731    print_banner( SCpnt->host );
1732    switch (SCpnt->SCp.phase) {
1733    case in_arbitration: printk( "arbitration " ); break;
1734    case in_selection:   printk( "selection " );   break;
1735    case in_other:       printk( "other " );       break;
1736    default:             printk( "unknown " );     break;
1737    }
1738 
1739    printk( "(%d), target = %d cmnd = 0x%02x pieces = %d size = %u\n",
1740            SCpnt->SCp.phase,
1741            SCpnt->target,
1742            *(unsigned char *)SCpnt->cmnd,
1743            SCpnt->use_sg,
1744            SCpnt->request_bufflen );
1745    printk( "sent_command = %d, have_data_in = %d, timeout = %d\n",
1746            SCpnt->SCp.sent_command,
1747            SCpnt->SCp.have_data_in,
1748            SCpnt->timeout );
1749 #if DEBUG_RACE
1750    printk( "in_interrupt_flag = %d\n", in_interrupt_flag );
1751 #endif
1752 
1753    imr = (inb( 0x0a1 ) << 8) + inb( 0x21 );
1754    outb( 0x0a, 0xa0 );
1755    irr = inb( 0xa0 ) << 8;
1756    outb( 0x0a, 0x20 );
1757    irr += inb( 0x20 );
1758    outb( 0x0b, 0xa0 );
1759    isr = inb( 0xa0 ) << 8;
1760    outb( 0x0b, 0x20 );
1761    isr += inb( 0x20 );
1762 
1763                                 /* Print out interesting information */
1764    printk( "IMR = 0x%04x", imr );
1765    if (imr & (1 << interrupt_level))
1766          printk( " (masked)" );
1767    printk( ", IRR = 0x%04x, ISR = 0x%04x\n", irr, isr );
1768 
1769    printk( "SCSI Status      = 0x%02x\n", inb( SCSI_Status_port ) );
1770    printk( "TMC Status       = 0x%02x", inb( TMC_Status_port ) );
1771    if (inb( TMC_Status_port & 1))
1772          printk( " (interrupt)" );
1773    printk( "\n" );
1774    printk( "Interrupt Status = 0x%02x", inb( Interrupt_Status_port ) );
1775    if (inb( Interrupt_Status_port ) & 0x08)
1776          printk( " (enabled)" );
1777    printk( "\n" );
1778    if (chip == tmc18c50 || chip == tmc18c30) {
1779       printk( "FIFO Status      = 0x%02x\n", inb( port_base + FIFO_Status ) );
1780       printk( "Int. Condition   = 0x%02x\n",
1781               inb( port_base + Interrupt_Cond ) );
1782    }
1783    printk( "Configuration 1  = 0x%02x\n", inb( port_base + Configuration1 ) );
1784    if (chip == tmc18c50 || chip == tmc18c30)
1785          printk( "Configuration 2  = 0x%02x\n",
1786                  inb( port_base + Configuration2 ) );
1787 }
1788 
1789 int fdomain_16x0_abort( Scsi_Cmnd *SCpnt)
     /* [previous][next][first][last][top][bottom][index][help] */
1790 {
1791    unsigned long flags;
1792 #if EVERY_ACCESS || ERRORS_ONLY || DEBUG_ABORT
1793    printk( "fdomain: abort " );
1794 #endif
1795 
1796    save_flags( flags );
1797    cli();
1798    if (!in_command) {
1799 #if EVERY_ACCESS || ERRORS_ONLY
1800       printk( " (not in command)\n" );
1801 #endif
1802       restore_flags( flags );
1803       return SCSI_ABORT_NOT_RUNNING;
1804    } else printk( "\n" );
1805 
1806 #if DEBUG_ABORT
1807    print_info( SCpnt );
1808 #endif
1809 
1810    fdomain_make_bus_idle();
1811 
1812    current_SC->SCp.phase |= aborted;
1813 
1814    current_SC->result = DID_ABORT << 16;
1815 
1816    restore_flags( flags );
1817    
1818    /* Aborts are not done well. . . */
1819    my_done( DID_ABORT << 16 );
1820 
1821    return SCSI_ABORT_SUCCESS;
1822 }
1823 
1824 int fdomain_16x0_reset( Scsi_Cmnd *SCpnt )
     /* [previous][next][first][last][top][bottom][index][help] */
1825 {
1826 #if DEBUG_RESET
1827    static int called_once = 0;
1828 #endif
1829 
1830 #if ERRORS_ONLY
1831    if (SCpnt) printk( "fdomain: SCSI Bus Reset\n" );
1832 #endif
1833 
1834 #if DEBUG_RESET
1835    if (called_once) print_info( current_SC );
1836    called_once = 1;
1837 #endif
1838    
1839    outb( 1, SCSI_Cntl_port );
1840    do_pause( 2 );
1841    outb( 0, SCSI_Cntl_port );
1842    do_pause( 115 );
1843    outb( 0, SCSI_Mode_Cntl_port );
1844    outb( PARITY_MASK, TMC_Cntl_port );
1845 
1846    /* Unless this is the very first call (i.e., SCPnt == NULL), everything
1847       is probably hosed at this point.  We will, however, try to keep
1848       things going by informing the high-level code that we need help. */
1849 
1850    return SCSI_RESET_WAKEUP;
1851 }
1852 
1853 #include "sd.h"
1854 #include "scsi_ioctl.h"
1855 
1856 int fdomain_16x0_biosparam( Scsi_Disk *disk, kdev_t dev, int *info_array )
     /* [previous][next][first][last][top][bottom][index][help] */
1857 {
1858    int              drive;
1859    unsigned char    buf[512 + sizeof( int ) * 2];
1860    int              size      = disk->capacity;
1861    int              *sizes    = (int *)buf;
1862    unsigned char    *data     = (unsigned char *)(sizes + 2);
1863    unsigned char    do_read[] = { READ_6, 0, 0, 0, 1, 0 };
1864    int              retcode;
1865    struct drive_info {
1866       unsigned short cylinders;
1867       unsigned char  heads;
1868       unsigned char  sectors;
1869    } *i;
1870    
1871    /* NOTES:
1872       The RAM area starts at 0x1f00 from the bios_base address.
1873 
1874       For BIOS Version 2.0:
1875       
1876       The drive parameter table seems to start at 0x1f30.
1877       The first byte's purpose is not known.
1878       Next is the cylinder, head, and sector information.
1879       The last 4 bytes appear to be the drive's size in sectors.
1880       The other bytes in the drive parameter table are unknown.
1881       If anyone figures them out, please send me mail, and I will
1882       update these notes.
1883 
1884       Tape drives do not get placed in this table.
1885 
1886       There is another table at 0x1fea:
1887       If the byte is 0x01, then the SCSI ID is not in use.
1888       If the byte is 0x18 or 0x48, then the SCSI ID is in use,
1889       although tapes don't seem to be in this table.  I haven't
1890       seen any other numbers (in a limited sample).
1891 
1892       0x1f2d is a drive count (i.e., not including tapes)
1893 
1894       The table at 0x1fcc are I/O ports addresses for the various
1895       operations.  I calculate these by hand in this driver code.
1896 
1897       
1898       
1899       For the ISA-200S version of BIOS Version 2.0:
1900 
1901       The drive parameter table starts at 0x1f33.
1902 
1903       WARNING: Assume that the table entry is 25 bytes long.  Someone needs
1904       to check this for the Quantum ISA-200S card.
1905 
1906       
1907       
1908       For BIOS Version 3.2:
1909 
1910       The drive parameter table starts at 0x1f70.  Each entry is
1911       0x0a bytes long.  Heads are one less than we need to report.
1912     */
1913 
1914    drive = MINOR(dev) / 16;
1915 
1916    if (bios_major == 2) {
1917       switch (Quantum) {
1918       case 2:                   /* ISA_200S */
1919                                 /* The value of 25 has never been verified.
1920                                    It should probably be 15. */
1921          i = (struct drive_info *)( (char *)bios_base + 0x1f33 + drive * 25 );
1922          break;
1923       case 3:                   /* ISA_250MG */
1924          i = (struct drive_info *)( (char *)bios_base + 0x1f36 + drive * 15 );
1925          break;
1926       case 4:                   /* ISA_200S (another one) */
1927          i = (struct drive_info *)( (char *)bios_base + 0x1f34 + drive * 15 );
1928          break;
1929       default:
1930          i = (struct drive_info *)( (char *)bios_base + 0x1f31 + drive * 25 );
1931          break;
1932       }
1933       info_array[0] = i->heads;
1934       info_array[1] = i->sectors;
1935       info_array[2] = i->cylinders;
1936    } else if (bios_major == 3
1937               && bios_minor >= 0
1938               && bios_minor < 4) { /* 3.0 and 3.2 BIOS */
1939       i = (struct drive_info *)( (char *)bios_base + 0x1f71 + drive * 10 );
1940       info_array[0] = i->heads + 1;
1941       info_array[1] = i->sectors;
1942       info_array[2] = i->cylinders;
1943    } else {                     /* 3.4 BIOS (and up?) */
1944       /* This algorithm was provided by Future Domain (much thanks!). */
1945 
1946       sizes[0] = 0;             /* zero bytes out */
1947       sizes[1] = 512;           /* one sector in */
1948       memcpy( data, do_read, sizeof( do_read ) );
1949       retcode = kernel_scsi_ioctl( disk->device,
1950                                    SCSI_IOCTL_SEND_COMMAND,
1951                                    (void *)buf );
1952       if (!retcode                                  /* SCSI command ok */
1953           && data[511] == 0xaa && data[510] == 0x55 /* Partition table valid */
1954           && data[0x1c2]) {                         /* Partition type */
1955 
1956          /* The partition table layout is as follows:
1957 
1958             Start: 0x1b3h
1959             Offset: 0 = partition status
1960                     1 = starting head
1961                     2 = starting sector and cylinder (word, encoded)
1962                     4 = partition type
1963                     5 = ending head
1964                     6 = ending sector and cylinder (word, encoded)
1965                     8 = starting absolute sector (double word)
1966                     c = number of sectors (double word)
1967             Signature: 0x1fe = 0x55aa
1968 
1969             So, this algorithm assumes:
1970             1) the first partition table is in use,
1971             2) the data in the first entry is correct, and
1972             3) partitions never divide cylinders
1973 
1974             Note that (1) may be FALSE for NetBSD (and other BSD flavors),
1975             as well as for Linux.  Note also, that Linux doesn't pay any
1976             attention to the fields that are used by this algorithm -- it
1977             only uses the absolute sector data.  Recent versions of Linux's
1978             fdisk(1) will fill this data in correctly, and forthcoming
1979             versions will check for consistency.
1980 
1981             Checking for a non-zero partition type is not part of the
1982             Future Domain algorithm, but it seemed to be a reasonable thing
1983             to do, especially in the Linux and BSD worlds. */
1984 
1985          info_array[0] = data[0x1c3] + 1;           /* heads */
1986          info_array[1] = data[0x1c4] & 0x3f;        /* sectors */
1987       } else {
1988 
1989          /* Note that this new method guarantees that there will always be
1990             less than 1024 cylinders on a platter.  This is good for drives
1991             up to approximately 7.85GB (where 1GB = 1024 * 1024 kB). */
1992 
1993          if ((unsigned int)size >= 0x7e0000U) {
1994             info_array[0] = 0xff; /* heads   = 255 */
1995             info_array[1] = 0x3f; /* sectors =  63 */
1996          } else if ((unsigned int)size >= 0x200000U) {
1997             info_array[0] = 0x80; /* heads   = 128 */
1998             info_array[1] = 0x3f; /* sectors =  63 */
1999          } else {
2000             info_array[0] = 0x40; /* heads   =  64 */
2001             info_array[1] = 0x20; /* sectors =  32 */
2002          }
2003       }
2004                                 /* For both methods, compute the cylinders */
2005       info_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
2006    }
2007    
2008    return 0;
2009 }
2010 
2011 #ifdef MODULE
2012 /* Eventually this will go into an include file, but this will be later */
2013 Scsi_Host_Template driver_template = FDOMAIN_16X0;
2014 
2015 #include "scsi_module.c"
2016 #endif

/* [previous][next][first][last][top][bottom][index][help] */