xref: /src/sys/arch/mac68k/dev/grf_compat.c

/*	$NetBSD: grf_compat.c,v 1.9 2002/10/10 22:33:16 jdolecek Exp $	*/

/*
 * Copyright (C) 1999 Scott Reynolds
 * 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 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.
 */

/*
 * macfb compatibility with legacy grf devices
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/cdefs.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/mman.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/vnode.h>

#include <machine/autoconf.h>
#include <machine/bus.h>
#include <machine/grfioctl.h>

#include <mac68k/nubus/nubus.h>
#include <mac68k/dev/grfvar.h>
#include <mac68k/dev/macfbvar.h>

#include <miscfs/specfs/specdev.h>

#include <uvm/uvm_extern.h>
#include <uvm/uvm_map.h>

dev_type_open(grfopen);
dev_type_close(grfclose);
dev_type_ioctl(grfioctl);
dev_type_mmap(grfmmap);

const struct cdevsw grf_cdevsw = {
	grfopen, grfclose, noread, nowrite, grfioctl,
	nostop, notty, nopoll, grfmmap,
};

void	grf_scinit __P((struct grf_softc *, const char *, int));
void	grf_init __P((int));
void	grfattach __P((int));
int	grfmap __P((dev_t, struct macfb_softc *, caddr_t *, struct proc *));
int	grfunmap __P((dev_t, struct macfb_softc *, caddr_t, struct proc *));

/* Non-private for the benefit of libkvm. */
struct	grf_softc *grf_softc;
int	numgrf = 0;

/*
 * Initialize a softc to sane defaults.
 */
void
grf_scinit(sc, name, unit)
	struct grf_softc *sc;
	const char *name;
	int unit;
{
	memset(sc, 0, sizeof(struct grf_softc));
	snprintf(sc->sc_xname, sizeof(sc->sc_xname), "%s%d", name, unit);
	sc->mfb_sc = NULL;
}

/*
 * (Re-)initialize the grf_softc block so that at least the requested
 * number of elements has been allocated.  If this results in more
 * elements than we had prior to getting here, we initialize each of
 * them to avoid problems down the road.
 */
void
grf_init(n)
	int n;
{
	struct grf_softc *sc;
	int i;

	if (n >= numgrf) {
		i = numgrf;
		numgrf = n + 1;

		if (grf_softc == NULL)
			sc = (struct grf_softc *)
			    malloc(numgrf * sizeof(*sc),
			    M_DEVBUF, M_NOWAIT);
		else
			sc = (struct grf_softc *)
			    realloc(grf_softc, numgrf * sizeof(*sc),
			    M_DEVBUF, M_NOWAIT);
		if (sc == NULL) {
			printf("WARNING: no memory for grf emulation\n");
			if (grf_softc != NULL)
				free(grf_softc, M_DEVBUF);
			return;
		}
		grf_softc = sc;

		/* Initialize per-softc structures. */
		while (i < numgrf) {
			grf_scinit(&grf_softc[i], "grf", i);
			i++;
		}
	}
}

/*
 * Called by main() during pseudo-device attachment.  If we had a
 * way to configure additional grf devices later, this would actually
 * allocate enough space for them.  As it stands, it's nonsensical,
 * so other than a basic sanity check we do nothing.
 */
void
grfattach(n)
	int n;
{
	if (n <= 0) {
#ifdef DIAGNOSTIC
		panic("grfattach: count <= 0");
#endif
		return;
	}

#if 0 /* XXX someday, if we implement a way to attach after autoconfig */
	grf_init(n);
#endif
}

/*
 * Called from macfb_attach() after setting up the frame buffer.  Since
 * there is a 1:1 correspondence between the macfb device and the grf
 * device, the only bit of information we really need is the macfb_softc.
 */
void
grf_attach(sc, unit)
	struct macfb_softc *sc;
	int unit;
{
	grf_init(unit);

	if (unit < numgrf)
		grf_softc[unit].mfb_sc = sc;
}

/*
 * Standard device ops
 */
int
grfopen(dev, flag, mode, p)
	dev_t dev;
	int flag;
	int mode;
	struct proc *p;
{
	struct grf_softc *sc;
	int unit = GRFUNIT(dev);
	int rv = 0;

	if (grf_softc == NULL || unit >= numgrf)
		return ENXIO;

	sc = &grf_softc[unit];
	if (sc->mfb_sc == NULL)
		rv = ENXIO;

	return rv;
}

int
grfclose(dev, flag, mode, p)
	dev_t dev;
	int flag;
	int mode;
	struct proc *p;
{
	struct grf_softc *sc;
	int unit = GRFUNIT(dev);
	int rv = 0;

	if (grf_softc == NULL || unit >= numgrf)
		return ENXIO;

	sc = &grf_softc[unit];
	if (sc->mfb_sc != NULL)
		macfb_clear(sc->mfb_sc->sc_dc);	/* clear the display */
	else
		rv = ENXIO;

	return rv;
}

int
grfioctl(dev, cmd, data, flag, p)
	dev_t dev;
	u_long cmd;
	caddr_t data;
	int flag;
	struct proc *p;
{
	struct grf_softc *sc;
	struct macfb_devconfig *dc;
#if defined(GRF_COMPAT) || (NGRF > 0)
	struct grfinfo *gd;
#endif /* GRF_COMPAT || (NGRF > 0) */
	struct grfmode *gm;
	int unit = GRFUNIT(dev);
	int rv;

	if (grf_softc == NULL || unit >= numgrf)
		return ENXIO;

	sc = &grf_softc[unit];
	if (sc->mfb_sc == NULL)
		return ENXIO;

	dc = sc->mfb_sc->sc_dc;

	switch (cmd) {
#if defined(GRF_COMPAT) || (NGRF > 0)
	case GRFIOCGINFO:
		gd = (struct grfinfo *)data;
		memset(gd, 0, sizeof(struct grfinfo));
		gd->gd_fbaddr     = (caddr_t)dc->dc_paddr;
		gd->gd_fbsize     = dc->dc_size;
		gd->gd_colors     = (short)(1 << dc->dc_depth);
		gd->gd_planes     = (short)dc->dc_depth;
		gd->gd_fbwidth    = dc->dc_wid;
		gd->gd_fbheight   = dc->dc_ht;
		gd->gd_fbrowbytes = dc->dc_rowbytes;
		gd->gd_dwidth     = dc->dc_raster.width;
		gd->gd_dheight    = dc->dc_raster.height;
		rv = 0;
		break;
#endif /* GRF_COMPAT || (NGRF > 0) */

	case GRFIOCON:
	case GRFIOCOFF:
		/* Nothing to do */
		rv = 0;
		break;

#if defined(GRF_COMPAT) || (NGRF > 0)
	case GRFIOCMAP:
		rv = grfmap(dev, sc->mfb_sc, (caddr_t *)data, p);
		break;

	case GRFIOCUNMAP:
		rv = grfunmap(dev, sc->mfb_sc, *(caddr_t *)data, p);
		break;
#endif /* GRF_COMPAT || (NGRF > 0) */

	case GRFIOCGMODE:
		gm = (struct grfmode *)data;
		memset(gm, 0, sizeof(struct grfmode));
		gm->fbbase   = (char *)dc->dc_vaddr;
		gm->fbsize   = dc->dc_size;
		gm->fboff    = dc->dc_offset;
		gm->rowbytes = dc->dc_rowbytes;
		gm->width    = dc->dc_wid;
		gm->height   = dc->dc_ht;
		gm->psize    = dc->dc_depth;
		rv = 0;
		break;

	case GRFIOCLISTMODES:
	case GRFIOCGETMODE:
	case GRFIOCSETMODE:
		/* NONE of these operations are (officially) supported. */
	default:
		rv = EINVAL;
		break;
	}
	return rv;
}

paddr_t
grfmmap(dev, off, prot)
	dev_t dev;
	off_t off;
	int prot;
{
	struct grf_softc *sc;
	struct macfb_devconfig *dc;
	paddr_t addr;
	int unit = GRFUNIT(dev);

	if (grf_softc == NULL || unit >= numgrf)
		return ENXIO;

	sc = &grf_softc[unit];
	if (sc->mfb_sc == NULL)
		return ENXIO;

	dc = sc->mfb_sc->sc_dc;

	if (off >= 0 &&
	    off < m68k_round_page(dc->dc_offset + dc->dc_size))
		addr = m68k_btop(dc->dc_paddr + off);
	else
		addr = (-1);	/* XXX bogus */

	return addr;
}

int
grfmap(dev, sc, addrp, p)
	dev_t dev;
	struct macfb_softc *sc;
	caddr_t *addrp;
	struct proc *p;
{
	struct specinfo si;
	struct vnode vn;
	u_long len;
	int error, flags;

	*addrp = (caddr_t)sc->sc_dc->dc_paddr;
	len = m68k_round_page(sc->sc_dc->dc_offset + sc->sc_dc->dc_size);
	flags = MAP_SHARED | MAP_FIXED;

	vn.v_type = VCHR;		/* XXX */
	vn.v_specinfo = &si;		/* XXX */
	vn.v_rdev = dev;		/* XXX */

	error = uvm_mmap(&p->p_vmspace->vm_map, (vaddr_t *)addrp,
	    (vsize_t)len, VM_PROT_ALL, VM_PROT_ALL,
	    flags, (caddr_t)&vn, 0, p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur);

	/* Offset into page: */
	*addrp += sc->sc_dc->dc_offset;

	return (error);
}

int
grfunmap(dev, sc, addr, p)
	dev_t dev;
	struct macfb_softc *sc;
	caddr_t addr;
	struct proc *p;
{
	vm_size_t size;

	addr -= sc->sc_dc->dc_offset;

	if (addr <= 0)
		return (-1);

	size = m68k_round_page(sc->sc_dc->dc_offset + sc->sc_dc->dc_size);
	uvm_unmap(&p->p_vmspace->vm_map, (vaddr_t)addr, (vaddr_t)addr + size);
	return 0;
}