xref: /src/sys/dev/ic/sunscpal.c

/*	$NetBSD: sunscpal.c,v 1.7 2001/08/17 00:24:09 fredette Exp $	*/

/*
 * Copyright (c) 2001 Matthew Fredette
 * Copyright (c) 1995 David Jones, Gordon W. Ross
 * Copyright (c) 1994 Jarle Greipsland
 * 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. The name of the authors may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 * 4. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by
 *      David Jones and Gordon Ross
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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.
 */

/*
 * This is a machine-independent driver for the Sun "sc"
 * SCSI Bus Controller (SBC).
 *
 * This code should work with any memory-mapped card,
 * and can be shared by multiple adapters that address
 * the card with different register offset spacings.
 * (This can happen on the atari, for example.)
 *
 * Credits, history:
 *
 * Matthew Fredette completely copied revision 1.38 of
 * ncr5380sbc.c, and then heavily modified it to match
 * the Sun sc PAL.  The remaining credits are for
 * ncr5380sbc.c:
 *
 * David Jones is the author of most of the code that now
 * appears in this file, and was the architect of the
 * current overall structure (MI/MD code separation, etc.)
 *
 * Gordon Ross integrated the message phase code, added lots of
 * comments about what happens when and why (re. SCSI spec.),
 * debugged some reentrance problems, and added several new
 * "hooks" needed for the Sun3 "si" adapters.
 *
 * The message in/out code was taken nearly verbatim from
 * the aic6360 driver by Jarle Greipsland.
 *
 * Several other NCR5380 drivers were used for reference
 * while developing this driver, including work by:
 *   The Alice Group (mac68k port) namely:
 *       Allen K. Briggs, Chris P. Caputo, Michael L. Finch,
 *       Bradley A. Grantham, and Lawrence A. Kesteloot
 *   Michael L. Hitch (amiga drivers: sci.c)
 *   Leo Weppelman (atari driver: ncr5380.c)
 * There are others too.  Thanks, everyone.
 *
 * Transliteration to bus_space() performed 9/17/98 by
 * John Ruschmeyer (jruschme (at) exit109.com) for i386 'nca' driver.
 * Thank you all.
 */

#include "opt_ddb.h"

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/errno.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/user.h>

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

#ifdef DDB
#include <ddb/db_output.h>
#endif

#include <dev/ic/sunscpalreg.h>
#include <dev/ic/sunscpalvar.h>

static void	sunscpal_reset_scsibus __P((struct sunscpal_softc *));
static void	sunscpal_sched __P((struct sunscpal_softc *));
static void	sunscpal_done __P((struct sunscpal_softc *));

static int	sunscpal_select
	__P((struct sunscpal_softc *, struct sunscpal_req *));
static void	sunscpal_reselect __P((struct sunscpal_softc *));

static int	sunscpal_msg_in __P((struct sunscpal_softc *));
static int	sunscpal_msg_out __P((struct sunscpal_softc *));
static int	sunscpal_data_xfer __P((struct sunscpal_softc *, int));
static int	sunscpal_command __P((struct sunscpal_softc *));
static int	sunscpal_status __P((struct sunscpal_softc *));
static void	sunscpal_machine __P((struct sunscpal_softc *));

void	sunscpal_abort __P((struct sunscpal_softc *));
void	sunscpal_cmd_timeout __P((void *));
/*
 * Action flags returned by the info_transfer functions:
 * (These determine what happens next.)
 */
#define ACT_CONTINUE	0x00	/* No flags: expect another phase */
#define ACT_DISCONNECT	0x01	/* Target is disconnecting */
#define ACT_CMD_DONE	0x02	/* Need to call scsipi_done() */
#define ACT_RESET_BUS	0x04	/* Need bus reset (cmd timeout) */
#define ACT_WAIT_DMA	0x10	/* Wait for DMA to complete */

/*****************************************************************
 * Debugging stuff
 *****************************************************************/

#ifndef DDB
/* This is used only in recoverable places. */
#ifndef Debugger
#define Debugger() printf("Debug: sunscpal.c:%d\n", __LINE__)
#endif
#endif

#ifdef	SUNSCPAL_DEBUG

#define	SUNSCPAL_DBG_BREAK	1
#define	SUNSCPAL_DBG_CMDS	2
#define	SUNSCPAL_DBG_DMA	4
int sunscpal_debug = 0;
#define	SUNSCPAL_BREAK() \
	do { if (sunscpal_debug & SUNSCPAL_DBG_BREAK) Debugger(); } while (0)
static void sunscpal_show_scsi_cmd __P((struct scsipi_xfer *));
#ifdef DDB
void	sunscpal_clear_trace __P((void));
void	sunscpal_show_trace __P((void));
void	sunscpal_show_req __P((struct sunscpal_req *));
void	sunscpal_show_state __P((void));
#endif	/* DDB */
#else	/* SUNSCPAL_DEBUG */

#define	SUNSCPAL_BREAK() 		/* nada */
#define sunscpal_show_scsi_cmd(xs) /* nada */

#endif	/* SUNSCPAL_DEBUG */

static char *
phase_names[8] = {
	"DATA_OUT",
	"DATA_IN",
	"COMMAND",
	"STATUS",
	"UNSPEC1",
	"UNSPEC2",
	"MSG_OUT",
	"MSG_IN",
};

#ifdef SUNSCPAL_USE_BUS_DMA
static void sunscpal_dma_alloc __P((struct sunscpal_softc *));
static void sunscpal_dma_free __P((struct sunscpal_softc *));
static void sunscpal_dma_setup __P((struct sunscpal_softc *));
#else
#define sunscpal_dma_alloc(sc) (*sc->sc_dma_alloc)(sc)
#define sunscpal_dma_free(sc) (*sc->sc_dma_free)(sc)
#define sunscpal_dma_setup(sc) (*sc->sc_dma_setup)(sc)
#endif
static void sunscpal_minphys __P((struct buf *));

/*****************************************************************
 * Actual chip control
 *****************************************************************/

/*
 * XXX: These timeouts might need to be tuned...
 */

/* This one is used when waiting for a phase change. (X100uS.) */
int sunscpal_wait_phase_timo = 1000 * 10 * 300;	/* 5 min. */

/* These are used in the following inline functions. */
int sunscpal_wait_req_timo = 1000 * 50;	/* X2 = 100 mS. */
int sunscpal_wait_nrq_timo = 1000 * 25;	/* X2 =  50 mS. */

static __inline int sunscpal_wait_req __P((struct sunscpal_softc *));
static __inline int sunscpal_wait_not_req __P((struct sunscpal_softc *));
static __inline void sunscpal_sched_msgout __P((struct sunscpal_softc *, int));

/* Return zero on success. */
static __inline int sunscpal_wait_req(sc)
	struct sunscpal_softc *sc;
{
	int timo = sunscpal_wait_req_timo;
	for (;;) {
		if (SUNSCPAL_READ_2(sc, sunscpal_icr) & SUNSCPAL_ICR_REQUEST) {
			timo = 0;	/* return 0 */
			break;
		}
		if (--timo < 0)
			break;	/* return -1 */
		delay(2);
	}
	return (timo);
}

/* Return zero on success. */
static __inline int sunscpal_wait_not_req(sc)
	struct sunscpal_softc *sc;
{
	int timo = sunscpal_wait_nrq_timo;
	for (;;) {
		if ((SUNSCPAL_READ_2(sc, sunscpal_icr) & SUNSCPAL_ICR_REQUEST) == 0) {
			timo = 0;	/* return 0 */
			break;
		}
		if (--timo < 0)
			break;	/* return -1 */
		delay(2);
	}
	return (timo);
}

/*
 * These functions control DMA functions in the chipset independent of
 * the host DMA implementation.
 */
static void sunscpal_dma_start __P((struct sunscpal_softc *));
static void sunscpal_dma_poll __P((struct sunscpal_softc *));
static void sunscpal_dma_stop __P((struct sunscpal_softc *));

static void
sunscpal_dma_start(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	int xlen;
	u_int16_t icr;

	xlen = sc->sc_reqlen;

	/* Let'er rip! */
	icr = SUNSCPAL_READ_2(sc, sunscpal_icr);
	icr |= SUNSCPAL_ICR_DMA_ENABLE |
	    ((xlen & 1) ? 0 : SUNSCPAL_ICR_WORD_MODE) |
	    ((sr->sr_flags & SR_IMMED) ? 0 : SUNSCPAL_ICR_INTERRUPT_ENABLE);
	SUNSCPAL_WRITE_2(sc, sunscpal_icr, icr);

	sc->sc_state |= SUNSCPAL_DOINGDMA;

#ifdef	SUNSCPAL_DEBUG
	if (sunscpal_debug & SUNSCPAL_DBG_DMA) {
		printf("sunscpal_dma_start: started, flags=0x%x\n",
			   sc->sc_state);
	}
#endif
}

#define	ICR_MASK (SUNSCPAL_ICR_PARITY_ERROR | SUNSCPAL_ICR_BUS_ERROR | SUNSCPAL_ICR_INTERRUPT_REQUEST)
#define	POLL_TIMO	50000	/* X100 = 5 sec. */

/*
 * Poll (spin-wait) for DMA completion.
 * Called right after xx_dma_start(), and
 * xx_dma_stop() will be called next.
 */
static void
sunscpal_dma_poll(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	int tmo;

	/* Make sure DMA started successfully. */
	if (sc->sc_state & SUNSCPAL_ABORTING)
		return;

	/* Wait for any "dma complete" or error bits. */
	tmo = POLL_TIMO;
	for (;;) {
		if (SUNSCPAL_READ_2(sc, sunscpal_icr) & ICR_MASK)
			break;
		if (--tmo <= 0) {
			printf("sc: DMA timeout (while polling)\n");
			/* Indicate timeout as MI code would. */
			sr->sr_flags |= SR_OVERDUE;
			break;
		}
		delay(100);
	}
	SUNSCPAL_TRACE("sunscpal_dma_poll: waited %d\n",
			  POLL_TIMO - tmo);

#ifdef	SUNSCPAL_DEBUG
	if (sunscpal_debug & SUNSCPAL_DBG_DMA) {
		char buffer[64];
		bitmask_snprintf(SUNSCPAL_READ_2(sc, sunscpal_icr), SUNSCPAL_ICR_BITS, buffer, sizeof(buffer));
		printf("sunscpal_dma_poll: done, icr=%s\n", buffer);
	}
#endif
}

static void
sunscpal_dma_stop(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	struct scsipi_xfer *xs = sr->sr_xs;
	int resid, ntrans;
	u_int16_t icr;

	if ((sc->sc_state & SUNSCPAL_DOINGDMA) == 0) {
#ifdef	DEBUG
		printf("sunscpal_dma_stop: dma not running\n");
#endif
		return;
	}
	sc->sc_state &= ~SUNSCPAL_DOINGDMA;

	/* First, halt the DMA engine. */
	icr = SUNSCPAL_READ_2(sc, sunscpal_icr);
	icr &= ~(SUNSCPAL_ICR_DMA_ENABLE | SUNSCPAL_ICR_WORD_MODE | SUNSCPAL_ICR_INTERRUPT_ENABLE);
	SUNSCPAL_WRITE_2(sc, sunscpal_icr, icr);

#ifdef	SUNSCPAL_USE_BUS_DMA
	/*
	 * XXX - this function is supposed to be independent of
	 * the host's DMA implementation.
	 */
 {
	 sunscpal_dma_handle_t dh = sr->sr_dma_hand;

	 /* sync the DMA map: */
	 bus_dmamap_sync(sc->sunscpal_dmat, dh->dh_dmamap, 0, dh->dh_maplen,
	     ((xs->xs_control & XS_CTL_DATA_OUT) == 0 ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE));
 }
#endif /* SUNSCPAL_USE_BUS_DMA */


	if (icr & (SUNSCPAL_ICR_BUS_ERROR)) {
		char buffer[64];
		bitmask_snprintf(icr, SUNSCPAL_ICR_BITS, buffer, sizeof(buffer));
		printf("sc: DMA error, icr=%s, reset\n", buffer);
		sr->sr_xs->error = XS_DRIVER_STUFFUP;
		sc->sc_state |= SUNSCPAL_ABORTING;
		goto out;
	}

	/* Note that timeout may have set the error flag. */
	if (sc->sc_state & SUNSCPAL_ABORTING)
		goto out;

	/* XXX: Wait for DMA to actually finish? */

	/*
	 * Now try to figure out how much actually transferred
	 */

	resid = SUNSCPAL_DMA_COUNT_FLIP(SUNSCPAL_READ_2(sc, sunscpal_dma_count));
	ntrans = sc->sc_reqlen - resid;

#ifdef	SUNSCPAL_DEBUG
	if (sunscpal_debug & SUNSCPAL_DBG_DMA) {
		printf("sunscpal_dma_stop: resid=0x%x ntrans=0x%x\n",
		       resid, ntrans);
	}
#endif

	if (ntrans < sc->sc_min_dma_len) {
		printf("sc: DMA count: 0x%x\n", resid);
		sc->sc_state |= SUNSCPAL_ABORTING;
		goto out;
	}
	if (ntrans > sc->sc_datalen)
		panic("sunscpal_dma_stop: excess transfer");

	/* Adjust data pointer */
	sc->sc_dataptr += ntrans;
	sc->sc_datalen -= ntrans;

	/*
	 * After a read, we may need to clean-up
	 * "Left-over bytes" (yuck!)
	 */
	if (((xs->xs_control & XS_CTL_DATA_OUT) == 0) &&
		((icr & SUNSCPAL_ICR_ODD_LENGTH) != 0))
	{
#ifdef DEBUG
		printf("sc: Got Left-over bytes!\n");
#endif
		*(sc->sc_dataptr++) = SUNSCPAL_READ_1(sc, sunscpal_data);
		sc->sc_datalen--;
	}

out:
	SUNSCPAL_WRITE_2(sc, sunscpal_dma_count, SUNSCPAL_DMA_COUNT_FLIP(0));

}

/* Ask the target for a MSG_OUT phase. */
static __inline void
sunscpal_sched_msgout(sc, msg_code)
	struct sunscpal_softc *sc;
	int msg_code;
{
	/*
	 * This controller does not allow you to assert ATN, which
	 * will eventually leave us with no option other than to reset
	 * the bus.  We keep this function as a placeholder, though,
	 * and this printf will eventually go away or get #ifdef'ed:
	 */
	printf("sunscpal_sched_msgout: trying to schedule 0x%0x\n", msg_code);
	sc->sc_msgpriq |= msg_code;
}

int
sunscpal_pio_out(sc, phase, count, data)
	struct sunscpal_softc *sc;
	int phase, count;
	unsigned char *data;
{
	int resid;

	resid = count;
	while (resid > 0) {
		if (!SUNSCPAL_BUSY(sc)) {
			SUNSCPAL_TRACE("pio_out: lost BSY, resid=%d\n", resid);
			break;
		}
		if (sunscpal_wait_req(sc)) {
			SUNSCPAL_TRACE("pio_out: no REQ, resid=%d\n", resid);
			break;
		}
		if (SUNSCPAL_BUS_PHASE(SUNSCPAL_READ_2(sc, sunscpal_icr)) != phase)
			break;

		/* Put the data on the bus. */
		if (data) {
			SUNSCPAL_BYTE_WRITE(sc, phase, *data++);
		} else {
			SUNSCPAL_BYTE_WRITE(sc, phase, 0);
		}

		--resid;
	}

	return (count - resid);
}


int
sunscpal_pio_in(sc, phase, count, data)
	struct sunscpal_softc *sc;
	int phase, count;
	unsigned char			*data;
{
	int resid;

	resid = count;
	while (resid > 0) {
		if (!SUNSCPAL_BUSY(sc)) {
			SUNSCPAL_TRACE("pio_in: lost BSY, resid=%d\n", resid);
			break;
		}
		if (sunscpal_wait_req(sc)) {
			SUNSCPAL_TRACE("pio_in: no REQ, resid=%d\n", resid);
			break;
		}
		/* A phase change is not valid until AFTER REQ rises! */
		if (SUNSCPAL_BUS_PHASE(SUNSCPAL_READ_2(sc, sunscpal_icr)) != phase)
			break;

		/* Read the data bus. */
		if (data)
			*data++ = SUNSCPAL_BYTE_READ(sc, phase);
		else
			(void) SUNSCPAL_BYTE_READ(sc, phase);

		--resid;
	}

	return (count - resid);
}


void
sunscpal_init(sc)
	struct sunscpal_softc *sc;
{
	int i, j;

#ifdef	SUNSCPAL_DEBUG
	sunscpal_debug_sc = sc;
#endif

	for (i = 0; i < SUNSCPAL_OPENINGS; i++)
		sc->sc_ring[i].sr_xs = NULL;
	for (i = 0; i < 8; i++)
		for (j = 0; j < 8; j++)
			sc->sc_matrix[i][j] = NULL;

	sc->sc_prevphase = SUNSCPAL_PHASE_INVALID;
	sc->sc_state = SUNSCPAL_IDLE;

	SUNSCPAL_WRITE_2(sc, sunscpal_icr, 0);
	SUNSCPAL_WRITE_2(sc, sunscpal_dma_addr_h, 0);
	SUNSCPAL_WRITE_2(sc, sunscpal_dma_addr_l, 0);
	SUNSCPAL_WRITE_2(sc, sunscpal_dma_count, SUNSCPAL_DMA_COUNT_FLIP(0));

	SUNSCPAL_CLR_INTR(sc);

	/* Another hack (Er.. hook!) for anything that needs it: */
	if (sc->sc_intr_on) {
		SUNSCPAL_TRACE("init: intr ON\n", 0);
		sc->sc_intr_on(sc);
	}
}


static void
sunscpal_reset_scsibus(sc)
	struct sunscpal_softc *sc;
{

	SUNSCPAL_TRACE("reset_scsibus, cur=0x%x\n",
			  (long) sc->sc_current);

	SUNSCPAL_WRITE_2(sc, sunscpal_icr, SUNSCPAL_ICR_RESET);
	delay(500);
	SUNSCPAL_WRITE_2(sc, sunscpal_icr, 0);

	SUNSCPAL_CLR_INTR(sc);
	/* XXX - Need long delay here! */
	delay(100000);

	/* XXX - Need to cancel disconnected requests. */
}


/*
 * Interrupt handler for the SCSI Bus Controller (SBC)
 * This may also called for a DMA timeout (at splbio).
 */
int
sunscpal_intr(arg)
	void *arg;
{
	struct sunscpal_softc *sc = arg;
	int claimed = 0;

	/*
	 * Do not touch SBC regs here unless sc_current == NULL
	 * or it will complain about "register conflict" errors.
	 * Instead, just let sunscpal_machine() deal with it.
	 */
	SUNSCPAL_TRACE("intr: top, state=%d\n", sc->sc_state);

	if (sc->sc_state == SUNSCPAL_IDLE) {
		/*
		 * Might be reselect.  sunscpal_reselect() will check,
		 * and set up the connection if so.  This will verify
		 * that sc_current == NULL at the beginning...
		 */

		/* Another hack (Er.. hook!) for anything that needs it: */
		if (sc->sc_intr_off) {
			SUNSCPAL_TRACE("intr: for reselect, intr off\n", 0);
		    sc->sc_intr_off(sc);
		}

		sunscpal_reselect(sc);
	}

	/*
	 * The remaining documented interrupt causes are a DMA complete
	 * condition.
	 *
	 * The procedure is to let sunscpal_machine() figure out what
	 * to do next.
	 */
	if (sc->sc_state & SUNSCPAL_WORKING) {
		SUNSCPAL_TRACE("intr: call machine, cur=0x%x\n",
				  (long) sc->sc_current);
		/* This will usually free-up the nexus. */
		sunscpal_machine(sc);
		SUNSCPAL_TRACE("intr: machine done, cur=0x%x\n",
				  (long) sc->sc_current);
		claimed = 1;
	}

	/* Maybe we can run some commands now... */
	if (sc->sc_state == SUNSCPAL_IDLE) {
		SUNSCPAL_TRACE("intr: call sched, cur=0x%x\n",
				  (long) sc->sc_current);
		sunscpal_sched(sc);
		SUNSCPAL_TRACE("intr: sched done, cur=0x%x\n",
				  (long) sc->sc_current);
	}

	return claimed;
}


/*
 * Abort the current command (i.e. due to timeout)
 */
void
sunscpal_abort(sc)
	struct sunscpal_softc *sc;
{

	/*
	 * Finish it now.  If DMA is in progress, we
	 * can not call sunscpal_sched_msgout() because
	 * that hits the SBC (avoid DMA conflict).
	 */

	/* Another hack (Er.. hook!) for anything that needs it: */
	if (sc->sc_intr_off) {
		SUNSCPAL_TRACE("abort: intr off\n", 0);
		sc->sc_intr_off(sc);
	}

	sc->sc_state |= SUNSCPAL_ABORTING;
	if ((sc->sc_state & SUNSCPAL_DOINGDMA) == 0) {
		sunscpal_sched_msgout(sc, SEND_ABORT);
	}
	SUNSCPAL_TRACE("abort: call machine, cur=0x%x\n",
			  (long) sc->sc_current);
	sunscpal_machine(sc);
	SUNSCPAL_TRACE("abort: machine done, cur=0x%x\n",
			  (long) sc->sc_current);

	/* Another hack (Er.. hook!) for anything that needs it: */
	if (sc->sc_intr_on) {
		SUNSCPAL_TRACE("abort: intr ON\n", 0);
	    sc->sc_intr_on(sc);
	}
}

/*
 * Timeout handler, scheduled for each SCSI command.
 */
void
sunscpal_cmd_timeout(arg)
	void *arg;
{
	struct sunscpal_req *sr = arg;
	struct scsipi_xfer *xs;
	struct scsipi_periph *periph;
	struct sunscpal_softc *sc;
	int s;

	s = splbio();

	/* Get all our variables... */
	xs = sr->sr_xs;
	if (xs == NULL) {
		printf("sunscpal_cmd_timeout: no scsipi_xfer\n");
		goto out;
	}
	periph = xs->xs_periph;
	sc = (void *)periph->periph_channel->chan_adapter->adapt_dev;

	printf("%s: cmd timeout, targ=%d, lun=%d\n",
	    sc->sc_dev.dv_xname,
	    sr->sr_target, sr->sr_lun);

	/*
	 * Mark the overdue job as failed, and arrange for
	 * sunscpal_machine to terminate it.  If the victim
	 * is the current job, call sunscpal_machine() now.
	 * Otherwise arrange for sunscpal_sched() to do it.
	 */
	sr->sr_flags |= SR_OVERDUE;
	if (sc->sc_current == sr) {
		SUNSCPAL_TRACE("cmd_tmo: call abort, sr=0x%x\n", (long) sr);
		sunscpal_abort(sc);
	} else {
		/*
		 * The driver may be idle, or busy with another job.
		 * Arrange for sunscpal_sched() to do the deed.
		 */
		SUNSCPAL_TRACE("cmd_tmo: clear matrix, t/l=0x%02x\n",
				  (sr->sr_target << 4) | sr->sr_lun);
		sc->sc_matrix[sr->sr_target][sr->sr_lun] = NULL;
	}

	/*
	 * We may have aborted the current job, or may have
	 * already been idle. In either case, we should now
	 * be idle, so try to start another job.
	 */
	if (sc->sc_state == SUNSCPAL_IDLE) {
		SUNSCPAL_TRACE("cmd_tmo: call sched, cur=0x%x\n",
				  (long) sc->sc_current);
		sunscpal_sched(sc);
		SUNSCPAL_TRACE("cmd_tmo: sched done, cur=0x%x\n",
				  (long) sc->sc_current);
	}

out:
	splx(s);
}


/*****************************************************************
 * Interface to higher level
 *****************************************************************/


/*
 * Enter a new SCSI command into the "issue" queue, and
 * if there is work to do, start it going.
 *
 * WARNING:  This can be called recursively!
 * (see comment in sunscpal_done)
 */
void
sunscpal_scsipi_request(chan, req, arg)
	struct scsipi_channel *chan;
	scsipi_adapter_req_t req;
	void *arg;
{
	struct scsipi_xfer *xs;
	struct scsipi_periph *periph;
	struct	sunscpal_softc *sc = (void *)chan->chan_adapter->adapt_dev;
	struct sunscpal_req	*sr;
	int s, i, flags;

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

		if (sc->sc_flags & SUNSCPAL_FORCE_POLLING)
			flags |= XS_CTL_POLL;

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

		s = splbio();

		if (flags & XS_CTL_POLL) {
			/* Terminate any current command. */
			sr = sc->sc_current;
			if (sr) {
				printf("%s: polled request aborting %d/%d\n",
				    sc->sc_dev.dv_xname,
				    sr->sr_target, sr->sr_lun);
				sunscpal_abort(sc);
			}
			if (sc->sc_state != SUNSCPAL_IDLE) {
				panic("sunscpal_scsi_cmd: polled request, abort failed");
			}
		}

		/*
		 * Find lowest empty slot in ring buffer.
		 * XXX: What about "fairness" and cmd order?
		 */
		for (i = 0; i < SUNSCPAL_OPENINGS; i++)
			if (sc->sc_ring[i].sr_xs == NULL)
				goto new;

		xs->error = XS_RESOURCE_SHORTAGE;
		SUNSCPAL_TRACE("scsipi_cmd: no openings, rv=%d\n", rv);
		goto out;

new:
		/* Create queue entry */
		sr = &sc->sc_ring[i];
		sr->sr_xs = xs;
		sr->sr_target = xs->xs_periph->periph_target;
		sr->sr_lun = xs->xs_periph->periph_lun;
		sr->sr_dma_hand = NULL;
		sr->sr_dataptr = xs->data;
		sr->sr_datalen = xs->datalen;
		sr->sr_flags = (flags & XS_CTL_POLL) ? SR_IMMED : 0;
		sr->sr_status = -1;	/* no value */
		sc->sc_ncmds++;

		SUNSCPAL_TRACE("scsipi_cmd: new sr=0x%x\n", (long)sr);

		if (flags & XS_CTL_POLL) {
			/* Force this new command to be next. */
			sc->sc_rr = i;
		}

		/*
		 * If we were idle, run some commands...
		 */
		if (sc->sc_state == SUNSCPAL_IDLE) {
			SUNSCPAL_TRACE("scsipi_cmd: call sched, cur=0x%x\n",
				  (long) sc->sc_current);
			sunscpal_sched(sc);
			SUNSCPAL_TRACE("scsipi_cmd: sched done, cur=0x%x\n",
				  (long) sc->sc_current);
		}

		if (flags & XS_CTL_POLL) {
			/* Make sure sunscpal_sched() finished it. */
			if ((xs->xs_status & XS_STS_DONE) == 0)
				panic("sunscpal_scsi_cmd: poll didn't finish");
		}

out:
		splx(s);
		return;

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

	case ADAPTER_REQ_SET_XFER_MODE:
	    {
		/*
		 * We don't support Sync, Wide, or Tagged Queueing.
		 * Just callback now, to report this.
		 */
		struct scsipi_xfer_mode *xm = arg;

		xm->xm_mode = 0;
		xm->xm_period = 0;
		xm->xm_offset = 0;
		scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm);
		return;
	    }
	}
}


/*
 * POST PROCESSING OF SCSI_CMD (usually current)
 * Called by sunscpal_sched(), sunscpal_machine()
 */
static void
sunscpal_done(sc)
	struct sunscpal_softc *sc;
{
	struct	sunscpal_req *sr;
	struct	scsipi_xfer *xs;

#ifdef	DIAGNOSTIC
	if (sc->sc_state == SUNSCPAL_IDLE)
		panic("sunscpal_done: state=idle");
	if (sc->sc_current == NULL)
		panic("sunscpal_done: current=0");
#endif

	sr = sc->sc_current;
	xs = sr->sr_xs;

	SUNSCPAL_TRACE("done: top, cur=0x%x\n", (long) sc->sc_current);

	/*
	 * Clean up DMA resources for this command.
	 */
	if (sr->sr_dma_hand) {
		SUNSCPAL_TRACE("done: dma_free, dh=0x%x\n",
				  (long) sr->sr_dma_hand);
		sunscpal_dma_free(sc);
	}
#ifdef	DIAGNOSTIC
	if (sr->sr_dma_hand)
		panic("sunscpal_done: dma free did not");
#endif

	if (sc->sc_state & SUNSCPAL_ABORTING) {
		SUNSCPAL_TRACE("done: aborting, error=%d\n", xs->error);
		if (xs->error == XS_NOERROR)
			xs->error = XS_TIMEOUT;
	}

	SUNSCPAL_TRACE("done: check error=%d\n", (long) xs->error);

	/* If error is already set, ignore sr_status value. */
	if (xs->error != XS_NOERROR)
		goto finish;

	SUNSCPAL_TRACE("done: check status=%d\n", sr->sr_status);

	xs->status = sr->sr_status;
	switch (sr->sr_status) {
	case SCSI_OK:	/* 0 */
		break;

	case SCSI_CHECK:
	case SCSI_BUSY:
		xs->error = XS_BUSY;
		break;

	case -1:
		/* This is our "impossible" initial value. */
		/* fallthrough */
	default:
		printf("%s: target %d, bad status=%d\n",
		    sc->sc_dev.dv_xname, sr->sr_target, sr->sr_status);
		xs->error = XS_DRIVER_STUFFUP;
		break;
	}

finish:

	SUNSCPAL_TRACE("done: finish, error=%d\n", xs->error);

	/*
	 * Dequeue the finished command, but don't clear sc_state until
	 * after the call to scsipi_done(), because that may call back to
	 * sunscpal_scsi_cmd() - unwanted recursion!
	 *
	 * Keeping sc->sc_state != idle terminates the recursion.
	 */
#ifdef	DIAGNOSTIC
	if ((sc->sc_state & SUNSCPAL_WORKING) == 0)
		panic("sunscpal_done: bad state");
#endif

	/* Clear our pointers to the request. */
	sc->sc_current = NULL;
	sc->sc_matrix[sr->sr_target][sr->sr_lun] = NULL;
	callout_stop(&sr->sr_xs->xs_callout);

	/* Make the request free. */
	sr->sr_xs = NULL;
	sc->sc_ncmds--;

	/* Tell common SCSI code it is done. */
	scsipi_done(xs);

	sc->sc_state = SUNSCPAL_IDLE;
	/* Now sunscpal_sched() may be called again. */
}


/*
 * Schedule a SCSI operation.  This routine should return
 * only after it achieves one of the following conditions:
 *  	Busy (sc->sc_state != SUNSCPAL_IDLE)
 *  	No more work can be started.
 */
static void
sunscpal_sched(sc)
	struct	sunscpal_softc *sc;
{
	struct sunscpal_req	*sr;
	struct scsipi_xfer *xs;
	int	target = 0, lun = 0;
	int	error, i;

	/* Another hack (Er.. hook!) for anything that needs it: */
	if (sc->sc_intr_off) {
		SUNSCPAL_TRACE("sched: top, intr off\n", 0);
	    sc->sc_intr_off(sc);
	}

next_job:
	/*
	 * Grab the next job from queue.  Must be idle.
	 */
#ifdef	DIAGNOSTIC
	if (sc->sc_state != SUNSCPAL_IDLE)
		panic("sunscpal_sched: not idle");
	if (sc->sc_current)
		panic("sunscpal_sched: current set");
#endif

	/*
	 * Always start the search where we last looked.
	 */
	i = sc->sc_rr;
	sr = NULL;
	do {
		if (sc->sc_ring[i].sr_xs) {
			target = sc->sc_ring[i].sr_target;
			lun = sc->sc_ring[i].sr_lun;
			if (sc->sc_matrix[target][lun] == NULL) {
				/*
				 * Do not mark the  target/LUN busy yet,
				 * because reselect may cause some other
				 * job to become the current one, so we
				 * might not actually start this job.
				 * Instead, set sc_matrix later on.
				 */
				sc->sc_rr = i;
				sr = &sc->sc_ring[i];
				break;
			}
		}
		i++;
		if (i == SUNSCPAL_OPENINGS)
			i = 0;
	} while (i != sc->sc_rr);

	if (sr == NULL) {
		SUNSCPAL_TRACE("sched: no work, cur=0x%x\n",
				  (long) sc->sc_current);

		/* Another hack (Er.. hook!) for anything that needs it: */
		if (sc->sc_intr_on) {
			SUNSCPAL_TRACE("sched: ret, intr ON\n", 0);
		    sc->sc_intr_on(sc);
		}

		return;		/* No more work to do. */
	}

	SUNSCPAL_TRACE("sched: select for t/l=0x%02x\n",
			  (sr->sr_target << 4) | sr->sr_lun);

	sc->sc_state = SUNSCPAL_WORKING;
	error = sunscpal_select(sc, sr);
	if (sc->sc_current) {
		/* Lost the race!  reselected out from under us! */
		/* Work with the reselected job. */
		if (sr->sr_flags & SR_IMMED) {
			printf("%s: reselected while polling (abort)\n",
			    sc->sc_dev.dv_xname);
			/* Abort the reselected job. */
			sc->sc_state |= SUNSCPAL_ABORTING;
			sc->sc_msgpriq |= SEND_ABORT;
		}
		sr = sc->sc_current;
		xs = sr->sr_xs;
		SUNSCPAL_TRACE("sched: reselect, new sr=0x%x\n", (long)sr);
		goto have_nexus;
	}

	/* Normal selection result.  Target/LUN is now busy. */
	sc->sc_matrix[target][lun] = sr;
	sc->sc_current = sr;	/* connected */
	xs = sr->sr_xs;

	/*
	 * Initialize pointers, etc. for this job
	 */
	sc->sc_dataptr  = sr->sr_dataptr;
	sc->sc_datalen  = sr->sr_datalen;
	sc->sc_prevphase = SUNSCPAL_PHASE_INVALID;
	sc->sc_msgpriq = SEND_IDENTIFY;
	sc->sc_msgoutq = 0;
	sc->sc_msgout  = 0;

	SUNSCPAL_TRACE("sched: select rv=%d\n", error);

	switch (error) {
	case XS_NOERROR:
		break;

	case XS_BUSY:
		/* XXX - Reset and try again. */
		printf("%s: select found SCSI bus busy, resetting...\n",
		    sc->sc_dev.dv_xname);
		sunscpal_reset_scsibus(sc);
		/* fallthrough */
	case XS_SELTIMEOUT:
	default:
		xs->error = error;	/* from select */
		SUNSCPAL_TRACE("sched: call done, sr=0x%x\n", (long)sr);
		sunscpal_done(sc);

		/* Paranoia: clear everything. */
		sc->sc_dataptr = NULL;
		sc->sc_datalen = 0;
		sc->sc_prevphase = SUNSCPAL_PHASE_INVALID;
		sc->sc_msgpriq = 0;
		sc->sc_msgoutq = 0;
		sc->sc_msgout  = 0;

		goto next_job;
	}

	/*
	 * Selection was successful.  Normally, this means
	 * we are starting a new command.  However, this
	 * might be the termination of an overdue job.
	 */
	if (sr->sr_flags & SR_OVERDUE) {
		SUNSCPAL_TRACE("sched: overdue, sr=0x%x\n", (long)sr);
		sc->sc_state |= SUNSCPAL_ABORTING;
		sc->sc_msgpriq |= SEND_ABORT;
		goto have_nexus;
	}

	/*
	 * OK, we are starting a new command.
	 * Initialize and allocate resources for the new command.
	 * Device reset is special (only uses MSG_OUT phase).
	 * Normal commands start in MSG_OUT phase where we will
	 * send and IDENDIFY message, and then expect CMD phase.
	 */
#ifdef	SUNSCPAL_DEBUG
	if (sunscpal_debug & SUNSCPAL_DBG_CMDS) {
		printf("sunscpal_sched: begin, target=%d, LUN=%d\n",
		    xs->xs_periph->periph_target, xs->xs_periph->periph_lun);
		sunscpal_show_scsi_cmd(xs);
	}
#endif
	if (xs->xs_control & XS_CTL_RESET) {
		SUNSCPAL_TRACE("sched: cmd=reset, sr=0x%x\n", (long)sr);
		/* Not an error, so do not set SUNSCPAL_ABORTING */
		sc->sc_msgpriq |= SEND_DEV_RESET;
		goto have_nexus;
	}

#ifdef	DIAGNOSTIC
	if ((xs->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT)) == 0) {
		if (sc->sc_dataptr) {
			printf("%s: ptr but no data in/out flags?\n",
			    sc->sc_dev.dv_xname);
			SUNSCPAL_BREAK();
			sc->sc_dataptr = NULL;
		}
	}
#endif

	/* Allocate DMA space (maybe) */
	if (sc->sc_dataptr && (sc->sc_flags & SUNSCPAL_DISABLE_DMA) == 0 &&
		(sc->sc_datalen >= sc->sc_min_dma_len))
	{
		SUNSCPAL_TRACE("sched: dma_alloc, len=%d\n", sc->sc_datalen);
		sunscpal_dma_alloc(sc);
	}

	/*
	 * Initialization hook called just after select,
	 * at the beginning of COMMAND phase.
	 * (but AFTER the DMA allocation is done)
	 *
	 * We need to set up the DMA engine BEFORE the target puts
	 * the SCSI bus into any DATA phase.
	 */
	if (sr->sr_dma_hand) {
		SUNSCPAL_TRACE("sched: dma_setup, dh=0x%x\n",
				  (long) sr->sr_dma_hand);
	    sunscpal_dma_setup(sc);
	}

	/*
	 * Schedule a timeout for the job we are starting.
	 */
	if ((sr->sr_flags & SR_IMMED) == 0) {
		i = (xs->timeout * hz) / 1000;
		SUNSCPAL_TRACE("sched: set timeout=%d\n", i);
		callout_reset(&sr->sr_xs->xs_callout, i,
		    sunscpal_cmd_timeout, sr);
	}

have_nexus:

	SUNSCPAL_TRACE("sched: call machine, cur=0x%x\n",
			  (long) sc->sc_current);
	sunscpal_machine(sc);
	SUNSCPAL_TRACE("sched: machine done, cur=0x%x\n",
			  (long) sc->sc_current);

	/*
	 * What state did sunscpal_machine() leave us in?
	 * Hopefully it sometimes completes a job...
	 */
	if (sc->sc_state == SUNSCPAL_IDLE)
		goto next_job;

	return; 	/* Have work in progress. */
}


/*
 *  Reselect handler: checks for reselection, and if we are being
 *	reselected, it sets up sc->sc_current.
 *
 *  We are reselected when:
 *	SEL is TRUE
 *	IO  is TRUE
 *	BSY is FALSE
 */
void
sunscpal_reselect(sc)
	struct sunscpal_softc *sc;
{
	/*
	 * This controller does not implement disconnect/reselect, so
	 * we really don't have anything to do here.  We keep this
	 * function as a placeholder, though.
	 */
}

/*
 *  Select target: xs is the transfer that we are selecting for.
 *  sc->sc_current should be NULL.
 *
 *  Returns:
 *	sc->sc_current != NULL  ==> we were reselected (race!)
 *	XS_NOERROR		==> selection worked
 *	XS_BUSY 		==> lost arbitration
 *	XS_SELTIMEOUT   	==> no response to selection
 */
static int
sunscpal_select(sc, sr)
	struct sunscpal_softc *sc;
	struct sunscpal_req *sr;
{
	int timo, target_mask;
	u_short	mode;

	/* Check for reselect */
	sunscpal_reselect(sc);
	if (sc->sc_current) {
		SUNSCPAL_TRACE("select: reselect, cur=0x%x\n",
				  (long) sc->sc_current);
		return XS_BUSY;	/* reselected */
	}

	/*
	 * Select the target.
	 */
	target_mask = (1 << sr->sr_target);
	SUNSCPAL_WRITE_1(sc, sunscpal_data, target_mask);
	SUNSCPAL_WRITE_2(sc, sunscpal_icr, SUNSCPAL_ICR_SELECT);

	/*
	 * Wait for the target to assert BSY.
	 * SCSI spec. says wait for 250 mS.
	 */
	for (timo = 25000;;) {
		if (SUNSCPAL_READ_2(sc, sunscpal_icr) & SUNSCPAL_ICR_BUSY)
			goto success;
		if (--timo <= 0)
			break;
		delay(10);
	}

	SUNSCPAL_WRITE_1(sc, sunscpal_data, 0);
	SUNSCPAL_WRITE_2(sc, sunscpal_icr, 0);

	SUNSCPAL_TRACE("select: device down, rc=%d\n", XS_SELTIMEOUT);
	return XS_SELTIMEOUT;

success:

	/*
	 * The target is now driving BSY, so we can stop
	 * driving SEL and the data bus.  We do set up
	 * whether or not this target needs parity.
	 */
	mode = 0;
	if ((sc->sc_parity_disable & target_mask) == 0)
		mode |= SUNSCPAL_ICR_PARITY_ENABLE;
	SUNSCPAL_WRITE_2(sc, sunscpal_icr, mode);

	return XS_NOERROR;
}

/*****************************************************************
 * Functions to handle each info. transfer phase:
 *****************************************************************/

/*
 * 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 XS_CTL_RESET & xs->xs_control (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 IS1BYTEMSG(m) (((m) != 0x01 && (m) < 0x20) || (m) >= 0x80)
#define IS2BYTEMSG(m) (((m) & 0xf0) == 0x20)
#define ISEXTMSG(m) ((m) == 0x01)

/*
 * 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.
 *
 * Our return value determines whether our caller, sunscpal_machine()
 * will expect to see another REQ (and possibly phase change).
 */
static int
sunscpal_msg_in(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	struct scsipi_xfer *xs = sr->sr_xs;
	int n, phase;
	int act_flags;

	act_flags = ACT_CONTINUE;

	if (sc->sc_prevphase == SUNSCPAL_PHASE_MSG_IN) {
		/* This is a continuation of the previous message. */
		n = sc->sc_imp - sc->sc_imess;
		SUNSCPAL_TRACE("msg_in: continuation, n=%d\n", n);
		goto nextbyte;
	}

	/* This is a new MESSAGE IN phase.  Clean up our state. */
	sc->sc_state &= ~SUNSCPAL_DROP_MSGIN;

nextmsg:
	n = 0;
	sc->sc_imp = &sc->sc_imess[n];

nextbyte:
	/*
	 * Read a whole message, but don't ack the last byte.  If we reject the
	 * message, we have to assert ATN during the message transfer phase
	 * itself.
	 */
	for (;;) {
		/*
		 * Read a message byte.
		 * First, check BSY, REQ, phase...
		 */
		if (!SUNSCPAL_BUSY(sc)) {
			SUNSCPAL_TRACE("msg_in: lost BSY, n=%d\n", n);
			/* XXX - Assume the command completed? */
			act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
			return (act_flags);
		}
		if (sunscpal_wait_req(sc)) {
			SUNSCPAL_TRACE("msg_in: BSY but no REQ, n=%d\n", n);
			/* Just let sunscpal_machine() handle it... */
			return (act_flags);
		}
		phase = SUNSCPAL_BUS_PHASE(SUNSCPAL_READ_2(sc, sunscpal_icr));
		if (phase != SUNSCPAL_PHASE_MSG_IN) {
			/*
			 * Target left MESSAGE IN, probably because it
			 * a) noticed our ATN signal, or
			 * b) ran out of messages.
			 */
			return (act_flags);
		}
		/* Still in MESSAGE IN phase, and REQ is asserted. */
		if (SUNSCPAL_READ_2(sc, sunscpal_icr) & SUNSCPAL_ICR_PARITY_ERROR) {
			sunscpal_sched_msgout(sc, SEND_PARITY_ERROR);
			sc->sc_state |= SUNSCPAL_DROP_MSGIN;
		}

		/* Gather incoming message bytes if needed. */
		if ((sc->sc_state & SUNSCPAL_DROP_MSGIN) == 0) {
			if (n >= SUNSCPAL_MAX_MSG_LEN) {
				sunscpal_sched_msgout(sc, SEND_REJECT);
				sc->sc_state |= SUNSCPAL_DROP_MSGIN;
			} else {
				*sc->sc_imp++ = SUNSCPAL_READ_1(sc, sunscpal_cmd_stat);
				n++;
				/*
				 * This testing is suboptimal, but most
				 * messages will be of the one byte variety, so
				 * it should not affect performance
				 * significantly.
				 */
				if (n == 1 && IS1BYTEMSG(sc->sc_imess[0]))
					goto have_msg;
				if (n == 2 && IS2BYTEMSG(sc->sc_imess[0]))
					goto have_msg;
				if (n >= 3 && ISEXTMSG(sc->sc_imess[0]) &&
					n == sc->sc_imess[1] + 2)
					goto have_msg;
			}
		}

		/*
		 * If we reach this spot we're either:
		 * a) in the middle of a multi-byte message, or
		 * b) dropping bytes.
		 */

		if (act_flags != ACT_CONTINUE)
			return (act_flags);

		/* back to nextbyte */
	}

have_msg:
	/* We now have a complete message.  Parse it. */

	switch (sc->sc_imess[0]) {
	case MSG_CMDCOMPLETE:
		SUNSCPAL_TRACE("msg_in: CMDCOMPLETE\n", 0);
		/* Target is about to disconnect. */
		act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
		break;

	case MSG_PARITY_ERROR:
		SUNSCPAL_TRACE("msg_in: PARITY_ERROR\n", 0);
		/* Resend the last message. */
		sunscpal_sched_msgout(sc, sc->sc_msgout);
		break;

	case MSG_MESSAGE_REJECT:
		/* The target rejects the last message we sent. */
		SUNSCPAL_TRACE("msg_in: got reject for 0x%x\n", sc->sc_msgout);
		switch (sc->sc_msgout) {
		case SEND_IDENTIFY:
			/* Really old target controller? */
			/* XXX ... */
			break;
		case SEND_INIT_DET_ERR:
			goto abort;
		}
		break;

	case MSG_NOOP:
		SUNSCPAL_TRACE("msg_in: NOOP\n", 0);
		break;

	case MSG_DISCONNECT:
		SUNSCPAL_TRACE("msg_in: DISCONNECT\n", 0);
		/* Target is about to disconnect. */
		act_flags |= ACT_DISCONNECT;
		if ((xs->xs_periph->periph_quirks & PQUIRK_AUTOSAVE) == 0)
			break;
		/*FALLTHROUGH*/

	case MSG_SAVEDATAPOINTER:
		SUNSCPAL_TRACE("msg_in: SAVE_PTRS\n", 0);
		sr->sr_dataptr = sc->sc_dataptr;
		sr->sr_datalen = sc->sc_datalen;
		break;

	case MSG_RESTOREPOINTERS:
		SUNSCPAL_TRACE("msg_in: RESTORE_PTRS\n", 0);
		sc->sc_dataptr = sr->sr_dataptr;
		sc->sc_datalen = sr->sr_datalen;
		break;

	case MSG_EXTENDED:
		switch (sc->sc_imess[2]) {
		case MSG_EXT_SDTR:
		case MSG_EXT_WDTR:
			/* The ncr5380 can not do synchronous mode. */
			goto reject;
		default:
			printf("%s: unrecognized MESSAGE EXTENDED; sending REJECT\n",
			    sc->sc_dev.dv_xname);
			SUNSCPAL_BREAK();
			goto reject;
		}
		break;

	default:
		SUNSCPAL_TRACE("msg_in: eh? imsg=0x%x\n", sc->sc_imess[0]);
		printf("%s: unrecognized MESSAGE; sending REJECT\n",
		    sc->sc_dev.dv_xname);
		SUNSCPAL_BREAK();
		/* fallthrough */
	reject:
		sunscpal_sched_msgout(sc, SEND_REJECT);
		break;

	abort:
		sc->sc_state |= SUNSCPAL_ABORTING;
		sunscpal_sched_msgout(sc, SEND_ABORT);
		break;
	}

	/* Go get the next message, if any. */
	if (act_flags == ACT_CONTINUE)
		goto nextmsg;

	return (act_flags);
}


/*
 * 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 4 stem from SCSI command activity
 * SDTR		   @
 * WDTR		   @
 * DEV_RESET	   @
 * REJECT if MSGI doesn't make sense
 * PARITY_ERROR if parity error while in MSGI
 * INIT_DET_ERR if parity error while not in MSGI
 * ABORT if INIT_DET_ERR rejected
 * NOOP if asked for a message and there's nothing to send
 *
 * Note that we call this one with (sc_current == NULL)
 * when sending ABORT for unwanted reselections.
 */
static int
sunscpal_msg_out(sc)
	struct sunscpal_softc *sc;
{
	/*
	 * This controller does not allow you to assert ATN, which
	 * means we will never get the opportunity to send messages to
	 * the target (the bus will never enter this MSG_OUT phase).
	 * This will eventually leave us with no option other than to
	 * reset the bus.  We keep this function as a placeholder,
	 * though, and this printf will eventually go away or get
	 * #ifdef'ed:
	 */
	printf("sunscpal_msg_out: bus is in MSG_OUT phase?\n");
	return (ACT_CONTINUE | ACT_RESET_BUS);
}

/*
 * Handle command phase.
 */
static int
sunscpal_command(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	struct scsipi_xfer *xs = sr->sr_xs;
	int len;

	/* Assume command can be sent in one go. */
	/* XXX: Do this using DMA, and get a phase change intr? */
	len = sunscpal_pio_out(sc, SUNSCPAL_PHASE_COMMAND, xs->cmdlen,
		(u_char *)xs->cmd);

	if (len != xs->cmdlen) {
#ifdef	SUNSCPAL_DEBUG
		printf("sunscpal_command: short transfer: wanted %d got %d.\n",
		    xs->cmdlen, len);
		sunscpal_show_scsi_cmd(xs);
		SUNSCPAL_BREAK();
#endif
		if (len < 6) {
			xs->error = XS_DRIVER_STUFFUP;
			sc->sc_state |= SUNSCPAL_ABORTING;
			sunscpal_sched_msgout(sc, SEND_ABORT);
		}

	}

	return ACT_CONTINUE;
}


/*
 * Handle either data_in or data_out
 */
static int
sunscpal_data_xfer(sc, phase)
	struct sunscpal_softc *sc;
	int phase;
{
	struct sunscpal_req *sr = sc->sc_current;
	struct scsipi_xfer *xs = sr->sr_xs;
	int expected_phase;
	int len;

	/*
	 * When aborting a command, disallow any data phase.
	 */
	if (sc->sc_state & SUNSCPAL_ABORTING) {
		printf("%s: aborting, bus phase=%s (reset)\n",
		    sc->sc_dev.dv_xname, phase_names[(phase >> 8) & 7]);
		return ACT_RESET_BUS;	/* XXX */
	}

	/* Validate expected phase (data_in or data_out) */
	expected_phase = (xs->xs_control & XS_CTL_DATA_OUT) ?
		SUNSCPAL_PHASE_DATA_OUT : SUNSCPAL_PHASE_DATA_IN;
	if (phase != expected_phase) {
		printf("%s: data phase error\n", sc->sc_dev.dv_xname);
		goto abort;
	}

	/* Make sure we have some data to move. */
	if (sc->sc_datalen <= 0) {
		/* Device needs padding. */
		if (phase == SUNSCPAL_PHASE_DATA_IN)
			sunscpal_pio_in(sc, phase, 4096, NULL);
		else
			sunscpal_pio_out(sc, phase, 4096, NULL);
		/* Make sure that caused a phase change. */
		if (SUNSCPAL_BUS_PHASE(SUNSCPAL_READ_2(sc, sunscpal_icr)) == phase) {
			/* More than 4k is just too much! */
			printf("%s: too much data padding\n",
				sc->sc_dev.dv_xname);
			goto abort;
		}
		return ACT_CONTINUE;
	}

	/*
	 * Attempt DMA only if dma_alloc gave us a DMA handle AND
	 * there is enough left to transfer so DMA is worth while.
	 */
	if (sr->sr_dma_hand &&
		(sc->sc_datalen >= sc->sc_min_dma_len))
	{
		/*
		 * OK, really start DMA.  Note, the MD start function
		 * is responsible for setting the TCMD register, etc.
		 * (Acknowledge the phase change there, not here.)
		 */
		SUNSCPAL_TRACE("data_xfer: dma_start, dh=0x%x\n",
		          (long) sr->sr_dma_hand);
		sunscpal_dma_start(sc);
		return ACT_WAIT_DMA;
	}

	/*
	 * Doing PIO for data transfer.  (Possibly "Pseudo DMA")
	 * XXX:  Do PDMA functions need to set tcmd later?
	 */
	SUNSCPAL_TRACE("data_xfer: doing PIO, len=%d\n", sc->sc_datalen);
	if (phase == SUNSCPAL_PHASE_DATA_OUT) {
		len = sunscpal_pio_out(sc, phase, sc->sc_datalen, sc->sc_dataptr);
	} else {
		len = sunscpal_pio_in(sc, phase, sc->sc_datalen, sc->sc_dataptr);
	}
	sc->sc_dataptr += len;
	sc->sc_datalen -= len;

	SUNSCPAL_TRACE("data_xfer: did PIO, resid=%d\n", sc->sc_datalen);
	return (ACT_CONTINUE);

abort:
	sc->sc_state |= SUNSCPAL_ABORTING;
	sunscpal_sched_msgout(sc, SEND_ABORT);
	return (ACT_CONTINUE);
}


static int
sunscpal_status(sc)
	struct sunscpal_softc *sc;
{
	int len;
	u_char status;
	struct sunscpal_req *sr = sc->sc_current;

	len = sunscpal_pio_in(sc, SUNSCPAL_PHASE_STATUS, 1, &status);
	if (len) {
		sr->sr_status = status;
	} else {
		printf("sunscpal_status: none?\n");
	}

	return ACT_CONTINUE;
}


/*
 * This is the big state machine that follows SCSI phase changes.
 * This is somewhat like a co-routine.  It will do a SCSI command,
 * and exit if the command is complete, or if it must wait, i.e.
 * for DMA to complete or for reselect to resume the job.
 *
 * The bus must be selected, and we need to know which command is
 * being undertaken.
 */
static void
sunscpal_machine(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr;
	struct scsipi_xfer *xs;
	int act_flags, phase, timo;

#ifdef	DIAGNOSTIC
	if (sc->sc_state == SUNSCPAL_IDLE)
		panic("sunscpal_machine: state=idle");
	if (sc->sc_current == NULL)
		panic("sunscpal_machine: no current cmd");
#endif

	sr = sc->sc_current;
	xs = sr->sr_xs;
	act_flags = ACT_CONTINUE;

	/*
	 * This will be called by sunscpal_intr() when DMA is
	 * complete.  Must stop DMA before touching the PAL or
	 * there will be "register conflict" errors.
	 */
	if (sc->sc_state & SUNSCPAL_DOINGDMA) {
		/* Pick-up where where we left off... */
		goto dma_done;
	}

next_phase:

	if (!SUNSCPAL_BUSY(sc)) {
		/* Unexpected disconnect */
		printf("sunscpal_machine: unexpected disconnect.\n");
		xs->error = XS_DRIVER_STUFFUP;
		act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
		goto do_actions;
	}

	/*
	 * Wait for REQ before reading the phase.
	 * Need to wait longer than usual here, because
	 * some devices are just plain slow...
	 */
	timo = sunscpal_wait_phase_timo;
	for (;;) {
		if (SUNSCPAL_READ_2(sc, sunscpal_icr) & SUNSCPAL_ICR_REQUEST)
			break;
		if (--timo <= 0) {
			if (sc->sc_state & SUNSCPAL_ABORTING) {
				printf("%s: no REQ while aborting, reset\n",
				    sc->sc_dev.dv_xname);
				act_flags |= ACT_RESET_BUS;
				goto do_actions;
			}
			printf("%s: no REQ for next phase, abort\n",
			    sc->sc_dev.dv_xname);
			sc->sc_state |= SUNSCPAL_ABORTING;
			sunscpal_sched_msgout(sc, SEND_ABORT);
			goto next_phase;
		}
		delay(100);
	}

	phase = SUNSCPAL_BUS_PHASE(SUNSCPAL_READ_2(sc, sunscpal_icr));
	SUNSCPAL_TRACE("machine: phase=%s\n",
			  (long) phase_names[(phase >> 8) & 7]);

	/*
	 * We assume that the device knows what it's doing,
	 * so any phase is good.
	 */

	switch (phase) {

	case SUNSCPAL_PHASE_DATA_OUT:
	case SUNSCPAL_PHASE_DATA_IN:
		act_flags = sunscpal_data_xfer(sc, phase);
		break;

	case SUNSCPAL_PHASE_COMMAND:
		act_flags = sunscpal_command(sc);
		break;

	case SUNSCPAL_PHASE_STATUS:
		act_flags = sunscpal_status(sc);
		break;

	case SUNSCPAL_PHASE_MSG_OUT:
		act_flags = sunscpal_msg_out(sc);
		break;

	case SUNSCPAL_PHASE_MSG_IN:
		act_flags = sunscpal_msg_in(sc);
		break;

	default:
		printf("sunscpal_machine: Unexpected phase 0x%x\n", phase);
		sc->sc_state |= SUNSCPAL_ABORTING;
		sunscpal_sched_msgout(sc, SEND_ABORT);
		goto next_phase;

	} /* switch */
	sc->sc_prevphase = phase;

do_actions:

	if (act_flags & ACT_WAIT_DMA) {
		act_flags &= ~ACT_WAIT_DMA;
		/* Wait for DMA to complete (polling, or interrupt). */
		if ((sr->sr_flags & SR_IMMED) == 0) {
			SUNSCPAL_TRACE("machine: wait for DMA intr.\n", 0);
			return; 	/* will resume at dma_done */
		}
		/* Busy-wait for it to finish. */
		SUNSCPAL_TRACE("machine: dma_poll, dh=0x%x\n",
				  (long) sr->sr_dma_hand);
		sunscpal_dma_poll(sc);
	dma_done:
		/* Return here after interrupt. */
		if (sr->sr_flags & SR_OVERDUE)
			sc->sc_state |= SUNSCPAL_ABORTING;
		SUNSCPAL_TRACE("machine: dma_stop, dh=0x%x\n",
				  (long) sr->sr_dma_hand);
		sunscpal_dma_stop(sc);
		SUNSCPAL_CLR_INTR(sc);	/* XXX */
		/*
		 * While DMA is running we can not touch the SBC,
		 * so various places just set SUNSCPAL_ABORTING and
		 * expect us the "kick it" when DMA is done.
		 */
		if (sc->sc_state & SUNSCPAL_ABORTING) {
			sunscpal_sched_msgout(sc, SEND_ABORT);
		}
	}

	/*
	 * Check for parity error.
	 * XXX - better place to check?
	 */
	if (SUNSCPAL_READ_2(sc, sunscpal_icr) & SUNSCPAL_ICR_PARITY_ERROR) {
		printf("%s: parity error!\n", sc->sc_dev.dv_xname);
		/* XXX: sc->sc_state |= SUNSCPAL_ABORTING; */
		sunscpal_sched_msgout(sc, SEND_PARITY_ERROR);
	}

	if (act_flags == ACT_CONTINUE)
		goto next_phase;
	/* All other actions "break" from the loop. */

	SUNSCPAL_TRACE("machine: act_flags=0x%x\n", act_flags);

	if (act_flags & ACT_RESET_BUS) {
		act_flags |= ACT_CMD_DONE;
		/*
		 * Reset the SCSI bus, usually due to a timeout.
		 * The error code XS_TIMEOUT allows retries.
		 */
		sc->sc_state |= SUNSCPAL_ABORTING;
		printf("%s: reset SCSI bus for TID=%d LUN=%d\n",
		    sc->sc_dev.dv_xname, sr->sr_target, sr->sr_lun);
		sunscpal_reset_scsibus(sc);
	}

	if (act_flags & ACT_CMD_DONE) {
		act_flags |= ACT_DISCONNECT;
		/* Need to call scsipi_done() */
		/* XXX: from the aic6360 driver, but why? */
		if (sc->sc_datalen < 0) {
			printf("%s: %d extra bytes from %d:%d\n",
			    sc->sc_dev.dv_xname, -sc->sc_datalen,
			    sr->sr_target, sr->sr_lun);
			sc->sc_datalen = 0;
		}
		xs->resid = sc->sc_datalen;
		/* Note: this will clear sc_current */
		SUNSCPAL_TRACE("machine: call done, cur=0x%x\n", (long)sr);
		sunscpal_done(sc);
	}

	if (act_flags & ACT_DISCONNECT) {
		/*
		 * The device has dropped BSY (or will soon).
		 * We have to wait here for BSY to drop, otherwise
		 * the next command may decide we need a bus reset.
		 */
		timo = sunscpal_wait_req_timo;	/* XXX */
		for (;;) {
			if (!SUNSCPAL_BUSY(sc))
				goto busfree;
			if (--timo <= 0)
				break;
			delay(2);
		}
		/* Device is sitting on the bus! */
		printf("%s: Target %d LUN %d stuck busy, resetting...\n",
		    sc->sc_dev.dv_xname, sr->sr_target, sr->sr_lun);
		sunscpal_reset_scsibus(sc);
	busfree:
		SUNSCPAL_TRACE("machine: discon, waited %d\n",
			sunscpal_wait_req_timo - timo);

		SUNSCPAL_WRITE_2(sc, sunscpal_icr, 0);

		if ((act_flags & ACT_CMD_DONE) == 0) {
			SUNSCPAL_TRACE("machine: discon, cur=0x%x\n", (long)sr);
		}

		/*
		 * We may be here due to a disconnect message,
		 * in which case we did NOT call sunscpal_done,
		 * and we need to clear sc_current.
		 */
		sc->sc_state = SUNSCPAL_IDLE;
		sc->sc_current = NULL;

		/* Paranoia: clear everything. */
		sc->sc_dataptr = NULL;
		sc->sc_datalen = 0;
		sc->sc_prevphase = SUNSCPAL_PHASE_INVALID;
		sc->sc_msgpriq = 0;
		sc->sc_msgoutq = 0;
		sc->sc_msgout  = 0;

		/* Our caller will re-enable interrupts. */
	}
}


#ifdef	SUNSCPAL_DEBUG

static void
sunscpal_show_scsi_cmd(xs)
	struct scsipi_xfer *xs;
{
	u_char	*b = (u_char *) xs->cmd;
	int	i  = 0;

	scsipi_printaddr(xs->xs_periph);
	if ( ! ( xs->xs_control & XS_CTL_RESET ) ) {
		printf("-");
		while (i < xs->cmdlen) {
			if (i) printf(",");
			printf("%x",b[i++]);
		}
		printf("-\n");
	} else {

		printf("-RESET-\n");
	}
}


int sunscpal_traceidx = 0;

#define	TRACE_MAX	1024
struct trace_ent {
	char *msg;
	long  val;
} sunscpal_tracebuf[TRACE_MAX];

void
sunscpal_trace(msg, val)
	char *msg;
	long  val;
{
	struct trace_ent *tr;
	int s;

	s = splbio();

	tr = &sunscpal_tracebuf[sunscpal_traceidx];

	sunscpal_traceidx++;
	if (sunscpal_traceidx >= TRACE_MAX)
		sunscpal_traceidx = 0;

	tr->msg = msg;
	tr->val = val;

	splx(s);
}

#ifdef	DDB
void
sunscpal_clear_trace()
{
	sunscpal_traceidx = 0;
	memset((char*) sunscpal_tracebuf, 0, sizeof(sunscpal_tracebuf));
}

void
sunscpal_show_trace()
{
	struct trace_ent *tr;
	int idx;

	idx = sunscpal_traceidx;
	do {
		tr = &sunscpal_tracebuf[idx];
		idx++;
		if (idx >= TRACE_MAX)
			idx = 0;
		if (tr->msg)
			db_printf(tr->msg, tr->val);
	} while (idx != sunscpal_traceidx);
}

void
sunscpal_show_req(sr)
	struct sunscpal_req *sr;
{
	struct scsipi_xfer *xs = sr->sr_xs;

	db_printf("TID=%d ",	sr->sr_target);
	db_printf("LUN=%d ",	sr->sr_lun);
	db_printf("dh=%p ",	sr->sr_dma_hand);
	db_printf("dptr=%p ",	sr->sr_dataptr);
	db_printf("dlen=0x%x ",	sr->sr_datalen);
	db_printf("flags=%d ",	sr->sr_flags);
	db_printf("stat=%d ",	sr->sr_status);

	if (xs == NULL) {
		db_printf("(xs=NULL)\n");
		return;
	}
	db_printf("\n");
#ifdef	SCSIDEBUG
	show_scsipi_xs(xs);
#else
	db_printf("xs=%p\n", xs);
#endif
}

void
sunscpal_show_state()
{
	struct sunscpal_softc *sc;
	struct sunscpal_req *sr;
	int i, j, k;

	sc = sunscpal_debug_sc;

	if (sc == NULL) {
		db_printf("sunscpal_debug_sc == NULL\n");
		return;
	}

	db_printf("sc_ncmds=%d\n",  	sc->sc_ncmds);
	k = -1;	/* which is current? */
	for (i = 0; i < SUNSCPAL_OPENINGS; i++) {
		sr = &sc->sc_ring[i];
		if (sr->sr_xs) {
			if (sr == sc->sc_current)
				k = i;
			db_printf("req %d: (sr=%p)", i, sr);
			sunscpal_show_req(sr);
		}
	}
	db_printf("sc_rr=%d, current=%d\n", sc->sc_rr, k);

	db_printf("Active request matrix:\n");
	for(i = 0; i < 8; i++) {		/* targets */
		for (j = 0; j < 8; j++) {	/* LUN */
			sr = sc->sc_matrix[i][j];
			if (sr) {
				db_printf("TID=%d LUN=%d sr=%p\n", i, j, sr);
			}
		}
	}

	db_printf("sc_state=0x%x\n",	sc->sc_state);
	db_printf("sc_current=%p\n",	sc->sc_current);
	db_printf("sc_dataptr=%p\n",	sc->sc_dataptr);
	db_printf("sc_datalen=0x%x\n",	sc->sc_datalen);

	db_printf("sc_prevphase=%d\n",	sc->sc_prevphase);
	db_printf("sc_msgpriq=0x%x\n",	sc->sc_msgpriq);
}
#endif	/* DDB */
#endif	/* SUNSCPAL_DEBUG */

void
sunscpal_attach(sc, options)
	struct sunscpal_softc *sc;
	int options;
{

	/*
	 * Handle our options.
	 */
	printf(": options=0x%x\n", options);
	sc->sc_parity_disable = (options & SUNSCPAL_OPT_NO_PARITY_CHK);
	if (options & SUNSCPAL_OPT_FORCE_POLLING)
		sc->sc_flags |= SUNSCPAL_FORCE_POLLING;
	if (options & SUNSCPAL_OPT_DISABLE_DMA)
		sc->sc_flags |= SUNSCPAL_DISABLE_DMA;

	/*
	 * Fill in the adapter.
	 */
	memset(&sc->sc_adapter, 0, sizeof(sc->sc_adapter));
	sc->sc_adapter.adapt_dev = &sc->sc_dev;
	sc->sc_adapter.adapt_nchannels = 1;
	sc->sc_adapter.adapt_openings = SUNSCPAL_OPENINGS;
	sc->sc_adapter.adapt_max_periph = 1;
	sc->sc_adapter.adapt_request = sunscpal_scsipi_request;
	sc->sc_adapter.adapt_minphys = sunscpal_minphys;

	sc->sc_channel.chan_adapter = &sc->sc_adapter;
	sc->sc_channel.chan_bustype = &scsi_bustype;
	sc->sc_channel.chan_channel = 0;
	sc->sc_channel.chan_ntargets = 8;
	sc->sc_channel.chan_nluns = 8;
	sc->sc_channel.chan_id = 7;

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

	sunscpal_init(sc);	/* Init chip and driver */
	sunscpal_reset_scsibus(sc);

	/*
	 * Ask the adapter what subunits are present
	 */
	(void) config_found(&sc->sc_dev, &sc->sc_channel, scsiprint);
	scsipi_adapter_delref(&sc->sc_adapter);
}

int
sunscpal_detach(sc, flags)
	struct sunscpal_softc *sc;
	int flags;
{

	return (EOPNOTSUPP);
}

static void
sunscpal_minphys(struct buf *bp)
{
	if (bp->b_bcount > SUNSCPAL_MAX_DMA_LEN) {
#ifdef	SUNSCPAL_DEBUG
		if (sunscpal_debug & SUNSCPAL_DBG_DMA) {
			printf("sunscpal_minphys len = 0x%lx.\n", bp->b_bcount);
			Debugger();
		}
#endif
		bp->b_bcount = SUNSCPAL_MAX_DMA_LEN;
	}
	return (minphys(bp));
}

#ifdef SUNSCPAL_USE_BUS_DMA

/*
 * Allocate a DMA handle and put it in sr->sr_dma_hand.  Prepare
 * for DMA transfer.
 */
static void
sunscpal_dma_alloc(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	sunscpal_dma_handle_t dh;
	int i, xlen;
	u_long addr;

#ifdef	DIAGNOSTIC
	if (sr->sr_dma_hand != NULL)
		panic("sunscpal_dma_alloc: already have DMA handle");
#endif

	addr = (u_long) sc->sc_dataptr;
	xlen = sc->sc_datalen;

	/* If the DMA start addr is misaligned then do PIO */
	if ((addr & 1) || (xlen & 1)) {
		printf("sunscpal_dma_alloc: misaligned.\n");
		return;
	}

	/* Make sure our caller checked sc_min_dma_len. */
	if (xlen < sc->sc_min_dma_len)
		panic("sunscpal_dma_alloc: xlen=0x%x\n", xlen);

	/*
	 * Never attempt single transfers of more than 63k, because
	 * our count register is only 16 bits.
	 * This should never happen since already bounded by minphys().
	 * XXX - Should just segment these...
	 */
	if (xlen > SUNSCPAL_MAX_DMA_LEN) {
		printf("sunscpal_dma_alloc: excessive xlen=0x%x\n", xlen);
		Debugger();
		sc->sc_datalen = xlen = SUNSCPAL_MAX_DMA_LEN;
	}

	/* Find free DMA handle.  Guaranteed to find one since we have
	   as many DMA handles as the driver has processes. */
	for (i = 0; i < SUNSCPAL_OPENINGS; i++) {
		if ((sc->sc_dma_handles[i].dh_flags & SUNSCDH_BUSY) == 0)
			goto found;
	}
	panic("sc: no free DMA handles.");
found:

	dh = &sc->sc_dma_handles[i];
	dh->dh_flags = SUNSCDH_BUSY;
	dh->dh_mapaddr = (u_char*) addr;
	dh->dh_maplen  = xlen;
	dh->dh_dvma = 0;

	/* Load the DMA map. */
	if (bus_dmamap_load(sc->sunscpal_dmat, dh->dh_dmamap, dh->dh_mapaddr, dh->dh_maplen, NULL, BUS_DMA_NOWAIT) != 0) {
		/* Can't load map */
		printf("sunscpal_dma_alloc: can't DMA %p/0x%x\n",
			dh->dh_mapaddr, dh->dh_maplen);
		dh->dh_flags = 0;
		return;
	}

	/* success */
	sr->sr_dma_hand = dh;

	return;
}

static void
sunscpal_dma_free(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	sunscpal_dma_handle_t dh = sr->sr_dma_hand;

#ifdef	DIAGNOSTIC
	if (dh == NULL)
		panic("sunscpal_dma_free: no DMA handle");
#endif

	if (sc->sc_state & SUNSCPAL_DOINGDMA)
		panic("sunscpal_dma_free: free while in progress");

	if (dh->dh_flags & SUNSCDH_BUSY) {
		/* XXX - Should separate allocation and mapping. */
		/* Give back the DVMA space. */
		bus_dmamap_unload(sc->sunscpal_dmat, dh->dh_dmamap);
		dh->dh_flags = 0;
	}
	sr->sr_dma_hand = NULL;
}

/*
 * This function is called during the SELECT phase that
 * precedes a COMMAND phase, in case we need to setup the
 * DMA engine before the bus enters a DATA phase.
 *
 * On the sc version, setup the start address and the count.
 */
static void
sunscpal_dma_setup(sc)
	struct sunscpal_softc *sc;
{
	struct sunscpal_req *sr = sc->sc_current;
	struct scsipi_xfer *xs = sr->sr_xs;
	sunscpal_dma_handle_t dh = sr->sr_dma_hand;
	long data_pa;
	int xlen;

	/*
	 * Get the DVMA mapping for this segment.
	 * XXX - Should separate allocation and mapin.
	 */
	data_pa = dh->dh_dvma;
	data_pa += (sc->sc_dataptr - dh->dh_mapaddr);
	if (data_pa & 1)
		panic("sunscpal_dma_setup: bad pa=0x%lx", data_pa);
	xlen = sc->sc_datalen;
	if (xlen & 1)
		panic("sunscpal_dma_setup: bad xlen=0x%x", xlen);
	sc->sc_reqlen = xlen; 	/* XXX: or less? */

#ifdef	SUNSCPAL_DEBUG
	if (sunscpal_debug & SUNSCPAL_DBG_DMA) {
		printf("sunscpal_dma_setup: dh=%p, pa=0x%lx, xlen=0x%x\n",
			   dh, data_pa, xlen);
	}
#endif

	/* sync the DMA map: */
	bus_dmamap_sync(sc->sunscpal_dmat, dh->dh_dmamap, 0, dh->dh_maplen,
	    ((xs->xs_control & XS_CTL_DATA_OUT) == 0 ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE));

	/* Load the start address and the count. */
	SUNSCPAL_WRITE_2(sc, sunscpal_dma_addr_h, (data_pa >> 16) & 0xFFFF);
	SUNSCPAL_WRITE_2(sc, sunscpal_dma_addr_l, (data_pa >> 0) & 0xFFFF);
	SUNSCPAL_WRITE_2(sc, sunscpal_dma_count, SUNSCPAL_DMA_COUNT_FLIP(xlen));
}

#endif /* SUNSCPAL_USE_BUS_DMA */