 @@ -1,1588 +1,1591 @@
-/* $NetBSD: vga.c,v 1.109 2012/08/09 23:56:35 uwe Exp $ */
+/* $NetBSD: vga.c,v 1.110 2013/01/21 19:49:15 mlelstv 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.109 2012/08/09 23:56:35 uwe Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vga.c,v 1.110 2013/01/21 19:49:15 mlelstv Exp $");
 /* 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 */
 ,				/* firstchar */
 ,				/* numbers */
 	WSDISPLAY_FONTENC_IBM,		/* encoding */
 ,				/* width */
 ,				/* height */
 ,				/* stride */
 	WSDISPLAY_FONTORDER_L2R,	/* bit order */
 ,				/* 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;
-struct egavga_font *egavga_getfont(struct vga_config *, struct vgascreen *,
+static struct egavga_font *egavga_getfont(struct vga_config *, struct vgascreen *,
 				   const char *, int);
-void egavga_unreffont(struct vga_config *, struct egavga_font *);
+static void egavga_unreffont(struct vga_config *, struct egavga_font *);
-int vga_selectfont(struct vga_config *, struct vgascreen *, const char *,
+static int vga_selectfont(struct vga_config *, struct vgascreen *, const char *,
 				   const char *);
-void vga_init_screen(struct vga_config *, struct vgascreen *,
+static void vga_init_screen(struct vga_config *, struct vgascreen *,
 		     const struct wsscreen_descr *, int, long *);
-void vga_init(struct vga_config *, bus_space_tag_t, bus_space_tag_t);
+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 *);
-void vga_putchar(void *, int, int, u_int, long);
+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
-void vga_scroll (void *, void *, int);
+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,
 , 16,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	NULL,
 }, vga_25lscreen_mono = {
 	"80x25", 80, 25,
 	&vga_emulops,
 , 16,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	NULL,
 }, vga_25lscreen_bf = {
 	"80x25bf", 80, 25,
 	&vga_emulops,
 , 16,
 	WSSCREEN_WSCOLORS | WSSCREEN_BLINK,
 	NULL,
 }, vga_40lscreen = {
 	"80x40", 80, 40,
 	&vga_emulops,
 , 10,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	NULL,
 }, vga_40lscreen_mono = {
 	"80x40", 80, 40,
 	&vga_emulops,
 , 10,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	NULL,
 }, vga_40lscreen_bf = {
 	"80x40bf", 80, 40,
 	&vga_emulops,
 , 10,
 	WSSCREEN_WSCOLORS | WSSCREEN_BLINK,
 	NULL,
 }, vga_50lscreen = {
 	"80x50", 80, 50,
 	&vga_emulops,
 , 8,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	NULL,
 }, vga_50lscreen_mono = {
 	"80x50", 80, 50,
 	&vga_emulops,
 , 8,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	NULL,
 }, vga_50lscreen_bf = {
 	"80x50bf", 80, 50,
 	&vga_emulops,
 , 8,
 	WSSCREEN_WSCOLORS | WSSCREEN_BLINK,
 	NULL,
 }, vga_24lscreen = {
 	"80x24", 80, 24,
 	&vga_emulops,
 , 16,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	NULL,
 }, vga_24lscreen_mono = {
 	"80x24", 80, 24,
 	&vga_emulops,
 , 16,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	NULL,
 }, vga_24lscreen_bf = {
 	"80x24bf", 80, 24,
 	&vga_emulops,
 , 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 */
-void vga_doswitch(struct vga_config *);
+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)
-struct egavga_font *
+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,
 , 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_NOWAIT);
 	if (!f) {
 		wsfont_unlock(cookie);
 		return (0);
+	}
 	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);
+}
-void
+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);
+	}
+}
-int
+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);
+}
-void
+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;
 	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);
+}
-void
+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, 0, &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");
 	/* should only reserve the space (no need to map - save KVM) */
 	vc->vc_biostag = memt;
 	if (bus_space_map(vc->vc_biostag, 0xc0000, 0x8000, 0, &vc->vc_bioshdl))
 		vc->vc_biosmapped = 0;
 	else
 		vc->vc_biosmapped = 1;
 	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_ia(sc->sc_dev, "wsemuldisplaydev", &aa, wsemuldisplaydevprint);
+}
 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) {
 		bus_space_unmap(vh->vh_iot, vh->vh_ioh_vga, 0x10);
 		bus_space_unmap(vh->vh_iot, vh->vh_ioh_6845, 0x10);
 		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);
+}
-int
+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));
+}
-int
+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);
+}
-void
+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;
+	}
+}
-int
+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);
+}
-void
+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,
 x2409, /* SYMBOL FOR HORIZONTAL TABULATION */
 x240a, /* SYMBOL FOR LINE FEED */
 x240b, /* SYMBOL FOR VERTICAL TABULATION */
 x240c, /* SYMBOL FOR FORM FEED */
 x240d, /* 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 */
 x03c8, /* GREEK SMALL LETTER PSI */
 x2202, /* PARTIAL DIFFERENTIAL */
 x03bb, /* GREEK SMALL LETTER LAMDA */
 x03b9, /* GREEK SMALL LETTER IOTA */
 x03b7, /* GREEK SMALL LETTER ETA */
 x03b5, /* GREEK SMALL LETTER EPSILON */
 x03c7, /* GREEK SMALL LETTER CHI */
 x2228, /* LOGICAL OR */
 x2227, /* LOGICAL AND */
 x222a, /* UNION */
 x2283, /* SUPERSET OF */
 x2282, /* SUBSET OF */
 x03a5, /* GREEK CAPITAL LETTER UPSILON */
 x039e, /* GREEK CAPITAL LETTER XI */
 x03a8, /* GREEK CAPITAL LETTER PSI */
 /* 5 */	0x03a0, /* GREEK CAPITAL LETTER PI */
 x21d2, /* RIGHTWARDS DOUBLE ARROW */
 x21d4, /* LEFT RIGHT DOUBLE ARROW */
 x039b, /* GREEK CAPITAL LETTER LAMDA */
 x0398, /* GREEK CAPITAL LETTER THETA */
 x2243, /* ASYMPTOTICALLY EQUAL TO */
 x2207, /* NABLA */
 x2206, /* INCREMENT */
 x221d, /* PROPORTIONAL TO */
 x2234, /* THEREFORE */
 x222b, /* INTEGRAL */
 x2215, /* DIVISION SLASH */
 x2216, /* SET MINUS */
 	_e00eU, /* angle? */
 	_e00dU, /* inverted angle? */
 	_e00bU, /* braceleftmid */
 /* 6 */	_e00cU, /* bracerightmid */
 	_e007U, /* bracelefttp */
 	_e008U, /* braceleftbt */
 	_e009U, /* bracerighttp */
 	_e00aU, /* bracerightbt */
 x221a, /* SQUARE ROOT */
 x03c9, /* GREEK SMALL LETTER OMEGA */
 x00a5, /* YEN SIGN */
 x03be, /* GREEK SMALL LETTER XI */
 x00fd, /* LATIN SMALL LETTER Y WITH ACUTE */
 x00fe, /* LATIN SMALL LETTER THORN */
 x00f0, /* LATIN SMALL LETTER ETH */
 x00de, /* LATIN CAPITAL LETTER THORN */
 x00dd, /* LATIN CAPITAL LETTER Y WITH ACUTE */
 x00d7, /* MULTIPLICATION SIGN */
 x00d0, /* LATIN CAPITAL LETTER ETH */
 /* 7 */	0x00be, /* VULGAR FRACTION THREE QUARTERS */
 x00b8, /* CEDILLA */
 x00b4, /* ACUTE ACCENT */
 x00af, /* MACRON */
 x00ae, /* REGISTERED SIGN */
 x00ad, /* SOFT HYPHEN */
 x00ac, /* NOT SIGN */
 x00a8, /* DIAERESIS */
 x2260, /* NOT EQUAL TO */
 x23bd, /* scan 9 */
 x23bc, /* scan 7 */
 x2500, /* scan 5 */
 x23bb, /* scan 3 */
 x23ba, /* scan 1 */
 x03c5, /* GREEK SMALL LETTER UPSILON */
 x00f8, /* LATIN SMALL LETTER O WITH STROKE */
 /* 8 */	0x0153, /* LATIN SMALL LIGATURE OE */
 x00f5, /* LATIN SMALL LETTER O WITH TILDE !!!doc bug */
 x00e3, /* LATIN SMALL LETTER A WITH TILDE */
 x0178, /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
 x00db, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
 x00da, /* LATIN CAPITAL LETTER U WITH ACUTE */
 x00d9, /* LATIN CAPITAL LETTER U WITH GRAVE */
 x00d8, /* LATIN CAPITAL LETTER O WITH STROKE */
 x0152, /* LATIN CAPITAL LIGATURE OE */
 x00d5, /* LATIN CAPITAL LETTER O WITH TILDE */
 x00d4, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
 x00d3, /* LATIN CAPITAL LETTER O WITH ACUTE */
 x00d2, /* LATIN CAPITAL LETTER O WITH GRAVE */
 x00cf, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
 x00ce, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
 x00cd, /* LATIN CAPITAL LETTER I WITH ACUTE */
 /* 9 */	0x00cc, /* LATIN CAPITAL LETTER I WITH GRAVE */
 x00cb, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
 x00ca, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
 x00c8, /* LATIN CAPITAL LETTER E WITH GRAVE */
 x00c3, /* LATIN CAPITAL LETTER A WITH TILDE */
 x00c2, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
 x00c1, /* LATIN CAPITAL LETTER A WITH ACUTE */
 x00c0, /* LATIN CAPITAL LETTER A WITH GRAVE */
 x00b9, /* SUPERSCRIPT ONE */
 x00b7, /* MIDDLE DOT */
 x03b6, /* GREEK SMALL LETTER ZETA */
 x00b3, /* SUPERSCRIPT THREE */
 x00a9, /* COPYRIGHT SIGN */
 x00a4, /* CURRENCY SIGN */
 x03ba, /* 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] = {
 x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
 x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
 x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
 x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
 x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
 x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
 x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
 x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
 x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
 x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
 x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
 x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
 };
 static const uint16_t koi8_unichars[0x40] = {
 x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
 x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
 x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
 x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
 x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
 x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
 x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
 x042C, 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
-void
+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
-void
+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
+}
-void
+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 */
+}
-void
+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);
+}

 @@ -1,1490 +1,1490 @@
-/*	$NetBSD: vga_raster.c,v 1.35 2012/01/11 20:41:28 macallan Exp $	*/
+/*	$NetBSD: vga_raster.c,v 1.36 2013/01/21 19:49:15 mlelstv Exp $	*/
 /*
  * Copyright (c) 2001, 2002 Bang Jun-Young
  * Copyright (c) 2004 Julio M. Merino Vidal
  * All rights reserved.
+ *
  * 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.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
  */
 /*
  * 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_raster.c,v 1.35 2012/01/11 20:41:28 macallan Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vga_raster.c,v 1.36 2013/01/21 19:49:15 mlelstv Exp $");
 #include "opt_wsmsgattrs.h" /* for WSDISPLAY_CUSTOM_OUTPUT */
 #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/videomode/videomode.h>
 #include <dev/wscons/wsdisplayvar.h>
 #include <dev/wscons/wsconsio.h>
 #include <dev/wsfont/wsfont.h>
 #include <dev/ic/pcdisplay.h>
 int vga_no_builtinfont = 0;
 u_int8_t builtinfont_data[256 * 16];
 struct wsdisplay_font builtinfont = {
 	"builtin",			/* typeface name */
 ,				/* firstchar */
 ,				/* numchars */
 	WSDISPLAY_FONTENC_IBM,		/* encoding */
 ,				/* width */
 ,				/* height */
 ,				/* stride */
 	WSDISPLAY_FONTORDER_L2R,	/* bit order */
 	WSDISPLAY_FONTORDER_L2R,	/* byte order */
 	builtinfont_data		/* data */
 };
 struct vga_scrmem {
 	u_int16_t ch;
 	u_int8_t attr;
 	u_int8_t second;	/* XXXBJY should be u_int8_t len; */
 	u_int8_t enc;
 };
 #ifdef VGA_CONSOLE_SCREENTYPE
 #define VGA_SCRMEM_SIZE		(80 * 30)
 #else
 #define VGA_SCRMEM_SIZE		(80 * 25)
 #endif
 struct vga_scrmem boot_scrmem[VGA_SCRMEM_SIZE];
 struct vga_raster_font {
 	LIST_ENTRY(vga_raster_font) next;
 	struct wsdisplay_font *font;
 };
 struct vgascreen {
 	LIST_ENTRY(vgascreen) next;
 	struct vga_config *cfg;
 	struct vga_handle *hdl;
 	const struct wsscreen_descr *type;
 	int active;
 	struct vga_scrmem *mem;
 	int encoding;
 	int dispoffset;
 	int mindispoffset;
 	int maxdispoffset;
 	int cursoron;			/* Is cursor displayed? */
 	int cursorcol;			/* Current cursor column */
 	int cursorrow;			/* Current cursor row */
 	struct vga_scrmem cursortmp;
 	int cursorstride;
 	LIST_HEAD(, vga_raster_font) fontset;
 };
 struct vga_moderegs {
 	u_int8_t miscout;		/* Misc. output */
 	u_int8_t crtc[MC6845_NREGS];	/* CRTC controller */
 	u_int8_t atc[VGA_ATC_NREGS];	/* Attribute controller */
 	u_int8_t ts[VGA_TS_NREGS];	/* Time sequencer */
 	u_int8_t gdc[VGA_GDC_NREGS];	/* Graphics display controller */
 };
 static int vgaconsole, vga_console_type, vga_console_attached;
 static struct vgascreen vga_console_screen;
 static struct vga_config vga_console_vc;
 static struct vga_raster_font vga_console_fontset_ascii;
 static struct videomode vga_console_modes[2] = {
 	/* 640x400 for 80x25, 80x40 and 80x50 modes */
+	{
 , 640, 664, 760, 800, 400, 409, 411, 450, 0, NULL,
 	},
 	/* 640x480 for 80x30 mode */
+	{
 , 640, 664, 760, 800, 480, 491, 493, 525, 0, NULL,
+	}
 };
 static void vga_raster_init(struct vga_config *, bus_space_tag_t,
 		bus_space_tag_t);
 static void vga_raster_init_screen(struct vga_config *, struct vgascreen *,
 		const struct wsscreen_descr *, int, long *);
 static void vga_raster_setup_font(struct vga_config *, struct vgascreen *);
 static void vga_setup_regs(struct videomode *, struct vga_moderegs *);
 static void vga_set_mode(struct vga_handle *, struct vga_moderegs *);
 static void vga_restore_screen(struct vgascreen *,
 		const struct wsscreen_descr *, struct vga_scrmem *);
 static void vga_raster_cursor_init(struct vgascreen *, int);
 static void _vga_raster_putchar(void *, int, int, u_int, long,
 		struct vga_raster_font *);
 static void vga_raster_cursor(void *, int, int, int);
 static int  vga_raster_mapchar(void *, int, u_int *);
 static void vga_raster_putchar(void *, int, int, u_int, long);
 static void vga_raster_copycols(void *, int, int, int, int);
 static void vga_raster_erasecols(void *, int, int, int, long);
 static void vga_raster_copyrows(void *, int, int, int);
 static void vga_raster_eraserows(void *, int, int, long);
 static int  vga_raster_allocattr(void *, int, int, int, long *);
 #ifdef WSDISPLAY_CUSTOM_OUTPUT
 static void vga_raster_replaceattr(void *, long, long);
 #endif /* WSDISPLAY_CUSTOM_OUTPUT */
 const struct wsdisplay_emulops vga_raster_emulops = {
 	vga_raster_cursor,
 	vga_raster_mapchar,
 	vga_raster_putchar,
 	vga_raster_copycols,
 	vga_raster_erasecols,
 	vga_raster_copyrows,
 	vga_raster_eraserows,
 	vga_raster_allocattr,
 #ifdef WSDISPLAY_CUSTOM_OUTPUT
 	vga_raster_replaceattr,
 #else /* WSDISPLAY_CUSTOM_OUTPUT */
 	NULL,
 #endif /* WSDISPLAY_CUSTOM_OUTPUT */
 };
 /*
  * 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_raster_emulops,
 , 16,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	&vga_console_modes[0]
 }, vga_25lscreen_mono = {
 	"80x25", 80, 25,
 	&vga_raster_emulops,
 , 16,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	&vga_console_modes[0]
 }, vga_30lscreen = {
 	"80x30", 80, 30,
 	&vga_raster_emulops,
 , 16,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	&vga_console_modes[1]
 }, vga_30lscreen_mono = {
 	"80x30", 80, 30,
 	&vga_raster_emulops,
 , 16,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	&vga_console_modes[1]
 }, vga_40lscreen = {
 	"80x40", 80, 40,
 	&vga_raster_emulops,
 , 10,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	&vga_console_modes[0]
 }, vga_40lscreen_mono = {
 	"80x40", 80, 40,
 	&vga_raster_emulops,
 , 10,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	&vga_console_modes[0]
 }, vga_50lscreen = {
 	"80x50", 80, 50,
 	&vga_raster_emulops,
 , 8,
 	WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_BLINK,
 	&vga_console_modes[0]
 }, vga_50lscreen_mono = {
 	"80x50", 80, 50,
 	&vga_raster_emulops,
 , 8,
 	WSSCREEN_HILIT | WSSCREEN_UNDERLINE | WSSCREEN_BLINK | WSSCREEN_REVERSE,
 	&vga_console_modes[0]
 };
 const struct wsscreen_descr *_vga_scrlist[] = {
 	&vga_25lscreen,
 	&vga_30lscreen,
 	&vga_40lscreen,
 	&vga_50lscreen,
 }, *_vga_scrlist_mono[] = {
 	&vga_25lscreen_mono,
 	&vga_30lscreen_mono,
 	&vga_40lscreen_mono,
 	&vga_50lscreen_mono,
 };
 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_raster_ioctl(void *, void *, u_long, void *, int,
 		    struct lwp *);
 static paddr_t	vga_raster_mmap(void *, void *, off_t, int);
 static int	vga_raster_alloc_screen(void *, const struct wsscreen_descr *,
 		    void **, int *, int *, long *);
 static void	vga_raster_free_screen(void *, void *);
 static int	vga_raster_show_screen(void *, void *, int,
 		    void (*)(void *, int, int), void *);
 static int	vga_raster_load_font(void *, void *, struct wsdisplay_font *);
 static void 	vga_switch_screen(struct vga_config *);
 static void 	vga_raster_setscreentype(struct vga_config *,
 		    const struct wsscreen_descr *);
 const struct wsdisplay_accessops vga_raster_accessops = {
 	vga_raster_ioctl,
 	vga_raster_mmap,
 	vga_raster_alloc_screen,
 	vga_raster_free_screen,
 	vga_raster_show_screen,
 	vga_raster_load_font,
 	NULL,	/* pollc */
 	NULL,	/* scroll */
 };
 int
 vga_cnattach(bus_space_tag_t iot, bus_space_tag_t memt, int type, int check)
+{
 	long defattr;
 	const struct wsscreen_descr *scr;
 #ifdef VGA_CONSOLE_SCREENTYPE
 	const char *typestr = NULL;
 #endif
 	if (check && !vga_common_probe(iot, memt))
 		return (ENXIO);
 	/* set up bus-independent VGA configuration */
 	vga_raster_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)
 		/* Invalid screen type, continue with the default mode. */
 		typestr = "80x25";
 	else if (scr->nrows > 30)
 		/* Unsupported screen type, try 80x30. */
 		typestr = "80x30";
 	if (typestr)
 		scr = wsdisplay_screentype_pick(vga_console_vc.hdl.vh_mono ?
 		    &vga_screenlist_mono : &vga_screenlist, typestr);
 	if (scr != vga_console_vc.currenttype)
 		vga_console_vc.currenttype = scr;
 #else
 	scr = vga_console_vc.currenttype;
 #endif
 	vga_raster_init_screen(&vga_console_vc, &vga_console_screen, scr, 1,
 	    &defattr);
 	vga_console_screen.active = 1;
 	vga_console_vc.active = &vga_console_screen;
 	wsdisplay_cnattach(scr, &vga_console_screen,
 	    vga_console_screen.cursorcol, vga_console_screen.cursorrow,
 	    defattr);
 	vgaconsole = 1;
 	vga_console_type = type;
 	return (0);
+}
-void
+static void
 vga_raster_init(struct vga_config *vc, bus_space_tag_t iot,
     bus_space_tag_t memt)
+{
 	struct vga_handle *vh = &vc->hdl;
 	u_int8_t mor;
 	struct vga_raster_font *vf;
 	vh->vh_iot = iot;
 	vh->vh_memt = memt;
 	if (bus_space_map(vh->vh_iot, 0x3c0, 0x10, 0, &vh->vh_ioh_vga))
 		panic("vga_raster_init: couldn't map vga io");
 	/* read "misc output register" */
 	mor = bus_space_read_1(vh->vh_iot, vh->vh_ioh_vga, 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_raster_init: couldn't map 6845 io");
 	if (bus_space_map(vh->vh_memt, 0xa0000, 0x20000, 0, &vh->vh_allmemh))
 		panic("vga_raster_init: couldn't map memory");
 	if (bus_space_subregion(vh->vh_memt, vh->vh_allmemh, 0, 0x10000,
 	    &vh->vh_memh))
 		panic("vga_raster_init: mem subrange failed");
 	/* should only reserve the space (no need to map - save KVM) */
 	vc->vc_biostag = memt;
 	if (bus_space_map(vc->vc_biostag, 0xc0000, 0x8000, 0, &vc->vc_bioshdl))
 		vc->vc_biosmapped = 0;
 	else
 		vc->vc_biosmapped = 1;
 	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();
 	vc->nfonts = 1;
 	LIST_INIT(&vc->vc_fontlist);
 	vf = &vga_console_fontset_ascii;
 	if (vga_no_builtinfont) {
 		struct wsdisplay_font *wf;
 		int cookie;
 		/* prefer 8x16 pixel font */
 		cookie = wsfont_find(NULL, 8, 16, 0, WSDISPLAY_FONTORDER_L2R,
 , WSFONT_FIND_BITMAP);
 		if (cookie == -1)
 			cookie = wsfont_find(NULL, 0, 0, 0,
 			    WSDISPLAY_FONTORDER_L2R, WSDISPLAY_FONTORDER_L2R,
 			    WSFONT_FIND_BITMAP);
 		if (cookie == -1 || wsfont_lock(cookie, &wf))
 			panic("vga_raster_init: can't load console font");
 		vf->font = wf;
 	} else {
 		vga_load_builtinfont(vh, builtinfont_data, 0, 256);
 		vf->font = &builtinfont;
+	}
 	LIST_INSERT_HEAD(&vc->vc_fontlist, vf, next);
+}
-void
+static void
 vga_raster_init_screen(struct vga_config *vc, struct vgascreen *scr,
     const struct wsscreen_descr *type, int existing, long *attrp)
+{
 	int cpos;
 	int res;
 	struct vga_handle *vh;
 	scr->cfg = vc;
 	scr->hdl = &vc->hdl;
 	scr->type = type;
 	scr->mindispoffset = 0;
 	scr->maxdispoffset = scr->dispoffset +
 	    type->nrows * type->ncols * type->fontheight;
 	vh = &vc->hdl;
 	LIST_INIT(&scr->fontset);
 	vga_raster_setup_font(vc, scr);
 	if (existing) {
 		int i;
 		cpos = vga_6845_read(vh, cursorh) << 8;
 		cpos |= vga_6845_read(vh, cursorl);
 		/* make sure we have a valid cursor position */
 		if (cpos < 0 || cpos >= type->nrows * type->ncols)
 			cpos = 0;
 		scr->dispoffset = vga_6845_read(vh, startadrh) << 9;
 		scr->dispoffset |= vga_6845_read(vh, startadrl) << 1;
 		/* make sure we have a valid memory offset */
 		if (scr->dispoffset < scr->mindispoffset ||
 		    scr->dispoffset > scr->maxdispoffset)
 			scr->dispoffset = scr->mindispoffset;
 		scr->mem = boot_scrmem;
 		scr->active = 1;
 		/* Save the current screen to memory. XXXBJY assume 80x25 */
 		for (i = 0; i < 80 * 25; i++) {
 			scr->mem[i].ch = bus_space_read_1(vh->vh_memt,
 			    vh->vh_allmemh, 0x18000 + i * 2);
 			scr->mem[i].attr = bus_space_read_1(vh->vh_memt,
 			    vh->vh_allmemh, 0x18000 + i * 2 + 1);
 			scr->mem[i].enc = scr->encoding;
+		}
 		vga_raster_setscreentype(vc, type);
 		/* Clear the entire screen. */
 		vga_gdc_write(vh, mode, 0x02);
 		bus_space_set_region_4(vh->vh_memt, vh->vh_allmemh, 0, 0,
 x4000);
 		vga_restore_screen(scr, type, scr->mem);
 	} else {
 		cpos = 0;
 		scr->dispoffset = scr->mindispoffset;
 		scr->mem = NULL;
 		scr->active = 0;
+	}
 	scr->cursorrow = cpos / type->ncols;
 	scr->cursorcol = cpos % type->ncols;
 	vga_raster_cursor_init(scr, existing);
 #ifdef __alpha__
 	if (!vc->hdl.vh_mono)
 		/*
 		 * DEC firmware uses a blue background.
 		 */
 		res = vga_raster_allocattr(scr, WSCOL_WHITE, WSCOL_BLUE,
 		    WSATTR_WSCOLORS, attrp);
 	else
 #endif
 	res = vga_raster_allocattr(scr, 0, 0, 0, attrp);
 #ifdef DIAGNOSTIC
 	if (res)
 		panic("vga_raster_init_screen: attribute botch");
 #endif
 	vc->nscreens++;
 	LIST_INSERT_HEAD(&vc->screens, scr, next);
+}
 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_raster_init(vc, iot, memt);
+	}
 	vc->vc_type = type;
 	vc->vc_funcs = vf;
 	sc->sc_vc = vc;
 	vc->softc = sc;
 	aa.console = console;
 	aa.scrdata = (vc->hdl.vh_mono ? &vga_screenlist_mono : &vga_screenlist);
 	aa.accessops = &vga_raster_accessops;
 	aa.accesscookie = vc;
 	config_found(sc->sc_dev, &aa, wsemuldisplaydevprint);
+}
 int
 vga_cndetach(void)
+{
 	struct vga_config *vc;
 	struct vga_handle *vh;
 	vc = &vga_console_vc;
 	vh = &vc->hdl;
 	if (vgaconsole) {
 		bus_space_unmap(vh->vh_iot, vh->vh_ioh_vga, 0x10);
 		bus_space_unmap(vh->vh_iot, vh->vh_ioh_6845, 0x10);
 		return 1;
+	}
 	return 0;
+}
 int
 vga_is_console(bus_space_tag_t iot, int type)
+{
 	if (vgaconsole &&
 	    !vga_console_attached &&
 	    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);
+}
 int
 vga_raster_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
 	struct lwp *l)
+{
 	struct vga_config *vc = v;
 	const struct vga_funcs *vf = vc->vc_funcs;
 	switch (cmd) {
 	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:
 #if 1
 		*(int *)data = (vga_get_video(vc) ?
 		    WSDISPLAYIO_VIDEO_ON : WSDISPLAYIO_VIDEO_OFF);
 		return 0;
 #endif
 	case WSDISPLAYIO_SVIDEO:
 #if 1
 		vga_set_video(vc, *(int *)data == WSDISPLAYIO_VIDEO_ON);
 		return 0;
 #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_raster_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));
+}
-int
+static int
 vga_raster_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) {
 		vc->screens.lh_first->mem = boot_scrmem;
+	}
 	scr = malloc(sizeof(struct vgascreen), M_DEVBUF, M_WAITOK);
 	vga_raster_init_screen(vc, scr, type, vc->nscreens == 0, defattrp);
 	if (vc->nscreens == 1) {
 		scr->active = 1;
 		vc->active = scr;
 		vc->currenttype = type;
 	} else {
 		scr->mem = malloc(sizeof(struct vga_scrmem) *
 		    type->ncols * type->nrows, M_DEVBUF, M_WAITOK);
 		vga_raster_eraserows(scr, 0, type->nrows, *defattrp);
+	}
 	*cookiep = scr;
 	*curxp = scr->cursorcol;
 	*curyp = scr->cursorrow;
 	return (0);
+}
-void
+static void
 vga_raster_free_screen(void *v, void *cookie)
+{
 	struct vgascreen *vs = cookie;
 	struct vga_config *vc = vs->cfg;
 	LIST_REMOVE(vs, next);
 	vc->nscreens--;
 	if (vs != &vga_console_screen)
 		free(vs, M_DEVBUF);
 	else
 		panic("vga_raster_free_screen: console");
 	if (vc->active == vs)
 		vc->active = 0;
+}
-int
+static int
 vga_raster_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_switch_screen, vc);
 		return (EAGAIN);
+	}
 	vga_switch_screen(vc);
 	return (0);
+}
-void
+static void
 vga_switch_screen(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_switch_screen: disappeared\n");
 		(*vc->switchcb)(vc->switchcbarg, EIO, 0);
 		return;
+	}
 	type = scr->type;
 	oldscr = vc->active; /* can be NULL! */
 #ifdef DIAGNOSTIC
 	if (oldscr) {
 		if (!oldscr->active)
 			panic("vga_raster_show_screen: not active");
 		if (oldscr->type != vc->currenttype)
 			panic("vga_raster_show_screen: bad type");
+	}
 #endif
 	if (scr == oldscr) {
 		return;
+	}
 #ifdef DIAGNOSTIC
 	if (scr->active)
 		panic("vga_raster_show_screen: active");
 #endif
 	if (oldscr)
 		oldscr->active = 0;
 	if (vc->currenttype != type) {
 		vga_raster_setscreentype(vc, type);
 		vc->currenttype = type;
+	}
 	scr->dispoffset = scr->mindispoffset;
 	if (!oldscr || (scr->dispoffset != oldscr->dispoffset)) {
 		vga_6845_write(vh, startadrh, scr->dispoffset >> 8);
 		vga_6845_write(vh, startadrl, scr->dispoffset);
+	}
 	/* Clear the entire screen. */
 	vga_gdc_write(vh, mode, 0x02);
 	bus_space_set_region_4(vh->vh_memt, vh->vh_allmemh, 0, 0, 0x2000);
 	scr->active = 1;
 	vga_restore_screen(scr, type, scr->mem);
 	vc->active = scr;
 	vga_raster_cursor(scr, scr->cursoron, scr->cursorrow, scr->cursorcol);
 	vc->wantedscreen = 0;
 	if (vc->switchcb)
 		(*vc->switchcb)(vc->switchcbarg, 0, 0);
+}
 static int
 vga_raster_load_font(void *v, void *id,
     struct wsdisplay_font *data)
+{
 	/* XXX */
 	printf("vga_raster_load_font: called\n");
 	return (0);
+}
-void
+static void
 vga_raster_setup_font(struct vga_config *vc, struct vgascreen *scr)
+{
 	struct vga_raster_font *vf;
 	struct wsdisplay_font *wf;
 	int cookie;
 	LIST_FOREACH(vf, &vc->vc_fontlist, next) {
 		if (wsfont_matches(vf->font, 0, 0, scr->type->fontheight, 0,
 		    WSFONT_FIND_BITMAP)) {
 			scr->encoding = vf->font->encoding;
 			LIST_INSERT_HEAD(&scr->fontset, vf, next);
 			return;
+		}
+	}
 	cookie = wsfont_find(NULL, 0, scr->type->fontheight, 0,
 	    WSDISPLAY_FONTORDER_L2R, 0, WSFONT_FIND_BITMAP);
 	if (cookie == -1)
 		return;
 	if (wsfont_lock(cookie, &wf))
 		return;
 	vf = malloc(sizeof(struct vga_raster_font), M_DEVBUF, M_NOWAIT);
 	if (!vf) {
 		wsfont_unlock(cookie);
 		return;
+	}
 	vf->font = wf;
 	scr->encoding = vf->font->encoding;
 	LIST_INSERT_HEAD(&scr->fontset, vf, next);
+}
-void
+static void
 vga_setup_regs(struct videomode *mode, struct vga_moderegs *regs)
+{
 	int i;
 	int depth = 4;			/* XXXBJY hardcoded for now */
 	const u_int8_t palette[] = {
 x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07,
 x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f
 	};
 	/*
 	 * Compute hsync and vsync polarity.
 	 */
 	if ((mode->flags & (VID_PHSYNC | VID_NHSYNC))
 	    && (mode->flags & (VID_PVSYNC | VID_NVSYNC))) {
 	    	regs->miscout = 0x23;
 		if (mode->flags & VID_NHSYNC)
 			regs->miscout |= 0x40;
 		if (mode->flags & VID_NVSYNC)
 			regs->miscout |= 0x80;
 	} else {
 		if (mode->flags & VID_DBLSCAN)
 			mode->vdisplay *= 2;
 		if (mode->vdisplay < 400)
 			regs->miscout = 0xa3;
 		else if (mode->vdisplay < 480)
 			regs->miscout = 0x63;
 		else if (mode->vdisplay < 768)
 			regs->miscout = 0xe3;
 		else
 			regs->miscout = 0x23;
+	}
 	/*
 	 * Time sequencer
 	 */
 	if (depth == 4)
 		regs->ts[0] = 0x02;
 	else
 		regs->ts[0] = 0x00;
 	if (mode->flags & VID_CLKDIV2)
 		regs->ts[1] = 0x09;
 	else
 		regs->ts[1] = 0x01;
 	regs->ts[2] = 0x0f;
 	regs->ts[3] = 0x00;
 	if (depth < 8)
 		regs->ts[4] = 0x06;
 	else
 		regs->ts[4] = 0x0e;
 	/*
 	 * CRTC controller
 	 */
 	regs->crtc[0] = (mode->htotal >> 3) - 5;
 	regs->crtc[1] = (mode->hdisplay >> 3) - 1;
 	regs->crtc[2] = (mode->hsync_start >> 3) - 1;
 	regs->crtc[3] = (((mode->hsync_end >> 3) - 1) & 0x1f) | 0x80;
 	regs->crtc[4] = mode->hsync_start >> 3;
 	regs->crtc[5] = ((((mode->hsync_end >> 3) - 1) & 0x20) << 2)
 	    | (((mode->hsync_end >> 3)) & 0x1f);
 	regs->crtc[6] = (mode->vtotal - 2) & 0xff;
 	regs->crtc[7] = (((mode->vtotal - 2) & 0x100) >> 8)
 	    | (((mode->vdisplay - 1) & 0x100) >> 7)
 	    | ((mode->vsync_start & 0x100) >> 6)
 	    | (((mode->vsync_start - 1) & 0x100) >> 5)
 	    | 0x10
 	    | (((mode->vtotal - 2) & 0x200) >> 4)
 	    | (((mode->vdisplay - 1) & 0x200) >> 3)
 	    | ((mode->vsync_start & 0x200) >> 2);
 	regs->crtc[8] = 0x00;
 	regs->crtc[9] = (((mode->vsync_start - 1) & 0x200) >> 4) | 0x40;
 	if (mode->flags & VID_DBLSCAN)
 		regs->crtc[9] |= 0x80;
 	regs->crtc[10] = 0x00;
 	regs->crtc[11] = 0x00;
 	regs->crtc[12] = 0x00;
 	regs->crtc[13] = 0x00;
 	regs->crtc[14] = 0x00;
 	regs->crtc[15] = 0x00;
 	regs->crtc[16] = mode->vsync_start & 0xff;
 	regs->crtc[17] = (mode->vsync_end & 0x0f) | 0x20;
 	regs->crtc[18] = (mode->vdisplay - 1) & 0xff;
 	regs->crtc[19] = mode->hdisplay >> 4;	/* XXXBJY */
 	regs->crtc[20] = 0x00;
 	regs->crtc[21] = (mode->vsync_start - 1) & 0xff;
 	regs->crtc[22] = (mode->vsync_end - 1) & 0xff;
 	if (depth < 8)
 		regs->crtc[23] = 0xe3;
 	else
 		regs->crtc[23] = 0xc3;
 	regs->crtc[24] = 0xff;
 	/*
 	 * Graphics display controller
 	 */
 	regs->gdc[0] = 0x00;
 	regs->gdc[1] = 0x00;
 	regs->gdc[2] = 0x00;
 	regs->gdc[3] = 0x00;
 	regs->gdc[4] = 0x00;
 	if (depth == 4)
 		regs->gdc[5] = 0x02;
 	else
 		regs->gdc[5] = 0x40;
 	regs->gdc[6] = 0x01;
 	regs->gdc[7] = 0x0f;
 	regs->gdc[8] = 0xff;
 	/*
 	 * Attribute controller
 	 */
 	/* Set palette registers. */
 	for (i = 0; i < 16; i++)
 		regs->atc[i] = palette[i];
 	if (depth == 4)
 		regs->atc[16] = 0x01;	/* XXXBJY was 0x81 in XFree86 */
 	else
 		regs->atc[16] = 0x41;
 	regs->atc[17] = 0x00;		/* XXXBJY just a guess */
 	regs->atc[18] = 0x0f;
 	regs->atc[19] = 0x00;
 	regs->atc[20] = 0x00;
+}
-void
+static void
 vga_set_mode(struct vga_handle *vh, struct vga_moderegs *regs)
+{
 	int i;
 	/* Disable display. */
 	vga_ts_write(vh, mode, vga_ts_read(vh, mode) | VGA_TS_MODE_BLANK);
 	/* Write misc output register. */
 	bus_space_write_1(vh->vh_iot, vh->vh_ioh_vga, VGA_MISC_DATAW,
 	    regs->miscout);
 	/* Set synchronous reset. */
 	vga_ts_write(vh, syncreset, 0x01);
 	vga_ts_write(vh, mode, regs->ts[1] | VGA_TS_MODE_BLANK);
 	for (i = 2; i < VGA_TS_NREGS; i++)
 		_vga_ts_write(vh, i, regs->ts[i]);
 	/* Clear synchronous reset. */
 	vga_ts_write(vh, syncreset, 0x03);
 	/* Unprotect CRTC registers 0-7. */
 	vga_6845_write(vh, vsynce, vga_6845_read(vh, vsynce) & ~0x80);
 	/* Write CRTC registers. */
 	for (i = 0; i < MC6845_NREGS; i++)
 		_vga_6845_write(vh, i, regs->crtc[i]);
 	/* Write graphics display registers. */
 	for (i = 0; i < VGA_GDC_NREGS; i++)
 		_vga_gdc_write(vh, i, regs->gdc[i]);
 	/* Write attribute controller registers. */
 	for (i = 0; i < VGA_ATC_NREGS; i++)
 		_vga_attr_write(vh, i, regs->atc[i]);
 	/* Enable display. */
 	vga_ts_write(vh, mode, vga_ts_read(vh, mode) & ~VGA_TS_MODE_BLANK);
+}
-void
+static void
 vga_raster_cursor_init(struct vgascreen *scr, int existing)
+{
 	struct vga_handle *vh = scr->hdl;
 	bus_space_tag_t memt;
 	bus_space_handle_t memh;
 	int off;
 	if (existing) {
 		/*
 		 * This is the first screen. At this point, scr->active is
 		 * false, so we can't use vga_raster_cursor() to do this.
 		 */
 		memt = vh->vh_memt;
 		memh = vh->vh_memh;
 		off = (scr->cursorrow * scr->type->ncols + scr->cursorcol) +
 		    scr->dispoffset / 8;
 		scr->cursortmp = scr->mem[off];
 		vga_raster_putchar(scr, scr->cursorrow, scr->cursorcol,
 		    scr->cursortmp.ch, scr->cursortmp.attr ^ 0x77);
 	} else {
 		scr->cursortmp.ch = 0;
 		scr->cursortmp.attr = 0;
 		scr->cursortmp.second = 0;
 		scr->cursortmp.enc = scr->encoding;
+	}
 	scr->cursoron = 1;
+}
-void
+static void
 vga_raster_cursor(void *id, int on, int row, int col)
+{
 	struct vgascreen *scr = id;
 	int off, tmp;
 	/* Remove old cursor image */
 	if (scr->cursoron) {
 		off = scr->cursorrow * scr->type->ncols + scr->cursorcol;
 		if (scr->active) {
 			tmp = scr->encoding;
 			scr->encoding = scr->cursortmp.enc;
 			if (scr->cursortmp.second)
 				vga_raster_putchar(id, scr->cursorrow,
 				    scr->cursorcol - 1, scr->cursortmp.ch,
 				    scr->cursortmp.attr);
 			else
 				vga_raster_putchar(id, scr->cursorrow,
 				    scr->cursorcol, scr->cursortmp.ch,
 				    scr->cursortmp.attr);
 			scr->encoding = tmp;
+		}
+	}
 	scr->cursorrow = row;
 	scr->cursorcol = col;
 	if ((scr->cursoron = on) == 0)
 		return;
 	off = scr->cursorrow * scr->type->ncols + scr->cursorcol;
 	scr->cursortmp = scr->mem[off];
 	if (scr->active) {
 		tmp = scr->encoding;
 		scr->encoding = scr->cursortmp.enc;
 		if (scr->cursortmp.second)
 			vga_raster_putchar(id, scr->cursorrow,
 			    scr->cursorcol - 1, scr->cursortmp.ch,
 			    scr->cursortmp.attr ^ 0x77);
 		else
 			vga_raster_putchar(id, scr->cursorrow,
 			    scr->cursorcol, scr->cursortmp.ch,
 			    scr->cursortmp.attr ^ 0x77);
 		scr->encoding = tmp;
+	}
+}
 static int
 vga_raster_mapchar(void *id, int uni, u_int *index)
+{
 	struct vgascreen *scr = id;
 	if (scr->encoding == WSDISPLAY_FONTENC_IBM)
 		return pcdisplay_mapchar(id, uni, index);
 	else {
 		*index = uni;
 		return 5;
+	}
+}
-void
+static void
 vga_raster_putchar(void *id, int row, int col, u_int c, long attr)
+{
 	struct vgascreen *scr = id;
 	size_t off;
 	struct vga_raster_font *fs;
 	u_int tmp_ch;
 	off = row * scr->type->ncols + col;
 	if (__predict_false(off >= (scr->type->ncols * scr->type->nrows)))
 		return;
 	LIST_FOREACH(fs, &scr->fontset, next) {
 		if ((scr->encoding == fs->font->encoding) &&
 		    (c >= fs->font->firstchar) &&
 		    (c < fs->font->firstchar + fs->font->numchars) &&
 		    (scr->type->fontheight == fs->font->fontheight)) {
 			if (scr->active) {
 				tmp_ch = c - fs->font->firstchar;
 				_vga_raster_putchar(scr, row, col, tmp_ch,
 				    attr, fs);
+			}
 			scr->mem[off].ch = c;
 			scr->mem[off].attr = attr;
 			scr->mem[off].second = 0;
 			scr->mem[off].enc = fs->font->encoding;
 			if (fs->font->stride == 2) {
 				scr->mem[off + 1].ch = c;
 				scr->mem[off + 1].attr = attr;
 				scr->mem[off + 1].second = 1;
 				scr->mem[off + 1].enc = fs->font->encoding;
+			}
 			return;
+		}
+	}
 	/*
 	 * No match found.
 	 */
 	if (scr->active)
 		/*
 		 * Put a single width space character no matter what the
 		 * actual width of the character is.
 		 */
 		_vga_raster_putchar(scr, row, col, ' ', attr,
 		    &vga_console_fontset_ascii);
 	scr->mem[off].ch = c;
 	scr->mem[off].attr = attr;
 	scr->mem[off].second = 0;
 	scr->mem[off].enc = scr->encoding;
+}
 static void
 _vga_raster_putchar(void *id, int row, int col, u_int c, long attr,
     struct vga_raster_font *fs)
+{
 	struct vgascreen *scr = id;
 	struct vga_handle *vh = scr->hdl;
 	bus_space_tag_t memt = vh->vh_memt;
 	bus_space_handle_t memh = vh->vh_memh;
 	int i;
 	int rasoff, rasoff2;
 	int fheight = scr->type->fontheight;
 	volatile u_int8_t dummy, pattern;
 	u_int8_t fgcolor, bgcolor;
 	rasoff = scr->dispoffset + row * scr->type->ncols * fheight + col;
 	rasoff2 = rasoff;
 #if 0
 	bgcolor = bgansitopc[attr >> 4];
 	fgcolor = fgansitopc[attr & 0x0f];
 #else
 	bgcolor = ((attr >> 4) & 0x0f);
 	fgcolor = attr & 0x0f;
 #endif
 	if (fs->font->stride == 1) {
 		/* Paint background. */
 		vga_gdc_write(vh, mode, 0x02);
 		for (i = 0; i < fheight; i++) {
 			bus_space_write_1(memt, memh, rasoff, bgcolor);
 			rasoff += scr->type->ncols;
+		}
 		/* Draw a single width character. */
 		vga_gdc_write(vh, mode, 0x03);
 		vga_gdc_write(vh, setres, fgcolor);
 		for (i = 0; i < fheight; i++) {
 			pattern = ((u_int8_t *)fs->font->data)[c * fheight + i];
 			/* When pattern is 0, skip output for speed-up. */
 			if (pattern != 0) {
 				dummy = bus_space_read_1(memt, memh, rasoff2);
 				bus_space_write_1(memt, memh, rasoff2, pattern);
+			}
 			rasoff2 += scr->type->ncols;
+		}
 	} else if (fs->font->stride == 2) {
 		/* Paint background. */
 		vga_gdc_write(vh, mode, 0x02);
 		for (i = 0; i < fheight; i++) {
 			bus_space_write_1(memt, memh, rasoff, bgcolor);
 			bus_space_write_1(memt, memh, rasoff + 1, bgcolor);
 			rasoff += scr->type->ncols;
+		}
 		/* Draw a double width character. */
 		vga_gdc_write(vh, mode, 0x03);
 		vga_gdc_write(vh, setres, fgcolor);
 		for (i = 0; i < fheight; i++) {
 			pattern = ((u_int8_t *)fs->font->data)
 			    [(c * fheight + i) * 2];
 			if (pattern != 0) {
 				dummy = bus_space_read_1(memt, memh, rasoff2);
 				bus_space_write_1(memt, memh, rasoff2, pattern);
+			}
 			pattern = ((u_int8_t *)fs->font->data)
 			    [(c * fheight + i) * 2 + 1];
 			if (pattern != 0) {
 				rasoff2++;
 				dummy = bus_space_read_1(memt, memh, rasoff2);
 				bus_space_write_1(memt, memh, rasoff2, pattern);
 				rasoff2--;
+			}
 			rasoff2 += scr->type->ncols;
+		}
+	}
+}
-void
+static void
 vga_raster_copycols(void *id, int row, int srccol, int dstcol, int ncols)
+{
 	struct vgascreen *scr = id;
 	struct vga_handle *vh = scr->hdl;
 	bus_space_tag_t memt = vh->vh_memt;
 	bus_space_handle_t memh = vh->vh_memh;
 	bus_size_t srcoff, dstoff;
 	bus_size_t rassrcoff, rasdstoff;
 	int i;
 	int fheight = scr->type->fontheight;
 	srcoff = row * scr->type->ncols + srccol;
 	dstoff = row * scr->type->ncols + dstcol;
 	rassrcoff = scr->dispoffset + row * scr->type->ncols * fheight + srccol;
 	rasdstoff = scr->dispoffset + row * scr->type->ncols * fheight + dstcol;
 	memcpy(&scr->mem[dstoff], &scr->mem[srcoff],
 	    ncols * sizeof(struct vga_scrmem));
 	vga_gdc_write(vh, mode, 0x01);
 	if (scr->active) {
 		for (i = 0; i < fheight; i++) {
 			bus_space_copy_region_1(memt, memh,
 			    rassrcoff + i * scr->type->ncols, memh,
 			    rasdstoff + i * scr->type->ncols, ncols);
+		}
+	}
+}
-void
+static void
 vga_raster_erasecols(void *id, int row, int startcol, int ncols, long fillattr)
+{
 	struct vgascreen *scr = id;
 	int i;
 	if (scr->active == 0)
 		return;
 	for (i = startcol; i < startcol + ncols; i++)
 		vga_raster_putchar(id, row, i, ' ', fillattr);
+}
-void
+static void
 vga_raster_copyrows(void *id, int srcrow, int dstrow, int nrows)
+{
 	struct vgascreen *scr = id;
 	struct vga_handle *vh = scr->hdl;
 	bus_space_tag_t memt = vh->vh_memt;
 	bus_space_handle_t memh = vh->vh_memh;
 	int ncols;
 	bus_size_t srcoff, dstoff;
 	bus_size_t rassrcoff, rasdstoff;
 	int fheight;
 	ncols = scr->type->ncols;
 	fheight = scr->type->fontheight;
 	srcoff = srcrow * ncols;
 	dstoff = dstrow * ncols;
 	rassrcoff = srcoff * fheight;
 	rasdstoff = dstoff * fheight;
 	if (scr->active) {
 		vga_gdc_write(vh, mode, 0x01);
 		if (dstrow == 0 && (srcrow + nrows == scr->type->nrows)) {
 			int cursoron = scr->cursoron;
 			if (cursoron)
 				/* Disable cursor. */
 				vga_raster_cursor(scr, 0,
 				    scr->cursorrow, scr->cursorcol);
 			/* scroll up whole screen */
 			if ((scr->dispoffset + srcrow * ncols * fheight)
 			    <= scr->maxdispoffset)
 				scr->dispoffset += srcrow * ncols * fheight;
 			else {
 				bus_space_copy_region_1(memt, memh,
 				    scr->dispoffset + rassrcoff,
 				    memh, scr->mindispoffset,
 				    nrows * ncols * fheight);
 				scr->dispoffset = scr->mindispoffset;
+			}
 			vga_6845_write(vh, startadrh, scr->dispoffset >> 8);
 			vga_6845_write(vh, startadrl, scr->dispoffset);
 			if (cursoron)
 				/* Enable cursor. */
 				vga_raster_cursor(scr, 1, scr->cursorrow,
 				    scr->cursorcol);
 		} else
 			bus_space_copy_region_1(memt, memh,
 			    scr->dispoffset + rassrcoff, memh,
 			    scr->dispoffset + rasdstoff,
 			    nrows * ncols * fheight);
+	}
 	memcpy(&scr->mem[dstoff], &scr->mem[srcoff],
 	    nrows * ncols * sizeof(struct vga_scrmem));
+}
-void
+static void
 vga_raster_eraserows(void *id, int startrow, int nrows, long fillattr)
+{
 	struct vgascreen *scr = id;
 	struct vga_handle *vh = scr->hdl;
 	bus_space_tag_t memt = vh->vh_memt;
 	bus_space_handle_t memh = vh->vh_memh;
 	bus_size_t off, count;
 	bus_size_t rasoff, rascount;
 	int i;
 	off = startrow * scr->type->ncols;
 	count = nrows * scr->type->ncols;
 	rasoff = off * scr->type->fontheight;
 	rascount = count * scr->type->fontheight;
 	if (scr->active) {
 		u_int8_t bgcolor = (fillattr >> 4) & 0x0F;
 		/* Paint background. */
 		vga_gdc_write(vh, mode, 0x02);
 		if (scr->type->ncols % 4 == 0) {
 			u_int32_t fill = bgcolor | (bgcolor << 8) |
 			    (bgcolor << 16) | (bgcolor << 24);
 			/* We can speed up I/O */
 			for (i = rasoff; i < rasoff + rascount; i += 4)
 				bus_space_write_4(memt, memh,
 				    scr->dispoffset + i, fill);
 		} else {
 			u_int16_t fill = bgcolor | (bgcolor << 8);
 			for (i = rasoff; i < rasoff + rascount; i += 2)
 				bus_space_write_2(memt, memh,
 				    scr->dispoffset + i, fill);
+		}
+	}
 	for (i = 0; i < count; i++) {
 		scr->mem[off + i].ch = ' ';
 		scr->mem[off + i].attr = fillattr;
 		scr->mem[off + i].second = 0;
 		scr->mem[off + i].enc = scr->encoding;
+	}
+}
 static int
 vga_raster_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);
+}
-void
+static void
 vga_restore_screen(struct vgascreen *scr,
     const struct wsscreen_descr *type, struct vga_scrmem *mem)
+{
 	int i, j, off, tmp;
 	tmp = scr->encoding;
 	for (i = 0; i < type->nrows; i++) {
 		for (j = 0; j < type->ncols; j++) {
 			off = i * type->ncols + j;
 			if (mem[off].second != 1) {
 				scr->encoding = mem[off].enc;
 				vga_raster_putchar(scr, i, j, mem[off].ch,
 				    mem[off].attr);
+			}
+		}
+	}
 	scr->encoding = tmp;
+}
-void
+static void
 vga_raster_setscreentype(struct vga_config *vc,
     const struct wsscreen_descr *type)
+{
 	struct vga_handle *vh = &vc->hdl;
 	struct vga_moderegs moderegs;
 	vga_setup_regs((struct videomode *)type->modecookie, &moderegs);
 	vga_set_mode(vh, &moderegs);
+}
 #ifdef WSDISPLAY_CUSTOM_OUTPUT
-void
+static void
 vga_raster_replaceattr(void *id, long oldattr, long newattr)
+{
 	struct vgascreen *scr = id;
 	const struct wsscreen_descr *type = scr->type;
 	int off;
 	for (off = 0; off < type->nrows * type->ncols; off++) {
 		if (scr->mem[off].attr == oldattr)
 			scr->mem[off].attr = newattr;
+	}
 	/* Repaint the whole screen, if needed */
 	if (scr->active)
 		vga_restore_screen(scr, type, scr->mem);
+}
 #endif /* WSDISPLAY_CUSTOM_OUTPUT */
 void
 vga_resume(struct vga_softc *sc)
+{
 #ifdef VGA_RESET_ON_RESUME
 	vga_initregs(&sc->sc_vc->hdl);
 #endif
+}

 @@ -1,223 +1,221 @@
-/* $NetBSD: vgavar.h,v 1.29 2010/12/09 23:33:30 christos Exp $ */
+/* $NetBSD: vgavar.h,v 1.30 2013/01/21 19:49:15 mlelstv 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/callout.h>
 #include "opt_vga.h"
 struct vga_handle {
 	struct pcdisplay_handle vh_ph;
 	bus_space_handle_t vh_ioh_vga, vh_allmemh;
 	int vh_mono;
 };
 #define vh_iot 		vh_ph.ph_iot
 #define vh_memt 	vh_ph.ph_memt
 #define vh_ioh_6845 	vh_ph.ph_ioh_6845
 #define vh_memh 	vh_ph.ph_memh
 struct vga_funcs {
 	int (*vf_ioctl)(void *, u_long, void *, int, struct lwp *);
 	paddr_t (*vf_mmap)(void *, off_t, int);
 };
 struct vga_config {
 	struct vga_handle hdl;
 	struct vga_softc *softc;
 	int nscreens;
 	LIST_HEAD(, vgascreen) screens;
 	struct vgascreen *active; /* current display */
 	const struct wsscreen_descr *currenttype;
 	int vc_biosmapped;
 	bus_space_tag_t vc_biostag;
 	bus_space_handle_t vc_bioshdl;
 	struct vgascreen *wantedscreen;
 	void (*switchcb)(void *, int, int);
 	void *switchcbarg;
 	struct callout vc_switch_callout;
 	int vc_quirks;
 	int vc_type;
 	const struct vga_funcs *vc_funcs;
 	u_int8_t palette[256 * 3];
 #ifndef VGA_RASTERCONSOLE
 	int currentfontset1, currentfontset2;
 	int vc_nfontslots;
 	struct egavga_font *vc_fonts[8]; /* currently loaded */
 	TAILQ_HEAD(, egavga_font) vc_fontlist; /* LRU queue */
 #else
 	int nfonts;
 	LIST_HEAD(, vga_raster_font) vc_fontlist;
 #endif /* !VGA_RASTERCONSOLE */
 };
 struct vga_softc {
 	device_t sc_dev;
 	struct vga_config *sc_vc;
 };
 static __inline u_int8_t 	_vga_attr_read(struct vga_handle *, int);
 static __inline void 	_vga_attr_write(struct vga_handle *, int, u_int8_t);
 static __inline u_int8_t 	_vga_ts_read(struct vga_handle *, int);
 static __inline void 	_vga_ts_write(struct vga_handle *, int, u_int8_t);
 static __inline u_int8_t 	_vga_gdc_read(struct vga_handle *, int);
 static __inline void 	_vga_gdc_write(struct vga_handle *, int, u_int8_t);
 #define	vga_raw_read(vh, reg) \
     bus_space_read_1(vh->vh_iot, vh->vh_ioh_vga, reg)
 #define	vga_raw_write(vh, reg, value) \
     bus_space_write_1(vh->vh_iot, vh->vh_ioh_vga, reg, value)
 #define	vga_enable(vh) \
     vga_raw_write(vh, 0, 0x20)
 #define vga_reset_state(vh) \
     (void) bus_space_read_1(vh->vh_iot, vh->vh_ioh_6845, 10)
 static __inline u_int8_t
 _vga_attr_read(struct vga_handle *vh, int reg)
+{
 	u_int8_t res;
 	/* reset state */
 	vga_reset_state(vh);
 	vga_raw_write(vh, VGA_ATC_INDEX, reg);
 	res = vga_raw_read(vh, VGA_ATC_DATAR);
 	/* XXX unneeded? */
 	vga_reset_state(vh);
 	vga_enable(vh);
 	return res;
+}
 static __inline void
 _vga_attr_write(struct vga_handle *vh, int reg, u_int8_t val)
+{
 	vga_reset_state(vh);
 	vga_raw_write(vh, VGA_ATC_INDEX, reg);
 	vga_raw_write(vh, VGA_ATC_DATAW, val);
 	/* XXX unneeded? */
 	vga_reset_state(vh);
 	vga_enable(vh);
+}
 static __inline u_int8_t
 _vga_ts_read(struct vga_handle *vh, int reg)
+{
 	vga_raw_write(vh, VGA_TS_INDEX, reg);
 	return vga_raw_read(vh, VGA_TS_DATA);
+}
 static __inline void
 _vga_ts_write(struct vga_handle *vh, int reg, u_int8_t val)
+{
 	vga_raw_write(vh, VGA_TS_INDEX, reg);
 	vga_raw_write(vh, VGA_TS_DATA, val);
+}
 static __inline u_int8_t
 _vga_gdc_read(struct vga_handle *vh, int reg)
+{
 	vga_raw_write(vh, VGA_GDC_INDEX, reg);
 	return vga_raw_read(vh, VGA_GDC_DATA);
+}
 static __inline void
 _vga_gdc_write(struct vga_handle *vh, int reg, u_int8_t val)
+{
 	vga_raw_write(vh, VGA_GDC_INDEX, reg);
 	vga_raw_write(vh, VGA_GDC_DATA, val);
+}
 #define vga_attr_read(vh, reg) \
 	_vga_attr_read(vh, offsetof(struct reg_vgaattr, reg))
 #define vga_attr_write(vh, reg, val) \
 	_vga_attr_write(vh, offsetof(struct reg_vgaattr, reg), val)
 #define vga_ts_read(vh, reg) \
 	_vga_ts_read(vh, offsetof(struct reg_vgats, reg))
 #define vga_ts_write(vh, reg, val) \
 	_vga_ts_write(vh, offsetof(struct reg_vgats, reg), val)
 #define vga_gdc_read(vh, reg) \
 	_vga_gdc_read(vh, offsetof(struct reg_vgagdc, reg))
 #define vga_gdc_write(vh, reg, val) \
 	_vga_gdc_write(vh, offsetof(struct reg_vgagdc, reg), val)
 #define vga_6845_read(vh, reg) \
 	pcdisplay_6845_read(&(vh)->vh_ph, reg)
 #define vga_6845_write(vh, reg, val) \
 	pcdisplay_6845_write(&(vh)->vh_ph, reg, val)
 #define _vga_6845_read(vh, reg) \
 	_pcdisplay_6845_read(&(vh)->vh_ph, reg)
 #define _vga_6845_write(vh, reg, val) \
 	_pcdisplay_6845_write(&(vh)->vh_ph, reg, val)
 int	vga_common_probe(bus_space_tag_t, bus_space_tag_t);
 void	vga_common_attach(struct vga_softc *, bus_space_tag_t,
 			  bus_space_tag_t, int, int, const struct vga_funcs *);
 #define VGA_QUIRK_ONEFONT	0x01
 #define VGA_QUIRK_NOFASTSCROLL	0x02
 int	vga_is_console(bus_space_tag_t, int);
 int	vga_cnattach(bus_space_tag_t, bus_space_tag_t, int, int);
 int	vga_cndetach(void);
 void	vga_resume(struct vga_softc *);
 #ifndef VGA_RASTERCONSOLE
 struct wsscreen_descr;
 void 	vga_loadchars(struct vga_handle *, int, int, int, int, const char *);
 void 	vga_readoutchars(struct vga_handle *, int, int, int, int, char *);
 #ifdef VGA_CONSOLE_ATI_BROKEN_FONTSEL
 void 	vga_copyfont01(struct vga_handle *);
 #endif
 void 	vga_setfontset(struct vga_handle *, int, int);
 void 	vga_setscreentype(struct vga_handle *, const struct wsscreen_descr *);
 #else /* !VGA_RASTERCONSOLE */
 void 	vga_load_builtinfont(struct vga_handle *, u_int8_t *, int, int);
 #endif /* !VGA_RASTERCONSOLE */
 void	vga_reset(struct vga_handle *, void (*)(struct vga_handle *));
 void	vga_initregs(struct vga_handle *);
 void	vga_save_palette(struct vga_config *);
 void	vga_restore_palette(struct vga_config *);
 extern int vga_no_builtinfont;