NetBSD/sys/arch/sgimips/hpc/sbic.c

/*	$NetBSD: sbic.c,v 1.3 2001/11/10 22:54:54 wdk Exp $	*/

/*
 * Changes Copyright (c) 2001 Wayne Knowles
 * Changes Copyright (c) 1996 Steve Woodford
 * Original Copyright (c) 1994 Christian E. Hopps
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Van Jacobson of Lawrence Berkeley Laboratory.
 *
 * 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 the University of
 *  California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
 *
 *  @(#)scsi.c  7.5 (Berkeley) 5/4/91
 */

/*
 * This version of the driver is pretty well generic, so should work with
 * any flavour of WD33C93 chip.
 */
#include "opt_ddb.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h> /* For hz */
#include <sys/disklabel.h>
#include <sys/dkstat.h>
#include <sys/buf.h>

#include <dev/scsipi/scsi_all.h>
#include <dev/scsipi/scsipi_all.h>
#include <dev/scsipi/scsiconf.h>
#include <dev/scsipi/scsi_message.h>

#include <uvm/uvm_extern.h>

#include <machine/bus.h>

#include <sgimips/hpc/sbicreg.h>
#include <sgimips/hpc/sbicvar.h>

/*
 * SCSI delays
 * In u-seconds, primarily for state changes on the SPC.
 */
#define SBIC_CMD_WAIT   50000   /* wait per step of 'immediate' cmds */
#define SBIC_DATA_WAIT  50000   /* wait per data in/out step */
#define SBIC_INIT_WAIT  50000   /* wait per step (both) during init */

#define STATUS_UNKNOWN	0xff	/* uninitialized status */

/*
 * Convenience macro for waiting for a particular sbic event
 */
#define SBIC_WAIT(regs, until, timeo) sbic_wait(regs, until, timeo, __LINE__)

/* Convert SCSI timeout from millisecs to hz avoiding overflow */
#define SCSI_TIMEOUT(t)	((t)>1000000 ? ((t)/1000)*hz : ((t)*hz)/1000)

void	sbic_init	__P((struct sbic_softc *));
void    sbic_reset	__P((struct sbic_softc *));
int     sbic_go         __P((struct sbic_softc *, struct sbic_acb *));
int     sbic_dmaok	__P((struct sbic_softc *, struct scsipi_xfer *));
int     sbic_wait	__P((struct sbic_softc *, u_char, int , int));
u_char  sbic_selectbus  __P((struct sbic_softc *, struct sbic_acb *));
int     sbic_xfout      __P((struct sbic_softc *, int, void *));
int     sbic_xfin       __P((struct sbic_softc *, int, void *));
int     sbic_poll       __P((struct sbic_softc *, struct sbic_acb *));
int     sbic_nextstate  __P((struct sbic_softc *, struct sbic_acb *,
				u_char, u_char));
int     sbic_abort	__P((struct sbic_softc *, struct sbic_acb *, char *));
void    sbic_xferdone	__P((struct sbic_softc *));
void    sbic_error	__P((struct sbic_softc *, struct sbic_acb *));
void    sbic_scsidone   __P((struct sbic_softc *, struct sbic_acb *, int));
void    sbic_sched      __P((struct sbic_softc *));
void	sbic_dequeue	__P((struct sbic_softc *, struct sbic_acb *));
void    sbic_dma_stop   __P((struct sbic_softc *));
void    sbic_dma_setup  __P((struct sbic_softc *, int));
int     sbic_msgin_phase __P((struct sbic_softc *, int));
void    sbic_msgin      __P((struct sbic_softc *, u_char *, int));
void	sbic_reselect	__P((struct sbic_softc *, int, int, int, int));
void    sbic_sched_msgout __P((struct sbic_softc *, u_short));
void    sbic_msgout	__P((struct sbic_softc *));
void    sbic_timeout	__P((void *arg));
void	sbic_watchdog	__P((void *arg));
int     sbic_div2stp	__P((struct sbic_softc *, int));
int     sbic_stp2div	__P((struct sbic_softc *, int));
void	sbic_setsync 	__P((struct sbic_softc *, struct sbic_tinfo *ti));
void    sbic_update_xfer_mode __P((struct sbic_softc *, int));

static struct pool sbic_pool;		/* Adapter Control Blocks */
static int sbic_pool_initialized = 0;

/*
 * Timeouts
 */
int     sbic_cmd_wait	= SBIC_CMD_WAIT;
int     sbic_data_wait  = SBIC_DATA_WAIT;
int     sbic_init_wait  = SBIC_INIT_WAIT;

int     sbic_nodma	= 0;   /* Use polled IO transfers */
int     sbic_nodisc	= 0;   /* Allow command queues */
int     sbic_notags	= 0;   /* No Tags */

/*
 * Some useful stuff for debugging purposes
 */
#ifdef DEBUG

#define QPRINTF(a)	SBIC_DEBUG(MISC, a)

int     sbic_debug	= 0;		/* Debug flags */

void    sbic_print_csr	__P((u_char));
void    sbic_hexdump	__P((u_char *, int));

#else
#define QPRINTF(a)  /* */
#endif

static const char *sbic_chip_names[] = SBIC_CHIP_LIST;

/*
 * Attach instance of driver and probe for sub devices
 */
void
sbic_attach(dev)
	struct sbic_softc *dev;
{
	struct scsipi_adapter *adapt = &dev->sc_adapter;
	struct scsipi_channel *chan = &dev->sc_channel;

	adapt->adapt_dev = &dev->sc_dev;
	adapt->adapt_nchannels = 1;
	adapt->adapt_openings = 256;
	adapt->adapt_max_periph = 256; /* Max tags per device */
	adapt->adapt_ioctl = NULL;
	/* adapt_request initialized by MD interface */
	/* adapt_minphys initialized by MD interface */

	memset(chan, 0, sizeof(*chan));
	chan->chan_adapter = &dev->sc_adapter;
	chan->chan_bustype = &scsi_bustype;
	chan->chan_channel = 0;
	chan->chan_ntargets = SBIC_NTARG;
	chan->chan_nluns = SBIC_NLUN;
	chan->chan_id = dev->sc_id;

	callout_init(&dev->sc_watchdog);

	dev->sc_minsync = 200/4; /* Min SCSI sync rate in 4ns units */
	dev->sc_maxoffset = SBIC_SYN_MAX_OFFSET; /* Max Sync Offset */

	/*
	 * Add reference to adapter so that we drop the reference after
	 * config_found() to make sure the adatper is disabled.
	 */
	if (scsipi_adapter_addref(&dev->sc_adapter) != 0) {
		printf("%s: unable to enable controller\n",
		    dev->sc_dev.dv_xname);
		return;
	}

	dev->sc_cfflags = dev->sc_dev.dv_cfdata->cf_flags;
	sbic_init(dev);

	dev->sc_child = config_found(&dev->sc_dev, &dev->sc_channel,
				     scsiprint);
	scsipi_adapter_delref(&dev->sc_adapter);
}

/*
 * Initialize driver-private structures
 */
void
sbic_init(dev)
	struct sbic_softc *dev;
{
	u_int   i;

	if (!sbic_pool_initialized) {
		/* All instances share the same pool */
		pool_init(&sbic_pool, sizeof(struct sbic_acb), 0, 0, 0,
		    "sbic_acb", 0, NULL, NULL, 0);
		++sbic_pool_initialized;
	}

	if (dev->sc_state == 0) {
		TAILQ_INIT(&dev->ready_list);

		dev->sc_nexus = NULL;
		dev->sc_disc  = 0;
		memset(dev->sc_tinfo, 0, sizeof(dev->sc_tinfo));

		callout_reset(&dev->sc_watchdog, 60 * hz, sbic_watchdog, dev);
	} else
		panic("sbic: reinitializing driver!");

	dev->sc_flags = 0;
	dev->sc_state = SBIC_IDLE;
	sbic_reset(dev);

	for (i = 0; i < 8; i++) {
		struct sbic_tinfo *ti = &dev->sc_tinfo[i];
		/*
		 * sc_flags = 0xTTRRSS
		 *
		 *   TT = Bitmask to disable Tagged Queues
		 *   RR = Bitmask to disable disconnect/reselect
		 *   SS = Bitmask to diable Sync negotiation
		 */
		ti->flags = T_NEED_RESET;
		if (dev->sc_minsync == 0 || (dev->sc_cfflags & (1<<(i+8))))
			ti->flags |= T_NOSYNC;
		if (dev->sc_cfflags & (1<<i) || sbic_nodisc)
			ti->flags |= T_NODISC;
		ti->period = dev->sc_minsync;
		ti->offset = 0;
	}
}

void
sbic_reset(dev)
	struct sbic_softc *dev;
{
	u_int           my_id, s;
	u_char          csr, reg;

	SET_SBIC_cmd(dev, SBIC_CMD_ABORT);
	WAIT_CIP(dev);

	s = splbio();

	my_id = dev->sc_channel.chan_id & SBIC_ID_MASK;
	if (dev->sc_clkfreq < 110)
		my_id |= SBIC_ID_FS_8_10;
	else if (dev->sc_clkfreq < 160)
		my_id |= SBIC_ID_FS_12_15;
	else if (dev->sc_clkfreq < 210)
		my_id |= SBIC_ID_FS_16_20;

	/* Enable advanced features */
#if 1
	my_id |= SBIC_ID_EAF;	/* XXX - MD Layer */
#endif

	SET_SBIC_myid(dev, my_id);

	/* Reset the chip */
	SET_SBIC_cmd(dev, SBIC_CMD_RESET);
	DELAY(25);
	SBIC_WAIT(dev, SBIC_ASR_INT, 0);

	/* Set up various chip parameters */
	SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI);

	GET_SBIC_csr(dev, csr);       /* clears interrupt also */
	GET_SBIC_cdb1(dev, dev->sc_rev);

	switch (csr) {
	case 0x0:
		dev->sc_chip = SBIC_CHIP_WD33C93;
		break;
	case 0x1:
		SET_SBIC_queue_tag(dev, 0x55);
		GET_SBIC_queue_tag(dev, reg);
		dev->sc_chip = (reg == 0x55) ?
		    	       SBIC_CHIP_WD33C93B : SBIC_CHIP_WD33C93A;
		SET_SBIC_queue_tag(dev, 0x0);
		break;
	default:
		dev->sc_chip = SBIC_CHIP_UNKNOWN;
	}

	/*
	 * don't allow Selection (SBIC_RID_ES)
	 * until we can handle target mode!!
	 */
	SET_SBIC_rselid(dev, SBIC_RID_ER);

	/* Asynchronous for now */
	SET_SBIC_syn(dev, 0);

	dev->sc_flags = 0;
	dev->sc_state = SBIC_IDLE;

	splx(s);

	printf(": %s SCSI, rev=%d, target %d\n",
	    sbic_chip_names[dev->sc_chip], dev->sc_rev,
	    dev->sc_channel.chan_id);
}

void
sbic_error(dev, acb)
	struct sbic_softc  *dev;
	struct sbic_acb    *acb;
{
	struct scsipi_xfer *xs  = acb->xs;

	KASSERT(xs);

	if (xs->xs_control & XS_CTL_SILENT)
		return;

	scsipi_printaddr(xs->xs_periph);
	printf("SCSI Error\n");
}

/*
 * Setup sync mode for given target
 */
void
sbic_setsync(dev, ti)
	struct sbic_softc *dev;
	struct sbic_tinfo *ti;
{
	u_char offset, period;

	if (ti->flags & T_SYNCMODE) {
		offset = ti->offset;
		period = sbic_stp2div(dev, ti->period);
	} else {
		offset = 0;
		period = 0;
	}

	SBIC_DEBUG(SYNC, ("sbic_setsync: sync reg = 0x%02x\n",
		       SBIC_SYN(offset, period)));
	SET_SBIC_syn(dev, SBIC_SYN(offset, period));
}

/*
 * Check if current operation can be done using DMA
 *
 * returns 1 if DMA OK, 0 for polled I/O transfer
 */
int
sbic_dmaok(dev, xs)
	struct sbic_softc  *dev;
	struct scsipi_xfer *xs;
{
	if (sbic_nodma || (xs->xs_control & XS_CTL_POLL) || xs->datalen == 0)
		return (0);
	return(1);
}

/*
 * Setup for dma transfer
 */
void
sbic_dma_setup(dev, datain)
	struct sbic_softc   *dev;
	int    datain;
{
	struct sbic_acb *acb = dev->sc_nexus;
	int     s;

	dev->sc_daddr = acb->daddr;
	dev->sc_dleft = acb->dleft;

	s = splbio();
	/* Indicate that we're in DMA mode */
	if (dev->sc_dleft) {
		dev->sc_dmasetup(dev, &dev->sc_daddr, &dev->sc_dleft,
		    datain, &dev->sc_dleft);
	}
	splx(s);
	return;
}


/*
 * Save DMA pointers.  Take into account partial transfer. Shut down DMA.
 */
void
sbic_dma_stop(dev)
	struct sbic_softc   *dev;
{
 	int                 count, asr;

	/* Wait until WD chip is idle */
	do {
		GET_SBIC_asr(dev, asr);	/* XXX */
		if (asr & SBIC_ASR_DBR) {
			printf("sbic_dma_stop: asr %02x canceled!\n", asr);
			break;
		}
	} while(asr & (SBIC_ASR_BSY|SBIC_ASR_CIP));

	/* Only need to save pointers if DMA was active */
	if (dev->sc_flags & SBICF_INDMA) {
		int s = splbio();

		/* Shut down DMA and flush FIFO's */
		dev->sc_dmastop(dev);

		/* Fetch the residual count */
		SBIC_TC_GET(dev, count);

		/* Work out how many bytes were actually transferred */
		count = dev->sc_tcnt - count;

		if (dev->sc_dleft < count)
			printf("xfer too large: dleft=%u resid=%u\n",
			    dev->sc_dleft, count);

		/* Fixup partial xfers */
		dev->sc_daddr += count;
		dev->sc_dleft -= count;
		dev->sc_tcnt   = 0;
		dev->sc_flags &= ~SBICF_INDMA;
		splx(s);
		SBIC_DEBUG(DMA, ("dma_stop\n"));
	}
	/*
	 * Ensure the WD chip is back in polled I/O mode, with nothing to
	 * transfer.
	 */
	SBIC_TC_PUT(dev, 0);
	SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI);
}


/*
 * Handle new request from scsipi layer
 */
void
sbic_scsi_request(chan, req, arg)
	struct scsipi_channel *chan;
	scsipi_adapter_req_t req;
	void *arg;
{
	struct sbic_softc *dev = (void *)chan->chan_adapter->adapt_dev;
	struct scsipi_xfer *xs;
	struct scsipi_periph *periph;
	struct sbic_acb *acb;
	int flags, s;

	switch (req) {
	case ADAPTER_REQ_RUN_XFER:
		xs = arg;
		periph = xs->xs_periph;
		flags = xs->xs_control;

		if (flags & XS_CTL_DATA_UIO)
			panic("sbic: scsi data uio requested");

		if (dev->sc_nexus && (flags & XS_CTL_POLL))
			panic("sbic_scsicmd: busy");

		s = splbio();
		acb = (struct sbic_acb *)pool_get(&sbic_pool, PR_NOWAIT);
		splx(s);

		if (acb == NULL) {
			scsipi_printaddr(periph);
			printf("cannot allocate acb\n");
			xs->error = XS_RESOURCE_SHORTAGE;
			scsipi_done(xs);
			return;
		}

		acb->flags = ACB_ACTIVE;
		acb->xs    = xs;
		acb->clen  = xs->cmdlen;
		acb->daddr = xs->data;
		acb->dleft = xs->datalen;
		acb->timeout = xs->timeout;
		memcpy(&acb->cmd, xs->cmd, xs->cmdlen);

		if (flags & XS_CTL_POLL) {
			/*
			 * Complete currently active command(s) before
			 * issuing an immediate command 
			 */
			while (dev->sc_nexus)
				sbic_poll(dev, dev->sc_nexus);
		}

		s = splbio();
		TAILQ_INSERT_TAIL(&dev->ready_list, acb, chain);
		acb->flags |= ACB_READY;

		/* If nothing is active, try to start it now. */
		if (dev->sc_state == SBIC_IDLE)
			sbic_sched(dev);
		splx(s);

		if ((flags & XS_CTL_POLL) == 0)
			return;

		if (sbic_poll(dev, acb)) {
			sbic_timeout(acb);
			if (sbic_poll(dev, acb)) /* 2nd retry for ABORT */
				sbic_timeout(acb);
		}
		return;

	case ADAPTER_REQ_GROW_RESOURCES:
		/* XXX Not supported. */
		return;

	case ADAPTER_REQ_SET_XFER_MODE:
	    {
		struct sbic_tinfo *ti;
		struct scsipi_xfer_mode *xm = arg;

		ti = &dev->sc_tinfo[xm->xm_target];
		ti->flags &= ~(T_NEGOTIATE|T_SYNCMODE);
		ti->period = 0;
		ti->offset = 0;
	    
		if ((dev->sc_cfflags & (1<<(xm->xm_target+16))) == 0 &&
		    (xm->xm_mode & PERIPH_CAP_TQING) && !sbic_notags)
			ti->flags |= T_TAG;
		else
			ti->flags &= ~T_TAG;

		if ((xm->xm_mode & PERIPH_CAP_SYNC) != 0 &&
		    (ti->flags & T_NOSYNC) == 0 && dev->sc_minsync != 0) {
			SBIC_DEBUG(SYNC, ("target %d: sync negotiation\n",
				       xm->xm_target));
			ti->flags |= T_NEGOTIATE;
			ti->period = dev->sc_minsync;
		}
		/*
		 * If we're not going to negotiate, send the notification
		 * now, since it won't happen later.
		 */
		if ((ti->flags & T_NEGOTIATE) == 0)
			sbic_update_xfer_mode(dev, xm->xm_target);
		return;
	    }

	}
}

/*
 * attempt to start the next available command
 */
void
sbic_sched(dev)
	struct sbic_softc *dev;
{
	struct scsipi_periph  *periph = NULL; /* Gag the compiler */
	struct sbic_acb       *acb;
	struct sbic_tinfo     *ti;
	struct sbic_linfo     *li;
	int		      lun, tag, flags;

	if (dev->sc_state != SBIC_IDLE)
		return;

	KASSERT(dev->sc_nexus == NULL);

	/* Loop through the ready list looking for work to do... */
	TAILQ_FOREACH(acb, &dev->ready_list, chain) {
		periph = acb->xs->xs_periph;
		lun = periph->periph_lun;
		ti = &dev->sc_tinfo[periph->periph_target];
	        li = TINFO_LUN(ti, lun);

		KASSERT(acb->flags & ACB_READY);

		/* Select type of tag for this command */
		if ((ti->flags & T_NODISC) != 0)
			tag = 0;
		else if ((ti->flags & T_TAG) == 0)
			tag = 0;
		else if ((acb->flags & ACB_SENSE) != 0)
			tag = 0;
		else if (acb->xs->xs_control & XS_CTL_POLL)
			tag = 0; /* No tags for polled commands */
		else
			tag = acb->xs->xs_tag_type;

		if (li == NULL) {
			/* Initialize LUN info and add to list. */
			li = malloc(sizeof(*li), M_DEVBUF, M_NOWAIT);
			if (li == NULL)
				continue;
			memset(li, 0, sizeof(*li));
			li->lun = lun;
			if (lun < SBIC_NLUN)
				ti->lun[lun] = li;
		}
		li->last_used = time.tv_sec;

		/*
		 * We've found a potential command, but is the target/lun busy?
		 */

		if (tag == 0 && li->untagged == NULL)
			li->untagged = acb; /* Issue untagged */

		if (li->untagged != NULL) {
			tag = 0;
			if ((li->state != L_STATE_BUSY) && li->used == 0) {
				/* Issue this untagged command now */
				acb = li->untagged;
				periph = acb->xs->xs_periph;
			} else	/* Not ready yet */
				continue;
		}

		acb->tag_type = tag;
		if (tag != 0) {
			if (li->queued[acb->xs->xs_tag_id])
				printf("queueing to active tag\n");
			li->queued[acb->xs->xs_tag_id] = acb;
			acb->tag_id = acb->xs->xs_tag_id;
			li->used++;
			break;
		}
		if (li->untagged != NULL && (li->state != L_STATE_BUSY)) {
			li->state = L_STATE_BUSY;
			break;
		}
		if (li->untagged == NULL && tag != 0) {
			break;
		} else
			printf("%d:%d busy\n", periph->periph_target,
			    periph->periph_lun);
	}

	if (acb == NULL) {
		SBIC_DEBUG(ACBS, ("sbicsched: no work\n"));
		return;			/* did not find an available command */
	}

	SBIC_DEBUG(ACBS, ("sbic_sched(%d,%d)\n", periph->periph_target,
		       periph->periph_lun));

	TAILQ_REMOVE(&dev->ready_list, acb, chain);
	acb->flags &= ~ACB_READY;

	flags = acb->xs->xs_control;
	if (flags & XS_CTL_RESET)
		sbic_reset(dev);

	/* XXX - Implicitly call scsidone on select timeout */
	if (sbic_go(dev, acb) != 0 || acb->xs->error == XS_SELTIMEOUT) {
		acb->dleft = dev->sc_dleft;
		sbic_scsidone(dev, acb, dev->sc_status);
		return;
	}

	return;
}

void
sbic_scsidone(dev, acb, status)
	struct sbic_softc *dev;
	struct sbic_acb   *acb;
	int               status;
{
	struct scsipi_xfer   *xs  = acb->xs;
	struct sbic_tinfo    *ti;
	struct sbic_linfo    *li;
	int                  s;

#ifdef DIAGNOSTIC
	KASSERT(dev->target == xs->xs_periph->periph_target);
	KASSERT(dev->lun    == xs->xs_periph->periph_lun);
	if (acb == NULL || xs == NULL) {
		panic("sbic_scsidone -- (%d,%d) no scsipi_xfer\n",
		    dev->target, dev->lun);
	}
	KASSERT(acb->flags != ACB_FREE);
#endif

	SBIC_DEBUG(ACBS, ("scsidone: (%d,%d)->(%d,%d)%02x\n",
		       xs->xs_periph->periph_target, xs->xs_periph->periph_lun,
		       dev->target, dev->lun, status));
	callout_stop(&xs->xs_callout);

	xs->status = status & SCSI_STATUS_MASK;
	xs->resid = acb->dleft;

	if (xs->error == XS_NOERROR) {
		switch (xs->status) {
		case SCSI_CHECK:
		case SCSI_TERMINATED:
			/* XXX Need to read sense - return busy for now */
			/*FALLTHROUGH*/
		case SCSI_QUEUE_FULL:
		case SCSI_BUSY:
			xs->error = XS_BUSY;
			break;
		}
	}

	ti = &dev->sc_tinfo[dev->target];
	li = TINFO_LUN(ti, dev->lun);
	ti->cmds++;
	if (xs->error == XS_SELTIMEOUT) {
		/* Selection timeout -- discard this LUN if empty */
		if (li->untagged == NULL && li->used == 0) {
			if (dev->lun < SBIC_NLUN)
				ti->lun[dev->lun] = NULL;
			free(li, M_DEVBUF);
		}
	}

	sbic_dequeue(dev, acb);
	if (dev->sc_nexus == acb) {
		dev->sc_state = SBIC_IDLE;
		dev->sc_nexus = NULL;
		dev->sc_flags = 0;

		if (!TAILQ_EMPTY(&dev->ready_list))
			sbic_sched(dev);
	}

	/* place control block back on free list. */
	s = splbio();
	acb->flags = ACB_FREE;
	pool_put(&sbic_pool, (void *)acb);
	splx(s);

	scsipi_done(xs);
}

void
sbic_dequeue(dev, acb)
	struct sbic_softc *dev;
	struct sbic_acb  *acb;
{
	struct sbic_tinfo *ti = &dev->sc_tinfo[acb->xs->xs_periph->periph_target];
	struct sbic_linfo *li;
	u_int32_t lun = acb->xs->xs_periph->periph_lun;
	
	li = TINFO_LUN(ti, lun);
#ifdef DIAGNOSTIC
	if (li == NULL || li->lun != lun)
		panic("sbic_dequeue: lun %x for ecb %p does not exist\n",
		      lun, acb);
#endif
	if (li->untagged == acb) {
		li->state = L_STATE_IDLE;
		li->untagged = NULL;
	}
	if (acb->tag_type && li->queued[acb->tag_id] != NULL) {
#ifdef DIAGNOSTIC
		if (li->queued[acb->tag_id] != NULL &&
		    (li->queued[acb->tag_id] != acb))
			panic("sbic_dequeue: slot %d for lun %x has %p "
			    "instead of acb %p\n", acb->tag_id,
			    lun, li->queued[acb->tag_id], acb);
#endif
		li->queued[acb->tag_id] = NULL;
		li->used--;
	}
}


int
sbic_wait(dev, until, timeo, line)
	struct sbic_softc *dev;
	u_char          until;
	int             timeo;
	int             line;
{
	u_char  val;

	if (timeo == 0)
		timeo = 1000000;    /* some large value.. */
	GET_SBIC_asr(dev, val);
	while ((val & until) == 0) {
		if (timeo-- == 0) {
			int csr;
			GET_SBIC_csr(dev, csr);
			printf("sbic_wait: TIMEO @%d with asr=x%x csr=x%x\n",
			    line, val, csr);
#if defined(DDB) && defined(DEBUG)
			Debugger();
#endif
			return(val); /* Maybe I should abort */
			break;
		}
		DELAY(1);
		GET_SBIC_asr(dev, val);
	}
	return(val);
}

int
sbic_abort(dev, acb, where)
	struct sbic_softc *dev;
	struct sbic_acb   *acb;
	char              *where;
{
	u_char csr, asr;

	GET_SBIC_asr(dev, asr);
	GET_SBIC_csr(dev, csr);

	scsipi_printaddr(acb->xs->xs_periph);
	printf ("ABORT in %s: csr=0x%02x, asr=0x%02x\n", where, csr, asr);

	acb->timeout = SBIC_ABORT_TIMEOUT;
	acb->flags |= ACB_ABORT;

	/*
	 * Clean up chip itself
	 */
	if (dev->sc_nexus == acb) {
		/* Reschedule timeout. */
		callout_reset(&acb->xs->xs_callout, SCSI_TIMEOUT(acb->timeout),
		    sbic_timeout, acb);

		while (asr & SBIC_ASR_DBR) {
			/*
			 * sbic is jammed w/data. need to clear it
			 * But we don't know what direction it needs to go
			 */
			GET_SBIC_data(dev, asr);
			printf("abort %s: clearing data buffer 0x%02x\n",
			       where, asr);
			GET_SBIC_asr(dev, asr);
			if (asr & SBIC_ASR_DBR) /* Not the read direction */
				SET_SBIC_data(dev, asr);
			GET_SBIC_asr(dev, asr);
		}

		scsipi_printaddr(acb->xs->xs_periph);
		printf("sending ABORT command\n");

		WAIT_CIP(dev);
		SET_SBIC_cmd(dev, SBIC_CMD_ABORT);
		WAIT_CIP(dev);

		GET_SBIC_asr(dev, asr);

		scsipi_printaddr(acb->xs->xs_periph);
		if (asr & (SBIC_ASR_BSY|SBIC_ASR_LCI)) {
			/*
			 * ok, get more drastic..
			 */
			printf("Resetting bus\n");
			sbic_reset(dev);
		} else {
			printf("sending DISCONNECT to target\n");
			SET_SBIC_cmd(dev, SBIC_CMD_DISC);
			WAIT_CIP(dev);

			do {
				SBIC_WAIT (dev, SBIC_ASR_INT, 0);
				GET_SBIC_asr(dev, asr);
				GET_SBIC_csr(dev, csr);
				SBIC_DEBUG(MISC, ("csr: 0x%02x, asr: 0x%02x\n",
					       csr, asr));
			} while ((csr != SBIC_CSR_DISC) && 
			    (csr != SBIC_CSR_DISC_1) &&
			    (csr != SBIC_CSR_CMD_INVALID));
		}
		dev->sc_state = SBIC_ERROR;	
		dev->sc_flags = 0;
	}
	return SBIC_STATE_ERROR;
}


/*
 * select the bus, return when selected or error.
 *
 * Returns the current CSR following selection and optionally MSG out phase.
 * i.e. the returned CSR *should* indicate CMD phase...
 * If the return value is 0, some error happened.
 */
u_char
sbic_selectbus(dev, acb)
	struct sbic_softc    *dev;
	struct sbic_acb	     *acb;
{
	struct scsipi_xfer   *xs  = acb->xs;
	struct sbic_tinfo    *ti;
	u_char		      target, lun, asr, csr, id;

	KASSERT(dev->sc_state == SBIC_IDLE);

	target = xs->xs_periph->periph_target;
	lun    = xs->xs_periph->periph_lun;
	ti     = &dev->sc_tinfo[target];

	dev->sc_state = SBIC_SELECTING;
	dev->target    = target;
	dev->lun       = lun;

	SBIC_DEBUG(PHASE, ("sbic_selectbus %d: ", target));

	if ((xs->xs_control & XS_CTL_POLL) == 0)
		callout_reset(&xs->xs_callout, SCSI_TIMEOUT(acb->timeout),
		    sbic_timeout, acb);

	/*
	 * issue select
	 */
	SBIC_TC_PUT(dev, 0);
	SET_SBIC_selid(dev, target);
	SET_SBIC_timeo(dev, SBIC_TIMEOUT(250, dev->sc_clkfreq));

	GET_SBIC_asr(dev, asr);
	if (asr & (SBIC_ASR_INT|SBIC_ASR_BSY)) {
		/* This means we got ourselves reselected upon */
		SBIC_DEBUG(PHASE, ("WD busy (reselect?) ASR=%02x\n", asr));
		return 0;
	}

	SET_SBIC_cmd(dev, SBIC_CMD_SEL_ATN);
	WAIT_CIP(dev);

	/*
	 * wait for select (merged from seperate function may need
	 * cleanup)
	 */
	do {
		asr = SBIC_WAIT(dev, SBIC_ASR_INT | SBIC_ASR_LCI, 0);
		if (asr & SBIC_ASR_LCI) {
			QPRINTF(("late LCI: asr %02x\n", asr));
			return 0;
		}

		/* Clear interrupt */
		GET_SBIC_csr (dev, csr);

		/* Reselected from under our feet? */
		if (csr == SBIC_CSR_RSLT_NI || csr == SBIC_CSR_RSLT_IFY) {
			SBIC_DEBUG(PHASE, ("got reselected, asr %02x\n", asr));
			/*
			 * We need to handle this now so we don't lock up later
			 */
			sbic_nextstate(dev, acb, csr, asr);
			return 0;
		}

		/* Whoops! */
		if (csr == SBIC_CSR_SLT || csr == SBIC_CSR_SLT_ATN) {
			panic("sbic_selectbus: target issued select!");
			return 0;
		}

	} while (csr != (SBIC_CSR_MIS_2 | MESG_OUT_PHASE) &&
	         csr != (SBIC_CSR_MIS_2 | CMD_PHASE) &&
	         csr != SBIC_CSR_SEL_TIMEO);

	/* Anyone at home? */
	if (csr == SBIC_CSR_SEL_TIMEO) {
		xs->error = XS_SELTIMEOUT;
		SBIC_DEBUG(PHASE, ("-- Selection Timeout\n"));
		return 0;
	}

	SBIC_DEBUG(PHASE, ("Selection Complete\n"));

	/* Assume we're now selected */
	GET_SBIC_selid(dev, id);
	if (id != target) {
		/* Something went wrong - wrong target was select */
		printf("sbic_selectbus: wrong target selected;"
		    "  WANTED %d GOT %d", target, id);
		return 0;      /* XXX: Need to call nexstate to handle? */
	}

	dev->sc_flags |= SBICF_SELECTED;
	dev->sc_state  = SBIC_CONNECTED;

	/* setup correct sync mode for this target */
	sbic_setsync(dev, ti);

	if (ti->flags & T_NODISC && dev->sc_disc == 0)
		SET_SBIC_rselid (dev, 0); /* Not expecting a reselect */
	else
		SET_SBIC_rselid (dev, SBIC_RID_ER);

	/*
	 * We only really need to do anything when the target goes to MSG out
	 * If the device ignored ATN, it's probably old and brain-dead,
	 * but we'll try to support it anyhow.
	 * If it doesn't support message out, it definately doesn't
	 * support synchronous transfers, so no point in even asking...
	 */
	if (csr == (SBIC_CSR_MIS_2 | MESG_OUT_PHASE)) {
		if (ti->flags & T_NEGOTIATE) {
			/* Inititae a SDTR message */
			SBIC_DEBUG(SYNC, ("Sending SDTR to target %d\n", id));
			ti->period = dev->sc_minsync;
			ti->offset = dev->sc_maxoffset;

			/* Send Sync negotiation message */
			dev->sc_omsg[0] = MSG_IDENTIFY(lun, 0); /* No Disc */
			dev->sc_omsg[1] = MSG_EXTENDED;
			dev->sc_omsg[2] = MSG_EXT_SDTR_LEN;
			dev->sc_omsg[3] = MSG_EXT_SDTR;
			dev->sc_omsg[4] = dev->sc_minsync;
			dev->sc_omsg[5] = dev->sc_maxoffset;
			sbic_xfout(dev, 6, dev->sc_omsg);
			dev->sc_msgout |= SEND_SDTR; /* may be rejected */
			dev->sc_flags  |= SBICF_SYNCNEGO;
		} else {
			if (dev->sc_nexus->tag_type != 0) {
				/* Use TAGS */
				SBIC_DEBUG(TAGS, ("<select %d:%d TAG=%x>\n",
					       dev->target, dev->lun,
					       dev->sc_nexus->tag_id));
				dev->sc_omsg[0] = MSG_IDENTIFY(lun, 1);
				dev->sc_omsg[1] = dev->sc_nexus->tag_type;
				dev->sc_omsg[2] = dev->sc_nexus->tag_id;
				sbic_xfout(dev, 3, dev->sc_omsg);
				dev->sc_msgout |= SEND_TAG;
			} else {
				int no_disc;

				/* Setup LUN nexus and disconnect privilege */
				no_disc = xs->xs_control & XS_CTL_POLL ||
				          ti->flags & T_NODISC;
				SEND_BYTE(dev, MSG_IDENTIFY(lun, !no_disc));
			}
		}
		/*
		 * There's one interrupt still to come:
		 * the change to CMD phase...
		 */
		SBIC_WAIT(dev, SBIC_ASR_INT , 0);
		GET_SBIC_csr(dev, csr);
        }

	return csr;
}

/*
 * Information Transfer *to* a SCSI Target.
 *
 * Note: Don't expect there to be an interrupt immediately after all
 * the data is transferred out. The WD spec sheet says that the Transfer-
 * Info command for non-MSG_IN phases only completes when the target
 * next asserts 'REQ'. That is, when the SCSI bus changes to a new state.
 *
 * This can have a nasty effect on commands which take a relatively long
 * time to complete, for example a START/STOP unit command may remain in
 * CMD phase until the disk has spun up. Only then will the target change
 * to STATUS phase. This is really only a problem for immediate commands
 * since we don't allow disconnection for them (yet).
 */
int
sbic_xfout(dev, len, bp)
	struct sbic_softc *dev;
	int             len;
	void            *bp;
{
	int     wait = sbic_data_wait;
	u_char  asr, *buf = bp;

	QPRINTF(("sbic_xfout {%d} %02x %02x %02x %02x %02x "
		    "%02x %02x %02x %02x %02x\n", len, buf[0], buf[1], buf[2],
		    buf[3], buf[4], buf[5], buf[6], buf[7], buf[8], buf[9]));

	/*
	 * sigh.. WD-PROTO strikes again.. sending the command in one go
	 * causes the chip to lock up if talking to certain (misbehaving?)
	 * targets. Anyway, this procedure should work for all targets, but
	 * it's slightly slower due to the overhead
	 */

	SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI);
	SBIC_TC_PUT (dev, (unsigned)len);

	WAIT_CIP (dev);
	SET_SBIC_cmd (dev, SBIC_CMD_XFER_INFO);

	/*
	 * Loop for each byte transferred
	 */
	do {
		GET_SBIC_asr (dev, asr);

		if (asr & SBIC_ASR_DBR) {
			if (len) {
				SET_SBIC_data (dev, *buf);
				buf++;
				len--;
			} else {
				SET_SBIC_data (dev, 0);
			}
			wait = sbic_data_wait;
		}
	} while (len && (asr & SBIC_ASR_INT) == 0 && wait-- > 0);

	QPRINTF(("sbic_xfout done: %d bytes remaining (wait:%d)\n", len, wait));

	/*
	 * Normally, an interrupt will be pending when this routing returns.
	 */
	return(len);
}

/*
 * Information Transfer *from* a Scsi Target
 * returns # bytes left to read
 */
int
sbic_xfin(dev, len, bp)
	struct sbic_softc *dev;
	int             len;
	void            *bp;
{
	int     wait = sbic_data_wait;
	u_char  *buf = bp;
	u_char  asr;
#ifdef  DEBUG
	u_char  *obp = bp;
#endif
	SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI);
	SBIC_TC_PUT (dev, (unsigned)len);

	WAIT_CIP (dev);
	SET_SBIC_cmd (dev, SBIC_CMD_XFER_INFO);

	/*
	 * Loop for each byte transferred
	 */
	do {
		GET_SBIC_asr (dev, asr);

		if (asr & SBIC_ASR_DBR) {
			if (len) {
				GET_SBIC_data (dev, *buf);
				buf++;
				len--;
			} else {
				u_char foo;
				GET_SBIC_data (dev, foo);
			}
			wait = sbic_data_wait;
		}

	} while ((asr & SBIC_ASR_INT) == 0 && wait-- > 0);

	QPRINTF(("sbic_xfin {%d} %02x %02x %02x %02x %02x %02x "
		    "%02x %02x %02x %02x\n", len, obp[0], obp[1], obp[2],
		    obp[3], obp[4], obp[5], obp[6], obp[7], obp[8], obp[9]));

	SBIC_TC_PUT (dev, 0);

	/*
	 * this leaves with one csr to be read
	 */
	return len;
}


/*
 * Finish SCSI xfer command:  After the completion interrupt from
 * a read/write operation, sequence through the final phases in
 * programmed i/o.
 */
void
sbic_xferdone(dev)
	struct sbic_softc   *dev;
{
	u_char          phase, csr;
	int             s;

	QPRINTF(("{"));
	s = splbio();

	/*
	 * have the sbic complete on its own
	 */
	SBIC_TC_PUT(dev, 0);
	SET_SBIC_cmd_phase(dev, 0x46);
	SET_SBIC_cmd(dev, SBIC_CMD_SEL_ATN_XFER);

	do {
		SBIC_WAIT (dev, SBIC_ASR_INT, 0);
		GET_SBIC_csr (dev, csr);
		QPRINTF(("%02x:", csr));
	} while ((csr != SBIC_CSR_DISC) &&
	         (csr != SBIC_CSR_DISC_1) &&
	         (csr != SBIC_CSR_S_XFERRED));

	dev->sc_flags &= ~SBICF_SELECTED;
	dev->sc_state = SBIC_DISCONNECT;

	GET_SBIC_cmd_phase (dev, phase);
	QPRINTF(("}%02x", phase));

	if (phase == 0x60)
		GET_SBIC_tlun(dev, dev->sc_status);
	else
		sbic_error(dev, dev->sc_nexus);

	QPRINTF(("=STS:%02x=\n", dev->sc_status));
	splx(s);
}


int
sbic_go(dev, acb)
	struct sbic_softc   *dev;
	struct sbic_acb     *acb;
{
	struct scsipi_xfer  *xs = acb->xs;
	int             i, dmaok;
	u_char          csr, asr;

	SBIC_DEBUG(ACBS, ("sbic_go(%d:%d)\n", dev->target, dev->lun));

	dev->sc_nexus = acb;

	dev->target = xs->xs_periph->periph_target;
	dev->lun    = xs->xs_periph->periph_lun;
	
	dev->sc_status = STATUS_UNKNOWN;
	dev->sc_daddr = acb->daddr;
	dev->sc_dleft = acb->dleft;

	dev->sc_msgpriq = dev->sc_msgout = dev->sc_msgoutq = 0;
	dev->sc_flags = 0;

	dmaok = sbic_dmaok(dev, xs);

	if (dmaok == 0)
		dev->sc_flags |= SBICF_NODMA;

	SBIC_DEBUG(DMA, ("sbic_go dmago:%d(tcnt=%x) dmaok=%dx\n",
		       dev->target, dev->sc_tcnt, dmaok));

	/* select the SCSI bus (it's an error if bus isn't free) */
	if ((csr = sbic_selectbus(dev, acb)) == 0)
		return(0); /* Not done: needs to be rescheduled */

	/*
	 * Lets cycle a while then let the interrupt handler take over.
	 */
	GET_SBIC_asr(dev, asr);
	do {
		QPRINTF(("go[0x%x] ", csr));

		/* Handle the new phase */
		i = sbic_nextstate(dev, acb, csr, asr);
		WAIT_CIP(dev);		/* XXX */
		if (dev->sc_state == SBIC_CONNECTED) {

			GET_SBIC_asr(dev, asr);

			if (asr & SBIC_ASR_LCI)
				printf("sbic_go: LCI asr:%02x csr:%02x\n", asr, csr);

			if (asr & SBIC_ASR_INT)
				GET_SBIC_csr(dev, csr);
		}

	} while (dev->sc_state == SBIC_CONNECTED && 
	    	 asr & (SBIC_ASR_INT|SBIC_ASR_LCI));

	QPRINTF(("> done i=%d stat=%02x\n", i, dev->sc_status));
    
	if (i == SBIC_STATE_DONE) {
		if (dev->sc_status == STATUS_UNKNOWN) {
			printf("sbic_go: done & stat == UNKNOWN\n");
			return 1;  /* Did we really finish that fast? */
		}
	}
	return 0;
}


int
sbic_intr(dev)
	struct sbic_softc *dev;
{
	u_char            asr, csr;
	int               i;

	/*
	 * pending interrupt?
	 */
	GET_SBIC_asr (dev, asr);
	if ((asr & SBIC_ASR_INT) == 0)
		return(0);

	GET_SBIC_csr(dev, csr);

	do {
		SBIC_DEBUG(INTS, ("intr[csr=0x%x]", csr));

		i = sbic_nextstate(dev, dev->sc_nexus, csr, asr);
		WAIT_CIP(dev);		/* XXX */
		if (dev->sc_state == SBIC_CONNECTED) {
			GET_SBIC_asr(dev, asr);

			if (asr & SBIC_ASR_LCI)
				printf("sbic_intr: LCI asr:%02x csr:%02x\n",
				    asr, csr);

			if (asr & SBIC_ASR_INT)
				GET_SBIC_csr(dev, csr);
		}
	} while (dev->sc_state == SBIC_CONNECTED &&
	    	 asr & (SBIC_ASR_INT|SBIC_ASR_LCI));
	
	SBIC_DEBUG(INTS, ("intr done. state=%d, asr=0x%02x\n", i, asr));

	return(1);
}

/*
 * Complete current command using polled I/O.   Used when interrupt driven
 * I/O is not allowed (ie. during boot and shutdown)
 *
 * Polled I/O is very processor intensive
 */
int
sbic_poll(dev, acb)
	struct sbic_softc   *dev;
	struct sbic_acb     *acb;
{
	u_char              asr, csr=0;
	int                 i, count;
	struct scsipi_xfer *xs = acb->xs;

	SBIC_WAIT(dev, SBIC_ASR_INT, sbic_cmd_wait);
	for (count=acb->timeout; count;) {
		GET_SBIC_asr (dev, asr);
		if (asr & SBIC_ASR_LCI)
			printf("sbic_poll: LCI; asr:%02x csr:%02x\n",
			    asr, csr);
		if (asr & SBIC_ASR_INT) {
			GET_SBIC_csr(dev, csr);
			dev->sc_flags |= SBICF_NODMA;
			i = sbic_nextstate(dev, dev->sc_nexus, csr, asr);
			WAIT_CIP(dev);		/* XXX */
		} else {
			DELAY(1000);
			count--;
		}

		if ((xs->xs_status & XS_STS_DONE) != 0)
			return (0);

		if (dev->sc_state == SBIC_IDLE) {
			SBIC_DEBUG(ACBS, ("[poll: rescheduling] "));
			sbic_sched(dev);
		}
	}
	return (1);
}

/*
 * XXX this might be common thing(check with scsipi)
 */
#define IS1BYTEMSG(m)	(((m) != 1 && (m) < 0x20) || (m) & 0x80)
#define IS2BYTEMSG(m)	(((m) & 0xf0) == 0x20)
#define ISEXTMSG(m)	((m) == 1)

static inline int
__verify_msg_format(u_char *p, int len)
{

	if (len == 1 && IS1BYTEMSG(p[0]))
		return 1;
	if (len == 2 && IS2BYTEMSG(p[0]))
		return 1;
	if (len >= 3 && ISEXTMSG(p[0]) &&
	    len == p[1] + 2)
		return 1;
	return 0;
}

/*
 * Handle message_in phase
 */
int
sbic_msgin_phase(dev, reselect)
	struct sbic_softc   *dev;
	int    reselect;
{
	int    len;
	u_char asr, csr, *msg;

	GET_SBIC_asr(dev, asr);

	SBIC_DEBUG(MSGS, ("sbicmsgin asr=%02x\n", asr));

	GET_SBIC_selid (dev, csr);
	SET_SBIC_selid (dev, csr | SBIC_SID_FROM_SCSI);

	SBIC_TC_PUT(dev, 0);

	SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI);

	msg = dev->sc_imsg;
	len = 0;

	do {
		/* Fetch the next byte of the message */
		RECV_BYTE(dev, *msg++);
		len++;

		/*
		 * get the command completion interrupt, or we
		 * can't send a new command (LCI)
		 */
		SBIC_WAIT(dev, SBIC_ASR_INT, 0);
		GET_SBIC_csr(dev, csr);

		/*
		 * Clear ACK, and wait for the interrupt
		 * for the next byte or phase change
		 */
		SET_SBIC_cmd(dev, SBIC_CMD_CLR_ACK);
		SBIC_WAIT(dev, SBIC_ASR_INT, 0);

		if (__verify_msg_format(dev->sc_imsg, len))
			break; /* Complete message recieved */

		GET_SBIC_csr(dev, csr);
	} while (len < SBIC_MAX_MSGLEN);

	if (__verify_msg_format(dev->sc_imsg, len))
		sbic_msgin(dev, dev->sc_imsg, len);

	/* Should still have one CSR to read */
	return SBIC_STATE_RUNNING;
}


void sbic_msgin(dev, msgaddr, msglen)
	struct sbic_softc   *dev;
	u_char *msgaddr;
        int    msglen;
{
	struct sbic_acb    *acb = dev->sc_nexus;
	struct sbic_tinfo  *ti = &dev->sc_tinfo[dev->target];
	struct sbic_linfo  *li;
	u_char asr;

	switch (dev->sc_state) {
	case SBIC_CONNECTED:
		switch (msgaddr[0]) {
		case MSG_MESSAGE_REJECT:
			SBIC_DEBUG(MSGS, ("msgin: MSG_REJECT, "
				       "last msgout=%x\n", dev->sc_msgout));
			switch (dev->sc_msgout) {
			case SEND_TAG:
				printf("%s: tagged queuing rejected: "
				    "target %d\n",
				    dev->sc_dev.dv_xname, dev->target);
				ti->flags &= ~T_TAG;
				li = TINFO_LUN(ti, dev->lun);
				if (acb->tag_type &&
				    li->queued[acb->tag_id] != NULL) {
					li->queued[acb->tag_id] = NULL;
					li->used--;
				}
				acb->tag_type = acb->tag_id = 0;
				li->untagged = acb;
				li->state = L_STATE_BUSY;
				break;

			case SEND_SDTR:
				printf("%s: sync transfer rejected: target %d\n",
				    dev->sc_dev.dv_xname, dev->target);

				dev->sc_flags &= ~SBICF_SYNCNEGO;
				ti->flags &= ~(T_NEGOTIATE | T_SYNCMODE);
				sbic_update_xfer_mode(dev,
				    acb->xs->xs_periph->periph_target);
				sbic_setsync(dev, ti);

			case SEND_INIT_DET_ERR:
				goto abort;

			default:
				SBIC_DEBUG(MSGS, ("Unexpected MSG_REJECT\n"));
				break;
			}
			dev->sc_msgout = 0;
			break;
	    
		case MSG_HEAD_OF_Q_TAG:
		case MSG_ORDERED_Q_TAG:
		case MSG_SIMPLE_Q_TAG:
			printf("-- Out of phase TAG;"
			    "Nexus=%d:%d Tag=%02x/%02x\n",
			    dev->target, dev->lun, msgaddr[0], msgaddr[1]);
			break;

		case MSG_DISCONNECT:
			SBIC_DEBUG(MSGS, ("msgin: DISCONNECT"));
			/*
			 * Mark the fact that all bytes have moved. The
			 * target may not bother to do a SAVE POINTERS
			 * at this stage. This flag will set the residual
			 * count to zero on MSG COMPLETE.
			 */
			if (dev->sc_dleft == 0)
				acb->flags |= ACB_COMPLETE;

			if (acb->xs->xs_control & XS_CTL_POLL)
			        /* Don't allow disconnect in immediate mode */
				goto reject;
			else {  /* Allow disconnect */
				dev->sc_flags &= ~SBICF_SELECTED;
				dev->sc_state = SBIC_DISCONNECT;
			}
			if ((acb->xs->xs_periph->periph_quirks &
				PQUIRK_AUTOSAVE) == 0)
				break;
			/*FALLTHROUGH*/

		case MSG_SAVEDATAPOINTER:
			SBIC_DEBUG(MSGS, ("msgin: SAVEDATAPTR"));
			acb->daddr = dev->sc_daddr;
			acb->dleft = dev->sc_dleft;
			break;

		case MSG_RESTOREPOINTERS:
			SBIC_DEBUG(MSGS, ("msgin: RESTOREPTR"));
			dev->sc_daddr = acb->daddr;
			dev->sc_dleft = acb->dleft;
			break;

		case MSG_CMDCOMPLETE:
			/*
			 * !! KLUDGE ALERT !! quite a few drives don't seem to
			 * really like the current way of sending the
			 * sync-handshake together with the ident-message, and
			 * they react by sending command-complete and
			 * disconnecting right after returning the valid sync
			 * handshake. So, all I can do is reselect the drive,
			 * and hope it won't disconnect again. I don't think
			 * this is valid behavior, but I can't help fixing a
			 * problem that apparently exists.
			 *
			 * Note: we should not get here on `normal' command
			 * completion, as that condition is handled by the
			 * high-level sel&xfer resume command used to walk
			 * thru status/cc-phase.
			 */
			SBIC_DEBUG(MSGS, ("msgin: CMD_COMPLETE"));
			SBIC_DEBUG(SYNC, ("GOT MSG %d! target %d"
				       " acting weird.."
				       " waiting for disconnect...\n",
				       msgaddr[0], dev->target));

			/* Check to see if sbic is handling this */
			GET_SBIC_asr(dev, asr);
			if (asr & SBIC_ASR_BSY)
				break;

			/* XXX: Assume it works and set status to 00 */
			dev->sc_status = 0;
			dev->sc_state = SBIC_CMDCOMPLETE;
			break;

		case MSG_EXTENDED:
			switch(msgaddr[2]) {
			case MSG_EXT_SDTR: /* Sync negotiation */
				SBIC_DEBUG(MSGS, ("msgin: EXT_SDTR; "
					       "period %d, offset %d",
					       msgaddr[3], msgaddr[4]));
				if (msgaddr[1] != 3)
					goto reject;

				ti->period = MAX(msgaddr[3], dev->sc_minsync);
				ti->offset = MIN(msgaddr[4], dev->sc_maxoffset);
				ti->flags &= ~T_NEGOTIATE;
				if (dev->sc_minsync == 0 || ti->period > 124)
					ti->offset = ti->period = 0;

				if (ti->offset == 0)
					ti->flags &= ~T_SYNCMODE; /* Async */
				else {
					int p;

					p = sbic_stp2div(dev, ti->period);
					ti->period = sbic_div2stp(dev, p);
					ti->flags |= T_SYNCMODE; /* Sync */
				}
				
				if ((dev->sc_flags&SBICF_SYNCNEGO) == 0)
					/* target initiated negotiation */
					sbic_sched_msgout(dev, SEND_SDTR);
				dev->sc_flags &= ~SBICF_SYNCNEGO;

				SBIC_DEBUG(SYNC, ("msgin(%d): SDTR(o=%d,p=%d)",
					       dev->target, ti->offset,
					       ti->period));
				sbic_update_xfer_mode(dev,
				    acb->xs->xs_periph->periph_target);
				sbic_setsync(dev, ti);
				break;

			case MSG_EXT_WDTR:
				SBIC_DEBUG(MSGS, ("msgin: EXT_WDTR ignored"));
				break;

			default:
				scsipi_printaddr(acb->xs->xs_periph);
				printf("unrecognized MESSAGE EXTENDED;"
				    " sending REJECT\n");
				goto reject;
			}
			break;

		default:
			scsipi_printaddr(acb->xs->xs_periph);
			printf("unrecognized MESSAGE; sending REJECT\n");

		reject:
			/* We don't support whatever this message is... */
			sbic_sched_msgout(dev, SEND_REJECT);
			break;
		}
		break;

	case SBIC_IDENTIFIED:
		/*
		 * IDENTIFY message was received and queue tag is expected now
		 */ 
		if ((msgaddr[0]!=MSG_SIMPLE_Q_TAG) || (dev->sc_msgify==0)) {
			printf("%s: TAG reselect without IDENTIFY;"
			    " MSG %x; sending DEVICE RESET\n",
			    dev->sc_dev.dv_xname, msgaddr[0]);
			goto reset;
		}
		SBIC_DEBUG(TAGS, ("TAG %x/%x\n", msgaddr[0], msgaddr[1]));
		if (dev->sc_nexus)
			printf("*TAG Recv with active nexus!!\n");
		sbic_reselect(dev, dev->target, dev->lun,
		    	      msgaddr[0], msgaddr[1]);
		break;

	case SBIC_RESELECTED:
		/*
		 * IDENTIFY message with target
		 */
		if (MSG_ISIDENTIFY(msgaddr[0])) {
			SBIC_DEBUG(PHASE, ("IFFY[%x] ", msgaddr[0]));
			dev->sc_msgify = msgaddr[0];
		} else {
			printf("%s: reselect without IDENTIFY;"
			    " MSG %x;"
			    " sending DEVICE RESET\n",
			    dev->sc_dev.dv_xname, msgaddr[0]);
			goto reset;
		}
		break;

	default:
		printf("Unexpected MESSAGE IN.  State=%d - Sending RESET\n",
		    dev->sc_state);
	reset:
		sbic_sched_msgout(dev, SEND_DEV_RESET);
		break;
	abort:
		sbic_sched_msgout(dev, SEND_ABORT);
		break;
	}
}

void
sbic_sched_msgout(dev, msg)
	struct sbic_softc *dev;
	u_short msg;
{
	u_char	asr;

	SBIC_DEBUG(SYNC,("sched_msgout: %04x\n", msg));
	dev->sc_msgpriq |= msg;

	/* Schedule MSGOUT Phase to send message */

	WAIT_CIP(dev);
	SET_SBIC_cmd(dev, SBIC_CMD_SET_ATN);
	WAIT_CIP(dev);
	GET_SBIC_asr(dev, asr);
	if (asr & SBIC_ASR_LCI) {
		printf("MSGOUT Failed!\n");
	}
	SET_SBIC_cmd(dev, SBIC_CMD_CLR_ACK);
	WAIT_CIP(dev);
}

/*
 * Send the highest priority, scheduled message
 */
void
sbic_msgout(dev)
	struct sbic_softc *dev;
{
	struct sbic_tinfo *ti;
	struct sbic_acb *acb = dev->sc_nexus;

	if (acb == NULL)
		panic("MSGOUT with no nexus"); 

	if (dev->sc_omsglen == 0) {
		/* Pick up highest priority message */
		dev->sc_msgout   = dev->sc_msgpriq & -dev->sc_msgpriq;
		dev->sc_msgoutq |= dev->sc_msgout;
		dev->sc_msgpriq &= ~dev->sc_msgout;
		dev->sc_omsglen = 1;		/* "Default" message len */
		switch (dev->sc_msgout) {
		case SEND_SDTR:
			ti = &dev->sc_tinfo[acb->xs->xs_periph->periph_target];
			dev->sc_omsg[0] = MSG_EXTENDED;
			dev->sc_omsg[1] = MSG_EXT_SDTR_LEN;
			dev->sc_omsg[2] = MSG_EXT_SDTR;
			dev->sc_omsg[3] = ti->period;
			dev->sc_omsg[4] = ti->offset;
			dev->sc_omsglen = 5;
			if ((dev->sc_flags & SBICF_SYNCNEGO) == 0) {
				ti->flags |= T_SYNCMODE;
				sbic_setsync(dev, ti);
			}
			break;
                case SEND_IDENTIFY:
                        if (dev->sc_state != SBIC_CONNECTED) {
                                printf("%s at line %d: no nexus\n",
                                    dev->sc_dev.dv_xname, __LINE__);
                        }
                        dev->sc_omsg[0] =
                            MSG_IDENTIFY(acb->xs->xs_periph->periph_lun, 0);
                        break;
		case SEND_TAG:
			if (dev->sc_state != SBIC_CONNECTED) {
				printf("%s at line %d: no nexus\n",
				    dev->sc_dev.dv_xname, __LINE__);
			}
			dev->sc_omsg[0] = acb->tag_type;
			dev->sc_omsg[1] = acb->tag_id;
			dev->sc_omsglen = 2;
			break;
		case SEND_DEV_RESET:
			dev->sc_omsg[0] = MSG_BUS_DEV_RESET;
			ti = &dev->sc_tinfo[dev->target];
			ti->flags &= ~T_SYNCMODE;
			sbic_update_xfer_mode(dev, dev->target);
			if ((ti->flags & T_NOSYNC) == 0)
				/* We can re-start sync negotiation */
				ti->flags |= T_NEGOTIATE;
			break;
		case SEND_PARITY_ERROR:
			dev->sc_omsg[0] = MSG_PARITY_ERROR;
			break;
		case SEND_ABORT:
			dev->sc_flags  |= SBICF_ABORTING;
			dev->sc_omsg[0] = MSG_ABORT;
			break;
		case SEND_INIT_DET_ERR:
			dev->sc_omsg[0] = MSG_INITIATOR_DET_ERR;
			break;
		case SEND_REJECT:
			dev->sc_omsg[0] = MSG_MESSAGE_REJECT;
			break;
		default:
			/* Wasn't expecting MSGOUT Phase */
			dev->sc_omsg[0] = MSG_NOOP;
			break;
		}
	}

	sbic_xfout(dev, dev->sc_omsglen, dev->sc_omsg);
}


/*
 * sbic_nextstate()
 * return:
 *      SBIC_STATE_DONE        == done
 *      SBIC_STATE_RUNNING     == working
 *      SBIC_STATE_DISCONNECT  == disconnected
 *      SBIC_STATE_ERROR       == error
 */
int
sbic_nextstate(dev, acb, csr, asr)
	struct sbic_softc   *dev;
	struct sbic_acb     *acb;
	u_char              csr, asr;
{
	SBIC_DEBUG(PHASE, ("next[a=%02x,c=%02x]: ",asr,csr));

	switch (csr) {

	case SBIC_CSR_XFERRED | CMD_PHASE:
	case SBIC_CSR_MIS     | CMD_PHASE:
	case SBIC_CSR_MIS_1   | CMD_PHASE:
	case SBIC_CSR_MIS_2   | CMD_PHASE:

		if (sbic_xfout(dev, acb->clen, &acb->cmd))
			goto abort;
		break;

	case SBIC_CSR_XFERRED | STATUS_PHASE:
	case SBIC_CSR_MIS     | STATUS_PHASE:
	case SBIC_CSR_MIS_1   | STATUS_PHASE:
	case SBIC_CSR_MIS_2   | STATUS_PHASE:

		SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI);

		/*
		 * this should be the normal i/o completion case.
		 * get the status & cmd complete msg then let the
		 * device driver look at what happened.
		 */
		sbic_xferdone(dev);

		sbic_dma_stop(dev);

		/* Fixup byte count to be passed to higher layer */
		acb->dleft = (acb->flags & ACB_COMPLETE) ? 0 :
		    	      dev->sc_dleft;

		/*
		 * Indicate to the upper layers that the command is done
		 */
		sbic_scsidone(dev, acb, dev->sc_status);

		return SBIC_STATE_DONE;


	case SBIC_CSR_XFERRED | DATA_IN_PHASE:
	case SBIC_CSR_MIS     | DATA_IN_PHASE:
	case SBIC_CSR_MIS_1   | DATA_IN_PHASE:
	case SBIC_CSR_MIS_2   | DATA_IN_PHASE:
	case SBIC_CSR_XFERRED | DATA_OUT_PHASE:
	case SBIC_CSR_MIS     | DATA_OUT_PHASE:
	case SBIC_CSR_MIS_1   | DATA_OUT_PHASE:
	case SBIC_CSR_MIS_2   | DATA_OUT_PHASE:
		/*
		 * Verify that we expected to transfer data...
		 */
		if (acb->dleft <= 0) {
			printf("next: DATA phase with xfer count == %d, asr:0x%02x csr:0x%02x\n",
			    acb->dleft, asr, csr);
			goto abort;
		}

		/*
		 * Should we transfer using PIO or DMA ?
		 */
		if (acb->xs->xs_control & XS_CTL_POLL ||
		    dev->sc_flags & SBICF_NODMA) {
			/* Perfrom transfer using PIO */
			int resid;

			SBIC_DEBUG(DMA, ("PIO xfer: %d(%p:%x)\n", dev->target,
				       dev->sc_daddr, dev->sc_dleft));

			if (SBIC_PHASE(csr) == DATA_IN_PHASE)
				/* data in */
				resid = sbic_xfin(dev, dev->sc_dleft,
				    		 dev->sc_daddr);
			else	/* data out */
				resid = sbic_xfout(dev, dev->sc_dleft,
				    		  dev->sc_daddr);

			dev->sc_daddr += (acb->dleft - resid);
			dev->sc_dleft = resid;
		} else {
			int datain = SBIC_PHASE(csr) == DATA_IN_PHASE;

			/* Perform transfer using DMA */
			sbic_dma_setup(dev, datain);

			SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI |
			    SBIC_CTL_DMA);

			SBIC_DEBUG(DMA, ("DMA xfer: %d(%p:%x)\n", dev->target,
				       dev->sc_daddr, dev->sc_dleft));

			/* Setup byte count for transfer */
			SBIC_TC_PUT(dev, (unsigned)dev->sc_dleft);

			/* Start the transfer */
			SET_SBIC_cmd(dev, SBIC_CMD_XFER_INFO);

			/* Start the DMA chip going */
			dev->sc_tcnt = dev->sc_dmago(dev);

			/* Indicate that we're in DMA mode */
			dev->sc_flags |= SBICF_INDMA;
		}
		break;

	case SBIC_CSR_XFERRED | MESG_IN_PHASE:
	case SBIC_CSR_MIS     | MESG_IN_PHASE:
	case SBIC_CSR_MIS_1   | MESG_IN_PHASE:
	case SBIC_CSR_MIS_2   | MESG_IN_PHASE:

		sbic_dma_stop(dev);

		/* Handle a single message in... */
		return sbic_msgin_phase(dev, 0);

	case SBIC_CSR_MSGIN_W_ACK:

		/*
		 * We should never see this since it's handled in
		 * 'sbic_msgin_phase()' but just for the sake of paranoia...
		 */
		SET_SBIC_cmd(dev, SBIC_CMD_CLR_ACK);

		printf("Acking unknown msgin CSR:%02x",csr);
		break;

	case SBIC_CSR_XFERRED | MESG_OUT_PHASE:
	case SBIC_CSR_MIS     | MESG_OUT_PHASE:
	case SBIC_CSR_MIS_1   | MESG_OUT_PHASE:
	case SBIC_CSR_MIS_2   | MESG_OUT_PHASE:

		/*
		 * Message out phase.  ATN signal has been asserted
		 */
		sbic_dma_stop(dev);
		sbic_msgout(dev);
		return SBIC_STATE_RUNNING;

	case SBIC_CSR_DISC:
	case SBIC_CSR_DISC_1:
		SBIC_DEBUG(RSEL, ("sbicnext target %d disconnected\n",
			       dev->target));
		sbic_dma_stop(dev);

		dev->sc_nexus = NULL;
		dev->sc_state = SBIC_IDLE;
		dev->sc_flags = 0;

		++dev->sc_tinfo[dev->target].dconns;
		++dev->sc_disc;

		if (acb->xs->xs_control & XS_CTL_POLL || sbic_nodisc)
			return SBIC_STATE_DISCONNECT;

		/* Try to schedule another target */
		sbic_sched(dev);

		return SBIC_STATE_DISCONNECT;

	case SBIC_CSR_RSLT_NI:
	case SBIC_CSR_RSLT_IFY:
	{
		/*
		 * A reselection.
		 * Note that since we don't enable Advanced Features (assuming
		 * the WD chip is at least the 'A' revision), we're only ever
		 * likely to see the 'SBIC_CSR_RSLT_NI' status. But for the
		 * hell of it, we'll handle it anyway, for all the extra code
		 * it needs...
		 */
		u_char  newtarget, newlun;

		if (dev->sc_flags & SBICF_INDMA) {
			printf("**** RESELECT WHILE DMA ACTIVE!!! ***\n");
			sbic_dma_stop(dev);
		}

		dev->sc_state = SBIC_RESELECTED;
		GET_SBIC_rselid(dev, newtarget);

		/* check SBIC_RID_SIV? */
		newtarget &= SBIC_RID_MASK;

		if (csr == SBIC_CSR_RSLT_IFY) {
			/* Read Identify msg to avoid lockup */
			GET_SBIC_data(dev, newlun);
			WAIT_CIP(dev);
			newlun &= SBIC_TLUN_MASK;
			dev->sc_msgify = MSG_IDENTIFY(newlun, 0);
		} else {
			/*
			 * Need to read Identify message the hard way, assuming
			 * the target even sends us one...
			 */
			for (newlun = 255; newlun; --newlun) {
				GET_SBIC_asr(dev, asr);
				if (asr & SBIC_ASR_INT)
					break;
				DELAY(10);
			}

			/* If we didn't get an interrupt, somethink's up */
			if ((asr & SBIC_ASR_INT) == 0) {
				printf("%s: Reselect without identify? asr %x\n",
				    dev->sc_dev.dv_xname, asr);
				newlun = 0; /* XXXX */
			} else {
				/*
				 * We got an interrupt, verify that it's a
				 * change to message in phase, and if so
				 * read the message.
				 */
				GET_SBIC_csr(dev,csr);

				if (csr == (SBIC_CSR_MIS   | MESG_IN_PHASE) ||
				    csr == (SBIC_CSR_MIS_1 | MESG_IN_PHASE) ||
				    csr == (SBIC_CSR_MIS_2 | MESG_IN_PHASE)) {
					/*
					 * Yup, gone to message in.
					 * Fetch the target LUN
					 */
					dev->sc_msgify = 0;
					sbic_msgin_phase(dev, 1);
					newlun = dev->sc_msgify & SBIC_TLUN_MASK;
				} else {
					/*
					 * Whoops! Target didn't go to msg_in
					 * phase!!
					 */
					printf("RSLT_NI - not MESG_IN_PHASE %x\n", csr);
					newlun = 0; /* XXXSCW */
				}
			}
		}

		/* Ok, we have the identity of the reselecting target. */
		SBIC_DEBUG(RSEL, ("sbicnext: reselect from targ %d lun %d",
			       newtarget, newlun));
		sbic_reselect(dev, newtarget, newlun, 0, 0);
		dev->sc_disc--;

		if (csr == SBIC_CSR_RSLT_IFY)
			SET_SBIC_cmd(dev, SBIC_CMD_CLR_ACK);
		break;
	}

	default:
        abort:
		/* Something unexpected happend -- deal with it. */
		printf("next: aborting asr 0x%02x csr 0x%02x\n", asr, csr);

#ifdef DDB
		Debugger();
#endif

		SET_SBIC_control(dev, SBIC_CTL_EDI | SBIC_CTL_IDI);
		if (acb->xs)
			sbic_error(dev, acb);
		sbic_abort(dev, acb, "next");

		if (dev->sc_flags & SBICF_INDMA) {
			sbic_dma_stop(dev);
			sbic_scsidone(dev, acb, STATUS_UNKNOWN);
		}
		return SBIC_STATE_ERROR;
	}
	return SBIC_STATE_RUNNING;
}


void
sbic_reselect(dev, target, lun, tag_type, tag_id)
	struct sbic_softc   *dev;
	int    target;
	int    lun;
	int    tag_type;
	int    tag_id;
{

	struct sbic_tinfo *ti;
	struct sbic_linfo *li;
	struct sbic_acb   *acb;

	if (dev->sc_nexus) {
		/*
		 * Whoops! We've been reselected with a
		 * command in progress!
		 * The best we can do is to put the current
		 * command back on the ready list and hope
		 * for the best.
		 */
		SBIC_DEBUG(RSEL, ("%s: reselect with active command\n",
			       dev->sc_dev.dv_xname));
		ti = &dev->sc_tinfo[dev->target];
		li = TINFO_LUN(ti, dev->lun);
		li->state = L_STATE_IDLE;

		sbic_dequeue(dev, dev->sc_nexus);
		TAILQ_INSERT_HEAD(&dev->ready_list, dev->sc_nexus, chain);
		dev->sc_nexus->flags |= ACB_READY;

		dev->sc_nexus = NULL;
	}

	/* Setup state for new nexus */
	acb = NULL;
	dev->sc_flags = SBICF_SELECTED;
	dev->sc_msgpriq = dev->sc_msgout = dev->sc_msgoutq = 0;

	ti = &dev->sc_tinfo[target];
	li = TINFO_LUN(ti, lun);

	if (li != NULL) {
		if (li->untagged != NULL && li->state)
			acb = li->untagged;
		else if (tag_type != MSG_SIMPLE_Q_TAG) {
			/* Wait for tag to come by during MESG_IN Phase */
			dev->target    = target; /* setup I_T_L nexus */
			dev->lun       = lun;
			dev->sc_state  = SBIC_IDENTIFIED;
			return;
		} else if (tag_type)
			acb = li->queued[tag_id];
	}

	if (acb == NULL) {
		printf("%s: reselect from target %d lun %d tag %x:%x "
		    "with no nexus; sending ABORT\n",
		    dev->sc_dev.dv_xname, target, lun, tag_type, tag_id);
		goto abort;
	}

	dev->target    = target;
	dev->lun       = lun;
	dev->sc_nexus  = acb;
	dev->sc_state  = SBIC_CONNECTED;

	/* Do an implicit RESTORE POINTERS. */
	dev->sc_daddr = acb->daddr;
	dev->sc_dleft = acb->dleft;

	/* Set sync modes for new target */
	sbic_setsync(dev, ti);

	if (acb->flags & ACB_RESET)
		sbic_sched_msgout(dev, SEND_DEV_RESET);
	else if (acb->flags & ACB_ABORT)
		sbic_sched_msgout(dev, SEND_ABORT);
	return;

abort:
	sbic_sched_msgout(dev, SEND_ABORT);
	return;

}

void
sbic_update_xfer_mode(sc, target)
	struct sbic_softc *sc;
	int target;
{
	struct sbic_tinfo *ti = &sc->sc_tinfo[target];
	struct scsipi_xfer_mode xm;

	xm.xm_target = target;
	xm.xm_mode = 0;
	xm.xm_period = 0;
	xm.xm_offset = 0;

	if (ti->flags & T_SYNCMODE) {
		xm.xm_mode |= PERIPH_CAP_SYNC;
		xm.xm_period = ti->period;
		xm.xm_offset = ti->offset;
	}

	if ((ti->flags & (T_NODISC|T_TAG)) == T_TAG)
		xm.xm_mode |= PERIPH_CAP_TQING;
	
	scsipi_async_event(&sc->sc_channel, ASYNC_EVENT_XFER_MODE, &xm);
}


/*
 * Convert SCSI Transfer Period Factor (in 4ns units) to the divisor
 *  value used by the WD33c93 controller.
 *
 * cycle = DIV / (2 * CLK)
 * DIV = FS + 2
 * best we can do is 200ns at 20Mhz, 2 cycles
 */
int
sbic_div2stp(dev, div)
	struct sbic_softc *dev;
	int div;
{
	unsigned int fs;

	GET_SBIC_myid(dev, fs);
	fs = (fs >> 6) + 2;		/* DIV */
	fs = (fs * 10000) / (dev->sc_clkfreq << 1); /* Cycle, in ns */
	if (div < 2)
		div = 8;		/* map to Cycles */
	return ((fs * div) >> 2);	/* in 4 ns units */
}

/*
 * Calculate SCSI Tranfser Period Factor (4ns units each) from the
 * WD33c93 divisor value
 */
int
sbic_stp2div(dev, stp)
	struct sbic_softc *dev;
	int stp;
{
	unsigned fs, div;

	/* Just the inverse of the above */
	GET_SBIC_myid(dev, fs);
	fs = (fs >> 6) + 2;     /* DIV */
	fs = (fs * 10000) / (dev->sc_clkfreq << 1); /* Cycle, in ns */
	div = stp << 2;			/* in ns units */
	div = div / fs;			/* in Cycles */
	if (div < 2)
		return(2);

	/* verify rounding */
	if (sbic_div2stp(dev, div) < stp)
		div++;

	return((div >= 8) ? 0 : div);
}

void
sbic_timeout(arg)
	void *arg;
{
	struct sbic_acb *acb = arg;
	struct scsipi_xfer *xs = acb->xs;
	struct scsipi_periph *periph = xs->xs_periph;
	struct sbic_softc *dev =
	    (void *)periph->periph_channel->chan_adapter->adapt_dev;
	int    s, asr;

	s = splbio();

	GET_SBIC_asr(dev, asr);
			
	scsipi_printaddr(periph);
	printf("%s: timed out; asr=0x%02x [acb %p (flags 0x%x, dleft %x)], "
	    "<state %d, nexus %p, resid %lx, msg(q %x,o %x)>",
	    dev->sc_dev.dv_xname, asr, acb, acb->flags, acb->dleft,
	    dev->sc_state, dev->sc_nexus, (long)dev->sc_dleft,
	    dev->sc_msgpriq, dev->sc_msgout);

	if (asr & SBIC_ASR_INT) {
		/* We need to service a missed IRQ */
		sbic_intr(dev);
	} else {
		(void) sbic_abort(dev, dev->sc_nexus, "timeout");
	}
	splx(s);
}


void
sbic_watchdog(arg)
	void *arg;
{
	struct sbic_softc *dev = arg;
	struct sbic_tinfo *ti;
	struct sbic_linfo *li;
	int t, s, l;
	/* scrub LUN's that have not been used in the last 10min. */
	time_t old = time.tv_sec - (10 * 60);

	for (t = 0; t < SBIC_NTARG; t++) {
		ti = &dev->sc_tinfo[t];
		for (l = 0; l < SBIC_NLUN; l++) {
			s = splbio();
			li = TINFO_LUN(ti, l);
			if (li && li->last_used < old &&
			    li->untagged == NULL && li->used == 0) {
				ti->lun[li->lun] = NULL;
				free(li, M_DEVBUF);
			}
			splx(s);
		}
	}
	callout_reset(&dev->sc_watchdog, 60 * hz, sbic_watchdog, dev);
}


#ifdef DEBUG
void
sbic_hexdump(buf, len)
	u_char *buf;
	int    len;
{
	printf("{%d}:", len);
	while (len--)
		printf(" %02x", *buf++);
	printf("\n");
}


void
sbic_print_csr(csr)
	u_char  csr;
{
	switch (SCSI_PHASE(csr)) {
	case CMD_PHASE:
		printf("CMD_PHASE\n");
		break;

	case STATUS_PHASE:
		printf("STATUS_PHASE\n");
		break;

	case DATA_IN_PHASE:
		printf("DATAIN_PHASE\n");
		break;

	case DATA_OUT_PHASE:
		printf("DATAOUT_PHASE\n");
		break;

	case MESG_IN_PHASE:
		printf("MESG_IN_PHASE\n");
		break;
	
	case MESG_OUT_PHASE:
		printf("MESG_OUT_PHASE\n");
		break;

	default:
		switch (csr) {
		case SBIC_CSR_DISC_1:
			printf("DISC_1\n");
			break;

		case SBIC_CSR_RSLT_NI:
			printf("RESELECT_NO_IFY\n");
			break;

		case SBIC_CSR_RSLT_IFY:
			printf("RESELECT_IFY\n");
			break;

		case SBIC_CSR_SLT:
			printf("SELECT\n");
			break;

		case SBIC_CSR_SLT_ATN:
			printf("SELECT, ATN\n");
			break;

		case SBIC_CSR_UNK_GROUP:
			printf("UNK_GROUP\n");
			break;

		default:
			printf("UNKNOWN csr=%02x\n", csr);
		}
	}
}
#endif