drivers/scsi/wd7000.c

   1 /* $Id: $
   2  *  linux/drivers/scsi/wd7000.c
   3  *
   4  *  Copyright (C) 1992  Thomas Wuensche
   5  *      closely related to the aha1542 driver from Tommy Thorn
   6  *      ( as close as different hardware allows on a lowlevel-driver :-) )
   7  *
   8  *  Revised (and renamed) by John Boyd <boyd@cis.ohio-state.edu> to
   9  *  accommodate Eric Youngdale's modifications to scsi.c.  Nov 1992.
  10  *
  11  *  Additional changes to support scatter/gather.  Dec. 1992.  tw/jb
  12  *
  13  *  No longer tries to reset SCSI bus at boot (it wasn't working anyway).
  14  *  Rewritten to support multiple host adapters.
  15  *  Miscellaneous cleanup.
  16  *  So far, still doesn't do reset or abort correctly, since I have no idea
  17  *  how to do them with this board (8^(.                      Jan 1994 jb
  18  *
  19  * This driver now supports both of the two standard configurations (per
  20  * the 3.36 Owner's Manual, my latest reference) by the same method as
  21  * before; namely, by looking for a BIOS signature.  Thus, the location of
  22  * the BIOS signature determines the board configuration.  Until I have
  23  * time to do something more flexible, users should stick to one of the
  24  * following:
  25  *
  26  * Standard configuration for single-adapter systems:
  27  *    - BIOS at CE00h
  28  *    - I/O base address 350h
  29  *    - IRQ level 15
  30  *    - DMA channel 6
  31  * Standard configuration for a second adapter in a system:
  32  *    - BIOS at C800h
  33  *    - I/O base address 330h
  34  *    - IRQ level 11
  35  *    - DMA channel 5
  36  *
  37  * Anyone who can recompile the kernel is welcome to add others as need
  38  * arises, but unpredictable results may occur if there are conflicts.
  39  * In any event, if there are multiple adapters in a system, they MUST
  40  * use different I/O bases, IRQ levels, and DMA channels, since they will be
  41  * indistinguishable (and in direct conflict) otherwise.
  42  *
  43  *   As a point of information, the NO_OP command toggles the CMD_RDY bit
  44  * of the status port, and this fact could be used as a test for the I/O
  45  * base address (or more generally, board detection).  There is an interrupt
  46  * status port, so IRQ probing could also be done.  I suppose the full
  47  * DMA diagnostic could be used to detect the DMA channel being used.  I
  48  * haven't done any of this, though, because I think there's too much of
  49  * a chance that such explorations could be destructive, if some other
  50  * board's resources are used inadvertently.  So, call me a wimp, but I
  51  * don't want to try it.  The only kind of exploration I trust is memory
  52  * exploration, since it's more certain that reading memory won't be
  53  * destructive.
  54  *
  55  * More to my liking would be a LILO boot command line specification, such
  56  * as is used by the aha152x driver (and possibly others).  I'll look into
  57  * it, as I have time...
  58  *
  59  *   I get mail occasionally from people who either are using or are
  60  * considering using a WD7000 with Linux.  There is a variety of
  61  * nomenclature describing WD7000's.  To the best of my knowledge, the
  62  * following is a brief summary (from an old WD doc - I don't work for
  63  * them or anything like that):
  64  *
  65  * WD7000-FASST2: This is a WD7000 board with the real-mode SST ROM BIOS
  66  *        installed.  Last I heard, the BIOS was actually done by Columbia
  67  *        Data Products.  The BIOS is only used by this driver (and thus
  68  *        by Linux) to identify the board; none of it can be executed under
  69  *        Linux.
  70  *
  71  * WD7000-ASC: This is the original adapter board, with or without BIOS.
  72  *        The board uses a WD33C93 or WD33C93A SBIC, which in turn is
  73  *        controlled by an onboard Z80 processor.  The board interface
  74  *        visible to the host CPU is defined effectively by the Z80's
  75  *        firmware, and it is this firmware's revision level that is
  76  *        determined and reported by this driver.  (The version of the
  77  *        on-board BIOS is of no interest whatsoever.)  The host CPU has
  78  *        no access to the SBIC; hence the fact that it is a WD33C93 is
  79  *        also of no interest to this driver.
  80  *
  81  * WD7000-AX:
  82  * WD7000-MX:
  83  * WD7000-EX: These are newer versions of the WD7000-ASC.  The -ASC is
  84  *        largely built from discrete components; these boards use more
  85  *        integration.  The -AX is an ISA bus board (like the -ASC),
  86  *        the -MX is an MCA (i.e., PS/2) bus board), and the -EX is an
  87  *        EISA bus board.
  88  *
  89  *  At the time of my documentation, the -?X boards were "future" products,
  90  *  and were not yet available.  However, I vaguely recall that Thomas
  91  *  Wuensche had an -AX, so I believe at least it is supported by this
  92  *  driver.  I have no personal knowledge of either -MX or -EX boards.
  93  *
  94  *  P.S. Just recently, I've discovered (directly from WD and Future
  95  *  Domain) that all but the WD7000-EX have been out of production for
  96  *  two years now.  FD has production rights to the 7000-EX, and are
  97  *  producing it under a new name, and with a new BIOS.  If anyone has
  98  *  one of the FD boards, it would be nice to come up with a signature
  99  *  for it.
 100  *                                                           J.B. Jan 1994.
 101  *
 102  *
 103  *  Revisions by Miroslav Zagorac <zaga@fly.cc.fer.hr>
 104  *
 105  *  08/24/1996.
 106  *
 107  *  Enhancement for wd7000_detect function has been made, so you don't have
 108  *  to enter BIOS ROM address in initialisation data (see struct Config).
 109  *  We cannot detect IRQ, DMA and I/O base address for now, so we have to
 110  *  enter them as arguments while wd_7000 is detected. If someone has IRQ,
 111  *  DMA or I/O base address set to some other value, he can enter them in
 112  *  configuration without any problem. Also I wrote a function wd7000_setup,
 113  *  so now you can enter WD-7000 definition as kernel arguments,
 114  *  as in lilo.conf:
 115  *
 116  *     append="wd7000=IRQ,DMA,IO"
 117  *
 118  *  PS: If card BIOS ROM is disabled, function wd7000_detect now will recognize
 119  *      adapter, unlike the old one. Anyway, BIOS ROM from WD7000 adapter is
 120  *      useless for Linux. B^)
 121  *
 122  *
 123  *  09/06/1996.
 124  *
 125  *  Autodetecting of I/O base address from wd7000_detect function is removed,
 126  *  some little bugs removed, etc...
 127  *
 128  *  Thanks to Roger Scott for driver debugging.
 129  *
 130  *  06/07/1997
 131  *
 132  *  Added support for /proc file system (/proc/scsi/wd7000/[0...] files).
 133  *  Now, driver can handle hard disks with capacity >1GB.
 134  *
 135  *  01/15/1998
 136  *
 137  *  Added support for BUS_ON and BUS_OFF parameters in config line.
 138  *  Miscellaneous cleanup.
 139  *
 140  *  03/01/1998
 141  *
 142  *  WD7000 driver now work on kernels >= 2.1.x
 143  *
 144  *
 145  * 12/31/2001 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 146  *
 147  * use host->host_lock, not io_request_lock, cleanups
 148  *
 149  * 2002/10/04 - Alan Cox <alan@lxorguk.ukuu.org.uk>
 150  *
 151  * Use dev_id for interrupts, kill __func__ pasting
 152  * Add a lock for the scb pool, clean up all other cli/sti usage stuff
 153  * Use the adapter lock for the other places we had the cli's
 154  *
 155  * 2002/10/06 - Alan Cox <alan@lxorguk.ukuu.org.uk>
 156  *
 157  * Switch to new style error handling
 158  * Clean up delay to udelay, and yielding sleeps
 159  * Make host reset actually reset the card
 160  * Make everything static
 161  *
 162  * 2003/02/12 - Christoph Hellwig <hch@infradead.org>
 163  *
 164  * Cleaned up host template definition
 165  * Removed now obsolete wd7000.h
 166  */
 167
 168 #include <linux/delay.h>
 169 #include <linux/module.h>
 170 #include <linux/interrupt.h>
 171 #include <linux/kernel.h>
 172 #include <linux/types.h>
 173 #include <linux/string.h>
 174 #include <linux/spinlock.h>
 175 #include <linux/ioport.h>
 176 #include <linux/proc_fs.h>
 177 #include <linux/blkdev.h>
 178 #include <linux/init.h>
 179 #include <linux/stat.h>
 180 #include <linux/io.h>
 181
 182 #include <asm/system.h>
 183 #include <asm/dma.h>
 184
 185 #include <scsi/scsi.h>
 186 #include <scsi/scsi_cmnd.h>
 187 #include <scsi/scsi_device.h>
 188 #include <scsi/scsi_host.h>
 189 #include <scsi/scsicam.h>
 190
 191
 192 #undef  WD7000_DEBUG            /* general debug                */
 193 #ifdef WD7000_DEBUG
 194 #define dprintk printk
 195 #else
 196 #define dprintk(format,args...)
 197 #endif
 198
 199 /*
 200  *  Mailbox structure sizes.
 201  *  I prefer to keep the number of ICMBs much larger than the number of
 202  *  OGMBs.  OGMBs are used very quickly by the driver to start one or
 203  *  more commands, while ICMBs are used by the host adapter per command.
 204  */
 205 #define OGMB_CNT        16
 206 #define ICMB_CNT        32
 207
 208 /*
 209  *  Scb's are shared by all active adapters.  So, if they all become busy,
 210  *  callers may be made to wait in alloc_scbs for them to free.  That can
 211  *  be avoided by setting MAX_SCBS to NUM_CONFIG * WD7000_Q.  If you'd
 212  *  rather conserve memory, use a smaller number (> 0, of course) - things
 213  *  will should still work OK.
 214  */
 215 #define MAX_SCBS        32
 216
 217 /*
 218  *  In this version, sg_tablesize now defaults to WD7000_SG, and will
 219  *  be set to SG_NONE for older boards.  This is the reverse of the
 220  *  previous default, and was changed so that the driver-level
 221  *  scsi_host_template would reflect the driver's support for scatter/
 222  *  gather.
 223  *
 224  *  Also, it has been reported that boards at Revision 6 support scatter/
 225  *  gather, so the new definition of an "older" board has been changed
 226  *  accordingly.
 227  */
 228 #define WD7000_Q        16
 229 #define WD7000_SG       16
 230
 231
 232 /*
 233  *  WD7000-specific mailbox structure
 234  *
 235  */
 236 typedef volatile struct mailbox {
 237         unchar status;
 238         unchar scbptr[3];       /* SCSI-style - MSB first (big endian) */
 239 } Mailbox;
 240
 241 /*
 242  *  This structure should contain all per-adapter global data.  I.e., any
 243  *  new global per-adapter data should put in here.
 244  */
 245 typedef struct adapter {
 246         struct Scsi_Host *sh;   /* Pointer to Scsi_Host structure    */
 247         int iobase;             /* This adapter's I/O base address   */
 248         int irq;                /* This adapter's IRQ level          */
 249         int dma;                /* This adapter's DMA channel        */
 250         int int_counter;        /* This adapter's interrupt counter  */
 251         int bus_on;             /* This adapter's BUS_ON time        */
 252         int bus_off;            /* This adapter's BUS_OFF time       */
 253         struct {                /* This adapter's mailboxes          */
 254                 Mailbox ogmb[OGMB_CNT]; /* Outgoing mailboxes                */
 255                 Mailbox icmb[ICMB_CNT]; /* Incoming mailboxes                */
 256         } mb;
 257         int next_ogmb;          /* to reduce contention at mailboxes */
 258         unchar control;         /* shadows CONTROL port value        */
 259         unchar rev1, rev2;      /* filled in by wd7000_revision      */
 260 } Adapter;
 261
 262 /*
 263  * (linear) base address for ROM BIOS
 264  */
 265 static const long wd7000_biosaddr[] = {
 266         0xc0000, 0xc2000, 0xc4000, 0xc6000, 0xc8000, 0xca000, 0xcc000, 0xce000,
 267         0xd0000, 0xd2000, 0xd4000, 0xd6000, 0xd8000, 0xda000, 0xdc000, 0xde000
 268 };
 269 #define NUM_ADDRS ARRAY_SIZE(wd7000_biosaddr)
 270
 271 static const unsigned short wd7000_iobase[] = {
 272         0x0300, 0x0308, 0x0310, 0x0318, 0x0320, 0x0328, 0x0330, 0x0338,
 273         0x0340, 0x0348, 0x0350, 0x0358, 0x0360, 0x0368, 0x0370, 0x0378,
 274         0x0380, 0x0388, 0x0390, 0x0398, 0x03a0, 0x03a8, 0x03b0, 0x03b8,
 275         0x03c0, 0x03c8, 0x03d0, 0x03d8, 0x03e0, 0x03e8, 0x03f0, 0x03f8
 276 };
 277 #define NUM_IOPORTS ARRAY_SIZE(wd7000_iobase)
 278
 279 static const short wd7000_irq[] = { 3, 4, 5, 7, 9, 10, 11, 12, 14, 15 };
 280 #define NUM_IRQS ARRAY_SIZE(wd7000_irq)
 281
 282 static const short wd7000_dma[] = { 5, 6, 7 };
 283 #define NUM_DMAS ARRAY_SIZE(wd7000_dma)
 284
 285 /*
 286  * The following is set up by wd7000_detect, and used thereafter for
 287  * proc and other global ookups
 288  */
 289
 290 #define UNITS   8
 291 static struct Scsi_Host *wd7000_host[UNITS];
 292
 293 #define BUS_ON    64            /* x 125ns = 8000ns (BIOS default) */
 294 #define BUS_OFF   15            /* x 125ns = 1875ns (BIOS default) */
 295
 296 /*
 297  *  Standard Adapter Configurations - used by wd7000_detect
 298  */
 299 typedef struct {
 300         short irq;              /* IRQ level                                  */
 301         short dma;              /* DMA channel                                */
 302         unsigned iobase;        /* I/O base address                           */
 303         short bus_on;           /* Time that WD7000 spends on the AT-bus when */
 304         /* transferring data. BIOS default is 8000ns. */
 305         short bus_off;          /* Time that WD7000 spends OFF THE BUS after  */
 306         /* while it is transferring data.             */
 307         /* BIOS default is 1875ns                     */
 308 } Config;
 309
 310 /*
 311  * Add here your configuration...
 312  */
 313 static Config configs[] = {
 314         {15, 6, 0x350, BUS_ON, BUS_OFF},        /* defaults for single adapter */
 315         {11, 5, 0x320, BUS_ON, BUS_OFF},        /* defaults for second adapter */
 316         {7, 6, 0x350, BUS_ON, BUS_OFF}, /* My configuration (Zaga)     */
 317         {-1, -1, 0x0, BUS_ON, BUS_OFF}  /* Empty slot                  */
 318 };
 319 #define NUM_CONFIGS ARRAY_SIZE(configs)
 320
 321 /*
 322  *  The following list defines strings to look for in the BIOS that identify
 323  *  it as the WD7000-FASST2 SST BIOS.  I suspect that something should be
 324  *  added for the Future Domain version.
 325  */
 326 typedef struct signature {
 327         const char *sig;        /* String to look for            */
 328         unsigned long ofs;      /* offset from BIOS base address */
 329         unsigned len;           /* length of string              */
 330 } Signature;
 331
 332 static const Signature signatures[] = {
 333         {"SSTBIOS", 0x0000d, 7} /* "SSTBIOS" @ offset 0x0000d */
 334 };
 335 #define NUM_SIGNATURES ARRAY_SIZE(signatures)
 336
 337
 338 /*
 339  *  I/O Port Offsets and Bit Definitions
 340  *  4 addresses are used.  Those not defined here are reserved.
 341  */
 342 #define ASC_STAT        0       /* Status,  Read          */
 343 #define ASC_COMMAND     0       /* Command, Write         */
 344 #define ASC_INTR_STAT   1       /* Interrupt Status, Read */
 345 #define ASC_INTR_ACK    1       /* Acknowledge, Write     */
 346 #define ASC_CONTROL     2       /* Control, Write         */
 347
 348 /*
 349  * ASC Status Port
 350  */
 351 #define INT_IM          0x80    /* Interrupt Image Flag           */
 352 #define CMD_RDY         0x40    /* Command Port Ready             */
 353 #define CMD_REJ         0x20    /* Command Port Byte Rejected     */
 354 #define ASC_INIT        0x10    /* ASC Initialized Flag           */
 355 #define ASC_STATMASK    0xf0    /* The lower 4 Bytes are reserved */
 356
 357 /*
 358  * COMMAND opcodes
 359  *
 360  *  Unfortunately, I have no idea how to properly use some of these commands,
 361  *  as the OEM manual does not make it clear.  I have not been able to use
 362  *  enable/disable unsolicited interrupts or the reset commands with any
 363  *  discernible effect whatsoever.  I think they may be related to certain
 364  *  ICB commands, but again, the OEM manual doesn't make that clear.
 365  */
 366 #define NO_OP             0     /* NO-OP toggles CMD_RDY bit in ASC_STAT  */
 367 #define INITIALIZATION    1     /* initialization (10 bytes)              */
 368 #define DISABLE_UNS_INTR  2     /* disable unsolicited interrupts         */
 369 #define ENABLE_UNS_INTR   3     /* enable unsolicited interrupts          */
 370 #define INTR_ON_FREE_OGMB 4     /* interrupt on free OGMB                 */
 371 #define SOFT_RESET        5     /* SCSI bus soft reset                    */
 372 #define HARD_RESET_ACK    6     /* SCSI bus hard reset acknowledge        */
 373 #define START_OGMB        0x80  /* start command in OGMB (n)              */
 374 #define SCAN_OGMBS        0xc0  /* start multiple commands, signature (n) */
 375                                 /*    where (n) = lower 6 bits            */
 376 /*
 377  * For INITIALIZATION:
 378  */
 379 typedef struct initCmd {
 380         unchar op;              /* command opcode (= 1)                    */
 381         unchar ID;              /* Adapter's SCSI ID                       */
 382         unchar bus_on;          /* Bus on time, x 125ns (see below)        */
 383         unchar bus_off;         /* Bus off time, ""         ""             */
 384         unchar rsvd;            /* Reserved                                */
 385         unchar mailboxes[3];    /* Address of Mailboxes, MSB first         */
 386         unchar ogmbs;           /* Number of outgoing MBs, max 64, 0,1 = 1 */
 387         unchar icmbs;           /* Number of incoming MBs,   ""       ""   */
 388 } InitCmd;
 389
 390 /*
 391  * Interrupt Status Port - also returns diagnostic codes at ASC reset
 392  *
 393  * if msb is zero, the lower bits are diagnostic status
 394  * Diagnostics:
 395  * 01   No diagnostic error occurred
 396  * 02   RAM failure
 397  * 03   FIFO R/W failed
 398  * 04   SBIC register read/write failed
 399  * 05   Initialization D-FF failed
 400  * 06   Host IRQ D-FF failed
 401  * 07   ROM checksum error
 402  * Interrupt status (bitwise):
 403  * 10NNNNNN   outgoing mailbox NNNNNN is free
 404  * 11NNNNNN   incoming mailbox NNNNNN needs service
 405  */
 406 #define MB_INTR    0xC0         /* Mailbox Service possible/required */
 407 #define IMB_INTR   0x40         /* 1 Incoming / 0 Outgoing           */
 408 #define MB_MASK    0x3f         /* mask for mailbox number           */
 409
 410 /*
 411  * CONTROL port bits
 412  */
 413 #define INT_EN     0x08         /* Interrupt Enable */
 414 #define DMA_EN     0x04         /* DMA Enable       */
 415 #define SCSI_RES   0x02         /* SCSI Reset       */
 416 #define ASC_RES    0x01         /* ASC Reset        */
 417
 418 /*
 419  * Driver data structures:
 420  *   - mb and scbs are required for interfacing with the host adapter.
 421  *     An SCB has extra fields not visible to the adapter; mb's
 422  *     _cannot_ do this, since the adapter assumes they are contiguous in
 423  *     memory, 4 bytes each, with ICMBs following OGMBs, and uses this fact
 424  *     to access them.
 425  *   - An icb is for host-only (non-SCSI) commands.  ICBs are 16 bytes each;
 426  *     the additional bytes are used only by the driver.
 427  *   - For now, a pool of SCBs are kept in global storage by this driver,
 428  *     and are allocated and freed as needed.
 429  *
 430  *  The 7000-FASST2 marks OGMBs empty as soon as it has _started_ a command,
 431  *  not when it has finished.  Since the SCB must be around for completion,
 432  *  problems arise when SCBs correspond to OGMBs, which may be reallocated
 433  *  earlier (or delayed unnecessarily until a command completes).
 434  *  Mailboxes are used as transient data structures, simply for
 435  *  carrying SCB addresses to/from the 7000-FASST2.
 436  *
 437  *  Note also since SCBs are not "permanently" associated with mailboxes,
 438  *  there is no need to keep a global list of scsi_cmnd pointers indexed
 439  *  by OGMB.   Again, SCBs reference their scsi_cmnds directly, so mailbox
 440  *  indices need not be involved.
 441  */
 442
 443 /*
 444  *  WD7000-specific scatter/gather element structure
 445  */
 446 typedef struct sgb {
 447         unchar len[3];
 448         unchar ptr[3];          /* Also SCSI-style - MSB first */
 449 } Sgb;
 450
 451 typedef struct scb {            /* Command Control Block 5.4.1               */
 452         unchar op;              /* Command Control Block Operation Code      */
 453         unchar idlun;           /* op=0,2:Target Id, op=1:Initiator Id       */
 454         /* Outbound data transfer, length is checked */
 455         /* Inbound data transfer, length is checked  */
 456         /* Logical Unit Number                       */
 457         unchar cdb[12];         /* SCSI Command Block                        */
 458         volatile unchar status; /* SCSI Return Status                        */
 459         volatile unchar vue;    /* Vendor Unique Error Code                  */
 460         unchar maxlen[3];       /* Maximum Data Transfer Length              */
 461         unchar dataptr[3];      /* SCSI Data Block Pointer                   */
 462         unchar linkptr[3];      /* Next Command Link Pointer                 */
 463         unchar direc;           /* Transfer Direction                        */
 464         unchar reserved2[6];    /* SCSI Command Descriptor Block             */
 465         /* end of hardware SCB                       */
 466         struct scsi_cmnd *SCpnt;/* scsi_cmnd using this SCB                  */
 467         Sgb sgb[WD7000_SG];     /* Scatter/gather list for this SCB          */
 468         Adapter *host;          /* host adapter                              */
 469         struct scb *next;       /* for lists of scbs                         */
 470 } Scb;
 471
 472 /*
 473  *  This driver is written to allow host-only commands to be executed.
 474  *  These use a 16-byte block called an ICB.  The format is extended by the
 475  *  driver to 18 bytes, to support the status returned in the ICMB and
 476  *  an execution phase code.
 477  *
 478  *  There are other formats besides these; these are the ones I've tried
 479  *  to use.  Formats for some of the defined ICB opcodes are not defined
 480  *  (notably, get/set unsolicited interrupt status) in my copy of the OEM
 481  *  manual, and others are ambiguous/hard to follow.
 482  */
 483 #define ICB_OP_MASK           0x80      /* distinguishes scbs from icbs        */
 484 #define ICB_OP_OPEN_RBUF      0x80      /* open receive buffer                 */
 485 #define ICB_OP_RECV_CMD       0x81      /* receive command from initiator      */
 486 #define ICB_OP_RECV_DATA      0x82      /* receive data from initiator         */
 487 #define ICB_OP_RECV_SDATA     0x83      /* receive data with status from init. */
 488 #define ICB_OP_SEND_DATA      0x84      /* send data with status to initiator  */
 489 #define ICB_OP_SEND_STAT      0x86      /* send command status to initiator    */
 490                                         /* 0x87 is reserved                    */
 491 #define ICB_OP_READ_INIT      0x88      /* read initialization bytes           */
 492 #define ICB_OP_READ_ID        0x89      /* read adapter's SCSI ID              */
 493 #define ICB_OP_SET_UMASK      0x8A      /* set unsolicited interrupt mask      */
 494 #define ICB_OP_GET_UMASK      0x8B      /* read unsolicited interrupt mask     */
 495 #define ICB_OP_GET_REVISION   0x8C      /* read firmware revision level        */
 496 #define ICB_OP_DIAGNOSTICS    0x8D      /* execute diagnostics                 */
 497 #define ICB_OP_SET_EPARMS     0x8E      /* set execution parameters            */
 498 #define ICB_OP_GET_EPARMS     0x8F      /* read execution parameters           */
 499
 500 typedef struct icbRecvCmd {
 501         unchar op;
 502         unchar IDlun;           /* Initiator SCSI ID/lun     */
 503         unchar len[3];          /* command buffer length     */
 504         unchar ptr[3];          /* command buffer address    */
 505         unchar rsvd[7];         /* reserved                  */
 506         volatile unchar vue;    /* vendor-unique error code  */
 507         volatile unchar status; /* returned (icmb) status    */
 508         volatile unchar phase;  /* used by interrupt handler */
 509 } IcbRecvCmd;
 510
 511 typedef struct icbSendStat {
 512         unchar op;
 513         unchar IDlun;           /* Target SCSI ID/lun                  */
 514         unchar stat;            /* (outgoing) completion status byte 1 */
 515         unchar rsvd[12];        /* reserved                            */
 516         volatile unchar vue;    /* vendor-unique error code            */
 517         volatile unchar status; /* returned (icmb) status              */
 518         volatile unchar phase;  /* used by interrupt handler           */
 519 } IcbSendStat;
 520
 521 typedef struct icbRevLvl {
 522         unchar op;
 523         volatile unchar primary;        /* primary revision level (returned)   */
 524         volatile unchar secondary;      /* secondary revision level (returned) */
 525         unchar rsvd[12];        /* reserved                            */
 526         volatile unchar vue;    /* vendor-unique error code            */
 527         volatile unchar status; /* returned (icmb) status              */
 528         volatile unchar phase;  /* used by interrupt handler           */
 529 } IcbRevLvl;
 530
 531 typedef struct icbUnsMask {     /* I'm totally guessing here */
 532         unchar op;
 533         volatile unchar mask[14];       /* mask bits                 */
 534 #if 0
 535         unchar rsvd[12];        /* reserved                  */
 536 #endif
 537         volatile unchar vue;    /* vendor-unique error code  */
 538         volatile unchar status; /* returned (icmb) status    */
 539         volatile unchar phase;  /* used by interrupt handler */
 540 } IcbUnsMask;
 541
 542 typedef struct icbDiag {
 543         unchar op;
 544         unchar type;            /* diagnostics type code (0-3) */
 545         unchar len[3];          /* buffer length               */
 546         unchar ptr[3];          /* buffer address              */
 547         unchar rsvd[7];         /* reserved                    */
 548         volatile unchar vue;    /* vendor-unique error code    */
 549         volatile unchar status; /* returned (icmb) status      */
 550         volatile unchar phase;  /* used by interrupt handler   */
 551 } IcbDiag;
 552
 553 #define ICB_DIAG_POWERUP   0    /* Power-up diags only       */
 554 #define ICB_DIAG_WALKING   1    /* walking 1's pattern       */
 555 #define ICB_DIAG_DMA       2    /* DMA - system memory diags */
 556 #define ICB_DIAG_FULL      3    /* do both 1 & 2             */
 557
 558 typedef struct icbParms {
 559         unchar op;
 560         unchar rsvd1;           /* reserved                  */
 561         unchar len[3];          /* parms buffer length       */
 562         unchar ptr[3];          /* parms buffer address      */
 563         unchar idx[2];          /* index (MSB-LSB)           */
 564         unchar rsvd2[5];        /* reserved                  */
 565         volatile unchar vue;    /* vendor-unique error code  */
 566         volatile unchar status; /* returned (icmb) status    */
 567         volatile unchar phase;  /* used by interrupt handler */
 568 } IcbParms;
 569
 570 typedef struct icbAny {
 571         unchar op;
 572         unchar data[14];        /* format-specific data      */
 573         volatile unchar vue;    /* vendor-unique error code  */
 574         volatile unchar status; /* returned (icmb) status    */
 575         volatile unchar phase;  /* used by interrupt handler */
 576 } IcbAny;
 577
 578 typedef union icb {
 579         unchar op;              /* ICB opcode                     */
 580         IcbRecvCmd recv_cmd;    /* format for receive command     */
 581         IcbSendStat send_stat;  /* format for send status         */
 582         IcbRevLvl rev_lvl;      /* format for get revision level  */
 583         IcbDiag diag;           /* format for execute diagnostics */
 584         IcbParms eparms;        /* format for get/set exec parms  */
 585         IcbAny icb;             /* generic format                 */
 586         unchar data[18];
 587 } Icb;
 588
 589 #ifdef MODULE
 590 static char *wd7000;
 591 module_param(wd7000, charp, 0);
 592 #endif
 593
 594 /*
 595  *  Driver SCB structure pool.
 596  *
 597  *  The SCBs declared here are shared by all host adapters; hence, this
 598  *  structure is not part of the Adapter structure.
 599  */
 600 static Scb scbs[MAX_SCBS];
 601 static Scb *scbfree;            /* free list         */
 602 static int freescbs = MAX_SCBS; /* free list counter */
 603 static spinlock_t scbpool_lock; /* guards the scb free list and count */
 604
 605 /*
 606  *  END of data/declarations - code follows.
 607  */
 608 static void __init setup_error(char *mesg, int *ints)
 609 {
 610         if (ints[0] == 3)
 611                 printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x\" -> %s\n", ints[1], ints[2], ints[3], mesg);
 612         else if (ints[0] == 4)
 613                 printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], mesg);
 614         else
 615                 printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], ints[5], mesg);
 616 }
 617
 618
 619 /*
 620  * Note: You can now set these options from the kernel's "command line".
 621  * The syntax is:
 622  *
 623  *     wd7000=<IRQ>,<DMA>,<IO>[,<BUS_ON>[,<BUS_OFF>]]
 624  *
 625  * , where BUS_ON and BUS_OFF are in nanoseconds. BIOS default values
 626  * are 8000ns for BUS_ON and 1875ns for BUS_OFF.
 627  * eg:
 628  *     wd7000=7,6,0x350
 629  *
 630  * will configure the driver for a WD-7000 controller
 631  * using IRQ 15 with a DMA channel 6, at IO base address 0x350.
 632  */
 633 static int __init wd7000_setup(char *str)
 634 {
 635         static short wd7000_card_num;   /* .bss will zero this */
 636         short i;
 637         int ints[6];
 638
 639         (void) get_options(str, ARRAY_SIZE(ints), ints);
 640
 641         if (wd7000_card_num >= NUM_CONFIGS) {
 642                 printk(KERN_ERR "%s: Too many \"wd7000=\" configurations in " "command line!\n", __func__);
 643                 return 0;
 644         }
 645
 646         if ((ints[0] < 3) || (ints[0] > 5)) {
 647                 printk(KERN_ERR "%s: Error in command line!  " "Usage: wd7000=<IRQ>,<DMA>,IO>[,<BUS_ON>" "[,<BUS_OFF>]]\n", __func__);
 648         } else {
 649                 for (i = 0; i < NUM_IRQS; i++)
 650                         if (ints[1] == wd7000_irq[i])
 651                                 break;
 652
 653                 if (i == NUM_IRQS) {
 654                         setup_error("invalid IRQ.", ints);
 655                         return 0;
 656                 } else
 657                         configs[wd7000_card_num].irq = ints[1];
 658
 659                 for (i = 0; i < NUM_DMAS; i++)
 660                         if (ints[2] == wd7000_dma[i])
 661                                 break;
 662
 663                 if (i == NUM_DMAS) {
 664                         setup_error("invalid DMA channel.", ints);
 665                         return 0;
 666                 } else
 667                         configs[wd7000_card_num].dma = ints[2];
 668
 669                 for (i = 0; i < NUM_IOPORTS; i++)
 670                         if (ints[3] == wd7000_iobase[i])
 671                                 break;
 672
 673                 if (i == NUM_IOPORTS) {
 674                         setup_error("invalid I/O base address.", ints);
 675                         return 0;
 676                 } else
 677                         configs[wd7000_card_num].iobase = ints[3];
 678
 679                 if (ints[0] > 3) {
 680                         if ((ints[4] < 500) || (ints[4] > 31875)) {
 681                                 setup_error("BUS_ON value is out of range (500" " to 31875 nanoseconds)!", ints);
 682                                 configs[wd7000_card_num].bus_on = BUS_ON;
 683                         } else
 684                                 configs[wd7000_card_num].bus_on = ints[4] / 125;
 685                 } else
 686                         configs[wd7000_card_num].bus_on = BUS_ON;
 687
 688                 if (ints[0] > 4) {
 689                         if ((ints[5] < 500) || (ints[5] > 31875)) {
 690                                 setup_error("BUS_OFF value is out of range (500" " to 31875 nanoseconds)!", ints);
 691                                 configs[wd7000_card_num].bus_off = BUS_OFF;
 692                         } else
 693                                 configs[wd7000_card_num].bus_off = ints[5] / 125;
 694                 } else
 695                         configs[wd7000_card_num].bus_off = BUS_OFF;
 696
 697                 if (wd7000_card_num) {
 698                         for (i = 0; i < (wd7000_card_num - 1); i++) {
 699                                 int j = i + 1;
 700
 701                                 for (; j < wd7000_card_num; j++)
 702                                         if (configs[i].irq == configs[j].irq) {
 703                                                 setup_error("duplicated IRQ!", ints);
 704                                                 return 0;
 705                                         }
 706                                 if (configs[i].dma == configs[j].dma) {
 707                                         setup_error("duplicated DMA " "channel!", ints);
 708                                         return 0;
 709                                 }
 710                                 if (configs[i].iobase == configs[j].iobase) {
 711                                         setup_error("duplicated I/O " "base address!", ints);
 712                                         return 0;
 713                                 }
 714                         }
 715                 }
 716
 717                 dprintk(KERN_DEBUG "wd7000_setup: IRQ=%d, DMA=%d, I/O=0x%x, "
 718                         "BUS_ON=%dns, BUS_OFF=%dns\n", configs[wd7000_card_num].irq, configs[wd7000_card_num].dma, configs[wd7000_card_num].iobase, configs[wd7000_card_num].bus_on * 125, configs[wd7000_card_num].bus_off * 125);
 719
 720                 wd7000_card_num++;
 721         }
 722         return 1;
 723 }
 724
 725 __setup("wd7000=", wd7000_setup);
 726
 727 static inline void any2scsi(unchar * scsi, int any)
 728 {
 729         *scsi++ = (unsigned)any >> 16;
 730         *scsi++ = (unsigned)any >> 8;
 731         *scsi++ = any;
 732 }
 733
 734 static inline int scsi2int(unchar * scsi)
 735 {
 736         return (scsi[0] << 16) | (scsi[1] << 8) | scsi[2];
 737 }
 738
 739 static inline void wd7000_enable_intr(Adapter * host)
 740 {
 741         host->control |= INT_EN;
 742         outb(host->control, host->iobase + ASC_CONTROL);
 743 }
 744
 745
 746 static inline void wd7000_enable_dma(Adapter * host)
 747 {
 748         unsigned long flags;
 749         host->control |= DMA_EN;
 750         outb(host->control, host->iobase + ASC_CONTROL);
 751
 752         flags = claim_dma_lock();
 753         set_dma_mode(host->dma, DMA_MODE_CASCADE);
 754         enable_dma(host->dma);
 755         release_dma_lock(flags);
 756
 757 }
 758
 759
 760 #define WAITnexttimeout 200     /* 2 seconds */
 761
 762 static inline short WAIT(unsigned port, unsigned mask, unsigned allof, unsigned noneof)
 763 {
 764         unsigned WAITbits;
 765         unsigned long WAITtimeout = jiffies + WAITnexttimeout;
 766
 767         while (time_before_eq(jiffies, WAITtimeout)) {
 768                 WAITbits = inb(port) & mask;
 769
 770                 if (((WAITbits & allof) == allof) && ((WAITbits & noneof) == 0))
 771                         return (0);
 772         }
 773
 774         return (1);
 775 }
 776
 777
 778 static inline int command_out(Adapter * host, unchar * cmd, int len)
 779 {
 780         if (!WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
 781                 while (len--) {
 782                         do {
 783                                 outb(*cmd, host->iobase + ASC_COMMAND);
 784                                 WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0);
 785                         } while (inb(host->iobase + ASC_STAT) & CMD_REJ);
 786
 787                         cmd++;
 788                 }
 789
 790                 return (1);
 791         }
 792
 793         printk(KERN_WARNING "wd7000 command_out: WAIT failed(%d)\n", len + 1);
 794
 795         return (0);
 796 }
 797
 798
 799 /*
 800  *  This version of alloc_scbs is in preparation for supporting multiple
 801  *  commands per lun and command chaining, by queueing pending commands.
 802  *  We will need to allocate Scbs in blocks since they will wait to be
 803  *  executed so there is the possibility of deadlock otherwise.
 804  *  Also, to keep larger requests from being starved by smaller requests,
 805  *  we limit access to this routine with an internal busy flag, so that
 806  *  the satisfiability of a request is not dependent on the size of the
 807  *  request.
 808  */
 809 static inline Scb *alloc_scbs(struct Scsi_Host *host, int needed)
 810 {
 811         Scb *scb, *p = NULL;
 812         unsigned long flags;
 813         unsigned long timeout = jiffies + WAITnexttimeout;
 814         unsigned long now;
 815         int i;
 816
 817         if (needed <= 0)
 818                 return (NULL);  /* sanity check */
 819
 820         spin_unlock_irq(host->host_lock);
 821
 822       retry:
 823         while (freescbs < needed) {
 824                 timeout = jiffies + WAITnexttimeout;
 825                 do {
 826                         /* FIXME: can we actually just yield here ?? */
 827                         for (now = jiffies; now == jiffies;)
 828                                 cpu_relax();    /* wait a jiffy */
 829                 } while (freescbs < needed && time_before_eq(jiffies, timeout));
 830                 /*
 831                  *  If we get here with enough free Scbs, we can take them.
 832                  *  Otherwise, we timed out and didn't get enough.
 833                  */
 834                 if (freescbs < needed) {
 835                         printk(KERN_ERR "wd7000: can't get enough free SCBs.\n");
 836                         return (NULL);
 837                 }
 838         }
 839
 840         /* Take the lock, then check we didnt get beaten, if so try again */
 841         spin_lock_irqsave(&scbpool_lock, flags);
 842         if (freescbs < needed) {
 843                 spin_unlock_irqrestore(&scbpool_lock, flags);
 844                 goto retry;
 845         }
 846
 847         scb = scbfree;
 848         freescbs -= needed;
 849         for (i = 0; i < needed; i++) {
 850                 p = scbfree;
 851                 scbfree = p->next;
 852         }
 853         p->next = NULL;
 854
 855         spin_unlock_irqrestore(&scbpool_lock, flags);
 856
 857         spin_lock_irq(host->host_lock);
 858         return (scb);
 859 }
 860
 861
 862 static inline void free_scb(Scb * scb)
 863 {
 864         unsigned long flags;
 865
 866         spin_lock_irqsave(&scbpool_lock, flags);
 867
 868         memset(scb, 0, sizeof(Scb));
 869         scb->next = scbfree;
 870         scbfree = scb;
 871         freescbs++;
 872
 873         spin_unlock_irqrestore(&scbpool_lock, flags);
 874 }
 875
 876
 877 static inline void init_scbs(void)
 878 {
 879         int i;
 880
 881         spin_lock_init(&scbpool_lock);
 882
 883         /* This is only ever called before the SCB pool is active */
 884
 885         scbfree = &(scbs[0]);
 886         memset(scbs, 0, sizeof(scbs));
 887         for (i = 0; i < MAX_SCBS - 1; i++) {
 888                 scbs[i].next = &(scbs[i + 1]);
 889                 scbs[i].SCpnt = NULL;
 890         }
 891         scbs[MAX_SCBS - 1].next = NULL;
 892         scbs[MAX_SCBS - 1].SCpnt = NULL;
 893 }
 894
 895
 896 static int mail_out(Adapter * host, Scb * scbptr)
 897 /*
 898  *  Note: this can also be used for ICBs; just cast to the parm type.
 899  */
 900 {
 901         int i, ogmb;
 902         unsigned long flags;
 903         unchar start_ogmb;
 904         Mailbox *ogmbs = host->mb.ogmb;
 905         int *next_ogmb = &(host->next_ogmb);
 906
 907         dprintk("wd7000_mail_out: 0x%06lx", (long) scbptr);
 908
 909         /* We first look for a free outgoing mailbox */
 910         spin_lock_irqsave(host->sh->host_lock, flags);
 911         ogmb = *next_ogmb;
 912         for (i = 0; i < OGMB_CNT; i++) {
 913                 if (ogmbs[ogmb].status == 0) {
 914                         dprintk(" using OGMB 0x%x", ogmb);
 915                         ogmbs[ogmb].status = 1;
 916                         any2scsi((unchar *) ogmbs[ogmb].scbptr, (int) scbptr);
 917
 918                         *next_ogmb = (ogmb + 1) % OGMB_CNT;
 919                         break;
 920                 } else
 921                         ogmb = (ogmb + 1) % OGMB_CNT;
 922         }
 923         spin_unlock_irqrestore(host->sh->host_lock, flags);
 924
 925         dprintk(", scb is 0x%06lx", (long) scbptr);
 926
 927         if (i >= OGMB_CNT) {
 928                 /*
 929                  *  Alternatively, we might issue the "interrupt on free OGMB",
 930                  *  and sleep, but it must be ensured that it isn't the init
 931                  *  task running.  Instead, this version assumes that the caller
 932                  *  will be persistent, and try again.  Since it's the adapter
 933                  *  that marks OGMB's free, waiting even with interrupts off
 934                  *  should work, since they are freed very quickly in most cases.
 935                  */
 936                 dprintk(", no free OGMBs.\n");
 937                 return (0);
 938         }
 939
 940         wd7000_enable_intr(host);
 941
 942         start_ogmb = START_OGMB | ogmb;
 943         command_out(host, &start_ogmb, 1);
 944
 945         dprintk(", awaiting interrupt.\n");
 946
 947         return (1);
 948 }
 949
 950
 951 static int make_code(unsigned hosterr, unsigned scsierr)
 952 {
 953 #ifdef WD7000_DEBUG
 954         int in_error = hosterr;
 955 #endif
 956
 957         switch ((hosterr >> 8) & 0xff) {
 958         case 0:         /* Reserved */
 959                 hosterr = DID_ERROR;
 960                 break;
 961         case 1:         /* Command Complete, no errors */
 962                 hosterr = DID_OK;
 963                 break;
 964         case 2:         /* Command complete, error logged in scb status (scsierr) */
 965                 hosterr = DID_OK;
 966                 break;
 967         case 4:         /* Command failed to complete - timeout */
 968                 hosterr = DID_TIME_OUT;
 969                 break;
 970         case 5:         /* Command terminated; Bus reset by external device */
 971                 hosterr = DID_RESET;
 972                 break;
 973         case 6:         /* Unexpected Command Received w/ host as target */
 974                 hosterr = DID_BAD_TARGET;
 975                 break;
 976         case 80:                /* Unexpected Reselection */
 977         case 81:                /* Unexpected Selection */
 978                 hosterr = DID_BAD_INTR;
 979                 break;
 980         case 82:                /* Abort Command Message  */
 981                 hosterr = DID_ABORT;
 982                 break;
 983         case 83:                /* SCSI Bus Software Reset */
 984         case 84:                /* SCSI Bus Hardware Reset */
 985                 hosterr = DID_RESET;
 986                 break;
 987         default:                /* Reserved */
 988                 hosterr = DID_ERROR;
 989         }
 990 #ifdef WD7000_DEBUG
 991         if (scsierr || hosterr)
 992                 dprintk("\nSCSI command error: SCSI 0x%02x host 0x%04x return %d\n", scsierr, in_error, hosterr);
 993 #endif
 994         return (scsierr | (hosterr << 16));
 995 }
 996
 997 #define wd7000_intr_ack(host)   outb (0, host->iobase + ASC_INTR_ACK)
 998
 999
1000 static irqreturn_t wd7000_intr(int irq, void *dev_id)
1001 {
1002         Adapter *host = (Adapter *) dev_id;
1003         int flag, icmb, errstatus, icmb_status;
1004         int host_error, scsi_error;
1005         Scb *scb;       /* for SCSI commands */
1006         IcbAny *icb;    /* for host commands */
1007         struct scsi_cmnd *SCpnt;
1008         Mailbox *icmbs = host->mb.icmb;
1009         unsigned long flags;
1010
1011         spin_lock_irqsave(host->sh->host_lock, flags);
1012         host->int_counter++;
1013
1014         dprintk("wd7000_intr: irq = %d, host = 0x%06lx\n", irq, (long) host);
1015
1016         flag = inb(host->iobase + ASC_INTR_STAT);
1017
1018         dprintk("wd7000_intr: intr stat = 0x%02x\n", flag);
1019
1020         if (!(inb(host->iobase + ASC_STAT) & INT_IM)) {
1021                 /* NB: these are _very_ possible if IRQ 15 is being used, since
1022                  * it's the "garbage collector" on the 2nd 8259 PIC.  Specifically,
1023                  * any interrupt signal into the 8259 which can't be identified
1024                  * comes out as 7 from the 8259, which is 15 to the host.  Thus, it
1025                  * is a good thing the WD7000 has an interrupt status port, so we
1026                  * can sort these out.  Otherwise, electrical noise and other such
1027                  * problems would be indistinguishable from valid interrupts...
1028                  */
1029                 dprintk("wd7000_intr: phantom interrupt...\n");
1030                 goto ack;
1031         }
1032
1033         if (!(flag & MB_INTR))
1034                 goto ack;
1035
1036         /* The interrupt is for a mailbox */
1037         if (!(flag & IMB_INTR)) {
1038                 dprintk("wd7000_intr: free outgoing mailbox\n");
1039                 /*
1040                  * If sleep_on() and the "interrupt on free OGMB" command are
1041                  * used in mail_out(), wake_up() should correspondingly be called
1042                  * here.  For now, we don't need to do anything special.
1043                  */
1044                 goto ack;
1045         }
1046
1047         /* The interrupt is for an incoming mailbox */
1048         icmb = flag & MB_MASK;
1049         icmb_status = icmbs[icmb].status;
1050         if (icmb_status & 0x80) {       /* unsolicited - result in ICMB */
1051                 dprintk("wd7000_intr: unsolicited interrupt 0x%02x\n", icmb_status);
1052                 goto ack;
1053         }
1054
1055         /* Aaaargh! (Zaga) */
1056         scb = isa_bus_to_virt(scsi2int((unchar *) icmbs[icmb].scbptr));
1057         icmbs[icmb].status = 0;
1058         if (scb->op & ICB_OP_MASK) {    /* an SCB is done */
1059                 icb = (IcbAny *) scb;
1060                 icb->status = icmb_status;
1061                 icb->phase = 0;
1062                 goto ack;
1063         }
1064
1065         SCpnt = scb->SCpnt;
1066         if (--(SCpnt->SCp.phase) <= 0) {        /* all scbs are done */
1067                 host_error = scb->vue | (icmb_status << 8);
1068                 scsi_error = scb->status;
1069                 errstatus = make_code(host_error, scsi_error);
1070                 SCpnt->result = errstatus;
1071
1072                 free_scb(scb);
1073
1074                 SCpnt->scsi_done(SCpnt);
1075         }
1076
1077  ack:
1078         dprintk("wd7000_intr: return from interrupt handler\n");
1079         wd7000_intr_ack(host);
1080
1081         spin_unlock_irqrestore(host->sh->host_lock, flags);
1082         return IRQ_HANDLED;
1083 }
1084
1085 static int wd7000_queuecommand(struct scsi_cmnd *SCpnt,
1086                 void (*done)(struct scsi_cmnd *))
1087 {
1088         Scb *scb;
1089         Sgb *sgb;
1090         unchar *cdb = (unchar *) SCpnt->cmnd;
1091         unchar idlun;
1092         short cdblen;
1093         int nseg;
1094         Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
1095
1096         cdblen = SCpnt->cmd_len;
1097         idlun = ((SCpnt->device->id << 5) & 0xe0) | (SCpnt->device->lun & 7);
1098         SCpnt->scsi_done = done;
1099         SCpnt->SCp.phase = 1;
1100         scb = alloc_scbs(SCpnt->device->host, 1);
1101         scb->idlun = idlun;
1102         memcpy(scb->cdb, cdb, cdblen);
1103         scb->direc = 0x40;      /* Disable direction check */
1104
1105         scb->SCpnt = SCpnt;     /* so we can find stuff later */
1106         SCpnt->host_scribble = (unchar *) scb;
1107         scb->host = host;
1108
1109         nseg = scsi_sg_count(SCpnt);
1110         if (nseg > 1) {
1111                 struct scatterlist *sg;
1112                 unsigned i;
1113
1114                 dprintk("Using scatter/gather with %d elements.\n", nseg);
1115
1116                 sgb = scb->sgb;
1117                 scb->op = 1;
1118                 any2scsi(scb->dataptr, (int) sgb);
1119                 any2scsi(scb->maxlen, nseg * sizeof(Sgb));
1120
1121                 scsi_for_each_sg(SCpnt, sg, nseg, i) {
1122                         any2scsi(sgb[i].ptr, isa_page_to_bus(sg_page(sg)) + sg->offset);
1123                         any2scsi(sgb[i].len, sg->length);
1124                 }
1125         } else {
1126                 scb->op = 0;
1127                 if (nseg) {
1128                         struct scatterlist *sg = scsi_sglist(SCpnt);
1129                         any2scsi(scb->dataptr, isa_page_to_bus(sg_page(sg)) + sg->offset);
1130                 }
1131                 any2scsi(scb->maxlen, scsi_bufflen(SCpnt));
1132         }
1133
1134         /* FIXME: drop lock and yield here ? */
1135
1136         while (!mail_out(host, scb))
1137                 cpu_relax();    /* keep trying */
1138
1139         return 0;
1140 }
1141
1142 static int wd7000_diagnostics(Adapter * host, int code)
1143 {
1144         static IcbDiag icb = { ICB_OP_DIAGNOSTICS };
1145         static unchar buf[256];
1146         unsigned long timeout;
1147
1148         icb.type = code;
1149         any2scsi(icb.len, sizeof(buf));
1150         any2scsi(icb.ptr, (int) &buf);
1151         icb.phase = 1;
1152         /*
1153          * This routine is only called at init, so there should be OGMBs
1154          * available.  I'm assuming so here.  If this is going to
1155          * fail, I can just let the timeout catch the failure.
1156          */
1157         mail_out(host, (struct scb *) &icb);
1158         timeout = jiffies + WAITnexttimeout;    /* wait up to 2 seconds */
1159         while (icb.phase && time_before(jiffies, timeout)) {
1160                 cpu_relax();    /* wait for completion */
1161                 barrier();
1162         }
1163
1164         if (icb.phase) {
1165                 printk("wd7000_diagnostics: timed out.\n");
1166                 return (0);
1167         }
1168         if (make_code(icb.vue | (icb.status << 8), 0)) {
1169                 printk("wd7000_diagnostics: failed (0x%02x,0x%02x)\n", icb.vue, icb.status);
1170                 return (0);
1171         }
1172
1173         return (1);
1174 }
1175
1176
1177 static int wd7000_adapter_reset(Adapter * host)
1178 {
1179         InitCmd init_cmd = {
1180                 INITIALIZATION,
1181                 7,
1182                 host->bus_on,
1183                 host->bus_off,
1184                 0,
1185                 {0, 0, 0},
1186                 OGMB_CNT,
1187                 ICMB_CNT
1188         };
1189         int diag;
1190         /*
1191          *  Reset the adapter - only.  The SCSI bus was initialized at power-up,
1192          *  and we need to do this just so we control the mailboxes, etc.
1193          */
1194         outb(ASC_RES, host->iobase + ASC_CONTROL);
1195         udelay(40);             /* reset pulse: this is 40us, only need 25us */
1196         outb(0, host->iobase + ASC_CONTROL);
1197         host->control = 0;      /* this must always shadow ASC_CONTROL */
1198
1199         if (WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
1200                 printk(KERN_ERR "wd7000_init: WAIT timed out.\n");
1201                 return -1;      /* -1 = not ok */
1202         }
1203
1204         if ((diag = inb(host->iobase + ASC_INTR_STAT)) != 1) {
1205                 printk("wd7000_init: ");
1206
1207                 switch (diag) {
1208                 case 2:
1209                         printk(KERN_ERR "RAM failure.\n");
1210                         break;
1211                 case 3:
1212                         printk(KERN_ERR "FIFO R/W failed\n");
1213                         break;
1214                 case 4:
1215                         printk(KERN_ERR "SBIC register R/W failed\n");
1216                         break;
1217                 case 5:
1218                         printk(KERN_ERR "Initialization D-FF failed.\n");
1219                         break;
1220                 case 6:
1221                         printk(KERN_ERR "Host IRQ D-FF failed.\n");
1222                         break;
1223                 case 7:
1224                         printk(KERN_ERR "ROM checksum error.\n");
1225                         break;
1226                 default:
1227                         printk(KERN_ERR "diagnostic code 0x%02Xh received.\n", diag);
1228                 }
1229                 return -1;
1230         }
1231         /* Clear mailboxes */
1232         memset(&(host->mb), 0, sizeof(host->mb));
1233
1234         /* Execute init command */
1235         any2scsi((unchar *) & (init_cmd.mailboxes), (int) &(host->mb));
1236         if (!command_out(host, (unchar *) & init_cmd, sizeof(init_cmd))) {
1237                 printk(KERN_ERR "wd7000_adapter_reset: adapter initialization failed.\n");
1238                 return -1;
1239         }
1240
1241         if (WAIT(host->iobase + ASC_STAT, ASC_STATMASK, ASC_INIT, 0)) {
1242                 printk("wd7000_adapter_reset: WAIT timed out.\n");
1243                 return -1;
1244         }
1245         return 0;
1246 }
1247
1248 static int wd7000_init(Adapter * host)
1249 {
1250         if (wd7000_adapter_reset(host) == -1)
1251                 return 0;
1252
1253
1254         if (request_irq(host->irq, wd7000_intr, IRQF_DISABLED, "wd7000", host)) {
1255                 printk("wd7000_init: can't get IRQ %d.\n", host->irq);
1256                 return (0);
1257         }
1258         if (request_dma(host->dma, "wd7000")) {
1259                 printk("wd7000_init: can't get DMA channel %d.\n", host->dma);
1260                 free_irq(host->irq, host);
1261                 return (0);
1262         }
1263         wd7000_enable_dma(host);
1264         wd7000_enable_intr(host);
1265
1266         if (!wd7000_diagnostics(host, ICB_DIAG_FULL)) {
1267                 free_dma(host->dma);
1268                 free_irq(host->irq, NULL);
1269                 return (0);
1270         }
1271
1272         return (1);
1273 }
1274
1275
1276 static void wd7000_revision(Adapter * host)
1277 {
1278         static IcbRevLvl icb = { ICB_OP_GET_REVISION };
1279
1280         icb.phase = 1;
1281         /*
1282          * Like diagnostics, this is only done at init time, in fact, from
1283          * wd7000_detect, so there should be OGMBs available.  If it fails,
1284          * the only damage will be that the revision will show up as 0.0,
1285          * which in turn means that scatter/gather will be disabled.
1286          */
1287         mail_out(host, (struct scb *) &icb);
1288         while (icb.phase) {
1289                 cpu_relax();    /* wait for completion */
1290                 barrier();
1291         }
1292         host->rev1 = icb.primary;
1293         host->rev2 = icb.secondary;
1294 }
1295
1296
1297 #undef SPRINTF
1298 #define SPRINTF(args...) { if (pos < (buffer + length)) pos += sprintf (pos, ## args); }
1299
1300 static int wd7000_set_info(char *buffer, int length, struct Scsi_Host *host)
1301 {
1302         dprintk("Buffer = <%.*s>, length = %d\n", length, buffer, length);
1303
1304         /*
1305          * Currently this is a no-op
1306          */
1307         dprintk("Sorry, this function is currently out of order...\n");
1308         return (length);
1309 }
1310
1311
1312 static int wd7000_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length,  int inout)
1313 {
1314         Adapter *adapter = (Adapter *)host->hostdata;
1315         unsigned long flags;
1316         char *pos = buffer;
1317 #ifdef WD7000_DEBUG
1318         Mailbox *ogmbs, *icmbs;
1319         short count;
1320 #endif
1321
1322         /*
1323          * Has data been written to the file ?
1324          */
1325         if (inout)
1326                 return (wd7000_set_info(buffer, length, host));
1327
1328         spin_lock_irqsave(host->host_lock, flags);
1329         SPRINTF("Host scsi%d: Western Digital WD-7000 (rev %d.%d)\n", host->host_no, adapter->rev1, adapter->rev2);
1330         SPRINTF("  IO base:      0x%x\n", adapter->iobase);
1331         SPRINTF("  IRQ:          %d\n", adapter->irq);
1332         SPRINTF("  DMA channel:  %d\n", adapter->dma);
1333         SPRINTF("  Interrupts:   %d\n", adapter->int_counter);
1334         SPRINTF("  BUS_ON time:  %d nanoseconds\n", adapter->bus_on * 125);
1335         SPRINTF("  BUS_OFF time: %d nanoseconds\n", adapter->bus_off * 125);
1336
1337 #ifdef WD7000_DEBUG
1338         ogmbs = adapter->mb.ogmb;
1339         icmbs = adapter->mb.icmb;
1340
1341         SPRINTF("\nControl port value: 0x%x\n", adapter->control);
1342         SPRINTF("Incoming mailbox:\n");
1343         SPRINTF("  size: %d\n", ICMB_CNT);
1344         SPRINTF("  queued messages: ");
1345
1346         for (i = count = 0; i < ICMB_CNT; i++)
1347                 if (icmbs[i].status) {
1348                         count++;
1349                         SPRINTF("0x%x ", i);
1350                 }
1351
1352         SPRINTF(count ? "\n" : "none\n");
1353
1354         SPRINTF("Outgoing mailbox:\n");
1355         SPRINTF("  size: %d\n", OGMB_CNT);
1356         SPRINTF("  next message: 0x%x\n", adapter->next_ogmb);
1357         SPRINTF("  queued messages: ");
1358
1359         for (i = count = 0; i < OGMB_CNT; i++)
1360                 if (ogmbs[i].status) {
1361                         count++;
1362                         SPRINTF("0x%x ", i);
1363                 }
1364
1365         SPRINTF(count ? "\n" : "none\n");
1366 #endif
1367
1368         spin_unlock_irqrestore(host->host_lock, flags);
1369
1370         /*
1371          * Calculate start of next buffer, and return value.
1372          */
1373         *start = buffer + offset;
1374
1375         if ((pos - buffer) < offset)
1376                 return (0);
1377         else if ((pos - buffer - offset) < length)
1378                 return (pos - buffer - offset);
1379         else
1380                 return (length);
1381 }
1382
1383
1384 /*
1385  *  Returns the number of adapters this driver is supporting.
1386  *
1387  *  The source for hosts.c says to wait to call scsi_register until 100%
1388  *  sure about an adapter.  We need to do it a little sooner here; we
1389  *  need the storage set up by scsi_register before wd7000_init, and
1390  *  changing the location of an Adapter structure is more trouble than
1391  *  calling scsi_unregister.
1392  *
1393  */
1394
1395 static __init int wd7000_detect(struct scsi_host_template *tpnt)
1396 {
1397         short present = 0, biosaddr_ptr, sig_ptr, i, pass;
1398         short biosptr[NUM_CONFIGS];
1399         unsigned iobase;
1400         Adapter *host = NULL;
1401         struct Scsi_Host *sh;
1402         int unit = 0;
1403
1404         dprintk("wd7000_detect: started\n");
1405
1406 #ifdef MODULE
1407         if (wd7000)
1408                 wd7000_setup(wd7000);
1409 #endif
1410
1411         for (i = 0; i < UNITS; wd7000_host[i++] = NULL);
1412         for (i = 0; i < NUM_CONFIGS; biosptr[i++] = -1);
1413
1414         tpnt->proc_name = "wd7000";
1415         tpnt->proc_info = &wd7000_proc_info;
1416
1417         /*
1418          * Set up SCB free list, which is shared by all adapters
1419          */
1420         init_scbs();
1421
1422         for (pass = 0; pass < NUM_CONFIGS; pass++) {
1423                 /*
1424                  * First, search for BIOS SIGNATURE...
1425                  */
1426                 for (biosaddr_ptr = 0; biosaddr_ptr < NUM_ADDRS; biosaddr_ptr++)
1427                         for (sig_ptr = 0; sig_ptr < NUM_SIGNATURES; sig_ptr++) {
1428                                 for (i = 0; i < pass; i++)
1429                                         if (biosptr[i] == biosaddr_ptr)
1430                                                 break;
1431
1432                                 if (i == pass) {
1433                                         void __iomem *biosaddr = ioremap(wd7000_biosaddr[biosaddr_ptr] + signatures[sig_ptr].ofs,
1434                                                                  signatures[sig_ptr].len);
1435                                         short bios_match = 1;
1436
1437                                         if (biosaddr)
1438                                                 bios_match = check_signature(biosaddr, signatures[sig_ptr].sig, signatures[sig_ptr].len);
1439
1440                                         iounmap(biosaddr);
1441
1442                                         if (bios_match)
1443                                                 goto bios_matched;
1444                                 }
1445                         }
1446
1447               bios_matched:
1448                 /*
1449                  * BIOS SIGNATURE has been found.
1450                  */
1451 #ifdef WD7000_DEBUG
1452                 dprintk("wd7000_detect: pass %d\n", pass + 1);
1453
1454                 if (biosaddr_ptr == NUM_ADDRS)
1455                         dprintk("WD-7000 SST BIOS not detected...\n");
1456                 else
1457                         dprintk("WD-7000 SST BIOS detected at 0x%lx: checking...\n", wd7000_biosaddr[biosaddr_ptr]);
1458 #endif
1459
1460                 if (configs[pass].irq < 0)
1461                         continue;
1462
1463                 if (unit == UNITS)
1464                         continue;
1465
1466                 iobase = configs[pass].iobase;
1467
1468                 dprintk("wd7000_detect: check IO 0x%x region...\n", iobase);
1469
1470                 if (request_region(iobase, 4, "wd7000")) {
1471
1472                         dprintk("wd7000_detect: ASC reset (IO 0x%x) ...", iobase);
1473                         /*
1474                          * ASC reset...
1475                          */
1476                         outb(ASC_RES, iobase + ASC_CONTROL);
1477                         msleep(10);
1478                         outb(0, iobase + ASC_CONTROL);
1479
1480                         if (WAIT(iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
1481                                 dprintk("failed!\n");
1482                                 goto err_release;
1483                         } else
1484                                 dprintk("ok!\n");
1485
1486                         if (inb(iobase + ASC_INTR_STAT) == 1) {
1487                                 /*
1488                                  *  We register here, to get a pointer to the extra space,
1489                                  *  which we'll use as the Adapter structure (host) for
1490                                  *  this adapter.  It is located just after the registered
1491                                  *  Scsi_Host structure (sh), and is located by the empty
1492                                  *  array hostdata.
1493                                  */
1494                                 sh = scsi_register(tpnt, sizeof(Adapter));
1495                                 if (sh == NULL)
1496                                         goto err_release;
1497
1498                                 host = (Adapter *) sh->hostdata;
1499
1500                                 dprintk("wd7000_detect: adapter allocated at 0x%x\n", (int) host);
1501                                 memset(host, 0, sizeof(Adapter));
1502
1503                                 host->irq = configs[pass].irq;
1504                                 host->dma = configs[pass].dma;
1505                                 host->iobase = iobase;
1506                                 host->int_counter = 0;
1507                                 host->bus_on = configs[pass].bus_on;
1508                                 host->bus_off = configs[pass].bus_off;
1509                                 host->sh = wd7000_host[unit] = sh;
1510                                 unit++;
1511
1512                                 dprintk("wd7000_detect: Trying init WD-7000 card at IO " "0x%x, IRQ %d, DMA %d...\n", host->iobase, host->irq, host->dma);
1513
1514                                 if (!wd7000_init(host)) /* Initialization failed */
1515                                         goto err_unregister;
1516
1517                                 /*
1518                                  *  OK from here - we'll use this adapter/configuration.
1519                                  */
1520                                 wd7000_revision(host);  /* important for scatter/gather */
1521
1522                                 /*
1523                                  *  For boards before rev 6.0, scatter/gather isn't supported.
1524                                  */
1525                                 if (host->rev1 < 6)
1526                                         sh->sg_tablesize = 1;
1527
1528                                 present++;      /* count it */
1529
1530                                 if (biosaddr_ptr != NUM_ADDRS)
1531                                         biosptr[pass] = biosaddr_ptr;
1532
1533                                 printk(KERN_INFO "Western Digital WD-7000 (rev %d.%d) ", host->rev1, host->rev2);
1534                                 printk("using IO 0x%x, IRQ %d, DMA %d.\n", host->iobase, host->irq, host->dma);
1535                                 printk("  BUS_ON time: %dns, BUS_OFF time: %dns\n", host->bus_on * 125, host->bus_off * 125);
1536                         }
1537                 } else
1538                         dprintk("wd7000_detect: IO 0x%x region already allocated!\n", iobase);
1539
1540                 continue;
1541
1542               err_unregister:
1543                 scsi_unregister(sh);
1544               err_release:
1545                 release_region(iobase, 4);
1546
1547         }
1548
1549         if (!present)
1550                 printk("Failed initialization of WD-7000 SCSI card!\n");
1551
1552         return (present);
1553 }
1554
1555 static int wd7000_release(struct Scsi_Host *shost)
1556 {
1557         if (shost->irq)
1558                 free_irq(shost->irq, NULL);
1559         if (shost->io_port && shost->n_io_port)
1560                 release_region(shost->io_port, shost->n_io_port);
1561         scsi_unregister(shost);
1562         return 0;
1563 }
1564
1565 #if 0
1566 /*
1567  *  I have absolutely NO idea how to do an abort with the WD7000...
1568  */
1569 static int wd7000_abort(Scsi_Cmnd * SCpnt)
1570 {
1571         Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
1572
1573         if (inb(host->iobase + ASC_STAT) & INT_IM) {
1574                 printk("wd7000_abort: lost interrupt\n");
1575                 wd7000_intr_handle(host->irq, NULL, NULL);
1576                 return FAILED;
1577         }
1578         return FAILED;
1579 }
1580 #endif
1581
1582 /*
1583  *  Last resort. Reinitialize the board.
1584  */
1585
1586 static int wd7000_host_reset(struct scsi_cmnd *SCpnt)
1587 {
1588         Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
1589
1590         spin_lock_irq(SCpnt->device->host->host_lock);
1591
1592         if (wd7000_adapter_reset(host) < 0) {
1593                 spin_unlock_irq(SCpnt->device->host->host_lock);
1594                 return FAILED;
1595         }
1596
1597         wd7000_enable_intr(host);
1598
1599         spin_unlock_irq(SCpnt->device->host->host_lock);
1600         return SUCCESS;
1601 }
1602
1603 /*
1604  *  This was borrowed directly from aha1542.c. (Zaga)
1605  */
1606
1607 static int wd7000_biosparam(struct scsi_device *sdev,
1608                 struct block_device *bdev, sector_t capacity, int *ip)
1609 {
1610         char b[BDEVNAME_SIZE];
1611
1612         dprintk("wd7000_biosparam: dev=%s, size=%d, ",
1613                 bdevname(bdev, b), capacity);
1614         (void)b;        /* unused var warning? */
1615
1616         /*
1617          * try default translation
1618          */
1619         ip[0] = 64;
1620         ip[1] = 32;
1621         ip[2] = capacity >> 11;
1622
1623         /*
1624          * for disks >1GB do some guessing
1625          */
1626         if (ip[2] >= 1024) {
1627                 int info[3];
1628
1629                 /*
1630                  * try to figure out the geometry from the partition table
1631                  */
1632                 if ((scsicam_bios_param(bdev, capacity, info) < 0) || !(((info[0] == 64) && (info[1] == 32)) || ((info[0] == 255) && (info[1] == 63)))) {
1633                         printk("wd7000_biosparam: unable to verify geometry for disk with >1GB.\n" "                  using extended translation.\n");
1634
1635                         ip[0] = 255;
1636                         ip[1] = 63;
1637                         ip[2] = (unsigned long) capacity / (255 * 63);
1638                 } else {
1639                         ip[0] = info[0];
1640                         ip[1] = info[1];
1641                         ip[2] = info[2];
1642
1643                         if (info[0] == 255)
1644                                 printk(KERN_INFO "%s: current partition table is " "using extended translation.\n", __func__);
1645                 }
1646         }
1647
1648         dprintk("bios geometry: head=%d, sec=%d, cyl=%d\n", ip[0], ip[1], ip[2]);
1649         dprintk("WARNING: check, if the bios geometry is correct.\n");
1650
1651         return (0);
1652 }
1653
1654 MODULE_AUTHOR("Thomas Wuensche, John Boyd, Miroslav Zagorac");
1655 MODULE_DESCRIPTION("Driver for the WD7000 series ISA controllers");
1656 MODULE_LICENSE("GPL");
1657
1658 static struct scsi_host_template driver_template = {
1659         .proc_name              = "wd7000",
1660         .proc_info              = wd7000_proc_info,
1661         .name                   = "Western Digital WD-7000",
1662         .detect                 = wd7000_detect,
1663         .release                = wd7000_release,
1664         .queuecommand           = wd7000_queuecommand,
1665         .eh_host_reset_handler  = wd7000_host_reset,
1666         .bios_param             = wd7000_biosparam,
1667         .can_queue              = WD7000_Q,
1668         .this_id                = 7,
1669         .sg_tablesize           = WD7000_SG,
1670         .cmd_per_lun            = 1,
1671         .unchecked_isa_dma      = 1,
1672         .use_clustering         = ENABLE_CLUSTERING,
1673 };
1674
1675 #include "scsi_module.c"