/*      $NetBSD: lynxfb.c,v 1.7 2021/08/07 16:19:14 thorpej Exp $       */
/*      $OpenBSD: smfb.c,v 1.13 2011/07/21 20:36:12 miod Exp $  */

/*
 * Copyright (c) 2012 NONAKA Kimihiro <nonaka@netbsd.org>
 * Copyright (c) 2009, 2010 Miodrag Vallat.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * SiliconMotion SM712 frame buffer driver.
 *
 * Assumes its video output is an LCD panel, in 5:6:5 mode, and fixed
 * 1024x600 resolution, depending on the system model.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lynxfb.c,v 1.7 2021/08/07 16:19:14 thorpej Exp $");

#include "opt_wsemul.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/endian.h>
#include <sys/kauth.h>

#include <sys/bus.h>

#include <dev/ic/vgareg.h>
#include <dev/isa/isareg.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/pcidevs.h>
#include <dev/pci/pciio.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>
#include <dev/rasops/rasops.h>
#include <dev/wscons/wsdisplay_vconsvar.h>
#include <dev/pci/wsdisplay_pci.h>

#include <dev/pci/lynxfbreg.h>
#include <dev/pci/lynxfbvar.h>

#ifndef LYNXFB_DEFAULT_WIDTH
#define LYNXFB_DEFAULT_WIDTH    1024
#endif
#ifndef LYNXFB_DEFAULT_HEIGHT
#define LYNXFB_DEFAULT_HEIGHT   600
#endif
#ifndef LYNXFB_DEFAULT_DEPTH
#define LYNXFB_DEFAULT_DEPTH    16
#endif
#ifndef LYNXFB_DEFAULT_STRIDE
#define LYNXFB_DEFAULT_STRIDE   0
#endif
#ifndef LYNXFB_DEFAULT_FLAGS
#ifdef __MIPSEL__
#define LYNXFB_DEFAULT_FLAGS    LYNXFB_FLAG_SWAPBR
#else
#define LYNXFB_DEFAULT_FLAGS    0
#endif
#endif

struct lynxfb_softc;

/* minimal frame buffer information, suitable for early console */
struct lynxfb {
        struct lynxfb_softc     *sc;
        void                    *fbaddr;

        bus_space_tag_t         memt;
        bus_space_handle_t      memh;

        /* DPR registers */
        bus_space_tag_t         dprt;
        bus_space_handle_t      dprh;
        /* MMIO space */
        bus_space_tag_t         mmiot;
        bus_space_handle_t      mmioh;

        struct vcons_screen     vcs;
        struct wsscreen_descr   wsd;

        int                     width, height, depth, stride;
        int                     accel;
        int                     blank;

        /* LYNXFB_FLAG_* */
        int                     flags;
#define LYNXFB_FLAG_SWAPBR      (1 << 0)
};

#define DPR_READ(fb, reg) \
        bus_space_read_4((fb)->memt, (fb)->dprh, (reg))
#define DPR_WRITE(fb, reg, val) \
        bus_space_write_4((fb)->memt, (fb)->dprh, (reg), (val))

struct lynxfb_softc {
        device_t                sc_dev;
        bus_space_tag_t         sc_memt;
        bus_space_handle_t      sc_memh;

        pci_chipset_tag_t       sc_pc;
        pcitag_t                sc_pcitag;

        struct lynxfb           *sc_fb;
        struct lynxfb           sc_fb_store;
        bus_addr_t              sc_fbaddr;
        bus_size_t              sc_fbsize;

        struct vcons_data       sc_vd;
        struct wsscreen_list    sc_screenlist;
        const struct wsscreen_descr *sc_screens[1];
        int                     sc_mode;
};

static int      lynxfb_match_by_id(pcireg_t);
static int      lynxfb_match(device_t, cfdata_t, void *);
static void     lynxfb_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(lynxfb, sizeof(struct lynxfb_softc),
    lynxfb_match, lynxfb_attach, NULL, NULL);

static int      lynxfb_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t  lynxfb_mmap(void *, void *, off_t, int);

static struct wsdisplay_accessops lynxfb_accessops = {
        lynxfb_ioctl,
        lynxfb_mmap,
        NULL,   /* alloc_screen */
        NULL,   /* free_screen */
        NULL,   /* show_screen */
        NULL,   /* load_font */
        NULL,   /* pollc */
        NULL,   /* scroll */
};

static bool     lynxfb_is_console(struct lynxfb_softc *, pcitag_t);
static void     lynxfb_init_screen(void *, struct vcons_screen *, int, long *);
static int      lynxfb_setup(struct lynxfb *);

static int      lynxfb_wait(struct lynxfb *);
static void     lynxfb_copyrect(struct lynxfb *, int, int, int, int, int, int);
static void     lynxfb_fillrect(struct lynxfb *, int, int, int, int, int);
static void     lynxfb_copyrows(void *, int, int, int);
static void     lynxfb_copycols(void *, int, int, int, int);
static void     lynxfb_erasecols(void *, int, int, int, long);
static void     lynxfb_eraserows(void *, int, int, long);
static void     lynxfb_vcons_copyrows(void *, int, int, int);
static void     lynxfb_vcons_copycols(void *, int, int, int, int);
static void     lynxfb_vcons_erasecols(void *, int, int, int, long);
static void     lynxfb_vcons_eraserows(void *, int, int, long);
static void     lynxfb_blank(struct lynxfb *, int);

static struct {
        bool is_console;
        pcitag_t tag;
        bus_space_tag_t memt;
        bus_space_handle_t memh;
        struct lynxfb fb;
        bus_addr_t fbaddr;
        bus_size_t fbsize;
} lynxfb_console;

int lynxfb_default_width = LYNXFB_DEFAULT_WIDTH;
int lynxfb_default_height = LYNXFB_DEFAULT_HEIGHT;
int lynxfb_default_depth = LYNXFB_DEFAULT_DEPTH;
int lynxfb_default_stride = LYNXFB_DEFAULT_STRIDE;
int lynxfb_default_flags = LYNXFB_DEFAULT_FLAGS;

static int
lynxfb_match_by_id(pcireg_t id)
{

        if (PCI_VENDOR(id) != PCI_VENDOR_SILMOTION)
                return (0);
        if (PCI_PRODUCT(id) != PCI_PRODUCT_SILMOTION_SM712)
                return (0);
        return (1);
}

int
lynxfb_cnattach(bus_space_tag_t memt, bus_space_tag_t iot, pci_chipset_tag_t pc,
    pcitag_t tag, pcireg_t id)
{
        struct rasops_info *ri = &lynxfb_console.fb.vcs.scr_ri;
        struct lynxfb *fb;
        bus_space_handle_t memh;
        bus_addr_t base;
        bus_size_t size;
        long defattr;
        int mapflags;
        int error;

        if (!lynxfb_match_by_id(id))
                return (ENODEV);

        if (pci_mapreg_info(pc, tag, PCI_MAPREG_START, PCI_MAPREG_TYPE_MEM,
            &base, &size, &mapflags))
                return (EINVAL);
        error = bus_space_map(memt, base, size, BUS_SPACE_MAP_LINEAR | mapflags,
            &memh);
        if (error)
                return (error);

        fb = &lynxfb_console.fb;
        fb->memt = memt;
        fb->memh = memh;
        fb->width = lynxfb_default_width;
        fb->height = lynxfb_default_height;
        fb->depth = lynxfb_default_depth;
        fb->stride = lynxfb_default_stride;
        if (fb->stride == 0)
                fb->stride = fb->width * fb->depth / 8;
        fb->flags = lynxfb_default_flags;
        error = lynxfb_setup(fb);
        if (error) {
                bus_space_unmap(memt, memh, size);
                return (error);
        }

        lynxfb_console.is_console = true;
        lynxfb_console.tag = tag;
        lynxfb_console.fbaddr = base;
        lynxfb_console.fbsize = size;
        (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr);
        wsdisplay_preattach(&fb->wsd, ri, 0, 0, defattr);

        return (0);
}

static bool
lynxfb_is_console(struct lynxfb_softc *sc, pcitag_t tag)
{

        return (lynxfb_console.is_console &&
            !memcmp(&lynxfb_console.tag, &tag, sizeof(tag)));
}

static int
lynxfb_match(device_t parent, cfdata_t match, void *aux)
{
        struct pci_attach_args *pa = (struct pci_attach_args *)aux;

        if (PCI_CLASS(pa->pa_class) != PCI_CLASS_DISPLAY)
                return (0);
        if (!lynxfb_match_by_id(pa->pa_id))
                return (0);
        return (1);
}

static void
lynxfb_attach(device_t parent, device_t self, void *aux)
{
        struct lynxfb_softc *sc = device_private(self);
        struct pci_attach_args *pa = (struct pci_attach_args *)aux;
        struct wsemuldisplaydev_attach_args waa;
        struct lynxfb *fb;
        struct rasops_info *ri;
        prop_dictionary_t dict;
        long defattr;
        bool is_console;

        sc->sc_dev = self;
        sc->sc_pc = pa->pa_pc;
        sc->sc_pcitag = pa->pa_tag;

        pci_aprint_devinfo(pa, NULL);

        is_console = lynxfb_is_console(sc, sc->sc_pcitag);

        fb = is_console ? &lynxfb_console.fb : &sc->sc_fb_store;
        sc->sc_fb = fb;
        fb->sc = sc;

        if (is_console) {
                sc->sc_fbaddr = lynxfb_console.fbaddr;
                sc->sc_fbsize = lynxfb_console.fbsize;
        } else {
                if (pci_mapreg_map(pa, PCI_MAPREG_START, PCI_MAPREG_TYPE_MEM,
                    BUS_SPACE_MAP_LINEAR, &fb->memt, &fb->memh, &sc->sc_fbaddr,
                    &sc->sc_fbsize)) {
                        aprint_error_dev(self, "can't map frame buffer\n");
                        return;
                }

                dict = device_properties(self);
                if (!prop_dictionary_get_uint32(dict, "width", &fb->width))
                        fb->width = lynxfb_default_width;
                if (!prop_dictionary_get_uint32(dict, "height", &fb->height))
                        fb->height = lynxfb_default_height;
                if (!prop_dictionary_get_uint32(dict, "depth", &fb->depth))
                        fb->depth = lynxfb_default_depth;
                if (!prop_dictionary_get_uint32(dict, "linebytes", &fb->stride)) {
                        if (lynxfb_default_stride == 0)
                                fb->stride = fb->width * fb->depth / 8;
                        else
                                fb->stride = lynxfb_default_stride;
                }
                if (!prop_dictionary_get_uint32(dict, "flags", &fb->flags))
                        fb->flags = lynxfb_default_flags;

                if (lynxfb_setup(fb)) {
                        aprint_error_dev(self, "can't setup frame buffer\n");
                        bus_space_unmap(fb->memt, fb->memh, sc->sc_fbsize);
                        return;
                }
        }
        sc->sc_memt = fb->memt;
        sc->sc_memh = fb->memh;

        aprint_normal_dev(self, "%d x %d, %d bpp, stride %d\n", fb->width,
            fb->height, fb->depth, fb->stride);

        fb->wsd = (struct wsscreen_descr) {
                "default",
                0, 0,
                NULL,
                8, 16,
                WSSCREEN_WSCOLORS | WSSCREEN_HILIT,
                NULL,
        };
        sc->sc_screens[0] = &fb->wsd;
        sc->sc_screenlist = (struct wsscreen_list){ 1, sc->sc_screens };
        sc->sc_mode = WSDISPLAYIO_MODE_EMUL;

        vcons_init(&sc->sc_vd, sc, &fb->wsd, &lynxfb_accessops);
        sc->sc_vd.init_screen = lynxfb_init_screen;

        ri = &fb->vcs.scr_ri;
        if (is_console) {
                vcons_init_screen(&sc->sc_vd, &fb->vcs, 1, &defattr);
                fb->vcs.scr_flags |= VCONS_SCREEN_IS_STATIC;

                fb->wsd.textops = &ri->ri_ops;
                fb->wsd.capabilities = ri->ri_caps;
                fb->wsd.nrows = ri->ri_rows;
                fb->wsd.ncols = ri->ri_cols;
                wsdisplay_cnattach(&fb->wsd, ri, 0, 0, defattr);
                vcons_replay_msgbuf(&fb->vcs);
        } else {
                /*
                 * since we're not the console we can postpone the rest
                 * until someone actually allocates a screen for us
                 */
                (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr);
        }

        waa.console = is_console;
        waa.scrdata = &sc->sc_screenlist;
        waa.accessops = &lynxfb_accessops;
        waa.accesscookie = &sc->sc_vd;

        config_found(self, &waa, wsemuldisplaydevprint, CFARGS_NONE);
}

/*
 * vga sequencer access through MMIO space
 */
static __inline uint8_t
lynxfb_vgats_read(struct lynxfb *fb, uint regno)
{

        bus_space_write_1(fb->mmiot, fb->mmioh, IO_VGA + VGA_TS_INDEX, regno);
        return bus_space_read_1(fb->mmiot, fb->mmioh, IO_VGA + VGA_TS_DATA);
}

static __inline void
lynxfb_vgats_write(struct lynxfb *fb, uint regno, uint8_t value)
{

        bus_space_write_1(fb->mmiot, fb->mmioh, IO_VGA + VGA_TS_INDEX, regno);
        bus_space_write_1(fb->mmiot, fb->mmioh, IO_VGA + VGA_TS_DATA, value);
}

/*
 * wsdisplay accesops
 */
static int
lynxfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flags,
    struct lwp *l)
{
        struct vcons_data *vd = v;
        struct lynxfb_softc *sc = vd->cookie;
        struct lynxfb *fb = sc->sc_fb;
        struct vcons_screen *ms = vd->active;
        struct wsdisplay_fbinfo *wdf;
        struct wsdisplay_param *param;

        switch (cmd) {
        case WSDISPLAYIO_GTYPE:
                *(uint *)data = WSDISPLAY_TYPE_PCIMISC;
                return (0);

        /* PCI config read/write passthrough. */
        case PCI_IOC_CFGREAD:
        case PCI_IOC_CFGWRITE:
                return pci_devioctl(sc->sc_pc, sc->sc_pcitag,
                    cmd, data, flags, l);

        case WSDISPLAYIO_GET_BUSID:
                return wsdisplayio_busid_pci(sc->sc_dev, sc->sc_pc,
                    sc->sc_pcitag, data);

        case WSDISPLAYIO_GINFO:
                if (ms == NULL)
                        return (ENODEV);
                wdf = (struct wsdisplay_fbinfo *)data;
                wdf->width = ms->scr_ri.ri_width;
                wdf->height = ms->scr_ri.ri_height;
                wdf->depth = ms->scr_ri.ri_depth;
                wdf->cmsize = 0;
                return (0);

        case WSDISPLAYIO_LINEBYTES:
                *(uint *)data = fb->stride;
                return (0);

        case WSDISPLAYIO_GVIDEO:
                *(int *)data = fb->blank ? WSDISPLAYIO_VIDEO_OFF :
                    WSDISPLAYIO_VIDEO_ON;
                return (0);

        case WSDISPLAYIO_SVIDEO:
                lynxfb_blank(fb, *(int *)data);
                return (0);

        case WSDISPLAYIO_GETPARAM:
                param = (struct wsdisplay_param *)data;
                switch (param->param) {
                case WSDISPLAYIO_PARAM_BACKLIGHT:
                        param->min = 0;
                        param->max = 1;
                        param->curval = fb->blank;
                        return (0);
                }
                break;

        case WSDISPLAYIO_SETPARAM:
                param = (struct wsdisplay_param *)data;
                switch (param->param) {
                case WSDISPLAYIO_PARAM_BACKLIGHT:
                        lynxfb_blank(fb, param->curval);
                        return (0);
                }
                break;
        }
        return (EPASSTHROUGH);
}

static paddr_t
lynxfb_mmap(void *v, void *vs, off_t offset, int prot)
{
        struct vcons_data *vd = v;
        struct lynxfb_softc *sc = vd->cookie;
        struct rasops_info *ri = &sc->sc_fb->vcs.scr_ri;

        /* 'regular' framebuffer mmap()ing */
        if (offset < ri->ri_stride * ri->ri_height) {
                return bus_space_mmap(sc->sc_memt, sc->sc_fbaddr + offset, 0,
                    prot, BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE);
        }

        /*
         * restrict all other mappings to processes with superuser privileges
         * or the kernel itself
         */
        if (kauth_authorize_machdep(kauth_cred_get(),
            KAUTH_MACHDEP_UNMANAGEDMEM, NULL, NULL, NULL, NULL) != 0) {
                aprint_normal_dev(sc->sc_dev, "mmap() rejected.\n");
                return (-1);
        }

        /* framebuffer mmap()ing */
        if (offset >= sc->sc_fbaddr &&
            offset < sc->sc_fbaddr + ri->ri_stride * ri->ri_height) {
                return bus_space_mmap(sc->sc_memt, offset, 0, prot,
                    BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_PREFETCHABLE);
        }

        /* register mmap()ing */
        if (offset >= sc->sc_fbaddr + SM7XX_REG_BASE &&
            offset < sc->sc_fbaddr + SM7XX_REG_BASE + SM7XX_REG_SIZE) {
                return bus_space_mmap(sc->sc_memt, offset, 0, prot, 0);
        }

        return (-1);
}

static void
lynxfb_init_screen(void *cookie, struct vcons_screen *scr,
    int existing, long *defattr)
{
        struct lynxfb_softc *sc = cookie;
        struct lynxfb *fb = sc->sc_fb;
        struct rasops_info *ri = &scr->scr_ri;

        ri->ri_width = fb->width;
        ri->ri_height = fb->height;
        ri->ri_depth = fb->depth;
        ri->ri_stride = fb->stride;
        ri->ri_flg = RI_CENTER;
        ri->ri_bits = fb->fbaddr;

#ifdef VCONS_DRAW_INTR
        scr->scr_flags |= VCONS_DONT_READ;
#endif

        if (existing)
                ri->ri_flg |= RI_CLEAR;

        rasops_init(ri, 0, 0);
        ri->ri_caps = WSSCREEN_WSCOLORS;
        rasops_reconfig(ri, fb->height / ri->ri_font->fontheight,
            fb->width / ri->ri_font->fontwidth);

        ri->ri_hw = scr;

        if (fb->accel) {
                ri->ri_ops.copycols = lynxfb_vcons_copycols;
                ri->ri_ops.copyrows = lynxfb_vcons_copyrows;
                ri->ri_ops.erasecols = lynxfb_vcons_erasecols;
                ri->ri_ops.eraserows = lynxfb_vcons_eraserows;
        }
}

/*
 * Frame buffer initialization.
 */
static int
lynxfb_setup(struct lynxfb *fb)
{
        struct rasops_info *ri = &fb->vcs.scr_ri;
        int error;

        fb->dprt = fb->memt;
        error = bus_space_subregion(fb->memt, fb->memh, SM7XX_DPR_BASE,
            SMXXX_DPR_SIZE, &fb->dprh);
        if (error != 0)
                return (error);

        fb->mmiot = fb->memt;
        error = bus_space_subregion(fb->mmiot, fb->memh, SM7XX_MMIO_BASE,
            SM7XX_MMIO_SIZE, &fb->mmioh);
        if (error != 0)
                return (error);

        ri->ri_width = fb->width;
        ri->ri_height = fb->height;
        ri->ri_depth = fb->depth;
        ri->ri_stride = fb->stride;
        ri->ri_flg = RI_CENTER | RI_CLEAR | RI_NO_AUTO;
        fb->fbaddr = ri->ri_bits = (void *)bus_space_vaddr(fb->memt, fb->memh);
        ri->ri_hw = fb;

        if (fb->flags & LYNXFB_FLAG_SWAPBR) {
                switch (fb->depth) {
                case 16:
                        ri->ri_rnum = 5;
                        ri->ri_rpos = 11;
                        ri->ri_gnum = 6;
                        ri->ri_gpos = 5;
                        ri->ri_bnum = 5;
                        ri->ri_bpos = 0;
                        break;
                }
        }

        rasops_init(ri, 0, 0);
        rasops_reconfig(ri, ri->ri_height / ri->ri_font->fontheight,
            ri->ri_width / ri->ri_font->fontwidth);

        fb->wsd.name = "std";
        fb->wsd.ncols = ri->ri_cols;
        fb->wsd.nrows = ri->ri_rows;
        fb->wsd.textops = &ri->ri_ops;
        fb->wsd.fontwidth = ri->ri_font->fontwidth;
        fb->wsd.fontheight = ri->ri_font->fontheight;
        fb->wsd.capabilities = ri->ri_caps;

        /*
         * Setup 2D acceleration whenever possible
         */
        if (lynxfb_wait(fb) == 0) {
                fb->accel = 1;

                DPR_WRITE(fb, DPR_CROP_TOPLEFT_COORDS, DPR_COORDS(0, 0));
                /* use of width both times is intentional */
                DPR_WRITE(fb, DPR_PITCH,
                    DPR_COORDS(ri->ri_width, ri->ri_width));
                DPR_WRITE(fb, DPR_SRC_WINDOW,
                    DPR_COORDS(ri->ri_width, ri->ri_width));
                DPR_WRITE(fb, DPR_BYTE_BIT_MASK, 0xffffffff);
                DPR_WRITE(fb, DPR_COLOR_COMPARE_MASK, 0);
                DPR_WRITE(fb, DPR_COLOR_COMPARE, 0);
                DPR_WRITE(fb, DPR_SRC_BASE, 0);
                DPR_WRITE(fb, DPR_DST_BASE, 0);
                DPR_READ(fb, DPR_DST_BASE);

                ri->ri_ops.copycols = lynxfb_copycols;
                ri->ri_ops.copyrows = lynxfb_copyrows;
                ri->ri_ops.erasecols = lynxfb_erasecols;
                ri->ri_ops.eraserows = lynxfb_eraserows;
        }

        return (0);
}

static int
lynxfb_wait(struct lynxfb *fb)
{
        uint32_t reg;
        int i;

        for (i = 10000; i > 0; i--) {
                reg = lynxfb_vgats_read(fb, 0x16);
                if ((reg & 0x18) == 0x10)
                        return (0);
                delay(1);
        }
        return (EBUSY);
}

static void
lynxfb_copyrect(struct lynxfb *fb, int sx, int sy, int dx, int dy, int w, int h)
{
        uint32_t dir;

        /* Compute rop direction */
        if (sy < dy || (sy == dy && sx <= dx)) {
                sx += w - 1;
                dx += w - 1;
                sy += h - 1;
                dy += h - 1;
                dir = DE_CTRL_RTOL;
        } else
                dir = 0;

        DPR_WRITE(fb, DPR_SRC_COORDS, DPR_COORDS(sx, sy));
        DPR_WRITE(fb, DPR_DST_COORDS, DPR_COORDS(dx, dy));
        DPR_WRITE(fb, DPR_SPAN_COORDS, DPR_COORDS(w, h));
        DPR_WRITE(fb, DPR_DE_CTRL, DE_CTRL_START | DE_CTRL_ROP_ENABLE | dir |
            (DE_CTRL_COMMAND_BITBLT << DE_CTRL_COMMAND_SHIFT) |
            (DE_CTRL_ROP_SRC << DE_CTRL_ROP_SHIFT));
        DPR_READ(fb, DPR_DE_CTRL);

        lynxfb_wait(fb);
}

static void
lynxfb_fillrect(struct lynxfb *fb, int x, int y, int w, int h, int bg)
{
        struct rasops_info *ri = &fb->vcs.scr_ri;

        DPR_WRITE(fb, DPR_FG_COLOR, ri->ri_devcmap[bg]);
        DPR_WRITE(fb, DPR_DST_COORDS, DPR_COORDS(x, y));
        DPR_WRITE(fb, DPR_SPAN_COORDS, DPR_COORDS(w, h));
        DPR_WRITE(fb, DPR_DE_CTRL, DE_CTRL_START | DE_CTRL_ROP_ENABLE |
            (DE_CTRL_COMMAND_SOLIDFILL << DE_CTRL_COMMAND_SHIFT) |
            (DE_CTRL_ROP_SRC << DE_CTRL_ROP_SHIFT));
        DPR_READ(fb, DPR_DE_CTRL);

        lynxfb_wait(fb);
}

static inline void
lynxfb_copyrows1(struct rasops_info *ri, int src, int dst, int num,
    struct lynxfb *fb)
{
        struct wsdisplay_font *f = ri->ri_font;

        num *= f->fontheight;
        src *= f->fontheight;
        dst *= f->fontheight;

        lynxfb_copyrect(fb, ri->ri_xorigin, ri->ri_yorigin + src,
            ri->ri_xorigin, ri->ri_yorigin + dst, ri->ri_emuwidth, num);
}

static inline void
lynxfb_copycols1(struct rasops_info *ri, int row, int src, int dst, int num,
    struct lynxfb *fb)
{
        struct wsdisplay_font *f = ri->ri_font;

        num *= f->fontwidth;
        src *= f->fontwidth;
        dst *= f->fontwidth;
        row *= f->fontheight;

        lynxfb_copyrect(fb, ri->ri_xorigin + src, ri->ri_yorigin + row,
            ri->ri_xorigin + dst, ri->ri_yorigin + row, num, f->fontheight);
}

static inline void
lynxfb_erasecols1(struct rasops_info *ri, int row, int col, int num, long attr,
    struct lynxfb *fb)
{
        struct wsdisplay_font *f = ri->ri_font;
        int32_t bg, fg, ul;

        row *= f->fontheight;
        col *= f->fontwidth;
        num *= f->fontwidth;
        rasops_unpack_attr(attr, &fg, &bg, &ul);

        lynxfb_fillrect(fb, ri->ri_xorigin + col, ri->ri_yorigin + row,
            num, f->fontheight, bg);
}

static inline void
lynxfb_eraserows1(struct rasops_info *ri, int row, int num, long attr,
    struct lynxfb *fb)
{
        struct wsdisplay_font *f = ri->ri_font;
        int32_t bg, fg, ul;
        int x, y, w;

        if ((num == ri->ri_rows) && ISSET(ri->ri_flg, RI_FULLCLEAR)) {
                num = ri->ri_height;
                x = y = 0;
                w = ri->ri_width;
        } else {
                num *= f->fontheight;
                x = ri->ri_xorigin;
                y = ri->ri_yorigin + row * f->fontheight;
                w = ri->ri_emuwidth;
        }
        rasops_unpack_attr(attr, &fg, &bg, &ul);
        lynxfb_fillrect(fb, x, y, w, num, bg);
}

static void
lynxfb_copyrows(void *cookie, int src, int dst, int num)
{
        struct rasops_info *ri = cookie;
        struct lynxfb *fb = ri->ri_hw;

        lynxfb_copyrows1(ri, src, dst, num, fb);
}

static void
lynxfb_copycols(void *cookie, int row, int src, int dst, int num)
{
        struct rasops_info *ri = cookie;
        struct lynxfb *fb = ri->ri_hw;

        lynxfb_copycols1(ri, row, src, dst, num, fb);
}

static void
lynxfb_erasecols(void *cookie, int row, int col, int num, long attr)
{
        struct rasops_info *ri = cookie;
        struct lynxfb *fb = ri->ri_hw;

        lynxfb_erasecols1(ri, row, col, num, attr, fb);
}

static void
lynxfb_eraserows(void *cookie, int row, int num, long attr)
{
        struct rasops_info *ri = cookie;
        struct lynxfb *fb = ri->ri_hw;

        lynxfb_eraserows1(ri, row, num, attr, fb);
}

static void
lynxfb_vcons_copyrows(void *cookie, int src, int dst, int num)
{
        struct rasops_info *ri = cookie;
        struct vcons_screen *scr = ri->ri_hw;
        struct lynxfb_softc *sc = scr->scr_cookie;
        struct lynxfb *fb = sc->sc_fb;

        lynxfb_copyrows1(ri, src, dst, num, fb);
}

static void
lynxfb_vcons_copycols(void *cookie, int row, int src, int dst, int num)
{
        struct rasops_info *ri = cookie;
        struct vcons_screen *scr = ri->ri_hw;
        struct lynxfb_softc *sc = scr->scr_cookie;
        struct lynxfb *fb = sc->sc_fb;

        lynxfb_copycols1(ri, row, src, dst, num, fb);
}

static void
lynxfb_vcons_erasecols(void *cookie, int row, int col, int num, long attr)
{
        struct rasops_info *ri = cookie;
        struct vcons_screen *scr = ri->ri_hw;
        struct lynxfb_softc *sc = scr->scr_cookie;
        struct lynxfb *fb = sc->sc_fb;

        lynxfb_erasecols1(ri, row, col, num, attr, fb);
}

static void
lynxfb_vcons_eraserows(void *cookie, int row, int num, long attr)
{
        struct rasops_info *ri = cookie;
        struct vcons_screen *scr = ri->ri_hw;
        struct lynxfb_softc *sc = scr->scr_cookie;
        struct lynxfb *fb = sc->sc_fb;

        lynxfb_eraserows1(ri, row, num, attr, fb);
}

static void
lynxfb_blank(struct lynxfb *fb, int enable)
{

        fb->blank = !enable;
        if (enable) {
                lynxfb_vgats_write(fb, 0x31,
                    lynxfb_vgats_read(fb, 0x31) | 0x01);
        } else {
                lynxfb_vgats_write(fb, 0x21,
                    lynxfb_vgats_read(fb, 0x21) | 0x30);
                lynxfb_vgats_write(fb, 0x31,
                    lynxfb_vgats_read(fb, 0x31) & ~0x01);
        }
}