Return to wd7000.c CVS log

Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi

Annotation of Gnu-Mach/i386/i386at/gpl/linux/scsi/wd7000.c, revision 1.1

1.1     ! root        1: /* $Id: wd7000.c,v 1.1.1.1 1997/02/25 21:27:53 thomas Exp $
        !             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 <[email protected]> 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: #ifdef MODULE
        !           104: #include <linux/module.h>
        !           105: #endif
        !           106: 
        !           107: #include <stdarg.h>
        !           108: #include <linux/kernel.h>
        !           109: #include <linux/head.h>
        !           110: #include <linux/types.h>
        !           111: #include <linux/string.h>
        !           112: #include <linux/sched.h>
        !           113: #include <linux/malloc.h>
        !           114: #include <asm/system.h>
        !           115: #include <asm/dma.h>
        !           116: #include <asm/io.h>
        !           117: #include <linux/ioport.h>
        !           118: #include <linux/proc_fs.h>
        !           119: #include <linux/blk.h>
        !           120: #include "scsi.h"
        !           121: #include "hosts.h"
        !           122: #include "sd.h"
        !           123: 
        !           124: #define ANY2SCSI_INLINE    /* undef this to use old macros */
        !           125: #undef DEBUG
        !           126: 
        !           127: #include "wd7000.h"
        !           128: 
        !           129: #include<linux/stat.h>
        !           130: 
        !           131: struct proc_dir_entry proc_scsi_wd7000 = {
        !           132:     PROC_SCSI_7000FASST, 6, "wd7000",
        !           133:     S_IFDIR | S_IRUGO | S_IXUGO, 2
        !           134: };
        !           135: 
        !           136: 
        !           137: /*
        !           138:  *  Mailbox structure sizes.
        !           139:  *  I prefer to keep the number of ICMBs much larger than the number of
        !           140:  *  OGMBs.  OGMBs are used very quickly by the driver to start one or
        !           141:  *  more commands, while ICMBs are used by the host adapter per command.
        !           142:  */
        !           143: #define OGMB_CNT       16
        !           144: #define ICMB_CNT       32
        !           145: 
        !           146: /*
        !           147:  *  Scb's are shared by all active adapters.  So, if they all become busy,
        !           148:  *  callers may be made to wait in alloc_scbs for them to free.  That can
        !           149:  *  be avoided by setting MAX_SCBS to NUM_CONFIG * WD7000_Q.  If you'd
        !           150:  *  rather conserve memory, use a smaller number (> 0, of course) - things
        !           151:  *  will should still work OK.
        !           152:  */
        !           153: #define MAX_SCBS        32
        !           154: 
        !           155: /*
        !           156:  *  WD7000-specific mailbox structure
        !           157:  *
        !           158:  */
        !           159: typedef volatile struct mailbox{
        !           160:   unchar status;
        !           161:   unchar scbptr[3];             /* SCSI-style - MSB first (big endian) */
        !           162: } Mailbox;
        !           163: 
        !           164: /*
        !           165:  *  This structure should contain all per-adapter global data.  I.e., any
        !           166:  *  new global per-adapter data should put in here.
        !           167:  *
        !           168:  */
        !           169: typedef struct adapter {
        !           170:   struct Scsi_Host *sh;             /* Pointer to Scsi_Host structure */
        !           171:   int iobase;                       /* This adapter's I/O base address */
        !           172:   int irq;                          /* This adapter's IRQ level */
        !           173:   int dma;                          /* This adapter's DMA channel */
        !           174:   struct {                          /* This adapter's mailboxes */
        !           175:     Mailbox ogmb[OGMB_CNT];             /* Outgoing mailboxes */
        !           176:     Mailbox icmb[ICMB_CNT];             /* Incoming mailboxes */
        !           177:   } mb;
        !           178:   int next_ogmb;                    /* to reduce contention at mailboxes */
        !           179:   unchar control;                   /* shadows CONTROL port value */
        !           180:   unchar rev1, rev2;                /* filled in by wd7000_revision */
        !           181: } Adapter;
        !           182: 
        !           183: /*
        !           184:  * The following is set up by wd7000_detect, and used thereafter by
        !           185:  * wd7000_intr_handle to map the irq level to the corresponding Adapter.
        !           186:  * Note that if SA_INTERRUPT is not used, wd7000_intr_handle must be
        !           187:  * changed to pick up the IRQ level correctly.
        !           188:  */
        !           189: Adapter *irq2host[16] = {NULL};  /* Possible IRQs are 0-15 */
        !           190: 
        !           191: /*
        !           192:  *  Standard Adapter Configurations - used by wd7000_detect
        !           193:  */
        !           194: typedef struct {
        !           195:   const void *bios;             /* (linear) base address for ROM BIOS */
        !           196:   int iobase;                   /* I/O ports base address */
        !           197:   int irq;                      /* IRQ level */
        !           198:   int dma;                      /* DMA channel */
        !           199: } Config;
        !           200: 
        !           201: static const Config configs[] = {
        !           202:   {(void *) 0xce000, 0x350, 15, 6},  /* defaults for single adapter */
        !           203:   {(void *) 0xc8000, 0x330, 11, 5},  /* defaults for second adapter */
        !           204:   {(void *) 0xd8000, 0x350, 15, 6},  /* Arghhh.... who added this ? */
        !           205: };
        !           206: #define NUM_CONFIGS (sizeof(configs)/sizeof(Config))
        !           207: 
        !           208: /*
        !           209:  *  The following list defines strings to look for in the BIOS that identify
        !           210:  *  it as the WD7000-FASST2 SST BIOS.  I suspect that something should be
        !           211:  *  added for the Future Domain version.
        !           212:  */
        !           213: typedef struct signature {
        !           214:     const void *sig;           /* String to look for */
        !           215:     unsigned    ofs;           /* offset from BIOS base address */
        !           216:     unsigned    len;           /* length of string */
        !           217: } Signature;
        !           218: 
        !           219: static const Signature signatures[] = {
        !           220:   {"SSTBIOS",0x0000d,7}                  /* "SSTBIOS" @ offset 0x0000d */
        !           221: };
        !           222: #define NUM_SIGNATURES (sizeof(signatures)/sizeof(Signature))
        !           223: 
        !           224: 
        !           225: /*
        !           226:  *  I/O Port Offsets and Bit Definitions
        !           227:  *  4 addresses are used.  Those not defined here are reserved.
        !           228:  */
        !           229: #define ASC_STAT        0       /* Status,  Read */
        !           230: #define ASC_COMMAND     0       /* Command, Write */
        !           231: #define ASC_INTR_STAT   1       /* Interrupt Status, Read */
        !           232: #define ASC_INTR_ACK    1       /* Acknowledge, Write */
        !           233: #define ASC_CONTROL     2       /* Control, Write */
        !           234: 
        !           235: /* ASC Status Port
        !           236:  */
        !           237: #define INT_IM         0x80            /* Interrupt Image Flag */
        !           238: #define CMD_RDY                0x40            /* Command Port Ready */
        !           239: #define CMD_REJ                0x20            /* Command Port Byte Rejected */
        !           240: #define ASC_INIT        0x10           /* ASC Initialized Flag */
        !           241: #define ASC_STATMASK    0xf0           /* The lower 4 Bytes are reserved */
        !           242: 
        !           243: /* COMMAND opcodes
        !           244:  *
        !           245:  *  Unfortunately, I have no idea how to properly use some of these commands,
        !           246:  *  as the OEM manual does not make it clear.  I have not been able to use
        !           247:  *  enable/disable unsolicited interrupts or the reset commands with any
        !           248:  *  discernible effect whatsoever.  I think they may be related to certain
        !           249:  *  ICB commands, but again, the OEM manual doesn't make that clear.
        !           250:  */
        !           251: #define NO_OP             0     /* NO-OP toggles CMD_RDY bit in ASC_STAT */
        !           252: #define INITIALIZATION    1     /* initialization (10 bytes) */
        !           253: #define DISABLE_UNS_INTR  2     /* disable unsolicited interrupts */
        !           254: #define ENABLE_UNS_INTR   3     /* enable unsolicited interrupts */
        !           255: #define INTR_ON_FREE_OGMB 4     /* interrupt on free OGMB */
        !           256: #define SOFT_RESET        5     /* SCSI bus soft reset */
        !           257: #define HARD_RESET_ACK    6     /* SCSI bus hard reset acknowledge */
        !           258: #define START_OGMB        0x80  /* start command in OGMB (n) */
        !           259: #define SCAN_OGMBS        0xc0  /* start multiple commands, signature (n) */
        !           260:                                /*    where (n) = lower 6 bits */
        !           261: /* For INITIALIZATION:
        !           262:  */
        !           263: typedef struct initCmd {
        !           264:   unchar op;                   /* command opcode (= 1) */
        !           265:   unchar ID;                   /* Adapter's SCSI ID */
        !           266:   unchar bus_on;               /* Bus on time, x 125ns (see below) */
        !           267:   unchar bus_off;              /* Bus off time, ""         ""      */
        !           268:   unchar rsvd;                 /* Reserved */
        !           269:   unchar mailboxes[3];         /* Address of Mailboxes, MSB first  */
        !           270:   unchar ogmbs;                /* Number of outgoing MBs, max 64, 0,1 = 1 */
        !           271:   unchar icmbs;                /* Number of incoming MBs,   ""       ""   */
        !           272: } InitCmd;
        !           273: 
        !           274: #define BUS_ON            64    /* x 125ns = 8000ns (BIOS default) */
        !           275: #define BUS_OFF           15    /* x 125ns = 1875ns (BIOS default) */
        !           276:  
        !           277: /* Interrupt Status Port - also returns diagnostic codes at ASC reset
        !           278:  *
        !           279:  * if msb is zero, the lower bits are diagnostic status
        !           280:  * Diagnostics:
        !           281:  * 01  No diagnostic error occurred
        !           282:  * 02  RAM failure
        !           283:  * 03  FIFO R/W failed
        !           284:  * 04   SBIC register read/write failed
        !           285:  * 05   Initialization D-FF failed
        !           286:  * 06   Host IRQ D-FF failed
        !           287:  * 07   ROM checksum error
        !           288:  * Interrupt status (bitwise):
        !           289:  * 10NNNNNN   outgoing mailbox NNNNNN is free
        !           290:  * 11NNNNNN   incoming mailbox NNNNNN needs service
        !           291:  */
        !           292: #define MB_INTR         0xC0           /* Mailbox Service possible/required */
        !           293: #define IMB_INTR 0x40          /* 1 Incoming / 0 Outgoing */
        !           294: #define MB_MASK  0x3f           /* mask for mailbox number */
        !           295: 
        !           296: /* CONTROL port bits
        !           297:  */
        !           298: #define INT_EN         0x08    /* Interrupt Enable     */
        !           299: #define DMA_EN         0x04    /* DMA Enable           */
        !           300: #define SCSI_RES       0x02    /* SCSI Reset           */
        !           301: #define ASC_RES                0x01    /* ASC Reset            */
        !           302: 
        !           303: /*
        !           304:    Driver data structures:
        !           305:    - mb and scbs are required for interfacing with the host adapter.
        !           306:      An SCB has extra fields not visible to the adapter; mb's
        !           307:      _cannot_ do this, since the adapter assumes they are contiguous in
        !           308:      memory, 4 bytes each, with ICMBs following OGMBs, and uses this fact
        !           309:      to access them.
        !           310:    - An icb is for host-only (non-SCSI) commands.  ICBs are 16 bytes each;
        !           311:      the additional bytes are used only by the driver.
        !           312:    - For now, a pool of SCBs are kept in global storage by this driver,
        !           313:      and are allocated and freed as needed.
        !           314: 
        !           315:   The 7000-FASST2 marks OGMBs empty as soon as it has _started_ a command,
        !           316:   not when it has finished.  Since the SCB must be around for completion,
        !           317:   problems arise when SCBs correspond to OGMBs, which may be reallocated
        !           318:   earlier (or delayed unnecessarily until a command completes).
        !           319:   Mailboxes are used as transient data structures, simply for
        !           320:   carrying SCB addresses to/from the 7000-FASST2.
        !           321: 
        !           322:   Note also since SCBs are not "permanently" associated with mailboxes,
        !           323:   there is no need to keep a global list of Scsi_Cmnd pointers indexed
        !           324:   by OGMB.   Again, SCBs reference their Scsi_Cmnds directly, so mailbox
        !           325:   indices need not be involved.
        !           326: */
        !           327: 
        !           328: /*
        !           329:  *  WD7000-specific scatter/gather element structure
        !           330:  */
        !           331: typedef struct sgb {
        !           332:     unchar len[3];
        !           333:     unchar ptr[3];              /* Also SCSI-style - MSB first */
        !           334: } Sgb;
        !           335: 
        !           336: typedef struct scb {           /* Command Control Block 5.4.1 */
        !           337:   unchar op;                   /* Command Control Block Operation Code */
        !           338:   unchar idlun;                        /* op=0,2:Target Id, op=1:Initiator Id */
        !           339:                                /* Outbound data transfer, length is checked*/
        !           340:                                /* Inbound data transfer, length is checked */
        !           341:                                /* Logical Unit Number */
        !           342:   unchar cdb[12];              /* SCSI Command Block */
        !           343:   volatile unchar status;       /* SCSI Return Status */
        !           344:   volatile unchar vue;         /* Vendor Unique Error Code */
        !           345:   unchar maxlen[3];            /* Maximum Data Transfer Length */
        !           346:   unchar dataptr[3];           /* SCSI Data Block Pointer */
        !           347:   unchar linkptr[3];           /* Next Command Link Pointer */
        !           348:   unchar direc;                        /* Transfer Direction */
        !           349:   unchar reserved2[6];         /* SCSI Command Descriptor Block */
        !           350:                                /* end of hardware SCB */
        !           351:   Scsi_Cmnd *SCpnt;             /* Scsi_Cmnd using this SCB */
        !           352:   Sgb sgb[WD7000_SG];           /* Scatter/gather list for this SCB */
        !           353:   Adapter *host;                /* host adapter */
        !           354:   struct scb *next;             /* for lists of scbs */
        !           355: } Scb;
        !           356: 
        !           357: /*
        !           358:  *  This driver is written to allow host-only commands to be executed.
        !           359:  *  These use a 16-byte block called an ICB.  The format is extended by the
        !           360:  *  driver to 18 bytes, to support the status returned in the ICMB and
        !           361:  *  an execution phase code.
        !           362:  *
        !           363:  *  There are other formats besides these; these are the ones I've tried
        !           364:  *  to use.  Formats for some of the defined ICB opcodes are not defined
        !           365:  *  (notably, get/set unsolicited interrupt status) in my copy of the OEM
        !           366:  *  manual, and others are ambiguous/hard to follow.
        !           367:  */
        !           368: #define ICB_OP_MASK             0x80  /* distinguishes scbs from icbs */
        !           369: #define ICB_OP_OPEN_RBUF        0x80  /* open receive buffer */
        !           370: #define ICB_OP_RECV_CMD         0x81  /* receive command from initiator */
        !           371: #define ICB_OP_RECV_DATA        0x82  /* receive data from initiator */
        !           372: #define ICB_OP_RECV_SDATA       0x83  /* receive data with status from init. */
        !           373: #define ICB_OP_SEND_DATA        0x84  /* send data with status to initiator */
        !           374: #define ICB_OP_SEND_STAT        0x86  /* send command status to initiator */
        !           375:                             /* 0x87 is reserved */
        !           376: #define ICB_OP_READ_INIT        0x88  /* read initialization bytes */
        !           377: #define ICB_OP_READ_ID          0x89  /* read adapter's SCSI ID */
        !           378: #define ICB_OP_SET_UMASK        0x8A  /* set unsolicited interrupt mask */
        !           379: #define ICB_OP_GET_UMASK        0x8B  /* read unsolicited interrupt mask */
        !           380: #define ICB_OP_GET_REVISION     0x8C  /* read firmware revision level */
        !           381: #define ICB_OP_DIAGNOSTICS      0x8D  /* execute diagnostics */
        !           382: #define ICB_OP_SET_EPARMS       0x8E  /* set execution parameters */
        !           383: #define ICB_OP_GET_EPARMS       0x8F  /* read execution parameters */
        !           384: 
        !           385: typedef struct icbRecvCmd {
        !           386:   unchar op;
        !           387:   unchar IDlun;                 /* Initiator SCSI ID/lun */
        !           388:   unchar len[3];                /* command buffer length */
        !           389:   unchar ptr[3];                /* command buffer address */
        !           390:   unchar rsvd[7];               /* reserved */
        !           391:   volatile unchar vue;          /* vendor-unique error code */
        !           392:   volatile unchar status;       /* returned (icmb) status */
        !           393:   volatile unchar phase;        /* used by interrupt handler */
        !           394: } IcbRecvCmd;
        !           395: 
        !           396: typedef struct icbSendStat {
        !           397:   unchar op;
        !           398:   unchar IDlun;                 /* Target SCSI ID/lun */
        !           399:   unchar stat;                  /* (outgoing) completion status byte 1 */
        !           400:   unchar rsvd[12];              /* reserved */
        !           401:   volatile unchar vue;          /* vendor-unique error code */
        !           402:   volatile unchar status;       /* returned (icmb) status */
        !           403:   volatile unchar phase;        /* used by interrupt handler */
        !           404: } IcbSendStat;
        !           405: 
        !           406: typedef struct icbRevLvl {
        !           407:   unchar op;
        !           408:   volatile unchar primary;      /* primary revision level (returned) */
        !           409:   volatile unchar secondary;    /* secondary revision level (returned) */
        !           410:   unchar rsvd[12];              /* reserved */
        !           411:   volatile unchar vue;          /* vendor-unique error code */
        !           412:   volatile unchar status;       /* returned (icmb) status */
        !           413:   volatile unchar phase;        /* used by interrupt handler */
        !           414: } IcbRevLvl;
        !           415: 
        !           416: typedef struct icbUnsMask {     /* I'm totally guessing here */
        !           417:   unchar op;
        !           418:   volatile unchar mask[14];     /* mask bits */
        !           419: #ifdef 0
        !           420:   unchar rsvd[12];              /* reserved */
        !           421: #endif
        !           422:   volatile unchar vue;          /* vendor-unique error code */
        !           423:   volatile unchar status;       /* returned (icmb) status */
        !           424:   volatile unchar phase;        /* used by interrupt handler */
        !           425: } IcbUnsMask;
        !           426: 
        !           427: typedef struct icbDiag {
        !           428:   unchar op;
        !           429:   unchar type;                  /* diagnostics type code (0-3) */
        !           430:   unchar len[3];                /* buffer length */
        !           431:   unchar ptr[3];                /* buffer address */
        !           432:   unchar rsvd[7];               /* reserved */
        !           433:   volatile unchar vue;          /* vendor-unique error code */
        !           434:   volatile unchar status;       /* returned (icmb) status */
        !           435:   volatile unchar phase;        /* used by interrupt handler */
        !           436: } IcbDiag;
        !           437: 
        !           438: #define ICB_DIAG_POWERUP        0     /* Power-up diags only */
        !           439: #define ICB_DIAG_WALKING        1     /* walking 1's pattern */
        !           440: #define ICB_DIAG_DMA            2     /* DMA - system memory diags */
        !           441: #define ICB_DIAG_FULL           3     /* do both 1 & 2 */
        !           442: 
        !           443: typedef struct icbParms {
        !           444:   unchar op;
        !           445:   unchar rsvd1;                 /* reserved */
        !           446:   unchar len[3];                /* parms buffer length */
        !           447:   unchar ptr[3];                /* parms buffer address */
        !           448:   unchar idx[2];                /* index (MSB-LSB) */
        !           449:   unchar rsvd2[5];              /* reserved */
        !           450:   volatile unchar vue;          /* vendor-unique error code */
        !           451:   volatile unchar status;       /* returned (icmb) status */
        !           452:   volatile unchar phase;        /* used by interrupt handler */
        !           453: } IcbParms;
        !           454: 
        !           455: typedef struct icbAny {
        !           456:   unchar op;
        !           457:   unchar data[14];              /* format-specific data */
        !           458:   volatile unchar vue;          /* vendor-unique error code */
        !           459:   volatile unchar status;       /* returned (icmb) status */
        !           460:   volatile unchar phase;        /* used by interrupt handler */
        !           461: } IcbAny;
        !           462: 
        !           463: typedef union icb {
        !           464:   unchar op;                    /* ICB opcode */
        !           465:   IcbRecvCmd recv_cmd;          /* format for receive command */
        !           466:   IcbSendStat send_stat;        /* format for send status */
        !           467:   IcbRevLvl rev_lvl;            /* format for get revision level */
        !           468:   IcbDiag diag;                 /* format for execute diagnostics */
        !           469:   IcbParms eparms;              /* format for get/set exec parms */
        !           470:   IcbAny icb;                   /* generic format */
        !           471:   unchar data[18];
        !           472: } Icb;
        !           473: 
        !           474: 
        !           475: /*
        !           476:  *  Driver SCB structure pool.
        !           477:  *
        !           478:  *  The SCBs declared here are shared by all host adapters; hence, this
        !           479:  *  structure is not part of the Adapter structure.
        !           480:  */
        !           481: static Scb scbs[MAX_SCBS];
        !           482: static Scb *scbfree = NULL;      /* free list */
        !           483: static int freescbs = MAX_SCBS;  /* free list counter */
        !           484: 
        !           485: /*
        !           486:  *  END of data/declarations - code follows.
        !           487:  */
        !           488: 
        !           489: 
        !           490: #ifdef ANY2SCSI_INLINE
        !           491: /*
        !           492:    Since they're used a lot, I've redone the following from the macros
        !           493:    formerly in wd7000.h, hopefully to speed them up by getting rid of
        !           494:    all the shifting (it may not matter; GCC might have done as well anyway).
        !           495: 
        !           496:    xany2scsi and xscsi2int were not being used, and are no longer defined.
        !           497:    (They were simply 4-byte versions of these routines).
        !           498: */
        !           499: 
        !           500: typedef union {  /* let's cheat... */
        !           501:   int i;
        !           502:   unchar u[sizeof(int)];  /* the sizeof(int) makes it more portable */
        !           503: } i_u;
        !           504: 
        !           505: 
        !           506: static inline void any2scsi( unchar *scsi, int any )
        !           507: {
        !           508:     *scsi++ = ((i_u) any).u[2];
        !           509:     *scsi++ = ((i_u) any).u[1];
        !           510:     *scsi++ = ((i_u) any).u[0];
        !           511: }
        !           512: 
        !           513: 
        !           514: static inline int scsi2int( unchar *scsi )
        !           515: {
        !           516:     i_u result;
        !           517: 
        !           518:     result.i = 0;  /* clears unused bytes */
        !           519:     *(result.u+2) = *scsi++;
        !           520:     *(result.u+1) = *scsi++;
        !           521:       *(result.u) = *scsi++;
        !           522:     return result.i;
        !           523: }
        !           524: #else
        !           525: /*
        !           526:    These are the old ones - I've just moved them here...
        !           527: */
        !           528: #undef any2scsi
        !           529: #define any2scsi(up, p)                        \
        !           530: (up)[0] = (((unsigned long)(p)) >> 16);                \
        !           531: (up)[1] = ((unsigned long)(p)) >> 8;           \
        !           532: (up)[2] = ((unsigned long)(p));
        !           533: 
        !           534: #undef scsi2int
        !           535: #define scsi2int(up) ( (((unsigned long)*(up)) << 16) + \
        !           536:  (((unsigned long)(up)[1]) << 8) + ((unsigned long)(up)[2]) )
        !           537: #endif
        !           538: 
        !           539:     
        !           540: static inline void wd7000_enable_intr(Adapter *host)
        !           541: {
        !           542:     host->control |= INT_EN;
        !           543:     outb(host->control, host->iobase+ASC_CONTROL);
        !           544: }
        !           545: 
        !           546: 
        !           547: static inline void wd7000_enable_dma(Adapter *host)
        !           548: {
        !           549:     host->control |= DMA_EN;
        !           550:     outb(host->control,host->iobase+ASC_CONTROL);
        !           551:     set_dma_mode(host->dma, DMA_MODE_CASCADE);
        !           552:     enable_dma(host->dma);
        !           553: }
        !           554: 
        !           555: 
        !           556: #define WAITnexttimeout 200  /* 2 seconds */
        !           557: 
        !           558: #define WAIT(port, mask, allof, noneof)                                        \
        !           559:  { register volatile unsigned WAITbits;                                \
        !           560:    register unsigned long WAITtimeout = jiffies + WAITnexttimeout;     \
        !           561:    while (1) {                                                         \
        !           562:      WAITbits = inb(port) & (mask);                                    \
        !           563:      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
        !           564:        break;                                                          \
        !           565:      if (jiffies > WAITtimeout) goto fail;                             \
        !           566:    }                                                                   \
        !           567:  }
        !           568: 
        !           569: 
        !           570: static inline void delay( unsigned how_long )
        !           571: {
        !           572:      register unsigned long time = jiffies + how_long;
        !           573: 
        !           574:      while (jiffies < time);
        !           575: }
        !           576: 
        !           577: 
        !           578: static inline int command_out(Adapter *host, unchar *cmd, int len)
        !           579: {
        !           580:     WAIT(host->iobase+ASC_STAT,ASC_STATMASK,CMD_RDY,0);
        !           581:     while (len--)  {
        !           582:        do  {
        !           583:            outb(*cmd, host->iobase+ASC_COMMAND);
        !           584:            WAIT(host->iobase+ASC_STAT, ASC_STATMASK, CMD_RDY, 0);
        !           585:        }  while (inb(host->iobase+ASC_STAT) & CMD_REJ);
        !           586:        cmd++;
        !           587:     }
        !           588:     return 1;
        !           589: 
        !           590: fail:
        !           591:     printk("wd7000 command_out: WAIT failed(%d)\n", len+1);
        !           592:     return 0;
        !           593: }
        !           594: 
        !           595: 
        !           596: /*
        !           597:  *  This version of alloc_scbs is in preparation for supporting multiple
        !           598:  *  commands per lun and command chaining, by queueing pending commands.
        !           599:  *  We will need to allocate Scbs in blocks since they will wait to be
        !           600:  *  executed so there is the possibility of deadlock otherwise.
        !           601:  *  Also, to keep larger requests from being starved by smaller requests,
        !           602:  *  we limit access to this routine with an internal busy flag, so that
        !           603:  *  the satisfiability of a request is not dependent on the size of the
        !           604:  *  request.
        !           605:  */
        !           606: static inline Scb *alloc_scbs(int needed)
        !           607: {
        !           608:     register Scb *scb, *p;
        !           609:     register unsigned long flags;
        !           610:     register unsigned long timeout = jiffies + WAITnexttimeout;
        !           611:     register unsigned long now;
        !           612:     static int busy = 0;
        !           613:     int i;
        !           614: 
        !           615:     if (needed <= 0)  return NULL;  /* sanity check */
        !           616: 
        !           617:     save_flags(flags);
        !           618:     cli();
        !           619:     while (busy)  { /* someone else is allocating */
        !           620:        sti();  /* Yes this is really needed here */
        !           621:        now = jiffies;  while (jiffies == now)  /* wait a jiffy */;
        !           622:        cli();
        !           623:     }
        !           624:     busy = 1;          /* not busy now; it's our turn */
        !           625: 
        !           626:     while (freescbs < needed)  {
        !           627:        timeout = jiffies + WAITnexttimeout;
        !           628:        do {
        !           629:            sti();      /* Yes this is really needed here */
        !           630:            now = jiffies;   while (jiffies == now) /* wait a jiffy */;
        !           631:            cli();
        !           632:        }  while (freescbs < needed && jiffies <= timeout);
        !           633:        /*
        !           634:         *  If we get here with enough free Scbs, we can take them.
        !           635:         *  Otherwise, we timed out and didn't get enough.
        !           636:         */
        !           637:        if (freescbs < needed)  {
        !           638:            busy = 0;
        !           639:            panic("wd7000: can't get enough free SCBs.\n");
        !           640:            restore_flags(flags);
        !           641:            return NULL;
        !           642:        }
        !           643:     }
        !           644:     scb = scbfree;  freescbs -= needed;
        !           645:     for (i = 0; i < needed; i++)  { p = scbfree;  scbfree = p->next; }
        !           646:     p->next = NULL;
        !           647:     
        !           648:     busy = 0;   /* we're done */
        !           649: 
        !           650:     restore_flags(flags);
        !           651: 
        !           652:     return scb;
        !           653: }
        !           654: 
        !           655: 
        !           656: static inline void free_scb( Scb *scb )
        !           657: {
        !           658:     register unsigned long flags;
        !           659: 
        !           660:     save_flags(flags);
        !           661:     cli();
        !           662: 
        !           663:     memset(scb, 0, sizeof(Scb));
        !           664:     scb->next = scbfree;  scbfree = scb;
        !           665:     freescbs++;
        !           666: 
        !           667:     restore_flags(flags);
        !           668: }
        !           669: 
        !           670: 
        !           671: static inline void init_scbs(void)
        !           672: {
        !           673:     int i;
        !           674:     unsigned long flags;
        !           675: 
        !           676:     save_flags(flags);
        !           677:     cli();
        !           678: 
        !           679:     scbfree = &(scbs[0]);
        !           680:     memset(scbs, 0, sizeof(scbs));
        !           681:     for (i = 0;  i < MAX_SCBS-1;  i++)  {
        !           682:       scbs[i].next = &(scbs[i+1]);  scbs[i].SCpnt = NULL;
        !           683:     }
        !           684:     scbs[MAX_SCBS-1].next = NULL;
        !           685:     scbs[MAX_SCBS-1].SCpnt = NULL;
        !           686: 
        !           687:     restore_flags(flags);
        !           688: }    
        !           689:     
        !           690: 
        !           691: static int mail_out( Adapter *host, Scb *scbptr )
        !           692: /*
        !           693:  *  Note: this can also be used for ICBs; just cast to the parm type.
        !           694:  */
        !           695: {
        !           696:     register int i, ogmb;
        !           697:     register unsigned long flags;
        !           698:     unchar start_ogmb;
        !           699:     Mailbox *ogmbs = host->mb.ogmb;
        !           700:     int *next_ogmb = &(host->next_ogmb);
        !           701: #ifdef DEBUG
        !           702:     printk("wd7000 mail_out: %06x",(unsigned int) scbptr);
        !           703: #endif
        !           704:     /* We first look for a free outgoing mailbox */
        !           705:     save_flags(flags);
        !           706:     cli();
        !           707:     ogmb = *next_ogmb;
        !           708:     for (i = 0; i < OGMB_CNT; i++) {
        !           709:        if (ogmbs[ogmb].status == 0)  {
        !           710: #ifdef DEBUG
        !           711:            printk(" using OGMB %x",ogmb);
        !           712: #endif
        !           713:            ogmbs[ogmb].status = 1;
        !           714:            any2scsi((unchar *) ogmbs[ogmb].scbptr, (int) scbptr);
        !           715: 
        !           716:            *next_ogmb = (ogmb+1) % OGMB_CNT;
        !           717:            break;
        !           718:        }  else
        !           719:            ogmb = (++ogmb) % OGMB_CNT;
        !           720:     }
        !           721:     restore_flags(flags);
        !           722: #ifdef DEBUG
        !           723:     printk(", scb is %x",(unsigned int) scbptr);
        !           724: #endif
        !           725:     if (i >= OGMB_CNT) {
        !           726:        /*
        !           727:         *  Alternatively, we might issue the "interrupt on free OGMB",
        !           728:         *  and sleep, but it must be ensured that it isn't the init
        !           729:         *  task running.  Instead, this version assumes that the caller
        !           730:         *  will be persistent, and try again.  Since it's the adapter
        !           731:         *  that marks OGMB's free, waiting even with interrupts off
        !           732:         *  should work, since they are freed very quickly in most cases.
        !           733:         */
        !           734:        #ifdef DEBUG
        !           735:        printk(", no free OGMBs.\n");
        !           736: #endif
        !           737:        return 0;
        !           738:     }
        !           739: 
        !           740:     wd7000_enable_intr(host); 
        !           741: 
        !           742:     start_ogmb = START_OGMB | ogmb;
        !           743:     command_out( host, &start_ogmb, 1 );
        !           744: #ifdef DEBUG
        !           745:     printk(", awaiting interrupt.\n");
        !           746: #endif
        !           747:     return 1;
        !           748: }
        !           749: 
        !           750: 
        !           751: int make_code(unsigned hosterr, unsigned scsierr)
        !           752: {   
        !           753: #ifdef DEBUG
        !           754:     int in_error = hosterr;
        !           755: #endif
        !           756: 
        !           757:     switch ((hosterr>>8)&0xff){
        !           758:        case 0: /* Reserved */
        !           759:                hosterr = DID_ERROR;
        !           760:                break;
        !           761:        case 1: /* Command Complete, no errors */
        !           762:                hosterr = DID_OK;
        !           763:                break;
        !           764:        case 2: /* Command complete, error logged in scb status (scsierr) */ 
        !           765:                hosterr = DID_OK;
        !           766:                break;
        !           767:        case 4: /* Command failed to complete - timeout */
        !           768:                hosterr = DID_TIME_OUT;
        !           769:                break;
        !           770:        case 5: /* Command terminated; Bus reset by external device */
        !           771:                hosterr = DID_RESET;
        !           772:                break;
        !           773:        case 6: /* Unexpected Command Received w/ host as target */
        !           774:                hosterr = DID_BAD_TARGET;
        !           775:                break;
        !           776:        case 80: /* Unexpected Reselection */
        !           777:        case 81: /* Unexpected Selection */
        !           778:                hosterr = DID_BAD_INTR;
        !           779:                break;
        !           780:        case 82: /* Abort Command Message  */
        !           781:                hosterr = DID_ABORT;
        !           782:                break;
        !           783:        case 83: /* SCSI Bus Software Reset */
        !           784:        case 84: /* SCSI Bus Hardware Reset */
        !           785:                hosterr = DID_RESET;
        !           786:                break;
        !           787:        default: /* Reserved */
        !           788:                hosterr = DID_ERROR;
        !           789:                break;
        !           790:        }
        !           791: #ifdef DEBUG
        !           792:     if (scsierr||hosterr)
        !           793:        printk("\nSCSI command error: SCSI %02x host %04x return %d",
        !           794:               scsierr,in_error,hosterr);
        !           795: #endif
        !           796:     return scsierr | (hosterr << 16);
        !           797: }
        !           798: 
        !           799: 
        !           800: static void wd7000_scsi_done(Scsi_Cmnd * SCpnt)
        !           801: {
        !           802: #ifdef DEBUG
        !           803:     printk("wd7000_scsi_done: %06x\n",(unsigned int) SCpnt);
        !           804: #endif
        !           805:     SCpnt->SCp.phase = 0;
        !           806: }
        !           807: 
        !           808: 
        !           809: #define wd7000_intr_ack(host)  outb(0,host->iobase+ASC_INTR_ACK)
        !           810: 
        !           811: void wd7000_intr_handle(int irq, struct pt_regs * regs)
        !           812: {
        !           813:     register int flag, icmb, errstatus, icmb_status;
        !           814:     register int host_error, scsi_error;
        !           815:     register Scb *scb;             /* for SCSI commands */
        !           816:     register IcbAny *icb;          /* for host commands */
        !           817:     register Scsi_Cmnd *SCpnt;
        !           818:     Adapter *host = irq2host[irq];  /* This MUST be set!!! */
        !           819:     Mailbox *icmbs = host->mb.icmb;
        !           820: 
        !           821: #ifdef DEBUG
        !           822:     printk("wd7000_intr_handle: irq = %d, host = %06x\n", irq, host);
        !           823: #endif
        !           824: 
        !           825:     flag = inb(host->iobase+ASC_INTR_STAT);
        !           826: #ifdef DEBUG
        !           827:     printk("wd7000_intr_handle: intr stat = %02x\n",flag);
        !           828: #endif
        !           829: 
        !           830:     if (!(inb(host->iobase+ASC_STAT) & INT_IM))  {
        !           831:        /* NB: these are _very_ possible if IRQ 15 is being used, since
        !           832:           it's the "garbage collector" on the 2nd 8259 PIC.  Specifically,
        !           833:           any interrupt signal into the 8259 which can't be identified
        !           834:           comes out as 7 from the 8259, which is 15 to the host.  Thus, it
        !           835:           is a good thing the WD7000 has an interrupt status port, so we
        !           836:           can sort these out.  Otherwise, electrical noise and other such
        !           837:           problems would be indistinguishable from valid interrupts...
        !           838:        */
        !           839: #ifdef DEBUG 
        !           840:        printk("wd7000_intr_handle: phantom interrupt...\n");
        !           841: #endif
        !           842:        wd7000_intr_ack(host);
        !           843:        return; 
        !           844:     }
        !           845: 
        !           846:     if (flag & MB_INTR)  {
        !           847:        /* The interrupt is for a mailbox */
        !           848:        if (!(flag & IMB_INTR)) {
        !           849: #ifdef DEBUG
        !           850:            printk("wd7000_intr_handle: free outgoing mailbox");
        !           851: #endif
        !           852:            /*
        !           853:             * If sleep_on() and the "interrupt on free OGMB" command are
        !           854:             * used in mail_out(), wake_up() should correspondingly be called
        !           855:             * here.  For now, we don't need to do anything special.
        !           856:             */
        !           857:            wd7000_intr_ack(host);
        !           858:            return;
        !           859:        }  else  {
        !           860:            /* The interrupt is for an incoming mailbox */
        !           861:            icmb = flag & MB_MASK;
        !           862:            icmb_status = icmbs[icmb].status;
        !           863:            if (icmb_status & 0x80)  {  /* unsolicited - result in ICMB */
        !           864: #ifdef DEBUG
        !           865:                printk("wd7000_intr_handle: unsolicited interrupt %02xh\n",
        !           866:                       icmb_status);
        !           867: #endif
        !           868:                wd7000_intr_ack(host);
        !           869:                return;
        !           870:            }
        !           871:            scb = (struct scb *) scsi2int((unchar *)icmbs[icmb].scbptr);
        !           872:            icmbs[icmb].status = 0;
        !           873:            if (!(scb->op & ICB_OP_MASK))  {   /* an SCB is done */
        !           874:                SCpnt = scb->SCpnt;
        !           875:                if (--(SCpnt->SCp.phase) <= 0)  {  /* all scbs are done */
        !           876:                    host_error = scb->vue | (icmb_status << 8);
        !           877:                    scsi_error = scb->status;
        !           878:                    errstatus = make_code(host_error,scsi_error);    
        !           879:                    SCpnt->result = errstatus;
        !           880: 
        !           881:                    free_scb(scb);
        !           882: 
        !           883:                    SCpnt->scsi_done(SCpnt);
        !           884:                }
        !           885:            }  else  {    /* an ICB is done */
        !           886:                icb = (IcbAny *) scb;
        !           887:                icb->status = icmb_status;
        !           888:                icb->phase  = 0;
        !           889:            }
        !           890:        }  /* incoming mailbox */
        !           891:     }
        !           892: 
        !           893:     wd7000_intr_ack(host);
        !           894:     return;
        !           895: }
        !           896: 
        !           897: 
        !           898: int wd7000_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
        !           899: {
        !           900:     register Scb *scb;
        !           901:     register Sgb *sgb;
        !           902:     register unchar *cdb = (unchar *) SCpnt->cmnd;
        !           903:     register unchar idlun;
        !           904:     register short cdblen;
        !           905:     Adapter *host = (Adapter *) SCpnt->host->hostdata;
        !           906: 
        !           907:     cdblen = SCpnt->cmd_len;
        !           908:     idlun = ((SCpnt->target << 5) & 0xe0) | (SCpnt->lun & 7);
        !           909:     SCpnt->scsi_done = done;
        !           910:     SCpnt->SCp.phase = 1;
        !           911:     scb = alloc_scbs(1);
        !           912:     scb->idlun = idlun;
        !           913:     memcpy(scb->cdb, cdb, cdblen);
        !           914:     scb->direc = 0x40;         /* Disable direction check */
        !           915: 
        !           916:     scb->SCpnt = SCpnt;         /* so we can find stuff later */
        !           917:     SCpnt->host_scribble = (unchar *) scb;
        !           918:     scb->host = host;
        !           919: 
        !           920:     if (SCpnt->use_sg)  {
        !           921:        struct scatterlist *sg = (struct scatterlist *) SCpnt->request_buffer;
        !           922:        unsigned i;
        !           923: 
        !           924:        if (SCpnt->host->sg_tablesize == SG_NONE)  {
        !           925:            panic("wd7000_queuecommand: scatter/gather not supported.\n");
        !           926:        }
        !           927: #ifdef DEBUG
        !           928:        printk("Using scatter/gather with %d elements.\n",SCpnt->use_sg);
        !           929: #endif
        !           930: 
        !           931:        sgb = scb->sgb;
        !           932:        scb->op = 1;
        !           933:        any2scsi(scb->dataptr, (int) sgb);
        !           934:        any2scsi(scb->maxlen, SCpnt->use_sg * sizeof (Sgb) );
        !           935: 
        !           936:        for (i = 0;  i < SCpnt->use_sg;  i++)  {
        !           937:            any2scsi(sgb[i].ptr, (int) sg[i].address);
        !           938:            any2scsi(sgb[i].len, sg[i].length);
        !           939:        }
        !           940:     }  else  {
        !           941:        scb->op = 0;
        !           942:        any2scsi(scb->dataptr, (int) SCpnt->request_buffer);
        !           943:        any2scsi(scb->maxlen, SCpnt->request_bufflen);
        !           944:     }
        !           945:     while (!mail_out(host, scb)) /* keep trying */;
        !           946: 
        !           947:     return 1;
        !           948: }
        !           949: 
        !           950: 
        !           951: int wd7000_command(Scsi_Cmnd *SCpnt)
        !           952: {
        !           953:     wd7000_queuecommand(SCpnt, wd7000_scsi_done);
        !           954: 
        !           955:     while (SCpnt->SCp.phase > 0) barrier();  /* phase counts scbs down to 0 */
        !           956: 
        !           957:     return SCpnt->result;
        !           958: }
        !           959: 
        !           960: 
        !           961: int wd7000_diagnostics( Adapter *host, int code )
        !           962: {
        !           963:     static IcbDiag icb = {ICB_OP_DIAGNOSTICS};
        !           964:     static unchar buf[256];
        !           965:     unsigned long timeout;
        !           966: 
        !           967:     icb.type = code;
        !           968:     any2scsi(icb.len, sizeof(buf));
        !           969:     any2scsi(icb.ptr, (int) &buf);
        !           970:     icb.phase = 1;
        !           971:     /*
        !           972:      * This routine is only called at init, so there should be OGMBs
        !           973:      * available.  I'm assuming so here.  If this is going to
        !           974:      * fail, I can just let the timeout catch the failure.
        !           975:      */
        !           976:     mail_out(host, (struct scb *) &icb);
        !           977:     timeout = jiffies + WAITnexttimeout;  /* wait up to 2 seconds */
        !           978:     while (icb.phase && jiffies < timeout)
        !           979:        barrier(); /* wait for completion */
        !           980: 
        !           981:     if (icb.phase)  {
        !           982:        printk("wd7000_diagnostics: timed out.\n");
        !           983:        return 0;
        !           984:     }
        !           985:     if (make_code(icb.vue|(icb.status << 8),0))  {
        !           986:        printk("wd7000_diagnostics: failed (%02x,%02x)\n",
        !           987:               icb.vue, icb.status);
        !           988:        return 0;
        !           989:     }
        !           990: 
        !           991:     return 1;
        !           992: }
        !           993: 
        !           994: 
        !           995: int wd7000_init( Adapter *host )
        !           996: {
        !           997:     InitCmd init_cmd = {
        !           998:        INITIALIZATION, 7, BUS_ON, BUS_OFF, 0, {0,0,0}, OGMB_CNT, ICMB_CNT
        !           999:     };
        !          1000:     int diag;
        !          1001: 
        !          1002:     /*
        !          1003:        Reset the adapter - only.  The SCSI bus was initialized at power-up,
        !          1004:        and we need to do this just so we control the mailboxes, etc.
        !          1005:     */
        !          1006:     outb(ASC_RES, host->iobase+ASC_CONTROL);
        !          1007:     delay(1);  /* reset pulse: this is 10ms, only need 25us */
        !          1008:     outb(0,host->iobase+ASC_CONTROL);
        !          1009:     host->control = 0;   /* this must always shadow ASC_CONTROL */
        !          1010:     WAIT(host->iobase+ASC_STAT, ASC_STATMASK, CMD_RDY, 0);
        !          1011: 
        !          1012:     if ((diag = inb(host->iobase+ASC_INTR_STAT)) != 1)  {
        !          1013:        printk("wd7000_init: ");
        !          1014:        switch (diag)  {
        !          1015:        case 2:
        !          1016:          printk("RAM failure.\n");
        !          1017:          break;
        !          1018:        case 3:
        !          1019:          printk("FIFO R/W failed\n");
        !          1020:          break;
        !          1021:        case 4:
        !          1022:          printk("SBIC register R/W failed\n");
        !          1023:          break;
        !          1024:        case 5:
        !          1025:          printk("Initialization D-FF failed.\n");
        !          1026:          break;
        !          1027:        case 6:
        !          1028:          printk("Host IRQ D-FF failed.\n");
        !          1029:          break;
        !          1030:        case 7:
        !          1031:          printk("ROM checksum error.\n");
        !          1032:          break;
        !          1033:        default:
        !          1034:          printk("diagnostic code %02Xh received.\n", diag);
        !          1035:          break;
        !          1036:        }
        !          1037:        return 0;
        !          1038:     }
        !          1039:     
        !          1040:     /* Clear mailboxes */
        !          1041:     memset(&(host->mb), 0, sizeof(host->mb));
        !          1042: 
        !          1043:     /* Execute init command */
        !          1044:     any2scsi((unchar *) &(init_cmd.mailboxes), (int) &(host->mb));
        !          1045:     if (!command_out(host, (unchar *) &init_cmd, sizeof(init_cmd)))  {
        !          1046:        printk("wd7000_init: adapter initialization failed.\n"); 
        !          1047:        return 0;
        !          1048:     }
        !          1049:     WAIT(host->iobase+ASC_STAT, ASC_STATMASK, ASC_INIT, 0);
        !          1050: 
        !          1051:     if (request_irq(host->irq, wd7000_intr_handle, SA_INTERRUPT, "wd7000")) {
        !          1052:        printk("wd7000_init: can't get IRQ %d.\n", host->irq);
        !          1053:        return 0;
        !          1054:     }
        !          1055:     if (request_dma(host->dma,"wd7000"))  {
        !          1056:        printk("wd7000_init: can't get DMA channel %d.\n", host->dma);
        !          1057:        free_irq(host->irq);
        !          1058:        return 0;
        !          1059:     }
        !          1060:     wd7000_enable_dma(host);
        !          1061:     wd7000_enable_intr(host);
        !          1062: 
        !          1063:     if (!wd7000_diagnostics(host,ICB_DIAG_FULL))  {
        !          1064:        free_dma(host->dma);
        !          1065:        free_irq(host->irq);
        !          1066:        return 0;
        !          1067:     }
        !          1068: 
        !          1069:     return 1;
        !          1070: 
        !          1071:   fail:
        !          1072:     printk("wd7000_init: WAIT timed out.\n"); 
        !          1073:     return 0;                                  /* 0 = not ok */
        !          1074: }
        !          1075: 
        !          1076: 
        !          1077: void wd7000_revision(Adapter *host)
        !          1078: {
        !          1079:     static IcbRevLvl icb = {ICB_OP_GET_REVISION};
        !          1080: 
        !          1081:     icb.phase = 1;
        !          1082:     /*
        !          1083:      * Like diagnostics, this is only done at init time, in fact, from
        !          1084:      * wd7000_detect, so there should be OGMBs available.  If it fails,
        !          1085:      * the only damage will be that the revision will show up as 0.0,
        !          1086:      * which in turn means that scatter/gather will be disabled.
        !          1087:      */
        !          1088:     mail_out(host, (struct scb *) &icb);
        !          1089:     while (icb.phase)
        !          1090:        barrier(); /* wait for completion */
        !          1091:     host->rev1 = icb.primary;
        !          1092:     host->rev2 = icb.secondary;
        !          1093: }
        !          1094: 
        !          1095: 
        !          1096: int wd7000_detect(Scsi_Host_Template * tpnt)
        !          1097: /* 
        !          1098:  *  Returns the number of adapters this driver is supporting.
        !          1099:  *
        !          1100:  *  The source for hosts.c says to wait to call scsi_register until 100%
        !          1101:  *  sure about an adapter.  We need to do it a little sooner here; we
        !          1102:  *  need the storage set up by scsi_register before wd7000_init, and
        !          1103:  *  changing the location of an Adapter structure is more trouble than
        !          1104:  *  calling scsi_unregister.
        !          1105:  *
        !          1106:  */
        !          1107: {
        !          1108:     int i,j, present = 0;
        !          1109:     const Config *cfg;
        !          1110:     const Signature *sig;
        !          1111:     Adapter *host = NULL;
        !          1112:     struct Scsi_Host *sh;
        !          1113: 
        !          1114:     tpnt->proc_dir = &proc_scsi_wd7000;
        !          1115: 
        !          1116:     /* Set up SCB free list, which is shared by all adapters */
        !          1117:     init_scbs();
        !          1118: 
        !          1119:     cfg = configs;
        !          1120:     for (i = 0; i < NUM_CONFIGS; i++)  {
        !          1121:        sig = signatures;
        !          1122:        for (j = 0; j < NUM_SIGNATURES; j++)  {
        !          1123:            if (!memcmp(cfg->bios+sig->ofs, sig->sig, sig->len))  {
        !          1124:                /* matched this one */
        !          1125: #ifdef DEBUG
        !          1126:                printk("WD-7000 SST BIOS detected at %04X: checking...\n",
        !          1127:                       (int) cfg->bios);
        !          1128: #endif
        !          1129:                /*
        !          1130:                 *  We won't explicitly test the configuration (in this
        !          1131:                 *  version); instead, we'll just see if it works to
        !          1132:                 *  setup the adapter; if it does, we'll use it.
        !          1133:                 */
        !          1134:                if (check_region(cfg->iobase, 4))  {  /* ports in use */
        !          1135:                    printk("IO %xh already in use.\n", host->iobase);
        !          1136:                    continue;
        !          1137:                }
        !          1138:                /*
        !          1139:                 *  We register here, to get a pointer to the extra space,
        !          1140:                 *  which we'll use as the Adapter structure (host) for
        !          1141:                 *  this adapter.  It is located just after the registered
        !          1142:                 *  Scsi_Host structure (sh), and is located by the empty
        !          1143:                 *  array hostdata.
        !          1144:                 */
        !          1145:                sh = scsi_register(tpnt, sizeof(Adapter) );
        !          1146:                host = (Adapter *) sh->hostdata;
        !          1147: #ifdef DEBUG
        !          1148:                printk("wd7000_detect: adapter allocated at %06x\n",
        !          1149:                       (int)host);
        !          1150: #endif
        !          1151:                memset( host, 0, sizeof(Adapter) );
        !          1152:                host->sh = sh;
        !          1153:                host->irq = cfg->irq;
        !          1154:                host->iobase = cfg->iobase;
        !          1155:                host->dma = cfg->dma;
        !          1156:                irq2host[host->irq] = host;
        !          1157: 
        !          1158:                if (!wd7000_init(host))  {  /* Initialization failed */
        !          1159:                    scsi_unregister (sh);
        !          1160:                    continue;
        !          1161:                }
        !          1162: 
        !          1163:                /*
        !          1164:                 *  OK from here - we'll use this adapter/configuration.
        !          1165:                 */
        !          1166:                wd7000_revision(host);   /* important for scatter/gather */
        !          1167: 
        !          1168:                printk("Western Digital WD-7000 (%d.%d) ",
        !          1169:                       host->rev1, host->rev2);
        !          1170:                printk("using IO %xh IRQ %d DMA %d.\n",
        !          1171:                       host->iobase, host->irq, host->dma);
        !          1172: 
        !          1173:                request_region(host->iobase, 4,"wd7000"); /* Register our ports */
        !          1174:                /*
        !          1175:                 *  For boards before rev 6.0, scatter/gather isn't supported.
        !          1176:                 */
        !          1177:                if (host->rev1 < 6)  sh->sg_tablesize = SG_NONE;
        !          1178: 
        !          1179:                present++;                      /* count it */
        !          1180:                break;                          /* don't try any more sigs */
        !          1181:            }
        !          1182:            sig++;  /* try next signature with this configuration */
        !          1183:        }
        !          1184:        cfg++;      /* try next configuration */
        !          1185:     }
        !          1186: 
        !          1187:     return present;
        !          1188: }
        !          1189: 
        !          1190: 
        !          1191: /*
        !          1192:  *  I have absolutely NO idea how to do an abort with the WD7000...
        !          1193:  */
        !          1194: int wd7000_abort(Scsi_Cmnd * SCpnt)
        !          1195: {
        !          1196:     Adapter *host = (Adapter *) SCpnt->host->hostdata;
        !          1197: 
        !          1198:     if (inb(host->iobase+ASC_STAT) & INT_IM)  {
        !          1199:        printk("wd7000_abort: lost interrupt\n");
        !          1200:        wd7000_intr_handle(host->irq, NULL);
        !          1201:        return SCSI_ABORT_SUCCESS;
        !          1202:     }
        !          1203: 
        !          1204:     return SCSI_ABORT_SNOOZE;
        !          1205: }
        !          1206: 
        !          1207: 
        !          1208: /*
        !          1209:  *  I also have no idea how to do a reset...
        !          1210:  */
        !          1211: int wd7000_reset(Scsi_Cmnd * SCpnt)
        !          1212: {
        !          1213:     return SCSI_RESET_PUNT;
        !          1214: }
        !          1215: 
        !          1216: 
        !          1217: /*
        !          1218:  *  This was borrowed directly from aha1542.c, but my disks are organized
        !          1219:  *  this way, so I think it will work OK.  Someone who is ambitious can
        !          1220:  *  borrow a newer or more complete version from another driver.
        !          1221:  */
        !          1222: int wd7000_biosparam(Disk * disk, kdev_t dev, int* ip)
        !          1223: {
        !          1224:   int size = disk->capacity;
        !          1225:   ip[0] = 64;
        !          1226:   ip[1] = 32;
        !          1227:   ip[2] = size >> 11;
        !          1228: /*  if (ip[2] >= 1024) ip[2] = 1024; */
        !          1229:   return 0;
        !          1230: }
        !          1231: 
        !          1232: #ifdef MODULE
        !          1233: /* Eventually this will go into an include file, but this will be later */
        !          1234: Scsi_Host_Template driver_template = WD7000;
        !          1235: 
        !          1236: #include "scsi_module.c"
        !          1237: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.