Replace syscons terminal renderer by a new renderer that uses libteken.

Some time ago I started working on a library called libteken, which is
terminal emulator. It does not buffer any screen contents, but only
keeps terminal state, such as cursor position, attributes, etc. It
should implement all escape sequences that are implemented by the
cons25 terminal emulator, but also a fair amount of sequences that are
present in VT100 and xterm.

A lot of random notes, which could be of interest to users/developers:

- Even though I'm leaving the terminal type set to `cons25', users can
  do experiments with placing `xterm-color' in /etc/ttys. Because we
  only implement a subset of features of xterm, this may cause
  artifacts. We should consider extending libteken, because in my
  opinion xterm is the way to go. Some missing features:

  - Keypad application mode (DECKPAM)
  - Character sets (SCS)

- libteken is filled with a fair amount of assertions, but unfortunately
  we cannot go into the debugger anymore if we fail them. I've done
  development of this library almost entirely in userspace. In
  sys/dev/syscons/teken there are two applications that can be helpful
  when debugging the code:

  - teken_demo: a terminal emulator that can be started from a regular
    xterm that emulates a terminal using libteken. This application can
    be very useful to debug any rendering issues.

  - teken_stress: a stress testing application that emulates random
    terminal output. libteken has literally survived multiple terabytes
    of random input.

- libteken also includes support for UTF-8, but unfortunately our input
  layer and font renderer don't support this. If users want to
  experiment with UTF-8 support, they can enable `TEKEN_UTF8' in
  teken.h. If you recompile your kernel or the teken_demo application,
  you can hold some nice experiments.

- I've left PC98 the way it is right now. The PC98 platform has a custom
  syscons renderer, which supports some form of localised input. Maybe
  we should port PC98 to libteken by the time syscons supports UTF-8?

- I've removed the `dumb' terminal emulator. It has been broken for
  years. It hasn't survived the `struct proc' -> `struct thread'
  conversion.

- To prevent confusion among people that want to hack on libteken:
  unlike syscons, the state machines that parse the escape sequences are
  machine generated. This means that if you want to add new escape
  sequences, you have to add an entry to the `sequences' file. This will
  cause new entries to be added to `teken_state.h'.

- Any rendering artifacts that didn't occur prior to this commit are by
  accident. They should be reported to me, so I can fix them.

Discussed on:	current@, hackers@
Discussed with:	philip (at 25C3)

24 files changed, 3117 insertions, 989 deletions

diff --git a/sys/conf/files b/sys/conf/files
index 08639e9..dc38a54 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -75,6 +75,11 @@ pccarddevs.h			standard				   \
 	compile-with	"${AWK} -f $S/tools/pccarddevs2h.awk $S/dev/pccard/pccarddevs" \
 	no-obj no-implicit-rule before-depend				   \
 	clean		"pccarddevs.h"
+teken_state.h		optional sc					   \
+	dependency	"$S/dev/syscons/teken/gensequences $S/dev/syscons/teken/sequences" \
+	compile-with	"${AWK} -f $S/dev/syscons/teken/gensequences $S/dev/syscons/teken/sequences > teken_state.h" \
+	no-obj no-implicit-rule before-depend				   \
+	clean		"teken_state.h"
 usbdevs.h			optional usb				   \
 	dependency	"$S/tools/usbdevs2h.awk $S/dev/usb/usbdevs" \
 	compile-with	"${AWK} -f $S/tools/usbdevs2h.awk $S/dev/usb/usbdevs -h" \
@@ -1424,7 +1429,6 @@ dev/syscons/logo/logo_saver.c	optional logo_saver
 dev/syscons/rain/rain_saver.c	optional rain_saver
 dev/syscons/schistory.c		optional sc
 dev/syscons/scmouse.c		optional sc
-dev/syscons/scterm-dumb.c	optional sc
 dev/syscons/scterm.c		optional sc
 dev/syscons/scvidctl.c		optional sc
 dev/syscons/snake/snake_saver.c	optional snake_saver
diff --git a/sys/conf/files.amd64 b/sys/conf/files.amd64
index 82ec801..c6c403f 100644
--- a/sys/conf/files.amd64
+++ b/sys/conf/files.amd64
@@ -196,9 +196,10 @@ dev/sio/sio_pci.c		optional	sio pci
 dev/sio/sio_puc.c		optional	sio puc
 dev/speaker/spkr.c		optional	speaker
 dev/syscons/apm/apm_saver.c	optional	apm_saver apm
-dev/syscons/scterm-sc.c		optional	sc
+dev/syscons/scterm-teken.c	optional	sc
 dev/syscons/scvgarndr.c		optional	sc vga
 dev/syscons/scvtb.c		optional	sc
+dev/syscons/teken/teken.c	optional sc
 dev/uart/uart_cpu_amd64.c	optional	uart
 dev/wpi/if_wpi.c		optional	wpi
 isa/atrtc.c			standard
diff --git a/sys/conf/files.i386 b/sys/conf/files.i386
index 17076db..72c1269 100644
--- a/sys/conf/files.i386
+++ b/sys/conf/files.i386
@@ -220,10 +220,11 @@ dev/sio/sio_puc.c		optional sio puc
 dev/speaker/spkr.c		optional speaker
 dev/sr/if_sr_isa.c		optional sr isa
 dev/syscons/apm/apm_saver.c	optional apm_saver apm
-dev/syscons/scterm-sc.c		optional sc
+dev/syscons/scterm-teken.c	optional sc
 dev/syscons/scvesactl.c		optional sc vga vesa
 dev/syscons/scvgarndr.c		optional sc vga
 dev/syscons/scvtb.c		optional sc
+dev/syscons/teken/teken.c	optional sc
 dev/uart/uart_cpu_i386.c	optional uart
 dev/acpica/acpi_if.m		standard
 dev/wpi/if_wpi.c		optional wpi
diff --git a/sys/conf/files.ia64 b/sys/conf/files.ia64
index 6556fbb..c17acb2 100644
--- a/sys/conf/files.ia64
+++ b/sys/conf/files.ia64
@@ -57,9 +57,10 @@ dev/fb/fb.c			optional	fb | vga
 dev/fb/vga.c			optional	vga
 dev/hwpmc/hwpmc_ia64.c		optional	hwpmc
 dev/kbd/kbd.c			optional	atkbd | sc | ukbd
-dev/syscons/scterm-sc.c		optional	sc
+dev/syscons/scterm-teken.c	optional	sc
 dev/syscons/scvgarndr.c		optional	sc vga
 dev/syscons/scvtb.c		optional	sc
+dev/syscons/teken/teken.c	optional sc
 dev/uart/uart_cpu_ia64.c	optional	uart
 dev/acpica/acpi_if.m		standard
 ia64/acpica/OsdEnvironment.c	optional	acpi
diff --git a/sys/conf/files.powerpc b/sys/conf/files.powerpc
index 901e36d..f42f81b 100644
--- a/sys/conf/files.powerpc
+++ b/sys/conf/files.powerpc
@@ -39,8 +39,9 @@ dev/powermac_nvram/powermac_nvram.c optional	powermac_nvram powermac
 dev/quicc/quicc_bfe_ocp.c	optional	quicc mpc85xx
 dev/scc/scc_bfe_macio.c		optional	scc powermac
 dev/syscons/scgfbrndr.c		optional	sc
-dev/syscons/scterm-sc.c		optional	sc
+dev/syscons/scterm-teken.c	optional	sc
 dev/syscons/scvtb.c		optional	sc
+dev/syscons/teken/teken.c	optional sc
 dev/tsec/if_tsec.c		optional	tsec
 dev/tsec/if_tsec_ocp.c		optional	tsec mpc85xx
 dev/uart/uart_bus_ocp.c		optional	uart mpc85xx
diff --git a/sys/conf/files.sparc64 b/sys/conf/files.sparc64
index 311027c..90c37a9 100644
--- a/sys/conf/files.sparc64
+++ b/sys/conf/files.sparc64
@@ -55,8 +55,9 @@ dev/pcf/pcf_ebus.c		optional	pcf ebus
 dev/sound/sbus/cs4231.c		optional	snd_audiocs ebus | \
 						snd_audiocs sbus
 dev/syscons/scgfbrndr.c		optional	sc
-dev/syscons/scterm-sc.c		optional	sc
+dev/syscons/scterm-teken.c	optional	sc
 dev/syscons/scvtb.c		optional	sc
+dev/syscons/teken/teken.c	optional sc
 dev/uart/uart_cpu_sparc64.c	optional	uart
 dev/uart/uart_kbd_sun.c		optional	uart sc
 kern/syscalls.c			optional	ktr
diff --git a/sys/dev/syscons/scterm-dumb.c b/sys/dev/syscons/scterm-dumb.c
deleted file mode 100644
index 1c130b6..0000000
--- a/sys/dev/syscons/scterm-dumb.c
+++ /dev/null
@@ -1,155 +0,0 @@
-/*-
- * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
- * 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 as
- *    the first lines of this file unmodified.
- * 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 AUTHORS ``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 AUTHORS 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>
-__FBSDID("$FreeBSD$");
-
-#include "opt_syscons.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/consio.h>
-
-#if defined(__sparc64__) || defined(__powerpc__)
-#include <machine/sc_machdep.h>
-#else
-#include <machine/pc/display.h>
-#endif
-
-#include <dev/syscons/syscons.h>
-#include <dev/syscons/sctermvar.h>
-
-#ifdef SC_DUMB_TERMINAL
-
-/* dumb terminal emulator */
-
-static sc_term_init_t	dumb_init;
-static sc_term_term_t	dumb_term;
-static sc_term_puts_t	dumb_puts;
-static sc_term_ioctl_t	dumb_ioctl;
-static sc_term_clear_t	dumb_clear;
-static sc_term_input_t	dumb_input;
-static void		dumb_nop(void);
-
-static sc_term_sw_t sc_term_dumb = {
-	{ NULL, NULL },
-	"dumb",				/* emulator name */
-	"dumb terminal",		/* description */
-	"*",				/* matching renderer */
-	0,				/* softc size */
-	0,
-	dumb_init,
-	dumb_term,
-	dumb_puts,
-	dumb_ioctl,
-	(sc_term_reset_t *)dumb_nop,
-	(sc_term_default_attr_t *)dumb_nop,
-	dumb_clear,
-	(sc_term_notify_t *)dumb_nop,
-	dumb_input,
-};
-
-SCTERM_MODULE(dumb, sc_term_dumb);
-
-static int
-dumb_init(scr_stat *scp, void **softc, int code)
-{
-	switch (code) {
-	case SC_TE_COLD_INIT:
-		++sc_term_dumb.te_refcount;
-		break;
-	case SC_TE_WARM_INIT:
-		break;
-	}
-	return 0;
-}
-
-static int
-dumb_term(scr_stat *scp, void **softc)
-{
-	--sc_term_dumb.te_refcount;
-	return 0;
-}
-
-static void
-dumb_puts(scr_stat *scp, u_char *buf, int len)
-{
-	while (len > 0) {
-		++scp->sc->write_in_progress;
-		sc_term_gen_print(scp, &buf, &len, SC_NORM_ATTR << 8);
-    		sc_term_gen_scroll(scp, scp->sc->scr_map[0x20],
-				   SC_NORM_ATTR << 8);
-		--scp->sc->write_in_progress;
-	}
-}
-
-static int
-dumb_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data,
-	   int flag, struct proc *p)
-{
-	vid_info_t *vi;
-
-	switch (cmd) {
-	case GIO_ATTR:      	/* get current attributes */
-		*(int*)data = SC_NORM_ATTR;
-		return 0;
-	case CONS_GETINFO:  	/* get current (virtual) console info */
-		vi = (vid_info_t *)data;
-		if (vi->size != sizeof(struct vid_info))
-			return EINVAL;
-		vi->mv_norm.fore = SC_NORM_ATTR & 0x0f;
-		vi->mv_norm.back = (SC_NORM_ATTR >> 4) & 0x0f;
-		vi->mv_rev.fore = SC_NORM_ATTR & 0x0f;
-		vi->mv_rev.back = (SC_NORM_ATTR >> 4) & 0x0f;
-		/*
-		 * The other fields are filled by the upper routine. XXX
-		 */
-		return ENOIOCTL;
-	}
-	return ENOIOCTL;
-}
-
-static void
-dumb_clear(scr_stat *scp)
-{
-	sc_move_cursor(scp, 0, 0);
-	sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], SC_NORM_ATTR << 8);
-	mark_all(scp);
-}
-
-static int
-dumb_input(scr_stat *scp, int c, struct tty *tp)
-{
-	return FALSE;
-}
-
-static void
-dumb_nop(void)
-{
-	/* nothing */
-}
-
-#endif /* SC_DUMB_TERMINAL */
diff --git a/sys/dev/syscons/scterm-sc.c b/sys/dev/syscons/scterm-sc.c
deleted file mode 100644
index b52bea8..0000000
--- a/sys/dev/syscons/scterm-sc.c
+++ /dev/null
@@ -1,811 +0,0 @@
-/*-
- * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
- * Copyright (c) 1992-1998 Søren Schmidt
- * 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 as
- *    the first lines of this file unmodified.
- * 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 AUTHORS ``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 AUTHORS 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>
-__FBSDID("$FreeBSD$");
-
-#include "opt_syscons.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/module.h>
-#include <sys/consio.h>
-
-#if defined(__sparc64__) || defined(__powerpc__)
-#include <machine/sc_machdep.h>
-#else
-#include <machine/pc/display.h>
-#endif
-
-#include <dev/syscons/syscons.h>
-#include <dev/syscons/sctermvar.h>
-
-#ifndef SC_DUMB_TERMINAL
-
-#define MAX_ESC_PAR	5
-
-/* attribute flags */
-typedef struct {
-	u_short		fg;			/* foreground color */
-	u_short		bg;			/* background color */
-} color_t;
-
-typedef struct {
-	int		flags;
-#define SCTERM_BUSY	(1 << 0)
-	int		esc;
-	int		num_param;
-	int		last_param;
-	int		param[MAX_ESC_PAR];
-	int		saved_xpos;
-	int		saved_ypos;
-	int		attr_mask;		/* current logical attr mask */
-#define NORMAL_ATTR	0x00
-#define BLINK_ATTR	0x01
-#define BOLD_ATTR	0x02
-#define UNDERLINE_ATTR	0x04
-#define REVERSE_ATTR	0x08
-#define FG_CHANGED	0x10
-#define BG_CHANGED	0x20
-	int		cur_attr;		/* current hardware attr word */
-	color_t		cur_color;		/* current hardware color */
-	color_t		std_color;		/* normal hardware color */
-	color_t		rev_color;		/* reverse hardware color */
-	color_t		dflt_std_color;		/* default normal color */
-	color_t		dflt_rev_color;		/* default reverse color */
-} term_stat;
-
-static sc_term_init_t	scterm_init;
-static sc_term_term_t	scterm_term;
-static sc_term_puts_t	scterm_puts;
-static sc_term_ioctl_t	scterm_ioctl;
-static sc_term_reset_t	scterm_reset;
-static sc_term_default_attr_t	scterm_default_attr;
-static sc_term_clear_t	scterm_clear;
-static sc_term_notify_t	scterm_notify;
-static sc_term_input_t	scterm_input;
-
-static sc_term_sw_t sc_term_sc = {
-	{ NULL, NULL },
-	"sc",					/* emulator name */
-	"syscons terminal",			/* description */
-	"*",					/* matching renderer, any :-) */
-	sizeof(term_stat),			/* softc size */
-	0,
-	scterm_init,
-	scterm_term,
-	scterm_puts,
-	scterm_ioctl,
-	scterm_reset,
-	scterm_default_attr,
-	scterm_clear,
-	scterm_notify,
-	scterm_input,
-};
-
-SCTERM_MODULE(sc, sc_term_sc);
-
-static term_stat	reserved_term_stat;
-static void		scterm_scan_esc(scr_stat *scp, term_stat *tcp,
-					u_char c);
-static int		mask2attr(term_stat *tcp);
-
-static int
-scterm_init(scr_stat *scp, void **softc, int code)
-{
-	term_stat *tcp;
-
-	if (*softc == NULL) {
-		if (reserved_term_stat.flags & SCTERM_BUSY)
-			return EINVAL;
-		*softc = &reserved_term_stat;
-	}
-	tcp = *softc;
-
-	switch (code) {
-	case SC_TE_COLD_INIT:
-		bzero(tcp, sizeof(*tcp));
-		tcp->flags = SCTERM_BUSY;
-		tcp->esc = 0;
-		tcp->saved_xpos = -1;
-		tcp->saved_ypos = -1;
-		tcp->attr_mask = NORMAL_ATTR;
-		/* XXX */
-		tcp->dflt_std_color.fg = SC_NORM_ATTR & 0x0f;
-		tcp->dflt_std_color.bg = (SC_NORM_ATTR >> 4) & 0x0f;
-		tcp->dflt_rev_color.fg = SC_NORM_REV_ATTR & 0x0f;
-		tcp->dflt_rev_color.bg = (SC_NORM_REV_ATTR >> 4) & 0x0f;
-		tcp->std_color = tcp->dflt_std_color;
-		tcp->rev_color = tcp->dflt_rev_color;
-		tcp->cur_color = tcp->std_color;
-		tcp->cur_attr = mask2attr(tcp);
-		++sc_term_sc.te_refcount;
-		break;
-
-	case SC_TE_WARM_INIT:
-		tcp->esc = 0;
-		tcp->saved_xpos = -1;
-		tcp->saved_ypos = -1;
-#if 0
-		tcp->std_color = tcp->dflt_std_color;
-		tcp->rev_color = tcp->dflt_rev_color;
-#endif
-		tcp->cur_color = tcp->std_color;
-		tcp->cur_attr = mask2attr(tcp);
-		break;
-	}
-
-	return 0;
-}
-
-static int
-scterm_term(scr_stat *scp, void **softc)
-{
-	if (*softc == &reserved_term_stat) {
-		*softc = NULL;
-		bzero(&reserved_term_stat, sizeof(reserved_term_stat));
-	}
-	--sc_term_sc.te_refcount;
-	return 0;
-}
-
-static void
-scterm_scan_esc(scr_stat *scp, term_stat *tcp, u_char c)
-{
-	static u_char ansi_col[16] = {
-		FG_BLACK,     FG_RED,          FG_GREEN,      FG_BROWN,
-		FG_BLUE,      FG_MAGENTA,      FG_CYAN,       FG_LIGHTGREY,
-		FG_DARKGREY,  FG_LIGHTRED,     FG_LIGHTGREEN, FG_YELLOW,
-		FG_LIGHTBLUE, FG_LIGHTMAGENTA, FG_LIGHTCYAN,  FG_WHITE
-	};
-	static int cattrs[] = {
-		0,					/* block */
-		CONS_BLINK_CURSOR,			/* blinking block */
-		CONS_CHAR_CURSOR,			/* underline */
-		CONS_CHAR_CURSOR | CONS_BLINK_CURSOR,	/* blinking underline */
-		CONS_RESET_CURSOR,			/* reset to default */
-		CONS_HIDDEN_CURSOR,			/* hide cursor */
-	};
-	static int tcattrs[] = {
-		CONS_RESET_CURSOR | CONS_LOCAL_CURSOR,	/* normal */
-		CONS_HIDDEN_CURSOR | CONS_LOCAL_CURSOR,	/* invisible */
-		CONS_BLINK_CURSOR | CONS_LOCAL_CURSOR,	/* very visible */
-	};
-	sc_softc_t *sc;
-	int v0, v1, v2;
-	int i, n;
-
-	i = n = 0;
-	sc = scp->sc; 
-	if (tcp->esc == 1) {	/* seen ESC */
-		switch (c) {
-
-		case '7':	/* Save cursor position */
-			tcp->saved_xpos = scp->xpos;
-			tcp->saved_ypos = scp->ypos;
-			break;
-
-		case '8':	/* Restore saved cursor position */
-			if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0)
-				sc_move_cursor(scp, tcp->saved_xpos,
-					       tcp->saved_ypos);
-			break;
-
-		case '[':	/* Start ESC [ sequence */
-			tcp->esc = 2;
-			tcp->last_param = -1;
-			for (i = tcp->num_param; i < MAX_ESC_PAR; i++)
-				tcp->param[i] = 1;
-			tcp->num_param = 0;
-			return;
-
-		case 'M':	/* Move cursor up 1 line, scroll if at top */
-			sc_term_up_scroll(scp, 1, sc->scr_map[0x20],
-					  tcp->cur_attr, 0, 0);
-			break;
-#ifdef notyet
-		case 'Q':
-			tcp->esc = 4;
-			return;
-#endif
-		case 'c':       /* reset */
-			tcp->attr_mask = NORMAL_ATTR;
-			tcp->cur_color = tcp->std_color
-				       = tcp->dflt_std_color;
-			tcp->rev_color = tcp->dflt_rev_color;
-			tcp->cur_attr = mask2attr(tcp);
-			sc_change_cursor_shape(scp,
-			    CONS_RESET_CURSOR | CONS_LOCAL_CURSOR, -1, -1);
-			sc_clear_screen(scp);
-			break;
-
-		case '(':	/* iso-2022: designate 94 character set to G0 */
-			tcp->esc = 5;
-			return;
-		}
-	} else if (tcp->esc == 2) {	/* seen ESC [ */
-		if (c >= '0' && c <= '9') {
-			if (tcp->num_param < MAX_ESC_PAR) {
-				if (tcp->last_param != tcp->num_param) {
-					tcp->last_param = tcp->num_param;
-					tcp->param[tcp->num_param] = 0;
-				} else {
-					tcp->param[tcp->num_param] *= 10;
-				}
-				tcp->param[tcp->num_param] += c - '0';
-				return;
-			}
-		}
-		tcp->num_param = tcp->last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (tcp->num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case '=':
-			tcp->esc = 3;
-			tcp->last_param = -1;
-			for (i = tcp->num_param; i < MAX_ESC_PAR; i++)
-				tcp->param[i] = 1;
-			tcp->num_param = 0;
-			return;
-
-		case 'A':	/* up n rows */
-			sc_term_up(scp, tcp->param[0], 0);
-			break;
-
-		case 'B':	/* down n rows */
-			sc_term_down(scp, tcp->param[0], 0);
-			break;
-
-		case 'C':	/* right n columns */
-			sc_term_right(scp, tcp->param[0]);
-			break;
-
-		case 'D':	/* left n columns */
-			sc_term_left(scp, tcp->param[0]);
-			break;
-
-		case 'E':	/* cursor to start of line n lines down */
-			n = tcp->param[0];
-			if (n < 1)
-				n = 1;
-			sc_move_cursor(scp, 0, scp->ypos + n);
-			break;
-
-		case 'F':	/* cursor to start of line n lines up */
-			n = tcp->param[0];
-			if (n < 1)
-				n = 1;
-			sc_move_cursor(scp, 0, scp->ypos - n);
-			break;
-
-		case 'f':	/* Cursor move */
-		case 'H':
-			if (tcp->num_param == 0)
-				sc_move_cursor(scp, 0, 0);
-			else if (tcp->num_param == 2)
-				sc_move_cursor(scp, tcp->param[1] - 1,
-					       tcp->param[0] - 1);
-			break;
-
-		case 'J':	/* Clear all or part of display */
-			if (tcp->num_param == 0)
-				n = 0;
-			else
-				n = tcp->param[0];
-			sc_term_clr_eos(scp, n, sc->scr_map[0x20],
-					tcp->cur_attr);
-			break;
-
-		case 'K':	/* Clear all or part of line */
-			if (tcp->num_param == 0)
-				n = 0;
-			else
-				n = tcp->param[0];
-			sc_term_clr_eol(scp, n, sc->scr_map[0x20],
-					tcp->cur_attr);
-			break;
-
-		case 'L':	/* Insert n lines */
-			sc_term_ins_line(scp, scp->ypos, tcp->param[0],
-					 sc->scr_map[0x20], tcp->cur_attr, 0);
-			break;
-
-		case 'M':	/* Delete n lines */
-			sc_term_del_line(scp, scp->ypos, tcp->param[0],
-					 sc->scr_map[0x20], tcp->cur_attr, 0);
-			break;
-
-		case 'P':	/* Delete n chars */
-			sc_term_del_char(scp, tcp->param[0],
-					 sc->scr_map[0x20], tcp->cur_attr);
-			break;
-
-		case '@':	/* Insert n chars */
-			sc_term_ins_char(scp, tcp->param[0],
-					 sc->scr_map[0x20], tcp->cur_attr);
-			break;
-
-		case 'S':	/* scroll up n lines */
-			sc_term_del_line(scp, 0, tcp->param[0],
-					 sc->scr_map[0x20], tcp->cur_attr, 0);
-			break;
-
-		case 'T':	/* scroll down n lines */
-			sc_term_ins_line(scp, 0, tcp->param[0],
-					 sc->scr_map[0x20], tcp->cur_attr, 0);
-			break;
-
-		case 'X':	/* erase n characters in line */
-			n = tcp->param[0];
-			if (n < 1)
-				n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			sc_vtb_erase(&scp->vtb, scp->cursor_pos, n,
-				     sc->scr_map[0x20], tcp->cur_attr);
-			mark_for_update(scp, scp->cursor_pos);
-			mark_for_update(scp, scp->cursor_pos + n - 1);
-			break;
-
-		case 'Z':	/* move n tabs backwards */
-			sc_term_backtab(scp, tcp->param[0]);
-			break;
-
-		case '`':	/* move cursor to column n */
-			sc_term_col(scp, tcp->param[0]);
-			break;
-
-		case 'a':	/* move cursor n columns to the right */
-			sc_term_right(scp, tcp->param[0]);
-			break;
-
-		case 'd':	/* move cursor to row n */
-			sc_term_row(scp, tcp->param[0]);
-			break;
-
-		case 'e':	/* move cursor n rows down */
-			sc_term_down(scp, tcp->param[0], 0);
-			break;
-
-		case 'm':	/* change attribute */
-			if (tcp->num_param == 0) {
-				tcp->attr_mask = NORMAL_ATTR;
-				tcp->cur_color = tcp->std_color;
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			}
-			for (i = 0; i < tcp->num_param; i++) {
-				switch (n = tcp->param[i]) {
-				case 0:	/* back to normal */
-					tcp->attr_mask = NORMAL_ATTR;
-					tcp->cur_color = tcp->std_color;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 1:	/* bold */
-					tcp->attr_mask |= BOLD_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 4:	/* underline */
-					tcp->attr_mask |= UNDERLINE_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 5:	/* blink */
-					tcp->attr_mask |= BLINK_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 7: /* reverse */
-					tcp->attr_mask |= REVERSE_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 22: /* remove bold (or dim) */
-					tcp->attr_mask &= ~BOLD_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 24: /* remove underline */
-					tcp->attr_mask &= ~UNDERLINE_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 25: /* remove blink */
-					tcp->attr_mask &= ~BLINK_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 27: /* remove reverse */
-					tcp->attr_mask &= ~REVERSE_ATTR;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 30: case 31: /* set ansi fg color */
-				case 32: case 33: case 34:
-				case 35: case 36: case 37:
-					tcp->attr_mask |= FG_CHANGED;
-					tcp->cur_color.fg = ansi_col[n - 30];
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 39: /* restore fg color back to normal */
-					tcp->attr_mask &= ~(FG_CHANGED|BOLD_ATTR);
-					tcp->cur_color.fg = tcp->std_color.fg;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				case 40: case 41: /* set ansi bg color */
-				case 42: case 43: case 44:
-				case 45: case 46: case 47:
-					tcp->attr_mask |= BG_CHANGED;
-					tcp->cur_color.bg = ansi_col[n - 40];
-					tcp->cur_attr = mask2attr(tcp);
-		    			break;
-				case 49: /* restore bg color back to normal */
-					tcp->attr_mask &= ~BG_CHANGED;
-					tcp->cur_color.bg = tcp->std_color.bg;
-					tcp->cur_attr = mask2attr(tcp);
-					break;
-				}
-			}
-			break;
-
-		case 's':	/* Save cursor position */
-			tcp->saved_xpos = scp->xpos;
-			tcp->saved_ypos = scp->ypos;
-			break;
-
-		case 'u':	/* Restore saved cursor position */
-			if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0)
-				sc_move_cursor(scp, tcp->saved_xpos,
-					       tcp->saved_ypos);
-			break;
-
-		case 'x':
-			if (tcp->num_param == 0)
-				n = 0;
-			else
-				n = tcp->param[0];
-			switch (n) {
-			case 0: /* reset colors and attributes back to normal */
-				tcp->attr_mask = NORMAL_ATTR;
-				tcp->cur_color = tcp->std_color
-					       = tcp->dflt_std_color;
-				tcp->rev_color = tcp->dflt_rev_color;
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			case 1:	/* set ansi background */
-				tcp->attr_mask &= ~BG_CHANGED;
-				tcp->cur_color.bg = tcp->std_color.bg
-						  = ansi_col[tcp->param[1] & 0x0f];
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			case 2:	/* set ansi foreground */
-				tcp->attr_mask &= ~FG_CHANGED;
-				tcp->cur_color.fg = tcp->std_color.fg
-						  = ansi_col[tcp->param[1] & 0x0f];
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			case 3: /* set adapter attribute directly */
-				tcp->attr_mask &= ~(FG_CHANGED | BG_CHANGED);
-				tcp->cur_color.fg = tcp->std_color.fg
-						  = tcp->param[1] & 0x0f;
-				tcp->cur_color.bg = tcp->std_color.bg
-						  = (tcp->param[1] >> 4) & 0x0f;
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			case 5: /* set ansi reverse background */
-				tcp->rev_color.bg = ansi_col[tcp->param[1] & 0x0f];
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			case 6: /* set ansi reverse foreground */
-				tcp->rev_color.fg = ansi_col[tcp->param[1] & 0x0f];
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			case 7: /* set adapter reverse attribute directly */
-				tcp->rev_color.fg = tcp->param[1] & 0x0f;
-				tcp->rev_color.bg = (tcp->param[1] >> 4) & 0x0f;
-				tcp->cur_attr = mask2attr(tcp);
-				break;
-			}
-			break;
-
-		case 'z':	/* switch to (virtual) console n */
-			if (tcp->num_param == 1)
-				sc_switch_scr(sc, tcp->param[0]);
-			break;
-		}
-	} else if (tcp->esc == 3) {	/* seen ESC [0-9]+ = */
-		if (c >= '0' && c <= '9') {
-			if (tcp->num_param < MAX_ESC_PAR) {
-				if (tcp->last_param != tcp->num_param) {
-					tcp->last_param = tcp->num_param;
-					tcp->param[tcp->num_param] = 0;
-				} else {
-					tcp->param[tcp->num_param] *= 10;
-				}
-				tcp->param[tcp->num_param] += c - '0';
-				return;
-			}
-		}
-		tcp->num_param = tcp->last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (tcp->num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case 'A':   /* set display border color */
-			if (tcp->num_param == 1) {
-				scp->border=tcp->param[0] & 0xff;
-				if (scp == sc->cur_scp)
-					sc_set_border(scp, scp->border);
-			}
-			break;
-
-		case 'B':   /* set bell pitch and duration */
-			if (tcp->num_param == 2) {
-				scp->bell_pitch = tcp->param[0];
-				scp->bell_duration = 
-				    (tcp->param[1] * hz + 99) / 100;
-			}
-			break;
-
-		case 'C':   /* set global/parmanent cursor type & shape */
-			i = spltty();
-			n = tcp->num_param;
-			v0 = tcp->param[0];
-			v1 = tcp->param[1];
-			v2 = tcp->param[2];
-			switch (n) {
-			case 1:	/* flags only */
-				if (v0 < sizeof(cattrs)/sizeof(cattrs[0]))
-					v0 = cattrs[v0];
-				else	/* backward compatibility */
-					v0 = cattrs[v0 & 0x3];
-				sc_change_cursor_shape(scp, v0, -1, -1);
-				break;
-			case 2:
-				v2 = 0;
-				v0 &= 0x1f;	/* backward compatibility */
-				v1 &= 0x1f;
-				/* FALL THROUGH */
-			case 3:	/* base and height */
-				if (v2 == 0)	/* count from top */
-					sc_change_cursor_shape(scp, -1,
-					    scp->font_size - v1 - 1,
-					    v1 - v0 + 1);
-				else if (v2 == 1) /* count from bottom */
-					sc_change_cursor_shape(scp, -1,
-					    v0, v1 - v0 + 1);
-				break;
-			}
-			splx(i);
-			break;
-
-		case 'F':   /* set adapter foreground */
-			if (tcp->num_param == 1) {
-				tcp->attr_mask &= ~FG_CHANGED;
-				tcp->cur_color.fg = tcp->std_color.fg
-						  = tcp->param[0] & 0x0f;
-				tcp->cur_attr = mask2attr(tcp);
-			}
-			break;
-
-		case 'G':   /* set adapter background */
-			if (tcp->num_param == 1) {
-				tcp->attr_mask &= ~BG_CHANGED;
-				tcp->cur_color.bg = tcp->std_color.bg
-						  = tcp->param[0] & 0x0f;
-				tcp->cur_attr = mask2attr(tcp);
-			}
-			break;
-
-		case 'H':   /* set adapter reverse foreground */
-			if (tcp->num_param == 1) {
-				tcp->rev_color.fg = tcp->param[0] & 0x0f;
-				tcp->cur_attr = mask2attr(tcp);
-			}
-			break;
-
-		case 'I':   /* set adapter reverse background */
-			if (tcp->num_param == 1) {
-				tcp->rev_color.bg = tcp->param[0] & 0x0f;
-				tcp->cur_attr = mask2attr(tcp);
-			}
-			break;
-
-		case 'S':   /* set local/temporary cursor type & shape */
-			i = spltty();
-			n = tcp->num_param;
-			v0 = tcp->param[0];
-			switch (n) {
-			case 0:
-				v0 = 0;
-				/* FALL THROUGH */
-			case 1:
-				if (v0 < sizeof(tcattrs)/sizeof(tcattrs[0]))
-					sc_change_cursor_shape(scp,
-					    tcattrs[v0], -1, -1);
-				break;
-			}
-			splx(i);
-			break;
-		}
-#ifdef notyet
-	} else if (tcp->esc == 4) {	/* seen ESC Q */
-		/* to be filled */
-#endif
-	} else if (tcp->esc == 5) {	/* seen ESC ( */
-		switch (c) {
-		case 'B':   /* iso-2022: desginate ASCII into G0 */
-			break;
-		/* other items to be filled */
-		default:
-			break;
-		}
-	}
-	tcp->esc = 0;
-}
-
-static void
-scterm_puts(scr_stat *scp, u_char *buf, int len)
-{
-	term_stat *tcp;
-
-	tcp = scp->ts;
-outloop:
-	scp->sc->write_in_progress++;
-
-	if (tcp->esc) {
-		scterm_scan_esc(scp, tcp, *buf);
-		buf++;
-		len--;
-	} else {
-		switch (*buf) {
-		case 0x1b:
-			tcp->esc = 1;
-			tcp->num_param = 0;
-			buf++;
-			len--;
-			break;
-		default:
-			sc_term_gen_print(scp, &buf, &len, tcp->cur_attr);
-			break;
-		}
-	}
-
-	sc_term_gen_scroll(scp, scp->sc->scr_map[0x20], tcp->cur_attr);
-
-	scp->sc->write_in_progress--;
-	if (len)
-		goto outloop;
-}
-
-static int
-scterm_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data,
-	     struct thread *td)
-{
-	term_stat *tcp = scp->ts;
-	vid_info_t *vi;
-
-	switch (cmd) {
-	case GIO_ATTR:      	/* get current attributes */
-		/* FIXME: */
-		*(int*)data = (tcp->cur_attr >> 8) & 0xff;
-		return 0;
-	case CONS_GETINFO:  	/* get current (virtual) console info */
-		vi = (vid_info_t *)data;
-		if (vi->size != sizeof(struct vid_info))
-			return EINVAL;
-		vi->mv_norm.fore = tcp->std_color.fg;
-		vi->mv_norm.back = tcp->std_color.bg;
-		vi->mv_rev.fore = tcp->rev_color.fg;
-		vi->mv_rev.back = tcp->rev_color.bg;
-		/*
-		 * The other fields are filled by the upper routine. XXX
-		 */
-		return ENOIOCTL;
-	}
-	return ENOIOCTL;
-}
-
-static int
-scterm_reset(scr_stat *scp, int code)
-{
-	/* FIXME */
-	return 0;
-}
-
-static void
-scterm_default_attr(scr_stat *scp, int color, int rev_color)
-{
-	term_stat *tcp = scp->ts;
-
-	tcp->dflt_std_color.fg = color & 0x0f;
-	tcp->dflt_std_color.bg = (color >> 4) & 0x0f;
-	tcp->dflt_rev_color.fg = rev_color & 0x0f;
-	tcp->dflt_rev_color.bg = (rev_color >> 4) & 0x0f;
-	tcp->std_color = tcp->dflt_std_color;
-	tcp->rev_color = tcp->dflt_rev_color;
-	tcp->cur_color = tcp->std_color;
-	tcp->cur_attr = mask2attr(tcp);
-}
-
-static void
-scterm_clear(scr_stat *scp)
-{
-	term_stat *tcp = scp->ts;
-
-	sc_move_cursor(scp, 0, 0);
-	sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], tcp->cur_attr);
-	mark_all(scp);
-}
-
-static void
-scterm_notify(scr_stat *scp, int event)
-{
-	switch (event) {
-	case SC_TE_NOTIFY_VTSWITCH_IN:
-		break;
-	case SC_TE_NOTIFY_VTSWITCH_OUT:
-		break;
-	}
-}
-
-static int
-scterm_input(scr_stat *scp, int c, struct tty *tp)
-{
-	return FALSE;
-}
-
-/*
- * Calculate hardware attributes word using logical attributes mask and
- * hardware colors
- */
-
-/* FIXME */
-static int
-mask2attr(term_stat *tcp)
-{
-	int attr, mask = tcp->attr_mask;
-
-	if (mask & REVERSE_ATTR) {
-		attr = ((mask & FG_CHANGED) ?
-			tcp->cur_color.bg : tcp->rev_color.fg) |
-			(((mask & BG_CHANGED) ?
-			tcp->cur_color.fg : tcp->rev_color.bg) << 4);
-	} else
-		attr = tcp->cur_color.fg | (tcp->cur_color.bg << 4);
-
-	/* XXX: underline mapping for Hercules adapter can be better */
-	if (mask & (BOLD_ATTR | UNDERLINE_ATTR))
-		attr ^= 0x08;
-	if (mask & BLINK_ATTR)
-		attr ^= 0x80;
-
-	return (attr << 8);
-}
-
-#endif /* SC_DUMB_TERMINAL */
diff --git a/sys/dev/syscons/scterm-teken.c b/sys/dev/syscons/scterm-teken.c
new file mode 100644
index 0000000..798a2cd
--- /dev/null
+++ b/sys/dev/syscons/scterm-teken.c
@@ -0,0 +1,504 @@
+/*-
+ * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
+ * All rights reserved.
+ *
+ * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+ * 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 as
+ *    the first lines of this file unmodified.
+ * 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 AUTHORS ``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 AUTHORS 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>
+__FBSDID("$FreeBSD$");
+
+#include "opt_syscons.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/consio.h>
+
+#if defined(__sparc64__) || defined(__powerpc__)
+#include <machine/sc_machdep.h>
+#else
+#include <machine/pc/display.h>
+#endif
+
+#include <dev/syscons/syscons.h>
+
+#include <dev/syscons/teken/teken.h>
+
+static void scteken_revattr(unsigned char, teken_attr_t *);
+
+static sc_term_init_t	scteken_init;
+static sc_term_term_t	scteken_term;
+static sc_term_puts_t	scteken_puts;
+static sc_term_ioctl_t	scteken_ioctl;
+static sc_term_default_attr_t scteken_default_attr;
+static sc_term_clear_t	scteken_clear;
+static sc_term_input_t	scteken_input;
+static void		scteken_nop(void);
+
+typedef struct {
+	teken_t		ts_teken;
+	int		ts_busy;
+} teken_stat;
+
+static teken_stat	reserved_teken_stat;
+
+static sc_term_sw_t sc_term_scteken = {
+	{ NULL, NULL },
+	"scteken",			/* emulator name */
+	"teken terminal",		/* description */
+	"*",				/* matching renderer */
+	sizeof(teken_stat),		/* softc size */
+	0,
+	scteken_init,
+	scteken_term,
+	scteken_puts,
+	scteken_ioctl,
+	(sc_term_reset_t *)scteken_nop,
+	scteken_default_attr,
+	scteken_clear,
+	(sc_term_notify_t *)scteken_nop,
+	scteken_input,
+};
+
+SCTERM_MODULE(scteken, sc_term_scteken);
+
+static tf_bell_t	scteken_bell;
+static tf_cursor_t	scteken_cursor;
+static tf_putchar_t	scteken_putchar;
+static tf_fill_t	scteken_fill;
+static tf_copy_t	scteken_copy;
+static tf_param_t	scteken_param;
+static tf_respond_t	scteken_respond;
+
+static const teken_funcs_t scteken_funcs = {
+	.tf_bell	= scteken_bell,
+	.tf_cursor	= scteken_cursor,
+	.tf_putchar	= scteken_putchar,
+	.tf_fill	= scteken_fill,
+	.tf_copy	= scteken_copy,
+	.tf_param	= scteken_param,
+	.tf_respond	= scteken_respond,
+};
+
+static int
+scteken_init(scr_stat *scp, void **softc, int code)
+{
+	teken_stat *ts = scp->ts;
+	teken_pos_t tp;
+
+	if (*softc == NULL) {
+		if (reserved_teken_stat.ts_busy)
+			return (EINVAL);
+		*softc = &reserved_teken_stat;
+	}
+	ts = *softc;
+
+	switch (code) {
+	case SC_TE_COLD_INIT:
+		++sc_term_scteken.te_refcount;
+		ts->ts_busy = 1;
+		/* FALLTHROUGH */
+	case SC_TE_WARM_INIT:
+		teken_init(&ts->ts_teken, &scteken_funcs, scp);
+
+		tp.tp_row = scp->ysize;
+		tp.tp_col = scp->xsize;
+		teken_set_winsize(&ts->ts_teken, &tp);
+
+		tp.tp_row = scp->cursor_pos / scp->xsize;
+		tp.tp_col = scp->cursor_pos % scp->xsize;
+		teken_set_cursor(&ts->ts_teken, &tp);
+		break;
+	}
+
+	return (0);
+}
+
+static int
+scteken_term(scr_stat *scp, void **softc)
+{
+
+	if (*softc == &reserved_teken_stat) {
+		*softc = NULL;
+		reserved_teken_stat.ts_busy = 0;
+	}
+	--sc_term_scteken.te_refcount;
+
+	return (0);
+}
+
+static void
+scteken_puts(scr_stat *scp, u_char *buf, int len)
+{
+	teken_stat *ts = scp->ts;
+
+	scp->sc->write_in_progress++;
+	teken_input(&ts->ts_teken, buf, len);
+	scp->sc->write_in_progress--;
+}
+
+static int
+scteken_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data,
+	     struct thread *td)
+{
+	vid_info_t *vi;
+
+	switch (cmd) {
+	case GIO_ATTR:      	/* get current attributes */
+		*(int*)data = SC_NORM_ATTR;
+		return (0);
+	case CONS_GETINFO:  	/* get current (virtual) console info */
+		/* XXX: INCORRECT! */
+		vi = (vid_info_t *)data;
+		if (vi->size != sizeof(struct vid_info))
+			return EINVAL;
+		vi->mv_norm.fore = SC_NORM_ATTR & 0x0f;
+		vi->mv_norm.back = (SC_NORM_ATTR >> 4) & 0x0f;
+		vi->mv_rev.fore = SC_NORM_ATTR & 0x0f;
+		vi->mv_rev.back = (SC_NORM_ATTR >> 4) & 0x0f;
+		/*
+		 * The other fields are filled by the upper routine. XXX
+		 */
+		return (ENOIOCTL);
+	}
+
+	return (ENOIOCTL);
+}
+
+static void
+scteken_default_attr(scr_stat *scp, int color, int rev_color)
+{
+	teken_stat *ts = scp->ts;
+	teken_attr_t ta;
+
+	scteken_revattr(color, &ta);
+	teken_set_defattr(&ts->ts_teken, &ta);
+}
+
+static void
+scteken_clear(scr_stat *scp)
+{
+
+	sc_move_cursor(scp, 0, 0);
+	sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], SC_NORM_ATTR << 8);
+	mark_all(scp);
+}
+
+static int
+scteken_input(scr_stat *scp, int c, struct tty *tp)
+{
+
+	return FALSE;
+}
+
+static void
+scteken_nop(void)
+{
+
+}
+
+/*
+ * libteken routines.
+ */
+
+static const unsigned char fgcolors_normal[TC_NCOLORS] = {
+	FG_BLACK,     FG_RED,          FG_GREEN,      FG_BROWN,
+	FG_BLUE,      FG_MAGENTA,      FG_CYAN,       FG_LIGHTGREY,
+};
+
+static const unsigned char fgcolors_bold[TC_NCOLORS] = {
+	FG_DARKGREY,  FG_LIGHTRED,     FG_LIGHTGREEN, FG_YELLOW,
+	FG_LIGHTBLUE, FG_LIGHTMAGENTA, FG_LIGHTCYAN,  FG_WHITE,
+};
+
+static const unsigned char bgcolors[TC_NCOLORS] = {
+	BG_BLACK,     BG_RED,          BG_GREEN,      BG_BROWN,
+	BG_BLUE,      BG_MAGENTA,      BG_CYAN,       BG_LIGHTGREY,
+};
+
+static void
+scteken_revattr(unsigned char color, teken_attr_t *a)
+{
+	teken_color_t fg, bg;
+
+	/*
+	 * XXX: Reverse conversion of syscons to teken attributes. Not
+	 * realiable. Maybe we should turn it into a 1:1 mapping one of
+	 * these days?
+	 */
+
+	a->ta_format = 0;
+	a->ta_fgcolor = TC_WHITE;
+	a->ta_bgcolor = TC_BLACK;
+
+#ifdef FG_BLINK
+	if (color & FG_BLINK) {
+		a->ta_format |= TF_BLINK;
+		color &= ~FG_BLINK;
+	}
+#endif /* FG_BLINK */
+
+	for (fg = 0; fg < TC_NCOLORS; fg++) {
+		for (bg = 0; bg < TC_NCOLORS; bg++) {
+			if ((fgcolors_normal[fg] | bgcolors[bg]) == color) {
+				a->ta_fgcolor = fg;
+				a->ta_bgcolor = bg;
+				return;
+			}
+
+			if ((fgcolors_bold[fg] | bgcolors[bg]) == color) {
+				a->ta_fgcolor = fg;
+				a->ta_bgcolor = bg;
+				a->ta_format |= TF_BOLD;
+				return;
+			}
+		}
+	}
+}
+
+static inline unsigned int
+scteken_attr(const teken_attr_t *a)
+{
+	unsigned int attr = 0;
+
+	if (a->ta_format & TF_BOLD)
+		attr |= fgcolors_bold[a->ta_fgcolor];
+	else
+		attr |= fgcolors_normal[a->ta_fgcolor];
+	attr |= bgcolors[a->ta_bgcolor];
+
+#ifdef FG_UNDERLINE
+	if (a->ta_format & TF_UNDERLINE)
+		attr |= FG_UNDERLINE;
+#endif /* FG_UNDERLINE */
+#ifdef FG_BLINK
+	if (a->ta_format & TF_BLINK)
+		attr |= FG_BLINK;
+#endif /* FG_BLINK */
+
+	return (attr << 8);
+}
+
+static void
+scteken_bell(void *arg)
+{
+	scr_stat *scp = arg;
+
+	sc_bell(scp, scp->bell_pitch, scp->bell_duration);
+}
+
+static void
+scteken_cursor(void *arg, const teken_pos_t *p)
+{
+	scr_stat *scp = arg;
+
+	sc_move_cursor(scp, p->tp_col, p->tp_row);
+}
+
+static void
+scteken_putchar(void *arg, const teken_pos_t *tp, teken_char_t c,
+    const teken_attr_t *a)
+{
+	scr_stat *scp = arg;
+	u_char *map;
+	u_char ch;
+	vm_offset_t p;
+	int cursor, attr;
+
+#ifdef TEKEN_UTF8
+	if (c >= 0x80) {
+		/* XXX: Don't display UTF-8 yet. */
+		attr = (FG_YELLOW|BG_RED) << 8;
+		ch = '?';
+	} else
+#endif /* TEKEN_UTF8 */
+	{
+		attr = scteken_attr(a);
+		ch = c;
+	}
+
+	map = scp->sc->scr_map;
+
+	cursor = tp->tp_row * scp->xsize + tp->tp_col;
+	p = sc_vtb_pointer(&scp->vtb, cursor);
+	sc_vtb_putchar(&scp->vtb, p, map[ch], attr);
+
+	mark_for_update(scp, cursor);
+	/*
+	 * XXX: Why do we need this? Only marking `cursor' should be
+	 * enough. Without this line, we get artifacts.
+	 */
+	mark_for_update(scp, imin(cursor + 1, scp->xsize * scp->ysize - 1));
+}
+
+static void
+scteken_fill(void *arg, const teken_rect_t *r, teken_char_t c,
+    const teken_attr_t *a)
+{
+	scr_stat *scp = arg;
+	u_char *map;
+	u_char ch;
+	unsigned int width;
+	int attr, row;
+
+#ifdef TEKEN_UTF8
+	if (c >= 0x80) {
+		/* XXX: Don't display UTF-8 yet. */
+		attr = (FG_YELLOW|BG_RED) << 8;
+		ch = '?';
+	} else
+#endif /* TEKEN_UTF8 */
+	{
+		attr = scteken_attr(a);
+		ch = c;
+	}
+
+	map = scp->sc->scr_map;
+
+	if (r->tr_begin.tp_col == 0 && r->tr_end.tp_col == scp->xsize) {
+		/* Single contiguous region to fill. */
+		sc_vtb_erase(&scp->vtb, r->tr_begin.tp_row * scp->xsize,
+		    (r->tr_end.tp_row - r->tr_begin.tp_row) * scp->xsize,
+		    map[ch], attr);
+	} else {
+		/* Fill display line by line. */
+		width = r->tr_end.tp_col - r->tr_begin.tp_col;
+
+		for (row = r->tr_begin.tp_row; row < r->tr_end.tp_row; row++) {
+			sc_vtb_erase(&scp->vtb, r->tr_begin.tp_row *
+			    scp->xsize + r->tr_begin.tp_col,
+			    width, map[ch], attr);
+		}
+	}
+
+	/* Mark begin and end positions to be refreshed. */
+	mark_for_update(scp,
+	    r->tr_begin.tp_row * scp->xsize + r->tr_begin.tp_col);
+	mark_for_update(scp,
+	    (r->tr_end.tp_row - 1) * scp->xsize + (r->tr_end.tp_col - 1));
+	sc_remove_cutmarking(scp);
+}
+
+static void
+scteken_copy(void *arg, const teken_rect_t *r, const teken_pos_t *p)
+{
+	scr_stat *scp = arg;
+	unsigned int width;
+	int src, dst, end;
+
+#ifndef SC_NO_HISTORY
+	/*
+	 * We count a line of input as history if we perform a copy of
+	 * one whole line upward. In other words: if a line of text gets
+	 * overwritten by a rectangle that's right below it.
+	 */
+	if (scp->history != NULL &&
+	    r->tr_begin.tp_col == 0 && r->tr_end.tp_col == scp->xsize &&
+	    r->tr_begin.tp_row == p->tp_row + 1) {
+		sc_hist_save_one_line(scp, p->tp_row);
+	}
+#endif
+
+	if (r->tr_begin.tp_col == 0 && r->tr_end.tp_col == scp->xsize) {
+		/* Single contiguous region to copy. */
+		sc_vtb_move(&scp->vtb, r->tr_begin.tp_row * scp->xsize,
+		    p->tp_row * scp->xsize,
+		    (r->tr_end.tp_row - r->tr_begin.tp_row) * scp->xsize);
+	} else {
+		/* Copy line by line. */
+		width = r->tr_end.tp_col - r->tr_begin.tp_col;
+
+		if (p->tp_row < r->tr_begin.tp_row) {
+			/* Copy from top to bottom. */
+			src = r->tr_begin.tp_row * scp->xsize +
+			    r->tr_begin.tp_col;
+			end = r->tr_end.tp_row * scp->xsize +
+			    r->tr_end.tp_col;
+			dst = p->tp_row * scp->xsize + p->tp_col;
+
+			while (src < end) {
+				sc_vtb_move(&scp->vtb, src, dst, width);
+			
+				src += scp->xsize;
+				dst += scp->xsize;
+			}
+		} else {
+			/* Copy from bottom to top. */
+			src = (r->tr_end.tp_row - 1) * scp->xsize +
+			    r->tr_begin.tp_col;
+			end = r->tr_begin.tp_row * scp->xsize +
+			    r->tr_begin.tp_col;
+			dst = (p->tp_row + r->tr_end.tp_row -
+			    r->tr_begin.tp_row - 1) * scp->xsize + p->tp_col;
+
+			while (src >= end) {
+				sc_vtb_move(&scp->vtb, src, dst, width);
+			
+				src -= scp->xsize;
+				dst -= scp->xsize;
+			}
+		}
+	}
+
+	/* Mark begin and end positions to be refreshed. */
+	mark_for_update(scp,
+	    p->tp_row * scp->xsize + p->tp_col);
+	mark_for_update(scp,
+	    (p->tp_row + r->tr_end.tp_row - r->tr_begin.tp_row - 1) *
+	    scp->xsize +
+	    (p->tp_col + r->tr_end.tp_col - r->tr_begin.tp_col - 1));
+	sc_remove_cutmarking(scp);
+}
+
+static void
+scteken_param(void *arg, int cmd, int value)
+{
+	scr_stat *scp = arg;
+
+	switch (cmd) {
+	case TP_SHOWCURSOR:
+		if (value) {
+			sc_change_cursor_shape(scp,
+			    CONS_RESET_CURSOR|CONS_LOCAL_CURSOR, -1, -1);
+		} else {
+			sc_change_cursor_shape(scp,
+			    CONS_HIDDEN_CURSOR|CONS_LOCAL_CURSOR, -1, -1);
+		}
+		break;
+	case TP_SWITCHVT:
+		sc_switch_scr(scp->sc, value);
+		break;
+	}
+}
+
+static void
+scteken_respond(void *arg, const void *buf, size_t len)
+{
+	scr_stat *scp = arg;
+
+	sc_respond(scp, buf, len);
+}
diff --git a/sys/dev/syscons/scterm.c b/sys/dev/syscons/scterm.c
index 0b9135a..f0f56b5 100644
--- a/sys/dev/syscons/scterm.c
+++ b/sys/dev/syscons/scterm.c
@@ -36,7 +36,6 @@ __FBSDID("$FreeBSD$");
 #include <sys/consio.h>
 
 #include <dev/syscons/syscons.h>
-#include <dev/syscons/sctermvar.h>
 
 SET_DECLARE(scterm_set, sc_term_sw_t);
 
diff --git a/sys/dev/syscons/syscons.c b/sys/dev/syscons/syscons.c
index 37b08b6..a9b8e40 100644
--- a/sys/dev/syscons/syscons.c
+++ b/sys/dev/syscons/syscons.c
@@ -2741,6 +2741,16 @@ scinit(int unit, int flags)
 	    init_scp(sc, sc->first_vty, scp);
 	    sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize,
 			(void *)sc_buffer, FALSE);
+
+	    /* move cursors to the initial positions */
+	    if (col >= scp->xsize)
+		col = 0;
+	    if (row >= scp->ysize)
+		row = scp->ysize - 1;
+	    scp->xpos = col;
+	    scp->ypos = row;
+	    scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
+
 	    if (sc_init_emulator(scp, SC_DFLT_TERM))
 		sc_init_emulator(scp, "*");
 	    (*scp->tsw->te_default_attr)(scp,
@@ -2764,15 +2774,6 @@ scinit(int unit, int flags)
 	    sc_vtb_copy(&scp->scr, 0, &scp->vtb, 0, scp->xsize*scp->ysize);
 #endif
 
-	/* move cursors to the initial positions */
-	if (col >= scp->xsize)
-	    col = 0;
-	if (row >= scp->ysize)
-	    row = scp->ysize - 1;
-	scp->xpos = col;
-	scp->ypos = row;
-	scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
-
 	if (bios_value.cursor_end < scp->font_size)
 	    sc->dflt_curs_attr.base = scp->font_size - 
 					  bios_value.cursor_end - 1;
@@ -3569,7 +3570,7 @@ sc_show_font(scr_stat *scp, int page)
 #endif /* !SC_NO_FONT_LOADING */
 
 void
-sc_paste(scr_stat *scp, u_char *p, int count) 
+sc_paste(scr_stat *scp, const u_char *p, int count) 
 {
     struct tty *tp;
     u_char *rmap;
@@ -3584,6 +3585,22 @@ sc_paste(scr_stat *scp, u_char *p, int count)
 }
 
 void
+sc_respond(scr_stat *scp, const u_char *p, int count) 
+{
+    struct tty *tp;
+
+    tp = SC_DEV(scp->sc, scp->sc->cur_scp->index);
+    if (!tty_opened(tp))
+	return;
+    for (; count > 0; --count)
+	ttydisc_rint(tp, *p++, 0);
+#if 0
+    /* XXX: we can't call ttydisc_rint_done() here! */
+    ttydisc_rint_done(tp);
+#endif
+}
+
+void
 sc_bell(scr_stat *scp, int pitch, int duration)
 {
     if (cold || shutdown_in_progress || !enable_bell)
diff --git a/sys/dev/syscons/syscons.h b/sys/dev/syscons/syscons.h
index 548cec6..56b30d3 100644
--- a/sys/dev/syscons/syscons.h
+++ b/sys/dev/syscons/syscons.h
@@ -563,7 +563,8 @@ int		sc_clean_up(scr_stat *scp);
 int		sc_switch_scr(sc_softc_t *sc, u_int next_scr);
 void		sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard);
 int		sc_init_emulator(scr_stat *scp, char *name);
-void		sc_paste(scr_stat *scp, u_char *p, int count);
+void		sc_paste(scr_stat *scp, const u_char *p, int count);
+void		sc_respond(scr_stat *scp, const u_char *p, int count);
 void		sc_bell(scr_stat *scp, int pitch, int duration);
 
 /* schistory.c */
diff --git a/sys/dev/syscons/teken/Makefile b/sys/dev/syscons/teken/Makefile
new file mode 100644
index 0000000..cbdd12b
--- /dev/null
+++ b/sys/dev/syscons/teken/Makefile
@@ -0,0 +1,13 @@
+# $FreeBSD$
+
+PROG=		teken_demo
+SRCS=		teken_demo.c teken.c teken_state.h
+CLEANFILES=	teken_state.h teken.log
+LDADD=		-lncurses -lutil
+NO_MAN=
+WARNS?=		6
+
+teken_state.h: gensequences sequences
+	awk -f gensequences sequences > ${.TARGET}
+
+.include <bsd.prog.mk>
diff --git a/sys/dev/syscons/teken/gensequences b/sys/dev/syscons/teken/gensequences
new file mode 100644
index 0000000..86c7979
--- /dev/null
+++ b/sys/dev/syscons/teken/gensequences
@@ -0,0 +1,157 @@
+#!/usr/bin/awk -f
+
+#-
+# Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+# 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 AUTHOR 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 AUTHOR 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.
+#
+# $FreeBSD$
+
+function die(msg) {
+	print msg;
+	exit 1;
+}
+
+function cchar(str) {
+	if (str == "^[")
+		return "\\x1B";
+
+	return str;
+}
+
+BEGIN {
+FS = "\t+"
+
+while (getline > 0) {
+	if (NF == 0 || $1 ~ /^#/)
+		continue;
+
+	if (NF != 3 && NF != 4)
+		die("Invalid line layout: " NF " columns");
+
+	split($3, sequence, " +");
+	nsequences = 0;
+	for (s in sequence)
+		nsequences++;
+
+	prefix = "";
+	l_prefix_name[""] = "teken_state_init";
+	for (i = 1; i < nsequences; i++) {
+		n = prefix sequence[i];
+		l_prefix_parent[n] = prefix;
+		l_prefix_suffix[n] = sequence[i];
+		if (!l_prefix_name[n])
+			l_prefix_name[n] = "teken_state_" ++npr;
+		prefix = n;
+	}
+
+	suffix = sequence[nsequences];
+	cmd = prefix suffix;
+
+	# Fill lists
+	if (l_cmd_name[cmd] != "")
+		die(cmd " already exists");
+	l_cmd_prefix[cmd] = prefix;
+	l_cmd_suffix[cmd] = suffix;
+	l_cmd_args[cmd] = $4;
+	l_cmd_abbr[cmd] = $1;
+	l_cmd_name[cmd] = $2;
+	l_cmd_c_name[cmd] = "teken_subr_" tolower($2);
+	gsub(" ", "_", l_cmd_c_name[cmd]);
+
+	if ($4 != "")
+		l_prefix_numbercmds[prefix]++;
+}
+
+print "/* Generated file. Do not edit. */";
+print "";
+
+for (p in l_prefix_name) {
+	if (l_prefix_name[p] != "teken_state_init")
+		print "static teken_state_t	" l_prefix_name[p] ";";
+}
+
+for (p in l_prefix_name) {
+	print "";
+	print "/* '" p "' */";
+	print "static void";
+	print l_prefix_name[p] "(teken_t *t, teken_char_t c)";
+	print "{";
+
+	if (l_prefix_numbercmds[p] > 0) {
+		print "";
+		print "\tif (teken_state_numbers(t, c))";
+		print "\t\treturn;";
+	}
+
+	print "";
+	print "\tswitch (c) {";
+	for (c in l_cmd_prefix) {
+		if (l_cmd_prefix[c] != p)
+			continue;
+
+		print "\tcase '" cchar(l_cmd_suffix[c]) "': /* " l_cmd_abbr[c] ": " l_cmd_name[c] " */";
+
+		if (l_cmd_args[c] == "v") {
+			print "\t\t" l_cmd_c_name[c] "(t, t->t_curnum, t->t_nums);";
+		} else {
+			printf "\t\t%s(t", l_cmd_c_name[c];
+			split(l_cmd_args[c], args, " ");
+			for (a = 1; args[a] != ""; a++) {
+				if (args[a] == "n")
+					printf ", (t->t_curnum < %d || t->t_nums[%d] == 0) ? 1 : t->t_nums[%d]", a, (a - 1), (a - 1);
+				else if (args[a] == "r")
+					printf ", t->t_curnum < %d ? 0 : t->t_nums[%d]", a, (a - 1);
+				else
+					die("Invalid argument type: " args[a]);
+			}
+			print ");";
+		}
+		print "\t\tbreak;";
+	}
+	for (pc in l_prefix_parent) {
+		if (l_prefix_parent[pc] != p)
+			continue;
+		print "\tcase '" cchar(l_prefix_suffix[pc]) "':";
+		print "\t\tteken_state_switch(t, " l_prefix_name[pc] ");";
+		print "\t\treturn;";
+	}
+
+	print "\tdefault:";
+	if (l_prefix_name[p] == "teken_state_init") {
+		print "\t\tteken_subr_regular_character(t, c);";
+	} else {
+		print "\t\tteken_printf(\"Unsupported sequence in " l_prefix_name[p] ": %u\\n\", (unsigned int)c);";
+	}
+	print "\t\tbreak;";
+
+	print "\t}";
+
+	if (l_prefix_name[p] != "teken_state_init") {
+		print "";
+		print "\tteken_state_switch(t, teken_state_init);";
+	}
+	print "}";
+}
+
+}
diff --git a/sys/dev/syscons/teken/sequences b/sys/dev/syscons/teken/sequences
new file mode 100644
index 0000000..eb5a9fe
--- /dev/null
+++ b/sys/dev/syscons/teken/sequences
@@ -0,0 +1,107 @@
+#-
+# Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+# 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 AUTHOR 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 AUTHOR 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.
+#
+# $FreeBSD$
+
+# File format is as follows:
+#	Abbr		Abbreviation of sequence name
+#	Name		Sequence name (will be converted to C function name)
+#	Sequence	Bytes that form the sequence
+#	Arguments	Standard value of arguments passed to this sequence
+#			- `n' non-zero number (0 gets converted to 1)
+#			- `r' regular numeric argument
+#			- `v' means a variable number of arguments
+
+# Abbr	Name					Sequence	Arguments
+CBT	Cursor Backward Tabulation		^[ [ Z		n
+CHT	Cursor Forward Tabulation		^[ [ I		n
+CNL	Cursor Next Line			^[ [ E		n
+CPL	Cursor Previous Line			^[ [ F		n
+CPR	Cursor Position Report			^[ [ n		r
+CUB	Cursor Backward				^[ [ D		n
+CUD	Cursor Down				^[ [ B		n
+CUD	Cursor Down				^[ [ e		n
+CUF	Cursor Forward				^[ [ C		n
+CUF	Cursor Forward				^[ [ a		n
+CUP	Cursor Position				^[ [ H		n n
+CUP	Cursor Position				^[ [ f		n n
+CUU	Cursor Up				^[ [ A		n
+DA1	Primary Device Attributes		^[ [ c		r
+DA2	Secondary Device Attributes		^[ [ > c	r
+DC	Delete character			^[ [ P		n
+DCS	Device Control String			^[ P
+DECALN	Alignment test				^[ # 8
+DECDHL	Double Height Double Width Line Top	^[ # 3
+DECDHL	Double Height Double Width Line Bottom	^[ # 4
+DECDWL	Single Height Double Width Line		^[ # 6
+DECKPAM	Keypad application mode			^[ =
+DECKPNM	Keypad numeric mode			^[ >
+DECRC	Restore cursor				^[ 8
+DECRC	Restore cursor				^[ [ u
+DECRM	Reset DEC mode				^[ [ ? l	r
+DECSC	Save cursor				^[ 7
+DECSC	Save cursor				^[ [ s
+DECSM	Set DEC mode				^[ [ ? h	r
+DECSTBM	Set top and bottom margins		^[ [ r		r r
+DECSWL	Single Height Single Width Line		^[ # 5
+DL	Delete line				^[ [ M		n
+DSR	Device Status Report			^[ [ ? n	r
+ECH	Erase character				^[ [ X		n
+ED	Erase display				^[ [ J		r
+EL	Erase line				^[ [ K		r
+HPA	Horizontal Position Absolute		^[ [ G		n
+HPA	Horizontal Position Absolute		^[ [ `		n
+HTS	Horizontal Tab Set			^[ H
+ICH	Insert character			^[ [ @		n
+IL	Insert line				^[ [ L		n
+IND	Index					^[ D
+NEL	Next line				^[ E
+RI	Reverse index				^[ M
+RIS	Reset to Initial State			^[ c
+RM	Reset Mode				^[ [ l		r
+SCS	SCS					^[ ( 0
+SCS	SCS					^[ ( 1
+SCS	SCS					^[ ( 2
+SCS	SCS					^[ ( A
+SCS	SCS					^[ ( B
+SCS	SCS					^[ ) 0
+SCS	SCS					^[ ) 1
+SCS	SCS					^[ ) 2
+SCS	SCS					^[ ) A
+SCS	SCS					^[ ) B
+SD	Pan Up					^[ [ T		n
+SGR	Set Graphic Rendition			^[ [ m		v
+SM	Set Mode				^[ [ h		r
+ST	String Terminator			^[ \\
+SU	Pan Down				^[ [ S		n
+TBC	Tab Clear				^[ [ g		r
+VPA	Vertical Position Absolute		^[ [ d		n
+
+# Cons25 compatibility sequences
+C25CURS	Cons25 set cursor type			^[ [ = S	r
+C25VTSW	Cons25 switch virtual terminal		^[ [ z		r
+
+# VT52 compatibility
+#DECID	VT52 DECID				^[ Z
diff --git a/sys/dev/syscons/teken/teken.c b/sys/dev/syscons/teken/teken.c
new file mode 100644
index 0000000..e1efcf7
--- /dev/null
+++ b/sys/dev/syscons/teken/teken.c
@@ -0,0 +1,386 @@
+/*-
+ * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+ * 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 AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/cdefs.h>
+#if defined(__FreeBSD__) && defined(_KERNEL)
+#include <sys/param.h>
+#include <sys/lock.h>
+#include <sys/systm.h>
+#define	teken_assert(x)		MPASS(x)
+#define	teken_printf(x,...)
+#else /* !(__FreeBSD__ && _KERNEL) */
+#include <sys/types.h>
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#define	teken_assert(x)		assert(x)
+#define	teken_printf(x,...)	do { \
+	if (df != NULL) \
+		fprintf(df, x, ## __VA_ARGS__); \
+} while (0)
+/* debug messages */
+static FILE *df;
+#endif /* __FreeBSD__ && _KERNEL */
+
+#include "teken.h"
+#ifdef TEKEN_UTF8
+#include "teken_wcwidth.h"
+#else /* !TEKEN_UTF8 */
+static inline int
+teken_wcwidth(teken_char_t c)
+{
+
+	return (c <= 0x1B) ? -1 : 1;
+}
+#endif /* TEKEN_UTF8 */
+
+/* Private flags for teken_format_t. */
+#define	TF_REVERSE	0x08
+
+/* Private flags for t_stateflags. */
+#define	TS_FIRSTDIGIT	0x01	/* First numeric digit in escape sequence. */
+#define	TS_INSERT	0x02	/* Insert mode. */
+#define	TS_AUTOWRAP	0x04	/* Autowrap. */
+#define	TS_ORIGIN	0x08	/* Origin mode. */
+#define	TS_WRAPPED	0x10	/* Next character should be printed on col 0. */
+
+/* Character that blanks a cell. */
+#define	BLANK	' '
+
+static teken_state_t	teken_state_init;
+
+/*
+ * Wrappers for hooks.
+ */
+
+static inline void
+teken_funcs_bell(teken_t *t)
+{
+
+	t->t_funcs->tf_bell(t->t_softc);
+}
+
+static inline void
+teken_funcs_cursor(teken_t *t)
+{
+
+	teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
+	teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
+
+	t->t_funcs->tf_cursor(t->t_softc, &t->t_cursor);
+}
+
+static inline void
+teken_funcs_putchar(teken_t *t, const teken_pos_t *p, teken_char_t c,
+    const teken_attr_t *a)
+{
+	teken_attr_t ta;
+
+	teken_assert(p->tp_row < t->t_winsize.tp_row);
+	teken_assert(p->tp_col < t->t_winsize.tp_col);
+
+	/* Apply inversion. */
+	if (a->ta_format & TF_REVERSE) {
+		ta.ta_format = a->ta_format;
+		ta.ta_fgcolor = a->ta_bgcolor;
+		ta.ta_bgcolor = a->ta_fgcolor;
+		a = &ta;
+	}
+
+	t->t_funcs->tf_putchar(t->t_softc, p, c, a);
+}
+
+static inline void
+teken_funcs_fill(teken_t *t, const teken_rect_t *r,
+    const teken_char_t c, const teken_attr_t *a)
+{
+	teken_attr_t ta;
+
+	teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
+	teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
+	teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
+	teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
+
+	/* Apply inversion. */
+	if (a->ta_format & TF_REVERSE) {
+		ta.ta_format = a->ta_format;
+		ta.ta_fgcolor = a->ta_bgcolor;
+		ta.ta_bgcolor = a->ta_fgcolor;
+		a = &ta;
+	}
+
+	t->t_funcs->tf_fill(t->t_softc, r, c, a);
+}
+
+static inline void
+teken_funcs_copy(teken_t *t, const teken_rect_t *r, const teken_pos_t *p)
+{
+
+	teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
+	teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
+	teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
+	teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
+	teken_assert(p->tp_row + (r->tr_end.tp_row - r->tr_begin.tp_row) <= t->t_winsize.tp_row);
+	teken_assert(p->tp_col + (r->tr_end.tp_col - r->tr_begin.tp_col) <= t->t_winsize.tp_col);
+
+	t->t_funcs->tf_copy(t->t_softc, r, p);
+}
+
+static inline void
+teken_funcs_param(teken_t *t, int cmd, int value)
+{
+
+	t->t_funcs->tf_param(t->t_softc, cmd, value);
+}
+
+static inline void
+teken_funcs_respond(teken_t *t, const void *buf, size_t len)
+{
+
+	t->t_funcs->tf_respond(t->t_softc, buf, len);
+}
+
+#include "teken_subr.h"
+#include "teken_subr_compat.h"
+
+/*
+ * Programming interface.
+ */
+
+void
+teken_init(teken_t *t, const teken_funcs_t *tf, void *softc)
+{
+	teken_pos_t tp = { .tp_row = 24, .tp_col = 80 };
+
+#if !(defined(__FreeBSD__) && defined(_KERNEL))
+	df = fopen("teken.log", "w");
+	if (df != NULL)
+		setvbuf(df, NULL, _IOLBF, BUFSIZ);
+#endif /* !(__FreeBSD__ && _KERNEL) */
+
+	t->t_funcs = tf;
+	t->t_softc = softc;
+
+	t->t_nextstate = teken_state_init;
+
+	t->t_defattr.ta_format = 0;
+	t->t_defattr.ta_fgcolor = TC_WHITE;
+	t->t_defattr.ta_bgcolor = TC_BLACK;
+	teken_subr_do_reset(t);
+
+#ifdef TEKEN_UTF8
+	t->t_utf8_left = 0;
+#endif /* TEKEN_UTF8 */
+
+	teken_set_winsize(t, &tp);
+}
+
+static void
+teken_input_char(teken_t *t, teken_char_t c)
+{
+
+	switch (c) {
+	case '\0':
+		break;
+	case '\a':
+		teken_subr_bell(t);
+		break;
+	case '\b':
+		teken_subr_backspace(t);
+		break;
+	case '\n':
+	case '\x0B':
+		teken_subr_newline(t);
+		break;
+	case '\r':
+		teken_subr_carriage_return(t);
+		break;
+	case '\t':
+		teken_subr_horizontal_tab(t);
+		break;
+	default:
+		t->t_nextstate(t, c);
+		break;
+	}
+
+	/* Post-processing assertions. */
+	teken_assert(t->t_cursor.tp_row >= t->t_originreg.ts_begin);
+	teken_assert(t->t_cursor.tp_row < t->t_originreg.ts_end);
+	teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
+	teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
+	teken_assert(t->t_saved_cursor.tp_row < t->t_winsize.tp_row);
+	teken_assert(t->t_saved_cursor.tp_col < t->t_winsize.tp_col);
+	teken_assert(t->t_scrollreg.ts_end <= t->t_winsize.tp_row);
+	teken_assert(t->t_scrollreg.ts_begin < t->t_scrollreg.ts_end);
+	/* Origin region has to be window size or the same as scrollreg. */
+	teken_assert((t->t_originreg.ts_begin == t->t_scrollreg.ts_begin &&
+	    t->t_originreg.ts_end == t->t_scrollreg.ts_end) ||
+	    (t->t_originreg.ts_begin == 0 &&
+	    t->t_originreg.ts_end == t->t_winsize.tp_row));
+}
+
+static void
+teken_input_byte(teken_t *t, unsigned char c)
+{
+
+#ifdef TEKEN_UTF8
+	/*
+	 * UTF-8 handling.
+	 */
+	if ((c & 0x80) == 0x00) {
+		/* One-byte sequence. */
+		t->t_utf8_left = 0;
+		teken_input_char(t, c);
+	} else if ((c & 0xe0) == 0xc0) {
+		/* Two-byte sequence. */
+		t->t_utf8_left = 1;
+		t->t_utf8_partial = c & 0x1f;
+	} else if ((c & 0xf0) == 0xe0) {
+		/* Three-byte sequence. */
+		t->t_utf8_left = 2;
+		t->t_utf8_partial = c & 0x0f;
+	} else if ((c & 0xf8) == 0xf0) {
+		/* Four-byte sequence. */
+		t->t_utf8_left = 3;
+		t->t_utf8_partial = c & 0x07;
+	} else if ((c & 0xc0) == 0x80) {
+		if (t->t_utf8_left == 0)
+			return;
+		t->t_utf8_left--;
+		t->t_utf8_partial = (t->t_utf8_partial << 6) | (c & 0x3f);
+		if (t->t_utf8_left == 0) {
+			teken_printf("Got UTF-8 char %u\n", t->t_utf8_partial);
+			teken_input_char(t, t->t_utf8_partial);
+		}
+	}
+#else /* !TEKEN_UTF8 */
+	teken_input_char(t, c);
+#endif /* TEKEN_UTF8 */
+}
+
+void
+teken_input(teken_t *t, const void *buf, size_t len)
+{
+	const char *c = buf;
+
+	while (len-- > 0)
+		teken_input_byte(t, *c++);
+}
+
+void
+teken_set_cursor(teken_t *t, const teken_pos_t *p)
+{
+
+	/* XXX: bounds checking with originreg! */
+	teken_assert(p->tp_row < t->t_winsize.tp_row);
+	teken_assert(p->tp_col < t->t_winsize.tp_col);
+
+	t->t_cursor = *p;
+}
+
+void
+teken_set_defattr(teken_t *t, const teken_attr_t *a)
+{
+
+	t->t_curattr = t->t_saved_curattr = t->t_defattr = *a;
+}
+
+void
+teken_set_winsize(teken_t *t, const teken_pos_t *p)
+{
+
+	teken_assert(p->tp_col <= T_NUMCOL);
+
+	t->t_winsize = *p;
+	/* XXX: bounds checking with cursor/etc! */
+	t->t_scrollreg.ts_begin = 0;
+	t->t_scrollreg.ts_end = t->t_winsize.tp_row;
+	t->t_originreg = t->t_scrollreg;
+}
+
+/*
+ * State machine.
+ */
+
+static void
+teken_state_switch(teken_t *t, teken_state_t *s)
+{
+
+	t->t_nextstate = s;
+	t->t_curnum = 0;
+	t->t_stateflags |= TS_FIRSTDIGIT;
+}
+
+static int
+teken_state_numbers(teken_t *t, teken_char_t c)
+{
+
+	teken_assert(t->t_curnum < T_NUMSIZE);
+
+	if (c >= '0' && c <= '9') {
+		/*
+		 * Don't do math with the default value of 1 when a
+		 * custom number is inserted.
+		 */
+		if (t->t_stateflags & TS_FIRSTDIGIT) {
+			t->t_stateflags &= ~TS_FIRSTDIGIT;
+			t->t_nums[t->t_curnum] = 0;
+		} else {
+			t->t_nums[t->t_curnum] *= 10;
+		}
+
+		t->t_nums[t->t_curnum] += c - '0';
+		return (1);
+	} else if (c == ';') {
+		if (t->t_stateflags & TS_FIRSTDIGIT)
+			t->t_nums[t->t_curnum] = 0;
+
+		/* Only allow a limited set of arguments. */
+		if (++t->t_curnum == T_NUMSIZE) {
+			teken_state_switch(t, teken_state_init);
+			return (1);
+		}
+
+		t->t_stateflags |= TS_FIRSTDIGIT;
+		return (1);
+	} else {
+		if (t->t_stateflags & TS_FIRSTDIGIT && t->t_curnum > 0) {
+			/* Finish off the last empty argument. */
+			t->t_nums[t->t_curnum] = 0;
+			t->t_curnum++;
+		} else if ((t->t_stateflags & TS_FIRSTDIGIT) == 0) {
+			/* Also count the last argument. */
+			t->t_curnum++;
+		}
+	}
+
+	return (0);
+}
+
+#include "teken_state.h"
diff --git a/sys/dev/syscons/teken/teken.h b/sys/dev/syscons/teken/teken.h
new file mode 100644
index 0000000..ef107ca
--- /dev/null
+++ b/sys/dev/syscons/teken/teken.h
@@ -0,0 +1,168 @@
+/*-
+ * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+ * 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 AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _TEKEN_H_
+#define	_TEKEN_H_
+
+/*
+ * libteken: terminal emulation library.
+ *
+ * This library converts an UTF-8 stream of bytes to terminal drawing
+ * commands. It implements commands similar to xterm-color.
+ */
+
+#if 0
+/*
+ * XXX: Disable UTF-8 support for now. It requires UTF-8 keyboard input
+ * and rendering, which we do not yet support.
+ */
+#define	TEKEN_UTF8
+#endif
+
+#ifdef TEKEN_UTF8
+typedef uint32_t teken_char_t;
+#else /* !TEKEN_UTF8 */
+typedef unsigned char teken_char_t;
+#endif /* TEKEN_UTF8 */
+typedef unsigned short teken_unit_t;
+typedef unsigned char teken_format_t;
+#define	TF_BOLD		0x01
+#define	TF_UNDERLINE	0x02
+#define	TF_BLINK	0x04
+typedef unsigned char teken_color_t;
+#define	TC_BLACK	0
+#define	TC_RED		1
+#define	TC_GREEN	2
+#define	TC_BROWN	3
+#define	TC_BLUE		4
+#define	TC_MAGENTA	5
+#define	TC_CYAN		6
+#define	TC_WHITE	7
+#define	TC_NCOLORS	8
+
+typedef struct {
+	teken_unit_t	tp_row;
+	teken_unit_t	tp_col;
+} teken_pos_t;
+typedef struct {
+	teken_pos_t	tr_begin;
+	teken_pos_t	tr_end;
+} teken_rect_t;
+typedef struct {
+	teken_format_t	ta_format;
+	teken_color_t	ta_fgcolor;
+	teken_color_t	ta_bgcolor;
+} teken_attr_t;
+typedef struct {
+	teken_unit_t	ts_begin;
+	teken_unit_t	ts_end;
+} teken_span_t;
+
+typedef struct __teken teken_t;
+
+typedef void teken_state_t(teken_t *, teken_char_t);
+
+/*
+ * Drawing routines supplied by the user.
+ */
+
+typedef void tf_bell_t(void *);
+typedef void tf_cursor_t(void *, const teken_pos_t *);
+typedef void tf_putchar_t(void *, const teken_pos_t *, teken_char_t,
+    const teken_attr_t *);
+typedef void tf_fill_t(void *, const teken_rect_t *, teken_char_t,
+    const teken_attr_t *);
+typedef void tf_copy_t(void *, const teken_rect_t *, const teken_pos_t *);
+typedef void tf_param_t(void *, int, int);
+#define	TP_SHOWCURSOR	0
+#define	TP_CURSORKEYS	1
+#define	TP_KEYPADAPP	2
+#define	TP_AUTOREPEAT	3
+#define	TP_SWITCHVT	4
+#define	TP_132COLS	5
+typedef void tf_respond_t(void *, const void *, size_t);
+
+typedef struct {
+	tf_bell_t	*tf_bell;
+	tf_cursor_t	*tf_cursor;
+	tf_putchar_t	*tf_putchar;
+	tf_fill_t	*tf_fill;
+	tf_copy_t	*tf_copy;
+	tf_param_t	*tf_param;
+	tf_respond_t	*tf_respond;
+} teken_funcs_t;
+
+/*
+ * Terminal state.
+ */
+
+struct __teken {
+	const teken_funcs_t *t_funcs;
+	void		*t_softc;
+
+	teken_state_t	*t_nextstate;
+	unsigned int	 t_stateflags;
+
+#define T_NUMSIZE	8
+	unsigned int	 t_nums[T_NUMSIZE];
+	unsigned int	 t_curnum;
+
+	teken_pos_t	 t_cursor;
+	teken_attr_t	 t_curattr;
+	teken_pos_t	 t_saved_cursor;
+	teken_attr_t	 t_saved_curattr;
+
+	teken_attr_t	 t_defattr;
+	teken_pos_t	 t_winsize;
+
+	/* For DECSTBM. */
+	teken_span_t	 t_scrollreg;
+	/* For DECOM. */
+	teken_span_t	 t_originreg;
+
+#define	T_NUMCOL	160
+	unsigned int	t_tabstops[T_NUMCOL / (sizeof(unsigned int) * 8)];
+
+#ifdef TEKEN_UTF8
+	unsigned int	t_utf8_left;
+	teken_char_t	t_utf8_partial;
+#endif /* TEKEN_UTF8 */
+};
+
+/* Initialize teken structure. */
+void	teken_init(teken_t *, const teken_funcs_t *, void *);
+
+/* Deliver character input. */
+void	teken_input(teken_t *, const void *, size_t);
+
+/* Set teken attributes. */
+void	teken_set_cursor(teken_t *, const teken_pos_t *);
+void	teken_set_defattr(teken_t *, const teken_attr_t *);
+void	teken_set_winsize(teken_t *, const teken_pos_t *);
+
+#endif /* !_TEKEN_H_ */
diff --git a/sys/dev/syscons/teken/teken_demo.c b/sys/dev/syscons/teken/teken_demo.c
new file mode 100644
index 0000000..7d01f9b
--- /dev/null
+++ b/sys/dev/syscons/teken/teken_demo.c
@@ -0,0 +1,336 @@
+/*-
+ * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+ * 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 AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/ioctl.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <ncurses.h>
+#if defined(__FreeBSD__)
+#include <libutil.h>
+#elif defined(__linux__)
+#include <pty.h>
+#else
+#include <util.h>
+#endif
+
+#include "teken.h"
+
+static tf_bell_t	test_bell;
+static tf_cursor_t	test_cursor;
+static tf_putchar_t	test_putchar;
+static tf_fill_t	test_fill;
+static tf_copy_t	test_copy;
+static tf_param_t	test_param;
+static tf_respond_t	test_respond;
+
+static teken_funcs_t tf = {
+	.tf_bell	= test_bell,
+	.tf_cursor	= test_cursor,
+	.tf_putchar	= test_putchar,
+	.tf_fill	= test_fill,
+	.tf_copy	= test_copy,
+	.tf_param	= test_param,
+	.tf_respond	= test_respond,
+};
+
+struct pixel {
+	teken_char_t	c;
+	teken_attr_t	a;
+};
+
+#define NCOLS	80
+#define NROWS	24
+struct pixel buffer[NCOLS][NROWS];
+
+static int ptfd;
+
+static void
+printchar(const teken_pos_t *p)
+{
+	int y, x, attr = 0;
+	struct pixel *px, pt;
+
+	assert(p->tp_row < NROWS);
+	assert(p->tp_col < NCOLS);
+
+	getyx(stdscr, y, x);
+
+ 	px = &buffer[p->tp_col][p->tp_row];
+
+	if (px->c >= 0x80) {
+		/* Mark UTF-8 chars (we don't support it). */
+		px = &pt;
+		px->c = '?';
+		px->a.ta_format = TF_BOLD;
+		px->a.ta_fgcolor = TC_BROWN;
+		px->a.ta_bgcolor = TC_RED;
+	}
+
+	if (px->a.ta_format & TF_BOLD)
+		attr |= A_BOLD;
+	if (px->a.ta_format & TF_UNDERLINE)
+		attr |= A_UNDERLINE;
+	if (px->a.ta_format & TF_BLINK)
+		attr |= A_BLINK;
+
+	bkgdset(attr | COLOR_PAIR(px->a.ta_fgcolor + 8 * px->a.ta_bgcolor + 1));
+	mvaddch(p->tp_row, p->tp_col, px->c);
+
+	move(y, x);
+}
+
+static void
+test_bell(void *s __unused)
+{
+
+	beep();
+}
+
+static void
+test_cursor(void *s __unused, const teken_pos_t *p)
+{
+
+	move(p->tp_row, p->tp_col);
+}
+
+static void
+test_putchar(void *s __unused, const teken_pos_t *p, teken_char_t c,
+    const teken_attr_t *a)
+{
+
+	buffer[p->tp_col][p->tp_row].c = c;
+	buffer[p->tp_col][p->tp_row].a = *a;
+	printchar(p);
+}
+
+static void
+test_fill(void *s, const teken_rect_t *r, teken_char_t c,
+    const teken_attr_t *a)
+{
+	teken_pos_t p;
+
+	/* Braindead implementation of fill() - just call putchar(). */
+	for (p.tp_row = r->tr_begin.tp_row; p.tp_row < r->tr_end.tp_row; p.tp_row++)
+		for (p.tp_col = r->tr_begin.tp_col; p.tp_col < r->tr_end.tp_col; p.tp_col++)
+			test_putchar(s, &p, c, a);
+}
+
+static void
+test_copy(void *s __unused, const teken_rect_t *r, const teken_pos_t *p)
+{
+	int nrow, ncol, x, y; /* Has to be signed - >= 0 comparison */
+	teken_pos_t d;
+
+	/*
+	 * Copying is a little tricky. We must make sure we do it in
+	 * correct order, to make sure we don't overwrite our own data.
+	 */
+	
+	nrow = r->tr_end.tp_row - r->tr_begin.tp_row;
+	ncol = r->tr_end.tp_col - r->tr_begin.tp_col;
+	
+	if (p->tp_row < r->tr_begin.tp_row) {
+		/* Copy from top to bottom. */
+		if (p->tp_col < r->tr_begin.tp_col) {
+			/* Copy from left to right. */
+			for (y = 0; y < nrow; y++) {
+				d.tp_row = p->tp_row + y;
+				for (x = 0; x < ncol; x++) {
+					d.tp_col = p->tp_col + x;
+					buffer[d.tp_col][d.tp_row] =
+					    buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
+					printchar(&d);
+				}
+			}
+		} else {
+			/* Copy from right to left. */
+			for (y = 0; y < nrow; y++) {
+				d.tp_row = p->tp_row + y;
+				for (x = ncol - 1; x >= 0; x--) {
+					d.tp_col = p->tp_col + x;
+					buffer[d.tp_col][d.tp_row] =
+					    buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
+					printchar(&d);
+				}
+			}
+		}
+	} else {
+		/* Copy from bottom to top. */
+		if (p->tp_col < r->tr_begin.tp_col) {
+			/* Copy from left to right. */
+			for (y = nrow - 1; y >= 0; y--) {
+				d.tp_row = p->tp_row + y;
+				for (x = 0; x < ncol; x++) {
+					d.tp_col = p->tp_col + x;
+					buffer[d.tp_col][d.tp_row] =
+					    buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
+					printchar(&d);
+				}
+			}
+		} else {
+			/* Copy from right to left. */
+			for (y = nrow - 1; y >= 0; y--) {
+				d.tp_row = p->tp_row + y;
+				for (x = ncol - 1; x >= 0; x--) {
+					d.tp_col = p->tp_col + x;
+					buffer[d.tp_col][d.tp_row] =
+					    buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
+					printchar(&d);
+				}
+			}
+		}
+	}
+}
+
+static void
+test_param(void *s __unused, int cmd, int value)
+{
+
+	switch (cmd) {
+	case TP_SHOWCURSOR:
+		curs_set(value);
+		break;
+	case TP_KEYPADAPP:
+		keypad(stdscr, value ? TRUE : FALSE);
+		break;
+	}
+}
+
+static void
+test_respond(void *s __unused, const void *buf, size_t len)
+{
+
+	write(ptfd, buf, len);
+}
+
+static void
+redraw_border(void)
+{
+	unsigned int i;
+
+	for (i = 0; i < NROWS; i++)
+		mvaddch(i, NCOLS, '|');
+	for (i = 0; i < NCOLS; i++)
+		mvaddch(NROWS, i, '-');
+
+	mvaddch(NROWS, NCOLS, '+');
+}
+
+static void
+redraw_all(void)
+{
+	teken_pos_t tp;
+
+	for (tp.tp_row = 0; tp.tp_row < NROWS; tp.tp_row++)
+		for (tp.tp_col = 0; tp.tp_col < NCOLS; tp.tp_col++)
+			printchar(&tp);
+
+	redraw_border();
+}
+
+int
+main(int argc __unused, char *argv[] __unused)
+{
+	struct winsize ws;
+	teken_t t;
+	teken_pos_t tp;
+	fd_set rfds;
+	char b[256];
+	ssize_t bl;
+	const int ccolors[8] = { COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE };
+	int i, j;
+
+	tp.tp_row = ws.ws_row = NROWS;
+	tp.tp_col = ws.ws_col = NCOLS;
+
+	switch (forkpty(&ptfd, NULL, NULL, &ws)) {
+	case -1:
+		perror("forkpty");
+		exit(1);
+	case 0:
+		setenv("TERM", "xterm-color", 1);
+		setenv("LC_CTYPE", "UTF-8", 0);
+		execlp("zsh", "-zsh", NULL);
+		execlp("bash", "-bash", NULL);
+		execlp("sh", "-sh", NULL);
+		_exit(1);
+	}
+
+	teken_init(&t, &tf, NULL);
+	teken_set_winsize(&t, &tp);
+
+	initscr();
+	raw();
+	start_color();
+	for (i = 0; i < 8; i++)
+		for (j = 0; j < 8; j++)
+			init_pair(i + 8 * j + 1, ccolors[i], ccolors[j]);
+
+	redraw_border();
+
+	FD_ZERO(&rfds);
+
+	for (;;) {
+		FD_SET(STDIN_FILENO, &rfds);
+		FD_SET(ptfd, &rfds);
+
+		if (select(ptfd + 1, &rfds, NULL, NULL, NULL) < 0) {
+			if (errno == EINTR) {
+				redraw_all();
+				refresh();
+				continue;
+			}
+			break;
+		}
+
+		if (FD_ISSET(STDIN_FILENO, &rfds)) {
+			bl = read(STDIN_FILENO, b, sizeof b);
+			if (bl <= 0)
+				break;
+			write(ptfd, b, bl);
+		}
+
+		if (FD_ISSET(ptfd, &rfds)) {
+			bl = read(ptfd, b, sizeof b);
+			if (bl <= 0)
+				break;
+			teken_input(&t, b, bl);
+			refresh();
+		}
+	}
+
+	endwin();
+
+	return (0);
+}
diff --git a/sys/dev/syscons/teken/teken_stress.c b/sys/dev/syscons/teken/teken_stress.c
new file mode 100644
index 0000000..1b71647
--- /dev/null
+++ b/sys/dev/syscons/teken/teken_stress.c
@@ -0,0 +1,123 @@
+/*-
+ * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+ * 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 AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/cdefs.h>
+
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "teken.h"
+
+static tf_bell_t	stress_bell;
+static tf_cursor_t	stress_cursor;
+static tf_putchar_t	stress_putchar;
+static tf_fill_t	stress_fill;
+static tf_copy_t	stress_copy;
+static tf_param_t	stress_param;
+static tf_respond_t	stress_respond;
+
+static teken_funcs_t tf = {
+	.tf_bell	= stress_bell,
+	.tf_cursor	= stress_cursor,
+	.tf_putchar	= stress_putchar,
+	.tf_fill	= stress_fill,
+	.tf_copy	= stress_copy,
+	.tf_param	= stress_param,
+	.tf_respond	= stress_respond,
+};
+
+static void
+stress_bell(void *s __unused)
+{
+}
+
+static void
+stress_cursor(void *s __unused, const teken_pos_t *p __unused)
+{
+}
+
+static void
+stress_putchar(void *s __unused, const teken_pos_t *p __unused,
+    teken_char_t c __unused, const teken_attr_t *a __unused)
+{
+}
+
+static void
+stress_fill(void *s __unused, const teken_rect_t *r __unused,
+    teken_char_t c __unused, const teken_attr_t *a __unused)
+{
+}
+
+static void
+stress_copy(void *s __unused, const teken_rect_t *r __unused,
+    const teken_pos_t *p __unused)
+{
+}
+
+static void
+stress_param(void *s __unused, int cmd __unused, int value __unused)
+{
+}
+
+static void
+stress_respond(void *s __unused, const void *buf __unused, size_t len __unused)
+{
+}
+
+int
+main(int argc __unused, char *argv[] __unused)
+{
+	teken_t t;
+	int rnd;
+	unsigned int iteration = 0;
+	char buf[2048];
+
+	rnd = open("/dev/urandom", O_RDONLY);
+	if (rnd < 0) {
+		perror("/dev/urandom");
+		exit(1);
+	}
+
+	teken_init(&t, &tf, NULL);
+
+	for (;;) {
+		if (read(rnd, buf, sizeof buf) != sizeof buf) {
+			perror("read");
+			exit(1);
+		}
+
+		teken_input(&t, buf, sizeof buf);
+
+		iteration++;
+		if ((iteration % 10000) == 0)
+			printf("Processed %u frames\n", iteration);
+	}
+}
diff --git a/sys/dev/syscons/teken/teken_subr.h b/sys/dev/syscons/teken/teken_subr.h
new file mode 100644
index 0000000..de79cfa
--- /dev/null
+++ b/sys/dev/syscons/teken/teken_subr.h
@@ -0,0 +1,1107 @@
+/*-
+ * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+ * 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 AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+static void teken_subr_cursor_up(teken_t *, unsigned int);
+static void teken_subr_erase_line(teken_t *, unsigned int);
+static void teken_subr_regular_character(teken_t *, teken_char_t);
+static void teken_subr_reset_to_initial_state(teken_t *);
+
+static inline int
+teken_tab_isset(teken_t *t, unsigned int col)
+{
+	unsigned int b, o;
+
+	teken_assert(col <= T_NUMCOL);
+
+	b = col / (sizeof(unsigned int) * 8);
+	o = col % (sizeof(unsigned int) * 8);
+
+	return (t->t_tabstops[b] & (1 << o));
+}
+
+static inline void
+teken_tab_clear(teken_t *t, unsigned int col)
+{
+	unsigned int b, o;
+
+	teken_assert(col <= T_NUMCOL);
+
+	b = col / (sizeof(unsigned int) * 8);
+	o = col % (sizeof(unsigned int) * 8);
+
+	t->t_tabstops[b] &= ~(1 << o);
+}
+
+static inline void
+teken_tab_set(teken_t *t, unsigned int col)
+{
+	unsigned int b, o;
+
+	teken_assert(col <= T_NUMCOL);
+
+	b = col / (sizeof(unsigned int) * 8);
+	o = col % (sizeof(unsigned int) * 8);
+
+	t->t_tabstops[b] |= 1 << o;
+}
+
+static void
+teken_tab_default(teken_t *t)
+{
+	unsigned int i;
+
+	memset(&t->t_tabstops, 0, T_NUMCOL / 8);
+
+	for (i = 8; i < T_NUMCOL; i += 8)
+		teken_tab_set(t, i);
+}
+
+static void
+teken_subr_do_scroll(teken_t *t, int amount)
+{
+	teken_rect_t tr;
+	teken_pos_t tp;
+
+	teken_assert(t->t_cursor.tp_row <= t->t_winsize.tp_row);
+	teken_assert(t->t_scrollreg.ts_end <= t->t_winsize.tp_row);
+	teken_assert(amount != 0);
+
+	/* Copy existing data 1 line up. */
+	if (amount > 0) {
+		/* Scroll down. */
+
+		/* Copy existing data up. */
+		if (t->t_scrollreg.ts_begin + amount < t->t_scrollreg.ts_end) {
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_begin + amount;
+			tr.tr_begin.tp_col = 0;
+			tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+			tr.tr_end.tp_col = t->t_winsize.tp_col;
+			tp.tp_row = t->t_scrollreg.ts_begin;
+			tp.tp_col = 0;
+			teken_funcs_copy(t, &tr, &tp);
+
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_end - amount;
+		} else {
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
+		}
+
+		/* Clear the last lines. */
+		tr.tr_begin.tp_col = 0;
+		tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+		teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+	} else {
+		/* Scroll up. */
+		amount = -amount;
+
+		/* Copy existing data down. */
+		if (t->t_scrollreg.ts_begin + amount < t->t_scrollreg.ts_end) {
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
+			tr.tr_begin.tp_col = 0;
+			tr.tr_end.tp_row = t->t_scrollreg.ts_end - amount;
+			tr.tr_end.tp_col = t->t_winsize.tp_col;
+			tp.tp_row = t->t_scrollreg.ts_begin + amount;
+			tp.tp_col = 0;
+			teken_funcs_copy(t, &tr, &tp);
+
+			tr.tr_end.tp_row = t->t_scrollreg.ts_begin + amount;
+		} else {
+			tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+		}
+
+		/* Clear the first lines. */
+		tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
+		tr.tr_begin.tp_col = 0;
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+		teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+	}
+}
+
+static ssize_t
+teken_subr_do_cpr(teken_t *t, unsigned int cmd, char response[16])
+{
+
+	switch (cmd) {
+	case 5: /* Operating status. */
+		strcpy(response, "0n");
+		return (2);
+	case 6: { /* Cursor position. */
+		int len;
+
+		len = snprintf(response, 16, "%u;%uR",
+		    (t->t_cursor.tp_row - t->t_originreg.ts_begin) + 1,
+		    t->t_cursor.tp_col + 1);
+
+		if (len >= 16)
+			return (-1);
+		return (len);
+	}
+	case 15: /* Printer status. */
+		strcpy(response, "13n");
+		return (3);
+	case 25: /* UDK status. */
+		strcpy(response, "20n");
+		return (3);
+	case 26: /* Keyboard status. */
+		strcpy(response, "27;1n");
+		return (5);
+	default:
+		teken_printf("Unknown DSR\n");
+		return (-1);
+	}
+}
+
+static void
+teken_subr_alignment_test(teken_t *t)
+{
+	teken_rect_t tr;
+
+	t->t_scrollreg.ts_begin = 0;
+	t->t_scrollreg.ts_end = t->t_winsize.tp_row;
+
+	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+
+	tr.tr_begin.tp_row = 0;
+	tr.tr_begin.tp_col = 0;
+	tr.tr_end = t->t_winsize;
+	teken_funcs_fill(t, &tr, 'E', &t->t_defattr);
+}
+
+static void
+teken_subr_backspace(teken_t *t)
+{
+
+	if (t->t_cursor.tp_col == 0)
+		return;
+
+	t->t_cursor.tp_col--;
+	t->t_stateflags &= ~TS_WRAPPED;
+
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_bell(teken_t *t)
+{
+
+	teken_funcs_bell(t);
+}
+
+static void
+teken_subr_carriage_return(teken_t *t)
+{
+
+	t->t_cursor.tp_col = 0;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_backward(teken_t *t, unsigned int ncols)
+{
+
+	if (ncols > t->t_cursor.tp_col)
+		t->t_cursor.tp_col = 0;
+	else
+		t->t_cursor.tp_col -= ncols;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_backward_tabulation(teken_t *t, unsigned int ntabs)
+{
+
+	do {
+		/* Stop when we've reached the beginning of the line. */
+		if (t->t_cursor.tp_col == 0)
+			break;
+
+		t->t_cursor.tp_col--;
+		
+		/* Tab marker set. */
+		if (teken_tab_isset(t, t->t_cursor.tp_col))
+			ntabs--;
+	} while (ntabs > 0);
+}
+
+static void
+teken_subr_cursor_down(teken_t *t, unsigned int nrows)
+{
+
+	teken_assert(t->t_cursor.tp_row < t->t_scrollreg.ts_end);
+	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end)
+		t->t_cursor.tp_row = t->t_scrollreg.ts_end - 1;
+	else
+		t->t_cursor.tp_row += nrows;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_forward(teken_t *t, unsigned int ncols)
+{
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col)
+		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+	else
+		t->t_cursor.tp_col += ncols;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_forward_tabulation(teken_t *t, unsigned int ntabs)
+{
+
+	do {
+		/* Stop when we've reached the end of the line. */
+		if (t->t_cursor.tp_col == t->t_winsize.tp_col - 1)
+			break;
+
+		t->t_cursor.tp_col++;
+		
+		/* Tab marker set. */
+		if (teken_tab_isset(t, t->t_cursor.tp_col))
+			ntabs--;
+	} while (ntabs > 0);
+}
+
+static void
+teken_subr_cursor_next_line(teken_t *t, unsigned int ncols)
+{
+
+	t->t_cursor.tp_col = 0;
+	teken_subr_cursor_down(t, ncols);
+}
+
+static void
+teken_subr_cursor_position(teken_t *t, unsigned int row, unsigned int col)
+{
+
+	t->t_cursor.tp_row = t->t_originreg.ts_begin + row - 1;
+	if (row >= t->t_originreg.ts_end)
+		t->t_cursor.tp_row = t->t_originreg.ts_end - 1;
+
+	t->t_cursor.tp_col = col - 1;
+	if (t->t_cursor.tp_col >= t->t_winsize.tp_col)
+		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_position_report(teken_t *t, unsigned int cmd)
+{
+	char response[18] = "\x1B[";
+	ssize_t len;
+
+	len = teken_subr_do_cpr(t, cmd, response + 2);
+	if (len < 0)
+		return;
+
+	teken_funcs_respond(t, response, len + 2);
+}
+
+static void
+teken_subr_cursor_previous_line(teken_t *t, unsigned int ncols)
+{
+
+	t->t_cursor.tp_col = 0;
+	teken_subr_cursor_up(t, ncols);
+}
+
+static void
+teken_subr_cursor_up(teken_t *t, unsigned int nrows)
+{
+
+	if (t->t_scrollreg.ts_begin + nrows >= t->t_cursor.tp_row)
+		t->t_cursor.tp_row = t->t_scrollreg.ts_begin;
+	else
+		t->t_cursor.tp_row -= nrows;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_delete_character(teken_t *t, unsigned int ncols)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin.tp_row = t->t_cursor.tp_row;
+	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
+	tr.tr_end.tp_col = t->t_winsize.tp_col;
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col) {
+		tr.tr_begin.tp_col = t->t_cursor.tp_col;
+	} else {
+		/* Copy characters to the left. */
+		tr.tr_begin.tp_col = t->t_cursor.tp_col + ncols;
+		teken_funcs_copy(t, &tr, &t->t_cursor);
+
+		tr.tr_begin.tp_col = t->t_winsize.tp_col - ncols;
+	}
+
+	/* Blank trailing columns. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_delete_line(teken_t *t, unsigned int nrows)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin.tp_col = 0;
+	tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+	tr.tr_end.tp_col = t->t_winsize.tp_col;
+
+	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
+		tr.tr_begin.tp_row = t->t_cursor.tp_row;
+	} else {
+		teken_pos_t tp;
+
+		/* Copy rows up. */
+		tr.tr_begin.tp_row = t->t_cursor.tp_row + nrows;
+		tp.tp_row = t->t_cursor.tp_row;
+		tp.tp_col = 0;
+		teken_funcs_copy(t, &tr, &tp);
+
+		tr.tr_begin.tp_row = t->t_scrollreg.ts_end - nrows;
+	}
+
+	/* Blank trailing rows. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_device_control_string(teken_t *t __unused)
+{
+
+	teken_printf("device control string???\n");
+}
+
+static void
+teken_subr_device_status_report(teken_t *t, unsigned int cmd)
+{
+	char response[19] = "\x1B[?";
+	ssize_t len;
+
+	len = teken_subr_do_cpr(t, cmd, response + 3);
+	if (len < 0)
+		return;
+
+	teken_funcs_respond(t, response, len + 3);
+}
+
+static void
+teken_subr_double_height_double_width_line_top(teken_t *t __unused)
+{
+
+	teken_printf("double height double width top\n");
+}
+
+static void
+teken_subr_double_height_double_width_line_bottom(teken_t *t __unused)
+{
+
+	teken_printf("double height double width bottom\n");
+}
+
+static void
+teken_subr_erase_character(teken_t *t, unsigned int ncols)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin = t->t_cursor;
+	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col)
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+	else
+		tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
+
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_erase_display(teken_t *t, unsigned int mode)
+{
+	teken_rect_t r;
+
+	r.tr_begin.tp_col = 0;
+	r.tr_end.tp_col = t->t_winsize.tp_col;
+
+	switch (mode) {
+	case 1: /* Erase from the top to the cursor. */
+		teken_subr_erase_line(t, 1);
+
+		/* Erase lines above. */
+		if (t->t_cursor.tp_row == 0)
+			return;
+		r.tr_begin.tp_row = 0;
+		r.tr_end.tp_row = t->t_cursor.tp_row;
+		break;
+	case 2: /* Erase entire display. */
+		r.tr_begin.tp_row = 0;
+		r.tr_end.tp_row = t->t_winsize.tp_row;
+		break;
+	default: /* Erase from cursor to the bottom. */
+		teken_subr_erase_line(t, 0);
+
+		/* Erase lines below. */
+		if (t->t_cursor.tp_row == t->t_winsize.tp_row - 1)
+			return;
+		r.tr_begin.tp_row = t->t_cursor.tp_row + 1;
+		r.tr_end.tp_row = t->t_winsize.tp_row;
+		break;
+	}
+
+	teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_erase_line(teken_t *t, unsigned int mode)
+{
+	teken_rect_t r;
+
+	r.tr_begin.tp_row = t->t_cursor.tp_row;
+	r.tr_end.tp_row = t->t_cursor.tp_row + 1;
+
+	switch (mode) {
+	case 1: /* Erase from the beginning of the line to the cursor. */
+		r.tr_begin.tp_col = 0;
+		r.tr_end.tp_col = t->t_cursor.tp_col + 1;
+		break;
+	case 2: /* Erase entire line. */
+		r.tr_begin.tp_col = 0;
+		r.tr_end.tp_col = t->t_winsize.tp_col;
+		break;
+	default: /* Erase from cursor to the end of the line. */
+		r.tr_begin.tp_col = t->t_cursor.tp_col;
+		r.tr_end.tp_col = t->t_winsize.tp_col;
+		break;
+	}
+
+	teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_horizontal_position_absolute(teken_t *t, unsigned int col)
+{
+
+	t->t_cursor.tp_col = col - 1;
+	if (t->t_cursor.tp_col >= t->t_winsize.tp_col)
+		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_horizontal_tab(teken_t *t)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin = t->t_cursor;
+	teken_subr_cursor_forward_tabulation(t, 1);
+	tr.tr_end.tp_row = tr.tr_begin.tp_row + 1;
+	tr.tr_end.tp_col = t->t_cursor.tp_col;
+
+	/* Blank region that we skipped. */
+	if (tr.tr_end.tp_col > tr.tr_begin.tp_col)
+		teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_horizontal_tab_set(teken_t *t)
+{
+
+	teken_tab_set(t, t->t_cursor.tp_col);
+}
+
+static void
+teken_subr_index(teken_t *t)
+{
+
+	if (t->t_cursor.tp_row < t->t_scrollreg.ts_end - 1) {
+		t->t_cursor.tp_row++;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+	} else {
+		teken_subr_do_scroll(t, 1);
+	}
+}
+
+static void
+teken_subr_insert_character(teken_t *t, unsigned int ncols)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin = t->t_cursor;
+	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col) {
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+	} else {
+		teken_pos_t tp;
+
+		/* Copy characters to the right. */
+		tr.tr_end.tp_col = t->t_winsize.tp_col - ncols;
+		tp.tp_row = t->t_cursor.tp_row;
+		tp.tp_col = t->t_cursor.tp_col + ncols;
+		teken_funcs_copy(t, &tr, &tp);
+
+		tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
+	}
+
+	/* Blank current location. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_insert_line(teken_t *t, unsigned int nrows)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin.tp_row = t->t_cursor.tp_row;
+	tr.tr_begin.tp_col = 0;
+	tr.tr_end.tp_col = t->t_winsize.tp_col;
+
+	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
+		tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+	} else {
+		teken_pos_t tp;
+
+		/* Copy lines down. */
+		tr.tr_end.tp_row = t->t_scrollreg.ts_end - nrows;
+		tp.tp_row = t->t_cursor.tp_row + nrows;
+		tp.tp_col = 0;
+		teken_funcs_copy(t, &tr, &tp);
+
+		tr.tr_end.tp_row = t->t_cursor.tp_row + nrows;
+	}
+
+	/* Blank current location. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_keypad_application_mode(teken_t *t)
+{
+
+	teken_funcs_param(t, TP_KEYPADAPP, 1);
+}
+
+static void
+teken_subr_keypad_numeric_mode(teken_t *t)
+{
+
+	teken_funcs_param(t, TP_KEYPADAPP, 0);
+}
+
+static void
+teken_subr_newline(teken_t *t)
+{
+
+	t->t_cursor.tp_row++;
+
+	if (t->t_cursor.tp_row >= t->t_scrollreg.ts_end) {
+		teken_subr_do_scroll(t, 1);
+		t->t_cursor.tp_row = t->t_scrollreg.ts_end - 1;
+	}
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_next_line(teken_t *t)
+{
+
+	t->t_cursor.tp_col = 0;
+	teken_subr_newline(t);
+}
+
+static void
+teken_subr_pan_down(teken_t *t, unsigned int nrows)
+{
+
+	teken_subr_do_scroll(t, (int)nrows);
+}
+
+static void
+teken_subr_pan_up(teken_t *t, unsigned int nrows)
+{
+
+	teken_subr_do_scroll(t, -(int)nrows);
+}
+
+static void
+teken_subr_primary_device_attributes(teken_t *t, unsigned int request)
+{
+
+	if (request == 0) {
+		const char response[] = "\x1B[?1;2c";
+
+		teken_funcs_respond(t, response, sizeof response - 1);
+	} else {
+		teken_printf("Unknown DA1\n");
+	}
+}
+
+static void
+teken_subr_do_putchar(teken_t *t, const teken_pos_t *tp, teken_char_t c,
+    int width)
+{
+
+	if (t->t_stateflags & TS_INSERT &&
+	    tp->tp_col < t->t_winsize.tp_col - width) {
+		teken_rect_t ctr;
+		teken_pos_t ctp;
+
+		/* Insert mode. Move existing characters to the right. */
+		ctr.tr_begin = *tp;
+		ctr.tr_end.tp_row = tp->tp_row + 1;
+		ctr.tr_end.tp_col = t->t_winsize.tp_col - width;
+		ctp.tp_row = tp->tp_row;
+		ctp.tp_col = tp->tp_col + width;
+		teken_funcs_copy(t, &ctr, &ctp);
+	}
+
+	teken_funcs_putchar(t, tp, c, &t->t_curattr);
+}
+
+static void
+teken_subr_regular_character(teken_t *t, teken_char_t c)
+{
+	int width;
+
+	/* XXX: Don't process zero-width characters yet. */
+	width = teken_wcwidth(c);
+	if (width <= 0)
+		return;
+
+	if (t->t_cursor.tp_col == t->t_winsize.tp_col - 1 &&
+	    (t->t_stateflags & (TS_WRAPPED|TS_AUTOWRAP)) ==
+	    (TS_WRAPPED|TS_AUTOWRAP)) {
+		teken_pos_t tp;
+
+		/* Perform line wrapping. */
+
+		if (t->t_cursor.tp_row == t->t_scrollreg.ts_end - 1) {
+			/* Perform scrolling. */
+			teken_subr_do_scroll(t, 1);
+			tp.tp_row = t->t_scrollreg.ts_end - 1;
+		} else {
+			/* No scrolling needed. */
+			tp.tp_row = t->t_cursor.tp_row + 1;
+			if (tp.tp_row == t->t_winsize.tp_row) {
+				/*
+				 * Corner case: regular character
+				 * outside scrolling region, but at the
+				 * bottom of the screen.
+				 */
+				teken_subr_do_putchar(t, &t->t_cursor,
+				    c, width);
+				return;
+			}
+		}
+
+		tp.tp_col = 0;
+		teken_subr_do_putchar(t, &tp, c, width);
+
+		t->t_cursor.tp_row = tp.tp_row;
+		t->t_cursor.tp_col = width;
+		t->t_stateflags &= ~TS_WRAPPED;
+	} else {
+		/* No line wrapping needed. */
+		teken_subr_do_putchar(t, &t->t_cursor, c, width);
+		t->t_cursor.tp_col += width;
+
+		if (t->t_cursor.tp_col >= t->t_winsize.tp_col) {
+			t->t_stateflags |= TS_WRAPPED;
+			t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+		} else {
+			t->t_stateflags &= ~TS_WRAPPED;
+		}
+	}
+
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_reset_dec_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 1: /* Cursor keys mode. */
+		teken_funcs_param(t, TP_CURSORKEYS, 0);
+		break;
+	case 2: /* DECANM: ANSI/VT52 mode. */
+		teken_printf("DECRST VT52\n");
+		break;
+	case 3: /* 132 column mode. */
+		teken_funcs_param(t, TP_132COLS, 0);
+		teken_subr_reset_to_initial_state(t);
+		break;
+	case 5: /* Inverse video. */
+		teken_printf("DECRST inverse video\n");
+		break;
+	case 6: /* Origin mode. */
+		t->t_stateflags &= ~TS_ORIGIN;
+		t->t_originreg.ts_begin = 0;
+		t->t_originreg.ts_end = t->t_winsize.tp_row;
+		t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+		break;
+	case 7: /* Autowrap mode. */
+		t->t_stateflags &= ~TS_AUTOWRAP;
+		break;
+	case 8: /* Autorepeat mode. */
+		teken_funcs_param(t, TP_AUTOREPEAT, 0);
+		break;
+	case 25: /* Hide cursor. */
+		teken_funcs_param(t, TP_SHOWCURSOR, 0);
+		break;
+	case 40: /* Disallow 132 columns. */
+		teken_printf("DECRST allow 132\n");
+		break;
+	case 45: /* Disable reverse wraparound. */
+		teken_printf("DECRST reverse wraparound\n");
+		break;
+	case 47: /* Switch to alternate buffer. */
+		teken_printf("Switch to alternate buffer\n");
+		break;
+	default:
+		teken_printf("Unknown DECRST: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_reset_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 4:
+		t->t_stateflags &= ~TS_INSERT;
+		break;
+	default:
+		teken_printf("Unknown reset mode: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_do_reset(teken_t *t)
+{
+
+	t->t_curattr = t->t_saved_curattr = t->t_defattr;
+	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
+	t->t_saved_cursor = t->t_cursor;
+	t->t_stateflags = TS_AUTOWRAP;
+
+	teken_tab_default(t);
+}
+
+static void
+teken_subr_reset_to_initial_state(teken_t *t)
+{
+
+	teken_subr_do_reset(t);
+	teken_subr_erase_display(t, 2);
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_restore_cursor(teken_t *t)
+{
+
+	t->t_cursor = t->t_saved_cursor;
+	t->t_curattr = t->t_saved_curattr;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_reverse_index(teken_t *t)
+{
+
+	if (t->t_cursor.tp_row > t->t_scrollreg.ts_begin) {
+		t->t_cursor.tp_row--;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+	} else {
+		teken_subr_do_scroll(t, -1);
+	}
+}
+
+static void
+teken_subr_save_cursor(teken_t *t)
+{
+
+	t->t_saved_cursor = t->t_cursor;
+	t->t_saved_curattr = t->t_curattr;
+}
+
+static void
+teken_subr_scs(teken_t *t __unused)
+{
+
+	teken_printf("scs???\n");
+}
+
+static void
+teken_subr_secondary_device_attributes(teken_t *t, unsigned int request)
+{
+
+	if (request == 0) {
+		const char response[] = "\x1B[>0;10;0c";
+		teken_funcs_respond(t, response, sizeof response - 1);
+	} else {
+		teken_printf("Unknown DA2\n");
+	}
+}
+
+static void
+teken_subr_set_dec_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 1: /* Cursor keys mode. */
+		teken_funcs_param(t, TP_CURSORKEYS, 1);
+		break;
+	case 2: /* DECANM: ANSI/VT52 mode. */
+		teken_printf("DECSET VT52\n");
+		break;
+	case 3: /* 132 column mode. */
+		teken_funcs_param(t, TP_132COLS, 1);
+		teken_subr_reset_to_initial_state(t);
+		break;
+	case 5: /* Inverse video. */
+		teken_printf("DECSET inverse video\n");
+		break;
+	case 6: /* Origin mode. */
+		t->t_stateflags |= TS_ORIGIN;
+		t->t_originreg = t->t_scrollreg;
+		t->t_cursor.tp_row = t->t_scrollreg.ts_begin;
+		t->t_cursor.tp_col = 0;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+		break;
+	case 7: /* Autowrap mode. */
+		t->t_stateflags |= TS_AUTOWRAP;
+		break;
+	case 8: /* Autorepeat mode. */
+		teken_funcs_param(t, TP_AUTOREPEAT, 1);
+		break;
+	case 25: /* Display cursor. */
+		teken_funcs_param(t, TP_SHOWCURSOR, 1);
+		break;
+	case 40: /* Allow 132 columns. */
+		teken_printf("DECSET allow 132\n");
+		break;
+	case 45: /* Enable reverse wraparound. */
+		teken_printf("DECSET reverse wraparound\n");
+		break;
+	case 47: /* Switch to alternate buffer. */
+		teken_printf("Switch away from alternate buffer\n");
+		break;
+	default:
+		teken_printf("Unknown DECSET: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_set_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 4:
+		teken_printf("Insert mode\n");
+		t->t_stateflags |= TS_INSERT;
+		break;
+	default:
+		teken_printf("Unknown set mode: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_set_graphic_rendition(teken_t *t, unsigned int ncmds,
+    unsigned int cmds[])
+{
+	unsigned int i, n;
+
+	/* No attributes means reset. */
+	if (ncmds == 0) {
+		t->t_curattr = t->t_defattr;
+		return;
+	}
+
+	for (i = 0; i < ncmds; i++) {
+		n = cmds[i];
+
+		switch (n) {
+		case 0: /* Reset. */
+			t->t_curattr = t->t_defattr;
+			break;
+		case 1: /* Bold. */
+			t->t_curattr.ta_format |= TF_BOLD;
+			break;
+		case 4: /* Underline. */
+			t->t_curattr.ta_format |= TF_UNDERLINE;
+			break;
+		case 5: /* Blink. */
+			t->t_curattr.ta_format |= TF_BLINK;
+			break;
+		case 7: /* Reverse. */
+			t->t_curattr.ta_format |= TF_REVERSE;
+			break;
+		case 22: /* Remove bold. */
+			t->t_curattr.ta_format &= ~TF_BOLD;
+			break;
+		case 24: /* Remove underline. */
+			t->t_curattr.ta_format &= ~TF_UNDERLINE;
+			break;
+		case 25: /* Remove blink. */
+			t->t_curattr.ta_format &= ~TF_BLINK;
+			break;
+		case 27: /* Remove reverse. */
+			t->t_curattr.ta_format &= ~TF_REVERSE;
+			break;
+		case 30: /* Set foreground color: black */
+		case 31: /* Set foreground color: red */
+		case 32: /* Set foreground color: green */
+		case 33: /* Set foreground color: brown */
+		case 34: /* Set foreground color: blue */
+		case 35: /* Set foreground color: magenta */
+		case 36: /* Set foreground color: cyan */
+		case 37: /* Set foreground color: white */
+			t->t_curattr.ta_fgcolor = n - 30;
+			break;
+		case 39: /* Set default foreground color. */
+			t->t_curattr.ta_fgcolor = t->t_defattr.ta_fgcolor;
+			break;
+		case 40: /* Set background color: black */
+		case 41: /* Set background color: red */
+		case 42: /* Set background color: green */
+		case 43: /* Set background color: brown */
+		case 44: /* Set background color: blue */
+		case 45: /* Set background color: magenta */
+		case 46: /* Set background color: cyan */
+		case 47: /* Set background color: white */
+			t->t_curattr.ta_bgcolor = n - 40;
+			break;
+		case 49: /* Set default background color. */
+			t->t_curattr.ta_bgcolor = t->t_defattr.ta_bgcolor;
+			break;
+		default:
+			teken_printf("unsupported attribute %u\n", n);
+		}
+	}
+}
+
+static void
+teken_subr_set_top_and_bottom_margins(teken_t *t, unsigned int top,
+    unsigned int bottom)
+{
+
+	/* Adjust top row number. */
+	if (top > 0)
+		top--;
+	/* Adjust bottom row number. */
+	if (bottom == 0 || bottom > t->t_winsize.tp_row)
+		bottom = t->t_winsize.tp_row;
+
+	/* Invalid arguments. */
+	if (top >= bottom - 1) {
+		top = 0;
+		bottom = t->t_winsize.tp_row;
+	}
+
+	t->t_scrollreg.ts_begin = top;
+	t->t_scrollreg.ts_end = bottom;
+	if (t->t_stateflags & TS_ORIGIN) {
+		/* XXX: home cursor? */
+		t->t_originreg = t->t_scrollreg;
+		t->t_cursor.tp_row = t->t_originreg.ts_begin;
+		t->t_cursor.tp_col = 0;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+	}
+}
+
+static void
+teken_subr_single_height_double_width_line(teken_t *t __unused)
+{
+
+	teken_printf("single height double width???\n");
+}
+
+static void
+teken_subr_single_height_single_width_line(teken_t *t __unused)
+{
+
+	teken_printf("single height single width???\n");
+}
+
+static void
+teken_subr_string_terminator(teken_t *t __unused)
+{
+
+	teken_printf("string terminator???\n");
+}
+
+static void
+teken_subr_tab_clear(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 0:
+		teken_tab_clear(t, t->t_cursor.tp_col);
+		break;
+	case 3:
+		memset(&t->t_tabstops, 0, T_NUMCOL / 8);
+		break;
+	}
+}
+
+static void
+teken_subr_vertical_position_absolute(teken_t *t, unsigned int row)
+{
+
+	t->t_cursor.tp_row = t->t_originreg.ts_begin + row - 1;
+	if (row >= t->t_originreg.ts_end)
+		t->t_cursor.tp_row = t->t_originreg.ts_end - 1;
+
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
diff --git a/sys/dev/syscons/teken/teken_subr_compat.h b/sys/dev/syscons/teken/teken_subr_compat.h
new file mode 100644
index 0000000..5378bb0
--- /dev/null
+++ b/sys/dev/syscons/teken/teken_subr_compat.h
@@ -0,0 +1,51 @@
+/*-
+ * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
+ * 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 AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+static void
+teken_subr_cons25_set_cursor_type(teken_t *t, unsigned int type)
+{
+
+	teken_funcs_param(t, TP_SHOWCURSOR, type != 1);
+}
+
+static void
+teken_subr_cons25_switch_virtual_terminal(teken_t *t, unsigned int vt)
+{
+
+	teken_funcs_param(t, TP_SWITCHVT, vt);
+}
+
+#if 0
+static void
+teken_subr_vt52_decid(teken_t *t)
+{
+	const char response[] = "\x1B/Z";
+
+	teken_funcs_respond(t, response, sizeof response - 1);
+}
+#endif
diff --git a/sys/dev/syscons/teken/teken_wcwidth.h b/sys/dev/syscons/teken/teken_wcwidth.h
new file mode 100644
index 0000000..838fb3d
--- /dev/null
+++ b/sys/dev/syscons/teken/teken_wcwidth.h
@@ -0,0 +1,120 @@
+/*
+ * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
+ *
+ * Permission to use, copy, modify, and distribute this software
+ * for any purpose and without fee is hereby granted. The author
+ * disclaims all warranties with regard to this software.
+ *
+ * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+ *
+ * $FreeBSD$
+ */
+
+struct interval {
+  teken_char_t first;
+  teken_char_t last;
+};
+
+/* auxiliary function for binary search in interval table */
+static int bisearch(teken_char_t ucs, const struct interval *table, int max) {
+  int min = 0;
+  int mid;
+
+  if (ucs < table[0].first || ucs > table[max].last)
+    return 0;
+  while (max >= min) {
+    mid = (min + max) / 2;
+    if (ucs > table[mid].last)
+      min = mid + 1;
+    else if (ucs < table[mid].first)
+      max = mid - 1;
+    else
+      return 1;
+  }
+
+  return 0;
+}
+
+static int teken_wcwidth(teken_char_t ucs)
+{
+  /* sorted list of non-overlapping intervals of non-spacing characters */
+  /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
+  static const struct interval combining[] = {
+    { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },
+    { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
+    { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },
+    { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },
+    { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
+    { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },
+    { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },
+    { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },
+    { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },
+    { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },
+    { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },
+    { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },
+    { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },
+    { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },
+    { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
+    { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
+    { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
+    { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
+    { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },
+    { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },
+    { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
+    { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
+    { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
+    { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
+    { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
+    { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
+    { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
+    { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
+    { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
+    { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },
+    { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },
+    { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },
+    { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },
+    { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },
+    { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },
+    { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },
+    { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },
+    { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },
+    { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },
+    { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },
+    { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },
+    { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },
+    { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB },
+    { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F },
+    { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 },
+    { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD },
+    { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F },
+    { 0xE0100, 0xE01EF }
+  };
+
+  /* test for 8-bit control characters */
+  if (ucs == 0)
+    return 0;
+  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
+    return -1;
+
+  /* binary search in table of non-spacing characters */
+  if (bisearch(ucs, combining,
+	       sizeof(combining) / sizeof(struct interval) - 1))
+    return 0;
+
+  /* if we arrive here, ucs is not a combining or C0/C1 control character */
+
+  return 1 + 
+    (ucs >= 0x1100 &&
+     (ucs <= 0x115f ||                    /* Hangul Jamo init. consonants */
+      ucs == 0x2329 || ucs == 0x232a ||
+      (ucs >= 0x2e80 && ucs <= 0xa4cf &&
+       ucs != 0x303f) ||                  /* CJK ... Yi */
+      (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
+      (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
+      (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
+      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
+      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
+      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
+      (ucs >= 0x20000 && ucs <= 0x2fffd) ||
+      (ucs >= 0x30000 && ucs <= 0x3fffd)));
+}
diff --git a/sys/pc98/cbus/scterm-sck.c b/sys/pc98/cbus/scterm-sck.c
index ced4a92..2577f66 100644
--- a/sys/pc98/cbus/scterm-sck.c
+++ b/sys/pc98/cbus/scterm-sck.c
@@ -37,9 +37,7 @@
 #include <machine/pc/display.h>
 
 #include <dev/syscons/syscons.h>
-#include <dev/syscons/sctermvar.h>
-
-#ifndef SC_DUMB_TERMINAL
+#include <pc98/cbus/sctermvar.h>
 
 #define MAX_ESC_PAR	5
 
@@ -1212,5 +1210,3 @@ mask2attr(term_stat *tcp)
 
 	return (attr << 8);
 }
-
-#endif /* SC_DUMB_TERMINAL */
diff --git a/sys/dev/syscons/sctermvar.h b/sys/pc98/cbus/sctermvar.h
index b1c01af..b1c01af 100644
--- a/sys/dev/syscons/sctermvar.h
+++ b/sys/pc98/cbus/sctermvar.h