xref: /src/sys/arch/evbppc/virtex/design_gsrd1.c

/* 	$NetBSD: design_gsrd1.c,v 1.1.4.2 2006/12/30 20:45:54 yamt Exp $ */

/*
 * Copyright (c) 2006 Jachym Holecek
 * All rights reserved.
 *
 * Written for DFC Design, s.r.o.
 *
 * 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.
 *
 * 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: design_gsrd1.c,v 1.1.4.2 2006/12/30 20:45:54 yamt Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/malloc.h>

#include <machine/cpu.h>
#include <machine/bus.h>
#include <machine/intr.h>

#include <powerpc/ibm4xx/dev/plbvar.h>

#include <evbppc/virtex/dev/xcvbusvar.h>

#include <evbppc/virtex/dev/xlcomreg.h>
#include <evbppc/virtex/dev/cdmacreg.h>
#include <evbppc/virtex/dev/temacreg.h>
#include <evbppc/virtex/dev/tftreg.h>

#include <evbppc/virtex/virtex.h>
#include <evbppc/virtex/dcr.h>


#define DCR_CDMAC_BASE 		0x0140
#define DCR_XLCOM_BASE 		0x0000
#define DCR_TEMAC_BASE 		0x0030
#define DCR_LLFB_BASE 		0x0080

#define CDMAC_TX0_STAT 		CDMAC_STAT_BASE(0)
#define CDMAC_RX0_STAT 		CDMAC_STAT_BASE(1)
#define CDMAC_TX1_STAT 		CDMAC_STAT_BASE(2)
#define CDMAC_RX1_STAT 		CDMAC_STAT_BASE(3)

#define CDMAC_TX0_BASE 		CDMAC_CTRL_BASE(0)
#define CDMAC_RX0_BASE 		CDMAC_CTRL_BASE(1)
#define CDMAC_TX1_BASE 		CDMAC_CTRL_BASE(2)
#define CDMAC_RX1_BASE 		CDMAC_CTRL_BASE(3)

#define CDMAC_INTR_LINE 	2
#define CDMAC_NCHAN 		4

#define IPL_CDMAC 		IPL_NET
#define splcdmac() 		splnet()


/*
 * CDMAC per-channel interrupt handler. CDMAC has only one interrupt signal
 * shared by all channels on GSRD, so we have to dispatch channels manually.
 *
 * Note: we hardwire priority to IPL_NET, temac(4) is the only device that
 * needs to service DMA interrupts anyway.
 */
struct cdmac_intr_handle {
	void 			(*cih_func)(void *);
	void 			*cih_arg;
};

static void 			*cdmac_ih = NULL; 	/* real CDMAC intr */
static struct cdmac_intr_handle *cdmac_intrs[CDMAC_NCHAN];


/*
 * DCR bus space leaf access routines.
 */

static void
xlcom0_write_4(bus_space_tag_t t, bus_space_handle_t h, uint32_t addr,
    uint32_t val)
{
	addr += h;

	switch (addr) {
	WCASE(DCR_XLCOM_BASE, XLCOM_TX_FIFO);
	WCASE(DCR_XLCOM_BASE, XLCOM_STAT);
	WCASE(DCR_XLCOM_BASE, XLCOM_CNTL);
	WDEAD(addr);
	}
}

static uint32_t
xlcom0_read_4(bus_space_tag_t t, bus_space_handle_t h, uint32_t addr)
{
	uint32_t 		val;

	addr += h;

	switch (addr) {
	RCASE(DCR_XLCOM_BASE, XLCOM_RX_FIFO);
	RCASE(DCR_XLCOM_BASE, XLCOM_STAT);
	RCASE(DCR_XLCOM_BASE, XLCOM_CNTL);
	RDEAD(addr);
	}

	return (val);
}

static void
tft0_write_4(bus_space_tag_t t, bus_space_handle_t h, uint32_t addr,
    uint32_t val)
{
	addr += h;

	switch (addr) {
	WCASE(DCR_LLFB_BASE, TFT_CTRL);
	WDEAD(addr);
	}
}

static uint32_t
tft0_read_4(bus_space_tag_t t, bus_space_handle_t h, uint32_t addr)
{
	uint32_t 		val;

	addr += h;

	switch (addr) {
	RCASE(DCR_LLFB_BASE, TFT_CTRL);
	RDEAD(addr);
	}

	return (val);
}

#define DOCHAN(op, channel) \
	op(DCR_CDMAC_BASE, channel + CDMAC_NEXT); 	\
	op(DCR_CDMAC_BASE, channel + CDMAC_CURADDR); 	\
	op(DCR_CDMAC_BASE, channel + CDMAC_CURSIZE); 	\
	op(DCR_CDMAC_BASE, channel + CDMAC_CURDESC)

static void
cdmac0_write_4(bus_space_tag_t t, bus_space_handle_t h, uint32_t addr,
    uint32_t val)
{
	addr += h;

	switch (addr) {
	WCASE(DCR_CDMAC_BASE, CDMAC_INTR);
	WCASE(DCR_CDMAC_BASE, CDMAC_TX0_STAT);
	WCASE(DCR_CDMAC_BASE, CDMAC_RX0_STAT);
	WCASE(DCR_CDMAC_BASE, CDMAC_TX1_STAT);
	WCASE(DCR_CDMAC_BASE, CDMAC_RX1_STAT);
	DOCHAN(WCASE, CDMAC_TX0_BASE);
	DOCHAN(WCASE, CDMAC_RX0_BASE);
	DOCHAN(WCASE, CDMAC_TX1_BASE);
	DOCHAN(WCASE, CDMAC_RX1_BASE);
	WDEAD(addr);
	}
}

static uint32_t
cdmac0_read_4(bus_space_tag_t t, bus_space_handle_t h, uint32_t addr)
{
	uint32_t 		val;

	addr += h;

	switch (addr) {
	RCASE(DCR_CDMAC_BASE, CDMAC_INTR);
	RCASE(DCR_CDMAC_BASE, CDMAC_TX0_STAT);
	RCASE(DCR_CDMAC_BASE, CDMAC_RX0_STAT);
	RCASE(DCR_CDMAC_BASE, CDMAC_TX1_STAT);
	RCASE(DCR_CDMAC_BASE, CDMAC_RX1_STAT);
	DOCHAN(RCASE, CDMAC_TX0_BASE);
	DOCHAN(RCASE, CDMAC_RX0_BASE);
	DOCHAN(RCASE, CDMAC_TX1_BASE);
	DOCHAN(RCASE, CDMAC_RX1_BASE);
	RDEAD(addr);
	}

	return (val);
}

#undef DOCHAN

static void
temac0_write_4(bus_space_tag_t t, bus_space_handle_t h, uint32_t addr,
    uint32_t val)
{
	addr += h;

	switch (addr) {
	WCASE(DCR_TEMAC_BASE, TEMAC_RESET);
	WDEAD(addr);
	}
}

static const struct powerpc_bus_space xlcom_bst = {
	DCR_BST_BODY(DCR_XLCOM_BASE, xlcom0_read_4, xlcom0_write_4)
};

static const struct powerpc_bus_space cdmac_bst = {
	DCR_BST_BODY(DCR_CDMAC_BASE, cdmac0_read_4, cdmac0_write_4)
};

static const struct powerpc_bus_space temac_bst = {
	DCR_BST_BODY(DCR_TEMAC_BASE, NULL, temac0_write_4)
};

static const struct powerpc_bus_space tft_bst = {
	DCR_BST_BODY(DCR_LLFB_BASE, tft0_read_4, tft0_write_4)
};

/*
 * Master device configuration table for GSRD design.
 */
static const struct gsrddev {
	const char 		*gdv_name;
	const char 		*gdv_attr;
	bus_space_tag_t 	gdv_bst;
	bus_addr_t 		gdv_addr;
	int 			gdv_intr;
	int 			gdv_rx_dma;
	int 			gdv_tx_dma;
} gsrd_devices[] = {
	{			/* gsrd_devices[0] */
		.gdv_name 	= "xlcom",
		.gdv_attr 	= "xcvbus",
		.gdv_bst 	= &xlcom_bst,
		.gdv_addr 	= 0,
		.gdv_intr 	= 0,
		.gdv_rx_dma 	= -1,
		.gdv_tx_dma 	= -1,
	},
	{			/* gsrd_devices[1] */
		.gdv_name 	= "temac",
		.gdv_attr 	= "xcvbus",
		.gdv_bst 	= &temac_bst,
		.gdv_addr 	= 0,
		.gdv_intr 	= 1,
		.gdv_rx_dma 	= 3,
		.gdv_tx_dma 	= 2,
	},
	{			/* gsrd_devices[2] */
		.gdv_name 	= "tft",
		.gdv_attr 	= "llbus",
		.gdv_bst 	= &tft_bst,
		.gdv_addr 	= 0,
		.gdv_intr 	= -1,
		.gdv_rx_dma 	= -1,
		.gdv_tx_dma 	= 0,
	}
};

static struct ll_dmac *
virtex_mpmc_mapdma(int n, struct ll_dmac *chan)
{
	if (n == -1)
		return (NULL);

	chan->dmac_iot = &cdmac_bst;
	chan->dmac_ctrl_addr = CDMAC_CTRL_BASE(n);
	chan->dmac_stat_addr = CDMAC_STAT_BASE(n);
	chan->dmac_chan = n;

	return (chan);
}

static int
cdmac_intr(void *arg)
{
	uint32_t 		isr;
	int 			i;
	int 			did = 0;

	isr = bus_space_read_4(&cdmac_bst, 0, CDMAC_INTR);
	bus_space_write_4(&cdmac_bst, 0, CDMAC_INTR, isr); 	/* ack */

	for (i = 0; i < CDMAC_NCHAN; i++)
		if (ISSET(isr, CDMAC_CHAN_INTR(i)) &&
		    cdmac_intrs[i] != NULL) {
			(cdmac_intrs[i]->cih_func)(cdmac_intrs[i]->cih_arg);
			did++;
		}

	/* XXX: This happens all the time under load... bug? */
#if 0
	if (did == 0)
		aprint_normal("WARNING: stray cdmac isr 0x%x\n", isr);
#endif

	return (0);
}

/*
 * Public interface.
 */

void
virtex_autoconf(device_t self, struct plb_attach_args *paa)
{
	struct xcvbus_attach_args 	vaa;
	struct ll_dmac 			rx, tx;
	int 				i;

	/* Reset all CDMAC engines, disable interrupt. */
	bus_space_write_4(&cdmac_bst, 0, CDMAC_STAT_BASE(0), CDMAC_STAT_RESET);
	bus_space_write_4(&cdmac_bst, 0, CDMAC_STAT_BASE(1), CDMAC_STAT_RESET);
	bus_space_write_4(&cdmac_bst, 0, CDMAC_STAT_BASE(2), CDMAC_STAT_RESET);
	bus_space_write_4(&cdmac_bst, 0, CDMAC_STAT_BASE(3), CDMAC_STAT_RESET);
	bus_space_write_4(&cdmac_bst, 0, CDMAC_INTR, 0);

	vaa.vaa_dmat = paa->plb_dmat;
	vaa._vaa_is_dcr = 1; 		/* XXX bst flag */

	/* Attach all we have. */
	for (i = 0; i < __arraycount(gsrd_devices); i++) {
		const struct gsrddev 	*g = &gsrd_devices[i];

		vaa.vaa_name 	= g->gdv_name;
		vaa.vaa_addr 	= g->gdv_addr;
		vaa.vaa_intr 	= g->gdv_intr;
		vaa.vaa_iot 	= g->gdv_bst;

		vaa.vaa_rx_dmac = virtex_mpmc_mapdma(g->gdv_rx_dma, &rx);
		vaa.vaa_tx_dmac = virtex_mpmc_mapdma(g->gdv_tx_dma, &tx);

		config_found_ia(self, g->gdv_attr, &vaa, xcvbus_print);
	}

	/* Setup the dispatch handler. */
	cdmac_ih = intr_establish(CDMAC_INTR_LINE, IST_LEVEL, IPL_CDMAC,
	    cdmac_intr, NULL);
	if (cdmac_ih == NULL)
		panic("virtex_autoconf: could not establish cdmac intr");

	/* Enable CDMAC interrupt. */
	bus_space_write_4(&cdmac_bst, 0, CDMAC_INTR, ~CDMAC_INTR_MIE);
	bus_space_write_4(&cdmac_bst, 0, CDMAC_INTR, CDMAC_INTR_MIE);
}

void *
ll_dmac_intr_establish(int chan, void (*func)(void *), void *arg)
{
	struct cdmac_intr_handle *ih;

	KASSERT(chan > 0 && chan < CDMAC_NCHAN);

	/* We only allow one handler per channel, somewhat arbitrarily. */
	if (cdmac_intrs[chan] != NULL)
		return (NULL);

	ih = malloc(sizeof(struct cdmac_intr_handle), M_DEVBUF,
	    cold ? M_NOWAIT : M_WAITOK);
	if (ih == NULL)
		return (NULL);

	ih->cih_func = func;
	ih->cih_arg = arg;

	return (cdmac_intrs[chan] = ih);
}

void
ll_dmac_intr_disestablish(int chan, void *handle)
{
	int 			s;

	KASSERT(chan > 0 && chan < CDMAC_NCHAN);
	KASSERT(cdmac_intrs[chan] == handle);

	s = splcdmac();
	cdmac_intrs[chan] = NULL;
	splx(s);

	free(handle, M_DEVBUF);
}

int
virtex_console_tag(const char *xname, bus_space_tag_t *bst)
{
	if (strncmp(xname, "xlcom", 5) == 0) {
		*bst = &xlcom_bst;
		return (0);
	}

	return (ENODEV);
}

void
virtex_machdep_init(vaddr_t endva, vsize_t maxsz, struct mem_region *phys,
    struct mem_region *avail)
{
	/* Nothing to do -- no memory-mapped devices. */
}

void
device_register(struct device *dev, void *aux)
{
	/* Nothing to do -- no property hacks needed. */
}