/*      $NetBSD: grf_compat.c,v 1.29 2019/11/10 21:16:29 chs 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 "opt_grf_compat.h"

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: grf_compat.c,v 1.29 2019/11/10 21:16:29 chs Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/resourcevar.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 "ioconf.h"

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

const struct cdevsw grf_cdevsw = {
       .d_open = grfopen,
       .d_close = grfclose,
       .d_read = noread,
       .d_write = nowrite,
       .d_ioctl = grfioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = grfmmap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = 0
};

void    grf_scinit(struct grf_softc *, const char *, int);
void    grf_init(int);
int     grfmap(dev_t, struct macfb_softc *, void **, struct proc *);
int     grfunmap(dev_t, struct macfb_softc *, void *, 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(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(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_WAITOK);
               else
                       sc = (struct grf_softc *)
                           realloc(grf_softc, numgrf * sizeof(*sc),
                           M_DEVBUF, M_WAITOK);
               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(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(struct macfb_softc *sc, int unit)
{

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

/*
* Standard device ops
*/
int
grfopen(dev_t dev, int flag, int mode, struct lwp *l)
{
       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_t dev, int flag, int mode, struct lwp *l)
{
       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_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
       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     = (void *)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, (void **)data, l->l_proc);
               break;

       case GRFIOCUNMAP:
               rv = grfunmap(dev, sc->mfb_sc, *(void **)data, l->l_proc);
               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_t dev, off_t off, int prot)
{
       struct grf_softc *sc;
       struct macfb_devconfig *dc;
       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 ((u_int)off < m68k_round_page(dc->dc_offset + dc->dc_size))
               return m68k_btop(dc->dc_paddr + off);

       return (-1);
}

int
grfmap(dev_t dev, struct macfb_softc *sc, void **addrp, struct proc *p)
{
       size_t len;
       int error;

       len = m68k_round_page(sc->sc_dc->dc_offset + sc->sc_dc->dc_size);
       error = uvm_mmap_dev(p, addrp, len, dev, 0);

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

       return (error);
}

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

       addr = (char *)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;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.