xref: /netbsd-src/sys/dev/wscons/wsdisplay_vcons.c (revision fd6a8bdebd774c17e15769f32449187c9632104f)

/*	$NetBSD: wsdisplay_vcons.c,v 1.69 2024/10/20 09:25:00 mlelstv Exp $ */

/*-
 * Copyright (c) 2005, 2006 Michael Lorenz
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: wsdisplay_vcons.c,v 1.69 2024/10/20 09:25:00 mlelstv Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/buf.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/mman.h>
#include <sys/tty.h>
#include <sys/conf.h>
#include <sys/proc.h>
#include <sys/kthread.h>
#include <sys/tprintf.h>
#include <sys/atomic.h>
#include <sys/kmem.h>

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

#include <dev/wscons/wsdisplay_vconsvar.h>

#ifdef _KERNEL_OPT
#include "opt_wsemul.h"
#include "opt_wsdisplay_compat.h"
#include "opt_vcons.h"
#endif

#ifdef VCONS_DEBUG
#define DPRINTF printf
#else
#define DPRINTF if (0) printf
#endif

struct vcons_data_private {
	/* accessops */
	int (*ioctl)(void *, void *, u_long, void *, int, struct lwp *);

	/* rasops */
	void (*copycols)(void *, int, int, int, int);
	void (*erasecols)(void *, int, int, int, long);
	void (*copyrows)(void *, int, int, int);
	void (*eraserows)(void *, int, int, long);
	void (*cursor)(void *, int, int, int);

	/* virtual screen management stuff */
	void (*switch_cb)(void *, int, int);
	void *switch_cb_arg;
	struct callout switch_callout;
	uint32_t switch_pending;
	LIST_HEAD(, vcons_screen) screens;
	struct vcons_screen *wanted;
	const struct wsscreen_descr *currenttype;
	struct wsscreen_descr *defaulttype;
	int switch_poll_count;

#ifdef VCONS_DRAW_INTR
	int cells;
	long *attrs;
	uint32_t *chars;
	int cursor_offset;
	callout_t intr;
	int intr_valid;
	void *intr_softint;
	int use_intr;		/* use intr drawing when non-zero */
#endif
};

static void vcons_dummy_init_screen(void *, struct vcons_screen *, int,
	    long *);

static int  vcons_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static int  vcons_alloc_screen(void *, const struct wsscreen_descr *, void **,
	    int *, int *, long *);
static void vcons_free_screen(void *, void *);
static int  vcons_show_screen(void *, void *, int, void (*)(void *, int, int),
	    void *);
static int  vcons_load_font(void *, void *, struct wsdisplay_font *);

#ifdef WSDISPLAY_SCROLLSUPPORT
static void vcons_scroll(void *, void *, int);
static void vcons_do_scroll(struct vcons_screen *);
#endif

static void vcons_do_switch(void *);

/* methods that work only on text buffers */
static void vcons_copycols_buffer(void *, int, int, int, int);
static void vcons_erasecols_buffer(void *, int, int, int, long);
static void vcons_copyrows_buffer(void *, int, int, int);
static void vcons_eraserows_buffer(void *, int, int, long);
static int vcons_putchar_buffer(void *, int, int, u_int, long);

/*
 * actual wrapper methods which call both the _buffer ones above and the
 * driver supplied ones to do the drawing
 */
static void vcons_copycols(void *, int, int, int, int);
static void vcons_erasecols(void *, int, int, int, long);
static void vcons_copyrows(void *, int, int, int);
static void vcons_eraserows(void *, int, int, long);
static void vcons_putchar(void *, int, int, u_int, long);
#ifdef VCONS_DRAW_INTR
static void vcons_erasecols_cached(void *, int, int, int, long);
static void vcons_eraserows_cached(void *, int, int, long);
static void vcons_putchar_cached(void *, int, int, u_int, long);
#endif
static void vcons_cursor(void *, int, int, int);
static void vcons_cursor_noread(void *, int, int, int);

/*
 * methods that avoid framebuffer reads
 */
static void vcons_copycols_noread(void *, int, int, int, int);
static void vcons_copyrows_noread(void *, int, int, int);


/* support for reading/writing text buffers. For wsmoused */
static int  vcons_putwschar(struct vcons_screen *, struct wsdisplay_char *);
static int  vcons_getwschar(struct vcons_screen *, struct wsdisplay_char *);

static void vcons_lock(struct vcons_screen *);
static void vcons_unlock(struct vcons_screen *);

#ifdef VCONS_DRAW_INTR
static void vcons_intr(void *);
static void vcons_softintr(void *);
static void vcons_init_thread(void *);
static void vcons_invalidate_cache(struct vcons_data *);
#endif

static inline bool
vcons_use_intr(const struct vcons_screen *scr)
{
#ifdef VCONS_DRAW_INTR
	return scr->scr_vd->private->use_intr;
#else
	return false;
#endif
}

static inline void
vcons_dirty(struct vcons_screen *scr)
{
#ifdef VCONS_DRAW_INTR
	membar_release();
	atomic_inc_uint(&scr->scr_dirty);
#endif
}

static int
vcons_init_common(struct vcons_data *vd, void *cookie,
    struct wsscreen_descr *def, struct wsdisplay_accessops *ao,
    int enable_intr)
{
	struct vcons_data_private *vdp;

	/* zero out everything so we can rely on untouched fields being 0 */
	memset(vd, 0, sizeof(struct vcons_data));

	vd->private = vdp = kmem_zalloc(sizeof(*vdp), KM_SLEEP);
	vd->cookie = cookie;

	vd->init_screen = vcons_dummy_init_screen;
	vd->show_screen_cb = NULL;

	/* keep a copy of the accessops that we replace below with our
	 * own wrappers */
	vdp->ioctl = ao->ioctl;

	/* configure the accessops */
	ao->ioctl = vcons_ioctl;
	ao->alloc_screen = vcons_alloc_screen;
	ao->free_screen = vcons_free_screen;
	ao->show_screen = vcons_show_screen;
	ao->load_font = vcons_load_font;
#ifdef WSDISPLAY_SCROLLSUPPORT
	ao->scroll = vcons_scroll;
#endif

	LIST_INIT(&vdp->screens);
	vd->active = NULL;
	vdp->wanted = NULL;
	vdp->currenttype = def;
	vdp->defaulttype = def;
	callout_init(&vdp->switch_callout, 0);
	callout_setfunc(&vdp->switch_callout, vcons_do_switch, vd);
#ifdef VCONS_DRAW_INTR
	vdp->cells = 0;
	vdp->attrs = NULL;
	vdp->chars = NULL;
	vdp->cursor_offset = -1;
#endif

	/*
	 * a lock to serialize access to the framebuffer.
	 * when switching screens we need to make sure there's no rasops
	 * operation in progress
	 */
#ifdef DIAGNOSTIC
	vdp->switch_poll_count = 0;
#endif
#ifdef VCONS_DRAW_INTR
	if (enable_intr) {
		vdp->intr_softint = softint_establish(SOFTINT_SERIAL,
		    vcons_softintr, vd);
		callout_init(&vdp->intr, CALLOUT_MPSAFE);
		callout_setfunc(&vdp->intr, vcons_intr, vd);
		vdp->intr_valid = 1;

		if (kthread_create(PRI_NONE, 0, NULL, vcons_init_thread, vd,
		    NULL, "vcons_init") != 0) {
			printf("%s: unable to create thread.\n", __func__);
			return -1;
		}
	}
#endif
	return 0;
}

int
vcons_init(struct vcons_data *vd, void *cookie,
    struct wsscreen_descr *def, struct wsdisplay_accessops *ao)
{
	return vcons_init_common(vd, cookie, def, ao, 1);
}

int
vcons_earlyinit(struct vcons_data *vd, void *cookie,
    struct wsscreen_descr *def, struct wsdisplay_accessops *ao)
{
	return vcons_init_common(vd, cookie, def, ao, 0);
}

static void
vcons_lock(struct vcons_screen *scr)
{
#ifdef VCONS_PARANOIA
	int s;

	s = splhigh();
#endif
	SCREEN_BUSY(scr);
#ifdef VCONS_PARANOIA
	splx(s);
#endif
}

static void
vcons_unlock(struct vcons_screen *scr)
{
#ifdef VCONS_PARANOIA
	int s;

	s = splhigh();
#endif
	SCREEN_IDLE(scr);
#ifdef VCONS_PARANOIA
	splx(s);
#endif
}

static void
vcons_dummy_init_screen(void *cookie,
    struct vcons_screen *scr, int exists,
    long *defattr)
{

	/*
	 * default init_screen() method.
	 * Needs to be overwritten so we bitch and whine in case anyone ends
	 * up in here.
	 */
	printf("vcons_init_screen: dummy function called. Your driver is "
	       "supposed to supply a replacement for proper operation\n");
}

static int
vcons_alloc_buffers(struct vcons_data *vd, struct vcons_screen *scr)
{
	struct rasops_info *ri = &scr->scr_ri;
	int cnt, i;
#ifdef VCONS_DRAW_INTR
	struct vcons_data_private *vdp = vd->private;
	int size;
#endif

	/*
	 * we allocate both chars and attributes in one chunk, attributes first
	 * because they have the (potentially) bigger alignment
	 */
#ifdef WSDISPLAY_SCROLLSUPPORT
	cnt = (ri->ri_rows + WSDISPLAY_SCROLLBACK_LINES) * ri->ri_cols;
	scr->scr_lines_in_buffer = WSDISPLAY_SCROLLBACK_LINES;
	scr->scr_current_line = 0;
	scr->scr_line_wanted = 0;
	scr->scr_offset_to_zero = ri->ri_cols * WSDISPLAY_SCROLLBACK_LINES;
	scr->scr_current_offset = scr->scr_offset_to_zero;
#else
	cnt = ri->ri_rows * ri->ri_cols;
#endif
	scr->scr_attrs = malloc(cnt * (sizeof(long) +
	    sizeof(uint32_t)), M_DEVBUF, M_WAITOK);
	if (scr->scr_attrs == NULL)
		return ENOMEM;

	scr->scr_chars = (uint32_t *)&scr->scr_attrs[cnt];

	/*
	 * fill the attribute buffer with *defattr, chars with 0x20
	 * since we don't know if the driver tries to mimic firmware output or
	 * reset everything we do nothing to VRAM here, any driver that feels
	 * the need to clear screen or something will have to do it on its own
	 * Additional screens will start out in the background anyway so
	 * cleaning or not only really affects the initial console screen
	 */
	for (i = 0; i < cnt; i++) {
		scr->scr_attrs[i] = scr->scr_defattr;
		scr->scr_chars[i] = 0x20;
	}

#ifdef VCONS_DRAW_INTR
	size = ri->ri_cols * ri->ri_rows;
	if (size > vdp->cells) {
		if (vdp->chars != NULL)
			free(vdp->chars, M_DEVBUF);
		if (vdp->attrs != NULL)
			free(vdp->attrs, M_DEVBUF);
		vdp->cells = size;
		vdp->chars = malloc(size * sizeof(uint32_t), M_DEVBUF,
		    M_WAITOK|M_ZERO);
		vdp->attrs = malloc(size * sizeof(long), M_DEVBUF,
		    M_WAITOK|M_ZERO);
		vcons_invalidate_cache(vd);
	} else if (SCREEN_IS_VISIBLE(scr))
		vcons_invalidate_cache(vd);
#endif
	return 0;
}

int
vcons_init_screen(struct vcons_data *vd, struct vcons_screen *scr,
    int existing, long *defattr)
{
	struct vcons_data_private *vdp = vd->private;
	struct rasops_info *ri = &scr->scr_ri;
	int i;

	scr->scr_cookie = vd->cookie;
	scr->scr_vd = scr->scr_origvd = vd;
	scr->scr_busy = 0;

	if (scr->scr_type == NULL)
		scr->scr_type = vdp->defaulttype;

	/*
	 * call the driver-supplied init_screen function which is expected
	 * to set up rasops_info, override cursor() and probably others
	 */
	vd->init_screen(vd->cookie, scr, existing, defattr);

	/*
	 * save the non virtual console aware rasops and replace them with
	 * our wrappers
	 */
	vdp->eraserows = ri->ri_ops.eraserows;
	vdp->erasecols = ri->ri_ops.erasecols;
	scr->putchar   = ri->ri_ops.putchar;

	if (scr->scr_flags & VCONS_NO_COPYCOLS) {
		vdp->copycols  = vcons_copycols_noread;
	} else {
		vdp->copycols = ri->ri_ops.copycols;
	}

	if (scr->scr_flags & VCONS_NO_COPYROWS) {
		vdp->copyrows  = vcons_copyrows_noread;
	} else {
		vdp->copyrows = ri->ri_ops.copyrows;
	}

	if (scr->scr_flags & VCONS_NO_CURSOR) {
		vdp->cursor  = vcons_cursor_noread;
	} else {
		vdp->cursor = ri->ri_ops.cursor;
	}

	ri->ri_ops.eraserows = vcons_eraserows;
	ri->ri_ops.erasecols = vcons_erasecols;
	ri->ri_ops.putchar   = vcons_putchar;
	ri->ri_ops.cursor    = vcons_cursor;
	ri->ri_ops.copycols  = vcons_copycols;
	ri->ri_ops.copyrows  = vcons_copyrows;


	ri->ri_hw = scr;

	i = ri->ri_ops.allocattr(ri, WS_DEFAULT_FG, WS_DEFAULT_BG, 0, defattr);
	if (i != 0) {
#ifdef DIAGNOSTIC
		printf("vcons: error allocating attribute %d\n", i);
#endif
		scr->scr_defattr = 0;
	} else
		scr->scr_defattr = *defattr;

	vcons_alloc_buffers(vd, scr);

	if (vd->active == NULL) {
		vd->active = scr;
		SCREEN_VISIBLE(scr);
	}

	if (existing) {
		SCREEN_VISIBLE(scr);
		vd->active = scr;
	} else {
		SCREEN_INVISIBLE(scr);
	}

	LIST_INSERT_HEAD(&vdp->screens, scr, next);
	return 0;
}

static int
vcons_load_font(void *v, void *cookie, struct wsdisplay_font *f)
{
	struct vcons_data *vd = v;
	struct vcons_data_private *vdp = vd->private;
	struct vcons_screen *scr = cookie;
	struct rasops_info *ri;
	struct wsdisplay_font *font;
	int flags = WSFONT_FIND_BITMAP, fcookie;

	/* see if we're asked to add a font or use it */
	if (scr == NULL)
		return 0;

	ri = &scr->scr_ri;

	/* see if the driver knows how to handle multiple fonts */
	if ((scr->scr_flags & VCONS_LOADFONT) == 0) {
		return EOPNOTSUPP;
	}

	/* now see what fonts we can use */
	if (ri->ri_flg & RI_ENABLE_ALPHA) {
		flags |= WSFONT_FIND_ALPHA;
	}

	fcookie = wsfont_find(f->name, 0, 0, 0,
	    /* bitorder */
	    scr->scr_flags & VCONS_FONT_BITS_R2L ?
	      WSDISPLAY_FONTORDER_R2L : WSDISPLAY_FONTORDER_L2R,
	    /* byteorder */
	    scr->scr_flags & VCONS_FONT_BYTES_R2L ?
	      WSDISPLAY_FONTORDER_R2L : WSDISPLAY_FONTORDER_L2R,
	    flags);
	if (fcookie == -1)
		return EINVAL;

	wsfont_lock(fcookie, &font);
	if (font == NULL)
		return EINVAL;

	/* ok, we got a font. Now clear the screen with the old parameters */
	if (SCREEN_IS_VISIBLE(scr))
		vdp->eraserows(ri, 0, ri->ri_rows, scr->scr_defattr);

	vcons_lock(vd->active);
#ifdef VCONS_DRAW_INTR
	callout_halt(&vdp->intr, NULL);
#endif
	/* set the new font and re-initialize things */
	ri->ri_font = font;
	wsfont_unlock(ri->ri_wsfcookie);
	ri->ri_wsfcookie = fcookie;

	vd->init_screen(vd->cookie, scr, 1, &scr->scr_defattr);
	DPRINTF("caps %x %x\n", scr->scr_type->capabilities, ri->ri_caps);
	if (scr->scr_type->capabilities & WSSCREEN_RESIZE) {
		scr->scr_type->nrows = ri->ri_rows;
		scr->scr_type->ncols = ri->ri_cols;
		DPRINTF("new size %d %d\n", ri->ri_rows, ri->ri_cols);
	}


	/* now, throw the old buffers away */
	if (scr->scr_attrs)
		free(scr->scr_attrs, M_DEVBUF);
	/* allocate new buffers */
	vcons_alloc_buffers(vd, scr);

	/* save the potentially changed ri_ops */
	vdp->eraserows = ri->ri_ops.eraserows;
	vdp->erasecols = ri->ri_ops.erasecols;
	scr->putchar   = ri->ri_ops.putchar;
	vdp->cursor    = ri->ri_ops.cursor;

	if (scr->scr_flags & VCONS_NO_COPYCOLS) {
		vdp->copycols  = vcons_copycols_noread;
	} else {
		vdp->copycols = ri->ri_ops.copycols;
	}

	if (scr->scr_flags & VCONS_NO_COPYROWS) {
		vdp->copyrows  = vcons_copyrows_noread;
	} else {
		vdp->copyrows = ri->ri_ops.copyrows;
	}

	if (scr->scr_flags & VCONS_NO_CURSOR) {
		vdp->cursor  = vcons_cursor_noread;
	} else {
		vdp->cursor = ri->ri_ops.cursor;
	}

	/* and put our wrappers back */
	ri->ri_ops.eraserows = vcons_eraserows;
	ri->ri_ops.erasecols = vcons_erasecols;
	ri->ri_ops.putchar   = vcons_putchar;
	ri->ri_ops.cursor    = vcons_cursor;
	ri->ri_ops.copycols  = vcons_copycols;
	ri->ri_ops.copyrows  = vcons_copyrows;
	vcons_unlock(vd->active);

	/* notify things that we're about to redraw */
	if (vd->show_screen_cb != NULL)
		vd->show_screen_cb(scr, vd->show_screen_cookie);

#ifdef VCONS_DRAW_INTR
	/*
	 * XXX
	 * Something(tm) craps all over VRAM somewhere up there if we're
	 * using VCONS_DRAW_INTR. Until I figure out what causes it, just
	 * redraw the screen for now.
	 */
	vcons_redraw_screen(vd->active);
	callout_schedule(&vdp->intr, mstohz(33));
#endif
	/* no need to draw anything, wsdisplay should reset the terminal */

	return 0;
}

static void
vcons_do_switch(void *arg)
{
	struct vcons_data *vd = arg;
	struct vcons_data_private *vdp = vd->private;
	struct vcons_screen *scr, *oldscr;

	scr = vdp->wanted;
	if (!scr) {
		printf("vcons_switch_screen: disappeared\n");
		vdp->switch_cb(vdp->switch_cb_arg, EIO, 0);
		return;
	}
	oldscr = vd->active; /* can be NULL! */

	/*
	 * if there's an old, visible screen we mark it invisible and wait
	 * until it's not busy so we can safely switch
	 */
	if (oldscr != NULL) {
		SCREEN_INVISIBLE(oldscr);
		if (SCREEN_IS_BUSY(oldscr)) {
			callout_schedule(&vdp->switch_callout, 1);
#ifdef DIAGNOSTIC
			/* bitch if we wait too long */
			vdp->switch_poll_count++;
			if (vdp->switch_poll_count > 100) {
				panic("vcons: screen still busy");
			}
#endif
			return;
		}
		/* invisible screen -> no visible cursor image */
		oldscr->scr_ri.ri_flg &= ~RI_CURSOR;
#ifdef DIAGNOSTIC
		vdp->switch_poll_count = 0;
#endif
	}

	if (scr == oldscr)
		return;

#ifdef DIAGNOSTIC
	if (SCREEN_IS_VISIBLE(scr))
		printf("vcons_switch_screen: already active");
#endif

#ifdef notyet
	if (vdp->currenttype != type) {
		vcons_set_screentype(vd, type);
		vdp->currenttype = type;
	}
#endif

	SCREEN_VISIBLE(scr);
	vd->active = scr;
	vdp->wanted = NULL;

#ifdef VCONS_DRAW_INTR
	vcons_invalidate_cache(vd);
#endif

	if (vd->show_screen_cb != NULL)
		vd->show_screen_cb(scr, vd->show_screen_cookie);

	if ((scr->scr_flags & VCONS_NO_REDRAW) == 0)
		vcons_redraw_screen(scr);

	if (vdp->switch_cb)
		vdp->switch_cb(vdp->switch_cb_arg, 0, 0);
}

void
vcons_redraw_screen(struct vcons_screen *scr)
{
	uint32_t *charptr = scr->scr_chars, c;
	long *attrptr = scr->scr_attrs, a, last_a = 0, mask, cmp, acmp;
	struct rasops_info *ri = &scr->scr_ri;
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
	int i, j, offset, boffset = 0, start = -1;

	mask = 0x00ff00ff;	/* background and flags */
	cmp = 0xffffffff;	/* never match anything */
	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {

		/*
		 * only clear the screen when RI_FULLCLEAR is set since we're
		 * going to overwrite every single character cell anyway
		 */
		if (ri->ri_flg & RI_FULLCLEAR) {
			vdp->eraserows(ri, 0, ri->ri_rows,
			    scr->scr_defattr);
			cmp = scr->scr_defattr & mask;
		}

		/* redraw the screen */
#ifdef WSDISPLAY_SCROLLSUPPORT
		offset = scr->scr_current_offset;
#else
		offset = 0;
#endif
		for (i = 0; i < ri->ri_rows; i++) {
			start = -1;
			for (j = 0; j < ri->ri_cols; j++) {
				/*
				 * no need to use the wrapper function - we
				 * don't change any characters or attributes
				 * and we already made sure the screen we're
				 * working on is visible
				 */
				c = charptr[offset];
				a = attrptr[offset];
				acmp = a & mask;
				if (c == ' ') {
					/*
					 * if we already erased the background
					 * and if this blank uses the same
					 * colour and flags we don't need to do
					 * anything here
					 */
					if (acmp == cmp && start == -1)
						goto next;
					/*
					 * see if we can optimize things a
					 * little bit by drawing stretches of
					 * blanks using erasecols
					 */

					if (start == -1) {
						start = j;
						last_a = acmp;
					} else if (acmp != last_a) {
						/*
						 * different attr, need to
						 * flush & restart
						 */
						vdp->erasecols(ri, i, start,
						    j - start, last_a);
						start = j;
						last_a = acmp;
					}
				} else {
					if (start != -1) {
						vdp->erasecols(ri, i, start,
						    j - start, last_a);
						start = -1;
					}

					scr->putchar(ri, i, j, c, a);
				}
next:
#ifdef VCONS_DRAW_INTR
				vdp->chars[boffset] = charptr[offset];
				vdp->attrs[boffset] = attrptr[offset];
#endif
				offset++;
				boffset++;
			}
			/* end of the line - draw all deferred blanks, if any */
			if (start != -1) {
				vdp->erasecols(ri, i, start, j - start, last_a);
			}
		}
		ri->ri_flg &= ~RI_CURSOR;
		scr->scr_vd->private->cursor(ri, 1, ri->ri_crow, ri->ri_ccol);
#ifdef VCONS_DRAW_INTR
		vdp->cursor_offset = ri->ri_crow * ri->ri_cols + ri->ri_ccol;
#endif
	}
	vcons_unlock(scr);
}

void
vcons_update_screen(struct vcons_screen *scr)
{
#ifdef VCONS_DRAW_INTR
	uint32_t *charptr = scr->scr_chars;
	long *attrptr = scr->scr_attrs;
	struct rasops_info *ri = &scr->scr_ri;
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
	int i, j, offset, boffset = 0;

	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {

		/* redraw the screen */
#ifdef WSDISPLAY_SCROLLSUPPORT
		offset = scr->scr_current_offset;
#else
		offset = 0;
#endif
		/*
		 * we mark the character cell occupied by the cursor as dirty
		 * so we don't have to deal with it
		 * notice that this isn't necessarily the position where rasops
		 * thinks it is, just where we drew it the last time
		 */
		if (vdp->cursor_offset >= 0)
			vdp->attrs[vdp->cursor_offset] = 0xffffffff;

		for (i = 0; i < ri->ri_rows; i++) {
			for (j = 0; j < ri->ri_cols; j++) {
				/*
				 * no need to use the wrapper function - we
				 * don't change any characters or attributes
				 * and we already made sure the screen we're
				 * working on is visible
				 */
				if ((vdp->chars[boffset] != charptr[offset]) ||
				    (vdp->attrs[boffset] != attrptr[offset])) {
					scr->putchar(ri, i, j,
				 	   charptr[offset], attrptr[offset]);
					vdp->chars[boffset] = charptr[offset];
					vdp->attrs[boffset] = attrptr[offset];
				}
				offset++;
				boffset++;
			}
		}
		ri->ri_flg &= ~RI_CURSOR;
		scr->scr_vd->private->cursor(ri, 1, ri->ri_crow, ri->ri_ccol);
		vdp->cursor_offset = ri->ri_crow * ri->ri_cols + ri->ri_ccol;
	}
	vcons_unlock(scr);
#else  /* !VCONS_DRAW_INTR */
	vcons_redraw_screen(scr);
#endif
}

static int
vcons_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
	struct lwp *l)
{
	struct vcons_data *vd = v;
	struct vcons_data_private *vdp = vd->private;
	int error = 0;


	switch (cmd) {
	case WSDISPLAYIO_GETWSCHAR:
		error = vcons_getwschar((struct vcons_screen *)vs,
			(struct wsdisplay_char *)data);
		break;

	case WSDISPLAYIO_PUTWSCHAR:
		error = vcons_putwschar((struct vcons_screen *)vs,
			(struct wsdisplay_char *)data);
		break;

	case WSDISPLAYIO_SET_POLLING: {
		int poll = *(int *)data;

		/* first call the driver's ioctl handler */
		if (vdp->ioctl != NULL)
			error = (*vdp->ioctl)(v, vs, cmd, data, flag, l);
		if (poll) {
			vcons_enable_polling(vd);
			vcons_hard_switch(LIST_FIRST(&vdp->screens));
		} else
			vcons_disable_polling(vd);
		}
		break;

	case WSDISPLAYIO_GFONT: {
		struct wsdisplay_getfont *gf = data;
		size_t actual;
		struct wsdisplay_font *font;
		const char *fontname;

		font = ((struct vcons_screen *)vs)->scr_ri.ri_font;
		fontname = font && font->name ? font->name : "";
		error = copyoutstr(fontname, gf->gf_name, gf->gf_size, &actual);
		if (!error)
			gf->gf_actual = actual;
		}
		break;

	default:
		if (vdp->ioctl != NULL)
			error = (*vdp->ioctl)(v, vs, cmd, data, flag, l);
		else
			error = EPASSTHROUGH;
	}

	return error;
}

static int
vcons_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
    int *curxp, int *curyp, long *defattrp)
{
	struct vcons_data *vd = v;
	struct vcons_data_private *vdp = vd->private;
	struct vcons_screen *scr;
	struct wsscreen_descr *t = __UNCONST(type);
	int ret;

	scr = malloc(sizeof(struct vcons_screen), M_DEVBUF, M_WAITOK | M_ZERO);
	if (scr == NULL)
		return ENOMEM;

	scr->scr_flags = 0;
	scr->scr_status = 0;
	scr->scr_busy = 0;
	scr->scr_type = __UNCONST(type);

	ret = vcons_init_screen(vd, scr, 0, defattrp);
	if (ret != 0) {
		free(scr, M_DEVBUF);
		return ret;
	}
	if (t->capabilities & WSSCREEN_RESIZE) {
		t->nrows = scr->scr_ri.ri_rows;
		t->ncols = scr->scr_ri.ri_cols;
	}

	if (vd->active == NULL) {
		SCREEN_VISIBLE(scr);
		vd->active = scr;
		vdp->currenttype = type;
	}

	*cookiep = scr;
	*curxp = scr->scr_ri.ri_ccol;
	*curyp = scr->scr_ri.ri_crow;
	return 0;
}

static void
vcons_free_screen(void *v, void *cookie)
{
	struct vcons_data *vd = v;
	struct vcons_screen *scr = cookie;

	vcons_lock(scr);
	/* there should be no rasops activity here */

	LIST_REMOVE(scr, next);

	if ((scr->scr_flags & VCONS_SCREEN_IS_STATIC) == 0) {
		free(scr->scr_attrs, M_DEVBUF);
		free(scr, M_DEVBUF);
	} else {
		/*
		 * maybe we should just restore the old rasops_info methods
		 * and free the character/attribute buffer here?
		 */
#ifdef VCONS_DEBUG
		panic("vcons_free_screen: console");
#else
		printf("vcons_free_screen: console\n");
#endif
	}

	if (vd->active == scr)
		vd->active = NULL;
}

static int
vcons_show_screen(void *v, void *cookie, int waitok,
    void (*cb)(void *, int, int), void *cb_arg)
{
	struct vcons_data *vd = v;
	struct vcons_data_private *vdp = vd->private;
	struct vcons_screen *scr;

	scr = cookie;
	if (scr == vd->active)
		return 0;

	vdp->wanted = scr;
	vdp->switch_cb = cb;
	vdp->switch_cb_arg = cb_arg;
	if (cb) {
		callout_schedule(&vdp->switch_callout, 0);
		return EAGAIN;
	}

	vcons_do_switch(vd);
	return 0;
}

/* wrappers for rasops_info methods */

static void
vcons_copycols_buffer(void *cookie, int row, int srccol, int dstcol, int ncols)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	int from = srccol + row * ri->ri_cols;
	int to = dstcol + row * ri->ri_cols;
	int offset = vcons_offset_to_zero(scr);

	memmove(&scr->scr_attrs[offset + to], &scr->scr_attrs[offset + from],
	    ncols * sizeof(long));
	memmove(&scr->scr_chars[offset + to], &scr->scr_chars[offset + from],
	    ncols * sizeof(uint32_t));

	vcons_dirty(scr);
}

static void
vcons_copycols(void *cookie, int row, int srccol, int dstcol, int ncols)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;

	vcons_copycols_buffer(cookie, row, srccol, dstcol, ncols);

	if (vcons_use_intr(scr))
		return;

	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
#if defined(VCONS_DRAW_INTR)
		vcons_update_screen(scr);
#else
		scr->scr_vd->private->copycols(cookie, row, srccol, dstcol,
		    ncols);
#endif
	}
	vcons_unlock(scr);
}

static void
vcons_copycols_noread(void *cookie, int row, int srccol, int dstcol, int ncols)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
#ifdef VCONS_DRAW_INTR
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
#endif

	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
		int pos, c, offset, ppos;

#ifdef WSDISPLAY_SCROLLSUPPORT
		offset = scr->scr_current_offset;
#else
		offset = 0;
#endif
		ppos = ri->ri_cols * row + dstcol;
		pos = ppos + offset;
		for (c = dstcol; c < (dstcol + ncols); c++) {
#ifdef VCONS_DRAW_INTR
			if ((scr->scr_chars[pos] != vdp->chars[ppos]) ||
			    (scr->scr_attrs[pos] != vdp->attrs[ppos])) {
				scr->putchar(cookie, row, c,
				   scr->scr_chars[pos], scr->scr_attrs[pos]);
				vdp->chars[ppos] = scr->scr_chars[pos];
				vdp->attrs[ppos] = scr->scr_attrs[pos];
			}
#else
			scr->putchar(cookie, row, c, scr->scr_chars[pos],
			    scr->scr_attrs[pos]);
#endif
			pos++;
			ppos++;
		}
		if (ri->ri_crow == row &&
		   (ri->ri_ccol >= dstcol && ri->ri_ccol < (dstcol + ncols )))
			ri->ri_flg &= ~RI_CURSOR;
	}
	vcons_unlock(scr);
}

static void
vcons_erasecols_buffer(void *cookie, int row, int startcol, int ncols, long fillattr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	int start = startcol + row * ri->ri_cols;
	int end = start + ncols, i;
	int offset = vcons_offset_to_zero(scr);

	for (i = start; i < end; i++) {
		scr->scr_attrs[offset + i] = fillattr;
		scr->scr_chars[offset + i] = 0x20;
	}

	vcons_dirty(scr);
}

#ifdef VCONS_DRAW_INTR
static void
vcons_erasecols_cached(void *cookie, int row, int startcol, int ncols, long fillattr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
	int i, pos = row * ri->ri_cols + startcol;

	vdp->erasecols(cookie, row, startcol, ncols, fillattr);
	for (i = pos; i < ncols; i++) {
		vdp->chars[i] = scr->scr_chars[i];
		vdp->attrs[i] = scr->scr_attrs[i];
	}
}
#endif

static void
vcons_erasecols(void *cookie, int row, int startcol, int ncols, long fillattr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;

	vcons_erasecols_buffer(cookie, row, startcol, ncols, fillattr);

	if (vcons_use_intr(scr))
		return;

	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
#ifdef VCONS_DRAW_INTR
		vcons_erasecols_cached(cookie, row, startcol, ncols,
		    fillattr);
#else
		scr->scr_vd->private->erasecols(cookie, row, startcol, ncols,
		    fillattr);
#endif
	}
	vcons_unlock(scr);
}

static void
vcons_copyrows_buffer(void *cookie, int srcrow, int dstrow, int nrows)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	int from, to, len;
	int offset = vcons_offset_to_zero(scr);

	/* do we need to scroll the back buffer? */
	if (dstrow == 0 && offset != 0) {
		from = ri->ri_cols * srcrow;
		to = ri->ri_cols * dstrow;

		memmove(&scr->scr_attrs[to], &scr->scr_attrs[from],
		    offset * sizeof(long));
		memmove(&scr->scr_chars[to], &scr->scr_chars[from],
		    offset * sizeof(uint32_t));
	}
	from = ri->ri_cols * srcrow + offset;
	to = ri->ri_cols * dstrow + offset;
	len = ri->ri_cols * nrows;

	memmove(&scr->scr_attrs[to], &scr->scr_attrs[from],
	    len * sizeof(long));
	memmove(&scr->scr_chars[to], &scr->scr_chars[from],
	    len * sizeof(uint32_t));

	vcons_dirty(scr);
}

static void
vcons_copyrows(void *cookie, int srcrow, int dstrow, int nrows)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;

	vcons_copyrows_buffer(cookie, srcrow, dstrow, nrows);

	if (vcons_use_intr(scr))
		return;

	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
#if defined(VCONS_DRAW_INTR)
		vcons_update_screen(scr);
#else
		scr->scr_vd->private->copyrows(cookie, srcrow, dstrow, nrows);
#endif
	}
	vcons_unlock(scr);
}

static void
vcons_copyrows_noread(void *cookie, int srcrow, int dstrow, int nrows)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
#ifdef VCONS_DRAW_INTR
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
#endif
	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
		int pos, l, c, offset, ppos;

#ifdef WSDISPLAY_SCROLLSUPPORT
		offset = scr->scr_current_offset;
#else
		offset = 0;
#endif
		ppos = ri->ri_cols * dstrow;
		pos = ppos + offset;
		for (l = dstrow; l < (dstrow + nrows); l++) {
			for (c = 0; c < ri->ri_cols; c++) {
#ifdef VCONS_DRAW_INTR
				if ((scr->scr_chars[pos] != vdp->chars[ppos]) ||
				    (scr->scr_attrs[pos] != vdp->attrs[ppos])) {
					scr->putchar(cookie, l, c,
					   scr->scr_chars[pos], scr->scr_attrs[pos]);
					vdp->chars[ppos] = scr->scr_chars[pos];
					vdp->attrs[ppos] = scr->scr_attrs[pos];
				}
#else
				scr->putchar(cookie, l, c, scr->scr_chars[pos],
				    scr->scr_attrs[pos]);
#endif
				pos++;
				ppos++;
			}
		}
		if (ri->ri_crow >= dstrow && ri->ri_crow < (dstrow + nrows))
			ri->ri_flg &= ~RI_CURSOR;
	}
	vcons_unlock(scr);
}

static void
vcons_eraserows_buffer(void *cookie, int row, int nrows, long fillattr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	int offset = vcons_offset_to_zero(scr);
	int start, end, i;

	start = ri->ri_cols * row + offset;
	end = ri->ri_cols * (row + nrows) + offset;

	for (i = start; i < end; i++) {
		scr->scr_attrs[i] = fillattr;
		scr->scr_chars[i] = 0x20;
	}

	vcons_dirty(scr);
}

#ifdef VCONS_DRAW_INTR
static void
vcons_eraserows_cached(void *cookie, int row, int nrows, long fillattr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
	int i, pos = row * ri->ri_cols, end = (row+nrows) * ri->ri_cols;

	for (i = pos; i < end; i++) {
		vdp->chars[i] = 0x20;
		vdp->attrs[i] = fillattr;
	}
	vdp->eraserows(cookie, row, nrows, fillattr);
}
#endif

static void
vcons_eraserows(void *cookie, int row, int nrows, long fillattr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;

	vcons_eraserows_buffer(cookie, row, nrows, fillattr);

	if (vcons_use_intr(scr))
		return;

	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
#ifdef VCONS_DRAW_INTR
		vcons_eraserows_cached(cookie, row, nrows, fillattr);
#else
		scr->scr_vd->private->eraserows(cookie, row, nrows, fillattr);
#endif
	}
	vcons_unlock(scr);
}

static int
vcons_putchar_buffer(void *cookie, int row, int col, u_int c, long attr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	int offset = vcons_offset_to_zero(scr);
	int pos, ret = 0;

	if ((row >= 0) && (row < ri->ri_rows) && (col >= 0) &&
	    (col < ri->ri_cols)) {
		pos = col + row * ri->ri_cols;
		ret = (scr->scr_attrs[pos + offset] != attr) ||
		      (scr->scr_chars[pos + offset] != c);
		scr->scr_attrs[pos + offset] = attr;
		scr->scr_chars[pos + offset] = c;
	}

	if (ret)
		vcons_dirty(scr);
	return ret;
}

#ifdef VCONS_DRAW_INTR
static void
vcons_putchar_cached(void *cookie, int row, int col, u_int c, long attr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
	int pos = row * ri->ri_cols + col;

	if ((vdp->chars == NULL) || (vdp->attrs == NULL)) {
		scr->putchar(cookie, row, col, c, attr);
		return;
	}
	if ((vdp->chars[pos] != c) || (vdp->attrs[pos] != attr)) {
		vdp->attrs[pos] = attr;
		vdp->chars[pos] = c;
		scr->putchar(cookie, row, col, c, attr);
	}
}
#endif

static void
vcons_putchar(void *cookie, int row, int col, u_int c, long attr)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	int need_draw;

	need_draw = vcons_putchar_buffer(cookie, row, col, c, attr);

	if (vcons_use_intr(scr))
		return;

	vcons_lock(scr);
	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
#ifdef VCONS_DRAW_INTR
		if (need_draw)
			vcons_putchar_cached(cookie, row, col, c, attr);
#else
		if (row == ri->ri_crow && col == ri->ri_ccol) {
			ri->ri_flg &= ~RI_CURSOR;
			scr->putchar(cookie, row, col, c, attr);
		} else if (need_draw)
			scr->putchar(cookie, row, col, c, attr);
#endif
	}
	vcons_unlock(scr);
}

static void
vcons_cursor(void *cookie, int on, int row, int col)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;

	if (vcons_use_intr(scr)) {
		vcons_lock(scr);
		if (scr->scr_ri.ri_crow != row || scr->scr_ri.ri_ccol != col) {
			scr->scr_ri.ri_crow = row;
			scr->scr_ri.ri_ccol = col;
			vcons_dirty(scr);
		}
		vcons_unlock(scr);
		return;
	}

	vcons_lock(scr);

	if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) {
		scr->scr_vd->private->cursor(cookie, on, row, col);
	} else {
		scr->scr_ri.ri_crow = row;
		scr->scr_ri.ri_ccol = col;
	}
	vcons_unlock(scr);
}

static void
vcons_cursor_noread(void *cookie, int on, int row, int col)
{
	struct rasops_info *ri = cookie;
	struct vcons_screen *scr = ri->ri_hw;
	int offset = 0, ofs;

#ifdef WSDISPLAY_SCROLLSUPPORT
	offset = scr->scr_current_offset;
#endif
	ofs = offset + ri->ri_crow * ri->ri_cols + ri->ri_ccol;
	if ((ri->ri_flg & RI_CURSOR) &&
	   (((scr->scr_flags & VCONS_DONT_READ) != VCONS_DONT_READ) || on)) {
		scr->putchar(cookie, ri->ri_crow, ri->ri_ccol,
		    scr->scr_chars[ofs], scr->scr_attrs[ofs]);
		ri->ri_flg &= ~RI_CURSOR;
	}
	ri->ri_crow = row;
	ri->ri_ccol = col;
	ofs = offset + ri->ri_crow * ri->ri_cols + ri->ri_ccol;
	if (on) {
		scr->putchar(cookie, row, col, scr->scr_chars[ofs],
#ifdef VCONS_DEBUG_CURSOR_NOREAD
		/* draw a red cursor so we can tell which cursor()
		 * implementation is being used */
		    ((scr->scr_attrs[ofs] & 0xff00ffff) ^ 0x0f000000) |
		      0x00010000);
#else
		    scr->scr_attrs[ofs] ^ 0x0f0f0000);
#endif
		ri->ri_flg |= RI_CURSOR;
	}
}

/* methods to read/write characters via ioctl() */

static int
vcons_putwschar(struct vcons_screen *scr, struct wsdisplay_char *wsc)
{
	long attr;
	struct rasops_info *ri;
	int error;

	KASSERT(scr != NULL);
	KASSERT(wsc != NULL);

	ri = &scr->scr_ri;

	/* allow col as linear index if row == 0 */
	if (wsc->row == 0) {
		if (wsc->col < 0 || wsc->col > (ri->ri_cols * ri->ri_rows))
			return EINVAL;
	    	int rem;
	    	rem = wsc->col % ri->ri_cols;
	    	wsc->row = wsc->col / ri->ri_cols;
	    	DPRINTF("off %d -> %d, %d\n", wsc->col, rem, wsc->row);
	    	wsc->col = rem;
	} else {
		if (__predict_false(wsc->col < 0 || wsc->col >= ri->ri_cols))
			return EINVAL;

		if (__predict_false(wsc->row < 0 || wsc->row >= ri->ri_rows))
			return EINVAL;
	}

	error = ri->ri_ops.allocattr(ri, wsc->foreground,
	    wsc->background, wsc->flags, &attr);
	if (error)
		return error;
	vcons_putchar(ri, wsc->row, wsc->col, wsc->letter, attr);
	DPRINTF("vcons_putwschar(%d, %d, %x, %lx\n", wsc->row, wsc->col,
	    wsc->letter, attr);
	return 0;
}

static int
vcons_getwschar(struct vcons_screen *scr, struct wsdisplay_char *wsc)
{
	int offset;
	long attr;
	struct rasops_info *ri;
	int fg, bg, ul;

	KASSERT(scr != NULL);
	KASSERT(wsc != NULL);

	ri = &scr->scr_ri;

	/* allow col as linear index if row == 0 */
	if (wsc->row == 0) {
		if (wsc->col < 0 || wsc->col > (ri->ri_cols * ri->ri_rows))
			return EINVAL;
	    	int rem;
	    	rem = wsc->col % ri->ri_cols;
	    	wsc->row = wsc->col / ri->ri_cols;
	    	DPRINTF("off %d -> %d, %d\n", wsc->col, rem, wsc->row);
	    	wsc->col = rem;
	} else {
		if (__predict_false(wsc->col < 0 || wsc->col >= ri->ri_cols))
			return EINVAL;

		if (__predict_false(wsc->row < 0 || wsc->row >= ri->ri_rows))
			return EINVAL;
	}

	offset = ri->ri_cols * wsc->row + wsc->col;
	offset += vcons_offset_to_zero(scr);
	wsc->letter = scr->scr_chars[offset];
	attr = scr->scr_attrs[offset];

	DPRINTF("vcons_getwschar: %d, %d, %x, %lx\n", wsc->row,
	    wsc->col, wsc->letter, attr);

	/*
	 * this is ugly. We need to break up an attribute into colours and
	 * flags but there's no rasops method to do that so we must rely on
	 * the 'canonical' encoding.
	 */

	/* only fetches underline attribute */
	/* rasops_unpack_attr(attr, &fg, &bg, &ul); */
	fg = (attr >> 24) & 0xf;
	bg = (attr >> 16) & 0xf;
	ul = (attr & 1);

	wsc->foreground = fg;
	wsc->background = bg;

	/* clear trashed bits and restore underline flag */
	attr &= ~(WSATTR_HILIT | WSATTR_BLINK | WSATTR_UNDERLINE);
	if (ul)
		attr |= WSATTR_UNDERLINE;

	/* restore highlight boost */
	if (attr & WSATTR_HILIT)
		if (wsc->foreground >= 8)
			wsc->foreground -= 8;

	/* we always use colors, even when not stored */
	attr |= WSATTR_WSCOLORS;
	return 0;
}

int
vcons_offset_to_zero(const struct vcons_screen *scr)
{
#ifdef WSDISPLAY_SCROLLSUPPORT
	return scr->scr_offset_to_zero;
#else
	return 0;
#endif
}

#ifdef WSDISPLAY_SCROLLSUPPORT

static void
vcons_scroll(void *cookie, void *vs, int where)
{
	struct vcons_screen *scr = vs;

	if (where == 0) {
		scr->scr_line_wanted = 0;
	} else {
		scr->scr_line_wanted = scr->scr_line_wanted - where;
		if (scr->scr_line_wanted < 0)
			scr->scr_line_wanted = 0;
		if (scr->scr_line_wanted > scr->scr_lines_in_buffer)
			scr->scr_line_wanted = scr->scr_lines_in_buffer;
	}

	if (scr->scr_line_wanted != scr->scr_current_line) {

		vcons_do_scroll(scr);
	}
}

static void
vcons_do_scroll(struct vcons_screen *scr)
{
	int dist, from, to, num;
	int r_offset, r_start;
	int i, j;

	if (scr->scr_line_wanted == scr->scr_current_line)
		return;
	dist = scr->scr_line_wanted - scr->scr_current_line;
	scr->scr_current_line = scr->scr_line_wanted;
	scr->scr_current_offset = scr->scr_ri.ri_cols *
	    (scr->scr_lines_in_buffer - scr->scr_current_line);
	if (abs(dist) >= scr->scr_ri.ri_rows) {
		vcons_redraw_screen(scr);
		return;
	}
	/* scroll and redraw only what we really have to */
	if (dist > 0) {
		/* we scroll down */
		from = 0;
		to = dist;
		num = scr->scr_ri.ri_rows - dist;
		/* now the redraw parameters */
		r_offset = scr->scr_current_offset;
		r_start = 0;
	} else {
		/* scrolling up */
		to = 0;
		from = -dist;
		num = scr->scr_ri.ri_rows + dist;
		r_offset = scr->scr_current_offset + num * scr->scr_ri.ri_cols;
		r_start = num;
	}
	scr->scr_vd->private->copyrows(scr, from, to, num);
	for (i = 0; i < abs(dist); i++) {
		for (j = 0; j < scr->scr_ri.ri_cols; j++) {
#ifdef VCONS_DRAW_INTR
			vcons_putchar_cached(scr, i + r_start, j,
			    scr->scr_chars[r_offset],
			    scr->scr_attrs[r_offset]);
#else
			scr->putchar(scr, i + r_start, j,
			    scr->scr_chars[r_offset],
			    scr->scr_attrs[r_offset]);
#endif
			r_offset++;
		}
	}

	if (scr->scr_line_wanted == 0) {
		/* this was a reset - need to draw the cursor */
		scr->scr_ri.ri_flg &= ~RI_CURSOR;
		scr->scr_vd->private->cursor(scr, 1, scr->scr_ri.ri_crow,
		    scr->scr_ri.ri_ccol);
	}
}

#endif /* WSDISPLAY_SCROLLSUPPORT */

#ifdef VCONS_DRAW_INTR
static void
vcons_intr(void *cookie)
{
	struct vcons_data *vd = cookie;
	struct vcons_data_private *vdp = vd->private;

	softint_schedule(vdp->intr_softint);
}

static void
vcons_softintr(void *cookie)
{
	struct vcons_data *vd = cookie;
	struct vcons_data_private *vdp = vd->private;
	struct vcons_screen *scr = vd->active;
	unsigned int dirty;

	if (scr && vdp->use_intr) {
		if (!SCREEN_IS_BUSY(scr)) {
			dirty = atomic_swap_uint(&scr->scr_dirty, 0);
			membar_acquire();
			if (vdp->use_intr == 2) {
				if ((scr->scr_flags & VCONS_NO_REDRAW) == 0) {
					vdp->use_intr = 1;
					vcons_redraw_screen(scr);
				}
			} else if (dirty > 0) {
				if ((scr->scr_flags & VCONS_NO_REDRAW) == 0)
					vcons_update_screen(scr);
			}
		}
	}

	callout_schedule(&vdp->intr, mstohz(33));
}

static void
vcons_init_thread(void *cookie)
{
	struct vcons_data *vd = (struct vcons_data *)cookie;
	struct vcons_data_private *vdp = vd->private;

	vdp->use_intr = 2;
	callout_schedule(&vdp->intr, mstohz(33));
	kthread_exit(0);
}
#endif /* VCONS_DRAW_INTR */

void
vcons_enable_polling(struct vcons_data *vd)
{
	struct vcons_screen *scr = vd->active;

#ifdef VCONS_DRAW_INTR
	struct vcons_data_private *vdp = vd->private;

	vdp->use_intr = 0;
#endif

	if (scr && !SCREEN_IS_BUSY(scr)) {
		if ((scr->scr_flags & VCONS_NO_REDRAW) == 0)
			vcons_redraw_screen(scr);
	}
}

void
vcons_disable_polling(struct vcons_data *vd)
{
#ifdef VCONS_DRAW_INTR
	struct vcons_data_private *vdp = vd->private;
	struct vcons_screen *scr = vd->active;

	if (!vdp->intr_valid)
		return;

	vdp->use_intr = 2;
	if (scr)
		vcons_dirty(scr);
#endif
}

void
vcons_hard_switch(struct vcons_screen *scr)
{
	struct vcons_data *vd = scr->scr_vd;
	struct vcons_data_private *vdp = vd->private;
	struct vcons_screen *oldscr = vd->active;

	if (oldscr) {
		SCREEN_INVISIBLE(oldscr);
		oldscr->scr_ri.ri_flg &= ~RI_CURSOR;
	}
	SCREEN_VISIBLE(scr);
	vd->active = scr;
	vdp->wanted = NULL;

	if (vd->show_screen_cb != NULL)
		vd->show_screen_cb(scr, vd->show_screen_cookie);
}

#ifdef VCONS_DRAW_INTR
static void
vcons_invalidate_cache(struct vcons_data *vd)
{
	struct vcons_data_private *vdp = vd->private;
	int i;

	for (i = 0; i < vdp->cells; i++) {
		vdp->chars[i] = -1;
		vdp->attrs[i] = -1;
	}
}
#endif