root/dev/sbus/mgx.c

DEFINITIONS

1. mgxmatch
2. mgxattach
3. mgx_ioctl
4. mgx_mmap
5. mgx_alloc_screen
6. mgx_free_screen
7. mgx_show_screen
8. mgx_burner
9. mgx_setcolor
10. mgx_loadcmap
11. mgx_getcmap
12. mgx_putcmap

    1 /*      $OpenBSD: mgx.c,v 1.8 2007/02/18 18:38:55 miod Exp $    */
    2 /*
    3  * Copyright (c) 2003, Miodrag Vallat.
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   18  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   19  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   23  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   24  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   25  * POSSIBILITY OF SUCH DAMAGE.
   26  *
   27  */
   29 /*
   30  * Driver for the Southland Media Systems (now Quantum 3D) MGX and MGXPlus
   31  * frame buffers.
   32  *
   33  * Pretty crude, due to the lack of documentation. Works as a dumb frame
   34  * buffer in 8 bit mode, although the hardware can run in an 32 bit
   35  * accelerated mode. Also, interrupts are not handled.
   36  */
   38 #include <sys/param.h>
   39 #include <sys/systm.h>
   40 #include <sys/buf.h>
   41 #include <sys/device.h>
   42 #include <sys/ioctl.h>
   43 #include <sys/malloc.h>
   44 #include <sys/mman.h>
   45 #include <sys/tty.h>
   46 #include <sys/conf.h>
   48 #include <uvm/uvm_extern.h>
   50 #include <machine/autoconf.h>
   51 #include <machine/pmap.h>
   52 #include <machine/cpu.h>
   53 #include <machine/conf.h>
   55 #include <dev/wscons/wsconsio.h>
   56 #include <dev/wscons/wsdisplayvar.h>
   57 #include <dev/rasops/rasops.h>
   58 #include <machine/fbvar.h>
   60 #include <dev/sbus/sbusvar.h>
   62 /*
   63  * MGX PROM register layout
   64  */
   66 #define MGX_NREG        9
   67 #define MGX_REG_CRTC    4       /* video control and ramdac */
   68 #define MGX_REG_CTRL    5       /* control engine */
   69 #define MGX_REG_VRAM8   8       /* 8-bit memory space */
   71 /*
   72  * MGX CRTC empirical constants
   73  */
   74 #if _BYTE_ORDER == _LITTLE_ENDIAN
   75 #define IO_ADDRESS(x)           (x)
   76 #else
   77 #define IO_ADDRESS(x)           ((x) ^ 0x03)
   78 #endif
   79 #define CRTC_INDEX              IO_ADDRESS(0x03c4)
   80 #define CRTC_DATA               IO_ADDRESS(0x03c5)
   81 #define CD_DISABLEVIDEO 0x0020
   82 #define CMAP_READ_INDEX         IO_ADDRESS(0x03c7)
   83 #define CMAP_WRITE_INDEX        IO_ADDRESS(0x03c8)
   84 #define CMAP_DATA               IO_ADDRESS(0x03c9)
   86 /* per-display variables */
   87 struct mgx_softc {
   88         struct  sunfb   sc_sunfb;       /* common base device */
bus_space_tag_t sc_bustag;
bus_addr_t      sc_paddr;
u_int8_t        sc_cmap[256 * 3];       /* shadow colormap */
   94         volatile u_int8_t *sc_vidc;     /* ramdac registers */
   96         int     sc_nscreens;
   97 };
   99 int mgx_ioctl(void *, u_long, caddr_t, int, struct proc *);
  100 int mgx_alloc_screen(void *, const struct wsscreen_descr *, void **,
  101     int *, int *, long *);
  102 void mgx_free_screen(void *, void *);
  103 int mgx_show_screen(void *, void *, int, void (*cb)(void *, int, int),
  104     void *);
paddr_t mgx_mmap(void *, off_t, int);
  106 void mgx_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
  107 int mgx_getcmap(u_int8_t *, struct wsdisplay_cmap *);
  108 int mgx_putcmap(u_int8_t *, struct wsdisplay_cmap *);
  109 void mgx_loadcmap(struct mgx_softc *, int, int);
  110 void mgx_burner(void *, u_int ,u_int);
  112 struct wsdisplay_accessops mgx_accessops = {
mgx_ioctl,
mgx_mmap,
mgx_alloc_screen,
mgx_free_screen,
mgx_show_screen,
NULL,   /* load_font */
NULL,   /* scrollback */
NULL,   /* getchar */
mgx_burner
  122 };
  124 int mgxmatch(struct device *, void *, void *);
  125 void mgxattach(struct device *, struct device *, void *);
  127 struct cfattach mgx_ca = {
  128         sizeof(struct mgx_softc), mgxmatch, mgxattach
  129 };
  131 struct cfdriver mgx_cd = {
NULL, "mgx", DV_DULL
  133 };
  135 /*
  136  * Match an MGX or MGX+ card.
  137  */
  138 int
mgxmatch(struct device *parent, void *vcf, void *aux)
  140 {
  141         struct sbus_attach_args *sa = aux;
  143         if (strcmp(sa->sa_name, "SMSI,mgx") != 0 &&
strcmp(sa->sa_name, "mgx") != 0)
  145                 return (0);
  147         return (1);
  148 }
  150 /*
  151  * Attach an MGX frame buffer.
  152  * This will keep the frame buffer in the actual PROM mode, and attach
  153  * a wsdisplay child device to itself.
  154  */
  155 void
mgxattach(struct device *parent, struct device *self, void *args)
  157 {
  158         struct mgx_softc *sc = (struct mgx_softc *)self;
  159         struct sbus_attach_args *sa = args;
bus_space_tag_t bt;
bus_space_handle_t bh;
  162         int node, fbsize;
  163         int isconsole;
bt = sa->sa_bustag;
node = sa->sa_node;
printf(": %s", getpropstring(node, "model"));
isconsole = node == fbnode;
  172         /* Check registers */
  173         if (sa->sa_nreg < MGX_NREG) {
printf("\n%s: expected %d registers, got %d\n",
self->dv_xname, MGX_NREG, sa->sa_nreg);
  176                 return;
  177         }
sc->sc_bustag = bt;
  180         if (sbus_bus_map(bt, sa->sa_reg[MGX_REG_CRTC].sbr_slot,
sa->sa_reg[MGX_REG_CRTC].sbr_offset, PAGE_SIZE,
BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
printf("\n%s: couldn't map crtc registers\n", self->dv_xname);
  184                 return;
  185         }
sc->sc_vidc = (volatile u_int8_t *)bus_space_vaddr(bt, bh);
  188         /* enable video */
mgx_burner(sc, 1, 0);
fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, 0);
  193         /* Sanity check frame buffer memory */
fbsize = getpropint(node, "fb_size", 0);
  195         if (fbsize != 0 && sc->sc_sunfb.sf_fbsize > fbsize) {
printf("\n%s: expected at least %d bytes of vram, but card "
  197                     "only provides %d\n",
self->dv_xname, sc->sc_sunfb.sf_fbsize, fbsize);
  199                 return;
  200         }
  202         /* Map the frame buffer memory area we're interested in */
sc->sc_paddr = sbus_bus_addr(bt, sa->sa_reg[MGX_REG_VRAM8].sbr_slot,
sa->sa_reg[MGX_REG_VRAM8].sbr_offset);
  205         if (sbus_bus_map(bt, sa->sa_reg[MGX_REG_VRAM8].sbr_slot,
sa->sa_reg[MGX_REG_VRAM8].sbr_offset,
round_page(sc->sc_sunfb.sf_fbsize),
BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
printf("\n%s: couldn't map video memory\n", self->dv_xname);
  210                 return;
  211         }
sc->sc_sunfb.sf_ro.ri_bits = bus_space_vaddr(bt, bh);
sc->sc_sunfb.sf_ro.ri_hw = sc;
fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
bzero(sc->sc_cmap, sizeof(sc->sc_cmap));
fbwscons_setcolormap(&sc->sc_sunfb, mgx_setcolor);
printf(", %dx%d\n",
sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
  223         if (isconsole) {
fbwscons_console_init(&sc->sc_sunfb, -1);
  225         }
fbwscons_attach(&sc->sc_sunfb, &mgx_accessops, isconsole);
  228 }
  230 /*
  231  * wsdisplay operations
  232  */
  234 int
mgx_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
  236 {
  237         struct mgx_softc *sc = dev;
  238         struct wsdisplay_cmap *cm;
  239         struct wsdisplay_fbinfo *wdf;
  240         int error;
  242         switch (cmd) {
  243         case WSDISPLAYIO_GTYPE:
  244                 *(u_int *)data = WSDISPLAY_TYPE_MGX;
  245                 break;
  246         case WSDISPLAYIO_GINFO:
wdf = (struct wsdisplay_fbinfo *)data;
wdf->height = sc->sc_sunfb.sf_height;
wdf->width = sc->sc_sunfb.sf_width;
wdf->depth = sc->sc_sunfb.sf_depth;
wdf->cmsize = 256;
  252                 break;
  253         case WSDISPLAYIO_LINEBYTES:
  254                 *(u_int *)data = sc->sc_sunfb.sf_linebytes;
  255                 break;
  257         case WSDISPLAYIO_GETCMAP:
cm = (struct wsdisplay_cmap *)data;
error = mgx_getcmap(sc->sc_cmap, cm);
  260                 if (error != 0)
  261                         return (error);
  262                 break;
  263         case WSDISPLAYIO_PUTCMAP:
cm = (struct wsdisplay_cmap *)data;
error = mgx_putcmap(sc->sc_cmap, cm);
  266                 if (error != 0)
  267                         return (error);
mgx_loadcmap(sc, cm->index, cm->count);
  269                 break;
  271         case WSDISPLAYIO_SVIDEO:
  272         case WSDISPLAYIO_GVIDEO:
  273                 break;
  275         default:
  276                 return (-1);
  277         }
  279         return (0);
  280 }
paddr_t
mgx_mmap(void *v, off_t offset, int prot)
  284 {
  285         struct mgx_softc *sc = v;
  287         if (offset & PGOFSET)
  288                 return (-1);
  290         /* Allow mapping as a dumb framebuffer from offset 0 */
  291         if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
  292                 return (bus_space_mmap(sc->sc_bustag, sc->sc_paddr,
offset, prot, BUS_SPACE_MAP_LINEAR));
  294         }
  296         return (-1);
  297 }
  299 int
mgx_alloc_screen(void *v, const struct wsscreen_descr *type,
  301     void **cookiep, int *curxp, int *curyp, long *attrp)
  302 {
  303         struct mgx_softc *sc = v;
  305         if (sc->sc_nscreens > 0)
  306                 return (ENOMEM);
  308         *cookiep = &sc->sc_sunfb.sf_ro;
  309         *curyp = 0;
  310         *curxp = 0;
sc->sc_sunfb.sf_ro.ri_ops.alloc_attr(&sc->sc_sunfb.sf_ro,
  312              0, 0, 0, attrp);
sc->sc_nscreens++;
  314         return (0);
  315 }
  317 void
mgx_free_screen(void *v, void *cookie)
  319 {
  320         struct mgx_softc *sc = v;
sc->sc_nscreens--;
  323 }
  325 int
mgx_show_screen(void *v, void *cookie, int waitok,
  327     void (*cb)(void *, int, int), void *cbarg)
  328 {
  329         return (0);
  330 }
  332 void
mgx_burner(void *v, u_int on, u_int flags)
  334 {
  335         struct mgx_softc *sc = v;
sc->sc_vidc[CRTC_INDEX] = 1;    /* TS mode register */
  338         if (on)
sc->sc_vidc[CRTC_DATA] &= ~CD_DISABLEVIDEO;
  340         else
sc->sc_vidc[CRTC_DATA] |= CD_DISABLEVIDEO;
  342 }
  344 /*
  345  * Colormap handling routines
  346  */
  348 void
mgx_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
  350 {
  351         struct mgx_softc *sc = v;
index *= 3;
sc->sc_cmap[index++] = r;
sc->sc_cmap[index++] = g;
sc->sc_cmap[index] = b;
mgx_loadcmap(sc, index, 1);
  359 }
  361 void
mgx_loadcmap(struct mgx_softc *sc, int start, int ncolors)
  363 {
u_int8_t *color;
  365         int i;
  367 #if 0
sc->sc_vidc[CMAP_WRITE_INDEX] = start;
color = sc->sc_cmap + start * 3;
  370 #else
  371         /*
  372          * Apparently there is no way to load an incomplete cmap to this
  373          * DAC. What a waste.
  374          */
ncolors = 256;
color = sc->sc_cmap;
  377 #endif
  378         for (i = ncolors * 3; i != 0; i--)
sc->sc_vidc[CMAP_DATA] = *color++;
  380 }
  382 int
mgx_getcmap(u_int8_t *cm, struct wsdisplay_cmap *rcm)
  384 {
u_int index = rcm->index, count = rcm->count, i;
  386         int error;
  388         if (index >= 256 || count > 256 - index)
  389                 return (EINVAL);
  391         for (i = 0; i < count; i++) {
  392                 if ((error =
copyout(cm + (index + i) * 3 + 0, &rcm->red[i], 1)) != 0)
  394                         return (error);
  395                 if ((error =
copyout(cm + (index + i) * 3 + 1, &rcm->green[i], 1)) != 0)
  397                         return (error);
  398                 if ((error =
copyout(cm + (index + i) * 3 + 2, &rcm->blue[i], 1)) != 0)
  400                         return (error);
  401         }
  403         return (0);
  404 }
  406 int
mgx_putcmap(u_int8_t *cm, struct wsdisplay_cmap *rcm)
  408 {
u_int index = rcm->index, count = rcm->count, i;
  410         int error;
  412         if (index >= 256 || count > 256 - index)
  413                 return (EINVAL);
  415         for (i = 0; i < count; i++) {
  416                 if ((error =
copyin(&rcm->red[i], cm + (index + i) * 3 + 0, 1)) != 0)
  418                         return (error);
  419                 if ((error =
copyin(&rcm->green[i], cm + (index + i) * 3 + 1, 1)) != 0)
  421                         return (error);
  422                 if ((error =
copyin(&rcm->blue[i], cm + (index + i) * 3 + 2, 1)) != 0)
  424                         return (error);
  425         }
  427         return (0);
  428 }