xref: /src/sys/arch/mac68k/obio/esp.c

/*	$NetBSD: esp.c,v 1.58 2019/07/23 15:19:07 rin Exp $	*/

/*
 * Copyright (c) 1997 Jason R. Thorpe.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed for the NetBSD Project
 *	by Jason R. Thorpe.
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Copyright (c) 1994 Peter Galbavy
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Peter Galbavy
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Based on aic6360 by Jarle Greipsland
 *
 * Acknowledgements: Many of the algorithms used in this driver are
 * inspired by the work of Julian Elischer (julian (at) tfs.com) and
 * Charles Hannum (mycroft (at) duality.gnu.ai.mit.edu).  Thanks a million!
 */

/*
 * Initial m68k mac support from Allen Briggs <briggs (at) macbsd.com>
 * (basically consisting of the match, a bit of the attach, and the
 *  "DMA" glue functions).
 */

/*
 * AV DMA support from Michael Zucca (mrz5149 (at) acm.org)
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: esp.c,v 1.58 2019/07/23 15:19:07 rin Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/buf.h>
#include <sys/bus.h>
#include <sys/device.h>

#include <uvm/uvm_extern.h>

#include <dev/scsipi/scsiconf.h>

#include <dev/ic/ncr53c9xreg.h>
#include <dev/ic/ncr53c9xvar.h>

#include <machine/cpu.h>
#include <machine/psc.h>
#include <machine/viareg.h>

#include <mac68k/obio/espvar.h>
#include <mac68k/obio/obiovar.h>

static int	espmatch(device_t, cfdata_t, void *);
static void	espattach(device_t, device_t, void *);

/* Linkup to the rest of the kernel */
CFATTACH_DECL_NEW(esp, sizeof(struct esp_softc),
    espmatch, espattach, NULL, NULL);

/*
 * Functions and the switch for the MI code.
 */
static uint8_t	esp_read_reg(struct ncr53c9x_softc *, int);
static void	esp_write_reg(struct ncr53c9x_softc *, int, uint8_t);
static int	esp_dma_isintr(struct ncr53c9x_softc *);
static void	esp_dma_reset(struct ncr53c9x_softc *);
static int	esp_dma_intr(struct ncr53c9x_softc *);
static int	esp_dma_setup(struct ncr53c9x_softc *, uint8_t **, size_t *,
			int, size_t *);
static void	esp_dma_go(struct ncr53c9x_softc *);
static void	esp_dma_stop(struct ncr53c9x_softc *);
static int	esp_dma_isactive(struct ncr53c9x_softc *);
static void	esp_quick_write_reg(struct ncr53c9x_softc *, int, uint8_t);
static int	esp_quick_dma_intr(struct ncr53c9x_softc *);
static int	esp_quick_dma_setup(struct ncr53c9x_softc *, uint8_t **,
			size_t *, int, size_t *);
static void	esp_quick_dma_go(struct ncr53c9x_softc *);

static void	esp_av_write_reg(struct ncr53c9x_softc *, int, uint8_t);
static void	esp_av_dma_reset(struct ncr53c9x_softc *);
static int	esp_av_dma_intr(struct ncr53c9x_softc *);
static int	esp_av_pio_intr(struct ncr53c9x_softc *);
static int	esp_av_dma_setup(struct ncr53c9x_softc *, uint8_t **, size_t *,
			int, size_t *);
static void	esp_av_dma_go(struct ncr53c9x_softc *);
static void	esp_av_dma_stop(struct ncr53c9x_softc *);

static void	esp_intr(void *);
static void	esp_dualbus_intr(void *);

static int	esp_dafb_have_dreq(struct esp_softc *);
static int	esp_iosb_have_dreq(struct esp_softc *);
int (*esp_have_dreq)(struct esp_softc *);

static struct esp_softc *esp0, *esp1;

static struct ncr53c9x_glue esp_glue = {
	.gl_read_reg = esp_read_reg,
	.gl_write_reg = esp_write_reg,
	.gl_dma_isintr = esp_dma_isintr,
	.gl_dma_reset = esp_dma_reset,
	.gl_dma_intr = esp_dma_intr,
	.gl_dma_setup = esp_dma_setup,
	.gl_dma_go = esp_dma_go,
	.gl_dma_stop = esp_dma_stop,
	.gl_dma_isactive = esp_dma_isactive,
	.gl_clear_latched_intr = NULL,
};

static int
espmatch(device_t parent, cfdata_t cf, void *aux)
{
	struct obio_attach_args *oa = aux;

	if (oa->oa_addr == 0 && mac68k_machine.scsi96)
		return 1;
	if (oa->oa_addr == 1 && mac68k_machine.scsi96_2)
		return 1;
	return 0;
}

/*
 * Attach this instance, and then all the sub-devices
 */
static void
espattach(device_t parent, device_t self, void *aux)
{
	struct esp_softc	*esc = device_private(self);
	struct ncr53c9x_softc	*sc = &esc->sc_ncr53c9x;
	struct obio_attach_args *oa = aux;
	bus_addr_t		addr;
	unsigned long		reg_offset;
	int			quick = 0, avdma = 0;
	uint8_t			irq_mask;	/* mask for clearing IRQ */
	extern vaddr_t		SCSIBase;

	sc->sc_dev = self;

	reg_offset = SCSIBase - IOBase;

	/*
	 * For Wombat, Primus and Optimus motherboards, DREQ is
	 * visible on bit 0 of the IOSB's emulated VIA2 vIFR (and
	 * the scsi registers are offset 0x1000 bytes from IOBase).
	 *
	 * For the Q700/900/950 it's at f9800024 for bus 0 and
	 * f9800028 for bus 1 (900/950).  For these machines, that is also
	 * a (12-bit) configuration register for DAFB's control of the
	 * pseudo-DMA timing.  The default value is 0x1d1.
	 */
	if (oa->oa_addr == 0) {
		if (reg_offset == 0x10000) {
			quick = 1;
			esp_have_dreq = esp_iosb_have_dreq;
		} else if (reg_offset == 0x18000)
			avdma = 1;
		else {
			addr = 0xf9800024;
			goto dafb_dreq;
		}
	} else {
		bus_space_tag_t bst;
		bus_space_handle_t bsh;

		addr = 0xf9800028;

dafb_dreq:	bst = oa->oa_tag;
		if (bus_space_map(bst, addr, 4, 0, &bsh))
			aprint_error(": failed to map 4 at 0x%lx.\n", addr);
		else {
			quick = 1;
			esp_have_dreq = esp_dafb_have_dreq;
			esc->sc_dreqreg = (volatile uint32_t *)
			    bus_space_vaddr(bst, bsh);
			*esc->sc_dreqreg = 0x1d1;
		}
	}

	if (quick) {
		esp_glue.gl_write_reg = esp_quick_write_reg;
		esp_glue.gl_dma_intr = esp_quick_dma_intr;
		esp_glue.gl_dma_setup = esp_quick_dma_setup;
		esp_glue.gl_dma_go = esp_quick_dma_go;
	} else if (avdma) {
		esp_glue.gl_write_reg = esp_av_write_reg;
		esp_glue.gl_dma_reset = esp_av_dma_reset;
		esp_glue.gl_dma_intr = esp_av_dma_intr;
		esp_glue.gl_dma_setup = esp_av_dma_setup;
		esp_glue.gl_dma_go = esp_av_dma_go;
		esp_glue.gl_dma_stop = esp_av_dma_stop;
	}

	/*
	 * Set up the glue for MI code early; we use some of it here.
	 */
	sc->sc_glue = &esp_glue;

	/*
	 * Save the regs
	 */
	if (oa->oa_addr == 0) {
		esp0 = esc;

		esc->sc_reg = (volatile uint8_t *)SCSIBase;
		via2_register_irq(VIA2_SCSIIRQ, esp_intr, esc);
		irq_mask = V2IF_SCSIIRQ;
		if (reg_offset == 0x10000) {
			/* From the Q650 developer's note */
			sc->sc_freq = 16500000;
		} else
			sc->sc_freq = 25000000;

		if (quick)
			aprint_normal(" (quick)");
		else if (avdma)
			aprint_normal(" (avdma)");
	} else {
		esp1 = esc;

		esc->sc_reg = (volatile uint8_t *)SCSIBase + 0x402;
		via2_register_irq(VIA2_SCSIIRQ, esp_dualbus_intr, NULL);
		irq_mask = 0;
		sc->sc_freq = 25000000;

		if (quick)
			printf(" (quick)");
	}

	aprint_normal(": address %p", esc->sc_reg);

	sc->sc_id = 7;

	/* gimme MHz */
	sc->sc_freq /= 1000000;

	/*
	 * It is necessary to try to load the 2nd config register here,
	 * to find out what rev the esp chip is, else the esp_reset
	 * will not set up the defaults correctly.
	 */
	sc->sc_cfg1 = sc->sc_id; /* | NCRCFG1_PARENB; */
	sc->sc_cfg2 = NCRCFG2_SCSI2;
	if (avdma) {
		sc->sc_cfg3 = NCRCFG3_CDB;
		sc->sc_rev = NCR_VARIANT_NCR53C94;
	} else {
		sc->sc_cfg3 = 0;
		sc->sc_rev = NCR_VARIANT_NCR53C96;
	}

	/*
	 * This is the value used to start sync negotiations
	 * Note that the NCR register "SYNCTP" is programmed
	 * in "clocks per byte", and has a minimum value of 4.
	 * The SCSI period used in negotiation is one-fourth
	 * of the time (in nanoseconds) needed to transfer one byte.
	 * Since the chip's clock is given in MHz, we have the following
	 * formula: 4 * period = (1000 / freq) * 4
	 */
	sc->sc_minsync = 1000 / sc->sc_freq;

	/* We need this to fit into the TCR... */
	sc->sc_maxxfer = 64 * 1024;

        switch (current_mac_model->machineid) {
        case MACH_MACQ630:
		/* XXX on LC630 64k xfer causes timeout error */
		sc->sc_maxxfer = 63 * 1024;
		break;
	}

	if (!quick) {
		/*
		 * No synchronous xfers w/o DMA.
		 *
		 * XXXRO
		 * Also disable synchronous xfers for avdma for now,
		 * by which some disks cannot be read.
		 */
		sc->sc_minsync = 0;
	}

	if (!quick && !avdma)
		sc->sc_maxxfer = 8 * 1024;

	/*
	 * Configure interrupts.
	 */
	if (irq_mask) {
		via2_reg(vPCR) = 0x22;
		via2_reg(vIFR) = irq_mask;
		via2_reg(vIER) = 0x80 | irq_mask;
	}

	/*
	 * Setup for AV DMA
	 */
	if (avdma) {
		bus_dma_segment_t osegs, isegs;
		int orsegs, irsegs;

		esc->sc_rset = 0;
		esc->sc_pio = 0;
		esc->sc_dmat = oa->oa_dmat;

		if (bus_dmamap_create(esc->sc_dmat, sc->sc_maxxfer,
		    sc->sc_maxxfer / NBPG + 1, sc->sc_maxxfer, 0,
		    BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW, &esc->sc_dmap)) {
			printf("failed to create DMA map.\n");
			return;
		}

		/*
		 * Allocate memory which is friendly to the DMA engine
		 * (16-byte aligned) for use as the SCSI message buffers.
		 *
		 * XXX
		 * We need two buffers here. Since bus_dmamem_map(9) for
		 * m68k round size into NBPG.
		 */
		if (bus_dmamem_alloc(esc->sc_dmat, NBPG, 16, NBPG,
		    &osegs, 1, &orsegs, BUS_DMA_NOWAIT)) {
			printf("failed to allocate omess buffer.\n");
			goto out1;
		}
		if (bus_dmamem_map(esc->sc_dmat, &osegs, orsegs,
		    NCR_MAX_MSG_LEN, (void **)&sc->sc_omess,
		    BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) {
			printf("failed to map omess buffer.\n");
			goto out2;
		}

		if (bus_dmamem_alloc(esc->sc_dmat, NBPG, 16, NBPG,
		    &isegs, 1, &irsegs, BUS_DMA_NOWAIT)) {
			printf("failed to allocate imess buffer.\n");
			goto out3;
		}
		if (bus_dmamem_map(esc->sc_dmat, &isegs, irsegs,
		    NCR_MAX_MSG_LEN + 1, (void **)&sc->sc_imess,
		    BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) {
			printf("failed to map imess buffer.");

			bus_dmamem_free(esc->sc_dmat, &isegs, irsegs);
		out3:	bus_dmamem_unmap(esc->sc_dmat, sc->sc_omess, NBPG);
		out2:	bus_dmamem_free(esc->sc_dmat, &osegs, orsegs);
		out1:	bus_dmamap_destroy(esc->sc_dmat, esc->sc_dmap);
			return;
		}
	}

	/*
	 * Now try to attach all the sub-devices
	 */
	sc->sc_adapter.adapt_minphys = minphys;
	sc->sc_adapter.adapt_request = ncr53c9x_scsipi_request;
	ncr53c9x_attach(sc);
}

/*
 * Glue functions.
 */

static uint8_t
esp_read_reg(struct ncr53c9x_softc *sc, int reg)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	return esc->sc_reg[reg * 16];
}

static void
esp_write_reg(struct ncr53c9x_softc *sc, int reg, uint8_t val)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	uint8_t	v = val;

	if (reg == NCR_CMD && v == (NCRCMD_TRANS|NCRCMD_DMA)) {
		v = NCRCMD_TRANS;
	}
	esc->sc_reg[reg * 16] = v;
}

static void
esp_dma_stop(struct ncr53c9x_softc *sc)
{
}

static int
esp_dma_isactive(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	return esc->sc_active;
}

static int
esp_dma_isintr(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	return esc->sc_reg[NCR_STAT * 16] & NCRSTAT_INT;
}

static void
esp_dma_reset(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	esc->sc_active = 0;
	esc->sc_tc = 0;
}

static int
esp_dma_intr(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	volatile uint8_t *cmdreg, *intrreg, *statreg, *fiforeg;
	uint8_t	*p;
	u_int	espphase, espstat, espintr;
	int	cnt, s;

	if (esc->sc_active == 0) {
		printf("dma_intr--inactive DMA\n");
		return -1;
	}

	if ((sc->sc_espintr & NCRINTR_BS) == 0) {
		esc->sc_active = 0;
		return 0;
	}

	cnt = *esc->sc_dmalen;
	if (*esc->sc_dmalen == 0) {
		printf("data interrupt, but no count left.");
	}

	p = *esc->sc_dmaaddr;
	espphase = sc->sc_phase;
	espstat = (u_int)sc->sc_espstat;
	espintr = (u_int)sc->sc_espintr;
	cmdreg = esc->sc_reg + NCR_CMD * 16;
	fiforeg = esc->sc_reg + NCR_FIFO * 16;
	statreg = esc->sc_reg + NCR_STAT * 16;
	intrreg = esc->sc_reg + NCR_INTR * 16;
	do {
		if (esc->sc_datain) {
			*p++ = *fiforeg;
			cnt--;
			if (espphase == DATA_IN_PHASE) {
				*cmdreg = NCRCMD_TRANS;
			} else {
				esc->sc_active = 0;
			}
	 	} else {
			if (   (espphase == DATA_OUT_PHASE)
			    || (espphase == MESSAGE_OUT_PHASE)) {
				*fiforeg = *p++;
				cnt--;
				*cmdreg = NCRCMD_TRANS;
			} else {
				esc->sc_active = 0;
			}
		}

		if (esc->sc_active) {
			while (!(*statreg & 0x80));
			s = splhigh();
			espstat = *statreg;
			espintr = *intrreg;
			espphase = (espintr & NCRINTR_DIS)
				    ? /* Disconnected */ BUSFREE_PHASE
				    : espstat & PHASE_MASK;
			splx(s);
		}
	} while (esc->sc_active && (espintr & NCRINTR_BS));
	sc->sc_phase = espphase;
	sc->sc_espstat = (uint8_t)espstat;
	sc->sc_espintr = (uint8_t)espintr;
	*esc->sc_dmaaddr = p;
	*esc->sc_dmalen = cnt;

	if (*esc->sc_dmalen == 0) {
		esc->sc_tc = NCRSTAT_TC;
	}
	sc->sc_espstat |= esc->sc_tc;
	return 0;
}

static int
esp_dma_setup(struct ncr53c9x_softc *sc, uint8_t **addr, size_t *len,
    int datain, size_t *dmasize)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	esc->sc_dmaaddr = addr;
	esc->sc_dmalen = len;
	esc->sc_datain = datain;
	esc->sc_dmasize = *dmasize;
	esc->sc_tc = 0;

	return 0;
}

static void
esp_dma_go(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	if (esc->sc_datain == 0) {
		esc->sc_reg[NCR_FIFO * 16] = **esc->sc_dmaaddr;
		(*esc->sc_dmalen)--;
		(*esc->sc_dmaaddr)++;
	}
	esc->sc_active = 1;
}

static void
esp_quick_write_reg(struct ncr53c9x_softc *sc, int reg, uint8_t val)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	esc->sc_reg[reg * 16] = val;
}

#if DEBUG
int mac68k_esp_debug=0;
#endif

static int
esp_quick_dma_intr(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	int trans=0, resid=0;

	if (esc->sc_active == 0)
		panic("dma_intr--inactive DMA");

	esc->sc_active = 0;

	if (esc->sc_dmasize == 0) {
		int	res;

		res = NCR_READ_REG(sc, NCR_TCL);
		res += NCR_READ_REG(sc, NCR_TCM) << 8;
		/* This can happen in the case of a TRPAD operation */
		/* Pretend that it was complete */
		sc->sc_espstat |= NCRSTAT_TC;
#if DEBUG
		if (mac68k_esp_debug) {
			printf("dmaintr: DMA xfer of zero xferred %d\n",
			    65536 - res);
		}
#endif
		return 0;
	}

	if ((sc->sc_espstat & NCRSTAT_TC) == 0) {
		if (esc->sc_datain == 0) {
			resid = NCR_READ_REG(sc, NCR_FFLAG) & 0x1f;
#if DEBUG
			if (mac68k_esp_debug) {
				printf("Write FIFO residual %d bytes\n", resid);
			}
#endif
		}
		resid += NCR_READ_REG(sc, NCR_TCL);
		resid += NCR_READ_REG(sc, NCR_TCM) << 8;
		if (resid == 0)
			resid = 65536;
	}

	trans = esc->sc_dmasize - resid;
	if (trans < 0) {
		printf("dmaintr: trans < 0????");
		trans = *esc->sc_dmalen;
	}

	NCR_DMA(("dmaintr: trans %d, resid %d.\n", trans, resid));
#if DEBUG
	if (mac68k_esp_debug) {
		printf("eqd_intr: trans %d, resid %d.\n", trans, resid);
	}
#endif
	*esc->sc_dmaaddr += trans;
	*esc->sc_dmalen -= trans;

	return 0;
}

static int
esp_quick_dma_setup(struct ncr53c9x_softc *sc, uint8_t **addr, size_t *len,
    int datain, size_t *dmasize)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	esc->sc_dmaaddr = addr;
	esc->sc_dmalen = len;

	if (*len & 1) {
		esc->sc_pad = 1;
	} else {
		esc->sc_pad = 0;
	}

	esc->sc_datain = datain;
	esc->sc_dmasize = *dmasize;

#if DIAGNOSTIC
	if (esc->sc_dmasize == 0) {
		/* This can happen in the case of a TRPAD operation */
	}
#endif
#if DEBUG
	if (mac68k_esp_debug) {
	printf("eqd_setup: addr %lx, len %lx, in? %d, dmasize %lx\n",
	    (long) *addr, (long) *len, datain, (long) esc->sc_dmasize);
	}
#endif

	return 0;
}

static int
esp_dafb_have_dreq(struct esp_softc *esc)
{

	return *esc->sc_dreqreg & 0x200;
}

static int
esp_iosb_have_dreq(struct esp_softc *esc)
{

	return via2_reg(vIFR) & V2IF_SCSIDRQ;
}

static volatile int espspl = -1;

/*
 * Apple "DMA" is weird.
 *
 * Basically, the CPU acts like the DMA controller.  The DREQ/ off the
 * chip goes to a register that we've mapped at attach time (on the
 * IOSB or DAFB, depending on the machine).  Apple also provides some
 * space for which the memory controller handshakes data to/from the
 * NCR chip with the DACK/ line.  This space appears to be mapped over
 * and over, every 4 bytes, but only the lower 16 bits are valid (but
 * reading the upper 16 bits will handshake DACK/ just fine, so if you
 * read *uint16_t++ = *uint16_t++ in a loop, you'll get
 * <databyte><databyte>0xff0xff<databyte><databyte>0xff0xff...
 *
 * When you're attempting to read or write memory to this DACK/ed space,
 * and the NCR is not ready for some timeout period, the system will
 * generate a bus error.  This might be for one of several reasons:
 *
 *	1) (on write) The FIFO is full and is not draining.
 *	2) (on read) The FIFO is empty and is not filling.
 *	3) An interrupt condition has occurred.
 *	4) Anything else?
 *
 * So if a bus error occurs, we first turn off the nofault bus error handler,
 * then we check for an interrupt (which would render the first two
 * possibilities moot).  If there's no interrupt, check for a DREQ/.  If we
 * have that, then attempt to resume stuffing (or unstuffing) the FIFO.  If
 * neither condition holds, pause briefly and check again.
 *
 * NOTE!!!  In order to make allowances for the hardware structure of
 *          the mac, spl values in here are hardcoded!!!!!!!!!
 *          This is done to allow serial interrupts to get in during
 *          scsi transfers.  This is ugly.
 */
static void
esp_quick_dma_go(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	extern long mac68k_a2_fromfault;
	extern int *nofault;
	label_t faultbuf;
	uint16_t volatile *pdma;
	uint16_t *addr;
	int		len, res;
	uint16_t	cnt32, cnt2;
	volatile uint8_t *statreg;

	esc->sc_active = 1;

	espspl = splhigh();

	addr = (uint16_t *)*esc->sc_dmaaddr;
	len  = esc->sc_dmasize;

restart_dmago:
#if DEBUG
	if (mac68k_esp_debug) {
		printf("eqdg: a %lx, l %lx, in? %d ... ",
		    (long) addr, (long) len, esc->sc_datain);
	}
#endif
	nofault = (int *)&faultbuf;
	if (setjmp((label_t *)nofault)) {
		int	i = 0;

		nofault = NULL;
#if DEBUG
		if (mac68k_esp_debug) {
			printf("be\n");
		}
#endif
		/*
		 * Bus error...
		 * So, we first check for an interrupt.  If we have
		 * one, go handle it.  Next we check for DREQ/.  If
		 * we have it, then we restart the transfer.  If
		 * neither, then loop until we get one or the other.
		 */
		statreg = esc->sc_reg + NCR_STAT * 16;
		for (;;) {
			spl2();		/* Give serial a chance... */
			splhigh();	/* That's enough... */

			if (*statreg & 0x80) {
				goto gotintr;
			}

			if (esp_have_dreq(esc)) {
				/*
				 * Get the remaining length from the address
				 * differential.
				 */
				addr = (uint16_t *)mac68k_a2_fromfault;
				len = esc->sc_dmasize -
				    ((long)addr - (long)*esc->sc_dmaaddr);

				if (esc->sc_datain == 0) {
					/*
					 * Let the FIFO drain before we read
					 * the transfer count.
					 * Do we need to do this?
					 * Can we do this?
					 */
					while (NCR_READ_REG(sc, NCR_FFLAG)
					    & 0x1f);
					/*
					 * Get the length from the transfer
					 * counters.
					 */
					res = NCR_READ_REG(sc, NCR_TCL);
					res += NCR_READ_REG(sc, NCR_TCM) << 8;
					/*
					 * If they don't agree,
					 * adjust accordingly.
					 */
					while (res > len) {
						len+=2; addr--;
					}
					if (res != len) {
						panic("%s: res %d != len %d",
						    __func__, res, len);
					}
				}
				break;
			}

			DELAY(1);
			if (i++ > 1000000)
				panic("%s: Bus error, but no condition!  Argh!",
				    __func__);
		}
		goto restart_dmago;
	}

	len &= ~1;

	statreg = esc->sc_reg + NCR_STAT * 16;
	pdma = (volatile uint16_t *)(esc->sc_reg + 0x100);

	/*
	 * These loops are unrolled into assembly for two reasons:
	 * 1) We can make sure that they are as efficient as possible, and
	 * 2) (more importantly) we need the address that we are reading
	 *    from or writing to to be in a2.
	 */
	cnt32 = len / 32;
	cnt2 = (len % 32) / 2;
	if (esc->sc_datain == 0) {
		/* while (cnt32--) { 16 instances of *pdma = *addr++; } */
		/* while (cnt2--) { *pdma = *addr++; } */
		__asm volatile (
			"	movl %1, %%a2	\n"
			"	movl %2, %%a3	\n"
			"	movw %3, %%d2	\n"
			"	cmpw #0, %%d2	\n"
			"	beq  2f		\n"
			"	subql #1, %%d2	\n"
			"1:	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw %%a2@+,%%a3@; movw %%a2@+,%%a3@	\n"
			"	movw #8704,%%sr	\n"
			"	movw #9728,%%sr	\n"
			"	dbra %%d2, 1b	\n"
			"2:	movw %4, %%d2	\n"
			"	cmpw #0, %%d2	\n"
			"	beq  4f		\n"
			"	subql #1, %%d2	\n"
			"3:	movw %%a2@+,%%a3@ \n"
			"	dbra %%d2, 3b	\n"
			"4:	movl %%a2, %0"
			: "=g" (addr)
			: "0" (addr), "g" (pdma), "g" (cnt32), "g" (cnt2)
			: "a2", "a3", "d2");
		if (esc->sc_pad) {
			volatile uint8_t *c;
			c = (volatile uint8_t *) addr;
			/* Wait for DREQ */
			while (!esp_have_dreq(esc)) {
				if (*statreg & 0x80) {
					nofault = NULL;
					goto gotintr;
				}
			}
			*(volatile int8_t *)pdma = *c;
		}
	} else {
		/* while (cnt32--) { 16 instances of *addr++ = *pdma; } */
		/* while (cnt2--) { *addr++ = *pdma; } */
		__asm volatile (
			"	movl %1, %%a2	\n"
			"	movl %2, %%a3	\n"
			"	movw %3, %%d2	\n"
			"	cmpw #0, %%d2	\n"
			"	beq  6f		\n"
			"	subql #1, %%d2	\n"
			"5:	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw %%a3@,%%a2@+; movw %%a3@,%%a2@+	\n"
			"	movw #8704,%%sr	\n"
			"	movw #9728,%%sr	\n"
			"	dbra %%d2, 5b	\n"
			"6:	movw %4, %%d2	\n"
			"	cmpw #0, %%d2	\n"
			"	beq  8f		\n"
			"	subql #1, %%d2	\n"
			"7:	movw %%a3@,%%a2@+ \n"
			"	dbra %%d2, 7b	\n"
			"8:	movl %%a2, %0"
			: "=g" (addr)
			: "0" (addr), "g" (pdma), "g" (cnt32), "g" (cnt2)
			: "a2", "a3", "d2");
		if (esc->sc_pad) {
			volatile uint8_t *c;
			c = (volatile int8_t *)addr;
			/* Wait for DREQ */
			while (!esp_have_dreq(esc)) {
				if (*statreg & 0x80) {
					nofault = NULL;
					goto gotintr;
				}
			}
			*c = *(volatile uint8_t *)pdma;
		}
	}

	nofault = NULL;

	/*
	 * If we have not received an interrupt yet, we should shortly,
	 * and we can't prevent it, so return and wait for it.
	 */
	if ((*statreg & 0x80) == 0) {
#if DEBUG
		if (mac68k_esp_debug) {
			printf("g.\n");
		}
#endif
		if (espspl != -1)
			splx(espspl);
		espspl = -1;
		return;
	}

gotintr:
#if DEBUG
	if (mac68k_esp_debug) {
		printf("g!\n");
	}
#endif
	/*
	 * We have been called from the MI ncr53c9x_intr() handler,
	 * which protects itself against multiple invocation with a
	 * lock.  Follow the example of ncr53c9x_poll().
	 */
	mutex_exit(&sc->sc_lock);
	ncr53c9x_intr(sc);
	mutex_enter(&sc->sc_lock);
	if (espspl != -1)
		splx(espspl);
	espspl = -1;
}

static void
esp_intr(void *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	if (esc->sc_reg[NCR_STAT * 16] & 0x80) {
		ncr53c9x_intr((struct ncr53c9x_softc *)esp0);
	}
}

static void
esp_dualbus_intr(void *sc)
{
	if (esp0 && (esp0->sc_reg[NCR_STAT * 16] & 0x80)) {
		ncr53c9x_intr((struct ncr53c9x_softc *)esp0);
	}

	if (esp1 && (esp1->sc_reg[NCR_STAT * 16] & 0x80)) {
		ncr53c9x_intr((struct ncr53c9x_softc *)esp1);
	}
}

static void
esp_av_write_reg(struct ncr53c9x_softc *sc, int reg, uint8_t val)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	uint8_t v;

	if (esc->sc_pio && reg == NCR_CMD && val == (NCRCMD_TRANS|NCRCMD_DMA))
		v = NCRCMD_TRANS;
	else
		v = val;
	esc->sc_reg[reg * 16] = v;
}

static void
esp_av_dma_reset(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	uint32_t res;

	if(esc->sc_active && !esc->sc_pio)
		stop_psc_dma(PSC_DMA_CHANNEL_SCSI, esc->sc_rset, &res,
		    esc->sc_datain);

	esc->sc_active = esc->sc_tc = 0;
}

static int
esp_av_dma_intr(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	uint32_t resid;
	int trans, fifo_count;

	KASSERT(esc->sc_active);

	/* Deal with any PIO transfers */
	if (esc->sc_pio)
		return esp_av_pio_intr(sc);

#if DEBUG
	int tc_size;
	tc_size = NCR_READ_REG(sc, NCR_TCM);
	tc_size <<= 8;
	tc_size |= NCR_READ_REG(sc, NCR_TCL);
	printf("[av_dma_intr: intr 0x%x stat 0x%x tc 0x%x dmasize %zu]\n",
	    sc->sc_espintr, sc->sc_espstat, tc_size, esc->sc_dmasize);
#endif

	esc->sc_active = 0;

	if (esc->sc_dmasize == 0) {
		/* A "Transfer Pad" operation completed */
		return 0;
	}

	if ((sc->sc_espintr & NCRINTR_BS) && (sc->sc_espstat & NCRSTAT_TC)) {
		/* Wait for engine to finish the transfer */
		wait_psc_dma(PSC_DMA_CHANNEL_SCSI, esc->sc_rset, &resid);
#if DEBUG
		printf("[av_dma_intr: DMA %s done]\n", esc->sc_datain ?
		    "read" : "write");
#endif
	}

	/* Halt the DMA engine */
	stop_psc_dma(PSC_DMA_CHANNEL_SCSI, esc->sc_rset, &resid,
	    esc->sc_datain);

	bus_dmamap_sync(esc->sc_dmat, esc->sc_dmap, 0, esc->sc_dmasize,
	    esc->sc_datain ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
	bus_dmamap_unload(esc->sc_dmat, esc->sc_dmap);

	/* On read, bytes in the FIFO count as residual */
	if (esc->sc_datain) {
		fifo_count = (int)(NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF);
		resid += fifo_count;
		if (fifo_count) {
			/*
			 * Flush those bytes since we don't know
			 * what state they were in.
			 */
			NCRCMD(sc, NCRCMD_FLUSH);
#if DEBUG
			printf("[av_dma_intr: flushed %d bytes from FIFO]\n",
			    fifo_count) ;
#endif
		}
	}

	trans = esc->sc_dmasize - resid;
	if (trans < 0) {
		/*
		 * XXXRO
		 * This situation can happen in perfectly normal operation
		 * if the ESP is reselected while using DMA to select
		 * another target.  As such, don't print the warning.
		 */
#if DEBUG
		printf("[av_dma_intr: xfer (%d) > req (%zu)]\n",
		    trans, esc->sc_dmasize);
#endif
		trans = esc->sc_dmasize;
	}

#if DEBUG
	printf("[av_dma_intr: DMA %s of %d bytes done with %u residual]\n",
	    esc->sc_datain ? "read" : "write", trans, resid);
#endif

	*esc->sc_dmalen -= trans;
	*esc->sc_dmaaddr += trans;

	return 0;
}

static int
esp_av_pio_intr(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	int espphase, cnt, s;
	uint8_t espstat, espintr;
	volatile uint8_t *cmdreg, *intrreg, *statreg, *fiforeg;
	uint8_t *p;

#if DEBUG
	printf("[av_pio_intr: intr 0x%x stat 0x%x] ", sc->sc_espintr,
	    sc->sc_espstat);
#endif

	if ((sc->sc_espintr & NCRINTR_BS) == 0) {
		esc->sc_active = 0;
		return 0;
	}

	cnt = esc->sc_dmasize;
#if DEBUG
	/*
	 * XXXRO
	 * Is this possible?
	 */
	if (cnt == 0)
		printf("data interrupt, but no count left.");
#endif

	p = *esc->sc_dmaaddr;
	espphase = sc->sc_phase;
	espstat = sc->sc_espstat;
	espintr = sc->sc_espintr;
	cmdreg = esc->sc_reg + NCR_CMD * 16;
	fiforeg = esc->sc_reg + NCR_FIFO * 16;
	statreg = esc->sc_reg + NCR_STAT * 16;
	intrreg = esc->sc_reg + NCR_INTR * 16;
	do {
		if (esc->sc_datain) {
			*p++ = *fiforeg;
			cnt--;
			if (espphase == DATA_IN_PHASE)
				*cmdreg = NCRCMD_TRANS;
			else
				esc->sc_active = 0;
		} else {
			if ((espphase == DATA_OUT_PHASE) ||
			    (espphase == MESSAGE_OUT_PHASE)) {
				*fiforeg = *p++;
				cnt--;
				*cmdreg = NCRCMD_TRANS;
			} else
				esc->sc_active = 0;
		}

		if (esc->sc_active) {
			while (!(*statreg & NCRSTAT_INT));
			s = splhigh();
			espstat = *statreg;
			espintr = *intrreg;
			if (espintr & NCRINTR_DIS)
				espphase = BUSFREE_PHASE; /* disconnected */
			else
				espphase = espstat & PHASE_MASK;
			splx(s);
		}
	} while (cnt > 0 /* XXXRO not present in esp_dma_intr() */ &&
	    esc->sc_active && (espintr & NCRINTR_BS));

	/* XXXRO */
	KASSERT(cnt >= 0);

	sc->sc_phase = espphase;
	sc->sc_espstat = espstat;
	sc->sc_espintr = espintr;
	*esc->sc_dmaaddr = p;
	*esc->sc_dmalen -= esc->sc_dmasize - cnt;

	if (cnt == 0) {
		/* XXXRO */
		esc->sc_active = 0;
		esc->sc_tc = NCRSTAT_TC;
	}

	sc->sc_espstat |= esc->sc_tc;

#if DEBUG
	printf("[av_pio_intr: PIO %s of %d bytes done %d residual]\n",
	    esc->sc_datain ? "read" : "write", esc->sc_dmasize - cnt, cnt) ;
#endif

	return 0;
}

static int
esp_av_dma_setup(struct ncr53c9x_softc *sc, uint8_t **addr, size_t *len,
    int datain, size_t *dmasize)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	size_t round_bytes;

	esc->sc_dmaaddr = addr;
	esc->sc_dmalen = len;
	esc->sc_datain = datain;

	/*
	 * XXXRO
	 * No need to set up DMA in `Transfer Pad' operation.
	 */
	if (*dmasize == 0) {
		esc->sc_dmasize = 0;
		return 0;
	}

	/*
	 * Do short transfers of 16 bytes or less using PIO.
	 */
	if (*dmasize <= 16) {
		esc->sc_pio = 1;
		esc->sc_tc = 0;
		esc->sc_dmasize = *dmasize;
#ifdef DEBUG
		printf("[av_dma_setup: short PIO "
		    "req %zu act %zu v %p p 0x%x %s]\n",
		    *len, esc->sc_dmasize, *esc->sc_dmaaddr,
		    kvtop(*esc->sc_dmaaddr), esc->sc_datain ?
		    "read" : "write");
#endif
		return 0;
	}

	/*
	 * Ensure the transfer is on a 16-byte aligned boundary for
	 * the DMA engine by doing PIO to the next 16-byte boundary.
	 */
	if ((uintptr_t)*addr & 0xf) {
		esc->sc_pio = 1;
		esc->sc_tc = 0;

		round_bytes = 16 - ((uintptr_t)*addr & 0xf);

		/* Try to optimize for fewer interrrupts */
		if (*dmasize > 16 + round_bytes)
			esc->sc_dmasize = round_bytes;
		else
			esc->sc_dmasize = *dmasize;

#ifdef DEBUG
		printf("[av_dma_setup: round PIO "
		    "req %zu act %zu v %p p 0x%x %s]\n",
		    *len, esc->sc_dmasize, *esc->sc_dmaaddr,
		    kvtop(*esc->sc_dmaaddr), esc->sc_datain ?
		    "read" : "write");
#endif

		return 0;
	}

	/*
	 * The DMA engine seems to like to move data in multiples of
	 * 16 bytes. So if there are any trailing bytes, we move them
	 * using PIO.
	 */
	if(*dmasize & 0xf) {
#ifdef DEBUG
		printf("[av_dma_setup: trimming %zu trailing bytes from DMA]\n",
		    *dmasize & 0xf);
#endif
		*dmasize -= *dmasize & 0xf;
	}

	/*
	 * At this point the data is acceptable for a DMA transaction.
	 */
	esc->sc_pio = 0;

	bus_dmamap_load(esc->sc_dmat, esc->sc_dmap, *esc->sc_dmaaddr,
	    *dmasize, NULL, BUS_DMA_NOWAIT);

	/*
	 * The DMA engine can only transfer one contiguous segment at a time.
	 */
	*dmasize = esc->sc_dmap->dm_segs[0].ds_len;
	esc->sc_dmasize = *dmasize;

	bus_dmamap_sync(esc->sc_dmat, esc->sc_dmap, 0, esc->sc_dmasize,
	    esc->sc_datain ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);

	/*
	 * We must start a DMA before the device is ready to transfer
	 * data or the DMA engine gets confused and thinks it has to
	 * do a write when it should really do a read.
	 *
	 * Doing this here also seems to work fine for DMA writes.
	 */
#ifdef DEBUG
	printf("[av_dma_setup: DMA req %zu act %zu v %p p 0x%lx %s]\n",
	    *len, esc->sc_dmasize, *esc->sc_dmaaddr,
	    esc->sc_dmap->dm_segs[0].ds_addr, esc->sc_datain ?
	    "read" : "write");
#endif
	start_psc_dma(PSC_DMA_CHANNEL_SCSI, &esc->sc_rset,
	    esc->sc_dmap->dm_segs[0].ds_addr,
	    esc->sc_dmasize & ~0x1UL, esc->sc_datain);

	return 0;
}

static void
esp_av_dma_go(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;

	/*
	 * XXXRO
	 * No DMA transfer in Transfer Pad operation
	 */
	if (esc->sc_dmasize == 0)
		return;

	if (esc->sc_pio && esc->sc_datain == 0) {
		NCR_WRITE_REG(sc, NCR_FIFO, **esc->sc_dmaaddr);
		(*esc->sc_dmaaddr)++;
		(*esc->sc_dmalen)--;
		esc->sc_dmasize--;
	}
	esc->sc_active = 1;
}

static void
esp_av_dma_stop(struct ncr53c9x_softc *sc)
{
	struct esp_softc *esc = (struct esp_softc *)sc;
	uint32_t res;

	if (esc->sc_active && !esc->sc_pio)
		stop_psc_dma(PSC_DMA_CHANNEL_SCSI, esc->sc_rset, &res,
		    esc->sc_datain);

	bus_dmamap_unload(esc->sc_dmat, esc->sc_dmap);

	esc->sc_active = esc->sc_tc = 0;
}