/*      $NetBSD: tcx.c,v 1.69 2026/07/07 09:11:31 macallan Exp $ */

/*
 *  Copyright (c) 1996, 1998, 2009 The NetBSD Foundation, Inc.
 *  All rights reserved.
 *
 *  This code is derived from software contributed to The NetBSD Foundation
 *  by Paul Kranenburg and Michael Lorenz.
 *
 *  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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 *  ``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 FOUNDATION OR CONTRIBUTORS
 *  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.
 */

/*
 * color display (TCX) driver.
 *
 * Does not handle interrupts, even though they can occur.
 *
 * XXX should defer colormap updates to vertical retrace interrupts
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: tcx.c,v 1.69 2026/07/07 09:11:31 macallan Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/tty.h>
#include <sys/conf.h>

#ifdef DEBUG
#include <sys/proc.h>
#include <sys/syslog.h>
#endif

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

#include <dev/sun/fbio.h>
#include <dev/sun/fbvar.h>
#include <dev/sun/btreg.h>
#include <dev/sun/btvar.h>

#include <dev/sbus/sbusvar.h>
#include <dev/sbus/tcxreg.h>

#include <dev/wscons/wsdisplayvar.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wsfont/wsfont.h>
#include <dev/rasops/rasops.h>

#include <dev/wscons/wsdisplay_vconsvar.h>

#include "opt_wsemul.h"

#include "ioconf.h"

/* per-display variables */
struct tcx_softc {
        device_t        sc_dev;         /* base device */
        struct fbdevice sc_fb;          /* frame buffer device */
        bus_space_tag_t sc_bustag;
        struct openprom_addr sc_physaddr[TCX_NREG];/* phys addr of h/w */

        bus_space_handle_t sc_bt;       /* Brooktree registers */
        bus_space_handle_t sc_thc;      /* THC registers */
        uint8_t         *sc_fbaddr;     /* framebuffer */
        volatile uint64_t       *sc_rblit;      /* blitspace */
        volatile uint64_t       *sc_rstip;      /* stipple space */

        short           sc_8bit;        /* true if 8-bit hardware */
        short           sc_blanked;     /* true if blanked */
        uint32_t        sc_fbsize;      /* size of the 8bit fb */
        int             sc_depth;       /* depth of the fb we mmap() */
        u_char          sc_cmap_red[256];
        u_char          sc_cmap_green[256];
        u_char          sc_cmap_blue[256];
        int             sc_mode, sc_bg;
        int             sc_cursor_x, sc_cursor_y;
        int             sc_hotspot_x, sc_hotspot_y;
        struct vcons_data vd;
};

static struct vcons_screen tcx_console_screen;

extern const u_char rasops_cmap[768];

struct wsscreen_descr tcx_defscreendesc = {
        "default",
        0, 0,
        NULL,
        8, 16,
        WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_UNDERLINE |
        WSSCREEN_REVERSE | WSSCREEN_RESIZE,
};

const struct wsscreen_descr *_tcx_scrlist[] = {
        &tcx_defscreendesc,
        /* XXX other formats, graphics screen? */
};

struct wsscreen_list tcx_screenlist = {
        sizeof(_tcx_scrlist) / sizeof(struct wsscreen_descr *),
        _tcx_scrlist
};

/* autoconfiguration driver */
static void     tcxattach(device_t, device_t, void *);
static int      tcxmatch(device_t, cfdata_t, void *);
static void     tcx_unblank(device_t);

CFATTACH_DECL_NEW(tcx, sizeof(struct tcx_softc),
    tcxmatch, tcxattach, NULL, NULL);

dev_type_open(tcxopen);
dev_type_close(tcxclose);
dev_type_ioctl(tcxioctl);
dev_type_mmap(tcxmmap);

const struct cdevsw tcx_cdevsw = {
        .d_open = tcxopen,
        .d_close = tcxclose,
        .d_read = noread,
        .d_write = nowrite,
        .d_ioctl = tcxioctl,
        .d_stop = nostop,
        .d_tty = notty,
        .d_poll = nopoll,
        .d_mmap = tcxmmap,
        .d_kqfilter = nokqfilter,
        .d_discard = nodiscard,
        .d_flag = 0
};

/* frame buffer generic driver */
static struct fbdriver tcx_fbdriver = {
        tcx_unblank, tcxopen, tcxclose, tcxioctl, nopoll, tcxmmap,
        nokqfilter
};

static void tcx_reset(struct tcx_softc *);
static void tcx_loadcmap(struct tcx_softc *, int, int);

static int      tcx_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t  tcx_mmap(void *, void *, off_t, int);

static void     tcx_init_cmap(struct tcx_softc *);
static void     tcx_init_screen(void *, struct vcons_screen *, int, long *);
static void     tcx_clearscreen(struct tcx_softc *, int);
static void     tcx_copyrows(void *, int, int, int);
static void     tcx_eraserows(void *, int, int, long);
static void     tcx_erasecols(void *, int, int, int, long);
static void     tcx_putchar(void *, int, int, u_int, long);
static int      tcx_allocattr(void *, int, int, int, long *);

static void     tcx_set_video(struct tcx_softc *, int);
static int      tcx_do_cursor(struct tcx_softc *, struct wsdisplay_cursor *);
static void     tcx_set_cursor(struct tcx_softc *);

struct wsdisplay_accessops tcx_accessops = {
        tcx_ioctl,
        tcx_mmap,
        NULL,   /* vcons_alloc_screen */
        NULL,   /* vcons_free_screen */
        NULL,   /* vcons_show_screen */
        NULL,   /* load_font */
        NULL,   /* polls */
        NULL,   /* scroll */
};

#define OBPNAME "SUNW,tcx"

/*
 * Match a tcx.
 */
int
tcxmatch(device_t parent, cfdata_t cf, void *aux)
{
        struct sbus_attach_args *sa = aux;

        if (strcmp(sa->sa_name, OBPNAME) == 0)
                return 100;     /* beat genfb */
        return 0;
}

/*
 * Attach a display.
 */
void
tcxattach(device_t parent, device_t self, void *args)
{
        struct tcx_softc *sc = device_private(self);
        struct sbus_attach_args *sa = args;
        struct wsemuldisplaydev_attach_args aa;
        struct rasops_info *ri;
        unsigned long defattr;
        int node;
        struct fbdevice *fb = &sc->sc_fb;
        bus_space_handle_t bh;
        int isconsole;
        uint32_t confreg;

        sc->sc_dev = self;
        sc->sc_bustag = sa->sa_bustag;
        node = sa->sa_node;

        sc->sc_cursor_x = 0x7fff;
        sc->sc_cursor_y = 0x7fff;
        sc->sc_hotspot_x = 0;
        sc->sc_hotspot_y = 0;

        fb->fb_driver = &tcx_fbdriver;
        fb->fb_device = sc->sc_dev;
        /* Mask out invalid flags from the user. */
        fb->fb_flags = device_cfdata(sc->sc_dev)->cf_flags & FB_USERMASK;
        /*
         * The onboard framebuffer on the SS4 supports only 8-bit mode;
         * it can be distinguished from the S24 card for the SS5 by the
         * presence of the "tcx-8-bit" attribute on the SS4 version.
         */
        sc->sc_8bit = node_has_property(node, "tcx-8-bit");
        fb->fb_type.fb_depth = 8;
        fb_setsize_obp(fb, fb->fb_type.fb_depth, 1152, 900, node);

        /*
         * actual FB size ( of the 8bit region )
         * no reason to restrict userland mappings to the visible VRAM
         */
        if (sc->sc_8bit) {
                aprint_normal(" (8-bit only TCX)\n");
                /* at least the SS4 can have 2MB with a VSIMM */
                sc->sc_fbsize = 0x100000 * prom_getpropint(node, "vram", 1);
                sc->sc_depth = 8;
        } else {
                aprint_normal(" (S24)\n");
                /* all S24 I know of have 4MB, non-expandable */
                sc->sc_fbsize = 0x100000;
                sc->sc_depth = 32;
        }

        fb->fb_type.fb_cmsize = 256;
        fb->fb_type.fb_size = sc->sc_fbsize;    /* later code assumes 8bit */
        aprint_normal_dev(self, "%s, %d x %d\n", OBPNAME,
                fb->fb_type.fb_width,
                fb->fb_type.fb_height);

        fb->fb_type.fb_type = FBTYPE_TCXCOLOR;

        if (sa->sa_nreg != TCX_NREG) {
                aprint_error("\n");
                aprint_error_dev(self, "only %d register sets\n",
                        sa->sa_nreg);
                return;
        }
        if (sa->sa_reg[TCX_REG_STIP].oa_size < 0x1000) {
                aprint_error("\n");
                aprint_error_dev(self, "STIP register too small (0x%x)\n",
                    sa->sa_reg[TCX_REG_STIP].oa_size);
                return;
        }

        memcpy(sc->sc_physaddr, sa->sa_reg,
              sa->sa_nreg * sizeof(struct openprom_addr));

        /* Map the register banks we care about */
        if (sbus_bus_map(sa->sa_bustag,
                         sc->sc_physaddr[TCX_REG_THC].oa_space,
                         sc->sc_physaddr[TCX_REG_THC].oa_base,
                         0x1000,
                         BUS_SPACE_MAP_LINEAR, &sc->sc_thc) != 0) {
                aprint_error_dev(self,
                    "tcxattach: cannot map thc registers\n");
                return;
        }

        if (sbus_bus_map(sa->sa_bustag,
                         sc->sc_physaddr[TCX_REG_CMAP].oa_space,
                         sc->sc_physaddr[TCX_REG_CMAP].oa_base,
                         0x1000,
                         BUS_SPACE_MAP_LINEAR, &sc->sc_bt) != 0) {
                aprint_error_dev(self, "tcxattach: cannot map DAC registers\n");
                return;
        }

        /* map the 8bit dumb FB for the console */
        if (sbus_bus_map(sa->sa_bustag,
                 sc->sc_physaddr[TCX_REG_DFB8].oa_space,
                 sc->sc_physaddr[TCX_REG_DFB8].oa_base,
                         sc->sc_fbsize,
                         BUS_SPACE_MAP_LINEAR,
                         &bh) != 0) {
                aprint_error_dev(self, "tcxattach: cannot map framebuffer\n");
                return;
        }
        sc->sc_fbaddr = bus_space_vaddr(sa->sa_bustag, bh);

        /*
         * 8bit tcx has the RSTIP and RBLIT ranges set to size 0.
         * On Real Hardware they work anyway ( on my SS4 at least ) but
         * emulators may not be so forgiving.
         */
        if (sc->sc_8bit) {
                /* BLIT space */
                if (sbus_bus_map(sa->sa_bustag,
                         sc->sc_physaddr[TCX_REG_BLIT].oa_space,
                         sc->sc_physaddr[TCX_REG_BLIT].oa_base,
                                 sc->sc_fbsize << 3,
                                 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE,
                                 &bh) != 0) {
                        aprint_error_dev(self,
                            "tcxattach: cannot map BLIT space\n");
                        return;
                }
                sc->sc_rblit = bus_space_vaddr(sa->sa_bustag, bh);

                /* STIP space */
                if (sbus_bus_map(sa->sa_bustag,
                         sc->sc_physaddr[TCX_REG_STIP].oa_space,
                         sc->sc_physaddr[TCX_REG_STIP].oa_base,
                                 sc->sc_fbsize << 3,
                                 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE,
                                 &bh) != 0) {
                        aprint_error_dev(self,
                            "tcxattach: cannot map STIP space\n");
                        return;
                }
                sc->sc_rstip = bus_space_vaddr(sa->sa_bustag, bh);
        } else {
                /* RBLIT space */
                if (sbus_bus_map(sa->sa_bustag,
                         sc->sc_physaddr[TCX_REG_RBLIT].oa_space,
                         sc->sc_physaddr[TCX_REG_RBLIT].oa_base,
                                 sc->sc_fbsize << 3,
                                 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE,
                                 &bh) != 0) {
                        aprint_error_dev(self,
                            "tcxattach: cannot map RBLIT space\n");
                        return;
                }
                sc->sc_rblit = bus_space_vaddr(sa->sa_bustag, bh);

                /* RSTIP space */
                if (sbus_bus_map(sa->sa_bustag,
                         sc->sc_physaddr[TCX_REG_RSTIP].oa_space,
                         sc->sc_physaddr[TCX_REG_RSTIP].oa_base,
                                 sc->sc_fbsize << 3,
                                 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE,
                                 &bh) != 0) {
                        aprint_error_dev(self,
                            "tcxattach: cannot map RSTIP space\n");
                        return;
                }
                sc->sc_rstip = bus_space_vaddr(sa->sa_bustag, bh);
        }
        isconsole = fb_is_console(node);

        confreg = bus_space_read_4(sa->sa_bustag, sc->sc_thc, THC_CONFIG);
        aprint_normal_dev(self, "id %d, rev %d, sense %d\n",
                (confreg & THC_CFG_FBID) >> THC_CFG_FBID_SHIFT,
                (confreg & THC_CFG_REV) >> THC_CFG_REV_SHIFT,
                (confreg & THC_CFG_SENSE) >> THC_CFG_SENSE_SHIFT
        );

        /* reset cursor & frame buffer controls */
        tcx_reset(sc);

        if (!sc->sc_8bit)
            tcx_set_cursor(sc);

        /* enable video */
        confreg = bus_space_read_4(sa->sa_bustag, sc->sc_thc, THC_MISC);
        confreg |= THC_MISC_VIDEN;
        bus_space_write_4(sa->sa_bustag, sc->sc_thc, THC_MISC, confreg);

        if (isconsole) {
                aprint_normal_dev(self, "(console)\n");
        }

        fb_attach(&sc->sc_fb, isconsole);

        sc->sc_mode = WSDISPLAYIO_MODE_EMUL;
        wsfont_init();

        vcons_init(&sc->vd, sc, &tcx_defscreendesc, &tcx_accessops);
        sc->vd.init_screen = tcx_init_screen;

        vcons_init_screen(&sc->vd, &tcx_console_screen, 1, &defattr);
        tcx_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;

        ri = &tcx_console_screen.scr_ri;

        sc->sc_bg = ri->ri_devcmap[(defattr >> 16) & 0xff];
        tcx_clearscreen(sc, 0);
        tcx_init_cmap(sc);

        tcx_defscreendesc.nrows = ri->ri_rows;
        tcx_defscreendesc.ncols = ri->ri_cols;
        tcx_defscreendesc.textops = &ri->ri_ops;
        tcx_defscreendesc.capabilities = ri->ri_caps;

        if(isconsole) {
                wsdisplay_cnattach(&tcx_defscreendesc, ri, 0, 0, defattr);
                vcons_replay_msgbuf(&tcx_console_screen);
        }

        aa.console = isconsole;
        aa.scrdata = &tcx_screenlist;
        aa.accessops = &tcx_accessops;
        aa.accesscookie = &sc->vd;

        config_found(self, &aa, wsemuldisplaydevprint, CFARGS_NONE);
        /*
         * we need to do this again - something overwrites a handful
         * palette registers and we end up with white in reg. 0
         */
        tcx_loadcmap(sc, 0, 256);
}

int
tcxopen(dev_t dev, int flags, int mode, struct lwp *l)
{
        return (0);
}

int
tcxclose(dev_t dev, int flags, int mode, struct lwp *l)
{
        struct tcx_softc *sc = device_lookup_private(&tcx_cd, minor(dev));

        tcx_reset(sc);
        /* we may want to clear and redraw the console here */
        return (0);
}

int
tcxioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
{
        struct tcx_softc *sc = device_lookup_private(&tcx_cd, minor(dev));

        switch (cmd) {

        case FBIOGTYPE:
                *(struct fbtype *)data = sc->sc_fb.fb_type;
                break;

        case FBIOGATTR:
#define fba ((struct fbgattr *)data)
                fba->real_type = sc->sc_fb.fb_type.fb_type;
                fba->owner = 0;         /* XXX ??? */
                fba->fbtype = sc->sc_fb.fb_type;
                fba->sattr.flags = 0;
                fba->sattr.emu_type = sc->sc_fb.fb_type.fb_type;
                fba->sattr.dev_specific[0] = -1;
                fba->emu_types[0] = sc->sc_fb.fb_type.fb_type;
                fba->emu_types[1] = FBTYPE_SUN3COLOR;
                fba->emu_types[2] = -1;
#undef fba
                break;

        case FBIOGETCMAP:
#define p ((struct fbcmap *)data)
                if (p->index > 256 || p->count > 256 - p->index)
                        return EINVAL;
                if (copyout(&sc->sc_cmap_red[p->index], p->red, p->count) != 0)
                        return EINVAL;
                if (copyout(&sc->sc_cmap_green[p->index], p->green, p->count)
                    != 0)
                        return EINVAL;
                if (copyout(&sc->sc_cmap_blue[p->index], p->blue, p->count)
                    != 0)
                        return EINVAL;
                return 0;

        case FBIOPUTCMAP:
                /* copy to software map */
                if (p->index > 256 || p->count > 256 - p->index)
                        return EINVAL;
                if (copyin(p->red, &sc->sc_cmap_red[p->index], p->count) != 0)
                        return EINVAL;
                if (copyin(p->green, &sc->sc_cmap_green[p->index], p->count)
                    != 0)
                        return EINVAL;
                if (copyin(p->blue, &sc->sc_cmap_blue[p->index], p->count) != 0)
                        return EINVAL;
                tcx_loadcmap(sc, p->index, p->count);
#undef p
                break;
        case FBIOGVIDEO:
                *(int *)data = sc->sc_blanked;
                break;

        case FBIOSVIDEO:
                tcx_set_video(sc, *(int *)data);
                break;

        default:
#ifdef DEBUG
                log(LOG_NOTICE, "tcxioctl(0x%lx) (%s[%d])\n", cmd,
                    l->l_proc->p_comm, l->l_proc->p_pid);
#endif
                return (ENOTTY);
        }
        return (0);
}

/*
 * Clean up hardware state (e.g., after bootup or after X crashes).
 */
static void
tcx_reset(struct tcx_softc *sc)
{
        uint32_t reg;

        reg = bus_space_read_4(sc->sc_bustag, sc->sc_thc, THC_MISC);
        reg |= THC_MISC_CURSRES;
        bus_space_write_4(sc->sc_bustag, sc->sc_thc, THC_MISC, reg);
}

static void
tcx_init_cmap(struct tcx_softc *sc)
{
        int i, j;

        /* Initialize the default color map. */
        j = 0;
        for (i = 0; i < 256; i++) {

                sc->sc_cmap_red[i] = rasops_cmap[j];
                sc->sc_cmap_green[i] = rasops_cmap[j + 1];
                sc->sc_cmap_blue[i] = rasops_cmap[j + 2];
                j += 3;
        }
        tcx_loadcmap(sc, 0, 256);
}

static void
tcx_loadcmap(struct tcx_softc *sc, int start, int ncolors)
{
        int i;

        for (i = 0; i < ncolors; i++) {
                bus_space_write_4(sc->sc_bustag, sc->sc_bt, DAC_ADDRESS,
                    (start + i) << 24);
                bus_space_write_4(sc->sc_bustag, sc->sc_bt, DAC_FB_LUT,
                    sc->sc_cmap_red[i + start] << 24);
                bus_space_write_4(sc->sc_bustag, sc->sc_bt, DAC_FB_LUT,
                    sc->sc_cmap_green[i + start] << 24);
                bus_space_write_4(sc->sc_bustag, sc->sc_bt, DAC_FB_LUT,
                    sc->sc_cmap_blue[i + start] << 24);
        }
        bus_space_write_4(sc->sc_bustag, sc->sc_bt, DAC_ADDRESS, 0);
}

static void
tcx_unblank(device_t dev)
{
        struct tcx_softc *sc = device_private(dev);

        if (sc->sc_blanked) {
                uint32_t reg;
                sc->sc_blanked = 0;
                reg = bus_space_read_4(sc->sc_bustag, sc->sc_thc, THC_MISC);
                reg &= ~THC_MISC_VSYNC_DISABLE;
                reg &= ~THC_MISC_HSYNC_DISABLE;
                reg |= THC_MISC_VIDEN;
                bus_space_write_4(sc->sc_bustag, sc->sc_thc, THC_MISC, reg);
        }
}

static void
tcx_set_video(struct tcx_softc *sc, int unblank)
{
        uint32_t reg;
        if (unblank) {
                sc->sc_blanked = 0;
                reg = bus_space_read_4(sc->sc_bustag, sc->sc_thc, THC_MISC);
                reg &= ~THC_MISC_VSYNC_DISABLE;
                reg &= ~THC_MISC_HSYNC_DISABLE;
                reg |= THC_MISC_VIDEN;
                bus_space_write_4(sc->sc_bustag, sc->sc_thc, THC_MISC, reg);
        } else {
                sc->sc_blanked = 1;
                reg = bus_space_read_4(sc->sc_bustag, sc->sc_thc, THC_MISC);
                reg |= THC_MISC_VSYNC_DISABLE;
                reg |= THC_MISC_HSYNC_DISABLE;
                reg &= ~THC_MISC_VIDEN;
                bus_space_write_4(sc->sc_bustag, sc->sc_thc, THC_MISC, reg);
        }
}

/*
 * Base addresses at which users can mmap() the various pieces of a tcx.
 */
#define TCX_USER_RAM    0x00000000
#define TCX_USER_RAM24  0x01000000
#define TCX_USER_RAM_COMPAT     0x04000000      /* cg3 emulation */
#define TCX_USER_STIP   0x10000000
#define TCX_USER_BLIT   0x20000000
#define TCX_USER_RDFB32 0x28000000
#define TCX_USER_RSTIP  0x30000000
#define TCX_USER_RBLIT  0x38000000
#define TCX_USER_TEC    0x70001000
#define TCX_USER_BTREGS 0x70002000
#define TCX_USER_THC    0x70004000
#define TCX_USER_DHC    0x70008000
#define TCX_USER_ALT    0x7000a000
#define TCX_USER_UART   0x7000c000
#define TCX_USER_VRT    0x7000e000
#define TCX_USER_ROM    0x70010000

struct mmo {
        u_int   mo_uaddr;       /* user (virtual) address */
        u_int   mo_size;        /* size, or 0 for video ram size */
        u_int   mo_bank;        /* register bank number */
};

/*
 * Return the address that would map the given device at the given
 * offset, allowing for the given protection, or return -1 for error.
 *
 * XXX  needs testing against `demanding' applications (e.g., aviator)
 */
paddr_t
tcxmmap(dev_t dev, off_t off, int prot)
{
        struct tcx_softc *sc = device_lookup_private(&tcx_cd, minor(dev));
        struct openprom_addr *rr = sc->sc_physaddr;
        struct mmo *mo, *mo_end;
        u_int u, sz;
        static struct mmo mmo[] = {
                { TCX_USER_RAM, 0, TCX_REG_DFB8 },
                { TCX_USER_RAM24, 0, TCX_REG_DFB24 },
                { TCX_USER_RAM_COMPAT, 0, TCX_REG_DFB8 },

                { TCX_USER_STIP, 1, TCX_REG_STIP },
                { TCX_USER_BLIT, 1, TCX_REG_BLIT },
                { TCX_USER_RDFB32, 0, TCX_REG_RDFB32 },
                { TCX_USER_RSTIP, 1, TCX_REG_RSTIP },
                { TCX_USER_RBLIT, 1, TCX_REG_RBLIT },
                { TCX_USER_TEC, 1, TCX_REG_TEC },
                { TCX_USER_BTREGS, 8192 /* XXX */, TCX_REG_CMAP },
                { TCX_USER_THC, 0x2000, TCX_REG_THC },
                { TCX_USER_DHC, 1, TCX_REG_DHC },
                { TCX_USER_ALT, 1, TCX_REG_ALT },
                { TCX_USER_ROM, 65536, TCX_REG_ROM },
        };
#define NMMO (sizeof mmo / sizeof *mmo)

        if (off & PGOFSET)
                panic("tcxmmap");

        /*
         * Entries with size 0 map video RAM (i.e., the size in fb data).
         * Entries that map 32-bit deep regions are adjusted for their
         * depth (fb_size gives the size of the 8-bit-deep region).
         *
         * Since we work in pages, the fact that the map offset table's
         * sizes are sometimes bizarre (e.g., 1) is effectively ignored:
         * one byte is as good as one page.
         */

        mo = mmo;
        mo_end = &mmo[NMMO];

        for (; mo < mo_end; mo++) {
                if ((u_int)off < mo->mo_uaddr)
                        continue;

                u = off - mo->mo_uaddr;
                sz = mo->mo_size;

                if (sz == 0) {
                        sz = sc->sc_fb.fb_type.fb_size;
                        /*
                         * check for the 32-bit-deep regions and adjust
                         * accordingly
                         */
                        if (mo->mo_uaddr == TCX_USER_RAM24 ||
                            mo->mo_uaddr == TCX_USER_RDFB32) {
                                if (sc->sc_8bit) {
                                        /*
                                         * not present on 8-bit hardware
                                         */
                                        continue;
                                }
                                sz *= 4;
                        }
                }
                if (sz == 1)
                        sz = rr[mo->mo_bank].oa_size;

                if (u < sz) {
                        return (bus_space_mmap(sc->sc_bustag,
                                BUS_ADDR(rr[mo->mo_bank].oa_space,
                                         rr[mo->mo_bank].oa_base),
                                u,
                                prot,
                                BUS_SPACE_MAP_LINEAR));
                }
        }
        return (-1);
}

int
tcx_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
        struct lwp *l)
{
        struct vcons_data *vd = v;
        struct tcx_softc *sc = vd->cookie;
        struct wsdisplay_fbinfo *wdf;
        struct vcons_screen *ms = vd->active;

        switch (cmd) {
                case WSDISPLAYIO_GTYPE:
                        *(u_int *)data = WSDISPLAY_TYPE_SUNTCX;
                        return 0;

                case FBIOGVIDEO:
                case WSDISPLAYIO_GVIDEO:
                        *(int *)data = !sc->sc_blanked;
                        return 0;

                case WSDISPLAYIO_SVIDEO:
                case FBIOSVIDEO:
                        tcx_set_video(sc, *(int *)data);
                        return 0;

                case WSDISPLAYIO_GINFO:
                        wdf = (void *)data;
                        wdf->height = ms->scr_ri.ri_height;
                        wdf->width = ms->scr_ri.ri_width;
                        if (sc->sc_8bit) {
                                wdf->depth = 8;
                        } else {
                                wdf->depth = 32;
                        }
                        wdf->cmsize = 256;
                        return 0;
                case WSDISPLAYIO_LINEBYTES:
                        {
                                int *ret = (int *)data;
                                *ret = sc->sc_8bit ? ms->scr_ri.ri_width :
                                    ms->scr_ri.ri_width << 2;
                        }
                        return 0;

                case WSDISPLAYIO_GETCMAP:
#define p ((struct wsdisplay_cmap *)data)
                if (p->index > 256 || p->count > 256 - p->index)
                        return EINVAL;
                if (copyout(&sc->sc_cmap_red[p->index], p->red, p->count) != 0)
                        return EINVAL;
                if (copyout(&sc->sc_cmap_green[p->index], p->green, p->count)
                    != 0)
                        return EINVAL;
                if (copyout(&sc->sc_cmap_blue[p->index], p->blue, p->count)
                    != 0)
                        return EINVAL;
                return 0;

                case WSDISPLAYIO_PUTCMAP:
                /* copy to software map */
                if (p->index > 256 || p->count > 256 - p->index)
                        return EINVAL;
                if (copyin(p->red, &sc->sc_cmap_red[p->index], p->count) != 0)
                        return EINVAL;
                if (copyin(p->green, &sc->sc_cmap_green[p->index], p->count)
                    != 0)
                        return EINVAL;
                if (copyin(p->blue, &sc->sc_cmap_blue[p->index], p->count) != 0)
                        return EINVAL;
                tcx_loadcmap(sc, p->index, p->count);
                return 0;
#undef p

                case WSDISPLAYIO_SMODE:
                        {
                                int new_mode = *(int*)data;
                                if (new_mode != sc->sc_mode)
                                {
                                        sc->sc_mode = new_mode;
                                        if (new_mode == WSDISPLAYIO_MODE_EMUL)
                                        {
                                                tcx_init_cmap(sc);
                                                tcx_clearscreen(sc, 0);
                                                vcons_redraw_screen(ms);
                                        } else if (sc->sc_depth == 32) {
                                                /*
                                                 * make sure we set the control
                                                 * bits correctly
                                                 */
                                                tcx_clearscreen(sc, 3);
                                        } else
                                                tcx_clearscreen(sc, 0);
                                }
                        }
                        return 0;

                case WSDISPLAYIO_GCURPOS:
                        if (sc->sc_8bit) {
                                return EOPNOTSUPP;
                        } else {
                                struct wsdisplay_curpos *cp = (void *)data;

                                cp->x = sc->sc_cursor_x;
                                cp->y = sc->sc_cursor_y;
                        }
                        return 0;

                case WSDISPLAYIO_SCURPOS:
                        if (sc->sc_8bit) {
                                return EOPNOTSUPP;
                        } else {
                                struct wsdisplay_curpos *cp = (void *)data;

                                sc->sc_cursor_x = cp->x;
                                sc->sc_cursor_y = cp->y;
                                tcx_set_cursor(sc);
                        }
                        return 0;

                case WSDISPLAYIO_GCURMAX:
                        if (sc->sc_8bit) {
                                return EOPNOTSUPP;
                        } else {
                                struct wsdisplay_curpos *cp = (void *)data;

                                cp->x = 32;
                                cp->y = 32;
                        }
                        return 0;

                case WSDISPLAYIO_SCURSOR:
                        if (sc->sc_8bit) {
                                return EOPNOTSUPP;
                        } else {
                                struct wsdisplay_cursor *cursor = (void *)data;

                                return tcx_do_cursor(sc, cursor);
                        }
                        break;  /* shouldn't ever get here */

                case WSDISPLAYIO_SET_DEPTH:
                {
                        int new_depth = *(int*)data;

                        if (sc->sc_8bit) {
                                return ( new_depth == 8) ? 0 : EINVAL;
                        } else if ((new_depth == 8) || (new_depth == 32)) {
                                sc->sc_depth = new_depth;
                                return 0;
                        }
                        return EINVAL;
                }

                case WSDISPLAYIO_GET_FBINFO:
                {
                        struct wsdisplayio_fbinfo *fbi = data;

                        if (sc->sc_depth == 8) {
                                fbi->fbi_fbsize = sc->sc_fbsize;
                                fbi->fbi_stride = sc->sc_fb.fb_type.fb_width;
                                fbi->fbi_bitsperpixel = 8;
                                fbi->fbi_pixeltype = WSFB_CI;
                        } else {
                                fbi->fbi_fbsize = sc->sc_fbsize * 4;
                                fbi->fbi_stride = sc->sc_fb.fb_type.fb_width * 4;
                                fbi->fbi_bitsperpixel = 32;
                                fbi->fbi_pixeltype = WSFB_RGB;
                        }
                        fbi->fbi_width = sc->sc_fb.fb_type.fb_width;
                        fbi->fbi_height = sc->sc_fb.fb_type.fb_height;
                        fbi->fbi_subtype.fbi_rgbmasks.red_offset = 0;
                        fbi->fbi_subtype.fbi_rgbmasks.red_size = 8;
                        fbi->fbi_subtype.fbi_rgbmasks.green_offset = 8;
                        fbi->fbi_subtype.fbi_rgbmasks.green_size = 8;
                        fbi->fbi_subtype.fbi_rgbmasks.blue_offset = 16;
                        fbi->fbi_subtype.fbi_rgbmasks.blue_size = 8;
                        fbi->fbi_subtype.fbi_rgbmasks.alpha_offset = 0;
                        fbi->fbi_subtype.fbi_rgbmasks.alpha_size = 0;
                        return 0;
                }

        }
        return EPASSTHROUGH;
}

static paddr_t
tcx_mmap(void *v, void *vs, off_t offset, int prot)
{
        struct vcons_data *vd = v;
        struct tcx_softc *sc = vd->cookie;

        /* 'regular' framebuffer mmap()ing */
        if (sc->sc_depth == 8) {
                /* on 8Bit boards hand over the 8 bit aperture */
                if (offset > sc->sc_fbsize)
                        return -1;
                return bus_space_mmap(sc->sc_bustag,
                    sc->sc_physaddr[TCX_REG_DFB8].oa_base + offset, 0, prot,
                    BUS_SPACE_MAP_LINEAR);
        } else {
                /* ... but if we have a 24bit aperture we use it */
                if (offset > sc->sc_fbsize * 4)
                        return -1;
                return bus_space_mmap(sc->sc_bustag,
                    sc->sc_physaddr[TCX_REG_DFB24].oa_base + offset, 0, prot,
                    BUS_SPACE_MAP_LINEAR);
        }
        return -1;
}

static void
tcx_init_screen(void *cookie, struct vcons_screen *scr,
    int existing, long *defattr)
{
        struct tcx_softc *sc = cookie;
        struct rasops_info *ri = &scr->scr_ri;

        ri->ri_depth = 8;
        ri->ri_width = sc->sc_fb.fb_type.fb_width;
        ri->ri_height = sc->sc_fb.fb_type.fb_height;
        ri->ri_stride = sc->sc_fb.fb_linebytes;
        ri->ri_flg = RI_CENTER | RI_FULLCLEAR;

        ri->ri_bits = sc->sc_fbaddr;

        rasops_init(ri, 0, 0);
        ri->ri_caps = WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_UNDERLINE |
                      WSSCREEN_REVERSE | WSSCREEN_RESIZE;
        rasops_reconfig(ri, ri->ri_height / ri->ri_font->fontheight,
                    ri->ri_width / ri->ri_font->fontwidth);

        scr->scr_flags |= VCONS_NO_COPYCOLS | VCONS_NO_CURSOR | VCONS_LOADFONT;
        /* enable acceleration */
        ri->ri_ops.copyrows  = tcx_copyrows;
        ri->ri_ops.eraserows = tcx_eraserows;
        ri->ri_ops.erasecols = tcx_erasecols;
        ri->ri_ops.putchar   = tcx_putchar;
        ri->ri_ops.allocattr   = tcx_allocattr;
#if 0
        ri->ri_ops.cursor    = tcx_cursor;
        ri->ri_ops.copycols  = tcx_copycols;
#endif
}

static void
tcx_clearscreen(struct tcx_softc *sc, int spc)
{
        /* ROP in the upper 4bit is necessary, tcx actually uses it */
        volatile uint64_t bg = 0x30000000ffffffffLL;
        volatile uint64_t spc64;
        int i, len;

        spc64 = ((spc & 3) << 24);
        bg |= (spc64 << 32);

        len = sc->sc_fb.fb_type.fb_width * sc->sc_fb.fb_type.fb_height;
        for (i = 0; i < len; i += 32)
                sc->sc_rstip[i] = bg;
}

static void
tcx_copyrows(void *cookie, int srcrow, int dstrow, int nrows)
{
        struct rasops_info *ri = cookie;
        struct vcons_screen *scr = ri->ri_hw;
        struct tcx_softc *sc = scr->scr_cookie;
        int i, last, first, len, dest, leftover;

        if ((ri->ri_crow >= srcrow && ri->ri_crow < (srcrow + nrows)) &&
           (ri->ri_flg & RI_CURSOR)) {
                int ofs = ri->ri_crow * ri->ri_cols + ri->ri_ccol;
                tcx_putchar(cookie, ri->ri_crow, ri->ri_ccol,
                    scr->scr_chars[ofs], scr->scr_attrs[ofs]);
                ri->ri_flg &= ~RI_CURSOR;
        }

        if (ri->ri_crow >= dstrow && ri->ri_crow < (dstrow + nrows))
                ri->ri_flg &= ~RI_CURSOR;

        i = ri->ri_width * ri->ri_font->fontheight * nrows;
        len = i & 0xffffe0;
        leftover = i & 0x1f;
        if (srcrow < dstrow) {
                /* we must go bottom to top */
                first = ri->ri_width * 
                    (ri->ri_font->fontheight * srcrow + ri->ri_yorigin);
                last = first + len;
                dest = ri->ri_width *
                    (ri->ri_font->fontheight * dstrow + ri->ri_yorigin) + len;
                if (leftover > 0) {
                        sc->sc_rblit[dest + 32] = 
                            (uint64_t)((leftover - 1) << 24) | 
                            (uint64_t)(i + 32);
                }
                for (i = last; i >= first; i -= 32) {
                        sc->sc_rblit[dest] = 0x300000001f000000LL | (uint64_t)i;
                        dest -= 32;
                }
        } else {
                /* top to bottom */
                first = ri->ri_width * 
                    (ri->ri_font->fontheight * srcrow + ri->ri_yorigin);
                dest = ri->ri_width * 
                    (ri->ri_font->fontheight * dstrow + ri->ri_yorigin);
                last = first + len;
                for (i = first; i <= last; i+= 32) {
                        sc->sc_rblit[dest] = 0x300000001f000000LL | (uint64_t)i;
                        dest += 32;
                }
                if (leftover > 0) {
                        sc->sc_rblit[dest] = 
                            (uint64_t)((leftover - 1) << 24) | (uint64_t)i;
                }
        }
}

static void
tcx_eraserows(void *cookie, int start, int nrows, long attr)
{
        struct rasops_info *ri = cookie;
        struct vcons_screen *scr = ri->ri_hw;
        struct tcx_softc *sc = scr->scr_cookie;
        volatile uint64_t temp;
        int i, last, first, len, leftover;

        if (ri->ri_crow >= start && ri->ri_crow < (start + nrows))
                ri->ri_flg &= ~RI_CURSOR;

        i = ri->ri_width * ri->ri_font->fontheight * nrows;
        len = i & 0xffffe0;
        leftover = i & 0x1f;
        first = ri->ri_width * 
            (ri->ri_font->fontheight * start + ri->ri_yorigin);
        last = first + len;
        temp = 0x30000000ffffffffLL | 
            ((uint64_t)((ri->ri_devcmap[(attr >> 16) & 0xff]) & 0xff) << 32);

        for (i = first; i < last; i+= 32)
                sc->sc_rstip[i] = temp;

        if (leftover > 0) {
                temp &= 0xffffffffffffffffLL << (32 - leftover);
                sc->sc_rstip[i] = temp;
        }
}

static void
tcx_erasecols(void *cookie, int row, int startcol, int ncols, long attr)
{
        struct rasops_info *ri = cookie;
        struct vcons_screen *scr = ri->ri_hw;
        struct tcx_softc *sc = scr->scr_cookie;
        volatile uint64_t temp, cmd, rcmd, lcmd;
        uint32_t pmask;
        int i, fullsteps, line, dst;
        int x1 = startcol * ri->ri_font->fontwidth + ri->ri_xorigin;
        int x2 = (startcol + ncols) * ri->ri_font->fontwidth + ri->ri_xorigin;

        temp = 0x3000000000000000LL | 
            ((uint64_t)((ri->ri_devcmap[(attr >> 16) & 0xff]) & 0xff) << 32),
        dst = ri->ri_width * (ri->ri_font->fontheight * row + ri->ri_yorigin) +
              x1;
        dst &= 0xffffffe0;

        /* see if the whole thing falls into one 32bit chunk */
        if ((x1 & 0xffe0) == (x2 & 0xffe0)) {
                /* first zero out pixels on the right */
                pmask = 0xffffffff << (31 - (x2 & 0x1f));
                /* then mask out pixels on the left */
                pmask &= (0xffffffff >> (x1 & 0x1f));
                cmd = temp | pmask;
                for (i = 0; i < ri->ri_font->fontheight; i++) {
                        sc->sc_rstip[dst] = cmd;
                        dst += ri->ri_width;
                }
        } else {
                /* at least two writes per line */
                pmask = 0xffffffff << (31 - (x2 & 0x1f));
                rcmd = temp | (uint64_t)pmask;
                pmask = 0xffffffff >> (x1 & 0x1f);
                lcmd = temp | (uint64_t)pmask;
                cmd = temp | 0xffffffffLL;
                dst &= 0xffffffe0;
                fullsteps = ((x2 >> 5) - (x1 >> 5));
                fullsteps = fullsteps << 5;
                for (line = 0; line < ri->ri_font->fontheight; line++) {
                        sc->sc_rstip[dst] = lcmd;
                        for (i = 32; i < fullsteps; i+= 32)
                                sc->sc_rstip[dst + i] = cmd;
                        sc->sc_rstip[dst + i] = rcmd;
                        dst += ri->ri_width;
                }
        }
}

/*
 * The stipple engine is 100% stupid. All drawing operations have to start 
 * at 32 pixel boundaries so we'll have to deal with characters being split.
 */

static void
tcx_putchar(void *cookie, int row, int col, u_int c, long attr)
{
        struct rasops_info *ri = cookie;
        struct wsdisplay_font *font = PICK_FONT(ri, c);
        struct vcons_screen *scr = ri->ri_hw;
        struct tcx_softc *sc = scr->scr_cookie;
        volatile uint64_t bg, fg, temp, mask;
        int addr, i, uc, shift;
        uint32_t fmask;
        uint8_t *cdata, cc;
        uint16_t *wdata, w;
        int bold = (attr & WSATTR_HILIT) != 0;

        addr = ri->ri_xorigin + col * font->fontwidth +
            (ri->ri_yorigin + row * font->fontheight) * ri->ri_width;

        /* check if the character is crossing a 32 pixel boundary */
        if ((addr & 0xffffe0) ==
            ((addr + font->fontwidth - 1) & 0xffffe0)) {
                /* phew, not split */
                shift = addr & 0x1f;
                addr &= 0xffffe0;
                fmask = 0xffffffff >> (32 - font->fontwidth);
                fmask = fmask << (32 - font->fontwidth - shift);
                mask = fmask;
                bg = 0x3000000000000000LL |
                    ((uint64_t)ri->ri_devcmap[(attr >> 16) & 0xff] &
                      0xff) << 32;
                bg |= mask;
                temp = 0x3000000000000000LL |
                    ((uint64_t)ri->ri_devcmap[(attr >> 24) & 0xff] & 0xff) << 
                        32;
                uc = c - font->firstchar;
                cdata = (uint8_t *)font->data + uc * ri->ri_fontscale;

                if (font->fontwidth < 9) {
                        /* byte by byte */
                        for (i = 0; i < font->fontheight - 1; i++) {
                                sc->sc_rstip[addr] = bg;
                                cc = *cdata;
                                if (cc != 0) {
                                        if (bold) cc |= cc >> 1;
                                        if (shift > 24) {
                                                fg = (uint64_t)(cc >>
                                                  (shift - 24));
                                        } else {
                                                fg = (uint64_t)(cc <<
                                                  (24 - shift));
                                        }
                                        sc->sc_rstip[addr] = fg | temp;
                                }
                                cdata++;
                                addr += ri->ri_width;
                        }
                        if (attr & WSATTR_UNDERLINE) {
                                sc->sc_rstip[addr] = temp | mask;
                        } else {
                                sc->sc_rstip[addr] = bg;
                                cc = *cdata;
                                if (cc != 0) {
                                        if (bold) cc |= cc >> 1;
                                        if (shift > 24) {
                                                fg = (uint64_t)(cc >> (shift - 24));
                                        } else {
                                                fg = (uint64_t)(cc << (24 - shift));
                                        }
                                        sc->sc_rstip[addr] = fg | temp;
                                }
                        }
                } else if (font->fontwidth < 17) {
                        /* short by short */
                        wdata = (uint16_t *)cdata;
                        for (i = 0; i < font->fontheight - 1; i++) {
                                sc->sc_rstip[addr] = bg;
                                w = *wdata;
                                if (w != 0) {
                                        if (bold) w |= w >> 1;
                                        if (shift > 16) {
                                                fg = temp | (uint64_t)(w >> 
                                                  (shift - 16));
                                        } else {
                                                fg = temp | (uint64_t)(w << 
                                                  (16 - shift));
                                        }
                                        sc->sc_rstip[addr] = fg;
                                }
                                wdata++;
                                addr += ri->ri_width;
                        }
                        if (attr & WSATTR_UNDERLINE) {
                                sc->sc_rstip[addr] = temp | mask;
                        } else {
                                sc->sc_rstip[addr] = bg;
                                w = *wdata;
                                if (w != 0) {
                                        if (bold) w |= w >> 1;
                                        if (shift > 16) {
                                                fg = temp | (uint64_t)(w >> 
                                                  (shift - 16));
                                        } else {
                                                fg = temp | (uint64_t)(w << 
                                                  (16 - shift));
                                        }
                                        sc->sc_rstip[addr] = fg;
                                }
                        }
                }
        } else {
                /* and now the split case ( man this hardware is dumb ) */
                volatile uint64_t bgr, maskr, fgr;
                uint32_t bork;

                shift = addr & 0x1f;
                addr &= 0xffffe0;
                mask = 0xffffffff >> shift;
                maskr = (uint64_t)(0xffffffffUL << 
                    (32 - (font->fontwidth + shift - 32)));
                bg = 0x3000000000000000LL |
                    ((uint64_t)ri->ri_devcmap[(attr >> 16) & 0xff] &
                      0xff) << 32;
                bgr = bg | maskr;
                bg |= mask;
                temp = 0x3000000000000000LL |
                    ((uint64_t)ri->ri_devcmap[(attr >> 24) & 0xff] & 0xff) << 
                      32;

                uc = c - font->firstchar;
                cdata = (uint8_t *)font->data + uc * ri->ri_fontscale;

                if (font->fontwidth < 9) {
                        /* byte by byte */
                        for (i = 0; i < font->fontheight - 1; i++) {
                                sc->sc_rstip[addr] = bg;
                                sc->sc_rstip[addr + 32] = bgr;
                                bork = *cdata;
                                if (bork != 0) {
                                        if (bold) bork |= bork >> 1;
                                        fg = (uint64_t)bork >> (shift - 24);
                                        sc->sc_rstip[addr] = fg | temp;
                                        fgr = (uint64_t)(bork << (52 - shift));
                                        sc->sc_rstip[addr] = fgr | temp;
                                }
                                cdata++;
                                addr += ri->ri_width;
                        }
                        if (attr & WSATTR_UNDERLINE) {
                                sc->sc_rstip[addr] = temp | mask;
                                sc->sc_rstip[addr + 32] = temp | maskr;
                        } else {
                                sc->sc_rstip[addr] = bg;
                                sc->sc_rstip[addr + 32] = bgr;
                                bork = *cdata;
                                if (bork != 0) {
                                        if (bold) bork |= bork >> 1;
                                        fg = (uint64_t)bork >> (shift - 24);
                                        sc->sc_rstip[addr] = fg | temp;
                                        fgr = (uint64_t)(bork << (52 - shift));
                                        sc->sc_rstip[addr] = fgr | temp;
                                }
                        }
                } else if (font->fontwidth < 17) {
                        /* short by short */
                        wdata = (uint16_t *)cdata;
                        for (i = 0; i < font->fontheight - 1; i++) {
                                sc->sc_rstip[addr] = bg;
                                sc->sc_rstip[addr + 32] = bgr;
                                bork = *wdata;
                                if (bork != 0) {
                                        if (bold) bork |= bork >> 1;
                                        fg = (uint64_t)bork >> (shift - 16);
                                        sc->sc_rstip[addr] = fg | temp;
                                        fgr = (uint64_t)(bork << (48 - shift));
                                        sc->sc_rstip[addr + 32] = fgr | temp;
                                }
                                wdata++;
                                addr += ri->ri_width;
                        }
                        if (attr & WSATTR_UNDERLINE) {
                                sc->sc_rstip[addr] = temp | mask;
                                sc->sc_rstip[addr + 32] = temp | maskr;
                        } else {
                                sc->sc_rstip[addr] = bg;
                                sc->sc_rstip[addr + 32] = bgr;
                                bork = *wdata;
                                if (bork != 0) {
                                        if (bold) bork |= bork >> 1;
                                        fg = (uint64_t)bork >> (shift - 16);
                                        sc->sc_rstip[addr] = fg | temp;
                                        fgr = (uint64_t)(bork << (48 - shift));
                                        sc->sc_rstip[addr + 32] = fgr | temp;
                                }
                        }
                }
        }
}

static int
tcx_allocattr(void *cookie, int fg0, int bg0, int flg, long *attrp)
{
        int fg = fg0, bg = bg0;

        if ((flg & WSATTR_BLINK) != 0)
                return EINVAL;

        if ((flg & WSATTR_REVERSE) != 0) {
                fg = bg0;
                bg = fg0;
        }

        *attrp = (bg << 16) | (fg << 24) | flg;
        return 0;
}

static int
tcx_do_cursor(struct tcx_softc *sc, struct wsdisplay_cursor *cur)
{
        if (sc->sc_8bit) {
                /* hw cursor is not implemented on tcx */
                return -1;
        }
        if (cur->which & WSDISPLAY_CURSOR_DOCUR) {

                if (cur->enable) {
                        tcx_set_cursor(sc);
                } else {
                        /* move the cursor out of sight */
                        bus_space_write_4(sc->sc_bustag, sc->sc_thc,
                            THC_CURSOR_POS, 0x7fff7fff);
                }
        }
        if (cur->which & WSDISPLAY_CURSOR_DOHOT) {

                sc->sc_hotspot_x = cur->hot.x;
                sc->sc_hotspot_y = cur->hot.y;
                tcx_set_cursor(sc);
        }
        if (cur->which & WSDISPLAY_CURSOR_DOPOS) {

                sc->sc_cursor_x = cur->pos.x;
                sc->sc_cursor_y = cur->pos.y;
                tcx_set_cursor(sc);
        }
        if (cur->which & WSDISPLAY_CURSOR_DOCMAP) {
#if 0
        /*
         * apparently we're not writing in the right register here - if we do
         * this the screen goes all funky
         */
                int i;

                for (i = 0; i < cur->cmap.count; i++) {
                        bus_space_write_4(sc->sc_bustag, sc->sc_bt, DAC_ADDRESS,
                            (cur->cmap.index + i + 2) << 24);
                        bus_space_write_4(sc->sc_bustag, sc->sc_bt,
                            DAC_CURSOR_LUT, cur->cmap.red[i] << 24);
                        bus_space_write_4(sc->sc_bustag, sc->sc_bt,
                            DAC_CURSOR_LUT, cur->cmap.green[i] << 24);
                        bus_space_write_4(sc->sc_bustag, sc->sc_bt,
                            DAC_CURSOR_LUT, cur->cmap.blue[i] << 24);
                }
#endif
        }
        if (cur->which & WSDISPLAY_CURSOR_DOSHAPE) {
                int i;
                uint32_t temp, poof;

                for (i = 0; i < 128; i += 4) {
                        memcpy(&temp, &cur->mask[i], 4);
                        poof = ((temp & 0x80808080) >> 7) |
                               ((temp & 0x40404040) >> 5) |
                               ((temp & 0x20202020) >> 3) |
                               ((temp & 0x10101010) >> 1) |
                               ((temp & 0x08080808) << 1) |
                               ((temp & 0x04040404) << 3) |
                               ((temp & 0x02020202) << 5) |
                               ((temp & 0x01010101) << 7);
                        bus_space_write_4(sc->sc_bustag, sc->sc_thc,
                            THC_CURSOR_1 + i, poof);
                        memcpy(&temp, &cur->image[i], 4);
                        poof = ((temp & 0x80808080) >> 7) |
                               ((temp & 0x40404040) >> 5) |
                               ((temp & 0x20202020) >> 3) |
                               ((temp & 0x10101010) >> 1) |
                               ((temp & 0x08080808) << 1) |
                               ((temp & 0x04040404) << 3) |
                               ((temp & 0x02020202) << 5) |
                               ((temp & 0x01010101) << 7);
                        bus_space_write_4(sc->sc_bustag, sc->sc_thc,
                            THC_CURSOR_0 + i, poof);
                }
        }
        return 0;
}

static void
tcx_set_cursor(struct tcx_softc *sc)
{
        uint32_t reg;

        reg = (((sc->sc_cursor_x - sc->sc_hotspot_x) & 0xfff) << 16) | 
             ((sc->sc_cursor_y - sc->sc_hotspot_y) & 0x0fff);
        bus_space_write_4(sc->sc_bustag, sc->sc_thc, THC_CURSOR_POS, reg);
}