/* $NetBSD: vga.c,v 1.120 2021/08/07 16:19:12 thorpej Exp $ */

/*
 * Copyright (c) 1995, 1996 Carnegie-Mellon University.
 * All rights reserved.
 *
 * Author: Chris G. Demetriou
 *
 * Permission to use, copy, modify and distribute this software and
 * its documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */

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

#include "opt_vga.h"
/* for WSCONS_SUPPORT_PCVTFONTS */
#include "opt_wsdisplay_compat.h"
/* for WSDISPLAY_CUSTOM_BORDER */
#include "opt_wsdisplay_border.h"
/* for WSDISPLAY_CUSTOM_OUTPUT */
#include "opt_wsmsgattrs.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/queue.h>
#include <sys/bus.h>

#include <dev/ic/mc6845reg.h>
#include <dev/ic/pcdisplayvar.h>
#include <dev/ic/vgareg.h>
#include <dev/ic/vgavar.h>

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

#include <dev/ic/pcdisplay.h>

int vga_no_builtinfont = 0;

static struct wsdisplay_font _vga_builtinfont = {
        "builtin",                      /* typeface name */
        0,                              /* firstchar */
        256,                            /* numbers */
        WSDISPLAY_FONTENC_IBM,          /* encoding */
        8,                              /* width */
        16,                             /* height */
        1,                              /* stride */
        WSDISPLAY_FONTORDER_L2R,        /* bit order */
        0,                              /* byte order */
        NULL                            /* data */
};

struct egavga_font {
        struct wsdisplay_font *wsfont;
        int cookie; /* wsfont handle, -1 invalid */
        int slot; /* in adapter RAM */
        int usecount;
        TAILQ_ENTRY(egavga_font) next; /* LRU queue */
};

static struct egavga_font vga_builtinfont = {
        .wsfont = &_vga_builtinfont,
        .cookie = -1,
        .slot = 0,
};

#ifdef VGA_CONSOLE_SCREENTYPE
static struct egavga_font vga_consolefont;
#endif

struct vgascreen {
        struct pcdisplayscreen pcs;

        LIST_ENTRY(vgascreen) next;

        struct vga_config *cfg;

        /* videostate */
        struct egavga_font *fontset1, *fontset2;
        /* font data */

        int mindispoffset, maxdispoffset;
        int vga_rollover;
        int visibleoffset;
};

static int vgaconsole, vga_console_type, vga_console_attached;
static struct vgascreen vga_console_screen;
static struct vga_config vga_console_vc;

static struct egavga_font *egavga_getfont(struct vga_config *, struct vgascreen *,
                                   const char *, int);
static void egavga_unreffont(struct vga_config *, struct egavga_font *);

static int vga_selectfont(struct vga_config *, struct vgascreen *, const char *,
                                   const char *);
static void vga_init_screen(struct vga_config *, struct vgascreen *,
                     const struct wsscreen_descr *, int, long *);
static void vga_init(struct vga_config *, bus_space_tag_t, bus_space_tag_t);
static void vga_setfont(struct vga_config *, struct vgascreen *);

static int vga_mapchar(void *, int, unsigned int *);
static void vga_putchar(void *, int, int, u_int, long);
static int vga_allocattr(void *, int, int, int, long *);
static void vga_copyrows(void *, int, int, int);
#ifdef WSDISPLAY_SCROLLSUPPORT
static void vga_scroll (void *, void *, int);
#endif

const struct wsdisplay_emulops vga_emulops = {
        pcdisplay_cursor,
        vga_mapchar,
        vga_putchar,
        pcdisplay_copycols,
        pcdisplay_erasecols,
        vga_copyrows,
        pcdisplay_eraserows,
        vga_allocattr,
#ifdef WSDISPLAY_CUSTOM_OUTPUT
        pcdisplay_replaceattr,
#else
        NULL,
#endif
};

/*
 * translate WS(=ANSI) color codes to standard pc ones
 */
static const unsigned char fgansitopc[] = {
#ifdef __alpha__
        /*
         * XXX DEC HAS SWITCHED THE CODES FOR BLUE AND RED!!!
         * XXX We should probably not bother with this
         * XXX (reinitialize the palette registers).
         */
        FG_BLACK, FG_BLUE, FG_GREEN, FG_CYAN, FG_RED,
        FG_MAGENTA, FG_BROWN, FG_LIGHTGREY
#else
        FG_BLACK, FG_RED, FG_GREEN, FG_BROWN, FG_BLUE,
        FG_MAGENTA, FG_CYAN, FG_LIGHTGREY
#endif
}, bgansitopc[] = {
#ifdef __alpha__
        BG_BLACK, BG_BLUE, BG_GREEN, BG_CYAN, BG_RED,
        BG_MAGENTA, BG_BROWN, BG_LIGHTGREY
#else
        BG_BLACK, BG_RED, BG_GREEN, BG_BROWN, BG_BLUE,
        BG_MAGENTA, BG_CYAN, BG_LIGHTGREY
#endif
};

const struct wsscreen_descr vga_25lscreen = {
        "80x25", 80, 25,
        &vga_emulops,
        8, 16,
        WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
        NULL,
}, vga_25lscreen_mono = {
        "80x25", 80, 25,
        &vga_emulops,
        8, 16,
        WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
        NULL,
}, vga_25lscreen_bf = {
        "80x25bf", 80, 25,
        &vga_emulops,
        8, 16,
        WSSCREEN_WSCOLORS | WSSCREEN_BLINK,
        NULL,
}, vga_40lscreen = {
        "80x40", 80, 40,
        &vga_emulops,
        8, 10,
        WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
        NULL,
}, vga_40lscreen_mono = {
        "80x40", 80, 40,
        &vga_emulops,
        8, 10,
        WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
        NULL,
}, vga_40lscreen_bf = {
        "80x40bf", 80, 40,
        &vga_emulops,
        8, 10,
        WSSCREEN_WSCOLORS | WSSCREEN_BLINK,
        NULL,
}, vga_50lscreen = {
        "80x50", 80, 50,
        &vga_emulops,
        8, 8,
        WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
        NULL,
}, vga_50lscreen_mono = {
        "80x50", 80, 50,
        &vga_emulops,
        8, 8,
        WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
        NULL,
}, vga_50lscreen_bf = {
        "80x50bf", 80, 50,
        &vga_emulops,
        8, 8,
        WSSCREEN_WSCOLORS | WSSCREEN_BLINK,
        NULL,
}, vga_24lscreen = {
        "80x24", 80, 24,
        &vga_emulops,
        8, 16,
        WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
        NULL,
}, vga_24lscreen_mono = {
        "80x24", 80, 24,
        &vga_emulops,
        8, 16,
        WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
        NULL,
}, vga_24lscreen_bf = {
        "80x24bf", 80, 24,
        &vga_emulops,
        8, 16,
        WSSCREEN_WSCOLORS | WSSCREEN_BLINK,
        NULL,
};

#define VGA_SCREEN_CANTWOFONTS(type) (!((type)->capabilities & WSSCREEN_HILIT))

const struct wsscreen_descr *_vga_scrlist[] = {
        &vga_25lscreen,
        &vga_25lscreen_bf,
        &vga_40lscreen,
        &vga_40lscreen_bf,
        &vga_50lscreen,
        &vga_50lscreen_bf,
        &vga_24lscreen,
        &vga_24lscreen_bf,
        /* XXX other formats, graphics screen? */
}, *_vga_scrlist_mono[] = {
        &vga_25lscreen_mono,
        &vga_40lscreen_mono,
        &vga_50lscreen_mono,
        &vga_24lscreen_mono,
        /* XXX other formats, graphics screen? */
};

const struct wsscreen_list vga_screenlist = {
        sizeof(_vga_scrlist) / sizeof(struct wsscreen_descr *),
        _vga_scrlist
}, vga_screenlist_mono = {
        sizeof(_vga_scrlist_mono) / sizeof(struct wsscreen_descr *),
        _vga_scrlist_mono
};

static int      vga_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t  vga_mmap(void *, void *, off_t, int);
static int      vga_alloc_screen(void *, const struct wsscreen_descr *,
                                 void **, int *, int *, long *);
static void     vga_free_screen(void *, void *);
static int      vga_show_screen(void *, void *, int,
                                void (*)(void *, int, int), void *);
static int      vga_load_font(void *, void *, struct wsdisplay_font *);
#ifdef WSDISPLAY_CUSTOM_BORDER
static int      vga_getborder(struct vga_config *, u_int *);
static int      vga_setborder(struct vga_config *, u_int);
#endif /* WSDISPLAY_CUSTOM_BORDER */

static void vga_doswitch(struct vga_config *);
static void    vga_save_palette(struct vga_config *);
static void    vga_restore_palette(struct vga_config *);


const struct wsdisplay_accessops vga_accessops = {
        vga_ioctl,
        vga_mmap,
        vga_alloc_screen,
        vga_free_screen,
        vga_show_screen,
        vga_load_font,
        NULL,
#ifdef WSDISPLAY_SCROLLSUPPORT
        vga_scroll,
#else
        NULL,
#endif
};

/*
 * We want at least ASCII 32..127 be present in the
 * first font slot.
 */
#define vga_valid_primary_font(f) \
        (f->wsfont->encoding == WSDISPLAY_FONTENC_IBM || \
        f->wsfont->encoding == WSDISPLAY_FONTENC_ISO || \
        f->wsfont->encoding == WSDISPLAY_FONTENC_ISO2 || \
        f->wsfont->encoding == WSDISPLAY_FONTENC_ISO7 || \
        f->wsfont->encoding == WSDISPLAY_FONTENC_KOI8_R)

static struct egavga_font *
egavga_getfont(struct vga_config *vc, struct vgascreen *scr, const char *name,
               int primary)
{
        struct egavga_font *f;
        int cookie;
        struct wsdisplay_font *wf;

        TAILQ_FOREACH(f, &vc->vc_fontlist, next) {
                if (wsfont_matches(f->wsfont, name,
                    8, scr->pcs.type->fontheight, 0, WSFONT_FIND_BITMAP) &&
                    (!primary || vga_valid_primary_font(f))) {
#ifdef VGAFONTDEBUG
                        if (scr != &vga_console_screen || vga_console_attached)
                                printf("vga_getfont: %s already present\n",
                                    name ? name : "<default>");
#endif
                        goto found;
                }
        }

        cookie = wsfont_find(name, 8, scr->pcs.type->fontheight, 0,
            WSDISPLAY_FONTORDER_L2R, 0, WSFONT_FIND_BITMAP);
        /* XXX obey "primary" */
        if (cookie == -1) {
#ifdef VGAFONTDEBUG
                if (scr != &vga_console_screen || vga_console_attached)
                        printf("vga_getfont: %s not found\n",
                            name ? name : "<default>");
#endif
                return (0);
        }

        if (wsfont_lock(cookie, &wf))
                return (0);

#ifdef VGA_CONSOLE_SCREENTYPE
        if (scr == &vga_console_screen)
                f = &vga_consolefont;
        else
#endif
        f = malloc(sizeof(struct egavga_font), M_DEVBUF, M_WAITOK);
        f->wsfont = wf;
        f->cookie = cookie;
        f->slot = -1; /* not yet loaded */
        f->usecount = 0; /* incremented below */
        TAILQ_INSERT_TAIL(&vc->vc_fontlist, f, next);

found:
        f->usecount++;
#ifdef VGAFONTDEBUG
        if (scr != &vga_console_screen || vga_console_attached)
                printf("vga_getfont: usecount=%d\n", f->usecount);
#endif
        return (f);
}

static void
egavga_unreffont(struct vga_config *vc, struct egavga_font *f)
{

        f->usecount--;
#ifdef VGAFONTDEBUG
        printf("vga_unreffont: usecount=%d\n", f->usecount);
#endif
        if (f->usecount == 0 && f->cookie != -1) {
                TAILQ_REMOVE(&vc->vc_fontlist, f, next);
                if (f->slot != -1) {
                        KASSERT(vc->vc_fonts[f->slot] == f);
                        vc->vc_fonts[f->slot] = 0;
                }
                wsfont_unlock(f->cookie);
#ifdef VGA_CONSOLE_SCREENTYPE
                if (f != &vga_consolefont)
#endif
                free(f, M_DEVBUF);
        }
}

static int
vga_selectfont(struct vga_config *vc, struct vgascreen *scr, const char *name1,
               const char *name2)
{
        const struct wsscreen_descr *type = scr->pcs.type;
        struct egavga_font *f1, *f2;

        f1 = egavga_getfont(vc, scr, name1, 1);
        if (!f1)
                return (ENXIO);

        if (VGA_SCREEN_CANTWOFONTS(type) && name2) {
                f2 = egavga_getfont(vc, scr, name2, 0);
                if (!f2) {
                        egavga_unreffont(vc, f1);
                        return (ENXIO);
                }
        } else
                f2 = 0;

#ifdef VGAFONTDEBUG
        if (scr != &vga_console_screen || vga_console_attached) {
                printf("vga (%s): font1=%s (slot %d)", type->name,
                    f1->wsfont->name, f1->slot);
                if (f2)
                        printf(", font2=%s (slot %d)",
                            f2->wsfont->name, f2->slot);
                printf("\n");
        }
#endif
        if (scr->fontset1)
                egavga_unreffont(vc, scr->fontset1);
        scr->fontset1 = f1;
        if (scr->fontset2)
                egavga_unreffont(vc, scr->fontset2);
        scr->fontset2 = f2;
        return (0);
}

static void
vga_init_screen(struct vga_config *vc, struct vgascreen *scr,
                const struct wsscreen_descr *type, int existing, long *attrp)
{
        int cpos;
        int res __diagused;

        scr->cfg = vc;
        scr->pcs.hdl = (struct pcdisplay_handle *)&vc->hdl;
        scr->pcs.type = type;
        scr->pcs.active = existing;
        scr->mindispoffset = 0;
        if (vc->vc_quirks & VGA_QUIRK_NOFASTSCROLL)
                scr->maxdispoffset = 0;
        else
                scr->maxdispoffset = 0x8000 - type->nrows * type->ncols * 2;

        if (existing) {
                vc->active = scr;

                cpos = vga_6845_read(&vc->hdl, cursorh) << 8;
                cpos |= vga_6845_read(&vc->hdl, cursorl);

                /* make sure we have a valid cursor position */
                if (cpos < 0 || cpos >= type->nrows * type->ncols)
                        cpos = 0;

                scr->pcs.dispoffset = vga_6845_read(&vc->hdl, startadrh) << 9;
                scr->pcs.dispoffset |= vga_6845_read(&vc->hdl, startadrl) << 1;

                /* make sure we have a valid memory offset */
                if (scr->pcs.dispoffset < scr->mindispoffset ||
                    scr->pcs.dispoffset > scr->maxdispoffset)
                        scr->pcs.dispoffset = scr->mindispoffset;

                if (type != vc->currenttype) {
                        vga_setscreentype(&vc->hdl, type);
                        vc->currenttype = type;
                }
        } else {
                cpos = 0;
                scr->pcs.dispoffset = scr->mindispoffset;
        }

        scr->pcs.visibleoffset = scr->pcs.dispoffset;
        scr->vga_rollover = 0;

        scr->pcs.cursorrow = cpos / type->ncols;
        scr->pcs.cursorcol = cpos % type->ncols;
        pcdisplay_cursor_init(&scr->pcs, existing);

#ifdef __alpha__
        if (!vc->hdl.vh_mono)
                /*
                 * DEC firmware uses a blue background.
                 * XXX These should be specified as kernel options for
                 * XXX alpha only, not hardcoded here (which is wrong
                 * XXX anyway because the emulation layer will assume
                 * XXX the default attribute is white on black).
                 */
                res = vga_allocattr(scr, WSCOL_WHITE, WSCOL_BLUE,
                    WSATTR_WSCOLORS, attrp);
        else
#endif
        res = vga_allocattr(scr, 0, 0, 0, attrp);
#ifdef DIAGNOSTIC
        if (res)
                panic("vga_init_screen: attribute botch");
#endif

        scr->pcs.mem = NULL;

        scr->fontset1 = scr->fontset2 = 0;
        if (vga_selectfont(vc, scr, 0, 0)) {
                if (scr == &vga_console_screen)
                        panic("vga_init_screen: no font");
                else
                        printf("vga_init_screen: no font\n");
        }
        if (existing)
                vga_setfont(vc, scr);

        vc->nscreens++;
        LIST_INSERT_HEAD(&vc->screens, scr, next);
}

static void
vga_init(struct vga_config *vc, bus_space_tag_t iot, bus_space_tag_t memt)
{
        struct vga_handle *vh = &vc->hdl;
        uint8_t mor;
        int i;

        vh->vh_iot = iot;
        vh->vh_memt = memt;

        if (bus_space_map(vh->vh_iot, 0x3c0, 0x10, 0, &vh->vh_ioh_vga))
                panic("vga_init: couldn't map vga io");

        /* read "misc output register" */
        mor = vga_raw_read(vh, VGA_MISC_DATAR);
        vh->vh_mono = !(mor & 1);

        if (bus_space_map(vh->vh_iot, (vh->vh_mono ? 0x3b0 : 0x3d0), 0x10, 0,
            &vh->vh_ioh_6845))
                panic("vga_init: couldn't map 6845 io");

        if (bus_space_map(vh->vh_memt, 0xa0000, 0x20000, 
            BUS_SPACE_MAP_CACHEABLE, &vh->vh_allmemh))
                panic("vga_init: couldn't map memory");

        if (bus_space_subregion(vh->vh_memt, vh->vh_allmemh,
            (vh->vh_mono ? 0x10000 : 0x18000), 0x8000, &vh->vh_memh))
                panic("vga_init: mem subrange failed");

        vc->nscreens = 0;
        LIST_INIT(&vc->screens);
        vc->active = NULL;
        vc->currenttype = vh->vh_mono ? &vga_25lscreen_mono : &vga_25lscreen;
        callout_init(&vc->vc_switch_callout, 0);

        wsfont_init();
        if (vga_no_builtinfont) {
                struct wsdisplay_font *wf;
                int cookie;

                cookie = wsfont_find(NULL, 8, 16, 0,
                     WSDISPLAY_FONTORDER_L2R, 0, WSFONT_FIND_BITMAP);
                if (cookie == -1 || wsfont_lock(cookie, &wf))
                        panic("vga_init: can't load console font");
                vga_loadchars(&vc->hdl, 0, wf->firstchar, wf->numchars,
                    wf->fontheight, wf->data);
                vga_builtinfont.wsfont = wf;
                vga_builtinfont.cookie = cookie;
                vga_builtinfont.slot = 0;
        }
        vc->vc_fonts[0] = &vga_builtinfont;
        for (i = 1; i < 8; i++)
                vc->vc_fonts[i] = 0;
        TAILQ_INIT(&vc->vc_fontlist);
        TAILQ_INSERT_HEAD(&vc->vc_fontlist, &vga_builtinfont, next);

        vc->currentfontset1 = vc->currentfontset2 = 0;

        if (!vh->vh_mono && (u_int)WSDISPLAY_BORDER_COLOR < sizeof(fgansitopc))
                _vga_attr_write(vh, VGA_ATC_OVERSCAN,
                                fgansitopc[WSDISPLAY_BORDER_COLOR]);
        vga_save_palette(vc);
}

void
vga_common_attach(struct vga_softc *sc, bus_space_tag_t iot,
                  bus_space_tag_t memt, int type, int quirks,
                  const struct vga_funcs *vf)
{
        int console;
        struct vga_config *vc;
        struct wsemuldisplaydev_attach_args aa;

        console = vga_is_console(iot, type);

        if (console) {
                vc = &vga_console_vc;
                vga_console_attached = 1;
        } else {
                vc = malloc(sizeof(struct vga_config), M_DEVBUF, M_WAITOK);
                vga_init(vc, iot, memt);
        }

        if (quirks & VGA_QUIRK_ONEFONT) {
                vc->vc_nfontslots = 1;
#ifndef VGA_CONSOLE_ATI_BROKEN_FONTSEL
                /*
                 * XXX maybe invalidate font in slot > 0, but this can
                 * only be happen with VGA_CONSOLE_SCREENTYPE, and then
                 * we require VGA_CONSOLE_ATI_BROKEN_FONTSEL anyway.
                 */
#endif
        } else {
                vc->vc_nfontslots = 8;
#ifndef VGA_CONSOLE_ATI_BROKEN_FONTSEL
                /*
                 * XXX maybe validate builtin font shifted to slot 1 if
                 * slot 0 got overwritten because of VGA_CONSOLE_SCREENTYPE,
                 * but it will be reloaded anyway if needed.
                 */
#endif
        }

        /*
         * Save the builtin font to memory. In case it got overwritten
         * in console initialization, use the copy in slot 1.
         */
#ifdef VGA_CONSOLE_ATI_BROKEN_FONTSEL
#define BUILTINFONTLOC (vga_builtinfont.slot == -1 ? 1 : 0)
#else
        KASSERT(vga_builtinfont.slot == 0);
#define BUILTINFONTLOC (0)
#endif
        if (!vga_no_builtinfont) {
                char *data =
                    malloc(256 * vga_builtinfont.wsfont->fontheight,
                    M_DEVBUF, M_WAITOK);
                vga_readoutchars(&vc->hdl, BUILTINFONTLOC, 0, 256,
                    vga_builtinfont.wsfont->fontheight, data);
                vga_builtinfont.wsfont->data = data;
        }

        vc->vc_type = type;
        vc->vc_funcs = vf;
        vc->vc_quirks = quirks;

        sc->sc_vc = vc;
        vc->softc = sc;

        aa.console = console;
        aa.scrdata = (vc->hdl.vh_mono ? &vga_screenlist_mono : &vga_screenlist);
        aa.accessops = &vga_accessops;
        aa.accesscookie = vc;

        config_found(sc->sc_dev, &aa, wsemuldisplaydevprint,
            CFARGS(.iattr = "wsemuldisplaydev"));
}

int
vga_cnattach(bus_space_tag_t iot, bus_space_tag_t memt, int type, int check)
{
        long defattr;
        const struct wsscreen_descr *scr;

        if (check && !vga_common_probe(iot, memt))
                return (ENXIO);

        /* set up bus-independent VGA configuration */
        vga_init(&vga_console_vc, iot, memt);
#ifdef VGA_CONSOLE_SCREENTYPE
        scr = wsdisplay_screentype_pick(vga_console_vc.hdl.vh_mono ?
            &vga_screenlist_mono : &vga_screenlist, VGA_CONSOLE_SCREENTYPE);
        if (!scr)
                panic("vga_cnattach: invalid screen type");
#else
        scr = vga_console_vc.currenttype;
#endif
#ifdef VGA_CONSOLE_ATI_BROKEN_FONTSEL
        /*
         * On some (most/all?) ATI cards, only font slot 0 is usable.
         * vga_init_screen() might need font slot 0 for a non-default
         * console font, so save the builtin VGA font to another font slot.
         * The attach() code will take care later.
         */
        vga_console_vc.vc_quirks |= VGA_QUIRK_ONEFONT; /* redundant */
        vga_copyfont01(&vga_console_vc.hdl);
        vga_console_vc.vc_nfontslots = 1;
#else
        vga_console_vc.vc_nfontslots = 8;
#endif
#ifdef notdef
        /* until we know better, assume "fast scrolling" does not work */
        vga_console_vc.vc_quirks |= VGA_QUIRK_NOFASTSCROLL;
#endif

        vga_init_screen(&vga_console_vc, &vga_console_screen, scr, 1, &defattr);

        wsdisplay_cnattach(scr, &vga_console_screen,
            vga_console_screen.pcs.cursorcol,
            vga_console_screen.pcs.cursorrow, defattr);

        vgaconsole = 1;
        vga_console_type = type;
        return (0);
}

int
vga_cndetach(void)
{
        struct vga_config *vc;
        struct vga_handle *vh;

        vc = &vga_console_vc;
        vh = &vc->hdl;

        if (vgaconsole) {
                wsdisplay_cndetach();

                bus_space_unmap(vh->vh_iot, vh->vh_ioh_vga, 0x10);
                bus_space_unmap(vh->vh_iot, vh->vh_ioh_6845, 0x10);
                bus_space_unmap(vh->vh_memt, vh->vh_allmemh, 0x20000);

                vga_console_attached = 0;
                vgaconsole = 0;

                return 1;
        }

        return 0;
}

int
vga_is_console(bus_space_tag_t iot, int type)
{
        if (vgaconsole &&
            !vga_console_attached &&
            bus_space_is_equal(iot, vga_console_vc.hdl.vh_iot) &&
            (vga_console_type == -1 || (type == vga_console_type)))
                return (1);
        return (0);
}

static int
vga_get_video(struct vga_config *vc)
{

        return (vga_ts_read(&vc->hdl, mode) & VGA_TS_MODE_BLANK) == 0;
}

static void
vga_set_video(struct vga_config *vc, int state)
{
        int val;

        vga_ts_write(&vc->hdl, syncreset, 0x01);
        if (state) {                                    /* unblank screen */
                val = vga_ts_read(&vc->hdl, mode);
                vga_ts_write(&vc->hdl, mode, val & ~VGA_TS_MODE_BLANK);
#ifndef VGA_NO_VBLANK
                val = vga_6845_read(&vc->hdl, mode);
                vga_6845_write(&vc->hdl, mode, val | 0x80);
#endif
        } else {                                        /* blank screen */
                val = vga_ts_read(&vc->hdl, mode);
                vga_ts_write(&vc->hdl, mode, val | VGA_TS_MODE_BLANK);
#ifndef VGA_NO_VBLANK
                val = vga_6845_read(&vc->hdl, mode);
                vga_6845_write(&vc->hdl, mode, val & ~0x80);
#endif
        }
        vga_ts_write(&vc->hdl, syncreset, 0x03);
}

static int
vga_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
{
        struct vga_config *vc = v;
        struct vgascreen *scr = vs;
        const struct vga_funcs *vf = vc->vc_funcs;

        switch (cmd) {
        case WSDISPLAYIO_SMODE:
                if (*(u_int *)data == WSDISPLAYIO_MODE_EMUL)
                        vga_restore_palette(vc);
                return 0;

        case WSDISPLAYIO_GTYPE:
                *(int *)data = vc->vc_type;
                return 0;

        case WSDISPLAYIO_GINFO:
                /* XXX should get detailed hardware information here */
                return EPASSTHROUGH;

        case WSDISPLAYIO_GVIDEO:
                *(int *)data = (vga_get_video(vc) ?
                    WSDISPLAYIO_VIDEO_ON : WSDISPLAYIO_VIDEO_OFF);
                return 0;

        case WSDISPLAYIO_SVIDEO:
                vga_set_video(vc, *(int *)data == WSDISPLAYIO_VIDEO_ON);
                return 0;

        case WSDISPLAYIO_GETWSCHAR:
                KASSERT(scr != NULL);
                return pcdisplay_getwschar(&scr->pcs,
                    (struct wsdisplay_char *)data);

        case WSDISPLAYIO_PUTWSCHAR:
                KASSERT(scr != NULL);
                return pcdisplay_putwschar(&scr->pcs,
                    (struct wsdisplay_char *)data);

#ifdef WSDISPLAY_CUSTOM_BORDER
        case WSDISPLAYIO_GBORDER:
                return (vga_getborder(vc, (u_int *)data));

        case WSDISPLAYIO_SBORDER:
                return (vga_setborder(vc, *(u_int *)data));
#endif

        case WSDISPLAYIO_GETCMAP:
        case WSDISPLAYIO_PUTCMAP:
        case WSDISPLAYIO_GCURPOS:
        case WSDISPLAYIO_SCURPOS:
        case WSDISPLAYIO_GCURMAX:
        case WSDISPLAYIO_GCURSOR:
        case WSDISPLAYIO_SCURSOR:
                /* NONE of these operations are by the generic VGA driver. */
                return EPASSTHROUGH;
        }

        if (vc->vc_funcs == NULL)
                return (EPASSTHROUGH);

        if (vf->vf_ioctl == NULL)
                return (EPASSTHROUGH);

        return ((*vf->vf_ioctl)(v, cmd, data, flag, l));
}

static paddr_t
vga_mmap(void *v, void *vs, off_t offset, int prot)
{
        struct vga_config *vc = v;
        const struct vga_funcs *vf = vc->vc_funcs;

        if (vc->vc_funcs == NULL)
                return (-1);

        if (vf->vf_mmap == NULL)
                return (-1);

        return ((*vf->vf_mmap)(v, offset, prot));
}

static int
vga_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
                 int *curxp, int *curyp, long *defattrp)
{
        struct vga_config *vc = v;
        struct vgascreen *scr;

        if (vc->nscreens == 1) {
                struct vgascreen *scr1 = vc->screens.lh_first;
                /*
                 * When allocating the second screen, get backing store
                 * for the first one too.
                 * XXX We could be more clever and use video RAM.
                 */
                scr1->pcs.mem =
                    malloc(scr1->pcs.type->ncols * scr1->pcs.type->nrows * 2,
                    M_DEVBUF, M_WAITOK);
        }

        scr = malloc(sizeof(struct vgascreen), M_DEVBUF, M_WAITOK);
        vga_init_screen(vc, scr, type, vc->nscreens == 0, defattrp);

        if (vc->nscreens > 1) {
                scr->pcs.mem = malloc(type->ncols * type->nrows * 2,
                    M_DEVBUF, M_WAITOK);
                pcdisplay_eraserows(&scr->pcs, 0, type->nrows, *defattrp);
        }

        *cookiep = scr;
        *curxp = scr->pcs.cursorcol;
        *curyp = scr->pcs.cursorrow;

        return (0);
}

static void
vga_free_screen(void *v, void *cookie)
{
        struct vgascreen *vs = cookie;
        struct vga_config *vc = vs->cfg;

        LIST_REMOVE(vs, next);
        vc->nscreens--;
        if (vs->fontset1)
                egavga_unreffont(vc, vs->fontset1);
        if (vs->fontset2)
                egavga_unreffont(vc, vs->fontset2);

        if (vs != &vga_console_screen)
                free(vs, M_DEVBUF);
        else
                panic("vga_free_screen: console");

        if (vc->active == vs)
                vc->active = 0;
}

static void vga_usefont(struct vga_config *, struct egavga_font *);

static void
vga_usefont(struct vga_config *vc, struct egavga_font *f)
{
        int slot;
        struct egavga_font *of;

        if (f->slot != -1)
                goto toend;

        for (slot = 0; slot < vc->vc_nfontslots; slot++) {
                if (!vc->vc_fonts[slot])
                        goto loadit;
        }

        /* have to kick out another one */
        TAILQ_FOREACH(of, &vc->vc_fontlist, next) {
                if (of->slot != -1) {
                        KASSERT(vc->vc_fonts[of->slot] == of);
                        slot = of->slot;
                        of->slot = -1;
                        goto loadit;
                }
        }
        panic("vga_usefont");

loadit:
        vga_loadchars(&vc->hdl, slot, f->wsfont->firstchar,
            f->wsfont->numchars, f->wsfont->fontheight, f->wsfont->data);
        f->slot = slot;
        vc->vc_fonts[slot] = f;

toend:
        TAILQ_REMOVE(&vc->vc_fontlist, f, next);
        TAILQ_INSERT_TAIL(&vc->vc_fontlist, f, next);
}

static void
vga_setfont(struct vga_config *vc, struct vgascreen *scr)
{
        int fontslot1, fontslot2;

        if (scr->fontset1)
                vga_usefont(vc, scr->fontset1);
        if (scr->fontset2)
                vga_usefont(vc, scr->fontset2);

        fontslot1 = (scr->fontset1 ? scr->fontset1->slot : 0);
        fontslot2 = (scr->fontset2 ? scr->fontset2->slot : fontslot1);
        if (vc->currentfontset1 != fontslot1 ||
            vc->currentfontset2 != fontslot2) {
                vga_setfontset(&vc->hdl, fontslot1, fontslot2);
                vc->currentfontset1 = fontslot1;
                vc->currentfontset2 = fontslot2;
        }
}

static int
vga_show_screen(void *v, void *cookie, int waitok,
                void (*cb)(void *, int, int), void *cbarg)
{
        struct vgascreen *scr = cookie, *oldscr;
        struct vga_config *vc = scr->cfg;

        oldscr = vc->active; /* can be NULL! */
        if (scr == oldscr) {
                return (0);
        }

        vc->wantedscreen = cookie;
        vc->switchcb = cb;
        vc->switchcbarg = cbarg;
        if (cb) {
                callout_reset(&vc->vc_switch_callout, 0,
                    (void(*)(void *))vga_doswitch, vc);
                return (EAGAIN);
        }

        vga_doswitch(vc);
        return (0);
}

static void
vga_doswitch(struct vga_config *vc)
{
        struct vgascreen *scr, *oldscr;
        struct vga_handle *vh = &vc->hdl;
        const struct wsscreen_descr *type;

        scr = vc->wantedscreen;
        if (!scr) {
                printf("vga_doswitch: disappeared\n");
                (*vc->switchcb)(vc->switchcbarg, EIO, 0);
                return;
        }
        type = scr->pcs.type;
        oldscr = vc->active; /* can be NULL! */
#ifdef DIAGNOSTIC
        if (oldscr) {
                if (!oldscr->pcs.active)
                        panic("vga_show_screen: not active");
                if (oldscr->pcs.type != vc->currenttype)
                        panic("vga_show_screen: bad type");
        }
#endif
        if (scr == oldscr) {
                return;
        }
#ifdef DIAGNOSTIC
        if (scr->pcs.active)
                panic("vga_show_screen: active");
#endif

        if (oldscr) {
                const struct wsscreen_descr *oldtype = oldscr->pcs.type;

                oldscr->pcs.active = 0;
                bus_space_read_region_2(vh->vh_memt, vh->vh_memh,
                    oldscr->pcs.dispoffset, oldscr->pcs.mem,
                    oldtype->ncols * oldtype->nrows);
        }

        if (vc->currenttype != type) {
                vga_setscreentype(vh, type);
                vc->currenttype = type;
        }

        vga_setfont(vc, scr);
        vga_restore_palette(vc);

        scr->pcs.visibleoffset = scr->pcs.dispoffset = scr->mindispoffset;
        if (!oldscr || (scr->pcs.dispoffset != oldscr->pcs.dispoffset)) {
                vga_6845_write(vh, startadrh, scr->pcs.dispoffset >> 9);
                vga_6845_write(vh, startadrl, scr->pcs.dispoffset >> 1);
        }

        bus_space_write_region_2(vh->vh_memt, vh->vh_memh,
            scr->pcs.dispoffset, scr->pcs.mem, type->ncols * type->nrows);
        scr->pcs.active = 1;

        vc->active = scr;

        pcdisplay_cursor(&scr->pcs, scr->pcs.cursoron,
            scr->pcs.cursorrow, scr->pcs.cursorcol);

        vc->wantedscreen = 0;
        if (vc->switchcb)
                (*vc->switchcb)(vc->switchcbarg, 0, 0);
}

static int
vga_load_font(void *v, void *cookie, struct wsdisplay_font *data)
{
        struct vga_config *vc = v;
        struct vgascreen *scr = cookie;
        char *name2;
        int res;

        if (scr) {
                name2 = NULL;
                if (data->name) {
                        name2 = strchr(data->name, ',');
                        if (name2)
                                *name2++ = '\0';
                }
                res = vga_selectfont(vc, scr, data->name, name2);
                if (!res && scr->pcs.active)
                        vga_setfont(vc, scr);
                return (res);
        }

        return (0);
}

static int
vga_allocattr(void *id, int fg, int bg, int flags, long *attrp)
{
        struct vgascreen *scr = id;
        struct vga_config *vc = scr->cfg;

        if (__predict_false((unsigned int)fg >= sizeof(fgansitopc) || 
            (unsigned int)bg >= sizeof(bgansitopc)))
                return (EINVAL);

        if (vc->hdl.vh_mono) {
                if (flags & WSATTR_WSCOLORS)
                        return (EINVAL);
                if (flags & WSATTR_REVERSE)
                        *attrp = 0x70;
                else
                        *attrp = 0x07;
                if (flags & WSATTR_UNDERLINE)
                        *attrp |= FG_UNDERLINE;
                if (flags & WSATTR_HILIT)
                        *attrp |= FG_INTENSE;
        } else {
                if (flags & (WSATTR_UNDERLINE | WSATTR_REVERSE))
                        return (EINVAL);
                if (flags & WSATTR_WSCOLORS)
                        *attrp = fgansitopc[fg] | bgansitopc[bg];
                else
                        *attrp = 7;
                if (flags & WSATTR_HILIT)
                        *attrp += 8;
        }
        if (flags & WSATTR_BLINK)
                *attrp |= FG_BLINK;
        return (0);
}

static void
vga_copyrows(void *id, int srcrow, int dstrow, int nrows)
{
        struct vgascreen *scr = id;
        bus_space_tag_t memt = scr->pcs.hdl->ph_memt;
        bus_space_handle_t memh = scr->pcs.hdl->ph_memh;
        int ncols = scr->pcs.type->ncols;
        bus_size_t srcoff, dstoff;

        srcoff = srcrow * ncols + 0;
        dstoff = dstrow * ncols + 0;

        if (scr->pcs.active) {
                if (dstrow == 0 && (srcrow + nrows == scr->pcs.type->nrows)) {
#ifdef PCDISPLAY_SOFTCURSOR
                        int cursoron = scr->pcs.cursoron;

                        if (cursoron)
                                pcdisplay_cursor(&scr->pcs, 0,
                                    scr->pcs.cursorrow, scr->pcs.cursorcol);
#endif
                        /* scroll up whole screen */
                        if ((scr->pcs.dispoffset + srcrow * ncols * 2)
                            <= scr->maxdispoffset) {
                                scr->pcs.dispoffset += srcrow * ncols * 2;
                        } else {
                                bus_space_copy_region_2(memt, memh,
                                    scr->pcs.dispoffset + srcoff * 2,
                                    memh, scr->mindispoffset, nrows * ncols);
                                scr->pcs.dispoffset = scr->mindispoffset;
                        }
                        vga_6845_write(&scr->cfg->hdl, startadrh,
                            scr->pcs.dispoffset >> 9);
                        vga_6845_write(&scr->cfg->hdl, startadrl,
                            scr->pcs.dispoffset >> 1);
#ifdef PCDISPLAY_SOFTCURSOR
                        if (cursoron)
                                pcdisplay_cursor(&scr->pcs, 1,
                                    scr->pcs.cursorrow, scr->pcs.cursorcol);
#endif
                } else {
                        bus_space_copy_region_2(memt, memh,
                            scr->pcs.dispoffset + srcoff * 2,
                            memh, scr->pcs.dispoffset + dstoff * 2,
                            nrows * ncols);
                }
        } else
                memcpy(&scr->pcs.mem[dstoff], &scr->pcs.mem[srcoff],
                    nrows * ncols * 2);
}

#ifdef WSCONS_SUPPORT_PCVTFONTS

#define NOTYET 0xffff
static const uint16_t pcvt_unichars[0xa0] = {
/* 0 */ _e006U, /* N/L control */
        NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET,
        NOTYET,
        0x2409, /* SYMBOL FOR HORIZONTAL TABULATION */
        0x240a, /* SYMBOL FOR LINE FEED */
        0x240b, /* SYMBOL FOR VERTICAL TABULATION */
        0x240c, /* SYMBOL FOR FORM FEED */
        0x240d, /* SYMBOL FOR CARRIAGE RETURN */
        NOTYET, NOTYET,
/* 1 */ NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET,
        NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET,
/* 2 */ NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET,
        NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET,
/* 3 */ NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET,
        NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET, NOTYET,
/* 4 */ 0x03c1, /* GREEK SMALL LETTER RHO */
        0x03c8, /* GREEK SMALL LETTER PSI */
        0x2202, /* PARTIAL DIFFERENTIAL */
        0x03bb, /* GREEK SMALL LETTER LAMDA */
        0x03b9, /* GREEK SMALL LETTER IOTA */
        0x03b7, /* GREEK SMALL LETTER ETA */
        0x03b5, /* GREEK SMALL LETTER EPSILON */
        0x03c7, /* GREEK SMALL LETTER CHI */
        0x2228, /* LOGICAL OR */
        0x2227, /* LOGICAL AND */
        0x222a, /* UNION */
        0x2283, /* SUPERSET OF */
        0x2282, /* SUBSET OF */
        0x03a5, /* GREEK CAPITAL LETTER UPSILON */
        0x039e, /* GREEK CAPITAL LETTER XI */
        0x03a8, /* GREEK CAPITAL LETTER PSI */
/* 5 */ 0x03a0, /* GREEK CAPITAL LETTER PI */
        0x21d2, /* RIGHTWARDS DOUBLE ARROW */
        0x21d4, /* LEFT RIGHT DOUBLE ARROW */
        0x039b, /* GREEK CAPITAL LETTER LAMDA */
        0x0398, /* GREEK CAPITAL LETTER THETA */
        0x2243, /* ASYMPTOTICALLY EQUAL TO */
        0x2207, /* NABLA */
        0x2206, /* INCREMENT */
        0x221d, /* PROPORTIONAL TO */
        0x2234, /* THEREFORE */
        0x222b, /* INTEGRAL */
        0x2215, /* DIVISION SLASH */
        0x2216, /* SET MINUS */
        _e00eU, /* angle? */
        _e00dU, /* inverted angle? */
        _e00bU, /* braceleftmid */
/* 6 */ _e00cU, /* bracerightmid */
        _e007U, /* bracelefttp */
        _e008U, /* braceleftbt */
        _e009U, /* bracerighttp */
        _e00aU, /* bracerightbt */
        0x221a, /* SQUARE ROOT */
        0x03c9, /* GREEK SMALL LETTER OMEGA */
        0x00a5, /* YEN SIGN */
        0x03be, /* GREEK SMALL LETTER XI */
        0x00fd, /* LATIN SMALL LETTER Y WITH ACUTE */
        0x00fe, /* LATIN SMALL LETTER THORN */
        0x00f0, /* LATIN SMALL LETTER ETH */
        0x00de, /* LATIN CAPITAL LETTER THORN */
        0x00dd, /* LATIN CAPITAL LETTER Y WITH ACUTE */
        0x00d7, /* MULTIPLICATION SIGN */
        0x00d0, /* LATIN CAPITAL LETTER ETH */
/* 7 */ 0x00be, /* VULGAR FRACTION THREE QUARTERS */
        0x00b8, /* CEDILLA */
        0x00b4, /* ACUTE ACCENT */
        0x00af, /* MACRON */
        0x00ae, /* REGISTERED SIGN */
        0x00ad, /* SOFT HYPHEN */
        0x00ac, /* NOT SIGN */
        0x00a8, /* DIAERESIS */
        0x2260, /* NOT EQUAL TO */
        0x23bd, /* scan 9 */
        0x23bc, /* scan 7 */
        0x2500, /* scan 5 */
        0x23bb, /* scan 3 */
        0x23ba, /* scan 1 */
        0x03c5, /* GREEK SMALL LETTER UPSILON */
        0x00f8, /* LATIN SMALL LETTER O WITH STROKE */
/* 8 */ 0x0153, /* LATIN SMALL LIGATURE OE */
        0x00f5, /* LATIN SMALL LETTER O WITH TILDE !!!doc bug */
        0x00e3, /* LATIN SMALL LETTER A WITH TILDE */
        0x0178, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
        0x00db, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
        0x00da, /* LATIN CAPITAL LETTER U WITH ACUTE */
        0x00d9, /* LATIN CAPITAL LETTER U WITH GRAVE */
        0x00d8, /* LATIN CAPITAL LETTER O WITH STROKE */
        0x0152, /* LATIN CAPITAL LIGATURE OE */
        0x00d5, /* LATIN CAPITAL LETTER O WITH TILDE */
        0x00d4, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
        0x00d3, /* LATIN CAPITAL LETTER O WITH ACUTE */
        0x00d2, /* LATIN CAPITAL LETTER O WITH GRAVE */
        0x00cf, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
        0x00ce, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
        0x00cd, /* LATIN CAPITAL LETTER I WITH ACUTE */
/* 9 */ 0x00cc, /* LATIN CAPITAL LETTER I WITH GRAVE */
        0x00cb, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
        0x00ca, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
        0x00c8, /* LATIN CAPITAL LETTER E WITH GRAVE */
        0x00c3, /* LATIN CAPITAL LETTER A WITH TILDE */
        0x00c2, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
        0x00c1, /* LATIN CAPITAL LETTER A WITH ACUTE */
        0x00c0, /* LATIN CAPITAL LETTER A WITH GRAVE */
        0x00b9, /* SUPERSCRIPT ONE */
        0x00b7, /* MIDDLE DOT */
        0x03b6, /* GREEK SMALL LETTER ZETA */
        0x00b3, /* SUPERSCRIPT THREE */
        0x00a9, /* COPYRIGHT SIGN */
        0x00a4, /* CURRENCY SIGN */
        0x03ba, /* GREEK SMALL LETTER KAPPA */
        _e000U  /* mirrored question mark? */
};

static int vga_pcvt_mapchar(int, u_int *);

static int
vga_pcvt_mapchar(int uni, u_int *index)
{
        int i;

        for (i = 0; i < 0xa0; i++) /* 0xa0..0xff are reserved */
                if (uni == pcvt_unichars[i]) {
                        *index = i;
                        return (5);
                }
        *index = 0x99; /* middle dot */
        return (0);
}

#endif /* WSCONS_SUPPORT_PCVTFONTS */

#ifdef WSCONS_SUPPORT_ISO7FONTS

static int
vga_iso7_mapchar(int uni, u_int *index)
{

        /*
         * U+0384 (GREEK TONOS) to
         * U+03ce (GREEK SMALL LETTER OMEGA WITH TONOS)
         * map directly to the iso-9 font
         */
        if (uni >= 0x0384 && uni <= 0x03ce) {
                /* U+0384 is at offset 0xb4 in the font */
                *index = uni - 0x0384 + 0xb4;
                return (5);
        }

        /* XXX more chars in the iso-9 font */

        *index = 0xa4; /* shaded rectangle */
        return (0);
}

#endif /* WSCONS_SUPPORT_ISO7FONTS */

static const uint16_t iso2_unichars[0x60] = {
        0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
        0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
        0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
        0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
        0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
        0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
        0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
        0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
        0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
        0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
        0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
        0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
};

static const uint16_t koi8_unichars[0x40] = {
        0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
        0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
        0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
        0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
        0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
        0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
        0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
        0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A
};

static int _vga_mapchar(void *, const struct egavga_font *, int, u_int *);

static int
_vga_mapchar(void *id, const struct egavga_font *font, int uni, u_int *index)
{

        switch (font->wsfont->encoding) {
        case WSDISPLAY_FONTENC_ISO:
                if (uni < 256) {
                        *index = uni;
                        return (5);
                } else {
                        *index = ' ';
                        return (0);
                }
        case WSDISPLAY_FONTENC_ISO2:
                if (uni < 0xa0) {
                        *index = uni;
                        return (5);
                } else {
                        int i;
                        for (i = 0; i < 0x60; i++) {
                                if (uni == iso2_unichars[i]) {
                                        *index = i + 0xa0;
                                        return (5);
                                }
                        }
                        *index = 0xa4; /* currency sign */
                        return (0);
                }
        case WSDISPLAY_FONTENC_KOI8_R:
                if (uni < 0x80) {
                        *index = uni;
                        return (5);
                } else {
                        int i;
                        for (i = 0; i < 0x40; i++) {
                                if (uni == koi8_unichars[i]) {
                                        *index = i + 0xc0;
                                        return (5);
                                }
                        }
                        *index = 0x94; /* box */
                        return (0);
                }
        case WSDISPLAY_FONTENC_IBM:
                return (pcdisplay_mapchar(id, uni, index));
#ifdef WSCONS_SUPPORT_PCVTFONTS
        case WSDISPLAY_FONTENC_PCVT:
                return (vga_pcvt_mapchar(uni, index));
#endif
#ifdef WSCONS_SUPPORT_ISO7FONTS
        case WSDISPLAY_FONTENC_ISO7:
                return (vga_iso7_mapchar(uni, index));
#endif
        default:
#ifdef VGAFONTDEBUG
                printf("_vga_mapchar: encoding=%d\n", font->wsfont->encoding);
#endif
                *index = ' ';
                return (0);
        }
}

static int
vga_mapchar(void *id, int uni, u_int *index)
{
        struct vgascreen *scr = id;
        u_int idx1, idx2;
        int res1, res2;

        res1 = 0;
        idx1 = ' '; /* space */
        if (scr->fontset1)
                res1 = _vga_mapchar(id, scr->fontset1, uni, &idx1);
        res2 = -1;
        if (scr->fontset2) {
                KASSERT(VGA_SCREEN_CANTWOFONTS(scr->pcs.type));
                res2 = _vga_mapchar(id, scr->fontset2, uni, &idx2);
        }
        if (res2 > res1) {
                *index = idx2 | 0x0800; /* attribute bit 3 */
                return (res2);
        }
        *index = idx1;
        return (res1);
}

#ifdef WSDISPLAY_SCROLLSUPPORT
static void
vga_scroll(void *v, void *cookie, int lines)
{
        struct vga_config *vc = v;
        struct vgascreen *scr = cookie;
        struct vga_handle *vh = &vc->hdl;

        if (lines == 0) {
                if (scr->pcs.visibleoffset == scr->pcs.dispoffset)
                        return;

                scr->pcs.visibleoffset = scr->pcs.dispoffset;
        }
        else {
                int vga_scr_end;
                int margin = scr->pcs.type->ncols * 2;
                int ul, we, p, st;

                vga_scr_end = (scr->pcs.dispoffset + scr->pcs.type->ncols *
                    scr->pcs.type->nrows * 2);
                if (scr->vga_rollover > vga_scr_end + margin) {
                        ul = vga_scr_end;
                        we = scr->vga_rollover + scr->pcs.type->ncols * 2;
                } else {
                        ul = 0;
                        we = 0x8000;
                }
                p = (scr->pcs.visibleoffset - ul + we) % we + lines *
                    (scr->pcs.type->ncols * 2);
                st = (scr->pcs.dispoffset - ul + we) % we;
                if (p < margin)
                        p = 0;
                if (p > st - margin)
                        p = st;
                scr->pcs.visibleoffset = (p + ul) % we;
        }

        vga_6845_write(vh, startadrh, scr->pcs.visibleoffset >> 9);
        vga_6845_write(vh, startadrl, scr->pcs.visibleoffset >> 1);
}
#endif

static void
vga_putchar(void *c, int row, int col, u_int uc, long attr)
{

        pcdisplay_putchar(c, row, col, uc, attr);
}

#ifdef WSDISPLAY_CUSTOM_BORDER
static int
vga_getborder(struct vga_config *vc, u_int *valuep)
{
        struct vga_handle *vh = &vc->hdl;
        u_int idx;
        uint8_t value;

        if (vh->vh_mono)
                return ENODEV;

        value = _vga_attr_read(vh, VGA_ATC_OVERSCAN);
        for (idx = 0; idx < sizeof(fgansitopc); idx++) {
                if (fgansitopc[idx] == value) {
                        *valuep = idx;
                        return (0);
                }
        }
        return (EIO);
}

static int
vga_setborder(struct vga_config *vc, u_int value)
{
        struct vga_handle *vh = &vc->hdl;

        if (vh->vh_mono)
                return ENODEV;
        if (value >= sizeof(fgansitopc))
                return EINVAL;

        _vga_attr_write(vh, VGA_ATC_OVERSCAN, fgansitopc[value]);
        return (0);
}
#endif /* WSDISPLAY_CUSTOM_BORDER */

void
vga_resume(struct vga_softc *sc)
{
#ifdef VGA_RESET_ON_RESUME
        vga_initregs(&sc->sc_vc->hdl);
#endif
#ifdef PCDISPLAY_SOFTCURSOR
        /* Disable the hardware cursor */
        vga_6845_write(&sc->sc_vc->hdl, curstart, 0x20);
        vga_6845_write(&sc->sc_vc->hdl, curend, 0x00);
#endif
}

static void
vga_save_palette(struct vga_config *vc)
{
        struct vga_handle *vh = &vc->hdl;
        size_t i;
        uint8_t *palette = vc->palette;

        if (vh->vh_mono)
                return;

        vga_raw_write(vh, VGA_DAC_PELMASK, 0xff);
        vga_raw_write(vh, VGA_DAC_ADDRR, 0x00);
        for (i = 0; i < sizeof(vc->palette); i++)
                *palette++ = vga_raw_read(vh, VGA_DAC_PALETTE);

        vga_reset_state(vh);                    /* reset flip/flop */
}

static void
vga_restore_palette(struct vga_config *vc)
{
        struct vga_handle *vh = &vc->hdl;
        size_t i;
        uint8_t *palette = vc->palette;

        if (vh->vh_mono)
                return;

        vga_raw_write(vh, VGA_DAC_PELMASK, 0xff);
        vga_raw_write(vh, VGA_DAC_ADDRW, 0x00);
        for (i = 0; i < sizeof(vc->palette); i++)
                vga_raw_write(vh, VGA_DAC_PALETTE, *palette++);

        vga_reset_state(vh);                    /* reset flip/flop */
        vga_enable(vh);
}