FreeBSD/Linux Kernel Cross Reference
sys/i386/isa/aic6360.c

     /*
      * Copyright (c) 1994 Charles Hannum.
      * Copyright (c) 1994 Jarle Greipsland
      * Copyright (c) 1997 Oliver Breuninger (APM modification)
      * All rights reserved.
      *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions
      * are met:
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     * 3. All advertising materials mentioning features or use of this software
     *    must display the following acknowledgement:
     *      This product includes software developed by Jarle Greipsland
     * 4. The name of the author may not be used to endorse or promote products
     *    derived from this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
     * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     * POSSIBILITY OF SUCH DAMAGE.
     */
    
    /*
     * $FreeBSD$
     *
     * Acknowledgements: Many of the algorithms used in this driver are
     * inspired by the work of Julian Elischer (julian@tfs.com) and
     * Charles Hannum (mycroft@duality.gnu.ai.mit.edu).  Thanks a million!
     *
     * Converted from NetBSD to FreeBSD by Jim Babb
     */
    
    /* TODO list:
     * 1) Get the DMA stuff working.
     * 2) Get the iov/uio stuff working. Is this a good thing ???
     * 3) Get the synch stuff working.
     * 4) Rewrite it to use malloc for the acb structs instead of static alloc.?
     */
    
    /*
     * PC-9801-100/AHA-1030P support by URATA S.
     */
    
    /*
     * A few customizable items:
     */
    
    /* The SCSI ID of the host adapter/computer */
    #ifndef AIC_SCSI_HOSTID
    #define AIC_SCSI_HOSTID 7
    #endif
    
    /* Use doubleword transfers to/from SCSI chip.  Note: This requires
     * motherboard support.  Basicly, some motherboard chipsets are able to
     * split a 32 bit I/O operation into two 16 bit I/O operations,
     * transparently to the processor.  This speeds up some things, notably long
     * data transfers.
     */
    #define AIC_USE_DWORDS 0
    
    /* Allow disconnects?  Was mainly used in an early phase of the driver when
     * the message system was very flaky.  Should go away soon.
     */
    #define AIC_ALLOW_DISCONNECT    1
    
    /* Synchronous data transfers? (does not work yet!) XXX */
    #define AIC_USE_SYNCHRONOUS     0       /* Enable/disable (1/0) */
    #define AIC_SYNC_PERIOD         200
    #define AIC_SYNC_REQ_ACK_OFS    8
    
    /* Max attempts made to transmit a message */
    #define AIC_MSG_MAX_ATTEMPT     3 /* Not used now XXX */
    
    /* Use DMA (else we do programmed I/O using string instructions) (not yet!)*/
    #define AIC_USE_EISA_DMA        0
    #define AIC_USE_ISA_DMA         0
    
    /* How to behave on the (E)ISA bus when/if DMAing (on<<4) + off in us */
    #define EISA_BRST_TIM ((15<<4) + 1)     /* 15us on, 1us off */
    
    /* Some spin loop parameters (essentially how long to wait some places)
     * The problem(?) is that sometimes we expect either to be able to transmit a
     * byte or to get a new one from the SCSI bus pretty soon.  In order to avoid
     * returning from the interrupt just to get yanked back for the next byte we
     * may spin in the interrupt routine waiting for this byte to come.  How long?
     * This is really (SCSI) device and processor dependent.  Tuneable, I guess.
     */
    #define AIC_MSGI_SPIN   1       /* Will spinwait upto ?ms for a new msg byte */
   #define AIC_MSGO_SPIN   1
   
   /* Include debug functions?  At the end of this file there are a bunch of
    * functions that will print out various information regarding queued SCSI
    * commands, driver state and chip contents.  You can call them from the
    * kernel debugger.  If you set AIC_DEBUG to 0 they are not included (the
    * kernel uses less memory) but you lose the debugging facilities.
    */
   #define AIC_DEBUG 0
   
   /* End of customizable parameters */
   
   #if AIC_USE_EISA_DMA || AIC_USE_ISA_DMA
   #error "I said not yet! Start paying attention... grumble"
   #endif
   
   #include "opt_ddb.h"
   #include "aic.h"
   #include "apm.h"
   
   #include <sys/param.h>
   #include <sys/kernel.h>
   #include <sys/systm.h>
   #include <sys/malloc.h>
   #include <sys/buf.h>
   #include <scsi/scsiconf.h>
   #include <scsi/scsi_debug.h>
   
   #include <machine/clock.h>
   #if NAPM > 0
   #include <machine/apm_bios.h>
   #endif /* NAPM > 0 */
   #include <i386/isa/isa_device.h>
   
   /* Definitions, most of them has turned out to be unneccesary, but here they
    * are anyway.
    */
   
   /*
    * Generic SCSI messages. For now we reject most of them.
    */
   /* Messages (1 byte) */              /* I/T M(andatory) or (O)ptional */
   #define MSG_CMDCOMPLETE         0x00 /* M/M */
   #define MSG_EXTENDED            0x01 /* O/O */
   #define MSG_SAVEDATAPOINTER     0x02 /* O/O */
   #define MSG_RESTOREPOINTERS     0x03 /* O/O */
   #define MSG_DISCONNECT          0x04 /* O/O */
   #define MSG_INITIATOR_DET_ERR   0x05 /* M/M */
   #define MSG_ABORT               0x06 /* O/M */
   #define MSG_MESSAGE_REJECT      0x07 /* M/M */
   #define MSG_NOOP                0x08 /* M/M */
   #define MSG_PARITY_ERR          0x09 /* M/M */
   #define MSG_LINK_CMD_COMPLETE   0x0a /* O/O */
   #define MSG_LINK_CMD_COMPLETEF  0x0b /* O/O */
   #define MSG_BUS_DEV_RESET       0x0c /* O/M */
   #define MSG_ABORT_TAG           0x0d /* O/O */
   #define MSG_CLEAR_QUEUE         0x0e /* O/O */
   #define MSG_INIT_RECOVERY       0x0f /* O/O */
   #define MSG_REL_RECOVERY        0x10 /* O/O */
   #define MSG_TERM_IO_PROC        0x11 /* O/O */
   
   /* Messages (2 byte) */
   #define MSG_SIMPLE_Q_TAG        0x20 /* O/O */
   #define MSG_HEAD_OF_Q_TAG       0x21 /* O/O */
   #define MSG_ORDERED_Q_TAG       0x22 /* O/O */
   #define MSG_IGN_WIDE_RESIDUE    0x23 /* O/O */
   
   /* Identify message */
   #define MSG_IDENTIFY(lun) ((AIC_ALLOW_DISCONNECT ? 0xc0 : 0x80)|((lun) & 0x7))
   #define MSG_ISIDENT(m)          ((m) & 0x80)
   
   /* Extended messages (opcode) */
   #define MSG_EXT_SDTR            0x01
   
   /* SCSI Status codes */
   #define ST_GOOD                 0x00
   #define ST_CHKCOND              0x02
   #define ST_CONDMET              0x04
   #define ST_BUSY                 0x08
   #define ST_INTERMED             0x10
   #define ST_INTERMED_CONDMET     0x14
   #define ST_RESERVATION_CONFLICT 0x18
   #define ST_CMD_TERM             0x22
   #define ST_QUEUE_FULL           0x28
   
   #define ST_MASK                 0x3e /* bit 0,6,7 is reserved */
   
   /* AIC6360 definitions */
   #ifdef PC98
   #include <i386/isa/aic_98.h>
   #else
   #define SCSISEQ         (iobase + 0x00) /* SCSI sequence control */
   #define SXFRCTL0        (iobase + 0x01) /* SCSI transfer control 0 */
   #define SXFRCTL1        (iobase + 0x02) /* SCSI transfer control 1 */
   #define SCSISIGI        (iobase + 0x03) /* SCSI signal in */
   #define SCSISIGO        (iobase + 0x03) /* SCSI signal out */
   #define SCSIRATE        (iobase + 0x04) /* SCSI rate control */
   #define SCSIID          (iobase + 0x05) /* SCSI ID */
   #define SELID           (iobase + 0x05) /* Selection/Reselection ID */
   #define SCSIDAT         (iobase + 0x06) /* SCSI Latched Data */
   #define SCSIBUS         (iobase + 0x07) /* SCSI Data Bus*/
   #define STCNT0          (iobase + 0x08) /* SCSI transfer count */
   #define STCNT1          (iobase + 0x09)
   #define STCNT2          (iobase + 0x0a)
   #define CLRSINT0        (iobase + 0x0b) /* Clear SCSI interrupts 0 */
   #define SSTAT0          (iobase + 0x0b) /* SCSI interrupt status 0 */
   #define CLRSINT1        (iobase + 0x0c) /* Clear SCSI interrupts 1 */
   #define SSTAT1          (iobase + 0x0c) /* SCSI status 1 */
   #define SSTAT2          (iobase + 0x0d) /* SCSI status 2 */
   #define SCSITEST        (iobase + 0x0e) /* SCSI test control */
   #define SSTAT3          (iobase + 0x0e) /* SCSI status 3 */
   #define CLRSERR         (iobase + 0x0f) /* Clear SCSI errors */
   #define SSTAT4          (iobase + 0x0f) /* SCSI status 4 */
   #define SIMODE0         (iobase + 0x10) /* SCSI interrupt mode 0 */
   #define SIMODE1         (iobase + 0x11) /* SCSI interrupt mode 1 */
   #define DMACNTRL0       (iobase + 0x12) /* DMA control 0 */
   #define DMACNTRL1       (iobase + 0x13) /* DMA control 1 */
   #define DMASTAT         (iobase + 0x14) /* DMA status */
   #define FIFOSTAT        (iobase + 0x15) /* FIFO status */
   #define DMADATA         (iobase + 0x16) /* DMA data */
   #define DMADATAL        (iobase + 0x16) /* DMA data low byte */
   #define DMADATAH        (iobase + 0x17) /* DMA data high byte */
   #define BRSTCNTRL       (iobase + 0x18) /* Burst Control */
   #define DMADATALONG     (iobase + 0x18)
   #define PORTA           (iobase + 0x1a) /* Port A */
   #define PORTB           (iobase + 0x1b) /* Port B */
   #define REV             (iobase + 0x1c) /* Revision (001 for 6360) */
   #define STACK           (iobase + 0x1d) /* Stack */
   #define TEST            (iobase + 0x1e) /* Test register */
   #define ID              (iobase + 0x1f) /* ID register */
   #endif
   
   #define IDSTRING "(C)1991ADAPTECAIC6360           "
   
   /* What all the bits do */
   
   /* SCSISEQ */
   #define TEMODEO         0x80
   #define ENSELO          0x40
   #define ENSELI          0x20
   #define ENRESELI        0x10
   #define ENAUTOATNO      0x08
   #define ENAUTOATNI      0x04
   #define ENAUTOATNP      0x02
   #define SCSIRSTO        0x01
   
   /* SXFRCTL0 */
   #define SCSIEN          0x80
   #define DMAEN           0x40
   #define CHEN            0x20
   #define CLRSTCNT        0x10
   #define SPIOEN          0x08
   #define CLRCH           0x02
   
   /* SXFRCTL1 */
   #define BITBUCKET       0x80
   #define SWRAPEN         0x40
   #define ENSPCHK         0x20
   #define STIMESEL1       0x10
   #define STIMESEL0       0x08
   #define STIMO_256ms     0x00
   #define STIMO_128ms     0x08
   #define STIMO_64ms      0x10
   #define STIMO_32ms      0x18
   #define ENSTIMER        0x04
   #define BYTEALIGN       0x02
   
   /* SCSISIGI */
   #define CDI             0x80
   #define IOI             0x40
   #define MSGI            0x20
   #define ATNI            0x10
   #define SELI            0x08
   #define BSYI            0x04
   #define REQI            0x02
   #define ACKI            0x01
   
   /* Important! The 3 most significant bits of this register, in initiator mode,
    * represents the "expected" SCSI bus phase and can be used to trigger phase
    * mismatch and phase change interrupts.  But more important:  If there is a
    * phase mismatch the chip will not transfer any data!  This is actually a nice
    * feature as it gives us a bit more control over what is happening when we are
    * bursting data (in) through the FIFOs and the phase suddenly changes from
    * DATA IN to STATUS or MESSAGE IN.  The transfer will stop and wait for the
    * proper phase to be set in this register instead of dumping the bits into the
    * FIFOs.
    */
   /* SCSISIGO */
   #define CDO             0x80
   #define CDEXP           (CDO)
   #define IOO             0x40
   #define IOEXP           (IOO)
   #define MSGO            0x20
   #define MSGEXP          (MSGO)
   #define ATNO            0x10
   #define SELO            0x08
   #define BSYO            0x04
   #define REQO            0x02
   #define ACKO            0x01
   
   /* Information transfer phases */
   #define PH_DOUT         (0)
   #define PH_DIN          (IOI)
   #define PH_CMD          (CDI)
   #define PH_STAT         (CDI|IOI)
   #define PH_MSGO         (MSGI|CDI)
   #define PH_MSGI         (MSGI|CDI|IOI)
   
   #define PH_MASK         0xe0
   
   /* Some pseudo phases for getphase()*/
   #define PH_BUSFREE      0x100   /* (Re)Selection no longer valid */
   #define PH_INVALID      0x101   /* (Re)Selection valid, but no REQ yet */
   #define PH_PSBIT        0x100   /* "pseudo" bit */
   
   /* SCSIRATE */
   #define SXFR2           0x40
   #define SXFR1           0x20
   #define SXFR0           0x10
   #define SOFS3           0x08
   #define SOFS2           0x04
   #define SOFS1           0x02
   #define SOFS0           0x01
   
   /* SCSI ID */
   #define OID2            0x40
   #define OID1            0x20
   #define OID0            0x10
   #define OID_S           4       /* shift value */
   #define TID2            0x04
   #define TID1            0x02
   #define TID0            0x01
   #define SCSI_ID_MASK    0x7
   
   /* SCSI selection/reselection ID (both target *and* initiator) */
   #define SELID7          0x80
   #define SELID6          0x40
   #define SELID5          0x20
   #define SELID4          0x10
   #define SELID3          0x08
   #define SELID2          0x04
   #define SELID1          0x02
   #define SELID0          0x01
   
   /* CLRSINT0                      Clears what? (interrupt and/or status bit) */
   #define SETSDONE        0x80
   #define CLRSELDO        0x40    /* I */
   #define CLRSELDI        0x20    /* I+ */
   #define CLRSELINGO      0x10    /* I */
   #define CLRSWRAP        0x08    /* I+S */
   #define CLRSDONE        0x04    /* I+S */
   #define CLRSPIORDY      0x02    /* I */
   #define CLRDMADONE      0x01    /* I */
   
   /* SSTAT0                          Howto clear */
   #define TARGET          0x80
   #define SELDO           0x40    /* Selfclearing */
   #define SELDI           0x20    /* Selfclearing when CLRSELDI is set */
   #define SELINGO         0x10    /* Selfclearing */
   #define SWRAP           0x08    /* CLRSWAP */
   #define SDONE           0x04    /* Not used in initiator mode */
   #define SPIORDY         0x02    /* Selfclearing (op on SCSIDAT) */
   #define DMADONE         0x01    /* Selfclearing (all FIFOs empty & T/C */
   
   /* CLRSINT1                      Clears what? */
   #define CLRSELTIMO      0x80    /* I+S */
   #define CLRATNO         0x40
   #define CLRSCSIRSTI     0x20    /* I+S */
   #define CLRBUSFREE      0x08    /* I+S */
   #define CLRSCSIPERR     0x04    /* I+S */
   #define CLRPHASECHG     0x02    /* I+S */
   #define CLRREQINIT      0x01    /* I+S */
   
   /* SSTAT1                       How to clear?  When set?*/
   #define SELTO           0x80    /* C            select out timeout */
   #define ATNTARG         0x40    /* Not used in initiator mode */
   #define SCSIRSTI        0x20    /* C            RST asserted */
   #define PHASEMIS        0x10    /* Selfclearing */
   #define BUSFREE         0x08    /* C            bus free condition */
   #define SCSIPERR        0x04    /* C            parity error on inbound data */
   #define PHASECHG        0x02    /* C         phase in SCSISIGI doesn't match */
   #define REQINIT         0x01    /* C or ACK     asserting edge of REQ */
   
   /* SSTAT2 */
   #define SOFFSET         0x20
   #define SEMPTY          0x10
   #define SFULL           0x08
   #define SFCNT2          0x04
   #define SFCNT1          0x02
   #define SFCNT0          0x01
   
   /* SCSITEST */
   #define SCTESTU         0x08
   #define SCTESTD         0x04
   #define STCTEST         0x01
   
   /* SSTAT3 */
   #define SCSICNT3        0x80
   #define SCSICNT2        0x40
   #define SCSICNT1        0x20
   #define SCSICNT0        0x10
   #define OFFCNT3         0x08
   #define OFFCNT2         0x04
   #define OFFCNT1         0x02
   #define OFFCNT0         0x01
   
   /* CLRSERR */
   #define CLRSYNCERR      0x04
   #define CLRFWERR        0x02
   #define CLRFRERR        0x01
   
   /* SSTAT4 */
   #define SYNCERR         0x04
   #define FWERR           0x02
   #define FRERR           0x01
   
   /* SIMODE0 */
   #define ENSELDO         0x40
   #define ENSELDI         0x20
   #define ENSELINGO       0x10
   #define ENSWRAP         0x08
   #define ENSDONE         0x04
   #define ENSPIORDY       0x02
   #define ENDMADONE       0x01
   
   /* SIMODE1 */
   #define ENSELTIMO       0x80
   #define ENATNTARG       0x40
   #define ENSCSIRST       0x20
   #define ENPHASEMIS      0x10
   #define ENBUSFREE       0x08
   #define ENSCSIPERR      0x04
   #define ENPHASECHG      0x02
   #define ENREQINIT       0x01
   
   /* DMACNTRL0 */
   #define ENDMA           0x80
   #define B8MODE          0x40
   #define DMA             0x20
   #define DWORDPIO        0x10
   #define WRITE           0x08
   #define INTEN           0x04
   #define RSTFIFO         0x02
   #define SWINT           0x01
   
   /* DMACNTRL1 */
   #define PWRDWN          0x80
   #define ENSTK32         0x40
   #define STK4            0x10
   #define STK3            0x08
   #define STK2            0x04
   #define STK1            0x02
   #define STK0            0x01
   
   /* DMASTAT */
   #define ATDONE          0x80
   #define WORDRDY         0x40
   #define INTSTAT         0x20
   #define DFIFOFULL       0x10
   #define DFIFOEMP        0x08
   #define DFIFOHF         0x04
   #define DWORDRDY        0x02
   
   /* BRSTCNTRL */
   #define BON3            0x80
   #define BON2            0x40
   #define BON1            0x20
   #define BON0            0x10
   #define BOFF3           0x08
   #define BOFF2           0x04
   #define BOFF1           0x02
   #define BOFF0           0x01
   
   /* TEST */
   #define BOFFTMR         0x40
   #define BONTMR          0x20
   #define STCNTH          0x10
   #define STCNTM          0x08
   #define STCNTL          0x04
   #define SCSIBLK         0x02
   #define DMABLK          0x01
   
   
   #define orreg(reg, val)   outb((reg), inb(reg)| (val))
   #define andreg(reg, val)  outb((reg), inb(reg)& (val))
   #define nandreg(reg, val) outb((reg), inb(reg)&~(val))
   
   
   
   #ifdef DDB
   #define fatal_if_no_DDB()
   #else
   #define fatal_if_no_DDB() panic("panic for historical reasons")
   #endif
   
   typedef u_long physaddr;
   
   struct aic_dma_seg {
           physaddr        addr;
           long            len;
   };
   
   #define DELAYCOUNT      16
   
   #define FUDGE(X)        ((X)>>1)        /* get 1 ms spincount */
   #define MINIFUDGE(X)    ((X)>>4)        /* get (approx) 125us spincount */
   #define AIC_NSEG        16
   #define NUM_CONCURRENT  7       /* Only one per target for now */
   
   /*
    * ACB. Holds additional information for each SCSI command Comments: We
    * need a separate scsi command block because we may need to overwrite it
    * with a request sense command.  Basicly, we refrain from fiddling with
    * the scsi_xfer struct (except do the expected updating of return values).
    * We'll generally update: xs->{flags,resid,error,sense,status} and
    * occasionally xs->retries.
    */
   
   struct acb {
           TAILQ_ENTRY(acb) chain;
           struct scsi_xfer *xs;   /* SCSI xfer ctrl block from above */
           int             flags;  /* Status */
   #define ACB_FREE        0x00
   #define ACB_ACTIVE      0x01
   #define ACB_DONE        0x04
   #define ACB_CHKSENSE    0x08
   /*      struct aic_dma_seg dma[AIC_NSEG]; */  /* Physical addresses+len */
           struct scsi_generic cmd;  /* SCSI command block */
           int      clen;
           char    *daddr;         /* Saved data pointer */
           int      dleft;         /* Residue */
           int      stat;          /* SCSI status byte */
   };
   
   /*
    * Some info about each (possible) target on the SCSI bus.  This should
    * probably have been a "per target+lunit" structure, but we'll leave it at
    * this for now.  Is there a way to reliably hook it up to sc->fordriver??
    */
   struct aic_tinfo {
           int     cmds;           /* #commands processed */
           int     dconns;         /* #disconnects */
           int     touts;          /* #timeouts */
           int     perrs;          /* #parity errors */
           int     senses;         /* #request sense commands sent */
           ushort  lubusy;         /* What local units/subr. are busy? */
           u_char  flags;
   #define NEED_TO_RESET   0x01    /* Should send a BUS_DEV_RESET */
   #define DO_NEGOTIATE    0x02    /* (Re)Negotiate synchronous options */
   #define TARGET_BUSY     0x04    /* Target is busy, i.e. cmd in progress */
           u_char  persgst;        /* Period suggestion */
           u_char  offsgst;        /* Offset suggestion */
           u_char  syncdata;       /* True negotiated synch parameters */
   };
   
   /* Register a linenumber (for debugging) */
   #if AIC_DEBUG
   #define LOGLINE(p) \
           do {                                    \
                   p->history[p->hp] = __LINE__;   \
                   p->hp = ++p->hp % AIC_HSIZE;    \
           } while (0)
   #else
   #define LOGLINE(p)
   #endif
   
   static struct aic_data { /* One of these per adapter */
           u_short         iobase;         /* Base I/O port */
           struct scsi_link sc_link;       /* prototype for subdevs */
           int             aic_int;        /* IRQ on the EISA bus */
           int             aic_dma;        /* DRQ on the EISA bus */
           /* Lists of command blocks */
           TAILQ_HEAD(acb_list, acb) free_list, ready_list, nexus_list;
           struct acb *nexus;      /* current command */
           /* Command blocks and target info */
           struct acb acb[NUM_CONCURRENT];
           struct aic_tinfo tinfo[8];
           /* Data about the current nexus (updated for every cmd switch) */
           u_char  *dp;            /* Current data pointer */
           int      dleft;         /* Data left to transfer */
           /* Adapter state */
           short    phase;         /* Copy of what bus phase we are in */
           short    prevphase;     /* Copy of what bus phase we were in */
           short    state;         /* State applicable to the adapter */
   #define AIC_IDLE        0x01
   #define AIC_TMP_UNAVAIL 0x02    /* Don't accept SCSI commands */
   #define AIC_SELECTING   0x03    /* SCSI command is arbiting  */
   #define AIC_RESELECTED  0x04    /* Has been reselected */
   #define AIC_HASNEXUS    0x05    /* Actively using the SCSI bus */
   #define AIC_CLEANING    0x06
   #define AIC_SUSPEND     0x07    /* Suspend mode (APM) */
           short    flags;
   #define AIC_DROP_MSGI   0x01    /* Discard all msgs (parity err detected) */
   #define AIC_DOINGDMA    0x02    /* The FIFO data path is active! */
   #define AIC_BUSFREE_OK  0x04    /* Bus free phase is OK. */
   #define AIC_SYNCHNEGO   0x08    /* Synch negotiation in progress. */
   #define AIC_BLOCKED     0x10    /* Don't schedule new scsi bus operations */
           /* Debugging stuff */
   #define AIC_HSIZE 8
           short   history[AIC_HSIZE]; /* Store line numbers here. */
           short   hp;
           u_char  progress;       /* Set if interrupt has achieved progress */
           /* Message stuff */
           u_char  msgpriq;        /* One or more messages to send (encoded) */
           u_char  msgout;         /* What message is on its way out? */
   #define SEND_DEV_RESET          0x01
   #define SEND_PARITY_ERROR       0x02
   #define SEND_ABORT              0x04
   #define SEND_REJECT             0x08
   #define SEND_INIT_DET_ERR       0x10
   #define SEND_IDENTIFY           0x20
   #define SEND_SDTR               0x40
   #define AIC_MAX_MSG_LEN 8
           u_char  omess[AIC_MAX_MSG_LEN]; /* Scratch area for messages */
           u_char  *omp;           /* Message pointer (for multibyte messages) */
           u_char  omlen;
           u_char  imess[AIC_MAX_MSG_LEN + 1];
           u_char  *imp;           /* Message pointer (for multibyte messages) */
           u_char  imlen;
   #ifdef PC98
           int             *aicport;       /* I/O port information */
   #endif
   #if NAPM > 0
           struct apmhook s_hook;  /* reconfiguration support */
           struct apmhook r_hook;  /* reconfiguration support */
   #endif /* NAPM > 0 */
   
   } *aicdata[NAIC];
   
   #define AIC_SHOWACBS 0x01
   #define AIC_SHOWINTS 0x02
   #define AIC_SHOWCMDS 0x04
   #define AIC_SHOWMISC 0x08
   #define AIC_SHOWTRAC 0x10
   #define AIC_SHOWSTART 0x20
   static int aic_debug = 0; /* AIC_SHOWSTART|AIC_SHOWMISC|AIC_SHOWTRAC; */
   
   #if AIC_DEBUG
   #define AIC_ACBS(str)  do {if (aic_debug & AIC_SHOWACBS) printf str;} while (0)
   #define AIC_MISC(str)  do {if (aic_debug & AIC_SHOWMISC) printf str;} while (0)
   #define AIC_INTS(str)  do {if (aic_debug & AIC_SHOWINTS) printf str;} while (0)
   #define AIC_TRACE(str) do {if (aic_debug & AIC_SHOWTRAC) printf str;} while (0)
   #define AIC_CMDS(str)  do {if (aic_debug & AIC_SHOWCMDS) printf str;} while (0)
   #define AIC_START(str) do {if (aic_debug & AIC_SHOWSTART) printf str;}while (0)
   #else
   #define AIC_ACBS(str)
   #define AIC_MISC(str)
   #define AIC_INTS(str)
   #define AIC_TRACE(str)
   #define AIC_CMDS(str)
   #define AIC_START(str)
   #endif
   
   static int      aicprobe        __P((struct isa_device *));
   static int      aicattach       __P((struct isa_device *));
   #if NAPM > 0
   static int      aic_suspend     __P((struct aic_data *));
   static int      aic_resume      __P((struct aic_data *));
   #endif /* NAPM > 0 */
   static void     aic_minphys     __P((struct buf *));
   static u_int32_t        aic_adapter_info __P((int));
   static void     aic_init        __P((struct aic_data *));
   static int      aic_find        __P((struct aic_data *));
   static void     aic_done        __P((struct acb *));
   static void     aic_dataout     __P((struct aic_data *aic));
   static void     aic_datain      __P((struct aic_data *aic));
   static ointhand2_t      aicintr;
   static int32_t  aic_scsi_cmd    __P((struct scsi_xfer *));
   static int      aic_poll        __P((struct aic_data *aic, struct acb *));
   void    aic_add_timeout __P((struct acb *, int));
   void    aic_remove_timeout __P((struct acb *));
   static  void    aic6360_reset   __P((struct aic_data *aic));
   static __inline u_short aicphase        __P((struct aic_data *aic));
   static  void    aic_msgin       __P((struct aic_data *aic));
   static  void    aic_msgout      __P((struct aic_data *aic));
   static timeout_t aic_timeout;
   static void     aic_sched       __P((struct aic_data *));
   static void     aic_scsi_reset  __P((struct aic_data *));
   #if AIC_DEBUG
   void    aic_print_active_acb    __P((void));
   void    aic_dump6360            __P((void));
   void    aic_dump_driver         __P((void));
   #endif
   #ifdef SCSI_DETACH
   static void     aicdetach       __P((struct isa_device *dev));
   #endif
   
   /* Linkup to the rest of the kernel */
   struct isa_driver aicdriver = {
       aicprobe, aicattach, "aic"
   };
   
   static int aicunit = 0;
   
   static struct scsi_adapter aic_switch = {
           aic_scsi_cmd,
           aic_minphys,
           0,
           0,
           aic_adapter_info,
           "aic"
           ,0 , 0
   };
   
   static struct scsi_device aic_dev = {
           NULL,                   /* Use default error handler */
           NULL,                   /* have a queue, served by this */
           NULL,                   /* have no async handler */
           NULL,                   /* Use default 'done' routine */
           "aic",
           0
   };
   
   
   /* PCCARD suport */
   #include "card.h"
   #if NCARD > 0
   #include <sys/select.h>
   #include <sys/module.h>
   #include <pccard/cardinfo.h>
   #include <pccard/slot.h>
   
   static int      aic_card_intr   __P((struct pccard_devinfo *));
   static int      aicinit         __P((struct pccard_devinfo *));
   static void     aicunload       __P((struct pccard_devinfo *));
   
   PCCARD_MODULE(aic, aicinit, aicunload, aic_card_intr, 0, bio_imask);
   
   /*
    * Initialize the device - called from Slot manager.
    */
   int
   aicinit(struct pccard_devinfo *devi)
   {
           static int already_aicinit[NAIC];
   
           /* validate unit number */
           if (devi->isahd.id_unit >= NAIC)
                   return(ENODEV);
           /* Make sure it isn't already initialised */
           if (already_aicinit[devi->isahd.id_unit] == 1) {
                   if (aicattach(&devi->isahd) == 0)
                           return(ENXIO);
                   return(0);
           }
           /*
            * Probe the device. If a value is returned, the
            * device was found at the location.
            */
           if (aicprobe(&devi->isahd) == 0)
                   return(ENXIO);
   
           if (aicattach(&devi->isahd) == 0)
                   return(ENXIO);
           already_aicinit[devi->isahd.id_unit] = 1;
           return(0);
   }
   
   /*
    * aicunload - unload the driver and clear the table.
    * XXX TODO:
    * This is called usually when the card is ejected, but
    * can be caused by the modunload of a controller driver.
    * The idea is reset the driver's view of the device
    * and ensure that any driver entry points such as
    * read and write do not hang.
    */
   static void
   aicunload(struct pccard_devinfo *devi)
   {
           printf("aic%d: unload\n", devi->isahd.id_unit);
   #if 0
           aicstop(devi->isahd.id_unit);
   #endif
   #ifdef SCSI_DETACH
           aicdetach(&devi->isahd);
   #endif
   }
   
   /*
    * card_intr - Shared interrupt called from front end of PC-Card handler.
    */
   static int
   aic_card_intr(struct pccard_devinfo *devi)
   {
           aicintr(devi->isahd.id_unit);
           return(1);
   }
   #endif /* NCARD > 0 */ 
   
   /*
    * INITIALIZATION ROUTINES (probe, attach ++)
    */
   
   /*
    * aicprobe: probe for AIC6360 SCSI-controller
    * returns non-zero value if a controller is found.
    */
   static int
   aicprobe(dev)
           struct isa_device *dev;
   {
           struct aic_data *aic;
   #if NCARD > 0
           int     unit = dev->id_unit;
           int     aic_reg_drv[NAIC];
   #else
           int     unit = aicunit;
   #endif
   
           if (unit >= NAIC) {
                   printf("aic%d: unit number too high\n", unit);
                   return 0;
           }
           dev->id_unit = unit;
   
   #if NCARD > 0
           if (!aic_reg_drv[unit])
                   aic_reg_drv[unit] = 1;
   #endif
   
           /*
            * Allocate a storage area for us
            */
           if (aicdata[unit]) {
                  printf("aic%d: memory already allocated\n", unit);
                  return 0;
           }
           aic = malloc(sizeof(struct aic_data), M_TEMP, M_NOWAIT);
           if (!aic) {
                  printf("aic%d: cannot malloc!\n", unit);
                  return 0;
           }
           bzero(aic, sizeof(struct aic_data));
           aicdata[unit] = aic;
           aic->iobase = dev->id_iobase;
   #ifdef PC98
           if (AIC_TYPE98(dev->id_flags) == AIC98_100) {
                   /* PC-9801-100 */
                   aic->aicport = aicport_100;
           } else {
                   /* generic card */
                   aic->aicport = aicport_generic;
           }
   #endif
   
           if (aic_find(aic) != 0) {
                   aicdata[unit] = NULL;
                   free(aic, M_TEMP);
                   return 0;
           }
           aicunit++;
   
   #ifdef PC98
           if (AIC_TYPE98(dev->id_flags) == AIC98_100)
                   return 0x40;
   #endif
           return 0x20;
   }
   
   #if NAPM > 0
   static int
   aic_suspend(aic)
           struct aic_data *aic;
   {
           AIC_TRACE(("Suspend aic:\n"));
           printf ("aic: suspend\n");
           aic->state = AIC_SUSPEND;
           return 0;
   }
   
   static int
   aic_resume(aic)
           struct aic_data *aic;
   {
           AIC_TRACE(("Resume aic:\n"));
           printf ("aic: resume\n");
           aic->state = 0;
           aic_init(aic);
   /*
           aic6360_reset(aic);
           aic_scsi_reset(aic);
   */
           return 0;
   }
   #endif /* NAPM > 0 */
   
   /* Do the real search-for-device.
    * Prerequisite: aic->iobase should be set to the proper value
    */
   static int
   aic_find(aic)
           struct aic_data *aic;
   {
           u_short iobase = aic->iobase;
           char chip_id[sizeof(IDSTRING)]; /* For chips that support it */
           int i;
   
           /* Remove aic6360 from possible powerdown mode */
           outb(DMACNTRL0, 0);
   
           /* Thanks to mark@aggregate.com for the new method for detecting
            * whether the chip is present or not.  Bonus: may also work for
            * the AIC-6260!
            */
           AIC_TRACE(("aic: probing for aic-chip at port 0x%x\n",(int)iobase));
           /*
            * Linux also init's the stack to 1-16 and then clears it,
            *  6260's don't appear to have an ID reg - mpg
            */
           /* Push the sequence 0,1,..,15 on the stack */
   #define STSIZE 16
           outb(DMACNTRL1, 0);     /* Reset stack pointer */
           for (i = 0; i < STSIZE; i++)
                   outb(STACK, i);
   
           /* See if we can pull out the same sequence */
           outb(DMACNTRL1, 0);
           for (i = 0; i < STSIZE && inb(STACK) == i; i++)
                   ;
           if (i != STSIZE) {
                   AIC_START(("STACK futzed at %d.\n", i));
                   return ENXIO;
           }
   
           /* See if we can pull the id string out of the ID register,
            * now only used for informational purposes.
            */
           bzero(chip_id, sizeof(chip_id));
           insb(ID, chip_id, sizeof(IDSTRING)-1);
           AIC_START(("AIC found at 0x%x ", (int)aic->iobase));
           AIC_START(("ID: %s ",chip_id));
           AIC_START(("chip revision %d\n",(int)inb(REV)));
           return 0;
   }
   
   #ifdef SCSI_DETACH
   static void
   aicdetach(dev)
           struct isa_device *dev;
   {
           int unit = dev->id_unit;
           struct aic_data *aic = aicdata[unit];
           struct scsibus_data *scbus;
   
           scbus =
            (struct scsibus_data *)scsi_extend_get(aicdata[unit]->sc_link.scsibus);
           scsi_detachdev(scbus);
   }
   #endif /* SCSI_DETACH */
   
   /*
    * Attach the AIC6360, fill out some high and low level data structures
    */
   static int
   aicattach(dev)
           struct isa_device *dev;
   {
           int unit = dev->id_unit;
           struct aic_data *aic = aicdata[unit];
           struct scsibus_data *scbus;
   
           AIC_TRACE(("aicattach\n"));
           dev->id_ointr = aicintr;
           aic->state = 0;
           aic_scsi_reset(aic);
           aic_init(aic);  /* Init chip and driver */
   
           /*
            * Fill in the prototype scsi_link
            */
           aic->sc_link.adapter_unit = unit;
           aic->sc_link.adapter_targ = AIC_SCSI_HOSTID;
           aic->sc_link.adapter_softc = aic;
           aic->sc_link.adapter = &aic_switch;
           aic->sc_link.device = &aic_dev;
   
   #if NAPM > 0
           aic->s_hook.ah_fun   = aic_suspend;
           aic->s_hook.ah_arg   = (void *) aic;
           aic->s_hook.ah_name  = "Adaptec AHA1520/AIC6369";
           aic->s_hook.ah_order = APM_MID_ORDER;
           apm_hook_establish(APM_HOOK_SUSPEND, &aic->s_hook);
           aic->r_hook.ah_fun   = aic_resume;
           aic->r_hook.ah_arg   = (void *) aic;
           aic->r_hook.ah_name  = "Adaptec AHA1520/AIC6369";
           aic->r_hook.ah_order = APM_MID_ORDER;
           apm_hook_establish(APM_HOOK_RESUME, &aic->r_hook);
   #endif /* NAPM > 0 */
   
           /*
            * Prepare the scsibus_data area for the upperlevel
            * scsi code.
            */
           scbus = scsi_alloc_bus();
           if(!scbus)
                   return 0;
           scbus->adapter_link = &aic->sc_link;
   
           /*
           * ask the adapter what subunits are present
           */
          scsi_attachdevs(scbus);
  
          return 1;
  }
  
  /* Initialize AIC6360 chip itself
   * The following conditions should hold:
   * aicprobe should have succeeded, i.e. the iobase address in aic_data must
   * be valid.
   */
  static void
  aic6360_reset(aic)
          struct aic_data *aic;
  {
          u_short iobase = aic->iobase;
  
          outb(SCSITEST, 0);      /* Doc. recommends to clear these two */
          outb(TEST, 0);          /* registers before operations commence */
  
          /* Reset SCSI-FIFO and abort any transfers */
          outb(SXFRCTL0, CHEN|CLRCH|CLRSTCNT);
  
          /* Reset DMA-FIFO */
          outb(DMACNTRL0, RSTFIFO);
          outb(DMACNTRL1, 0);
  
          outb(SCSISEQ, 0);       /* Disable all selection features */
          outb(SXFRCTL1, 0);
  
          outb(SIMODE0, 0x00);            /* Disable some interrupts */
          outb(CLRSINT0, 0x7f);   /* Clear a slew of interrupts */
  
          outb(SIMODE1, 0x00);            /* Disable some more interrupts */
          outb(CLRSINT1, 0xef);   /* Clear another slew of interrupts */
  
          outb(SCSIRATE, 0);      /* Disable synchronous transfers */
  
          outb(CLRSERR, 0x07);    /* Haven't seen ant errors (yet) */
  
          outb(SCSIID, AIC_SCSI_HOSTID << OID_S); /* Set our SCSI-ID */
          outb(BRSTCNTRL, EISA_BRST_TIM);
  }
  
  /* Pull the SCSI RST line for 500 us */
  static void
  aic_scsi_reset(aic)
          struct aic_data *aic;
  {
          u_short iobase = aic->iobase;
  
          AIC_TRACE(("aic_scsi_reset:\n"));
          outb(SCSISEQ, SCSIRSTO);
          DELAY(500);
          outb(SCSISEQ, 0);
          DELAY(50);
  }
  
  /*
   * Initialize aic SCSI driver, also (conditonally) reset the SCSI bus.
   * The reinitialization is still buggy (e.g. on SCSI resets).
   */
  static void
  aic_init(aic)
          struct aic_data *aic;
  {
          u_short iobase = aic->iobase;
          struct acb *acb;
          int r;
  
          AIC_TRACE(("aic_init:\n"));
          
                                  /* Reset the SCSI-bus itself */
          aic_scsi_reset(aic);
  
          aic6360_reset(aic);     /* Clean up our own hardware */
  
  /*XXX*/ /* If not the first time (probably a reset condition),
           * we should clean queues with active commands
           */
          if (aic->state == 0) {  /* First time through */
                  TAILQ_INIT(&aic->ready_list);
                  TAILQ_INIT(&aic->nexus_list);
                  TAILQ_INIT(&aic->free_list);
                  aic->nexus = 0;
                  acb = aic->acb;
                  bzero(acb, sizeof(aic->acb));
                  for (r = 0; r < sizeof(aic->acb) / sizeof(*acb); r++) {
                          TAILQ_INSERT_TAIL(&aic->free_list, acb, chain);
                          acb++;
                  }
                  bzero(&aic->tinfo, sizeof(aic->tinfo));
          } else {
                  aic->state = AIC_CLEANING;
                  if (aic->nexus != NULL) {
                          aic->nexus->xs->error = XS_DRIVER_STUFFUP;
                          untimeout(aic_timeout, (caddr_t)aic->nexus,
                                    aic->nexus->xs->timeout_ch);
                          aic_done(aic->nexus);
                  }
                  aic->nexus = NULL;
                  while (acb = aic->nexus_list.tqh_first) {
                          acb->xs->error = XS_DRIVER_STUFFUP;
                          untimeout(aic_timeout, (caddr_t)aic->nexus,
                                    aic->nexus->xs->timeout_ch);
                          aic_done(acb);
                  }
          }
  
          aic->phase = aic->prevphase = PH_INVALID;
          aic->hp = 0;
          for (r = 0; r < 7; r++) {
                  struct aic_tinfo *tp = &aic->tinfo[r];
                  tp->flags = AIC_USE_SYNCHRONOUS ? DO_NEGOTIATE : 0;
                  tp->flags |= NEED_TO_RESET;
                  tp->persgst = AIC_SYNC_PERIOD;
                  tp->offsgst = AIC_SYNC_REQ_ACK_OFS;
                  tp->syncdata = 0;
          }
          aic->state = AIC_IDLE;
          outb(DMACNTRL0, INTEN);
          return;
  }
  
  /*
   * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS
   */
  
  /*
   * Expected sequence:
   * 1) Command inserted into ready list
   * 2) Command selected for execution
   * 3) Command won arbitration and has selected target device
   * 4) Send message out (identify message, eventually also sync.negotiations)
   * 5) Send command
   * 5a) Receive disconnect message, disconnect.
   * 5b) Reselected by target
   * 5c) Receive identify message from target.
   * 6) Send or receive data
   * 7) Receive status
   * 8) Receive message (command complete etc.)
   * 9) If status == SCSI_CHECK construct a synthetic request sense SCSI cmd.
   *    Repeat 2-8 (no disconnects please...)
   */
  
  /*
   * Start a SCSI-command
   * This function is called by the higher level SCSI-driver to queue/run
   * SCSI-commands.
   */
  static int32_t
  aic_scsi_cmd(xs)
          struct scsi_xfer *xs;
  {
          struct scsi_link *sc = xs->sc_link;
          struct aic_data *aic;
          struct acb      *acb;
          int s = 0;
          int flags;
  
          aic = (struct aic_data *)sc->adapter_softc;
          SC_DEBUG(sc, SDEV_DB2, ("aic_scsi_cmd\n"));
          AIC_TRACE(("aic_scsi_cmd\n"));
          AIC_MISC(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
                    sc->target));
  
          flags = xs->flags;
  
          /* Get a aic command block */
          if (!(flags & SCSI_NOMASK)) {
                  /* Critical region */
                  s = splbio();
                  acb = aic->free_list.tqh_first;
                  if (acb) {
                          TAILQ_REMOVE(&aic->free_list, acb, chain);
                  }
                  splx(s);
          } else {
                  acb = aic->free_list.tqh_first;
                  if (acb) {
                          TAILQ_REMOVE(&aic->free_list, acb, chain);
                  }
          }
  
          if (acb == NULL) {
                  xs->error = XS_DRIVER_STUFFUP;
                  AIC_MISC(("TRY_AGAIN_LATER"));
                  return TRY_AGAIN_LATER;
          }
  
          /* Initialize acb */
          acb->flags = ACB_ACTIVE;
          acb->xs = xs;
          bcopy(xs->cmd, &acb->cmd, xs->cmdlen);
          acb->clen = xs->cmdlen;
          acb->daddr = xs->data;
          acb->dleft = xs->datalen;
          acb->stat = 0;
  
          if (!(flags & SCSI_NOMASK))
                  s = splbio();
  
          TAILQ_INSERT_TAIL(&aic->ready_list, acb, chain);
          xs->timeout_ch = timeout(aic_timeout, (caddr_t)acb,
                                   (xs->timeout*hz)/1000);
  
          if (aic->state == AIC_IDLE)
                  aic_sched(aic);
  
          if (!(flags & SCSI_NOMASK)) { /* Almost done. Wait outside */
                  splx(s);
                  AIC_MISC(("SUCCESSFULLY_QUEUED"));
                  return SUCCESSFULLY_QUEUED;
          }
  
          /* Not allowed to use interrupts, use polling instead */
          return aic_poll(aic, acb);
  }
  
  /*
   * Adjust transfer size in buffer structure
   */
  static void
  aic_minphys(bp)
          struct buf *bp;
  {
  
          AIC_TRACE(("aic_minphys\n"));
          if (bp->b_bcount > (AIC_NSEG << PAGE_SHIFT))
                  bp->b_bcount = (AIC_NSEG << PAGE_SHIFT);
  }
  
  
  static u_int32_t
  aic_adapter_info(unit)
          int     unit;
  {
  
          AIC_TRACE(("aic_adapter_info\n"));
          return (2);             /* One outstanding command per target */
  }
  
  /*
   * Used when interrupt driven I/O isn't allowed, e.g. during boot.
   */
  static int
  aic_poll(aic, acb)
          struct aic_data *aic;
          struct acb *acb;
  {
          register u_short iobase = aic->iobase;
          struct scsi_xfer *xs = acb->xs;
          int count = xs->timeout * 10;
  
          AIC_TRACE(("aic_poll\n"));
          while (count) {
                  if (inb(DMASTAT) & INTSTAT)
                          aicintr(xs->sc_link->adapter_unit);
                  if (xs->flags & ITSDONE)
                          break;
                  DELAY(100);
                  count--;
          }
          if (count == 0) {
                  AIC_MISC(("aic_poll: timeout"));
                  aic_timeout((caddr_t)acb);
          }
          if (xs->error)
                  return HAD_ERROR;
          return COMPLETE;
  }
  
  /* LOW LEVEL SCSI UTILITIES */
  
  /* Determine the SCSI bus phase, return either a real SCSI bus phase or some
   * pseudo phase we use to detect certain exceptions.  This one is a bit tricky.
   * The bits we peek at:
   * CDI, MSGI and DI is the 3 SCSI signals determining the bus phase.
   * These should be qualified by REQI high and ACKI low.
   * Also peek at SSTAT0[SELDO|SELDI] to detect a passing BUSFREE condition.
   * No longer detect SCSI RESET or PERR here.  They are tested for separately
   * in the interrupt handler.
   * Note: If an exception occur at some critical time during the phase
   * determination we'll most likely return something wildly erronous....
   */
  static __inline u_short
  aicphase(aic)
          struct aic_data *aic;
  {
          register u_short iobase = aic->iobase;
          register u_char sstat0, sstat1, scsisig;
  
          sstat1 = inb(SSTAT1);   /* Look for REQINIT (REQ asserted) */
          scsisig = inb(SCSISIGI); /* Get the SCSI bus signals */
          sstat0 = inb(SSTAT0);   /* Get the selection valid status bits */
  
          if (!(inb(SSTAT0) & (SELDO|SELDI))) /* Selection became invalid? */
                  return PH_BUSFREE;
  
          /* Selection is still valid */
          if (!(sstat1 & REQINIT))                /* REQ not asserted ? */
                  return PH_INVALID;
  
          /* REQ is asserted, (and ACK is not) */
          return scsisig & PH_MASK;
  }
  
  
  /* Schedule a scsi operation.  This has now been pulled out of the interrupt
   * handler so that we may call it from aic_scsi_cmd and aic_done.  This may
   * save us an unecessary interrupt just to get things going.  Should only be
   * called when state == AIC_IDLE and at bio pl.
   */
  static void
  aic_sched(aic)
          register struct aic_data *aic;
  {
          struct scsi_link *sc;
          struct acb *acb;
          u_short iobase = aic->iobase;
          int t;
          u_char simode0, simode1, scsiseq;
  
          AIC_TRACE(("aic_sched\n"));
          simode0 = ENSELDI;
          simode1 = ENSCSIRST|ENSCSIPERR|ENREQINIT;
          scsiseq = ENRESELI;
          /*
           * Find first acb in rdy queue that is for a target/lunit
           * combinations that is not busy.
           */
          outb(CLRSINT1, CLRSELTIMO|CLRBUSFREE|CLRSCSIPERR);
          for (acb = aic->ready_list.tqh_first; acb; acb = acb->chain.tqe_next) {
                  sc = acb->xs->sc_link;
                  t = sc->target;
                  if (!(aic->tinfo[t].lubusy & (1 << sc->lun))) {
                          TAILQ_REMOVE(&aic->ready_list, acb, chain);
                          aic->nexus = acb;
                          aic->state = AIC_SELECTING;
                          /*
                           * Start selection process. Always enable
                           * reselections.  Note: we don't have a nexus yet, so
                           * cannot set aic->state = AIC_HASNEXUS.
                           */
                          simode0 = ENSELDI|ENSELDO;
                          simode1 = ENSCSIRST|ENSCSIPERR|
                                    ENREQINIT|ENSELTIMO;
                          scsiseq = ENRESELI|ENSELO|ENAUTOATNO;
                          outb(SCSIID, AIC_SCSI_HOSTID << OID_S | t);
                          outb(SXFRCTL1, STIMO_256ms|ENSTIMER);
                          outb(CLRSINT0, CLRSELDO);
                          break;
                  }
  #if AIC_DEBUG
                  else
                          AIC_MISC(("%d:%d busy\n", t, sc->lun));
  #endif
          }
          AIC_MISC(("%sselecting\n",scsiseq&ENSELO?"":"re"));
          outb(SIMODE0, simode0);
          outb(SIMODE1, simode1);
          outb(SCSISEQ, scsiseq);
  }
  
  
  /*
   * POST PROCESSING OF SCSI_CMD (usually current)
   */
  static void
  aic_done(acb)
          struct acb *acb;
  {
          struct scsi_xfer *xs = acb->xs;
          struct scsi_link *sc = xs->sc_link;
          struct aic_data *aic = (struct aic_data *)sc->adapter_softc;
  
          AIC_TRACE(("aic_done "));
  
          /*
           * Now, if we've come here with no error code, i.e. we've kept the
           * initial XS_NOERROR, and the status code signals that we should
           * check sense, we'll need to set up a request sense cmd block and
           * push the command back into the ready queue *before* any other
           * commands for this target/lunit, else we lose the sense info.
           * We don't support chk sense conditions for the request sense cmd.
           */
          if (xs->error == XS_NOERROR && !(acb->flags & ACB_CHKSENSE)) {
                  if ((acb->stat & ST_MASK)==SCSI_CHECK) {
                          struct scsi_sense *ss = (void *)&acb->cmd;
                          AIC_MISC(("requesting sense "));
                          /* First, save the return values */
                          xs->resid = acb->dleft;
                          xs->status = acb->stat;
                          /* Next, setup a request sense command block */
                          bzero(ss, sizeof(*ss));
                          ss->op_code = REQUEST_SENSE;
                          ss->byte2 = sc->lun << 5;
                          ss->length = sizeof(struct scsi_sense_data);
                          acb->clen = sizeof(*ss);
                          acb->daddr = (char *)&xs->sense;
                          acb->dleft = sizeof(struct scsi_sense_data);
                          acb->flags = ACB_ACTIVE|ACB_CHKSENSE;
                          TAILQ_INSERT_HEAD(&aic->ready_list, acb, chain);
                          aic->tinfo[sc->target].lubusy &= ~(1<<sc->lun);
                          aic->tinfo[sc->target].senses++;
                          if (aic->nexus == acb) {
                                  aic->nexus = NULL;
                                  aic->state = AIC_IDLE;
                                  aic_sched(aic);
                          }
                          return;
                  }
          }
  
          if (xs->flags & SCSI_ERR_OK) {
                  xs->resid = 0;
                  xs->error = XS_NOERROR;
          } else if (xs->error == XS_NOERROR && (acb->flags & ACB_CHKSENSE)) {
                  xs->error = XS_SENSE;
          } else {
                  xs->resid = acb->dleft;
          }
          xs->flags |= ITSDONE;
  
  #if AIC_DEBUG
          if (aic_debug & AIC_SHOWMISC) {
                  printf("err=0x%02x ",xs->error);
                  if (xs->error == XS_SENSE)
                          printf("sense=%2x\n", xs->sense.error_code);
          }
          if ((xs->resid || xs->error > XS_SENSE) && aic_debug & AIC_SHOWMISC) {
                  if (xs->resid)
                          printf("aic_done: resid=%d\n", xs->resid);
                  if (xs->error)
                          printf("aic_done: error=%d\n", xs->error);
          }
  #endif
  
          /*
           * Remove the ACB from whatever queue it's on.  We have to do a bit of
           * a hack to figure out which queue it's on.  Note that it is *not*
           * necessary to cdr down the ready queue, but we must cdr down the
           * nexus queue and see if it's there, so we can mark the unit as no
           * longer busy.  This code is sickening, but it works.
           */
          if (acb == aic->nexus) {
  #if NAPM > 0 && NCARD > 0
                  /* SlimSCSI dies without this when it resumes from suspend */
                  aic->nexus = NULL;
  #endif
                  aic->state = AIC_IDLE;
                  aic->tinfo[sc->target].lubusy &= ~(1<<sc->lun);
                  aic_sched(aic);
          } else if (aic->ready_list.tqh_last == &acb->chain.tqe_next) {
                  TAILQ_REMOVE(&aic->ready_list, acb, chain);
          } else {
                  register struct acb *acb2;
                  for (acb2 = aic->nexus_list.tqh_first; acb2;
                      acb2 = acb2->chain.tqe_next)
                          if (acb2 == acb) {
                                  TAILQ_REMOVE(&aic->nexus_list, acb, chain);
                                  aic->tinfo[sc->target].lubusy &= ~(1<<sc->lun);
                                  /* XXXX Should we call aic_sched() here? */
                                  break;
                          }
                  if (acb2)
                          ;
                  else if (acb->chain.tqe_next) {
                          TAILQ_REMOVE(&aic->ready_list, acb, chain);
                  } else {
                          printf("aic%d: can't find matching acb\n", 
                                  xs->sc_link->adapter_unit);
                          Debugger("aic6360");
                          fatal_if_no_DDB();
                  }
          }
          /* Put it on the free list. */
          acb->flags = ACB_FREE;
          TAILQ_INSERT_HEAD(&aic->free_list, acb, chain);
  
          aic->tinfo[sc->target].cmds++;
          scsi_done(xs);
          return;
  }
  
  /*
   * INTERRUPT/PROTOCOL ENGINE
   */
  
  /* The message system:
   * This is a revamped message system that now should easier accomodate new
   * messages, if necessary.
   * Currently we accept these messages:
   * IDENTIFY (when reselecting)
   * COMMAND COMPLETE # (expect bus free after messages marked #)
   * NOOP
   * MESSAGE REJECT
   * SYNCHRONOUS DATA TRANSFER REQUEST
   * SAVE DATA POINTER
   * RESTORE POINTERS
   * DISCONNECT #
   *
   * We may send these messages in prioritized order:
   * BUS DEVICE RESET #           if SCSI_RESET & xs->flags (or in weird sits.)
   * MESSAGE PARITY ERROR         par. err. during MSGI
   * MESSAGE REJECT               If we get a message we don't know how to handle
   * ABORT #                      send on errors
   * INITIATOR DETECTED ERROR     also on errors (SCSI2) (during info xfer)
   * IDENTIFY                     At the start of each transfer
   * SYNCHRONOUS DATA TRANSFER REQUEST    if appropriate
   * NOOP                         if nothing else fits the bill ...
   */
  
  #define aic_sched_msgout(m) \
          do {                            \
                  orreg(SCSISIGO, ATNO);  \
                  aic->msgpriq |= (m);    \
          } while (0)
  
  #define IS1BYTEMSG(m) (((m) != 1 && (m) < 0x20) || (m) >= 0x80)
  #define IS2BYTEMSG(m) (((m) & 0xf0) == 0x20)
  #define ISEXTMSG(m) ((m) == 1)
  /* Precondition:
   * The SCSI bus is already in the MSGI phase and there is a message byte
   * on the bus, along with an asserted REQ signal.
   */
  static void
  aic_msgin(aic)
          register struct aic_data *aic;
  {
          register u_short iobase = aic->iobase;
          int spincount, extlen;
          u_char sstat1;
  
          AIC_TRACE(("aic_msgin "));
          outb(SCSISIGO, PH_MSGI);
          /* Prepare for a new message.  A message should (according to the SCSI
           * standard) be transmitted in one single message_in phase.
           * If we have been in some other phase, then this is a new message.
           */
          if (aic->prevphase != PH_MSGI) {
                  aic->flags &= ~AIC_DROP_MSGI;
                  aic->imlen = 0;
          }
          /*
           * Read a whole message but the last byte.  If we shall reject the
           * message, we shall have to do it, by asserting ATNO, during the
           * message transfer phase itself.
           */
          for (;;) {
                  sstat1 = inb(SSTAT1);
                  /* If parity errors just dump everything on the floor, also
                   * a parity error automatically sets ATNO
                   */
                  if (sstat1 & SCSIPERR) {
                          aic_sched_msgout(SEND_PARITY_ERROR);
                          aic->flags |= AIC_DROP_MSGI;
                  }
                  /*
                   * If we're going to reject the message, don't bother storing
                   * the incoming bytes.  But still, we need to ACK them.
                   */
                  if (!(aic->flags & AIC_DROP_MSGI)) {
                          /* Get next message byte */
                          aic->imess[aic->imlen] = inb(SCSIDAT);
                          /*
                           * This testing is suboptimal, but most messages will
                           * be of the one byte variety, so it should not effect
                           * performance significantly.
                           */
                          if (IS1BYTEMSG(aic->imess[0]))
                                  break;
                          if (IS2BYTEMSG(aic->imess[0]) && aic->imlen == 1)
                                  break;
                          if (ISEXTMSG(aic->imess[0]) && aic->imlen > 0) {
                                  if (aic->imlen == AIC_MAX_MSG_LEN) {
                                          aic->flags |= AIC_DROP_MSGI;
                                          aic_sched_msgout(SEND_REJECT);
                                  }
                                  extlen = aic->imess[1] ? aic->imess[1] : 256;
                                  if (aic->imlen == extlen + 2)
                                          break; /* Got it all */
                          }
                  }
                  /* If we reach this spot we're either:
                   * a) in the middle of a multi-byte message or
                   * b) we're dropping bytes
                   */
                  outb(SXFRCTL0, CHEN|SPIOEN);
                  inb(SCSIDAT); /* Really read it (ACK it, that is) */
                  outb(SXFRCTL0, CHEN);
                  aic->imlen++;
  
                  /*
                   * We expect the bytes in a multibyte message to arrive
                   * relatively close in time, a few microseconds apart.
                   * Therefore we will spinwait for some small amount of time
                   * waiting for the next byte.
                   */
                  spincount = DELAYCOUNT * AIC_MSGI_SPIN;
                  LOGLINE(aic);
                  while (spincount-- && !((sstat1 = inb(SSTAT1)) & REQINIT))
                          ;
                  if (spincount == -1 || sstat1 & (PHASEMIS|BUSFREE))
                          return;
          }
          /* Now we should have a complete message (1 byte, 2 byte and moderately
           * long extended messages).  We only handle extended messages which
           * total length is shorter than AIC_MAX_MSG_LEN.  Longer messages will
           * be amputated.  (Return XS_BOBBITT ?)
           */
          if (aic->state == AIC_HASNEXUS) {
                  struct acb *acb = aic->nexus;
                  struct aic_tinfo *ti = &aic->tinfo[acb->xs->sc_link->target];
                  int offs, per, rate;
  
                  outb(SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE|ENSCSIPERR);
                  switch (aic->imess[0]) {
                  case MSG_CMDCOMPLETE:
                          if (!acb) {
                                  aic_sched_msgout(SEND_ABORT);
                                  printf("aic: CMDCOMPLETE but no command?\n");
                                  break;
                          }
                          if (aic->dleft < 0) {
                                  struct scsi_link *sc = acb->xs->sc_link;
                                  printf("aic: %d extra bytes from %d:%d\n",
                                      -aic->dleft, sc->target, sc->lun);
                                  acb->dleft = 0;
                          }
                          acb->xs->resid = acb->dleft = aic->dleft;
                          aic->flags |= AIC_BUSFREE_OK;
                          untimeout(aic_timeout, (caddr_t)acb,
                                    acb->xs->timeout_ch);
                          aic_done(acb);
                          break;
                  case MSG_MESSAGE_REJECT:
                          if (aic_debug & AIC_SHOWMISC)
                                  printf("aic: our msg rejected by target\n");
                          if (aic->flags & AIC_SYNCHNEGO) {
                                  ti->syncdata = 0;
                                  ti->persgst = ti->offsgst = 0;
                                  aic->flags &= ~AIC_SYNCHNEGO;
                                  ti->flags &= ~DO_NEGOTIATE;
                          }
                          /* Not all targets understand INITIATOR_DETECTED_ERR */
                          if (aic->msgout == SEND_INIT_DET_ERR)
                                  aic_sched_msgout(SEND_ABORT);
                          break;
                  case MSG_NOOP:  /* Will do! Immediately, sir!*/
                          break;  /* Hah, that was easy! */
                  case MSG_DISCONNECT:
                          if (!acb) {
                                  aic_sched_msgout(SEND_ABORT);
                                  printf("aic: nothing to DISCONNECT\n");
                                  break;
                          }
                          ti->dconns++;
                          TAILQ_INSERT_HEAD(&aic->nexus_list, acb, chain);
                          acb = aic->nexus = NULL;
                          aic->state = AIC_IDLE;
                          aic->flags |= AIC_BUSFREE_OK;
                          break;
                  case MSG_SAVEDATAPOINTER:
                          if (!acb) {
                                  aic_sched_msgout(SEND_ABORT);
                                  printf("aic: no DATAPOINTERs to save\n");
                                  break;
                          }
                          acb->dleft = aic->dleft;
                          acb->daddr = aic->dp;
                          break;
                  case MSG_RESTOREPOINTERS:
                          if (!acb) {
                                  aic_sched_msgout(SEND_ABORT);
                                  printf("aic: no DATAPOINTERs to restore\n");
                                  break;
                          }
                          aic->dp = acb->daddr;
                          aic->dleft = acb->dleft;
                          break;
                  case MSG_EXTENDED:
                          switch (aic->imess[2]) {
                          case MSG_EXT_SDTR:
                                  per = aic->imess[3] * 4;
                                  rate = (per + 49 - 100)/50;
                                  offs = aic->imess[4];
                                  if (offs == 0)
                                          ti->syncdata = 0;
                                  else if (rate > 7) {
                                          /* Too slow for aic6360. Do asynch
                                           * instead.  Renegotiate the deal.
                                           */
                                          ti->persgst = 0;
                                          ti->offsgst = 0;
                                          aic_sched_msgout(SEND_SDTR);
                                  } else {
                                          rate = rate<<4 | offs;
                                          ti->syncdata = rate;
                                  }
                                  break;
                          default: /* Extended messages we don't handle */
                                  aic_sched_msgout(SEND_REJECT);
                                  break;
                          }
                          break;
                  default:
                          aic_sched_msgout(SEND_REJECT);
                          break;
                  }
          } else if (aic->state == AIC_RESELECTED) {
                  struct scsi_link *sc;
                  struct acb *acb;
                  u_char selid, lunit;
                  /*
                   * Which target is reselecting us? (The ID bit really)
                   */
                  selid = inb(SELID) & ~(1<<AIC_SCSI_HOSTID);
                  if (MSG_ISIDENT(aic->imess[0])) {       /* Identify? */
                          AIC_MISC(("searching "));
                          /* Search wait queue for disconnected cmd
                           * The list should be short, so I haven't bothered with
                           * any more sophisticated structures than a simple
                           * singly linked list.
                           */
                          lunit = aic->imess[0] & 0x07;
                          for (acb = aic->nexus_list.tqh_first; acb;
                              acb = acb->chain.tqe_next) {
                                  sc = acb->xs->sc_link;
                                  if (sc->lun == lunit &&
                                      selid == (1<<sc->target)) {
                                          TAILQ_REMOVE(&aic->nexus_list, acb,
                                              chain);
                                          break;
                                  }
                          }
                          if (!acb) { /* Invalid reselection! */
                                  aic_sched_msgout(SEND_ABORT);
                                  printf("aic: invalid reselect (idbit=0x%2x)\n",
                                      selid);
                          } else { /* Reestablish nexus */
                                  /* Setup driver data structures and
                                   * do an implicit RESTORE POINTERS
                                   */
                                  aic->nexus = acb;
                                  aic->dp = acb->daddr;
                                  aic->dleft = acb->dleft;
                                  aic->tinfo[sc->target].lubusy |= (1<<sc->lun);
                                  outb(SCSIRATE,aic->tinfo[sc->target].syncdata);
                                  AIC_MISC(("... found acb"));
                                  aic->state = AIC_HASNEXUS;
                          }
                  } else {
                          printf("aic: bogus reselect (no IDENTIFY) %0x2x\n",
                              selid);
                          aic_sched_msgout(SEND_DEV_RESET);
                  }
          } else { /* Neither AIC_HASNEXUS nor AIC_RESELECTED! */
                  printf("aic: unexpected message in; will send DEV_RESET\n");
                  aic_sched_msgout(SEND_DEV_RESET);
          }
          /* Must not forget to ACK the last message byte ... */
          outb(SXFRCTL0, CHEN|SPIOEN);
          inb(SCSIDAT);
          outb(SXFRCTL0, CHEN);
          outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
  }
  
  
  /* The message out (and in) stuff is a bit complicated:
   * If the target requests another message (sequence) without
   * having changed phase in between it really asks for a
   * retransmit, probably due to parity error(s).
   * The following messages can be sent:
   * IDENTIFY        @ These 3 stems from scsi command activity
   * BUS_DEV_RESET   @
   * IDENTIFY + SDTR @
   * MESSAGE_REJECT if MSGI doesn't make sense
   * MESSAGE_PARITY_ERROR if MSGI spots a parity error
   * NOOP if asked for a message and there's nothing to send
   */
  static void
  aic_msgout(aic)
          register struct aic_data *aic;
  {
          register u_short iobase = aic->iobase;
          struct aic_tinfo *ti;
          struct acb *acb;
  
          /* First determine what to send. If we haven't seen a
           * phasechange this is a retransmission request.
           */
          outb(SCSISIGO, PH_MSGO);
          if (aic->prevphase != PH_MSGO) { /* NOT a retransmit */
                  /* Pick up highest priority message */
                  aic->msgout = aic->msgpriq & -aic->msgpriq; /* What message? */
                  aic->omlen = 1; /* "Default" message len */
                  switch (aic->msgout) {
                  case SEND_SDTR: /* Also implies an IDENTIFY message */
                          acb = aic->nexus;
                          ti = &aic->tinfo[acb->xs->sc_link->target];
                          aic->omess[1] = MSG_EXTENDED;
                          aic->omess[2] = 3;
                          aic->omess[3] = MSG_EXT_SDTR;
                          aic->omess[4] = ti->persgst >> 2;
                          aic->omess[5] = ti->offsgst;
                          aic->omlen = 6;
                          /* Fallthrough! */
                  case SEND_IDENTIFY:
                          if (aic->state != AIC_HASNEXUS) {
                                  printf("aic at line %d: no nexus", __LINE__);
                                  Debugger("aic6360");
                                  fatal_if_no_DDB();
                          }
                          acb = aic->nexus;
                          aic->omess[0] = MSG_IDENTIFY(acb->xs->sc_link->lun);
                          break;
                  case SEND_DEV_RESET:
                          aic->omess[0] = MSG_BUS_DEV_RESET;
                          aic->flags |= AIC_BUSFREE_OK;
                          break;
                  case SEND_PARITY_ERROR:
                          aic->omess[0] = MSG_PARITY_ERR;
                          break;
                  case SEND_ABORT:
                          aic->omess[0] = MSG_ABORT;
                          aic->flags |= AIC_BUSFREE_OK;
                          break;
                  case SEND_INIT_DET_ERR:
                          aic->omess[0] = MSG_INITIATOR_DET_ERR;
                          break;
                  case SEND_REJECT:
                          aic->omess[0] = MSG_MESSAGE_REJECT;
                          break;
                  default:
                          aic->omess[0] = MSG_NOOP;
                          break;
                  }
                  aic->omp = aic->omess;
          } else if (aic->omp == &aic->omess[aic->omlen]) {
                  /* Have sent the message at least once, this is a retransmit.
                   */
                  AIC_MISC(("retransmitting "));
                  if (aic->omlen > 1)
                          outb(SCSISIGO, PH_MSGO|ATNO);
          }
          /* else, we're in the middle of a multi-byte message */
          outb(SXFRCTL0, CHEN|SPIOEN);
          outb(DMACNTRL0, INTEN|RSTFIFO);
          outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
          do {
                  LOGLINE(aic);
                  do {
                          aic->phase = aicphase(aic);
                  } while (aic->phase == PH_INVALID);
                  if (aic->phase != PH_MSGO)
                          /* Target left MSGO, possibly to reject our
                           * message
                           */
                          break;
                  /* Clear ATN before last byte */
                  if (aic->omp == &aic->omess[aic->omlen-1])
                          outb(CLRSINT1, CLRATNO);
                  outb(SCSIDAT, *aic->omp++);     /* Send MSG */
                  LOGLINE(aic);
                  while (inb(SCSISIGI) & ACKO)
                          ;
          } while (aic->omp != &aic->omess[aic->omlen]);
          aic->progress = aic->omp != aic->omess;
          /* We get here in two ways:
           * a) phase != MSGO.  Target is probably going to reject our message
           * b) aic->omp == &aic->omess[aic->omlen], i.e. the message has been
           *    transmitted correctly and accepted by the target.
           */
          if (aic->phase == PH_MSGO) {    /* Message accepted by target! */
                  aic->msgpriq &= ~aic->msgout;
                  aic->msgout = 0;
          }
          outb(SXFRCTL0, CHEN);   /* Disable SPIO */
          outb(SIMODE0, 0); /* Setup interrupts before leaving */
          outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
          /* Enabled ints: SCSIPERR, SCSIRSTI (unexpected)
           *               REQINIT (expected) BUSFREE (possibly expected)
           */
  }
  
  /* aic_dataout: perform a data transfer using the FIFO datapath in the aic6360
   * Precondition: The SCSI bus should be in the DOUT phase, with REQ asserted
   * and ACK deasserted (i.e. waiting for a data byte)
   * This new revision has been optimized (I tried) to make the common case fast,
   * and the rarer cases (as a result) somewhat more comlex
   */
  static void
  aic_dataout(aic)
          register struct aic_data *aic;
  {
          register u_short iobase = aic->iobase;
          register u_char dmastat;
          int amount, olddleft = aic->dleft;
  #define DOUTAMOUNT 128          /* Full FIFO */
  
          /* Enable DATA OUT transfers */
          outb(SCSISIGO, PH_DOUT);
          outb(CLRSINT1, CLRPHASECHG);
          /* Clear FIFOs and counters */
          outb(SXFRCTL0, CHEN|CLRSTCNT|CLRCH);
          outb(DMACNTRL0, WRITE|INTEN|RSTFIFO);
          /* Enable FIFOs */
          outb(SXFRCTL0, SCSIEN|DMAEN|CHEN);
          outb(DMACNTRL0, ENDMA|DWORDPIO|WRITE|INTEN);
  
          /* Setup to detect:
           * PHASEMIS & PHASECHG: target has left the DOUT phase
           * SCSIRST: something just pulled the RST line.
           * BUSFREE: target has unexpectedly left the DOUT phase
           */
          outb(SIMODE1, ENPHASEMIS|ENSCSIRST|ENBUSFREE|ENPHASECHG);
  
          /* I have tried to make the main loop as tight as possible.  This
           * means that some of the code following the loop is a bit more
           * complex than otherwise.
           */
          while (aic->dleft) {
                  int xfer;
  
                  LOGLINE(aic);
  
                  for (;;) {
                          dmastat = inb(DMASTAT);
                          if (dmastat & DFIFOEMP)
                                  break;
                          if (dmastat & INTSTAT)
                                  goto phasechange;
                  }
  
                  xfer = min(DOUTAMOUNT, aic->dleft);
  
  #if AIC_USE_DWORDS
                  if (xfer >= 12) {
                          outsl(DMADATALONG, aic->dp, xfer/4);
                          aic->dleft -= xfer & ~3;
                          aic->dp += xfer & ~3;
                          xfer &= 3;
                  }
  #else
                  if (xfer >= 8) {
                          outsw(DMADATA, aic->dp, xfer/2);
                          aic->dleft -= xfer & ~1;
                          aic->dp += xfer & ~1;
                          xfer &= 1;
                  }
  #endif
  
                  if (xfer) {
                          outb(DMACNTRL0, ENDMA|B8MODE|INTEN);
                          outsb(DMADATA, aic->dp, xfer);
                          aic->dleft -= xfer;
                          aic->dp += xfer;
                          outb(DMACNTRL0, ENDMA|DWORDPIO|INTEN);
                  }
          }
  
          /* See the bytes off chip */
          for (;;) {
                  dmastat = inb(DMASTAT);
                  if ((dmastat & DFIFOEMP) && (inb(SSTAT2) & SEMPTY))
                          break;
                  if (dmastat & INTSTAT)
                          goto phasechange;
          }
  
  phasechange:
          /* We now have the data off chip.  */
          outb(SXFRCTL0, CHEN);
  
          if (dmastat & INTSTAT) { /* Some sort of phasechange */
                  register u_char sstat2;
                  /* Stop transfers, do some accounting */
                  amount = inb(FIFOSTAT);
                  sstat2 = inb(SSTAT2);
                  if ((sstat2 & 7) == 0)
                          amount += sstat2 & SFULL ? 8 : 0;
                  else
                          amount += sstat2 & 7;
                  aic->dleft += amount;
                  aic->dp -= amount;
                  AIC_MISC(("+%d ", amount));
          }
  
          outb(DMACNTRL0, RSTFIFO|INTEN);
          LOGLINE(aic);
          while (inb(SXFRCTL0) & SCSIEN)
                  ;
          outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
          /* Enabled ints: BUSFREE, SCSIPERR, SCSIRSTI (unexpected)
           *               REQINIT (expected)
           */
          aic->progress = olddleft != aic->dleft;
          return;
  }
  
  /* aic_datain: perform data transfers using the FIFO datapath in the aic6360
   * Precondition: The SCSI bus should be in the DIN phase, with REQ asserted
   * and ACK deasserted (i.e. at least one byte is ready).
   * For now, uses a pretty dumb algorithm, hangs around until all data has been
   * transferred.  This, is OK for fast targets, but not so smart for slow
   * targets which don't disconnect or for huge transfers.
   */
  static void
  aic_datain(aic)
          register struct aic_data *aic;
  {
          register u_short iobase = aic->iobase;
          register u_char dmastat;
          int olddleft = aic->dleft;
  #define DINAMOUNT 128           /* Default amount of data to transfer */
  
          /* Enable DATA IN transfers */
          outb(SCSISIGO, PH_DIN);
          outb(CLRSINT1, CLRPHASECHG);
          /* Clear FIFOs and counters */
          outb(SXFRCTL0, CHEN|CLRSTCNT|CLRCH);
          outb(DMACNTRL0, INTEN|RSTFIFO);
          /* Enable FIFOs */
          outb(SXFRCTL0, SCSIEN|DMAEN|CHEN);
          outb(DMACNTRL0, ENDMA|DWORDPIO|INTEN);
  
          outb(SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE|ENPHASECHG);
  
          /* We leave this loop if one or more of the following is true:
           * a) phase != PH_DIN && FIFOs are empty
           * b) SCSIRSTI is set (a reset has occurred) or busfree is detected.
           */
          while (aic->dleft) {
                  int done = 0;
                  int xfer;
  
                  LOGLINE(aic);
  
                  /* Wait for fifo half full or phase mismatch */
                  for (;;) {
                          dmastat = inb(DMASTAT);
                          if (dmastat & (DFIFOFULL|INTSTAT))
                                  break;
                  }
  
                  if (dmastat & DFIFOFULL)
                          xfer = DINAMOUNT;
                  else {
                          while ((inb(SSTAT2) & SEMPTY) == 0)
                                  ;
                          xfer = inb(FIFOSTAT);
                          done = 1;
                  }
  
                  xfer = min(xfer, aic->dleft);
  
  #if AIC_USE_DWORDS
                  if (xfer >= 12) {
                          insl(DMADATALONG, aic->dp, xfer/4);
                          aic->dleft -= xfer & ~3;
                          aic->dp += xfer & ~3;
                          xfer &= 3;
                  }
  #else
                  if (xfer >= 8) {
                          insw(DMADATA, aic->dp, xfer/2);
                          aic->dleft -= xfer & ~1;
                          aic->dp += xfer & ~1;
                          xfer &= 1;
                  }
  #endif
  
                  if (xfer) {
                          outb(DMACNTRL0, ENDMA|B8MODE|INTEN);
                          insb(DMADATA, aic->dp, xfer);
                          aic->dleft -= xfer;
                          aic->dp += xfer;
                          outb(DMACNTRL0, ENDMA|DWORDPIO|INTEN);
                  }
  
                  if (done)
                          break;
          }
  
  #if 0
          if (aic->dleft)
                  printf("residual of %d\n", aic->dleft);
  #endif
  
          aic->progress = olddleft != aic->dleft;
          /* Some SCSI-devices are rude enough to transfer more data than what
           * was requested, e.g. 2048 bytes from a CD-ROM instead of the
           * requested 512.  Test for progress, i.e. real transfers.  If no real
           * transfers have been performed (acb->dleft is probably already zero)
           * and the FIFO is not empty, waste some bytes....
           */
          if (!aic->progress) {
                  int extra = 0;
                  LOGLINE(aic);
  
                  for (;;) {
                          dmastat = inb(DMASTAT);
                          if (dmastat & DFIFOEMP)
                                  break;
                          (void) inb(DMADATA); /* Throw it away */
                          extra++;
                  }
  
                  AIC_MISC(("aic: %d extra bytes from %d:%d\n", extra,
                      acb->xs->sc_link->target, acb->xs->sc_link->lun));
                  aic->progress = extra;
          }
  
          /* Stop the FIFO data path */
          outb(SXFRCTL0, CHEN);
  
          outb(DMACNTRL0, RSTFIFO|INTEN);
          /* Come back when REQ is set again */
          outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
          LOGLINE(aic);
  }
  
  
  /*
   * This is the workhorse routine of the driver.
   * Deficiencies (for now):
   * 1) always uses programmed I/O
   * 2) doesn't support synchronous transfers properly (yet)
   */
  
  static void
  aicintr(int unit)
  {
          struct aic_data *aic = aicdata[unit];
          register struct acb *acb;
          register struct scsi_link *sc;
          register u_short iobase = aic->iobase;
          struct aic_tinfo *ti;
          u_char sstat0, sstat1,  sstat2, sxfrctl0;
  
  
          LOGLINE(aic);
          /* Clear INTEN.  This is important if we're running with edge
           * triggered interrupts as we don't guarantee that all interrupts will
           * be served during one single invocation of this routine, i.e. we may
           * need another edge.
           */
          outb(DMACNTRL0, 0);
          AIC_TRACE(("aicintr\n"));
  
          /*
           * 1st check for abnormal conditions, such as reset or parity errors
           */
          sstat1 = inb(SSTAT1);
          AIC_MISC(("s1:0x%02x ", sstat1));
          if (sstat1 & (SCSIRSTI|SCSIPERR)) {
                  if (sstat1 & SCSIRSTI) {
                          printf("aic: reset in -- reinitializing....\n");
                          aic_init(aic); /* Restart everything */
                          LOGLINE(aic);
                          outb(DMACNTRL0, INTEN);
                          return;
                  } else {
                          printf("aic: SCSI bus parity error\n");
                          outb(CLRSINT1, CLRSCSIPERR);
                          if (aic->prevphase == PH_MSGI)
                                  aic_sched_msgout(SEND_PARITY_ERROR);
                          else
                                  aic_sched_msgout(SEND_INIT_DET_ERR);
                  }
          }
  
          /*
           * If we're not already busy doing something test for the following
           * conditions:
           * 1) We have been reselected by something
           * 2) We have selected something successfully
           * 3) Our selection process has timed out
           * 4) This is really a bus free interrupt just to get a new command
           *    going?
           * 5) Spurious interrupt?
           */
          sstat0 = inb(SSTAT0);
          AIC_MISC(("s0:0x%02x ", sstat0));
          if (aic->state != AIC_HASNEXUS) { /* No nexus yet */
                  if (sstat0 & SELDI) {
                          LOGLINE(aic);
                          /* We have been reselected. Things to do:
                           * a) If we're trying to select something ourselves
                           *    back off the current command.
                           * b) "Wait" for a message in phase (IDENTIFY)
                           * c) Call aic_msgin() to get the identify message and
                           *    retrieve the disconnected command from the wait
                           *    queue.
                           */
                          AIC_MISC(("reselect "));
                          /* If we're trying to select a target ourselves,
                           * push our command back into the rdy list.
                           */
                          if (aic->state == AIC_SELECTING) {
                                  AIC_MISC(("backoff selector "));
                                  TAILQ_INSERT_HEAD(&aic->ready_list, aic->nexus,
                                      chain);
                                  aic->nexus = NULL;
                          }
                          aic->state = AIC_RESELECTED;
                          /* Clear interrupts, disable future selection stuff
                           * including select interrupts and timeouts
                           */
                          outb(CLRSINT0, CLRSELDI);
                          outb(SCSISEQ, 0);
                          outb(SIMODE0, 0);
                          /* Setup chip so we may detect spurious busfree
                           * conditions later.
                           */
                          outb(CLRSINT1, CLRBUSFREE);
                          outb(SIMODE1, ENSCSIRST|ENBUSFREE|
                               ENSCSIPERR|ENREQINIT);
                          /* Now, we're expecting an IDENTIFY message. */
                          aic->phase = aicphase(aic);
                          if (aic->phase & PH_PSBIT) {
                                  LOGLINE(aic);
                                  outb(DMACNTRL0, INTEN);
                                  return; /* Come back when REQ is set */
                          }
                          if (aic->phase == PH_MSGI)
                                  aic_msgin(aic); /* Handle identify message */
                          else {
                                  /* Things are seriously fucked up.
                                   * Pull the brakes, i.e. RST
                                   */
                                  printf("aic at line %d: target didn't identify\n", __LINE__);
                                  Debugger("aic6360");
                                  fatal_if_no_DDB();
                                  aic_init(aic);
                                  return;
                          }
                          if (aic->state != AIC_HASNEXUS) {/* IDENTIFY fail?! */
                                  printf("aic at line %d: identify failed\n",
                                      __LINE__);
                                  aic_init(aic);
                                  return;
                          } else {
                                  outb(SIMODE1,
                                      ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
                                  /* Fallthrough to HASNEXUS part of aicintr */
                          }
                  } else if (sstat0 & SELDO) {
                          LOGLINE(aic);
                          /* We have selected a target. Things to do:
                           * a) Determine what message(s) to send.
                           * b) Verify that we're still selecting the target.
                           * c) Mark device as busy.
                           */
                          acb = aic->nexus;
                          if (!acb) {
                                  printf("aic at line %d: missing acb", __LINE__);
                                  Debugger("aic6360");
                                  fatal_if_no_DDB();
                          }
                          sc = acb->xs->sc_link;
                          ti = &aic->tinfo[sc->target];
                          if (acb->xs->flags & SCSI_RESET)
                                  aic->msgpriq = SEND_DEV_RESET;
                          else if (ti->flags & DO_NEGOTIATE)
                                  aic->msgpriq = SEND_IDENTIFY|SEND_SDTR;
                          else
                                  aic->msgpriq = SEND_IDENTIFY;
                          /* Setup chip to enable later testing for busfree
                           * conditions
                           */
                          outb(CLRSINT1, CLRBUSFREE);
                          outb(SCSISEQ, 0); /* Stop selection stuff */
                          nandreg(SIMODE0, ENSELDO); /* No more selectout ints */
                          sstat0 = inb(SSTAT0);
                          if (sstat0 & SELDO) { /* Still selected!? */
                                  outb(SIMODE0, 0);
                                  outb(SIMODE1, ENSCSIRST|ENSCSIPERR|
                                       ENBUSFREE|ENREQINIT);
                                  aic->state = AIC_HASNEXUS;
                                  aic->flags = 0;
                                  aic->prevphase = PH_INVALID;
                                  aic->dp = acb->daddr;
                                  aic->dleft = acb->dleft;
                                  ti->lubusy |= (1<<sc->lun);
                                  AIC_MISC(("select ok "));
                          } else {
                                  /* Has seen busfree since selection, i.e.
                                   * a "spurious" selection. Shouldn't happen.
                                   */
                                  printf("aic: unexpected busfree\n");
                                  acb->xs->error = XS_DRIVER_STUFFUP;
                                  untimeout(aic_timeout, (caddr_t)acb,
                                            acb->xs->timeout_ch);
                                  aic_done(acb);
                          }
                          LOGLINE(aic);
                          outb(DMACNTRL0, INTEN);
                          return;
                  } else if (sstat1 & SELTO) {
                          /* Selection timed out. What to do:
                           * Disable selections out and fail the command with
                           * code XS_TIMEOUT.
                           */
                          acb = aic->nexus;
                          if (!acb) {
                                  printf("aic at line %d: missing acb", __LINE__);
                                  Debugger("aic6360");
                                  fatal_if_no_DDB();
                          }
                          outb(SCSISEQ, ENRESELI|ENAUTOATNP);
                          outb(SXFRCTL1, 0);
                          outb(CLRSINT1, CLRSELTIMO);
                          aic->state = AIC_IDLE;
                          acb->xs->error = XS_TIMEOUT;
                          untimeout(aic_timeout, (caddr_t)acb,
                                    acb->xs->timeout_ch);
                          aic_done(acb);
                          LOGLINE(aic);
                          outb(DMACNTRL0, INTEN);
                          return;
                  } else {
                          /* Assume a bus free interrupt.  What to do:
                           * Start selecting.
                           */
                          if (aic->state == AIC_IDLE)
                                  aic_sched(aic);
  #if AIC_DEBUG
                          else
                                  AIC_MISC(("Extra aic6360 interrupt."));
  #endif
                          LOGLINE(aic);
                          outb(DMACNTRL0, INTEN);
                          return;
                  }
          }
          /* Driver is now in state AIC_HASNEXUS, i.e. we have a current command
           * working the SCSI bus.
           */
          acb = aic->nexus;
          if (aic->state != AIC_HASNEXUS || acb == NULL) {
                  printf("aic: no nexus!!\n");
                  Debugger("aic6360");
                  fatal_if_no_DDB();
          }
  
          /* What sort of transfer does the bus signal? */
          aic->phase = aicphase(aic);
          if (!(aic->phase & PH_PSBIT)) /* not a pseudo phase */
                  outb(SCSISIGO, aic->phase);
          outb(CLRSINT1, CLRPHASECHG);
          /* These interrupts are enabled by default:
           * SCSIRSTI, SCSIPERR, BUSFREE, REQINIT
           */
          switch (aic->phase) {
          case PH_MSGO:
                  LOGLINE(aic);
                  if (aic_debug & AIC_SHOWMISC)
                          printf("PH_MSGO ");
                  aic_msgout(aic);
                  aic->prevphase = PH_MSGO;
                  /* Setup interrupts before leaving */
                  outb(SIMODE0, 0);
                  outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
                  /* Enabled ints: SCSIPERR, SCSIRSTI (unexpected)
                   *               REQINIT (expected) BUSFREE (possibly expected)
                   */
                  break;
          case PH_CMD:            /* CMD phase & REQ asserted */
                  LOGLINE(aic);
                  if (aic_debug & AIC_SHOWMISC)
                          printf("PH_CMD 0x%02x (%d) ",
                                 acb->cmd.opcode, acb->clen);
                  outb(SCSISIGO, PH_CMD);
                  /* Use FIFO for CMDs. Assumes that no cmd > 128 bytes. OK? */
                  /* Clear hostFIFO and enable EISA-hostFIFO transfers */
                  outb(DMACNTRL0, WRITE|RSTFIFO|INTEN);   /* 3(4) */
                  /* Clear scsiFIFO and enable SCSI-interface
                     & hostFIFO-scsiFIFO transfers */
                  outb(SXFRCTL0, CHEN|CLRCH|CLRSTCNT);    /* 4 */
                  outb(SXFRCTL0, SCSIEN|DMAEN|CHEN);      /* 5 */
                  outb(DMACNTRL0, ENDMA|WRITE|INTEN);     /* 3+6 */
                  /* What (polled) interrupts to enable */
                  outb(SIMODE1, ENPHASEMIS|ENSCSIRST|ENBUSFREE|ENSCSIPERR);
                  /* DFIFOEMP is set, FIFO (128 byte) is always big enough */
                  outsw(DMADATA, (short *)&acb->cmd, acb->clen>>1);
  
                  /* Wait for SCSI FIFO to drain */
                  LOGLINE(aic);
                  do {
                          sstat2 = inb(SSTAT2);
                  } while (!(sstat2 & SEMPTY) && !(inb(DMASTAT) & INTSTAT));
                  if (!(inb(SSTAT2) & SEMPTY)) {
                          printf("aic at line %d: SCSI-FIFO didn't drain\n",
                              __LINE__);
                          Debugger("aic6360");
                          fatal_if_no_DDB();
                          acb->xs->error = XS_DRIVER_STUFFUP;
                          untimeout(aic_timeout, (caddr_t)acb,
                                    acb->xs->timeout_ch);
                          aic_done(acb);
                          aic_init(aic);
                          return;
                  }
                  outb(SXFRCTL0, CHEN);   /* Clear SCSIEN & DMAEN */
                  outb(SIMODE0, 0);
                  outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR);
                  LOGLINE(aic);
                  do {
                          sxfrctl0 = inb(SXFRCTL0);
                  } while (sxfrctl0 & SCSIEN && !(inb(DMASTAT) & INTSTAT));
                  if (sxfrctl0 & SCSIEN) {
                          printf("aic at line %d: scsi xfer never finished\n",
                              __LINE__);
                          Debugger("aic6360");
                          fatal_if_no_DDB();
                          acb->xs->error = XS_DRIVER_STUFFUP;
                          untimeout(aic_timeout, (caddr_t)acb,
                                    acb->xs->timeout_ch);
                          aic_done(acb);
                          aic_init(aic);
                          return;
                  }
                  outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
                  /* Enabled ints: BUSFREE, SCSIPERR, SCSIRSTI (unexpected)
                   *               REQINIT (expected)
                   */
                  aic->prevphase = PH_CMD;
                  break;
          case PH_DOUT:
                  LOGLINE(aic);
                  AIC_MISC(("PH_DOUT [%d] ",aic->dleft));
                  aic_dataout(aic);
                  aic->prevphase = PH_DOUT;
                  break;
          case PH_MSGI:
                  LOGLINE(aic);
                  if (aic_debug & AIC_SHOWMISC)
                          printf("PH_MSGI ");
                  aic_msgin(aic);
                  outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
                  aic->prevphase = PH_MSGI;
                  break;
          case PH_DIN:
                  LOGLINE(aic);
                  if (aic_debug & AIC_SHOWMISC)
                          printf("PH_DIN ");
                  aic_datain(aic);
                  aic->prevphase = PH_DIN;
                  break;
          case PH_STAT:
                  LOGLINE(aic);
                  if (aic_debug & AIC_SHOWMISC)
                          printf("PH_STAT ");
                  outb(SCSISIGO, PH_STAT);
                  outb(SXFRCTL0, CHEN|SPIOEN);
                  outb(DMACNTRL0, RSTFIFO|INTEN);
                  outb(SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE|ENSCSIPERR);
                  acb->stat = inb(SCSIDAT);
                  outb(SXFRCTL0, CHEN);
                  if (aic_debug & AIC_SHOWMISC)
                          printf("0x%02x ", acb->stat);
                  outb(SIMODE1, ENSCSIRST|ENBUSFREE|ENSCSIPERR|ENREQINIT);
                  aic->prevphase = PH_STAT;
                  break;
          case PH_INVALID:
                  LOGLINE(aic);
                  break;
          case PH_BUSFREE:
                  LOGLINE(aic);
                  if (aic->flags & AIC_BUSFREE_OK) { /*It's fun the 1st time.. */
                          aic->flags &= ~AIC_BUSFREE_OK;
                  } else {
                          printf("aic at line %d: unexpected busfree phase\n",
                              __LINE__);
                          Debugger("aic6360");
                          fatal_if_no_DDB();
                  }
                  break;
          default:
                  printf("aic at line %d: bogus bus phase\n", __LINE__);
                  Debugger("aic6360");
                  fatal_if_no_DDB();
                  break;
          }
          LOGLINE(aic);
          outb(DMACNTRL0, INTEN);
          return;
  }
  
  static void
  aic_timeout(void *arg1) {
          int s = splbio();
          struct acb *acb = (struct acb *)arg1;
          int     unit;
          struct aic_data *aic;
  
          unit = acb->xs->sc_link->adapter_unit;
          aic = aicdata[unit];
          sc_print_addr(acb->xs->sc_link);
          acb->xs->error = XS_TIMEOUT;
          printf("timed out\n");
  
          aic_done(acb);
          splx(s);
  }
  
  #if AIC_DEBUG
  /*
   * The following functions are mostly used for debugging purposes, either
   * directly called from the driver or from the kernel debugger.
   */
  
  void
  aic_show_scsi_cmd(acb)
          struct acb *acb;
  {
          u_char  *b = (u_char *)&acb->cmd;
          struct scsi_link *sc = acb->xs->sc_link;
          int i;
  
          sc_print_addr(sc);
          if (!(acb->xs->flags & SCSI_RESET)) {
                  for (i = 0; i < acb->clen; i++) {
                          if (i)
                                  printf(",");
                          printf("%x", b[i]);
                  }
                  printf("\n");
          } else
                  printf("RESET\n");
  }
  
  void
  aic_print_acb(acb)
          struct acb *acb;
  {
  
          printf("acb@%x xs=%x flags=%x", acb, acb->xs, acb->flags);
          printf(" daddr=%x dleft=%d stat=%x\n",
              (long)acb->daddr, acb->dleft, acb->stat);
          aic_show_scsi_cmd(acb);
  }
  
  void
  aic_print_active_acb()
  {
          struct acb *acb;
          struct aic_data *aic = aicdata[0];
  
          printf("ready list:\n");
          for (acb = aic->ready_list.tqh_first; acb; acb = acb->chain.tqe_next)
                  aic_print_acb(acb);
          printf("nexus:\n");
          if (aic->nexus)
                  aic_print_acb(aic->nexus);
          printf("nexus list:\n");
          for (acb = aic->nexus_list.tqh_first; acb; acb = acb->chain.tqe_next)
                  aic_print_acb(acb);
  }
  
  void
  aic_dump6360()
  {
          u_short iobase = 0x340;
  
          printf("aic6360: SCSISEQ=%x SXFRCTL0=%x SXFRCTL1=%x SCSISIGI=%x\n",
              inb(SCSISEQ), inb(SXFRCTL0), inb(SXFRCTL1), inb(SCSISIGI));
          printf("         SSTAT0=%x SSTAT1=%x SSTAT2=%x SSTAT3=%x SSTAT4=%x\n",
              inb(SSTAT0), inb(SSTAT1), inb(SSTAT2), inb(SSTAT3), inb(SSTAT4));
          printf("         SIMODE0=%x SIMODE1=%x DMACNTRL0=%x DMACNTRL1=%x DMASTAT=%x\n",
              inb(SIMODE0), inb(SIMODE1), inb(DMACNTRL0), inb(DMACNTRL1),
              inb(DMASTAT));
          printf("         FIFOSTAT=%d SCSIBUS=0x%x\n",
              inb(FIFOSTAT), inb(SCSIBUS));
  }
  
  void
  aic_dump_driver()
  {
          struct aic_data *aic = aicdata[0];
          struct aic_tinfo *ti;
          int i;
  
          printf("nexus=%x phase=%x prevphase=%x\n", aic->nexus, aic->phase,
              aic->prevphase);
          printf("state=%x msgin=%x msgpriq=%x msgout=%x imlen=%d omlen=%d\n",
              aic->state, aic->imess[0], aic->msgpriq, aic->msgout, aic->imlen,
              aic->omlen);
          printf("history:");
          i = aic->hp;
          do {
                  printf(" %d", aic->history[i]);
                  i = (i + 1) % AIC_HSIZE;
          } while (i != aic->hp);
          printf("*\n");
          for (i = 0; i < 7; i++) {
                  ti = &aic->tinfo[i];
                  printf("tinfo%d: %d cmds %d disconnects %d timeouts",
                      i, ti->cmds, ti->dconns, ti->touts);
                  printf(" %d senses flags=%x\n", ti->senses, ti->flags);
          }
  }
  #endif

Cache object: 21aa3f70202a441f5df7a86a53ebc488