root/dev/sbus/zx.c

DEFINITIONS

1. zx_match
2. zx_attach
3. zx_ioctl
4. zx_alloc_screen
5. zx_free_screen
6. zx_show_screen
7. zx_mmap
8. zx_setcolor
9. zx_reset
10. zx_cross_wait
11. zx_cross_loadwid
12. zx_putcmap
13. zx_burner
14. zx_fillrect
15. zx_copyrect
16. zx_do_cursor
17. zx_erasecols
18. zx_eraserows
19. zx_copyrows
20. zx_copycols
21. zx_putchar

    1 /*      $OpenBSD: zx.c,v 1.13 2007/03/13 19:40:49 miod Exp $    */
    2 /*      $NetBSD: zx.c,v 1.5 2002/10/02 16:52:46 thorpej Exp $   */
    4 /*
    5  * Copyright (c) 2003, Miodrag Vallat.
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   20  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   21  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   23  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   25  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   26  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   27  * POSSIBILITY OF SUCH DAMAGE.
   28  *
   29  * Derived from NetBSD syssrc/sys/dev/sbus/zx.c under the following licence
   30  * terms:
   31  *
   32  *  Copyright (c) 2002 The NetBSD Foundation, Inc.
   33  *  All rights reserved.
   34  *
   35  *  This code is derived from software contributed to The NetBSD Foundation
   36  *  by Andrew Doran.
   37  *
   38  *  Redistribution and use in source and binary forms, with or without
   39  *  modification, are permitted provided that the following conditions
   40  *  are met:
   41  *  1. Redistributions of source code must retain the above copyright
   42  *     notice, this list of conditions and the following disclaimer.
   43  *  2. Redistributions in binary form must reproduce the above copyright
   44  *     notice, this list of conditions and the following disclaimer in the
   45  *     documentation and/or other materials provided with the distribution.
   46  *  3. All advertising materials mentioning features or use of this software
   47  *     must display the following acknowledgement:
   48  *         This product includes software developed by the NetBSD
   49  *         Foundation, Inc. and its contributors.
   50  *  4. Neither the name of The NetBSD Foundation nor the names of its
   51  *     contributors may be used to endorse or promote products derived
   52  *     from this software without specific prior written permission.
   53  *
   54  *  THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   55  *  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   56  *  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   57  *  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   58  *  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   59  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   60  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   61  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   62  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   63  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   64  *  POSSIBILITY OF SUCH DAMAGE.
   65  */
   67 /*
   68  * Driver for the Sun ZX display adapter.  This would be called 'leo', but
   69  * NetBSD/amiga already has a driver by that name.  The XFree86 and Linux
   70  * drivers were used as "living documentation" when writing this; thanks
   71  * to the authors.
   72  */
   74 #include <sys/param.h>
   75 #include <sys/systm.h>
   76 #include <sys/device.h>
   77 #include <sys/ioctl.h>
   78 #include <sys/malloc.h>
   79 #include <sys/mman.h>
   80 #include <sys/tty.h>
   81 #include <sys/conf.h>
   83 #include <uvm/uvm_extern.h>
   85 #include <machine/autoconf.h>
   86 #include <machine/bus.h>
   87 #include <machine/cpu.h>
   88 #include <machine/conf.h>
   90 #include <dev/wscons/wsconsio.h>
   91 #include <dev/wscons/wsdisplayvar.h>
   92 #include <dev/rasops/rasops.h>
   93 #include <machine/fbvar.h>
   95 #include <dev/sbus/zxreg.h>
   96 #include <dev/sbus/sbusvar.h>
   98 #define ZX_WID_SHARED_8         0
   99 #define ZX_WID_SHARED_24        1
  100 #define ZX_WID_DBL_8            2
  101 #define ZX_WID_DBL_24           3
  103 /*
  104  * Per-instance data.
  105  */
  107 struct zx_cmap {
u_int8_t        cm_red[256];
u_int8_t        cm_green[256];
u_int8_t        cm_blue[256];
  111 };
  113 struct zx_softc {
  114         struct  sunfb   sc_sunfb;
bus_space_tag_t sc_bustag;
bus_addr_t      sc_paddr;
  119         struct  zx_cmap sc_cmap;        /* shadow color map for overlay plane */
  121         volatile struct zx_command *sc_zc;
  122         volatile struct zx_cross *sc_zx;
  123         volatile struct zx_draw *sc_zd_ss0;
  124         volatile struct zx_draw_ss1 *sc_zd_ss1;
  125         volatile struct zx_cursor *sc_zcu;
  127         int     sc_nscreens;
  128 };
  130 int zx_ioctl(void *, u_long, caddr_t, int, struct proc *);
  131 int zx_alloc_screen(void *, const struct wsscreen_descr *, void **,
  132     int *, int *, long *);
  133 void zx_free_screen(void *, void *);
  134 int zx_show_screen(void *, void *, int, void (*)(void *, int, int), void *);
paddr_t zx_mmap(void *, off_t, int);
  136 void zx_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
  137 void zx_reset(struct zx_softc *, u_int);
  138 void zx_burner(void *, u_int, u_int);
  140 struct wsdisplay_accessops zx_accessops = {
zx_ioctl,
zx_mmap,
zx_alloc_screen,
zx_free_screen,
zx_show_screen,
NULL,   /* load_font */
NULL,   /* scrollback */
NULL,   /* getchar */
zx_burner
  150 };
  152 /* Force 32-bit writes. */
  153 #define SETREG(r, v)    (*((volatile u_int32_t *)&r) = (v))
  155 #define ZX_STD_ROP      (ZX_ROP_NEW | ZX_ATTR_WE_ENABLE | \
ZX_ATTR_OE_ENABLE | ZX_ATTR_FORCE_WID)
  158 #define ZX_BWIDTH       13
  159 #define ZX_WWIDTH       11      /* word width */
  161 #define ZX_COORDS(x, y) ((x) | ((y) << ZX_WWIDTH))
  163 void    zx_attach(struct device *, struct device *, void *);
  164 int     zx_match(struct device *, void *, void *);
  166 int     zx_putcmap(struct zx_softc *);
  167 void    zx_copyrect(struct rasops_info *, int, int, int, int, int, int);
  168 int     zx_cross_loadwid(struct zx_softc *, u_int, u_int, u_int);
  169 int     zx_cross_wait(struct zx_softc *);
  170 void    zx_fillrect(struct rasops_info *, int, int, int, int, long, int);
  171 int     zx_intr(void *);
  172 void    zx_prom(void *);
  174 void    zx_putchar(void *, int, int, u_int, long);
  175 void    zx_copycols(void *, int, int, int, int);
  176 void    zx_erasecols(void *, int, int, int, long);
  177 void    zx_copyrows(void *, int, int, int);
  178 void    zx_eraserows(void *, int, int, long);
  179 void    zx_do_cursor(struct rasops_info *);
  181 struct cfattach zx_ca = {
  182         sizeof(struct zx_softc), zx_match, zx_attach
  183 };
  185 struct cfdriver zx_cd = {
NULL, "zx", DV_DULL
  187 };
  189 int
zx_match(struct device *parent, void *vcf, void *aux)
  191 {
  192         struct sbus_attach_args *sa = aux;
  194         if (strcmp(sa->sa_name, "SUNW,leo") == 0)
  195                 return (1);
  197         return (0);
  198 }
  200 void
zx_attach(struct device *parent, struct device *self, void *args)
  202 {
  203         struct zx_softc *sc = (struct zx_softc *)self;
  204         struct sbus_attach_args *sa = args;
  205         struct rasops_info *ri;
bus_space_tag_t bt;
bus_space_handle_t bh;
  208         int node, isconsole = 0;
  209         const char *nam;
bt = sa->sa_bustag;
ri = &sc->sc_sunfb.sf_ro;
node = sa->sa_node;
  215         /*
  216          * Map the various parts of the card.
  217          */
sc->sc_bustag = bt;
sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset);
  221         if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LC_SS0_USR,
  222             sizeof(struct zx_command), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
printf(": couldn't map command registers\n");
  224                 return;
  225         }
sc->sc_zc = (struct zx_command *)bus_space_vaddr(bt, bh);
  228         if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS0,
  229             sizeof(struct zx_draw), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
printf(": couldn't map ss0 drawing registers\n");
  231                 return;
  232         }
sc->sc_zd_ss0 = (struct zx_draw *)bus_space_vaddr(bt, bh);
  235         if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS1,
  236             sizeof(struct zx_draw_ss1), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
printf(": couldn't map ss1 drawing registers\n");
  238                 return;
  239         }
sc->sc_zd_ss1 = (struct zx_draw_ss1 *)bus_space_vaddr(bt, bh);
  242         if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CROSS,
  243             sizeof(struct zx_cross), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
printf(": couldn't map cross registers\n");
  245                 return;
  246         }
sc->sc_zx = (struct zx_cross *)bus_space_vaddr(bt, bh);
  249         if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CURSOR,
  250             sizeof(struct zx_cursor), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
printf(": couldn't map cursor registers\n");
  252                 return;
  253         }
sc->sc_zcu = (struct zx_cursor *)bus_space_vaddr(bt, bh);
nam = getpropstring(node, "model");
  257         if (*nam == '\0')
nam = sa->sa_name;
printf(": %s", nam);
isconsole = node == fbnode;
  263         /*
  264          * The console is using the 8-bit overlay plane, while the prom
  265          * will correctly report 32 bit depth.
  266          * The following is an equivalent for
  267          *    fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, ca->ca_bustype);
  268          * forcing the depth value not to be overwritten.
  269          * Furthermore, the linebytes value is in fact 8192 bytes.
  270          */
sc->sc_sunfb.sf_depth = 8;
sc->sc_sunfb.sf_width = getpropint(node, "width", 1152);
sc->sc_sunfb.sf_height = getpropint(node, "height", 900);
sc->sc_sunfb.sf_linebytes = 1 << ZX_BWIDTH;
sc->sc_sunfb.sf_fbsize = sc->sc_sunfb.sf_height << ZX_BWIDTH;
printf(", %dx%d\n", sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
  279         if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_SS0,
round_page(sc->sc_sunfb.sf_fbsize), BUS_SPACE_MAP_LINEAR,
  281             0, &bh) != 0) {
printf("%s: couldn't map video memory\n", self->dv_xname);
  283                 return;
  284         }
ri->ri_bits = bus_space_vaddr(bt, bh);
ri->ri_hw = sc;
fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
  290         /*
  291          * Watch out! rasops_init() invoked via fbwscons_init() did not
  292          * compute ri_bits correctly when centering the display, because
  293          * it has been tricked with the low depth value.
  294          * Recompute now.
  295          */
ri->ri_emustride = ri->ri_emuwidth * 4;
ri->ri_delta = ri->ri_stride - ri->ri_emustride;
ri->ri_pelbytes = 4;
ri->ri_xscale = ri->ri_font->fontwidth * 4;
ri->ri_bits = ri->ri_origbits;
ri->ri_bits += (((ri->ri_width * 4) - ri->ri_emustride) >> 1) & ~3;
ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
ri->ri_stride;
ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits)
  305             / ri->ri_stride;
ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits)
  307             % ri->ri_stride) / 4);
ri->ri_ops.copyrows = zx_copyrows;
ri->ri_ops.copycols = zx_copycols;
ri->ri_ops.eraserows = zx_eraserows;
ri->ri_ops.erasecols = zx_erasecols;
ri->ri_ops.putchar = zx_putchar;
ri->ri_do_cursor = zx_do_cursor;
  316         if (isconsole) {
  317                 /* zx_reset() below will clear screen, so restart at 1st row */
fbwscons_console_init(&sc->sc_sunfb, 0);
  319         }
  321         /* reset cursor & frame buffer controls */
zx_reset(sc, WSDISPLAYIO_MODE_EMUL);
  324         /* enable video */
zx_burner(sc, 1, 0);
fbwscons_attach(&sc->sc_sunfb, &zx_accessops, isconsole);
  328 }
  330 int
zx_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
  332 {
  333         struct zx_softc *sc = dev;
  334         struct wsdisplay_fbinfo *wdf;
  336         /*
  337          * Note that, although the emulation (text) mode is running in
  338          * a 8-bit plane, we advertize the frame buffer as the full-blown
  339          * 32-bit beast it is.
  340          */
  341         switch (cmd) {
  342         case WSDISPLAYIO_GTYPE:
  343                 *(u_int *)data = WSDISPLAY_TYPE_SUN24;
  344                 break;
  345         case WSDISPLAYIO_GINFO:
wdf = (struct wsdisplay_fbinfo *)data;
wdf->height = sc->sc_sunfb.sf_height;
wdf->width = sc->sc_sunfb.sf_width;
wdf->depth = 32;
wdf->cmsize = 0;
  351                 break;
  352         case WSDISPLAYIO_GETSUPPORTEDDEPTH:
  353                 *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
  354                 break;
  355         case WSDISPLAYIO_LINEBYTES:
  356                 *(u_int *)data = sc->sc_sunfb.sf_linebytes;
  357                 break;
  359         case WSDISPLAYIO_GETCMAP:
  360         case WSDISPLAYIO_PUTCMAP:
  361                 break;
  363         case WSDISPLAYIO_SMODE:
zx_reset(sc, *(u_int *)data);
  365                 break;
  367         case WSDISPLAYIO_SVIDEO:
  368         case WSDISPLAYIO_GVIDEO:
  369                 break;
  371         default:
  372                 return (-1);
  373         }
  375         return (0);
  376 }
  378 int
zx_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
  380     int *curxp, int *curyp, long *attrp)
  381 {
  382         struct zx_softc *sc = v;
  384         if (sc->sc_nscreens > 0)
  385                 return (ENOMEM);
  387         *cookiep = &sc->sc_sunfb.sf_ro;
  388         *curyp = 0;
  389         *curxp = 0;
sc->sc_sunfb.sf_ro.ri_ops.alloc_attr(&sc->sc_sunfb.sf_ro,
WSCOL_BLACK, WSCOL_WHITE, WSATTR_WSCOLORS, attrp);
sc->sc_nscreens++;
  393         return (0);
  394 }
  396 void
zx_free_screen(void *v, void *cookie)
  398 {
  399         struct zx_softc *sc = v;
sc->sc_nscreens--;
  402 }
  404 int
zx_show_screen(void *v, void *cookie, int waitok, void (*cb)(void *, int, int),
  406     void *cbarg)
  407 {
  408         return (0);
  409 }
  411 /*
  412  * Return the address that would map the given device at the given
  413  * offset, allowing for the given protection, or return -1 for error.
  414  */
paddr_t
zx_mmap(void *v, off_t offset, int prot)
  417 {
  418         struct zx_softc *sc = v;
  420         if (offset & PGOFSET)
  421                 return (-1);
  423         /* Allow mapping as a dumb framebuffer from offset 0 */
  424         if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
  425                 return (bus_space_mmap(sc->sc_bustag, sc->sc_paddr,
ZX_OFF_SS0 + offset, prot, BUS_SPACE_MAP_LINEAR));
  427         }
  429         return (-1);
  430 }
  432 void
zx_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
  434 {
  435         struct zx_softc *sc = v;
sc->sc_cmap.cm_red[index] = r;
sc->sc_cmap.cm_green[index] = g;
sc->sc_cmap.cm_blue[index] = b;
  440 }
  442 void
zx_reset(struct zx_softc *sc, u_int mode)
  444 {
  445         volatile struct zx_draw *zd;
  446         volatile struct zx_command *zc;
u_int32_t i;
  448         const u_char *color;
u_int8_t *r, *g, *b;
zd = sc->sc_zd_ss0;
zc = sc->sc_zc;
  454         if (mode == WSDISPLAYIO_MODE_EMUL) {
  455                 /* Back from X11 to emulation mode, or first reset */
zx_cross_loadwid(sc, ZX_WID_DBL_8, 0, 0x2c0);
zx_cross_loadwid(sc, ZX_WID_DBL_8, 1, 0x30);
zx_cross_loadwid(sc, ZX_WID_DBL_8, 2, 0x20);
zx_cross_loadwid(sc, ZX_WID_DBL_24, 1, 0x30);
i = sc->sc_zd_ss1->zd_misc;
i |= ZX_SS1_MISC_ENABLE;
SETREG(sc->sc_zd_ss1->zd_misc, i);
  465                 /*
  466                  * XXX
  467                  * If zc_fill is not set to that value, there will be black
  468                  * bars left in the margins. But then with this value, the
  469                  * screen gets cleared. Go figure.
  470                  */
SETREG(zd->zd_wid, 0xffffffff);
SETREG(zd->zd_wmask, 0xffff);
SETREG(zd->zd_vclipmin, 0);
SETREG(zd->zd_vclipmax, (sc->sc_sunfb.sf_width - 1) |
  475                     ((sc->sc_sunfb.sf_height - 1) << 16));
SETREG(zd->zd_fg, 0);
SETREG(zd->zd_planemask, 0xff000000);
SETREG(zd->zd_rop, ZX_STD_ROP);
SETREG(zd->zd_widclip, 0);
SETREG(zc->zc_extent, ZX_COORDS(sc->sc_sunfb.sf_width - 1,
sc->sc_sunfb.sf_height - 1));
SETREG(zc->zc_addrspace, ZX_ADDRSPC_FONT_OBGR);
SETREG(zc->zc_fill, ZX_COORDS(0, 0) | ZX_EXTENT_DIR_BACKWARDS);
SETREG(zc->zc_fontt, 0);
  487                 while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
  488                         ;
  490                 /*
  491                  * Initialize the 8-bit colormap
  492                  */
r = sc->sc_cmap.cm_red;
g = sc->sc_cmap.cm_green;
b = sc->sc_cmap.cm_blue;
color = rasops_cmap;
  497                 for (i = 0; i < 256; i++) {
  498                         *r++ = *color++;
  499                         *g++ = *color++;
  500                         *b++ = *color++;
  501                 }
fbwscons_setcolormap(&sc->sc_sunfb, zx_setcolor);
zx_putcmap(sc);
  504         } else {
  505                 /* Starting X11 - switch to 24bit WID */
SETREG(zd->zd_wid, 1);
SETREG(zd->zd_widclip, 0);
SETREG(zd->zd_wmask, 0xffff);
SETREG(zd->zd_planemask, 0x00ffffff);
SETREG(zc->zc_extent, ZX_COORDS(sc->sc_sunfb.sf_width - 1,
sc->sc_sunfb.sf_height - 1));
SETREG(zc->zc_fill, 0);
  513                 while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
  514                         ;
SETREG(zc->zc_addrspace, ZX_ADDRSPC_OBGR);
SETREG(zd->zd_rop, ZX_ATTR_RGBE_ENABLE |
ZX_ROP_NEW /* | ZX_ATTR_FORCE_WID */);
  519         }
  520 }
  522 int
zx_cross_wait(struct zx_softc *sc)
  524 {
  525         volatile struct zx_cross *zx;
  526         int i;
zx = sc->sc_zx;
  530         for (i = 300000; i != 0; i--) {
  531                 if ((zx->zx_csr & ZX_CROSS_CSR_PROGRESS) == 0)
  532                         break;
DELAY(1);
  534         }
  536         if (i == 0)
printf("%s: zx_cross_wait: timed out\n",
sc->sc_sunfb.sf_dev.dv_xname);
  540         return (i);
  541 }
  543 int
zx_cross_loadwid(struct zx_softc *sc, u_int type, u_int index, u_int value)
  545 {
  546         volatile struct zx_cross *zx;
u_int tmp;
zx = sc->sc_zx;
SETREG(zx->zx_type, ZX_CROSS_TYPE_WID);
  552         if (!zx_cross_wait(sc))
  553                 return (1);
  555         if (type == ZX_WID_DBL_8)
tmp = (index & 0x0f) + 0x40;
  557         else if (type == ZX_WID_DBL_24)
tmp = index & 0x3f;
SETREG(zx->zx_type, 0x5800 + tmp);
SETREG(zx->zx_value, value);
SETREG(zx->zx_type, ZX_CROSS_TYPE_WID);
SETREG(zx->zx_csr, ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2);
  565         return (0);
  566 }
  568 int
zx_putcmap(struct zx_softc *sc)
  570 {
  571         volatile struct zx_cross *zx;
u_int32_t i;
u_int8_t *r, *g, *b;
zx = sc->sc_zx;
SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUT0);
  578         if (!zx_cross_wait(sc))
  579                 return (1);
SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUTDATA);
r = sc->sc_cmap.cm_red;
g = sc->sc_cmap.cm_green;
b = sc->sc_cmap.cm_blue;
  586         for (i = 0; i < 256; i++) {
SETREG(zx->zx_value, *r++ | (*g++ << 8) | (*b++ << 16));
  588         }
SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUT0);
i = zx->zx_csr;
i = i | ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2;
SETREG(zx->zx_csr, i);
  594         return (0);
  595 }
  597 void
zx_burner(void *v, u_int on, u_int flags)
  599 {
  600         struct zx_softc *sc = v;
  601         volatile struct zx_cross *zx;
u_int32_t i;
zx = sc->sc_zx;
SETREG(zx->zx_type, ZX_CROSS_TYPE_VIDEO);
i = zx->zx_csr;
  608         if (on) {
i |= ZX_CROSS_CSR_ENABLE;
  610         } else {
i &= ~ZX_CROSS_CSR_ENABLE;
  612         }
SETREG(zx->zx_csr, i);
  614 }
  616 void
zx_fillrect(struct rasops_info *ri, int x, int y, int w, int h, long attr,
  618             int rop)
  619 {
  620         struct zx_softc *sc;
  621         volatile struct zx_command *zc;
  622         volatile struct zx_draw *zd;
  623         int fg, bg;
sc = ri->ri_hw;
zc = sc->sc_zc;
zd = sc->sc_zd_ss0;
ri->ri_ops.unpack_attr(ri, attr, &fg, &bg, NULL);
x = x * ri->ri_font->fontwidth + ri->ri_xorigin;
y = y * ri->ri_font->fontheight + ri->ri_yorigin;
w = ri->ri_font->fontwidth * w - 1;
h = ri->ri_font->fontheight * h - 1;
  635         while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
  636                 ;
SETREG(zd->zd_rop, rop);
SETREG(zd->zd_fg, ri->ri_devcmap[bg] << 24);
SETREG(zc->zc_extent, ZX_COORDS(w, h));
SETREG(zc->zc_fill, ZX_COORDS(x, y) | ZX_EXTENT_DIR_BACKWARDS);
  642 }
  644 void
zx_copyrect(struct rasops_info *ri, int sx, int sy, int dx, int dy, int w,
  646             int h)
  647 {
  648         struct zx_softc *sc;
  649         volatile struct zx_command *zc;
  650         volatile struct zx_draw *zd;
  651         int dir;
sc = ri->ri_hw;
zc = sc->sc_zc;
zd = sc->sc_zd_ss0;
sx = sx * ri->ri_font->fontwidth + ri->ri_xorigin;
sy = sy * ri->ri_font->fontheight + ri->ri_yorigin;
dx = dx * ri->ri_font->fontwidth + ri->ri_xorigin;
dy = dy * ri->ri_font->fontheight + ri->ri_yorigin;
w = w * ri->ri_font->fontwidth - 1;
h = h * ri->ri_font->fontheight - 1;
  664         if (sy < dy || sx < dx) {
dir = ZX_EXTENT_DIR_BACKWARDS;
sx += w;
sy += h;
dx += w;
dy += h;
  670         } else
dir = ZX_EXTENT_DIR_FORWARDS;
  673         while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
  674                 ;
SETREG(zd->zd_rop, ZX_STD_ROP);
SETREG(zc->zc_extent, ZX_COORDS(w, h) | dir);
SETREG(zc->zc_src, ZX_COORDS(sx, sy));
SETREG(zc->zc_copy, ZX_COORDS(dx, dy));
  680 }
  682 void
zx_do_cursor(struct rasops_info *ri)
  684 {
zx_fillrect(ri, ri->ri_ccol, ri->ri_crow, 1, 1, WSCOL_BLACK << 16,
ZX_ROP_NEW_XOR_OLD | ZX_ATTR_WE_ENABLE | ZX_ATTR_OE_ENABLE |
ZX_ATTR_FORCE_WID);
  689 }
  691 void
zx_erasecols(void *cookie, int row, int col, int num, long attr)
  693 {
  694         struct rasops_info *ri;
ri = (struct rasops_info *)cookie;
zx_fillrect(ri, col, row, num, 1, attr, ZX_STD_ROP);
  699 }
  701 void
zx_eraserows(void *cookie, int row, int num, long attr)
  703 {
  704         struct rasops_info *ri;
  705         struct zx_softc *sc;
  706         volatile struct zx_command *zc;
  707         volatile struct zx_draw *zd;
  708         int fg, bg;
ri = (struct rasops_info *)cookie;
  712         if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR)) {
sc = ri->ri_hw;
zc = sc->sc_zc;
zd = sc->sc_zd_ss0;
ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, NULL);
  719                 while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
  720                         ;
SETREG(zd->zd_rop, ZX_STD_ROP);
SETREG(zd->zd_fg, ri->ri_devcmap[bg] << 24);
SETREG(zc->zc_extent,
ZX_COORDS(ri->ri_width - 1, ri->ri_height - 1));
SETREG(zc->zc_fill, ZX_COORDS(0, 0) | ZX_EXTENT_DIR_BACKWARDS);
  727         } else
zx_fillrect(ri, 0, row, ri->ri_cols, num, attr, ZX_STD_ROP);
  729 }
  731 void
zx_copyrows(void *cookie, int src, int dst, int num)
  733 {
  734         struct rasops_info *ri;
ri = (struct rasops_info *)cookie;
zx_copyrect(ri, 0, src, 0, dst, ri->ri_cols, num);
  739 }
  741 void
zx_copycols(void *cookie, int row, int src, int dst, int num)
  743 {
  744         struct rasops_info *ri;
ri = (struct rasops_info *)cookie;
zx_copyrect(ri, src, row, dst, row, num, 1);
  749 }
  751 void
zx_putchar(void *cookie, int row, int col, u_int uc, long attr)
  753 {
  754         struct rasops_info *ri;
  755         struct zx_softc *sc;
  756         struct wsdisplay_font *font;
  757         volatile struct zx_command *zc;
  758         volatile struct zx_draw *zd;
  759         volatile u_int32_t *dp;
u_int8_t *fb;
  761         int fs, i, fg, bg, ul;
ri = (struct rasops_info *)cookie;
font = ri->ri_font;
ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, &ul);
fg = ri->ri_devcmap[fg];
bg = ri->ri_devcmap[bg];
dp = (volatile u_int32_t *)ri->ri_bits +
ZX_COORDS(col * font->fontwidth, row * font->fontheight);
  772         if (uc == ' ') {
zx_fillrect(ri, col, row, 1, 1, attr, ZX_STD_ROP);
  774                 if (ul == 0)
  775                         return;
dp += font->fontheight << ZX_WWIDTH;
  779                 while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
  780                         ;
SETREG(zd->zd_rop, ZX_STD_ROP);
SETREG(zd->zd_fg, fg << 24);
SETREG(zd->zd_bg, bg << 24);
SETREG(zc->zc_fontmsk, 0xffffffff << (32 - font->fontwidth));
  786         } else {
sc = ri->ri_hw;
zc = sc->sc_zc;
zd = sc->sc_zd_ss0;
fb = (u_int8_t *)font->data + (uc - font->firstchar) *
ri->ri_fontscale;
fs = font->stride;
  795                 while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
  796                         ;
SETREG(zd->zd_rop, ZX_STD_ROP);
SETREG(zd->zd_fg, fg << 24);
SETREG(zd->zd_bg, bg << 24);
SETREG(zc->zc_fontmsk, 0xffffffff << (32 - font->fontwidth));
  803                 if (font->fontwidth <= 8) {
  804                         for (i = font->fontheight; i != 0;
i--, dp += 1 << ZX_WWIDTH) {
  806                                 *dp = *fb << 24;
fb += fs;
  808                         }
  809                 } else {
  810                         for (i = font->fontheight; i != 0;
i--, dp += 1 << ZX_WWIDTH) {
  812                                 *dp = *((u_int16_t *)fb) << 16;
fb += fs;
  814                         }
  815                 }
  816         }
  818         /* underline */
  819         if (ul) {
dp -= 2 << ZX_WWIDTH;
  821                 *dp = 0xffffffff;
  822         }
  823 }