Next syscons update (given up on numbering :)

Removed screensavers from syscons, they are now LKM's. This makes it
possible to do some really "interesting" screensavers...
Fixed bug that sometimes caused garbage to appear when leaving
"scroll-lock" history.
Reformattet indentation, it got too deep for a normal 80 pos screen.
Split up in syscons.c & syscons.h for use with the saver-lkm's.
Temporarily removed -s option from vidcontrol, savers should now
be loaded with modload.

39 files changed, 9663 insertions, 8715 deletions

diff --git a/lkm/Makefile b/lkm/Makefile
index 3d98fa7..e6f2d66 100644
--- a/lkm/Makefile
+++ b/lkm/Makefile
@@ -1,7 +1,7 @@
-#	$Id: Makefile,v 1.6 1994/10/16 20:39:52 sos Exp $
+#	$Id: Makefile,v 1.7 1995/01/30 14:21:46 ugen Exp $
 
 SUBDIR=	cd9660 coff fdesc ibcs2 ip_mroute_mod ipfw kernfs msdos nfs nullfs \
-	portal procfs socksys umapfs union
+	portal procfs socksys syscons umapfs union
 #
 # Doesn't work:
 # mfs
diff --git a/lkm/syscons/Makefile b/lkm/syscons/Makefile
new file mode 100644
index 0000000..edd608e
--- /dev/null
+++ b/lkm/syscons/Makefile
@@ -0,0 +1,5 @@
+#	$Id$
+
+SUBDIR=	blank fade green snake star
+
+.include <bsd.subdir.mk>
diff --git a/lkm/syscons/blank/Makefile b/lkm/syscons/blank/Makefile
new file mode 100644
index 0000000..c920cf4
--- /dev/null
+++ b/lkm/syscons/blank/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	blank_saver_mod
+SRCS= 	blank_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/lkm/syscons/blank/blank_saver.c b/lkm/syscons/blank/blank_saver.c
new file mode 100644
index 0000000..9362c0b
--- /dev/null
+++ b/lkm/syscons/blank/blank_saver.c
@@ -0,0 +1,81 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("blank_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+blank_saver(int blank)
+{
+	u_char val;
+	if (blank) {
+		scrn_blanked = 1;
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+	}
+	else {
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
+		scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = blank_saver;
+	uprintf("blank screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("blank screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/lkm/syscons/fade/Makefile b/lkm/syscons/fade/Makefile
new file mode 100644
index 0000000..610a195
--- /dev/null
+++ b/lkm/syscons/fade/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	fade_saver_mod
+SRCS= 	fade_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/lkm/syscons/fade/fade_saver.c b/lkm/syscons/fade/fade_saver.c
new file mode 100644
index 0000000..a58eaa0
--- /dev/null
+++ b/lkm/syscons/fade/fade_saver.c
@@ -0,0 +1,96 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("fade_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+fade_saver(int blank)
+{
+	static int count = 0;
+	int i;
+
+	if (blank) {
+		scrn_blanked = 1;
+		if (count < 64) {
+			outb(PIXMASK, 0xFF);		/* no pixelmask */
+			outb(PALWADR, 0x00);
+			outb(PALDATA, 0);
+			outb(PALDATA, 0);
+			outb(PALDATA, 0);
+			for (i = 3; i < 768; i++) {
+				if (palette[i] - count > 15)
+					outb(PALDATA, palette[i]-count);
+				else
+					outb(PALDATA, 15);
+			}
+			inb(crtc_addr+6);		/* reset flip/flop */
+			outb(ATC, 0x20);		/* enable palette */
+			count++;
+		}
+	}
+	else {
+		load_palette();
+		count = scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = fade_saver;
+	uprintf("fade screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("fade screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/lkm/syscons/green/Makefile b/lkm/syscons/green/Makefile
new file mode 100644
index 0000000..9c1ae14
--- /dev/null
+++ b/lkm/syscons/green/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	green_saver_mod
+SRCS= 	green_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/lkm/syscons/green/green_saver.c b/lkm/syscons/green/green_saver.c
new file mode 100644
index 0000000..e6ed074
--- /dev/null
+++ b/lkm/syscons/green/green_saver.c
@@ -0,0 +1,85 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("green_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+green_saver(int blank)
+{
+	u_char val;
+	if (blank) {
+		scrn_blanked = 1;
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
+		outb(crtc_addr + 1, val & ~0x80);
+	}
+	else {
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
+		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
+		outb(crtc_addr + 1, val | 0x80);
+		scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = green_saver;
+	uprintf("green screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("green screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/lkm/syscons/saver.h b/lkm/syscons/saver.h
new file mode 100644
index 0000000..a51c72c
--- /dev/null
+++ b/lkm/syscons/saver.h
@@ -0,0 +1,16 @@
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/tty.h>
+#include <i386/include/pc/display.h>
+#include <i386/include/console.h>
+#include <i386/i386/cons.h>
+#include <i386/isa/isa.h>
+#include <i386/isa/isa_device.h>
+#include <i386/isa/syscons.h>
+
+extern scr_stat	*cur_console;
+extern u_short	*Crtat;
+extern u_int	crtc_addr;
+extern char	scr_map[];
+extern int	scrn_blanked;
+extern char	*palette;
diff --git a/lkm/syscons/snake/Makefile b/lkm/syscons/snake/Makefile
new file mode 100644
index 0000000..bc8b2b2
--- /dev/null
+++ b/lkm/syscons/snake/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	snake_saver_mod
+SRCS= 	snake_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/lkm/syscons/snake/snake_saver.c b/lkm/syscons/snake/snake_saver.c
new file mode 100644
index 0000000..1974980
--- /dev/null
+++ b/lkm/syscons/snake/snake_saver.c
@@ -0,0 +1,121 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("snake_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+snake_saver(int blank)
+{
+	const char	saves[] = {"FreeBSD-2.1"};
+	static u_char	*savs[sizeof(saves)-1];
+	static int	dirx, diry;
+	int		f;
+	scr_stat	*scp = cur_console;
+
+	if (blank) {
+		if (!scrn_blanked) {
+			fillw((FG_LIGHTGREY|BG_BLACK)<<8 | scr_map[0x20],
+			      Crtat, scp->xsize * scp->ysize);
+			set_border(0);
+			dirx = (scp->xpos ? 1 : -1);
+			diry = (scp->ypos ?
+				scp->xsize : -scp->xsize);
+			for (f=0; f< sizeof(saves)-1; f++)
+				savs[f] = (u_char *)Crtat + 2 *
+					  (scp->xpos+scp->ypos*scp->xsize);
+			*(savs[0]) = scr_map[*saves];
+			f = scp->ysize * scp->xsize + 5;
+			outb(crtc_addr, 14);
+			outb(crtc_addr+1, f >> 8);
+			outb(crtc_addr, 15);
+			outb(crtc_addr+1, f & 0xff);
+			scrn_blanked = 1;
+		}
+		if (scrn_blanked++ < 4) 
+			return;
+		scrn_blanked = 1;
+		*(savs[sizeof(saves)-2]) = scr_map[0x20];
+		for (f=sizeof(saves)-2; f > 0; f--)
+			savs[f] = savs[f-1];
+		f = (savs[0] - (u_char *)Crtat) / 2;
+		if ((f % scp->xsize) == 0 ||
+		    (f % scp->xsize) == scp->xsize - 1 ||
+		    (random() % 50) == 0)
+			dirx = -dirx;
+		if ((f / scp->xsize) == 0 ||
+		    (f / scp->xsize) == scp->ysize - 1 ||
+		    (random() % 20) == 0)
+			diry = -diry;
+		savs[0] += 2*dirx + 2*diry;
+		for (f=sizeof(saves)-2; f>=0; f--)
+			*(savs[f]) = scr_map[saves[f]];
+	}
+	else {
+		if (scrn_blanked) {
+			set_border(scp->border);
+			scrn_blanked = 0;
+			scp->status |= UPDATE_SCREEN;
+		}
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = snake_saver;
+	uprintf("snake screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("snake screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/lkm/syscons/star/Makefile b/lkm/syscons/star/Makefile
new file mode 100644
index 0000000..fc2ae17
--- /dev/null
+++ b/lkm/syscons/star/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	star_saver_mod
+SRCS= 	star_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/lkm/syscons/star/star_saver.c b/lkm/syscons/star/star_saver.c
new file mode 100644
index 0000000..f18dc09
--- /dev/null
+++ b/lkm/syscons/star/star_saver.c
@@ -0,0 +1,111 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("star_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+#define NUM_STARS	50
+
+/*
+ * Alternate saver that got its inspiration from a well known utility
+ * package for an inferior^H^H^H^H^H^Hfamous OS.
+ */
+void 
+star_saver(int blank)
+{
+	scr_stat	*scp = cur_console;
+	int		cell, i;
+	char 		pattern[] = {"...........++++***   "};
+	char		colors[] = {FG_DARKGREY, FG_LIGHTGREY, 
+				    FG_WHITE, FG_LIGHTCYAN};
+	static u_short 	stars[NUM_STARS][2];
+ 
+	if (blank) {
+		if (!scrn_blanked) {
+			scrn_blanked = 1;
+			fillw((FG_LIGHTGREY|BG_BLACK)<<8|scr_map[0x20], Crtat, 
+			      scp->xsize * scp->ysize);
+			set_border(0);
+			for(i=0; i<NUM_STARS; i++) {
+				stars[i][0] = 
+					random() % (scp->xsize*scp->ysize);
+				stars[i][1] = 0;
+			}
+		}
+		cell = random() % NUM_STARS;
+		*((u_short*)(Crtat + stars[cell][0])) = 
+			scr_map[pattern[stars[cell][1]]] | 
+				colors[random()%sizeof(colors)] << 8;
+		if ((stars[cell][1]+=(random()%4)) >= sizeof(pattern)-1) {
+			stars[cell][0] = random() % (scp->xsize*scp->ysize);
+			stars[cell][1] = 0;
+		}
+	}
+	else {
+		if (scrn_blanked) {
+			set_border(scp->border);
+			scrn_blanked = 0;
+			scp->status |= UPDATE_SCREEN;
+		}
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = star_saver;
+	uprintf("star screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("star screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/dev/syscons/blank/blank_saver.c b/sys/dev/syscons/blank/blank_saver.c
new file mode 100644
index 0000000..9362c0b
--- /dev/null
+++ b/sys/dev/syscons/blank/blank_saver.c
@@ -0,0 +1,81 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("blank_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+blank_saver(int blank)
+{
+	u_char val;
+	if (blank) {
+		scrn_blanked = 1;
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+	}
+	else {
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
+		scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = blank_saver;
+	uprintf("blank screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("blank screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/dev/syscons/fade/fade_saver.c b/sys/dev/syscons/fade/fade_saver.c
new file mode 100644
index 0000000..a58eaa0
--- /dev/null
+++ b/sys/dev/syscons/fade/fade_saver.c
@@ -0,0 +1,96 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("fade_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+fade_saver(int blank)
+{
+	static int count = 0;
+	int i;
+
+	if (blank) {
+		scrn_blanked = 1;
+		if (count < 64) {
+			outb(PIXMASK, 0xFF);		/* no pixelmask */
+			outb(PALWADR, 0x00);
+			outb(PALDATA, 0);
+			outb(PALDATA, 0);
+			outb(PALDATA, 0);
+			for (i = 3; i < 768; i++) {
+				if (palette[i] - count > 15)
+					outb(PALDATA, palette[i]-count);
+				else
+					outb(PALDATA, 15);
+			}
+			inb(crtc_addr+6);		/* reset flip/flop */
+			outb(ATC, 0x20);		/* enable palette */
+			count++;
+		}
+	}
+	else {
+		load_palette();
+		count = scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = fade_saver;
+	uprintf("fade screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("fade screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/dev/syscons/green/green_saver.c b/sys/dev/syscons/green/green_saver.c
new file mode 100644
index 0000000..e6ed074
--- /dev/null
+++ b/sys/dev/syscons/green/green_saver.c
@@ -0,0 +1,85 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("green_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+green_saver(int blank)
+{
+	u_char val;
+	if (blank) {
+		scrn_blanked = 1;
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
+		outb(crtc_addr + 1, val & ~0x80);
+	}
+	else {
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
+		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
+		outb(crtc_addr + 1, val | 0x80);
+		scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = green_saver;
+	uprintf("green screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("green screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/dev/syscons/snake/snake_saver.c b/sys/dev/syscons/snake/snake_saver.c
new file mode 100644
index 0000000..1974980
--- /dev/null
+++ b/sys/dev/syscons/snake/snake_saver.c
@@ -0,0 +1,121 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("snake_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+snake_saver(int blank)
+{
+	const char	saves[] = {"FreeBSD-2.1"};
+	static u_char	*savs[sizeof(saves)-1];
+	static int	dirx, diry;
+	int		f;
+	scr_stat	*scp = cur_console;
+
+	if (blank) {
+		if (!scrn_blanked) {
+			fillw((FG_LIGHTGREY|BG_BLACK)<<8 | scr_map[0x20],
+			      Crtat, scp->xsize * scp->ysize);
+			set_border(0);
+			dirx = (scp->xpos ? 1 : -1);
+			diry = (scp->ypos ?
+				scp->xsize : -scp->xsize);
+			for (f=0; f< sizeof(saves)-1; f++)
+				savs[f] = (u_char *)Crtat + 2 *
+					  (scp->xpos+scp->ypos*scp->xsize);
+			*(savs[0]) = scr_map[*saves];
+			f = scp->ysize * scp->xsize + 5;
+			outb(crtc_addr, 14);
+			outb(crtc_addr+1, f >> 8);
+			outb(crtc_addr, 15);
+			outb(crtc_addr+1, f & 0xff);
+			scrn_blanked = 1;
+		}
+		if (scrn_blanked++ < 4) 
+			return;
+		scrn_blanked = 1;
+		*(savs[sizeof(saves)-2]) = scr_map[0x20];
+		for (f=sizeof(saves)-2; f > 0; f--)
+			savs[f] = savs[f-1];
+		f = (savs[0] - (u_char *)Crtat) / 2;
+		if ((f % scp->xsize) == 0 ||
+		    (f % scp->xsize) == scp->xsize - 1 ||
+		    (random() % 50) == 0)
+			dirx = -dirx;
+		if ((f / scp->xsize) == 0 ||
+		    (f / scp->xsize) == scp->ysize - 1 ||
+		    (random() % 20) == 0)
+			diry = -diry;
+		savs[0] += 2*dirx + 2*diry;
+		for (f=sizeof(saves)-2; f>=0; f--)
+			*(savs[f]) = scr_map[saves[f]];
+	}
+	else {
+		if (scrn_blanked) {
+			set_border(scp->border);
+			scrn_blanked = 0;
+			scp->status |= UPDATE_SCREEN;
+		}
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = snake_saver;
+	uprintf("snake screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("snake screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/dev/syscons/star/star_saver.c b/sys/dev/syscons/star/star_saver.c
new file mode 100644
index 0000000..f18dc09
--- /dev/null
+++ b/sys/dev/syscons/star/star_saver.c
@@ -0,0 +1,111 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("star_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+#define NUM_STARS	50
+
+/*
+ * Alternate saver that got its inspiration from a well known utility
+ * package for an inferior^H^H^H^H^H^Hfamous OS.
+ */
+void 
+star_saver(int blank)
+{
+	scr_stat	*scp = cur_console;
+	int		cell, i;
+	char 		pattern[] = {"...........++++***   "};
+	char		colors[] = {FG_DARKGREY, FG_LIGHTGREY, 
+				    FG_WHITE, FG_LIGHTCYAN};
+	static u_short 	stars[NUM_STARS][2];
+ 
+	if (blank) {
+		if (!scrn_blanked) {
+			scrn_blanked = 1;
+			fillw((FG_LIGHTGREY|BG_BLACK)<<8|scr_map[0x20], Crtat, 
+			      scp->xsize * scp->ysize);
+			set_border(0);
+			for(i=0; i<NUM_STARS; i++) {
+				stars[i][0] = 
+					random() % (scp->xsize*scp->ysize);
+				stars[i][1] = 0;
+			}
+		}
+		cell = random() % NUM_STARS;
+		*((u_short*)(Crtat + stars[cell][0])) = 
+			scr_map[pattern[stars[cell][1]]] | 
+				colors[random()%sizeof(colors)] << 8;
+		if ((stars[cell][1]+=(random()%4)) >= sizeof(pattern)-1) {
+			stars[cell][0] = random() % (scp->xsize*scp->ysize);
+			stars[cell][1] = 0;
+		}
+	}
+	else {
+		if (scrn_blanked) {
+			set_border(scp->border);
+			scrn_blanked = 0;
+			scp->status |= UPDATE_SCREEN;
+		}
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = star_saver;
+	uprintf("star screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("star screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/dev/syscons/syscons.c b/sys/dev/syscons/syscons.c
index 102cc0e..1671125 100644
--- a/sys/dev/syscons/syscons.c
+++ b/sys/dev/syscons/syscons.c
@@ -1,47 +1,35 @@
 /*-
  * Copyright (c) 1992-1995 Søren Schmidt
- * Copyright (c) 1990 The Regents of the University of California.
  * All rights reserved.
  *
- * This code is derived from software contributed to Berkeley by
- * William Jolitz and Don Ahn.
- *
  * 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,
+ *    notice, this list of conditions and the following disclaimer 
  *    in this position and unchanged.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
  *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- *	$Id: syscons.c,v 1.102 1995/02/14 14:37:53 sos Exp $
+ *  $Id$
  */
 
 #include "sc.h"
-
 #if NSC > 0
-
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/conf.h>
@@ -68,6 +56,7 @@
 #include <i386/isa/timerreg.h>
 #include <i386/isa/kbdtables.h>
 #include <i386/i386/cons.h>
+#include <i386/isa/syscons.h>
 
 #if !defined(MAXCONS)
 #define MAXCONS 16
@@ -78,1484 +67,1109 @@
 #endif 
 
 /* this may break on older VGA's but is usefull on real 32 bit systems */
-#define	bcopyw	bcopy		
-
-/* vm things */
-#define	ISMAPPED(pa, width) \
-	(((pa) <= (u_long)0x1000 - (width)) \
-	 || ((pa) >= 0xa0000 && (pa) <= 0x100000 - (width)))
-#define	pa_to_va(pa)	(KERNBASE + (pa))	/* works if ISMAPPED(pa...) */
-
-/* printable chars */
-#define PRINTABLE(ch)	(ch>0x1B || (ch>0x0d && ch<0x1b) || ch<0x07)
-
-/* status flags */
-#define LOCK_KEY_MASK	0x0000F
-#define LED_MASK	0x00007
-#define UNKNOWN_MODE	0x00010
-#define KBD_RAW_MODE	0x00020
-#define SWITCH_WAIT_REL	0x00040
-#define SWITCH_WAIT_ACQ	0x00080
-#define BUFFER_SAVED	0x00100
-#define CURSOR_ENABLED 	0x00200
-#define CURSOR_SHOWN 	0x00400
-#define MOUSE_ENABLED	0x00800
-#define UPDATE_MOUSE	0x01000
-#define UPDATE_SCREEN	0x02000
-
-/* configuration flags */
-#define VISUAL_BELL	0x00001
-#define BLINK_CURSOR	0x00002
-#define CHAR_CURSOR	0x00004
-
-/* video hardware memory addresses */
-#define VIDEOMEM	0x000A0000
-
-/* misc defines */
-#define FALSE		0
-#define TRUE		1
-#define MAX_ESC_PAR 	5
-#define	LOAD		1
-#define SAVE		0
-#define	COL		80
-#define	ROW		25
-#define BELL_DURATION	5
-#define BELL_PITCH	800
-#define TIMER_FREQ	1193182			/* should be in isa.h */
-#define CONSOLE_BUFSIZE 1024
-#define PCBURST		128
-#define FONT_8		0x001
-#define FONT_14		0x002
-#define FONT_16		0x004
-#define HISTORY_SIZE	100*80
-
-/* defines related to hardware addresses */
-#define	MONO_BASE	0x3B4			/* crt controller base mono */
-#define	COLOR_BASE	0x3D4			/* crt controller base color */
-#define MISC		0x3C2			/* misc output register */
-#define ATC		IO_VGA+0x00		/* attribute controller */
-#define TSIDX		IO_VGA+0x04		/* timing sequencer idx */
-#define TSREG		IO_VGA+0x05		/* timing sequencer data */
-#define PIXMASK		IO_VGA+0x06		/* pixel write mask */
-#define PALRADR		IO_VGA+0x07		/* palette read address */
-#define PALWADR		IO_VGA+0x08		/* palette write address */
-#define PALDATA		IO_VGA+0x09		/* palette data register */
-#define GDCIDX		IO_VGA+0x0E		/* graph data controller idx */
-#define GDCREG		IO_VGA+0x0F		/* graph data controller data */
-
-/* special characters */
-#define cntlc	0x03	
-#define cntld	0x04
-#define bs	0x08
-#define lf	0x0a
-#define cr	0x0d	
-#define del	0x7f	
-
-typedef struct term_stat {
-	int 		esc;			/* processing escape sequence */
-	int 		num_param;		/* # of parameters to ESC */
-	int	 	last_param;		/* last parameter # */
-	int 		param[MAX_ESC_PAR];	/* contains ESC parameters */
-	int 		cur_attr;		/* current attributes */
-	int 		std_attr;		/* normal attributes */
-	int 		rev_attr;		/* reverse attributes */
-} term_stat;
-
-typedef struct scr_stat {
-	u_short 	*scr_buf;		/* buffer when off screen */
-	int 		xpos;			/* current X position */
-	int 		ypos;			/* current Y position */
-	int 		xsize;			/* X size */
-	int 		ysize;			/* Y size */
-	term_stat 	term;			/* terminal emulation stuff */
-	int	 	status;			/* status (bitfield) */
-	u_short 	*cursor_pos;		/* cursor buffer position */
-	u_short		cursor_saveunder;	/* saved chars under cursor */
-	char		cursor_start;		/* cursor start line # */
-	char		cursor_end;		/* cursor end line # */
-	u_short		*mouse_pos;		/* mouse buffer position */
-	u_short		*mouse_oldpos;		/* mouse old buffer position */
-	u_short		mouse_saveunder[4];	/* saved chars under mouse */
-	short		mouse_xpos;		/* mouse x coordinate */
-	short		mouse_ypos;		/* mouse y coordinate */
-	u_char		mouse_cursor[128];	/* mouse cursor bitmap store */
-	u_short		bell_duration;
-	u_short		bell_pitch;
-	u_char		border;			/* border color */
-	u_char	 	mode;			/* mode */
-	u_char		font;			/* font on this screen */
-	pid_t 		pid;			/* pid of controlling proc */
-	struct proc 	*proc;			/* proc* of controlling proc */
-	struct vt_mode 	smode;			/* switch mode */
-	u_short		*history;		/* circular history buffer */
-	u_short		*history_head;		/* current head position */
-	u_short		*history_pos;		/* position shown on screen */
-	u_short		*history_save;		/* save area index */
-	int		history_size;		/* size of history buffer */
-#if NAPM > 0
-	struct apmhook  r_hook;			/* reconfiguration support */
-#endif /* NAPM > 0 */
-} scr_stat;
-
-typedef struct default_attr {
-	int             std_attr;               /* normal attributes */
-	int 		rev_attr;		/* reverse attributes */
-} default_attr;
+#define bcopyw  bcopy       
 
 static default_attr user_default = {
-	(FG_LIGHTGREY | BG_BLACK) << 8,
-	(FG_BLACK | BG_LIGHTGREY) << 8
+    (FG_LIGHTGREY | BG_BLACK) << 8,
+    (FG_BLACK | BG_LIGHTGREY) << 8
 };
 
 static default_attr kernel_default = {
-	(FG_WHITE | BG_BLACK) << 8,
-	(FG_BLACK | BG_LIGHTGREY) << 8
+    (FG_WHITE | BG_BLACK) << 8,
+    (FG_BLACK | BG_LIGHTGREY) << 8
 };
 
-static	scr_stat	main_console;
-static	scr_stat	*console[MAXCONS];
-static	scr_stat	*cur_console;
-static	scr_stat	*new_scp, *old_scp;
-static	term_stat	kernel_console; 
-static	default_attr	*current_default;
-static 	char 		init_done = FALSE;
-static	char		switch_in_progress = FALSE;
-static	char		blink_in_progress = FALSE;
-static	char 		write_in_progress = FALSE;
-static	u_int		crtc_addr = MONO_BASE;
-static	char		crtc_vga = FALSE;
-static 	u_char		shfts = 0, ctls = 0, alts = 0, agrs = 0, metas = 0;
-static 	u_char		nlkcnt = 0, clkcnt = 0, slkcnt = 0, alkcnt = 0;
-static	char		*font_8 = NULL, *font_14 = NULL, *font_16 = NULL;
-static  int		fonts_loaded = 0;
-static	char		palette[3*256];
-static 	const u_int 	n_fkey_tab = sizeof(fkey_tab) / sizeof(*fkey_tab);
+static  scr_stat    	main_console;
+static  scr_stat    	*console[MAXCONS];
+	scr_stat    	*cur_console;
+static  scr_stat    	*new_scp, *old_scp;
+static  term_stat   	kernel_console; 
+static  default_attr    *current_default;
+static  char        	init_done = FALSE;
+static  char        	switch_in_progress = FALSE;
+static  char        	blink_in_progress = FALSE;
+static  char        	write_in_progress = FALSE;
+	u_int       	crtc_addr = MONO_BASE;
+static  char        	crtc_vga = FALSE;
+static  u_char      	shfts = 0, ctls = 0, alts = 0, agrs = 0, metas = 0;
+static  u_char      	nlkcnt = 0, clkcnt = 0, slkcnt = 0, alkcnt = 0;
+static  char        	*font_8 = NULL, *font_14 = NULL, *font_16 = NULL;
+static  int     	fonts_loaded = 0;
+	char        	palette[3*256];
+static  const u_int     n_fkey_tab = sizeof(fkey_tab) / sizeof(*fkey_tab);
 #if ASYNCH
-static  u_char		kbd_reply = 0;
+static  u_char      	kbd_reply = 0;
 #endif
-static	int	 	delayed_next_scr = FALSE;
-static	int		configuration = 0;	/* current setup */
-static	long		scrn_blank_time = 0;	/* screen saver timeout value */
-static	int		scrn_blanked = FALSE;	/* screen saver active flag */
-static	int		scrn_saver = 0;		/* screen saver routine */
-static	long 		scrn_time_stamp;
-static  u_char		scr_map[256];
-static	char 		*video_mode_ptr = NULL;
-static	u_short mouse_and_mask[16] = {	
-		0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
-		0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
-	};
-static	u_short mouse_or_mask[16] = {
-		0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
-		0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
-	};
-
-/* function prototypes */
-int scprobe(struct isa_device *dev);
-int scattach(struct isa_device *dev);
-int scopen(dev_t dev, int flag, int mode, struct proc *p);
-int scclose(dev_t dev, int flag, int mode, struct proc *p);
-int scread(dev_t dev, struct uio *uio, int flag);
-int scwrite(dev_t dev, struct uio *uio, int flag);
-int scparam(struct tty *tp, struct termios *t);
-int scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p);
-void scxint(dev_t dev);
-void scstart(struct tty *tp);
-void pccnprobe(struct consdev *cp);
-void pccninit(struct consdev *cp);
-void pccnputc(dev_t dev, char c);
-int pccngetc(dev_t dev);
-int pccncheckc(dev_t dev);
-void scintr(int unit);
-int pcmmap(dev_t dev, int offset, int nprot);
-static void scinit(void);
-static void scput(u_char c);
-static u_int scgetc(int noblock);
-static struct tty *get_tty_ptr(dev_t dev);
-static scr_stat *get_scr_stat(dev_t dev);
-static scr_stat *alloc_scp();
-static void init_scp(scr_stat *scp);
-static int get_scr_num();
-static void scrn_timer();
-static void clear_screen(scr_stat *scp);
-static int switch_scr(scr_stat *scp, u_int next_scr);
-static void exchange_scr(void);
-static inline void move_crsr(scr_stat *scp, int x, int y);
-static void scan_esc(scr_stat *scp, u_char c);
-static inline void draw_cursor(scr_stat *scp, int show);
-static void ansi_put(scr_stat *scp, u_char *buf, int len);
-static u_char *get_fstr(u_int c, u_int *len);
-static void update_leds(int which);
-static void history_to_screen(scr_stat *scp);
-static int history_up_line(scr_stat *scp);
-static int history_down_line(scr_stat *scp);
-static void kbd_wait(void);
-static void kbd_cmd(u_char command);
-static void set_mode(scr_stat *scp);
-static void set_border(int color);
-static void set_vgaregs(char *modetable);
-static void set_font_mode();
-static void set_normal_mode();
-static void copy_font(int operation, int font_type, char* font_image);
-static void draw_mouse_image(scr_stat *scp);
-static void save_palette(void);
-static void load_palette(void);
-static void do_bell(scr_stat *scp, int pitch, int duration);
-static void blink_screen(scr_stat *scp);
-
-/* available screen savers */
-static void none_saver(int blank);
-static void blank_saver(int blank);
-static void fade_saver(int blank);
-static void star_saver(int blank);
-static void snake_saver(int blank);
-static void green_saver(int blank);
-
-static const struct {
-	char	*name;
-	void	(*routine)();
-} screen_savers[] = {
-	{ "none",	none_saver },	/* 0 */
-	{ "blank",	blank_saver },	/* 1 */
-	{ "fade",	fade_saver },	/* 2 */
-	{ "star",	star_saver },	/* 3 */
-	{ "snake",	snake_saver },	/* 4 */
-	{ "green",	green_saver },	/* 5 */
+static  int     	delayed_next_scr = FALSE;
+static  int     	configuration = 0;  	/* current setup */
+static  long        	scrn_blank_time = 0;    /* screen saver timeout value */
+	int     	scrn_blanked = FALSE;   /* screen saver active flag */
+static  int     	scrn_saver = 0;    	/* screen saver routine */
+static  long       	scrn_time_stamp;
+	u_char      	scr_map[256];
+static  char        	*video_mode_ptr = NULL;
+
+static  u_short mouse_and_mask[16] = {  
+	0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
+	0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
 };
-#define SCRN_SAVER(arg)	(*screen_savers[scrn_saver].routine)(arg)
-#define NUM_SCRN_SAVERS	(sizeof(screen_savers) / sizeof(screen_savers[0]))
-#define WRAPHIST(scp, pointer, offset)\
-	((scp->history) + ((((pointer) - (scp->history)) + (scp->history_size)\
-	+ (offset)) % (scp->history_size)))
+static  u_short mouse_or_mask[16] = {
+	0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
+	0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
+};
+
+void    none_saver(int blank) { }
+void    (*current_saver)() = none_saver;
 
 /* OS specific stuff */
 #ifdef not_yet_done
-#define VIRTUAL_TTY(x)	(sccons[x] = ttymalloc(sccons[x]))
-struct	CONSOLE_TTY	(sccons[MAXCONS] = ttymalloc(sccons[MAXCONS]))
-struct	tty 		*sccons[MAXCONS+1];
+#define VIRTUAL_TTY(x)  (sccons[x] = ttymalloc(sccons[x]))
+struct  CONSOLE_TTY 	(sccons[MAXCONS] = ttymalloc(sccons[MAXCONS]))
+struct  tty         	*sccons[MAXCONS+1];
 #else
-#define VIRTUAL_TTY(x)	&sccons[x]
-#define CONSOLE_TTY	&sccons[MAXCONS]
-struct	tty 		sccons[MAXCONS+1];
+#define VIRTUAL_TTY(x)  &sccons[x]
+#define CONSOLE_TTY 	&sccons[MAXCONS]
+struct  tty         	sccons[MAXCONS+1];
 #endif
-#define	MONO_BUF	pa_to_va(0xB0000)
-#define	CGA_BUF		pa_to_va(0xB8000)
-u_short			*Crtat = (u_short *)MONO_BUF;
+#define MONO_BUF    	pa_to_va(0xB0000)
+#define CGA_BUF     	pa_to_va(0xB8000)
+u_short         	*Crtat = (u_short *)MONO_BUF;
+
+#define WRAPHIST(scp, pointer, offset)\
+    ((scp->history) + ((((pointer) - (scp->history)) + (scp->history_size)\
+    + (offset)) % (scp->history_size)))
 
-struct	isa_driver scdriver = {
-	scprobe, scattach, "sc", 1
+struct  isa_driver scdriver = {
+    scprobe, scattach, "sc", 1
 };
 
 int
 scprobe(struct isa_device *dev)
 {
-	int i, retries = 5;
-	unsigned char val;
+    int i, retries = 5;
+    unsigned char val;
+
+    /* Enable interrupts and keyboard controller */
+    kbd_wait();
+    outb(KB_STAT, KB_WRITE);
+    kbd_wait();
+    outb(KB_DATA, KB_MODE);
+
+    /* flush any noise in the buffer */
+    while (inb(KB_STAT) & KB_BUF_FULL) {
+	DELAY(10);
+	(void) inb(KB_DATA);
+    }
 
-	/* Enable interrupts and keyboard controller */
-	kbd_wait();
-	outb(KB_STAT, KB_WRITE);
+    /* Reset keyboard hardware */
+    while (retries--) {
 	kbd_wait();
-	outb(KB_DATA, KB_MODE);
-
-	/* flush any noise in the buffer */
-	while (inb(KB_STAT) & KB_BUF_FULL) {
-		DELAY(10);
-		(void) inb(KB_DATA);
-	}
-
-	/* Reset keyboard hardware */
-	while (retries--) {
-		kbd_wait();
-		outb(KB_DATA, KB_RESET);
-		for (i=0; i<100000; i++) {
-			DELAY(10);
-			val = inb(KB_DATA);
-			if (val == KB_ACK || val == KB_ECHO)
-				goto gotres;	
-			if (val == KB_RESEND)
-				break;
-		}
+	outb(KB_DATA, KB_RESET);
+	for (i=0; i<100000; i++) {
+	    DELAY(10);
+	    val = inb(KB_DATA);
+	    if (val == KB_ACK || val == KB_ECHO)
+		goto gotres;    
+	    if (val == KB_RESEND)
+		break;
 	}
+    }
 gotres:
-	if (!retries)
-		printf("scprobe: keyboard won't accept RESET command\n");
-	else {
+    if (!retries)
+	printf("scprobe: keyboard won't accept RESET command\n");
+    else {
 gotack:
-		DELAY(10);
-		while ((inb(KB_STAT) & KB_BUF_FULL) == 0) DELAY(10);
-		DELAY(10);
-		val = inb(KB_DATA);
-		if (val == KB_ACK)
-			goto gotack;
-		if (val != KB_RESET_DONE) 
-			printf("scprobe: keyboard RESET failed %02x\n", val);
-	}
+	DELAY(10);
+	while ((inb(KB_STAT) & KB_BUF_FULL) == 0) DELAY(10);
+	DELAY(10);
+	val = inb(KB_DATA);
+	if (val == KB_ACK)
+	    goto gotack;
+	if (val != KB_RESET_DONE) 
+	    printf("scprobe: keyboard RESET failed %02x\n", val);
+    }
 #ifdef XT_KEYBOARD
-	kbd_wait();
-	outb(KB_DATA, 0xF0);
-	kbd_wait();
-	outb(KB_DATA, 1)
-	kbd_wait();
+    kbd_wait();
+    outb(KB_DATA, 0xF0);
+    kbd_wait();
+    outb(KB_DATA, 1)
+    kbd_wait();
 #endif /* XT_KEYBOARD */
-	return (IO_KBDSIZE);
+    return (IO_KBDSIZE);
 }
 
-static struct kern_devconf kdc_sc[NSC] = { {
-	0, 0, 0,		/* filled in by dev_attach */
-	"sc", 0, { MDDT_ISA, 0, "tty" },
-	isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
-	&kdc_isa0,		/* parent */
-	0,			/* parentdata */
-	DC_BUSY,		/* the console is almost always busy */
-	"Graphics console"
-} };
+static struct kern_devconf kdc_sc[NSC] = {
+    0, 0, 0,        		/* filled in by dev_attach */
+    "sc", 0, { MDDT_ISA, 0, "tty" },
+    isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
+    &kdc_isa0,      		/* parent */
+    0,          		/* parentdata */
+    DC_BUSY,        		/* the console is almost always busy */
+    "Graphics console"
+};
 
 static inline void
 sc_registerdev(struct isa_device *id)
 {
-	if(id->id_unit)
-		kdc_sc[id->id_unit] = kdc_sc[0];
-	kdc_sc[id->id_unit].kdc_unit = id->id_unit;
-	kdc_sc[id->id_unit].kdc_isa = id;
-	dev_attach(&kdc_sc[id->id_unit]);
+    if(id->id_unit)
+	kdc_sc[id->id_unit] = kdc_sc[0];
+    kdc_sc[id->id_unit].kdc_unit = id->id_unit;
+    kdc_sc[id->id_unit].kdc_isa = id;
+    dev_attach(&kdc_sc[id->id_unit]);
 }
 
-#if NAPM > 0 
-/* ARGSUSED */
-static int 
-pcresume(void *dummy)
-{
-	shfts = 0;
-	ctls = 0;
-	alts = 0;
-	agrs = 0;
-	metas = 0;
-	return 0;
-}
-#endif /* NAPM > 0 */
-
-
 int
 scattach(struct isa_device *dev)
 {
-	scr_stat *scp;
+    scr_stat *scp;
 
-	scinit();
-	configuration = dev->id_flags;
-	printf("sc%d: ", dev->id_unit);
-	if (crtc_vga)
-		if (crtc_addr == MONO_BASE)
-			printf("VGA mono");
-		else	
-			printf("VGA color");
-	else
-		if (crtc_addr == MONO_BASE)
-			printf("MDA/hercules");
-		else	
-			printf("CGA/EGA");
-	printf(" <%d virtual consoles, flags=0x%x>\n", 
-			MAXCONS, configuration);
-	scp = console[0];
-	scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
-					 M_DEVBUF, M_NOWAIT);
-	/* copy screen to buffer */
-	bcopyw(Crtat, scp->scr_buf, scp->xsize * scp->ysize * sizeof(u_short));
-	scp->cursor_pos = scp->scr_buf + scp->xpos + scp->ypos * scp->xsize;
-	scp->mouse_pos = scp->scr_buf;
-
-	/* initialize history buffer & pointers */
-	scp->history_head = scp->history_pos = scp->history =
-		(u_short *)malloc(scp->history_size*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	bzero(scp->history_head, scp->history_size*sizeof(u_short));
-
-	if (crtc_vga) {
-		font_8 = (char *)malloc(8*256, M_DEVBUF, M_NOWAIT);
-		font_14 = (char *)malloc(14*256, M_DEVBUF, M_NOWAIT);
-		font_16 = (char *)malloc(16*256, M_DEVBUF, M_NOWAIT);
-		copy_font(SAVE, FONT_16, font_16);
-		fonts_loaded = FONT_16;
-		scp->font = FONT_16;
-		save_palette();
-	}
+    scinit();
+    configuration = dev->id_flags;
+    printf("sc%d: ", dev->id_unit);
+    if (crtc_vga)
+	if (crtc_addr == MONO_BASE)
+	    printf("VGA mono");
+	else    
+	    printf("VGA color");
+    else
+	if (crtc_addr == MONO_BASE)
+	    printf("MDA/hercules");
+	else    
+	    printf("CGA/EGA");
+    printf(" <%d virtual consoles, flags=0x%x>\n", MAXCONS, configuration);
+    scp = console[0];
+    scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+				     M_DEVBUF, M_NOWAIT);
+    /* copy screen to buffer */
+    bcopyw(Crtat, scp->scr_buf, scp->xsize * scp->ysize * sizeof(u_short));
+    scp->cursor_pos = scp->scr_buf + scp->xpos + scp->ypos * scp->xsize;
+    scp->mouse_pos = scp->scr_buf;
+
+    /* initialize history buffer & pointers */
+    scp->history_head = scp->history_pos = scp->history =
+	(u_short *)malloc(scp->history_size*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    bzero(scp->history_head, scp->history_size*sizeof(u_short));
+
+    if (crtc_vga) {
+	font_8 = (char *)malloc(8*256, M_DEVBUF, M_NOWAIT);
+	font_14 = (char *)malloc(14*256, M_DEVBUF, M_NOWAIT);
+	font_16 = (char *)malloc(16*256, M_DEVBUF, M_NOWAIT);
+	copy_font(SAVE, FONT_16, font_16);
+	fonts_loaded = FONT_16;
+	scp->font = FONT_16;
+	save_palette();
+    }
 
-	/* get screen update going */
-	scrn_timer();
+    /* get screen update going */
+    scrn_timer();
 
-	update_leds(scp->status);
-	sc_registerdev(dev);
+    update_leds(scp->status);
+    sc_registerdev(dev);
 #if NAPM > 0
-        scp->r_hook.ah_fun = pcresume;
-        scp->r_hook.ah_arg = NULL;
-        scp->r_hook.ah_name = "pccons keyboard";
-        scp->r_hook.ah_order = APM_MID_ORDER;
-        apm_hook_establish(APM_HOOK_RESUME , &scp->r_hook);
-#endif /* NAPM > 0*/
-	return 0;
+    scp->r_hook.ah_fun = pcresume;
+    scp->r_hook.ah_arg = NULL;
+    scp->r_hook.ah_name = "system keyboard";
+    scp->r_hook.ah_order = APM_MID_ORDER;
+    apm_hook_establish(APM_HOOK_RESUME , &scp->r_hook);
+#endif
+    return 0;
 }
 
 static struct tty 
 *get_tty_ptr(dev_t dev)
 {
-	int unit = minor(dev);
+    int unit = minor(dev);
 
-	if (unit > MAXCONS || unit < 0)
-		return(NULL);
-	if (unit == MAXCONS)
-		return CONSOLE_TTY;
-	return VIRTUAL_TTY(unit);
+    if (unit > MAXCONS || unit < 0)
+	return(NULL);
+    if (unit == MAXCONS)
+	return CONSOLE_TTY;
+    return VIRTUAL_TTY(unit);
 }
 
 static scr_stat 
 *get_scr_stat(dev_t dev)
 {
-	int unit = minor(dev);
+    int unit = minor(dev);
 
-	if (unit > MAXCONS || unit < 0)
-		return(NULL);
-	if (unit == MAXCONS)
-		return console[0];
-	return console[unit];
+    if (unit > MAXCONS || unit < 0)
+	return(NULL);
+    if (unit == MAXCONS)
+	return console[0];
+    return console[unit];
 }
 
 static int
 get_scr_num()
 {
-	int i = 0;
+    int i = 0;
 
-	while ((i < MAXCONS) && (cur_console != console[i])) i++;
-	return i < MAXCONS ? i : 0;
+    while ((i < MAXCONS) && (cur_console != console[i]))
+	i++;
+    return i < MAXCONS ? i : 0;
 }
 
 int 
 scopen(dev_t dev, int flag, int mode, struct proc *p)
 {
-	struct tty *tp = get_tty_ptr(dev);
-
-	if (!tp)
-		return(ENXIO);
-
-	tp->t_oproc = scstart;
-	tp->t_param = scparam;
-	tp->t_dev = dev;
-	if (!(tp->t_state & TS_ISOPEN)) {
-		ttychars(tp);
-		tp->t_iflag = TTYDEF_IFLAG;
-		tp->t_oflag = TTYDEF_OFLAG;
-		tp->t_cflag = TTYDEF_CFLAG;
-		tp->t_lflag = TTYDEF_LFLAG;
-		tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
-		scparam(tp, &tp->t_termios);
-		ttsetwater(tp);
-	} else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
-		return(EBUSY);
-	tp->t_state |= TS_CARR_ON;
-	tp->t_cflag |= CLOCAL;
-	if (!console[minor(dev)])
-		console[minor(dev)] = alloc_scp();
-	return((*linesw[tp->t_line].l_open)(dev, tp));
+    struct tty *tp = get_tty_ptr(dev);
+
+    if (!tp)
+	return(ENXIO);
+
+    tp->t_oproc = scstart;
+    tp->t_param = scparam;
+    tp->t_dev = dev;
+    if (!(tp->t_state & TS_ISOPEN)) {
+	ttychars(tp);
+	tp->t_iflag = TTYDEF_IFLAG;
+	tp->t_oflag = TTYDEF_OFLAG;
+	tp->t_cflag = TTYDEF_CFLAG;
+	tp->t_lflag = TTYDEF_LFLAG;
+	tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
+	scparam(tp, &tp->t_termios);
+	ttsetwater(tp);
+    } 
+    else 
+	if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
+	    return(EBUSY);
+    tp->t_state |= TS_CARR_ON;
+    tp->t_cflag |= CLOCAL;
+    if (!console[minor(dev)])
+	console[minor(dev)] = alloc_scp();
+    return((*linesw[tp->t_line].l_open)(dev, tp));
 }
 
 int 
 scclose(dev_t dev, int flag, int mode, struct proc *p)
 {
-	struct tty *tp = get_tty_ptr(dev);
-	struct scr_stat *scp;
-
-	if (!tp)
-		return(ENXIO);
-	if (minor(dev) < MAXCONS) {
-		scp = get_scr_stat(tp->t_dev);
-		if (scp->status & SWITCH_WAIT_ACQ)
-			wakeup((caddr_t)&scp->smode);
+    struct tty *tp = get_tty_ptr(dev);
+    struct scr_stat *scp;
+
+    if (!tp)
+	return(ENXIO);
+    if (minor(dev) < MAXCONS) {
+	scp = get_scr_stat(tp->t_dev);
+	if (scp->status & SWITCH_WAIT_ACQ)
+	    wakeup((caddr_t)&scp->smode);
 #if not_yet_done
-		if (scp == &main_console) {
-			scp->pid = 0;
-			scp->proc = NULL;
-			scp->smode.mode = VT_AUTO;
-		}
-		else {
-			free(scp->scr_buf, M_DEVBUF); 
-			free(scp->history, M_DEVBUF); 
-			free(scp, M_DEVBUF);
-			console[minor(dev)] = NULL;
-		}
+	if (scp == &main_console) {
+	    scp->pid = 0;
+	    scp->proc = NULL;
+	    scp->smode.mode = VT_AUTO;
+	}
+	else {
+	    free(scp->scr_buf, M_DEVBUF); 
+	    free(scp->history, M_DEVBUF); 
+	    free(scp, M_DEVBUF);
+	    console[minor(dev)] = NULL;
+	}
 #else
-		scp->pid = 0;
-		scp->proc = NULL;
-		scp->smode.mode = VT_AUTO;
+	scp->pid = 0;
+	scp->proc = NULL;
+	scp->smode.mode = VT_AUTO;
 #endif
-	}
-	(*linesw[tp->t_line].l_close)(tp, flag);
-	ttyclose(tp); 
-	return(0);
+    }
+    (*linesw[tp->t_line].l_close)(tp, flag);
+    ttyclose(tp); 
+    return(0);
 }
 
 int 
 scread(dev_t dev, struct uio *uio, int flag)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return(ENXIO);
-	return((*linesw[tp->t_line].l_read)(tp, uio, flag));
+    if (!tp)
+	return(ENXIO);
+    return((*linesw[tp->t_line].l_read)(tp, uio, flag));
 }
 
 int 
 scwrite(dev_t dev, struct uio *uio, int flag)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return(ENXIO);
-	return((*linesw[tp->t_line].l_write)(tp, uio, flag));
+    if (!tp)
+	return(ENXIO);
+    return((*linesw[tp->t_line].l_write)(tp, uio, flag));
 }
 
 void 
 scintr(int unit)
 {
-	static struct tty *cur_tty;
-	int c, len;
-	u_char *cp;
-
-	/* make screensaver happy */
-	scrn_time_stamp = time.tv_sec;
-	if (scrn_blanked) {
-		SCRN_SAVER(FALSE);
-		cur_console->status |= UPDATE_SCREEN;
-	}
-
-	c = scgetc(1);
-
-	cur_tty = VIRTUAL_TTY(get_scr_num());
-	if (!(cur_tty->t_state & TS_ISOPEN))
-		if (!((cur_tty = CONSOLE_TTY)->t_state & TS_ISOPEN))
-			return;
+    static struct tty *cur_tty;
+    int c, len;
+    u_char *cp;
+
+    /* make screensaver happy */
+    scrn_time_stamp = time.tv_sec;
+    if (scrn_blanked) {
+	(*current_saver)(FALSE);
+	cur_console->status |= UPDATE_SCREEN;
+    }
 
-	switch (c & 0xff00) {
-	case 0x0000: /* normal key */
-		(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
-		break;
-	case NOKEY:	/* nothing there */
-		break;
-	case FKEY:	/* function key, return string */
-		if (cp = get_fstr((u_int)c, (u_int *)&len)) {
-			while (len-- >  0)
-				(*linesw[cur_tty->t_line].l_rint)
-					(*cp++ & 0xFF, cur_tty);
-		}
-		break;
-	case MKEY:	/* meta is active, prepend ESC */
-		(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
-		break;
-	case BKEY:	/* backtab fixed sequence (esc [ Z) */
-		(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
-		break;
-	}	
+    c = scgetc(1);
+
+    cur_tty = VIRTUAL_TTY(get_scr_num());
+    if (!(cur_tty->t_state & TS_ISOPEN))
+	if (!((cur_tty = CONSOLE_TTY)->t_state & TS_ISOPEN))
+	    return;
+
+    switch (c & 0xff00) {
+    case 0x0000: /* normal key */
+	(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
+	break;
+    case NOKEY: /* nothing there */
+	break;
+    case FKEY:  /* function key, return string */
+	if (cp = get_fstr((u_int)c, (u_int *)&len)) {
+	    while (len-- >  0)
+		(*linesw[cur_tty->t_line].l_rint)(*cp++ & 0xFF, cur_tty);
+	}
+	break;
+    case MKEY:  /* meta is active, prepend ESC */
+	(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
+	break;
+    case BKEY:  /* backtab fixed sequence (esc [ Z) */
+	(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
+	break;
+    }   
 }
 
 int 
 scparam(struct tty *tp, struct termios *t)
 {
-	int cflag = t->c_cflag;
-
-	/* and copy to tty */
-	tp->t_ispeed = t->c_ispeed;
-	tp->t_ospeed = t->c_ospeed;
-	tp->t_cflag = cflag;
-	return 0;
+    tp->t_ispeed = t->c_ispeed;
+    tp->t_ospeed = t->c_ospeed;
+    tp->t_cflag = t->c_cflag;
+    return 0;
 }
 
 int 
 scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 {
-	int i, error;
-	struct tty *tp;
-	struct trapframe *fp;
-	scr_stat *scp; 
-
-	tp = get_tty_ptr(dev);
-	if (!tp)
-		return ENXIO;
-	scp = get_scr_stat(tp->t_dev);
+    int i, error;
+    struct tty *tp;
+    struct trapframe *fp;
+    scr_stat *scp; 
 
-	switch (cmd) {	/* process console hardware related ioctl's */
+    tp = get_tty_ptr(dev);
+    if (!tp)
+	return ENXIO;
+    scp = get_scr_stat(tp->t_dev);
 
-	case GIO_ATTR:		/* get current attributes */
-		*(int*)data = scp->term.cur_attr;
-		return 0;
+    switch (cmd) {  		/* process console hardware related ioctl's */
 
-	case GIO_COLOR:		/* is this a color console ? */
-		if (crtc_addr == COLOR_BASE)
-			*(int*)data = 1;
-		else
-			*(int*)data = 0;
-		return 0;
-			
-	case CONS_CURRENT:	/* get current adapter type */
-		if (crtc_vga)
-			*(int*)data = KD_VGA;
-		else
-			if (crtc_addr == MONO_BASE)
-				*(int*)data = KD_MONO;
-			else	
-				*(int*)data = KD_CGA;
-		return 0;
+    case GIO_ATTR:      	/* get current attributes */
+	*(int*)data = scp->term.cur_attr;
+	return 0;
 
-	case CONS_GET:		/* get current video mode */
-		*(int*)data = scp->mode;
-		return 0;
+    case GIO_COLOR:     	/* is this a color console ? */
+	if (crtc_addr == COLOR_BASE)
+	    *(int*)data = 1;
+	else
+	    *(int*)data = 0;
+	return 0;
+	    
+    case CONS_CURRENT:  	/* get current adapter type */
+	if (crtc_vga)
+	    *(int*)data = KD_VGA;
+	else
+	    if (crtc_addr == MONO_BASE)
+		*(int*)data = KD_MONO;
+	    else    
+		*(int*)data = KD_CGA;
+	return 0;
 
-	case CONS_BLANKTIME:	/* set screen saver timeout (0 = no saver) */
-		scrn_blank_time = *(int*)data;
-		return 0;
+    case CONS_GET:      	/* get current video mode */
+	*(int*)data = scp->mode;
+	return 0;
 
-#define	SAVER(p) ((ssaver_t *)(p))
-	case CONS_SSAVER:	/* set screen saver */
-		if (SAVER(data)->num < 0 
-		    || SAVER(data)->num >= NUM_SCRN_SAVERS)
-			return EIO;
-		if (scrn_blanked) {
-			SCRN_SAVER(FALSE);
-			cur_console->status |= UPDATE_SCREEN;
-		}
-		scrn_saver = SAVER(data)->num;
-		scrn_blank_time = SAVER(data)->time;
-		return 0;
+    case CONS_BLANKTIME:    	/* set screen saver timeout (0 = no saver) */
+	scrn_blank_time = *(int*)data;
+	return 0;
 
-	case CONS_GSAVER:	/* get screen saver info */
-		if (SAVER(data)->num < 0)
-			SAVER(data)->num = scrn_saver;
-		else if (SAVER(data)->num >= NUM_SCRN_SAVERS)
-			return EIO;
-		SAVER(data)->time = scrn_blank_time;
-		strcpy(SAVER(data)->name, screen_savers[SAVER(data)->num].name);
-		return 0;
+    case CONS_CURSORTYPE:   	/* set cursor type blink/noblink */
+	if ((*(int*)data) & 0x01)
+	    configuration |= BLINK_CURSOR;
+	else
+	    configuration &= ~BLINK_CURSOR;
+	if ((*(int*)data) & 0x02)
+	    configuration |= CHAR_CURSOR;
+	else
+	    configuration &= ~CHAR_CURSOR;
+	return 0;
 
-	case CONS_CURSORTYPE:	/* set cursor type blink/noblink */
-		if ((*(int*)data) & 0x01)
-			configuration |= BLINK_CURSOR;
-		else
-			configuration &= ~BLINK_CURSOR;
-		if ((*(int*)data) & 0x02)
-			configuration |= CHAR_CURSOR;
-		else
-			configuration &= ~CHAR_CURSOR;
-		return 0;
+    case CONS_BELLTYPE: 	/* set bell type sound/visual */
+	if (*data)
+	    configuration |= VISUAL_BELL;
+	else
+	    configuration &= ~VISUAL_BELL;
+	return 0;
 
-	case CONS_BELLTYPE:	/* set bell type sound/visual */
-		if (*data)
-			configuration |= VISUAL_BELL;
-		else
-			configuration &= ~VISUAL_BELL;
-		return 0;
+    case CONS_HISTORY:  	/* set history size */
+	if (*data) {
+	    free(scp->history, M_DEVBUF); 
+	    scp->history_size = *(int*)data;
+	    if (scp->history_size < scp->ysize)
+		scp->history = NULL;
+	    else {
+		scp->history_size *= scp->xsize;
+		scp->history_head = scp->history_pos = scp->history =
+		    (u_short *)malloc(scp->history_size*sizeof(u_short),
+				      M_DEVBUF, M_NOWAIT);
+		bzero(scp->history_head, scp->history_size*sizeof(u_short));
+	    }
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case CONS_HISTORY:	/* set history size */
-		if (*data) {
-		    free(scp->history, M_DEVBUF); 
-		    scp->history_size = *(int*)data;
-		    if (scp->history_size < scp->ysize)
-			scp->history = NULL;
-		    else {
-			scp->history_size *= scp->xsize;
-			scp->history_head = scp->history_pos = scp->history =
-			    (u_short *)malloc(scp->history_size*sizeof(u_short),
-					      M_DEVBUF, M_NOWAIT);
-			bzero(scp->history_head, 
-			      scp->history_size*sizeof(u_short));
-		    }
-		    return 0;
-		}
-		else
-			return EINVAL;
-
-	case CONS_MOUSECTL:
-	{
-		mouse_info_t *mouse = (mouse_info_t*)data;
-		int fontsize;
-
-		switch (scp->font) {
-		default:
-		case FONT_8:
-			fontsize = 8; break;
-		case FONT_14:
-			fontsize = 14; break;
-		case FONT_16:
-			fontsize = 16; break;
-		}
-		switch (mouse->operation) {
-		case MOUSE_SHOW:
-			if (!(scp->status & MOUSE_ENABLED)) {
-				scp->mouse_oldpos = 
-					Crtat + (scp->mouse_pos - scp->scr_buf);
-				scp->status |= (UPDATE_MOUSE | MOUSE_ENABLED);
-			}
-			else
-				return EINVAL;
-			break;
-
-		case MOUSE_HIDE:
-			if (scp->status & MOUSE_ENABLED) {
-				scp->status &= ~MOUSE_ENABLED;
-				scp->status |= UPDATE_MOUSE;
-			}
-			else
-				return EINVAL;
-			break;
-
-		case MOUSE_MOVEABS:
-			scp->mouse_xpos = mouse->x;
-			scp->mouse_ypos = mouse->y;
-			goto set_mouse_pos;
-
-		case MOUSE_MOVEREL:
-			scp->mouse_xpos += mouse->x;
-			scp->mouse_ypos += mouse->y;
+    case CONS_MOUSECTL:		/* control mouse arrow */
+    {
+	mouse_info_t *mouse = (mouse_info_t*)data;
+	int fontsize;
+
+	switch (scp->font) {
+	default:
+	case FONT_8:
+	    fontsize = 8; break;
+	case FONT_14:
+	    fontsize = 14; break;
+	case FONT_16:
+	    fontsize = 16; break;
+	}
+	switch (mouse->operation) {
+	case MOUSE_SHOW:
+	    if (!(scp->status & MOUSE_ENABLED)) {
+		scp->mouse_oldpos = Crtat + (scp->mouse_pos - scp->scr_buf);
+		scp->status |= (UPDATE_MOUSE | MOUSE_ENABLED);
+	    }
+	    else
+		return EINVAL;
+	    break;
+
+	case MOUSE_HIDE:
+	    if (scp->status & MOUSE_ENABLED) {
+		scp->status &= ~MOUSE_ENABLED;
+		scp->status |= UPDATE_MOUSE;
+	    }
+	    else
+		return EINVAL;
+	    break;
+
+	case MOUSE_MOVEABS:
+	    scp->mouse_xpos = mouse->x;
+	    scp->mouse_ypos = mouse->y;
+	    goto set_mouse_pos;
+
+	case MOUSE_MOVEREL:
+	    scp->mouse_xpos += mouse->x;
+	    scp->mouse_ypos += mouse->y;
 set_mouse_pos:
-			if (scp->mouse_xpos < 0)
-				scp->mouse_xpos = 0;
-			if (scp->mouse_ypos < 0)
-				scp->mouse_ypos = 0;
-			if (scp->mouse_xpos >= scp->xsize*8)
-				scp->mouse_xpos = (scp->xsize*8)-1;
-			if (scp->mouse_ypos >= scp->ysize*fontsize)
-				scp->mouse_ypos = (scp->ysize*fontsize)-1;
-			scp->mouse_pos = scp->scr_buf + 
-				(scp->mouse_ypos/fontsize)*scp->xsize + 
-				scp->mouse_xpos/8;
-			if (scp->status & MOUSE_ENABLED)
-				scp->status |= UPDATE_MOUSE;
-			break;
-
-		case MOUSE_GETPOS:
-			mouse->x = scp->mouse_xpos;
-			mouse->y = scp->mouse_ypos;
-			return 0;
-
-		default:
-			return EINVAL;
-		}
-		/* make screensaver happy */
-		if (scp == cur_console) {
-			scrn_time_stamp = time.tv_sec;
-			if (scrn_blanked) {
-				SCRN_SAVER(FALSE);
-				scp->status |= UPDATE_SCREEN;
-			}
-		}
-		return 0;
+	    if (scp->mouse_xpos < 0)
+		scp->mouse_xpos = 0;
+	    if (scp->mouse_ypos < 0)
+		scp->mouse_ypos = 0;
+	    if (scp->mouse_xpos >= scp->xsize*8)
+		scp->mouse_xpos = (scp->xsize*8)-1;
+	    if (scp->mouse_ypos >= scp->ysize*fontsize)
+		scp->mouse_ypos = (scp->ysize*fontsize)-1;
+	    scp->mouse_pos = scp->scr_buf + 
+		(scp->mouse_ypos/fontsize)*scp->xsize + scp->mouse_xpos/8;
+	    if (scp->status & MOUSE_ENABLED)
+		scp->status |= UPDATE_MOUSE;
+	    break;
+
+	case MOUSE_GETPOS:
+	    mouse->x = scp->mouse_xpos;
+	    mouse->y = scp->mouse_ypos;
+	    return 0;
+
+	default:
+	    return EINVAL;
+	}
+	/* make screensaver happy */
+	if (scp == cur_console) {
+	    scrn_time_stamp = time.tv_sec;
+	    if (scrn_blanked) {
+		(*current_saver)(FALSE);
+		scp->status |= UPDATE_SCREEN;
+	    }
 	}
+	return 0;
+    }
 
-	case CONS_GETINFO:	/* get current (virtual) console info */
-	{
-		vid_info_t *ptr = (vid_info_t*)data;
-		if (ptr->size == sizeof(struct vid_info)) {
-			ptr->m_num = get_scr_num();
-			ptr->mv_col = scp->xpos;
-			ptr->mv_row = scp->ypos;
-			ptr->mv_csz = scp->xsize;
-			ptr->mv_rsz = scp->ysize;
-			ptr->mv_norm.fore = (scp->term.std_attr & 0x0f00)>>8;
-			ptr->mv_norm.back = (scp->term.std_attr & 0xf000)>>12;
-			ptr->mv_rev.fore = (scp->term.rev_attr & 0x0f00)>>8;
-			ptr->mv_rev.back = (scp->term.rev_attr & 0xf000)>>12;
-			ptr->mv_grfc.fore = 0;		/* not supported */
-			ptr->mv_grfc.back = 0;		/* not supported */
-			ptr->mv_ovscan = scp->border;
-			ptr->mk_keylock = scp->status & LOCK_KEY_MASK;
-			return 0;
-		}
+    case CONS_GETINFO:  	/* get current (virtual) console info */
+    {
+	vid_info_t *ptr = (vid_info_t*)data;
+	if (ptr->size == sizeof(struct vid_info)) {
+	    ptr->m_num = get_scr_num();
+	    ptr->mv_col = scp->xpos;
+	    ptr->mv_row = scp->ypos;
+	    ptr->mv_csz = scp->xsize;
+	    ptr->mv_rsz = scp->ysize;
+	    ptr->mv_norm.fore = (scp->term.std_attr & 0x0f00)>>8;
+	    ptr->mv_norm.back = (scp->term.std_attr & 0xf000)>>12;
+	    ptr->mv_rev.fore = (scp->term.rev_attr & 0x0f00)>>8;
+	    ptr->mv_rev.back = (scp->term.rev_attr & 0xf000)>>12;
+	    ptr->mv_grfc.fore = 0;      /* not supported */
+	    ptr->mv_grfc.back = 0;      /* not supported */
+	    ptr->mv_ovscan = scp->border;
+	    ptr->mk_keylock = scp->status & LOCK_KEY_MASK;
+	    return 0;
+	}
+	return EINVAL;
+    }
+
+    case CONS_GETVERS:  	/* get version number */
+	*(int*)data = 0x200;    /* version 2.0 */
+	return 0;
+
+    /* VGA TEXT MODES */
+    case SW_VGA_C40x25:
+    case SW_VGA_C80x25: case SW_VGA_M80x25:
+    case SW_VGA_C80x30: case SW_VGA_M80x30:
+    case SW_VGA_C80x50: case SW_VGA_M80x50:
+    case SW_VGA_C80x60: case SW_VGA_M80x60:
+    case SW_B40x25:     case SW_C40x25:
+    case SW_B80x25:     case SW_C80x25:
+    case SW_ENH_B40x25: case SW_ENH_C40x25: 
+    case SW_ENH_B80x25: case SW_ENH_C80x25:
+    case SW_ENH_B80x43: case SW_ENH_C80x43:
+
+	if (!crtc_vga || video_mode_ptr == NULL)
+	    return ENXIO;
+	switch (cmd & 0xff) {
+	case M_VGA_C80x60: case M_VGA_M80x60:
+	    if (!(fonts_loaded & FONT_8))
+		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 60;
+	    break;
+	case M_VGA_C80x50: case M_VGA_M80x50:
+	    if (!(fonts_loaded & FONT_8))
+		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 50;
+	    break;
+	case M_ENH_B80x43: case M_ENH_C80x43:
+	    if (!(fonts_loaded & FONT_8))
 		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 43;
+	    break;
+	case M_VGA_C80x30: case M_VGA_M80x30:
+	    scp->xsize = 80;
+	    scp->ysize = 30;
+	    break;
+	default:
+	    if ((cmd & 0xff) > M_VGA_CG320)
+		return EINVAL;
+	    else 
+		scp->xsize = *(video_mode_ptr+((cmd&0xff)*64));
+		scp->ysize = *(video_mode_ptr+((cmd&0xff)*64)+1)+1;
+	    break;
+	}
+	scp->mode = cmd & 0xff;
+	scp->status &= ~UNKNOWN_MODE;   /* text mode */
+	free(scp->scr_buf, M_DEVBUF); 
+	scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+					 M_DEVBUF, M_NOWAIT);
+	if (scp == cur_console)
+	    set_mode(scp);
+	clear_screen(scp);
+	if (tp->t_winsize.ws_col != scp->xsize 
+	    || tp->t_winsize.ws_row != scp->ysize) {
+	    tp->t_winsize.ws_col = scp->xsize;
+	    tp->t_winsize.ws_row = scp->ysize;
+	    pgsignal(tp->t_pgrp, SIGWINCH, 1);
+	}
+	return 0; 
+
+    /* GRAPHICS MODES */
+    case SW_BG320:     case SW_BG640:
+    case SW_CG320:     case SW_CG320_D:   case SW_CG640_E:
+    case SW_CG640x350: case SW_ENH_CG640:
+    case SW_BG640x480: case SW_CG640x480: case SW_VGA_CG320:
+
+	if (!crtc_vga || video_mode_ptr == NULL)
+	    return ENXIO;
+	scp->mode = cmd & 0xFF;
+	scp->status |= UNKNOWN_MODE;    /* graphics mode */
+	scp->xsize = (*(video_mode_ptr + (scp->mode*64))) * 8;
+	scp->ysize = (*(video_mode_ptr + (scp->mode*64) + 1) + 1) *
+		     (*(video_mode_ptr + (scp->mode*64) + 2));
+	set_mode(scp);
+	/* clear_graphics();*/
+
+	if (tp->t_winsize.ws_xpixel != scp->xsize 
+	    || tp->t_winsize.ws_ypixel != scp->ysize) {
+	    tp->t_winsize.ws_xpixel = scp->xsize;
+	    tp->t_winsize.ws_ypixel = scp->ysize;
+	    pgsignal(tp->t_pgrp, SIGWINCH, 1);
 	}
+	return 0;
 
-	case CONS_GETVERS:	/* get version number */
-		*(int*)data = 0x200;	/* version 2.0 */
+    case VT_SETMODE:    	/* set screen switcher mode */
+	bcopy(data, &scp->smode, sizeof(struct vt_mode));
+	if (scp->smode.mode == VT_PROCESS) {
+	    scp->proc = p;
+	    scp->pid = scp->proc->p_pid;
+	}
+	return 0;
+    
+    case VT_GETMODE:    	/* get screen switcher mode */
+	bcopy(&scp->smode, data, sizeof(struct vt_mode));
+	return 0;
+    
+    case VT_RELDISP:    	/* screen switcher ioctl */
+	switch(*data) {
+	case VT_FALSE:  	/* user refuses to release screen, abort */
+	    if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
+		old_scp->status &= ~SWITCH_WAIT_REL;
+		switch_in_progress = FALSE;
 		return 0;
+	    }
+	    return EINVAL;
 
-	case SW_VGA_C40x25: case SW_VGA_C80x25:	/* VGA TEXT MODES */
-	case SW_VGA_M80x25:
-	case SW_VGA_C80x30: case SW_VGA_M80x30:
-	case SW_VGA_C80x50: case SW_VGA_M80x50:
-	case SW_VGA_C80x60: case SW_VGA_M80x60:
-	case SW_B40x25:     case SW_C40x25:
-	case SW_B80x25:     case SW_C80x25:
-	case SW_ENH_B40x25: case SW_ENH_C40x25: 
-	case SW_ENH_B80x25: case SW_ENH_C80x25:
-	case SW_ENH_B80x43: case SW_ENH_C80x43:
-
-		if (!crtc_vga || video_mode_ptr == NULL)
-			return ENXIO;
-		switch (cmd & 0xff) {
-		case M_VGA_C80x60: case M_VGA_M80x60:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 60;
-			break;
-		case M_VGA_C80x50: case M_VGA_M80x50:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 50;
-			break;
-		case M_ENH_B80x43: case M_ENH_C80x43:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 43;
-			break;
-		case M_VGA_C80x30: case M_VGA_M80x30:
-			scp->xsize = 80;
-			scp->ysize = 30;
-			break;
-		default:
-			if ((cmd & 0xff) > M_VGA_CG320)
-				return EINVAL;
-			else 
-			    scp->xsize = *(video_mode_ptr+((cmd&0xff)*64));
-			    scp->ysize = *(video_mode_ptr+((cmd&0xff)*64)+1)+1;
-			break;
-		}
-		scp->mode = cmd & 0xff;
-		scp->status &= ~UNKNOWN_MODE;	/* text mode */
-		free(scp->scr_buf, M_DEVBUF); 
-		scp->scr_buf = (u_short *)malloc(scp->xsize * scp->ysize * 
-				sizeof(u_short), M_DEVBUF, M_NOWAIT);
-		if (scp == cur_console)
-			set_mode(scp);
-		clear_screen(scp);
-		if (tp->t_winsize.ws_col != scp->xsize 
-		    || tp->t_winsize.ws_row != scp->ysize) {
-			tp->t_winsize.ws_col = scp->xsize;
-			tp->t_winsize.ws_row = scp->ysize;
-			pgsignal(tp->t_pgrp, SIGWINCH, 1);
+	case VT_TRUE:   	/* user has released screen, go on */
+	    if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
+		scp->status &= ~SWITCH_WAIT_REL;
+		exchange_scr();
+		if (new_scp->smode.mode == VT_PROCESS) {
+		    new_scp->status |= SWITCH_WAIT_ACQ;
+		    psignal(new_scp->proc, new_scp->smode.acqsig);
 		}
-		return 0; 
-
-	/* GRAPHICS MODES */
-	case SW_BG320:      case SW_CG320:      case SW_BG640:
-	case SW_CG320_D:    case SW_CG640_E:
-	case SW_CG640x350:  case SW_ENH_CG640:
-	case SW_BG640x480:  case SW_CG640x480:  case SW_VGA_CG320:
-
-		if (!crtc_vga || video_mode_ptr == NULL)
-			return ENXIO;
-		scp->mode = cmd & 0xFF;
-		scp->status |= UNKNOWN_MODE;	/* graphics mode */
-		scp->xsize = (*(video_mode_ptr + (scp->mode*64))) * 8;
-		scp->ysize = (*(video_mode_ptr + (scp->mode*64) + 1) + 1)
-			   * (*(video_mode_ptr + (scp->mode*64) + 2));
-		set_mode(scp);
-		/* clear_graphics();*/
+		else 
+		    switch_in_progress = FALSE;
+		return 0;
+	    }
+	    return EINVAL;
 
-		if (tp->t_winsize.ws_xpixel != scp->xsize 
-		    || tp->t_winsize.ws_ypixel != scp->ysize) {
-			tp->t_winsize.ws_xpixel = scp->xsize;
-			tp->t_winsize.ws_ypixel = scp->ysize;
-			pgsignal(tp->t_pgrp, SIGWINCH, 1);
-		}
+	case VT_ACKACQ: 	/* acquire acknowledged, switch completed */
+	    if (scp == new_scp && (scp->status & SWITCH_WAIT_ACQ)) {
+		scp->status &= ~SWITCH_WAIT_ACQ;
+		switch_in_progress = FALSE;
 		return 0;
+	    }
+	    return EINVAL;
 
-	case VT_SETMODE:	/* set screen switcher mode */
-		bcopy(data, &scp->smode, sizeof(struct vt_mode));
-		if (scp->smode.mode == VT_PROCESS) {
-			scp->proc = p;
-			scp->pid = scp->proc->p_pid;
-		}
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
+
+    case VT_OPENQRY:    	/* return free virtual console */
+	for (i = 0; i < MAXCONS; i++) {
+	    tp = VIRTUAL_TTY(i);
+	    if (!(tp->t_state & TS_ISOPEN)) {
+		*data = i + 1;
 		return 0;
-	
-	case VT_GETMODE:	/* get screen switcher mode */
-		bcopy(&scp->smode, data, sizeof(struct vt_mode));
+	    }
+	} 
+	return EINVAL;
+
+    case VT_ACTIVATE:   	/* switch to screen *data */
+	return switch_scr(scp, (*data) - 1);
+
+    case VT_WAITACTIVE: 	/* wait for switch to occur */
+	if (*data > MAXCONS || *data < 0) 
+	    return EINVAL;
+	if (minor(dev) == (*data) - 1) 
+	    return 0;
+	if (*data == 0) {
+	    if (scp == cur_console)
 		return 0;
-	
-	case VT_RELDISP:	/* screen switcher ioctl */
-		switch(*data) {
-		case VT_FALSE:	/* user refuses to release screen, abort */
-			if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
-				old_scp->status &= ~SWITCH_WAIT_REL;
-				switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
-
-		case VT_TRUE:	/* user has released screen, go on */
-			if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
-				scp->status &= ~SWITCH_WAIT_REL;
-				exchange_scr();
-				if (new_scp->smode.mode == VT_PROCESS) {
-					new_scp->status |= SWITCH_WAIT_ACQ;
-					psignal(new_scp->proc, 
-						new_scp->smode.acqsig);
-				}
-				else 
-					switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
+	}
+	else 
+	    scp = console[(*data) - 1];
+	while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH, 
+			     "waitvt", 0)) == ERESTART) ;
+	return error;
 
-		case VT_ACKACQ:	/* acquire acknowledged, switch completed */
-			if (scp == new_scp && (scp->status & SWITCH_WAIT_ACQ)) {
-				scp->status &= ~SWITCH_WAIT_ACQ;
-				switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
+    case VT_GETACTIVE:
+	*data = get_scr_num()+1;
+	return 0;
 
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
-
-	case VT_OPENQRY:	/* return free virtual console */
-		for (i = 0; i < MAXCONS; i++) {
-			tp = VIRTUAL_TTY(i);
-			if (!(tp->t_state & TS_ISOPEN)) {
-				*data = i + 1;
-				return 0;
-			}
-		} 
-		return EINVAL;
+    case KDENABIO:      	/* allow io operations */
+	fp = (struct trapframe *)p->p_md.md_regs;
+	fp->tf_eflags |= PSL_IOPL;
+	return 0; 
 
-	case VT_ACTIVATE:	/* switch to screen *data */
-		return switch_scr(scp, (*data) - 1);
-
-	case VT_WAITACTIVE:	/* wait for switch to occur */
-		if (*data > MAXCONS || *data < 0) 
-			return EINVAL;
-		if (minor(dev) == (*data) - 1) 
-			return 0;
-		if (*data == 0) {
-			if (scp == cur_console)
-				return 0;
-		}
-		else 
-			scp = console[(*data) - 1];
-		while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH, 
-			"waitvt", 0)) == ERESTART) ;
-		return error;
+    case KDDISABIO:     	/* disallow io operations (default) */
+	fp = (struct trapframe *)p->p_md.md_regs;
+	fp->tf_eflags &= ~PSL_IOPL;
+	return 0;
 
-	case VT_GETACTIVE:
-		*data = get_scr_num()+1;
-		return 0;
+    case KDSETMODE:     	/* set current mode of this (virtual) console */
+	switch (*data) {
+	case KD_TEXT:   	/* switch to TEXT (known) mode */
+	    /* restore fonts & palette ! */
+	    if (crtc_vga) {
+		if (fonts_loaded & FONT_8)
+		    copy_font(LOAD, FONT_8, font_8);
+		if (fonts_loaded & FONT_14)
+		    copy_font(LOAD, FONT_14, font_14);
+		if (fonts_loaded & FONT_16)
+		    copy_font(LOAD, FONT_16, font_16);
+		load_palette();
+	    }
+	    /* FALL THROUGH */
 
-	case KDENABIO:		/* allow io operations */
-		fp = (struct trapframe *)p->p_md.md_regs;
-		fp->tf_eflags |= PSL_IOPL;
-		return 0; 
+	case KD_TEXT1:  	/* switch to TEXT (known) mode */
+	    /* no restore fonts & palette */
+	    scp->status &= ~UNKNOWN_MODE;
+	    if (crtc_vga && video_mode_ptr)
+		set_mode(scp);
+	    clear_screen(scp);
+	    return 0;
 
-	case KDDISABIO:		/* disallow io operations (default) */
-		fp = (struct trapframe *)p->p_md.md_regs;
-		fp->tf_eflags &= ~PSL_IOPL;
-		return 0;
+	case KD_GRAPHICS:	/* switch to GRAPHICS (unknown) mode */
+	    scp->status |= UNKNOWN_MODE;
+	    return 0;
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
 
-	case KDSETMODE:		/* set current mode of this (virtual) console */
-		switch (*data) {
-		case KD_TEXT:	/* switch to TEXT (known) mode */
-				/* restore fonts & palette ! */
-			if (crtc_vga) {
-				if (fonts_loaded & FONT_8)
-					copy_font(LOAD, FONT_8, font_8);
-				if (fonts_loaded & FONT_14)
-					copy_font(LOAD, FONT_14, font_14);
-				if (fonts_loaded & FONT_16)
-					copy_font(LOAD, FONT_16, font_16);
-				load_palette();
-			}
-			/* FALL THROUGH */
-
-		case KD_TEXT1:	/* switch to TEXT (known) mode */
-				/* no restore fonts & palette */
-			scp->status &= ~UNKNOWN_MODE;
-			if (crtc_vga && video_mode_ptr)
-				set_mode(scp);
-			clear_screen(scp);
-			return 0;
-
-		case KD_GRAPHICS:/* switch to GRAPHICS (unknown) mode */
-			scp->status |= UNKNOWN_MODE;
-			return 0;
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
+    case KDGETMODE:     	/* get current mode of this (virtual) console */
+	*data = (scp->status & UNKNOWN_MODE) ? KD_GRAPHICS : KD_TEXT;
+	return 0;
 
-	case KDGETMODE:		/* get current mode of this (virtual) console */
-		*data = (scp->status & UNKNOWN_MODE) ? KD_GRAPHICS : KD_TEXT;
-		return 0;
+    case KDSBORDER:     	/* set border color of this (virtual) console */
+	if (!crtc_vga)
+	    return ENXIO;
+	scp->border = *data;
+	if (scp == cur_console) 
+	    set_border(scp->border);
+	return 0;
 
-	case KDSBORDER:		/* set border color of this (virtual) console */
-		if (!crtc_vga)
-			return ENXIO;
-		scp->border = *data;
-		if (scp == cur_console) 
-			set_border(scp->border);
-		return 0;
+    case KDSKBSTATE:    	/* set keyboard state (locks) */
+	if (*data >= 0 && *data <= LOCK_KEY_MASK) {
+	    scp->status &= ~LOCK_KEY_MASK;
+	    scp->status |= *data;
+	    if (scp == cur_console) 
+		update_leds(scp->status);
+	    return 0;
+	}
+	return EINVAL;
 
-	case KDSKBSTATE:	/* set keyboard state (locks) */
-		if (*data >= 0 && *data <= LOCK_KEY_MASK) {
-			scp->status &= ~LOCK_KEY_MASK;
-			scp->status |= *data;
-			if (scp == cur_console) 
-				update_leds(scp->status);
-			return 0;
-		}
-		return EINVAL;
+    case KDGKBSTATE:    	/* get keyboard state (locks) */
+	*data = scp->status & LOCK_KEY_MASK;
+	return 0;
 
-	case KDGKBSTATE:	/* get keyboard state (locks) */
-		*data = scp->status & LOCK_KEY_MASK;
-		return 0;
+    case KDSETRAD:      	/* set keyboard repeat & delay rates */
+	if (*data & 0x80)
+	    return EINVAL;
+	i = spltty();
+	kbd_cmd(KB_SETRAD);
+	kbd_cmd(*data);
+	splx(i);
+	return 0;
 
-	case KDSETRAD:		/* set keyboard repeat & delay rates */
-		if (*data & 0x80)
-			return EINVAL;
-		i = spltty();
-		kbd_cmd(KB_SETRAD);
-		kbd_cmd(*data);
-		splx(i);
-		return 0;
+    case KDSKBMODE:     	/* set keyboard mode */
+	switch (*data) {
+	case K_RAW: 		/* switch to RAW scancode mode */
+	    scp->status |= KBD_RAW_MODE;
+	    return 0;
 
-	case KDSKBMODE:		/* set keyboard mode */
-		switch (*data) {
-		case K_RAW:	/* switch to RAW scancode mode */
-			scp->status |= KBD_RAW_MODE;
-			return 0;
-
-		case K_XLATE:	/* switch to XLT ascii mode */
-			if (scp == cur_console && scp->status == KBD_RAW_MODE)
-				shfts = ctls = alts = agrs = metas = 0;
-			scp->status &= ~KBD_RAW_MODE;
-			return 0;
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
+	case K_XLATE:   	/* switch to XLT ascii mode */
+	    if (scp == cur_console && scp->status == KBD_RAW_MODE)
+		shfts = ctls = alts = agrs = metas = 0;
+	    scp->status &= ~KBD_RAW_MODE;
+	    return 0;
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
 
-	case KDGKBMODE:		/* get keyboard mode */
-		*data = (scp->status & KBD_RAW_MODE) ? K_RAW : K_XLATE;
-		return 0;
+    case KDGKBMODE:     	/* get keyboard mode */
+	*data = (scp->status & KBD_RAW_MODE) ? K_RAW : K_XLATE;
+	return 0;
 
-	case KDMKTONE:		/* sound the bell */
-		if (*(int*)data) {
-			do_bell(scp, (*(int*)data)&0xffff,
-				(((*(int*)data)>>16)&0xffff)*hz/1000);
-		}
-		else
-			do_bell(scp, scp->bell_pitch, scp->bell_duration);
-		return 0;
+    case KDMKTONE:      	/* sound the bell */
+	if (*(int*)data)
+	    do_bell(scp, (*(int*)data)&0xffff,
+		    (((*(int*)data)>>16)&0xffff)*hz/1000);
+	else
+	    do_bell(scp, scp->bell_pitch, scp->bell_duration);
+	return 0;
 
-	case KIOCSOUND:		/* make tone (*data) hz */
-		if (scp == cur_console) {
-			if (*(int*)data) {
-			int pitch = TIMER_FREQ/(*(int*)data);
-				/* set command for counter 2, 2 byte write */
-				if (acquire_timer2(TIMER_16BIT|TIMER_SQWAVE)) {
-					return EBUSY;
-				}
-				/* set pitch */
-				outb(TIMER_CNTR2, pitch);
-				outb(TIMER_CNTR2, (pitch>>8));
-				/* enable counter 2 output to speaker */
-				outb(IO_PPI, inb(IO_PPI) | 3);
-			}
-			else {
-				/* disable counter 2 output to speaker */
-				outb(IO_PPI, inb(IO_PPI) & 0xFC);
-				release_timer2();
-			}
-		}
-		return 0;
+    case KIOCSOUND:     	/* make tone (*data) hz */
+	if (scp == cur_console) {
+	    if (*(int*)data) {
+		int pitch = TIMER_FREQ/(*(int*)data);
 
-	case KDGKBTYPE:		/* get keyboard type */
-		*data = 0;	/* type not known (yet) */
-		return 0;
+		/* set command for counter 2, 2 byte write */
+		if (acquire_timer2(TIMER_16BIT|TIMER_SQWAVE))
+		    return EBUSY;
 
-	case KDSETLED:		/* set keyboard LED status */
-		if (*data >= 0 && *data <= LED_MASK) {
-			scp->status &= ~LED_MASK;
-			scp->status |= *data;
-			if (scp == cur_console)
-				update_leds(scp->status);
-			return 0;
-		}
-		return EINVAL;
+		/* set pitch */
+		outb(TIMER_CNTR2, pitch);
+		outb(TIMER_CNTR2, (pitch>>8));
 
-	case KDGETLED:		/* get keyboard LED status */
-		*data = scp->status & LED_MASK;
-		return 0;
+		/* enable counter 2 output to speaker */
+		outb(IO_PPI, inb(IO_PPI) | 3);
+	    }
+	    else {
+		/* disable counter 2 output to speaker */
+		outb(IO_PPI, inb(IO_PPI) & 0xFC);
+		release_timer2();
+	    }
+	}
+	return 0;
 
-	case GETFKEY:		/* get functionkey string */
-		if (*(u_short*)data < n_fkey_tab) {
-			fkeyarg_t *ptr = (fkeyarg_t*)data;
-			bcopy(&fkey_tab[ptr->keynum].str,
-			      ptr->keydef,
-			      fkey_tab[ptr->keynum].len);
-			ptr->flen = fkey_tab[ptr->keynum].len;
-			return 0;
-		}
-		else
-			return EINVAL;
-
-	case SETFKEY:		/* set functionkey string */
-		if (*(u_short*)data < n_fkey_tab) {
-			fkeyarg_t *ptr = (fkeyarg_t*)data;
-			bcopy(ptr->keydef, 
-			      &fkey_tab[ptr->keynum].str, 
-			      min(ptr->flen, MAXFK));
-			fkey_tab[ptr->keynum].len = min(ptr->flen, MAXFK);
-			return 0;
-		}
-		else
-			return EINVAL;
+    case KDGKBTYPE:     	/* get keyboard type */
+	*data = 0;  		/* type not known (yet) */
+	return 0;
 
-	case GIO_SCRNMAP: 	/* get output translation table */
-		bcopy(&scr_map, data, sizeof(scr_map));
-		return 0;
+    case KDSETLED:      	/* set keyboard LED status */
+	if (*data >= 0 && *data <= LED_MASK) {
+	    scp->status &= ~LED_MASK;
+	    scp->status |= *data;
+	    if (scp == cur_console)
+		update_leds(scp->status);
+	    return 0;
+	}
+	return EINVAL;
 
-	case PIO_SCRNMAP:	/* set output translation table */
-		bcopy(data, &scr_map, sizeof(scr_map));
-		return 0;
+    case KDGETLED:      	/* get keyboard LED status */
+	*data = scp->status & LED_MASK;
+	return 0;
 
-	case GIO_KEYMAP: 	/* get keyboard translation table */
-		bcopy(&key_map, data, sizeof(key_map));
-		return 0;
+    case GETFKEY:       	/* get functionkey string */
+	if (*(u_short*)data < n_fkey_tab) {
+	    fkeyarg_t *ptr = (fkeyarg_t*)data;
+	    bcopy(&fkey_tab[ptr->keynum].str, ptr->keydef,
+		  fkey_tab[ptr->keynum].len);
+	    ptr->flen = fkey_tab[ptr->keynum].len;
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case PIO_KEYMAP:	/* set keyboard translation table */
-		bcopy(data, &key_map, sizeof(key_map));
-		return 0;
+    case SETFKEY:       	/* set functionkey string */
+	if (*(u_short*)data < n_fkey_tab) {
+	    fkeyarg_t *ptr = (fkeyarg_t*)data;
+	    bcopy(ptr->keydef, &fkey_tab[ptr->keynum].str, 
+		  min(ptr->flen, MAXFK));
+	    fkey_tab[ptr->keynum].len = min(ptr->flen, MAXFK);
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case PIO_FONT8x8:	/* set 8x8 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_8, 8*256);
-		fonts_loaded |= FONT_8;
-		copy_font(LOAD, FONT_8, font_8);
-		return 0;
+    case GIO_SCRNMAP:   	/* get output translation table */
+	bcopy(&scr_map, data, sizeof(scr_map));
+	return 0;
 
-	case GIO_FONT8x8:	/* get 8x8 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_8) {
-			bcopy(font_8, data, 8*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-
-	case PIO_FONT8x14:	/* set 8x14 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_14, 14*256);
-		fonts_loaded |= FONT_14;
-		copy_font(LOAD, FONT_14, font_14);
-		return 0;
+    case PIO_SCRNMAP:   	/* set output translation table */
+	bcopy(data, &scr_map, sizeof(scr_map));
+	return 0;
 
-	case GIO_FONT8x14:	/* get 8x14 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_14) {
-			bcopy(font_14, data, 14*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-
-	case PIO_FONT8x16:	/* set 8x16 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_16, 16*256);
-		fonts_loaded |= FONT_16;
-		copy_font(LOAD, FONT_16, font_16);
-		return 0;
+    case GIO_KEYMAP:    	/* get keyboard translation table */
+	bcopy(&key_map, data, sizeof(key_map));
+	return 0;
 
-	case GIO_FONT8x16:	/* get 8x16 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_16) {
-			bcopy(font_16, data, 16*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-	default:
-		break;
-	}	
-	
-	error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
-	if (error >= 0)
-		return(error);
-	error = ttioctl(tp, cmd, data, flag);
-	if (error >= 0)
-		return(error);
-	return(ENOTTY);
+    case PIO_KEYMAP:    	/* set keyboard translation table */
+	bcopy(data, &key_map, sizeof(key_map));
+	return 0;
+
+    case PIO_FONT8x8:   	/* set 8x8 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_8, 8*256);
+	fonts_loaded |= FONT_8;
+	copy_font(LOAD, FONT_8, font_8);
+	return 0;
+
+    case GIO_FONT8x8:   	/* get 8x8 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_8) {
+	    bcopy(font_8, data, 8*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+
+    case PIO_FONT8x14:  	/* set 8x14 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_14, 14*256);
+	fonts_loaded |= FONT_14;
+	copy_font(LOAD, FONT_14, font_14);
+	return 0;
+
+    case GIO_FONT8x14:  	/* get 8x14 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_14) {
+	    bcopy(font_14, data, 14*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+
+    case PIO_FONT8x16:  	/* set 8x16 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_16, 16*256);
+	fonts_loaded |= FONT_16;
+	copy_font(LOAD, FONT_16, font_16);
+	return 0;
+
+    case GIO_FONT8x16:  	/* get 8x16 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_16) {
+	    bcopy(font_16, data, 16*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+    default:
+	break;
+    }   
+    
+    error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
+    if (error >= 0)
+	return(error);
+    error = ttioctl(tp, cmd, data, flag);
+    if (error >= 0)
+	return(error);
+    return(ENOTTY);
 }
 
 void 
 scxint(dev_t dev)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return;
-	tp->t_state &= ~TS_BUSY;
-	if (tp->t_line)
-		(*linesw[tp->t_line].l_start)(tp);
-	else
-		scstart(tp);
+    if (!tp)
+	return;
+    tp->t_state &= ~TS_BUSY;
+    if (tp->t_line)
+	(*linesw[tp->t_line].l_start)(tp);
+    else
+	scstart(tp);
 }
 
 void 
 scstart(struct tty *tp)
 {
-	struct clist *rbp;
-	int i, s, len;
-	u_char buf[PCBURST];
-	scr_stat *scp = get_scr_stat(tp->t_dev);
+    struct clist *rbp;
+    int i, s, len;
+    u_char buf[PCBURST];
+    scr_stat *scp = get_scr_stat(tp->t_dev);
 
-	if (scp->status & SLKED || blink_in_progress)
-		return;
+    if (scp->status & SLKED || blink_in_progress)
+	return;
+    s = spltty();
+    if (!(tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))) {
+	tp->t_state |= TS_BUSY;
+	splx(s);
+	rbp = &tp->t_outq;
+	while (rbp->c_cc) {
+	    len = q_to_b(rbp, buf, PCBURST);
+	    ansi_put(scp, buf, len);
+	}
+	scp->status |= UPDATE_SCREEN;
 	s = spltty();
-	if (!(tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))) {
-		tp->t_state |= TS_BUSY;
-		splx(s);
-		rbp = &tp->t_outq;
-		/* scp->status &= ~CURSOR_ENABLED; */
-		while (rbp->c_cc) {
-			len = q_to_b(rbp, buf, PCBURST);
-			ansi_put(scp, buf, len);
-		}
-		/* scp->status |= (CURSOR_ENABLED | UPDATE_SCREEN); */
-		scp->status |= UPDATE_SCREEN;
-		s = spltty();
-		tp->t_state &= ~TS_BUSY;
-		if (rbp->c_cc <= tp->t_lowat) {
-			if (tp->t_state & TS_ASLEEP) {
-				tp->t_state &= ~TS_ASLEEP;
-				wakeup((caddr_t)rbp);
-			}
-			selwakeup(&tp->t_wsel);
-		}
+	tp->t_state &= ~TS_BUSY;
+	if (rbp->c_cc <= tp->t_lowat) {
+	    if (tp->t_state & TS_ASLEEP) {
+		tp->t_state &= ~TS_ASLEEP;
+		wakeup((caddr_t)rbp);
+	    }
+	    selwakeup(&tp->t_wsel);
 	}
-	splx(s);
+    }
+    splx(s);
 }
 
+#if NAPM > 0 
+static int 
+scresume(void *dummy)
+{
+	shfts = 0;
+	ctls = 0;
+	alts = 0;
+	agrs = 0;
+	metas = 0;
+	return 0;
+}
+#endif
+
 void 
 pccnprobe(struct consdev *cp)
 {
-	int maj;
+    int maj;
 
-	/* locate the major number */
-	for (maj = 0; maj < nchrdev; maj++)
-		if ((void*)cdevsw[maj].d_open == (void*)scopen)
-			break;
+    /* locate the major number */
+    for (maj = 0; maj < nchrdev; maj++)
+	if ((void*)cdevsw[maj].d_open == (void*)scopen)
+	    break;
 
-	/* initialize required fields */
-	cp->cn_dev = makedev(maj, MAXCONS);
-	cp->cn_pri = CN_INTERNAL;
+    /* initialize required fields */
+    cp->cn_dev = makedev(maj, MAXCONS);
+    cp->cn_pri = CN_INTERNAL;
 }
 
 void 
 pccninit(struct consdev *cp)
 {
-	scinit();
+    scinit();
 }
 
 void 
 pccnputc(dev_t dev, char c)
 {
-	if (c == '\n')
-		scput('\r');
-	scput(c);
+    scr_stat *scp = console[0];
+    term_stat save = scp->term;
+
+    scp->term = kernel_console;
+    current_default = &kernel_default;
+    if (scp->scr_buf == Crtat)
+	draw_cursor(scp, FALSE);
+    if (c == '\n')
+	ansi_put(scp, "\r\n", 2);
+    else
+	ansi_put(scp, &c, 1);
+    scp->status |= UPDATE_SCREEN;
+    kernel_console = scp->term;
+    current_default = &user_default;
+    scp->term = save;
+    if (scp == cur_console /* && scrn_timer not running */) {
+	if (scp->scr_buf != Crtat) {
+	    bcopyw(scp->scr_buf, Crtat,
+		   (scp->xsize*scp->ysize)*sizeof(u_short));
+	    scp->status &= ~CURSOR_SHOWN;
+	}
+	draw_cursor(scp, TRUE);
+	scp->status &= ~UPDATE_SCREEN;
+    }
 }
 
 int 
 pccngetc(dev_t dev)
 {
-	int s = spltty();		/* block scintr while we poll */
-	int c = scgetc(0);
-	splx(s);
-	return(c);
+    int s = spltty();       /* block scintr while we poll */
+    int c = scgetc(0);
+    splx(s);
+    return(c);
 }
 
 int 
 pccncheckc(dev_t dev)
 {
-	return (scgetc(1) & 0xff);
-}
-
-static void 
-none_saver(int blank)
-{
-}
-
-static void 
-fade_saver(int blank)
-{
-	static int count = 0;
-	int i;
-
-	if (blank) {
-		scrn_blanked = 1;
-		if (count < 64) {
-			outb(PIXMASK, 0xFF);		/* no pixelmask */
-			outb(PALWADR, 0x00);
-			outb(PALDATA, 0);
-			outb(PALDATA, 0);
-			outb(PALDATA, 0);
-			for (i = 3; i < 768; i++) {
-				if (palette[i] - count > 15)
-					outb(PALDATA, palette[i]-count);
-				else
-					outb(PALDATA, 15);
-			}
-			inb(crtc_addr+6);		/* reset flip/flop */
-			outb(ATC, 0x20);		/* enable palette */
-			count++;
-		}
-	}
-	else {
-		load_palette();
-		count = scrn_blanked = 0;
-	}
-}
-
-static void 
-blank_saver(int blank)
-{
-	u_char val;
-	if (blank) {
-		scrn_blanked = 1;
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-	}
-	else {
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
-		scrn_blanked = 0;
-	}
-}
-
-static void 
-green_saver(int blank)
-{
-	u_char val;
-	if (blank) {
-		scrn_blanked = 1;
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
-		outb(crtc_addr + 1, val & ~0x80);
-	}
-	else {
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
-		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
-		outb(crtc_addr + 1, val | 0x80);
-		scrn_blanked = 0;
-	}
-}
-
-#define NUM_STARS	50
-
-/*
- * Alternate saver that got its inspiration from a well known utility
- * package for an inferior^H^H^H^H^H^Hfamous OS.
- */
-static void 
-star_saver(int blank)
-{
-	scr_stat	*scp = cur_console;
-	int		cell, i;
-	char 		pattern[] = {"...........++++***   "};
-	char		colors[] = {FG_DARKGREY, FG_LIGHTGREY, 
-				    FG_WHITE, FG_LIGHTCYAN};
-	static u_short 	stars[NUM_STARS][2];
- 
-	if (blank) {
-		if (!scrn_blanked) {
-			scrn_blanked = 1;
-			fillw((FG_LIGHTGREY|BG_BLACK)<<8|scr_map[0x20], Crtat, 
-			      scp->xsize * scp->ysize);
-			set_border(0);
-			for(i=0; i<NUM_STARS; i++) {
-				stars[i][0] = 
-					random() % (scp->xsize*scp->ysize);
-				stars[i][1] = 0;
-			}
-		}
-		cell = random() % NUM_STARS;
-		*((u_short*)(Crtat + stars[cell][0])) = 
-			scr_map[pattern[stars[cell][1]]] | 
-				colors[random()%sizeof(colors)] << 8;
-		if ((stars[cell][1]+=(random()%4)) >= sizeof(pattern)-1) {
-			stars[cell][0] = random() % (scp->xsize*scp->ysize);
-			stars[cell][1] = 0;
-		}
-	}
-	else {
-		if (scrn_blanked) {
-			set_border(scp->border);
-			scrn_blanked = 0;
-		}
-	}
-}
-
-static void 
-snake_saver(int blank)
-{
-	const char	saves[] = {"FreeBSD-2.0"};
-	static u_char	*savs[sizeof(saves)-1];
-	static int	dirx, diry;
-	int		f;
-	scr_stat	*scp = cur_console;
-
-	if (blank) {
-		if (!scrn_blanked) {
-			fillw((FG_LIGHTGREY|BG_BLACK)<<8 | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-			set_border(0);
-			dirx = (scp->xpos ? 1 : -1);
-			diry = (scp->ypos ?
-				scp->xsize : -scp->xsize);
-			for (f=0; f< sizeof(saves)-1; f++)
-				savs[f] = (u_char *)Crtat + 2 *
-					  (scp->xpos+scp->ypos*scp->xsize);
-			*(savs[0]) = scr_map[*saves];
-			f = scp->ysize * scp->xsize + 5;
-			outb(crtc_addr, 14);
-			outb(crtc_addr+1, f >> 8);
-			outb(crtc_addr, 15);
-			outb(crtc_addr+1, f & 0xff);
-			scrn_blanked = 1;
-		}
-		if (scrn_blanked++ < 4) 
-			return;
-		scrn_blanked = 1;
-		*(savs[sizeof(saves)-2]) = scr_map[0x20];
-		for (f=sizeof(saves)-2; f > 0; f--)
-			savs[f] = savs[f-1];
-		f = (savs[0] - (u_char *)Crtat) / 2;
-		if ((f % scp->xsize) == 0 ||
-		    (f % scp->xsize) == scp->xsize - 1 ||
-		    (random() % 50) == 0)
-			dirx = -dirx;
-		if ((f / scp->xsize) == 0 ||
-		    (f / scp->xsize) == scp->ysize - 1 ||
-		    (random() % 20) == 0)
-			diry = -diry;
-		savs[0] += 2*dirx + 2*diry;
-		for (f=sizeof(saves)-2; f>=0; f--)
-			*(savs[f]) = scr_map[saves[f]];
-	}
-	else {
-		if (scrn_blanked) {
-			set_border(scp->border);
-			scrn_blanked = 0;
-		}
-	}
+    return (scgetc(1) & 0xff);
 }
 
 static void 
@@ -1569,14 +1183,14 @@ scrn_timer()
 	timeout((timeout_func_t)scrn_timer, 0, hz/10);
 	return;
     }
-	
+    
     if (!scrn_blanked) {
 	/* update entire screen image */
 	if (scp->status & UPDATE_SCREEN) {
 	    bcopyw(scp->scr_buf, Crtat, scp->xsize*scp->ysize*sizeof(u_short));
 	    scp->status &= ~CURSOR_SHOWN;
 	}
-	/* update "pseudo" mouse */
+	/* update "pseudo" mouse arrow */
 	if ((scp->status & MOUSE_ENABLED) && 
 	    ((scp->status & UPDATE_MOUSE) || (scp->status & UPDATE_SCREEN)))
 	    draw_mouse_image(scp);
@@ -1590,909 +1204,880 @@ scrn_timer()
 	scp->status &= ~UPDATE_SCREEN;
     }
     if (scrn_blank_time && (time.tv_sec>scrn_time_stamp+scrn_blank_time))
-	SCRN_SAVER(TRUE);
+	(*current_saver)(TRUE);
     timeout((timeout_func_t)scrn_timer, 0, hz/25);
 }
-	
+
 static void 
 clear_screen(scr_stat *scp)
 {
-	move_crsr(scp, 0, 0);
-	fillw(scp->term.cur_attr | scr_map[0x20], scp->scr_buf,
-	       scp->xsize * scp->ysize);
+    move_crsr(scp, 0, 0);
+    fillw(scp->term.cur_attr | scr_map[0x20], scp->scr_buf,
+	  scp->xsize * scp->ysize);
 }
 
 static int 
 switch_scr(scr_stat *scp, u_int next_scr)
 {
-	if (switch_in_progress && (cur_console->proc != pfind(cur_console->pid)))
-		switch_in_progress = FALSE;
-
-	if (next_scr >= MAXCONS || switch_in_progress
-	    || (cur_console->smode.mode == VT_AUTO && cur_console->status & UNKNOWN_MODE)) {
-		do_bell(scp, BELL_PITCH, BELL_DURATION);
-		return EINVAL;
-	}
+    if (switch_in_progress && (cur_console->proc != pfind(cur_console->pid)))
+	switch_in_progress = FALSE;
+
+    if (next_scr >= MAXCONS || switch_in_progress || 
+	(cur_console->smode.mode == VT_AUTO 
+	 && cur_console->status & UNKNOWN_MODE)) {
+	do_bell(scp, BELL_PITCH, BELL_DURATION);
+	return EINVAL;
+    }
 
-	/* is the wanted virtual console open ? */
-	if (next_scr) {
-		struct tty *tp = VIRTUAL_TTY(next_scr);
-		if (!(tp->t_state & TS_ISOPEN)) {
-			do_bell(scp, BELL_PITCH, BELL_DURATION);
-			return EINVAL;
-		}
-	}
-	/* delay switch if actively updating screen */
-	if (write_in_progress || blink_in_progress) {
-		delayed_next_scr = next_scr+1;
-		return 0;
-	}
-	switch_in_progress = TRUE;
-	old_scp = cur_console;
-	new_scp = console[next_scr];
-	wakeup((caddr_t)&new_scp->smode);
-	if (new_scp == old_scp) {
-		switch_in_progress = FALSE;
-		delayed_next_scr = FALSE;
-		return 0;
-	}
-	
-	/* has controlling process died? */
-	if (old_scp->proc && (old_scp->proc != pfind(old_scp->pid)))
-		old_scp->smode.mode = VT_AUTO;
-	if (new_scp->proc && (new_scp->proc != pfind(new_scp->pid)))
-		new_scp->smode.mode = VT_AUTO;
-
-	/* check the modes and switch approbiatly */
-	if (old_scp->smode.mode == VT_PROCESS) {
-		old_scp->status |= SWITCH_WAIT_REL;
-		psignal(old_scp->proc, old_scp->smode.relsig);
-	}
-	else {
-		exchange_scr();
-		if (new_scp->smode.mode == VT_PROCESS) {
-			new_scp->status |= SWITCH_WAIT_ACQ;
-			psignal(new_scp->proc, new_scp->smode.acqsig);
-		}
-		else
-			switch_in_progress = FALSE;
+    /* is the wanted virtual console open ? */
+    if (next_scr) {
+	struct tty *tp = VIRTUAL_TTY(next_scr);
+	if (!(tp->t_state & TS_ISOPEN)) {
+	    do_bell(scp, BELL_PITCH, BELL_DURATION);
+	    return EINVAL;
 	}
+    }
+    /* delay switch if actively updating screen */
+    if (write_in_progress || blink_in_progress) {
+	delayed_next_scr = next_scr+1;
+	return 0;
+    }
+    switch_in_progress = TRUE;
+    old_scp = cur_console;
+    new_scp = console[next_scr];
+    wakeup((caddr_t)&new_scp->smode);
+    if (new_scp == old_scp) {
+	switch_in_progress = FALSE;
+	delayed_next_scr = FALSE;
 	return 0;
+    }
+    
+    /* has controlling process died? */
+    if (old_scp->proc && (old_scp->proc != pfind(old_scp->pid)))
+	old_scp->smode.mode = VT_AUTO;
+    if (new_scp->proc && (new_scp->proc != pfind(new_scp->pid)))
+	new_scp->smode.mode = VT_AUTO;
+
+    /* check the modes and switch approbiatly */
+    if (old_scp->smode.mode == VT_PROCESS) {
+	old_scp->status |= SWITCH_WAIT_REL;
+	psignal(old_scp->proc, old_scp->smode.relsig);
+    }
+    else {
+	exchange_scr();
+	if (new_scp->smode.mode == VT_PROCESS) {
+	    new_scp->status |= SWITCH_WAIT_ACQ;
+	    psignal(new_scp->proc, new_scp->smode.acqsig);
+	}
+	else
+	    switch_in_progress = FALSE;
+    }
+    return 0;
 }
 
 static void 
 exchange_scr(void) 
 {
-	move_crsr(old_scp, old_scp->xpos, old_scp->ypos);
-	cur_console = new_scp;
-	if (old_scp->mode != new_scp->mode || (old_scp->status & UNKNOWN_MODE)){
-		if (crtc_vga && video_mode_ptr)
-			set_mode(new_scp);
-	}
-	move_crsr(new_scp, new_scp->xpos, new_scp->ypos);
-	if ((old_scp->status & UNKNOWN_MODE) && crtc_vga) {
-		if (fonts_loaded & FONT_8)
-			copy_font(LOAD, FONT_8, font_8);
-		if (fonts_loaded & FONT_14)
-			copy_font(LOAD, FONT_14, font_14);
-		if (fonts_loaded & FONT_16)
-			copy_font(LOAD, FONT_16, font_16);
-		load_palette();
-	}
-	if (old_scp->status & KBD_RAW_MODE || new_scp->status & KBD_RAW_MODE)
-		shfts = ctls = alts = agrs = metas = 0;
-	update_leds(new_scp->status);
-	delayed_next_scr = FALSE;
-	new_scp->status |= UPDATE_SCREEN;
+    move_crsr(old_scp, old_scp->xpos, old_scp->ypos);
+    cur_console = new_scp;
+    if (old_scp->mode != new_scp->mode || (old_scp->status & UNKNOWN_MODE)){
+	if (crtc_vga && video_mode_ptr)
+	    set_mode(new_scp);
+    }
+    move_crsr(new_scp, new_scp->xpos, new_scp->ypos);
+    if ((old_scp->status & UNKNOWN_MODE) && crtc_vga) {
+	if (fonts_loaded & FONT_8)
+	    copy_font(LOAD, FONT_8, font_8);
+	if (fonts_loaded & FONT_14)
+	    copy_font(LOAD, FONT_14, font_14);
+	if (fonts_loaded & FONT_16)
+	    copy_font(LOAD, FONT_16, font_16);
+	load_palette();
+    }
+    if (old_scp->status & KBD_RAW_MODE || new_scp->status & KBD_RAW_MODE)
+	shfts = ctls = alts = agrs = metas = 0;
+    update_leds(new_scp->status);
+    delayed_next_scr = FALSE;
+    bcopyw(new_scp->scr_buf, Crtat,
+	   (new_scp->xsize*new_scp->ysize)*sizeof(u_short));
+    new_scp->status &= ~CURSOR_SHOWN;
 }
 
 static inline void 
 move_crsr(scr_stat *scp, int x, int y)
 {
-	if (x < 0 || y < 0 || x >= scp->xsize || y >= scp->ysize)
-		return;
-	scp->xpos = x;
-	scp->ypos = y;
-	scp->cursor_pos = scp->scr_buf + scp->ypos * scp->xsize + scp->xpos;
+    if (x < 0 || y < 0 || x >= scp->xsize || y >= scp->ysize)
+	return;
+    scp->xpos = x;
+    scp->ypos = y;
+    scp->cursor_pos = scp->scr_buf + scp->ypos * scp->xsize + scp->xpos;
 }
 
 static void 
 scan_esc(scr_stat *scp, u_char c)
 {
-	static u_char ansi_col[16] = 
-		{0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15};
-	int i, n;
-	u_short *src, *dst, count;
-
-	if (scp->term.esc == 1) {
-		switch (c) {
-
-		case '[': 	/* Start ESC [ sequence */
-			scp->term.esc = 2;
-			scp->term.last_param = -1;
-			for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
-				scp->term.param[i] = 1;
-			scp->term.num_param = 0;
-			return;
-
-		case 'M':	/* Move cursor up 1 line, scroll if at top */
-			if (scp->ypos > 0)
-				move_crsr(scp, scp->xpos, scp->ypos - 1);
-			else {
-				bcopyw(scp->scr_buf, 
-					scp->scr_buf + scp->xsize,
-					(scp->ysize - 1) * scp->xsize *
-					sizeof(u_short));
-				fillw(scp->term.cur_attr | scr_map[0x20], 
-				      scp->scr_buf, scp->xsize);
-			}
-			break;
+    static u_char ansi_col[16] = 
+	{0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15};
+    int i, n;
+    u_short *src, *dst, count;
+
+    if (scp->term.esc == 1) {
+	switch (c) {
+
+	case '[':   /* Start ESC [ sequence */
+	    scp->term.esc = 2;
+	    scp->term.last_param = -1;
+	    for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
+		scp->term.param[i] = 1;
+	    scp->term.num_param = 0;
+	    return;
+
+	case 'M':   /* Move cursor up 1 line, scroll if at top */
+	    if (scp->ypos > 0)
+		move_crsr(scp, scp->xpos, scp->ypos - 1);
+	    else {
+		bcopyw(scp->scr_buf, scp->scr_buf + scp->xsize,
+		       (scp->ysize - 1) * scp->xsize * sizeof(u_short));
+		fillw(scp->term.cur_attr | scr_map[0x20], 
+		      scp->scr_buf, scp->xsize);
+	    }
+	    break;
 #if notyet
-		case 'Q':
-			scp->term.esc = 4;
-			break;
+	case 'Q':
+	    scp->term.esc = 4;
+	    break;
 #endif
-		case 'c':	/* Clear screen & home */
-			clear_screen(scp);
-			break;
-		}
+	case 'c':   /* Clear screen & home */
+	    clear_screen(scp);
+	    break;
 	}
-	else if (scp->term.esc == 2) {
-		if (c >= '0' && c <= '9') {
-		    if (scp->term.num_param < MAX_ESC_PAR) {
-			if (scp->term.last_param != scp->term.num_param) {
-			    scp->term.last_param = scp->term.num_param;
-			    scp->term.param[scp->term.num_param] = 0;
-			}
-			else
-			    scp->term.param[scp->term.num_param] *= 10;
-			scp->term.param[scp->term.num_param] += c - '0';
-			return;
-		    }
-		}
-		scp->term.num_param = scp->term.last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (scp->term.num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case '=':
-			scp->term.esc = 3;
-			scp->term.last_param = -1;
-			for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
-				scp->term.param[i] = 1;
-			scp->term.num_param = 0;
-			return;
-
-		case 'A': /* up n rows */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos - n);
-			break;
-
-		case 'B': /* down n rows */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos + n);
-			break;
-
-		case 'C': /* right n columns */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos + n, scp->ypos);
-			break;
-
-		case 'D': /* left n columns */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos - n, scp->ypos);
-			break;
-
-		case 'E': /* cursor to start of line n lines down */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, 0, scp->ypos + n);
-			break;
-
-		case 'F': /* cursor to start of line n lines up */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, 0, scp->ypos - n);
-			break;
-
-		case 'f': /* System V consoles .. */
-		case 'H': /* Cursor move */
-			if (scp->term.num_param == 0) 
-				move_crsr(scp, 0, 0);
-			else if (scp->term.num_param == 2)
-				move_crsr(scp, scp->term.param[1] - 1, 
-					  scp->term.param[0] - 1);
-			break;
-
-		case 'J': /* Clear all or part of display */
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: /* clear form cursor to end of display */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->cursor_pos, scp->scr_buf + 
-				      scp->xsize * scp->ysize - 
-				      scp->cursor_pos);
-				break;
-			case 1: /* clear from beginning of display to cursor */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->scr_buf, 
-				      scp->cursor_pos - scp->scr_buf);
-				break;
-			case 2: /* clear entire display */
-				clear_screen(scp);
-				break;
-			}
-			break;
-
-		case 'K': /* Clear all or part of line */
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: /* clear form cursor to end of line */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->cursor_pos, scp->xsize - scp->xpos);
-				break;
-			case 1: /* clear from beginning of line to cursor */
-				fillw(scp->term.cur_attr|scr_map[0x20], 
-				      scp->cursor_pos - (scp->xsize - scp->xpos),
-				      (scp->xsize - scp->xpos) + 1);
-				break;
-			case 2: /* clear entire line */
-				fillw(scp->term.cur_attr|scr_map[0x20], 
-				      scp->cursor_pos - (scp->xsize - scp->xpos),
-				      scp->xsize);
-				break;
-			}
-			break;
-
-		case 'L':	/* Insert n lines */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->ysize - scp->ypos)
-				n = scp->ysize - scp->ypos;
-			src = scp->scr_buf + scp->ypos * scp->xsize;
-			dst = src + n * scp->xsize;
-			count = scp->ysize - (scp->ypos + n);
-			bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], src,
-			      n * scp->xsize);
-			break;
-
-		case 'M':	/* Delete n lines */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->ysize - scp->ypos)
-				n = scp->ysize - scp->ypos;
-			dst = scp->scr_buf + scp->ypos * scp->xsize;
-			src = dst + n * scp->xsize;
-			count = scp->ysize - (scp->ypos + n);
-			bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
-			src = dst + count * scp->xsize;
-			fillw(scp->term.cur_attr | scr_map[0x20], src,
-			      n * scp->xsize);
-			break;
-
-		case 'P':	/* Delete n chars */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			dst = scp->cursor_pos;
-			src = dst + n;
-			count = scp->xsize - (scp->xpos + n);
-			bcopyw(src, dst, count * sizeof(u_short));
-			src = dst + count;
-			fillw(scp->term.cur_attr | scr_map[0x20], src, n);
-			break;
-
-		case '@':	/* Insert n chars */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			src = scp->cursor_pos;
-			dst = src + n;
-			count = scp->xsize - (scp->xpos + n);
-			bcopyw(src, dst, count * sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], src, n);
-			break;
-
-		case 'S':	/* scroll up n lines */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->ysize)
-				n = scp->ysize;
-			bcopyw(scp->scr_buf + (scp->xsize * n),
-			      scp->scr_buf, 
-			      scp->xsize * (scp->ysize - n) * 
-			      sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20],
-			      scp->scr_buf + scp->xsize * 
-			      (scp->ysize - n),
-			      scp->xsize * n);
-			break;
-
-		case 'T':	/* scroll down n lines */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->ysize)
-				n = scp->ysize;
-			bcopyw(scp->scr_buf, 
-			      scp->scr_buf + (scp->xsize * n),
-			      scp->xsize * (scp->ysize - n) * 
-			      sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], 
-			      scp->scr_buf, scp->xsize * n);
-			break;
-
-		case 'X':	/* delete n characters in line */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			fillw(scp->term.cur_attr | scr_map[0x20], 
-			      scp->scr_buf + scp->xpos + 
-			      ((scp->xsize*scp->ypos) * sizeof(u_short)), n);
-			break;
-
-		case 'Z':	/* move n tabs backwards */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if ((i = scp->xpos & 0xf8) == scp->xpos)
-				i -= 8*n;
-			else 
-				i -= 8*(n-1); 
-			if (i < 0) 
-				i = 0;
-			move_crsr(scp, i, scp->ypos);
-			break;
-
-		case '`': 	/* move cursor to column n */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, n - 1, scp->ypos);
-			break;
-
-		case 'a': 	/* move cursor n columns to the right */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos + n, scp->ypos);
-			break;
-
-		case 'd': 	/* move cursor to row n */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos, n - 1);
-			break;
-
-		case 'e': 	/* move cursor n rows down */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos + n);
-			break;
-
-		case 'm': 	/* change attribute */
-			if (scp->term.num_param == 0) {
-				scp->term.cur_attr = scp->term.std_attr;
-				break;
-			}
-			for (i = 0; i < scp->term.num_param; i++) {
-				switch (n = scp->term.param[i]) {
-				case 0:	/* back to normal */
-					scp->term.cur_attr = scp->term.std_attr;
-					break;
-				case 1:	/* highlight (bold) */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x0800;
-					break;
-				case 4: /* highlight (underline) */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x0800;
-					break;
-				case 5: /* blink */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x8000;
-					break;
-				case 7: /* reverse video */
-					scp->term.cur_attr = scp->term.rev_attr;
-					break;
-				case 30: case 31: /* set fg color */
-				case 32: case 33: case 34: 
-				case 35: case 36: case 37:
-					scp->term.cur_attr = 
-						(scp->term.cur_attr & 0xF8FF)
-						| (ansi_col[(n-30) & 7] << 8);
-					break;
-				case 40: case 41: /* set bg color */
-				case 42: case 43: case 44: 
-				case 45: case 46: case 47:
-					scp->term.cur_attr = 
-						(scp->term.cur_attr & 0x8FFF)
-						| (ansi_col[(n-40) & 7] << 12);
-					break;
-				}
-			}
-			break;
-
-		case 'x':
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: 	/* reset attributes */
-				scp->term.cur_attr = scp->term.std_attr =
-				    current_default->std_attr;
-				scp->term.rev_attr = current_default->rev_attr;
-				break;
-			case 1: 	/* set ansi background */
-				scp->term.cur_attr = scp->term.std_attr =  
-				    (scp->term.std_attr & 0x0F00) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<12);
-				break;
-			case 2: 	/* set ansi foreground */
-				scp->term.cur_attr = scp->term.std_attr =  
-				    (scp->term.std_attr & 0xF000) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<8);
-				break;
-			case 3: 	/* set ansi attribute directly */
-				scp->term.cur_attr = scp->term.std_attr =
-				    (scp->term.param[1]&0xFF)<<8;
-				break;
-			case 5: 	/* set ansi reverse video background */
-				scp->term.rev_attr = 
-				    (scp->term.rev_attr & 0x0F00) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<12);
-				break;
-			case 6: 	/* set ansi reverse video foreground */
-				scp->term.rev_attr = 
-				    (scp->term.rev_attr & 0xF000) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<8);
-				break;
-			case 7: 	/* set ansi reverse video directly */
-				scp->term.rev_attr =
-				    (scp->term.param[1]&0xFF)<<8;
-				break;
-			}
-			break;
+    }
+    else if (scp->term.esc == 2) {
+	if (c >= '0' && c <= '9') {
+	    if (scp->term.num_param < MAX_ESC_PAR) {
+	    if (scp->term.last_param != scp->term.num_param) {
+		scp->term.last_param = scp->term.num_param;
+		scp->term.param[scp->term.num_param] = 0;
+	    }
+	    else
+		scp->term.param[scp->term.num_param] *= 10;
+	    scp->term.param[scp->term.num_param] += c - '0';
+	    return;
+	    }
+	}
+	scp->term.num_param = scp->term.last_param + 1;
+	switch (c) {
 
-		case 'z':	/* switch to (virtual) console n */
-			if (scp->term.num_param == 1)
-				switch_scr(scp, scp->term.param[0]);
-			break;
+	case ';':
+	    if (scp->term.num_param < MAX_ESC_PAR)
+		return;
+	    break;
+
+	case '=':
+	    scp->term.esc = 3;
+	    scp->term.last_param = -1;
+	    for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
+		scp->term.param[i] = 1;
+	    scp->term.num_param = 0;
+	    return;
+
+	case 'A':   /* up n rows */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos - n);
+	    break;
+
+	case 'B':   /* down n rows */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos + n);
+	    break;
+
+	case 'C':   /* right n columns */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos + n, scp->ypos);
+	    break;
+
+	case 'D':   /* left n columns */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos - n, scp->ypos);
+	    break;
+
+	case 'E':   /* cursor to start of line n lines down */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, 0, scp->ypos + n);
+	    break;
+
+	case 'F':   /* cursor to start of line n lines up */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, 0, scp->ypos - n);
+	    break;
+
+	case 'f':   /* Cursor move */
+	case 'H':
+	    if (scp->term.num_param == 0) 
+		move_crsr(scp, 0, 0);
+	    else if (scp->term.num_param == 2)
+		move_crsr(scp, scp->term.param[1] - 1, scp->term.param[0] - 1);
+	    break;
+
+	case 'J':   /* Clear all or part of display */
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0: /* clear form cursor to end of display */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->cursor_pos, 
+		      scp->scr_buf + scp->xsize * scp->ysize - scp->cursor_pos);
+		break;
+	    case 1: /* clear from beginning of display to cursor */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->scr_buf, 
+		      scp->cursor_pos - scp->scr_buf);
+		break;
+	    case 2: /* clear entire display */
+		clear_screen(scp);
+		break;
+	    }
+	    break;
+
+	case 'K':   /* Clear all or part of line */
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0: /* clear form cursor to end of line */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->cursor_pos, 
+		      scp->xsize - scp->xpos);
+		break;
+	    case 1: /* clear from beginning of line to cursor */
+		fillw(scp->term.cur_attr|scr_map[0x20], 
+		      scp->cursor_pos - (scp->xsize - scp->xpos),
+		      (scp->xsize - scp->xpos) + 1);
+		break;
+	    case 2: /* clear entire line */
+		fillw(scp->term.cur_attr|scr_map[0x20], 
+		      scp->cursor_pos - (scp->xsize - scp->xpos),
+		      scp->xsize);
+		break;
+	    }
+	    break;
+
+	case 'L':   /* Insert n lines */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->ysize - scp->ypos)
+		n = scp->ysize - scp->ypos;
+	    src = scp->scr_buf + scp->ypos * scp->xsize;
+	    dst = src + n * scp->xsize;
+	    count = scp->ysize - (scp->ypos + n);
+	    bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], src,
+		  n * scp->xsize);
+	    break;
+
+	case 'M':   /* Delete n lines */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->ysize - scp->ypos)
+		n = scp->ysize - scp->ypos;
+	    dst = scp->scr_buf + scp->ypos * scp->xsize;
+	    src = dst + n * scp->xsize;
+	    count = scp->ysize - (scp->ypos + n);
+	    bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
+	    src = dst + count * scp->xsize;
+	    fillw(scp->term.cur_attr | scr_map[0x20], src,
+		  n * scp->xsize);
+	    break;
+
+	case 'P':   /* Delete n chars */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    dst = scp->cursor_pos;
+	    src = dst + n;
+	    count = scp->xsize - (scp->xpos + n);
+	    bcopyw(src, dst, count * sizeof(u_short));
+	    src = dst + count;
+	    fillw(scp->term.cur_attr | scr_map[0x20], src, n);
+	    break;
+
+	case '@':   /* Insert n chars */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    src = scp->cursor_pos;
+	    dst = src + n;
+	    count = scp->xsize - (scp->xpos + n);
+	    bcopyw(src, dst, count * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], src, n);
+	    break;
+
+	case 'S':   /* scroll up n lines */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->ysize)
+		n = scp->ysize;
+	    bcopyw(scp->scr_buf + (scp->xsize * n), 
+		   scp->scr_buf, 
+		   scp->xsize * (scp->ysize - n) * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20],
+		  scp->scr_buf + scp->xsize * (scp->ysize - n), 
+		  scp->xsize * n);
+	    break;
+
+	case 'T':   /* scroll down n lines */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->ysize)
+		n = scp->ysize;
+	    bcopyw(scp->scr_buf, 
+		  scp->scr_buf + (scp->xsize * n),
+		  scp->xsize * (scp->ysize - n) * 
+		  sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], 
+		  scp->scr_buf, scp->xsize * n);
+	    break;
+
+	case 'X':   /* delete n characters in line */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    fillw(scp->term.cur_attr | scr_map[0x20], 
+		  scp->scr_buf + scp->xpos + 
+		  ((scp->xsize*scp->ypos) * sizeof(u_short)), n);
+	    break;
+
+	case 'Z':   /* move n tabs backwards */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if ((i = scp->xpos & 0xf8) == scp->xpos)
+		i -= 8*n;
+	    else 
+		i -= 8*(n-1); 
+	    if (i < 0) 
+		i = 0;
+	    move_crsr(scp, i, scp->ypos);
+	    break;
+
+	case '`':   /* move cursor to column n */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, n - 1, scp->ypos);
+	    break;
+
+	case 'a':   /* move cursor n columns to the right */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos + n, scp->ypos);
+	    break;
+
+	case 'd':   /* move cursor to row n */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos, n - 1);
+	    break;
+
+	case 'e':   /* move cursor n rows down */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos + n);
+	    break;
+
+	case 'm':   /* change attribute */
+	    if (scp->term.num_param == 0) {
+		scp->term.cur_attr = scp->term.std_attr;
+		break;
+	    }
+	    for (i = 0; i < scp->term.num_param; i++) {
+		switch (n = scp->term.param[i]) {
+		case 0: /* back to normal */
+		    scp->term.cur_attr = scp->term.std_attr;
+		    break;
+		case 1: /* highlight (bold) */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x0800;
+		    break;
+		case 4: /* highlight (underline) */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x0800;
+		    break;
+		case 5: /* blink */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x8000;
+		    break;
+		case 7: /* reverse video */
+		    scp->term.cur_attr = scp->term.rev_attr;
+		    break;
+		case 30: case 31: /* set fg color */
+		case 32: case 33: case 34: 
+		case 35: case 36: case 37:
+		    scp->term.cur_attr = 
+			(scp->term.cur_attr&0xF8FF) | (ansi_col[(n-30)&7]<<8);
+		    break;
+		case 40: case 41: /* set bg color */
+		case 42: case 43: case 44: 
+		case 45: case 46: case 47:
+		    scp->term.cur_attr = 
+			(scp->term.cur_attr&0x8FFF) | (ansi_col[(n-40)&7]<<12);
+		    break;
 		}
+	    }
+	    break;
+
+	case 'x':
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0:     /* reset attributes */
+		scp->term.cur_attr = scp->term.std_attr =
+		    current_default->std_attr;
+		scp->term.rev_attr = current_default->rev_attr;
+		break;
+	    case 1:     /* set ansi background */
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0x0F00) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<12);
+		break;
+	    case 2:     /* set ansi foreground */
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0xF000) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<8);
+		break;
+	    case 3:     /* set ansi attribute directly */
+		scp->term.cur_attr = scp->term.std_attr =
+		    (scp->term.param[1]&0xFF)<<8;
+		break;
+	    case 5:     /* set ansi reverse video background */
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0x0F00) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<12);
+		break;
+	    case 6:     /* set ansi reverse video foreground */
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0xF000) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<8);
+		break;
+	    case 7:     /* set ansi reverse video directly */
+		scp->term.rev_attr =
+		    (scp->term.param[1]&0xFF)<<8;
+		break;
+	    }
+	    break;
+
+	case 'z':   /* switch to (virtual) console n */
+	    if (scp->term.num_param == 1)
+		switch_scr(scp, scp->term.param[0]);
+	    break;
 	}
-	else if (scp->term.esc == 3) {
-		if (c >= '0' && c <= '9') {
-		    if (scp->term.num_param < MAX_ESC_PAR) {
-			if (scp->term.last_param != scp->term.num_param) {
-			    scp->term.last_param = scp->term.num_param;
-			    scp->term.param[scp->term.num_param] = 0;
-			}
-			else
-			    scp->term.param[scp->term.num_param] *= 10;
-			scp->term.param[scp->term.num_param] += c - '0';
-			return;
-		    }
-		}
-		scp->term.num_param = scp->term.last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (scp->term.num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case 'A':	/* set display border color */
-			if (scp->term.num_param == 1)
-				scp->border=scp->term.param[0] & 0xff;
-				if (scp == cur_console)
-					set_border(scp->border);
-			break;
-
-		case 'B':	/* set bell pitch and duration */
-			if (scp->term.num_param == 2) {
-				scp->bell_pitch = scp->term.param[0];
-				scp->bell_duration = scp->term.param[1]*10;
-			}
-			break;
-
-		case 'C': 	/* set cursor type & shape */
-			if (scp->term.num_param == 1) {
-				if (scp->term.param[0] & 0x01)
-					configuration |= BLINK_CURSOR;
-				else
-					configuration &= ~BLINK_CURSOR;
-				if (scp->term.param[0] & 0x02)
-					configuration |= CHAR_CURSOR;
-				else
-					configuration &= ~CHAR_CURSOR;
-			}
-			else if (scp->term.num_param == 2) {
-				scp->cursor_start = scp->term.param[0] & 0x1F; 
-				scp->cursor_end = scp->term.param[1] & 0x1F; 
-			}
-			break;
-
-		case 'F':	/* set ansi foreground */
-			if (scp->term.num_param == 1) 
-				scp->term.cur_attr = scp->term.std_attr =  
-					(scp->term.std_attr & 0xF000) 
-					| ((scp->term.param[0] & 0x0F) << 8);
-			break;
-
-		case 'G': 	/* set ansi background */
-			if (scp->term.num_param == 1) 
-				scp->term.cur_attr = scp->term.std_attr =  
-					(scp->term.std_attr & 0x0F00) 
-					| ((scp->term.param[0] & 0x0F) << 12);
-			break;
-
-		case 'H':	/* set ansi reverse video foreground */
-			if (scp->term.num_param == 1) 
-				scp->term.rev_attr = 
-					(scp->term.rev_attr & 0xF000) 
-					| ((scp->term.param[0] & 0x0F) << 8);
-			break;
-
-		case 'I': 	/* set ansi reverse video background */
-			if (scp->term.num_param == 1) 
-				scp->term.rev_attr = 
-					(scp->term.rev_attr & 0x0F00) 
-					| ((scp->term.param[0] & 0x0F) << 12);
-			break;
-		}
+    }
+    else if (scp->term.esc == 3) {
+	if (c >= '0' && c <= '9') {
+	    if (scp->term.num_param < MAX_ESC_PAR) {
+	    if (scp->term.last_param != scp->term.num_param) {
+		scp->term.last_param = scp->term.num_param;
+		scp->term.param[scp->term.num_param] = 0;
+	    }
+	    else
+		scp->term.param[scp->term.num_param] *= 10;
+	    scp->term.param[scp->term.num_param] += c - '0';
+	    return;
+	    }
+	}
+	scp->term.num_param = scp->term.last_param + 1;
+	switch (c) {
+
+	case ';':
+	    if (scp->term.num_param < MAX_ESC_PAR)
+		return;
+	    break;
+
+	case 'A':   /* set display border color */
+	    if (scp->term.num_param == 1)
+		scp->border=scp->term.param[0] & 0xff;
+		if (scp == cur_console)
+		    set_border(scp->border);
+	    break;
+
+	case 'B':   /* set bell pitch and duration */
+	    if (scp->term.num_param == 2) {
+		scp->bell_pitch = scp->term.param[0];
+		scp->bell_duration = scp->term.param[1]*10;
+	    }
+	    break;
+
+	case 'C':   /* set cursor type & shape */
+	    if (scp->term.num_param == 1) {
+		if (scp->term.param[0] & 0x01)
+		    configuration |= BLINK_CURSOR;
+		else
+		    configuration &= ~BLINK_CURSOR;
+		if (scp->term.param[0] & 0x02)
+		    configuration |= CHAR_CURSOR;
+		else
+		    configuration &= ~CHAR_CURSOR;
+	    }
+	    else if (scp->term.num_param == 2) {
+		scp->cursor_start = scp->term.param[0] & 0x1F; 
+		scp->cursor_end = scp->term.param[1] & 0x1F; 
+	    }
+	    break;
+
+	case 'F':   /* set ansi foreground */
+	    if (scp->term.num_param == 1) 
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0xF000) 
+		    | ((scp->term.param[0] & 0x0F) << 8);
+	    break;
+
+	case 'G':   /* set ansi background */
+	    if (scp->term.num_param == 1) 
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0x0F00) 
+		    | ((scp->term.param[0] & 0x0F) << 12);
+	    break;
+
+	case 'H':   /* set ansi reverse video foreground */
+	    if (scp->term.num_param == 1) 
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0xF000) 
+		    | ((scp->term.param[0] & 0x0F) << 8);
+	    break;
+
+	case 'I':   /* set ansi reverse video background */
+	    if (scp->term.num_param == 1) 
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0x0F00) 
+		    | ((scp->term.param[0] & 0x0F) << 12);
+	    break;
 	}
-	scp->term.esc = 0;
+    }
+    scp->term.esc = 0;
 }
 
 static inline void 
 draw_cursor(scr_stat *scp, int show)
 {
-	if (show && !(scp->status & CURSOR_SHOWN)) {
-	    u_short cursor_image = *(Crtat + (scp->cursor_pos - scp->scr_buf));
+    if (show && !(scp->status & CURSOR_SHOWN)) {
+	u_short cursor_image = *(Crtat + (scp->cursor_pos - scp->scr_buf));
 
-		scp->cursor_saveunder = cursor_image;
-		if (configuration & CHAR_CURSOR)
-			cursor_image = (cursor_image & 0xff00) | '_';
-		else {
-			if ((cursor_image & 0x7000) == 0x7000) {
-				cursor_image &= 0x8fff;
-				if(!(cursor_image & 0x0700))
-					cursor_image |= 0x0700;
-			} else {
-				cursor_image |= 0x7000;
-				if ((cursor_image & 0x0700) == 0x0700)
-					cursor_image &= 0xf0ff;
-			}
-		}
-		*(Crtat + (scp->cursor_pos - scp->scr_buf)) = cursor_image;
-		scp->status |= CURSOR_SHOWN;
-	}
-	if (!show && (scp->status & CURSOR_SHOWN)) {
-		*(Crtat+(scp->cursor_pos-scp->scr_buf)) = scp->cursor_saveunder;
-		scp->status &= ~CURSOR_SHOWN;
+	scp->cursor_saveunder = cursor_image;
+	if (configuration & CHAR_CURSOR)
+	    cursor_image = (cursor_image & 0xff00) | '_';
+	else {
+	    if ((cursor_image & 0x7000) == 0x7000) {
+		cursor_image &= 0x8fff;
+		if(!(cursor_image & 0x0700))
+		    cursor_image |= 0x0f00;
+	    } else {
+		cursor_image |= 0x7000;
+		if ((cursor_image & 0x0f00) == 0x0f00)
+		    cursor_image &= 0xf0ff;
+	    }
 	}
+	*(Crtat + (scp->cursor_pos - scp->scr_buf)) = cursor_image;
+	scp->status |= CURSOR_SHOWN;
+    }
+    if (!show && (scp->status & CURSOR_SHOWN)) {
+	*(Crtat+(scp->cursor_pos-scp->scr_buf)) = scp->cursor_saveunder;
+	scp->status &= ~CURSOR_SHOWN;
+    }
 }
 
 static void 
 ansi_put(scr_stat *scp, u_char *buf, int len)
 {
-	u_char *ptr = buf;
+    u_char *ptr = buf;
 
-	if (scp->status & UNKNOWN_MODE) 
-		return;
+    if (scp->status & UNKNOWN_MODE) 
+	return;
 
-	/* make screensaver happy */
-	if (scp == cur_console) {
-		scrn_time_stamp = time.tv_sec;
-		if (scrn_blanked)
-			SCRN_SAVER(FALSE);
-	}
-	write_in_progress++;
+    /* make screensaver happy */
+    if (scp == cur_console) {
+	scrn_time_stamp = time.tv_sec;
+	if (scrn_blanked)
+	    (*current_saver)(FALSE);
+    }
+    write_in_progress++;
 outloop:
-	if (scp->term.esc) {
-		scan_esc(scp, *ptr++);
-		len--;
+    if (scp->term.esc) {
+	scan_esc(scp, *ptr++);
+	len--;
+    }
+    else if (PRINTABLE(*ptr)) {     /* Print only printables */
+	do {
+	    *scp->cursor_pos++ = (scp->term.cur_attr | scr_map[*ptr++]);
+	    scp->xpos++;
+	    len--;
+	} while (len && PRINTABLE(*ptr) && (scp->xpos < scp->xsize));
+	if (scp->xpos >= scp->xsize) {
+	    scp->xpos = 0;
+	    scp->ypos++;
 	}
-	else if (PRINTABLE(*ptr)) { 	/* Print only printables */
-		do {
-			*scp->cursor_pos++ = 
-				(scp->term.cur_attr | scr_map[*ptr++]);
-			scp->xpos++;
-			len--;
-		} while (len && PRINTABLE(*ptr) && (scp->xpos < scp->xsize));
-		if (scp->xpos >= scp->xsize) {
-			scp->xpos = 0;
-			scp->ypos++;
+    }
+    else  {
+	switch(*ptr) {
+	case 0x07:
+	    do_bell(scp, scp->bell_pitch, scp->bell_duration);
+	    break;
+
+	case 0x08:      /* non-destructive backspace */
+	    if (scp->cursor_pos > scp->scr_buf) {
+		scp->cursor_pos--;
+		if (scp->xpos > 0)
+		    scp->xpos--;
+		else {
+		    scp->xpos += scp->xsize - 1;
+		    scp->ypos--;
 		}
-	}
-	else  {
-		switch(*ptr) {
-		case 0x07:
-			do_bell(scp, scp->bell_pitch, scp->bell_duration);
-			break;
-		case 0x08:      /* non-destructive backspace */
-			if (scp->cursor_pos > scp->scr_buf) {
-				scp->cursor_pos--;
-				if (scp->xpos > 0)
-					scp->xpos--;
-				else {
-					scp->xpos += scp->xsize - 1;
-					scp->ypos--;
-				}
-			}
-			break;
-		case 0x09:	/* non-destructive tab */
-			{
-				int i = 8 - scp->xpos % 8u;
-
-				scp->cursor_pos += i;
-				if ((scp->xpos += i) >= scp->xsize) {
-					scp->xpos = 0;
-					scp->ypos++;
-				}
-			}
-			break;
-		case 0x0a:	/* newline, same pos */
-			scp->cursor_pos += scp->xsize;
-			scp->ypos++;
-			break;
-		case 0x0c:	/* form feed, clears screen */
-			clear_screen(scp);
-			break;
-		case 0x0d:	/* return, return to pos 0 */
-			scp->cursor_pos -= scp->xpos;
-			scp->xpos = 0;
-			break;
-		case 0x1b:	/* start escape sequence */
-			scp->term.esc = 1;
-			scp->term.num_param = 0;
-			break;
+	    }
+	    break;
+
+	case 0x09:  /* non-destructive tab */
+	    {
+		int i = 8 - scp->xpos % 8u;
+
+		scp->cursor_pos += i;
+		if ((scp->xpos += i) >= scp->xsize) {
+		    scp->xpos = 0;
+		    scp->ypos++;
 		}
-		ptr++; len--;
-	}
-	/* do we have to scroll ?? */
-	if (scp->cursor_pos >= scp->scr_buf + scp->ysize * scp->xsize) {
-	    if (scp->history) {
-		bcopyw(scp->scr_buf, scp->history_head,
-		       scp->xsize * sizeof(u_short));
-
-		scp->history_head += scp->xsize;
-		if (scp->history_head + scp->xsize >
-		    scp->history + scp->history_size)
-			scp->history_head = scp->history;
 	    }
-	    bcopyw(scp->scr_buf + scp->xsize, scp->scr_buf,
-		   scp->xsize * (scp->ysize - 1) * sizeof(u_short));
-	    fillw(scp->term.cur_attr | scr_map[0x20],
-		  scp->scr_buf + scp->xsize * (scp->ysize - 1), 
-		  scp->xsize);
-	    scp->cursor_pos -= scp->xsize;
-	    scp->ypos--;
+	    break;
+
+	case 0x0a:  /* newline, same pos */
+	    scp->cursor_pos += scp->xsize;
+	    scp->ypos++;
+	    break;
+
+	case 0x0c:  /* form feed, clears screen */
+	    clear_screen(scp);
+	    break;
+
+	case 0x0d:  /* return, return to pos 0 */
+	    scp->cursor_pos -= scp->xpos;
+	    scp->xpos = 0;
+	    break;
+
+	case 0x1b:  /* start escape sequence */
+	    scp->term.esc = 1;
+	    scp->term.num_param = 0;
+	    break;
 	}
-	if (len)
-		goto outloop;
-	write_in_progress--;
-	if (delayed_next_scr)
-		switch_scr(scp, delayed_next_scr - 1);
+	ptr++; len--;
+    }
+    /* do we have to scroll ?? */
+    if (scp->cursor_pos >= scp->scr_buf + scp->ysize * scp->xsize) {
+	if (scp->history) {
+	    bcopyw(scp->scr_buf, scp->history_head,
+		   scp->xsize * sizeof(u_short));
+	    scp->history_head += scp->xsize;
+	    if (scp->history_head + scp->xsize >
+		scp->history + scp->history_size)
+		scp->history_head = scp->history;
+	}
+	bcopyw(scp->scr_buf + scp->xsize, scp->scr_buf,
+	       scp->xsize * (scp->ysize - 1) * sizeof(u_short));
+	fillw(scp->term.cur_attr | scr_map[0x20],
+	      scp->scr_buf + scp->xsize * (scp->ysize - 1), 
+	      scp->xsize);
+	scp->cursor_pos -= scp->xsize;
+	scp->ypos--;
+    }
+    if (len)
+	goto outloop;
+    write_in_progress--;
+    if (delayed_next_scr)
+	switch_scr(scp, delayed_next_scr - 1);
 }
 
 static void 
 scinit(void)
 {
-	u_short volatile *cp = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short), was;
-	unsigned hw_cursor;
-	int i;
+    u_short volatile *cp = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short), was;
+    unsigned hw_cursor;
+    int i;
+
+    if (init_done)  
+	return;
+    init_done = TRUE;
+    /*
+     * Crtat initialized to point to MONO buffer, if not present change
+     * to CGA_BUF offset. ONLY add the difference since locore.s adds
+     * in the remapped offset at the "right" time
+     */
+    was = *cp;
+    *cp = (u_short) 0xA55A;
+    if (*cp != 0xA55A)
+	crtc_addr = MONO_BASE;
+    else {
+	*cp = was;
+	crtc_addr = COLOR_BASE;
+	Crtat = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short);
+    }
+
+    /* extract cursor location */
+    outb(crtc_addr,14);
+    hw_cursor = inb(crtc_addr+1)<<8 ;
+    outb(crtc_addr,15);
+    hw_cursor |= inb(crtc_addr+1);
+
+    /* move hardware cursor out of the way */
+    outb(crtc_addr,14);
+    outb(crtc_addr+1, 0xff);
+    outb(crtc_addr,15);
+    outb(crtc_addr+1, 0xff);
+
+    /* is this a VGA or higher ? */
+    outb(crtc_addr, 7);
+    if (inb(crtc_addr) == 7) {
+	u_long  pa;
+	u_long  segoff;
+
+	crtc_vga = TRUE;
 
-	if (init_done) 	
-		return;
-	init_done = TRUE;
 	/*
-	 * Crtat initialized to point to MONO buffer, if not present change
-	 * to CGA_BUF offset. ONLY add the difference since locore.s adds
-	 * in the remapped offset at the "right" time
+	 * Get the BIOS video mode pointer.
 	 */
-	was = *cp;
-	*cp = (u_short) 0xA55A;
-	if (*cp != 0xA55A)
-		crtc_addr = MONO_BASE;
-	else {
-		*cp = was;
-		crtc_addr = COLOR_BASE;
-		Crtat = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short);
+	segoff = *(u_long *)pa_to_va(0x4a8);
+	pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
+	if (ISMAPPED(pa, sizeof(u_long))) {
+	    segoff = *(u_long *)pa_to_va(pa);
+	    pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
+	    if (ISMAPPED(pa, 64))
+		video_mode_ptr = (char *)pa_to_va(pa);
 	}
-
-	/* extract cursor location */
-	outb(crtc_addr,14);
-	hw_cursor = inb(crtc_addr+1)<<8 ;
-	outb(crtc_addr,15);
-	hw_cursor |= inb(crtc_addr+1);
-
-	/* move hardware cursor out of the way */
-	outb(crtc_addr,14);
-	outb(crtc_addr+1, 0xff);
-	outb(crtc_addr,15);
-	outb(crtc_addr+1, 0xff);
-
-	/* is this a VGA or higher ? */
-	outb(crtc_addr, 7);
-	if (inb(crtc_addr) == 7) {
-		u_long	pa;
-		u_long	segoff;
-
-		crtc_vga = TRUE;
-
-		/*
-		 * Get the BIOS video mode pointer.
-		 */
-		segoff = *(u_long *)pa_to_va(0x4a8);
-		pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
-		if (ISMAPPED(pa, sizeof(u_long))) {
-			segoff = *(u_long *)pa_to_va(pa);
-			pa = (((segoff & 0xffff0000) >> 12)
-			      + (segoff & 0xffff));
-			if (ISMAPPED(pa, 64))
-				video_mode_ptr = (char *)pa_to_va(pa);
-		}
-	}
-	current_default = &user_default;
-	console[0] = &main_console;
-	init_scp(console[0]);
-	console[0]->scr_buf = console[0]->mouse_pos =  Crtat;
-	console[0]->cursor_pos = Crtat + hw_cursor;
-	console[0]->xpos = hw_cursor % COL;
-	console[0]->ypos = hw_cursor / COL;
-	cur_console = console[0];
-	for (i=1; i<MAXCONS; i++)
-		console[i] = NULL;
-	kernel_console.esc = 0;
-	kernel_console.std_attr = kernel_default.std_attr;
-	kernel_console.rev_attr = kernel_default.rev_attr;
-	kernel_console.cur_attr = kernel_default.std_attr;
-	/* initialize mapscrn array to a one to one map */
-	for (i=0; i<sizeof(scr_map); i++)
-		scr_map[i] = i;
+    }
+    current_default = &user_default;
+    console[0] = &main_console;
+    init_scp(console[0]);
+    console[0]->scr_buf = console[0]->mouse_pos =  Crtat;
+    console[0]->cursor_pos = Crtat + hw_cursor;
+    console[0]->xpos = hw_cursor % COL;
+    console[0]->ypos = hw_cursor / COL;
+    cur_console = console[0];
+    for (i=1; i<MAXCONS; i++)
+	console[i] = NULL;
+    kernel_console.esc = 0;
+    kernel_console.std_attr = kernel_default.std_attr;
+    kernel_console.rev_attr = kernel_default.rev_attr;
+    kernel_console.cur_attr = kernel_default.std_attr;
+    /* initialize mapscrn array to a one to one map */
+    for (i=0; i<sizeof(scr_map); i++)
+	scr_map[i] = i;
 }
 
 static scr_stat 
 *alloc_scp()
 {
-	scr_stat *scp;
-
-	scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_NOWAIT);
-	init_scp(scp);
-	scp->scr_buf = scp->cursor_pos = scp->scr_buf = scp->mouse_pos =
-		(u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	scp->history_head = scp->history_pos = scp->history =
-		(u_short *)malloc(scp->history_size*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	bzero(scp->history_head, scp->history_size*sizeof(u_short));
-	if (crtc_vga && video_mode_ptr)
-		set_mode(scp);
-	clear_screen(scp);
-	return scp;
+    scr_stat *scp;
+
+    scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_NOWAIT);
+    init_scp(scp);
+    scp->scr_buf = scp->cursor_pos = scp->scr_buf = scp->mouse_pos =
+	(u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    scp->history_head = scp->history_pos = scp->history =
+	(u_short *)malloc(scp->history_size*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    bzero(scp->history_head, scp->history_size*sizeof(u_short));
+    if (crtc_vga && video_mode_ptr)
+	set_mode(scp);
+    clear_screen(scp);
+    return scp;
 }
 
 static void
 init_scp(scr_stat *scp)
 {
-	scp->mode = M_VGA_C80x25;
-	scp->font = FONT_16;
-	scp->xsize = COL;
-	scp->ysize = ROW;
-	scp->term.esc = 0;
-	scp->term.std_attr = current_default->std_attr;
-	scp->term.rev_attr = current_default->rev_attr;
-	scp->term.cur_attr = scp->term.std_attr;
-	scp->border = BG_BLACK;
-	scp->cursor_start = -1;
-	scp->cursor_end = -1;
-	scp->mouse_xpos = scp->mouse_ypos = 0;
-	scp->bell_pitch = BELL_PITCH;
-	scp->bell_duration = BELL_DURATION;
-	scp->status = (*(char *)pa_to_va(0x417) & 0x20) ? NLKED : 0;
-	scp->status |= CURSOR_ENABLED;
-	scp->pid = 0;
-	scp->proc = NULL;
-	scp->smode.mode = VT_AUTO;
-	scp->history_head = scp->history_pos = scp->history = NULL;
-	scp->history_size = HISTORY_SIZE;
-}
-
-static void 
-scput(u_char c)
-{
-	scr_stat *scp;
-	term_stat save;
-
-	scp = console[0];
-	save = scp->term;
-	scp->term = kernel_console;
-	current_default = &kernel_default;
-	if (scp->scr_buf == Crtat)
-		draw_cursor(scp, FALSE);
-	ansi_put(scp, &c, 1);
-	scp->status |= UPDATE_SCREEN;
-	kernel_console = scp->term;
-	current_default = &user_default;
-	scp->term = save;
-	if (scp == cur_console /* && scrn_timer not running */) {
-		if (scp->scr_buf != Crtat) {
-	    		bcopyw(scp->scr_buf, Crtat,
-			       (scp->xsize*scp->ysize)*sizeof(u_short));
-	    		scp->status &= ~CURSOR_SHOWN;
-		}
-		draw_cursor(scp, TRUE);
-		scp->status &= ~UPDATE_SCREEN;
-	}
+    scp->mode = M_VGA_C80x25;
+    scp->font = FONT_16;
+    scp->xsize = COL;
+    scp->ysize = ROW;
+    scp->term.esc = 0;
+    scp->term.std_attr = current_default->std_attr;
+    scp->term.rev_attr = current_default->rev_attr;
+    scp->term.cur_attr = scp->term.std_attr;
+    scp->border = BG_BLACK;
+    scp->cursor_start = -1;
+    scp->cursor_end = -1;
+    scp->mouse_xpos = scp->mouse_ypos = 0;
+    scp->bell_pitch = BELL_PITCH;
+    scp->bell_duration = BELL_DURATION;
+    scp->status = (*(char *)pa_to_va(0x417) & 0x20) ? NLKED : 0;
+    scp->status |= CURSOR_ENABLED;
+    scp->pid = 0;
+    scp->proc = NULL;
+    scp->smode.mode = VT_AUTO;
+    scp->history_head = scp->history_pos = scp->history = NULL;
+    scp->history_size = HISTORY_SIZE;
 }
 
 static u_char 
 *get_fstr(u_int c, u_int *len)
 {
-	u_int i;
-
-	if (!(c & FKEY))
-		return(NULL);
-	i = (c & 0xFF) - F_FN;
-	if (i > n_fkey_tab)
-		return(NULL);
-	*len = fkey_tab[i].len;
-	return(fkey_tab[i].str);
+    u_int i;
+
+    if (!(c & FKEY))
+	return(NULL);
+    i = (c & 0xFF) - F_FN;
+    if (i > n_fkey_tab)
+	return(NULL);
+    *len = fkey_tab[i].len;
+    return(fkey_tab[i].str);
 }
 
 static void 
 update_leds(int which)
 {
-	int s;
-	static u_char xlate_leds[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
+    int s;
+    static u_char xlate_leds[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
 
-	/* replace CAPS led with ALTGR led for ALTGR keyboards */
-	if (key_map.n_keys > ALTGR_OFFSET) {
-		if (which & ALKED)
-			which |= CLKED;
-		else
-			which &= ~CLKED;
-	}
-	s = spltty();
-	kbd_cmd(KB_SETLEDS);
-	kbd_cmd(xlate_leds[which & LED_MASK]);
-	splx(s);
+    /* replace CAPS led with ALTGR led for ALTGR keyboards */
+    if (key_map.n_keys > ALTGR_OFFSET) {
+	if (which & ALKED)
+	    which |= CLKED;
+	else
+	    which &= ~CLKED;
+    }
+    s = spltty();
+    kbd_cmd(KB_SETLEDS);
+    kbd_cmd(xlate_leds[which & LED_MASK]);
+    splx(s);
 }
   
 static void
 history_to_screen(scr_stat *scp)
 {
-	int i;
-
-	scp->status &= ~UPDATE_SCREEN;
-	for (i=0; i<scp->ysize; i++)
-		bcopyw(scp->history + (((scp->history_pos - scp->history) + 
-		       scp->history_size-((i+1)*scp->xsize))%scp->history_size),
-		       scp->scr_buf + (scp->xsize * (scp->ysize-1 - i)),
-		       scp->xsize * sizeof(u_short));
-	scp->status |= UPDATE_SCREEN;
+    int i;
+
+    scp->status &= ~UPDATE_SCREEN;
+    for (i=0; i<scp->ysize; i++)
+	bcopyw(scp->history + (((scp->history_pos - scp->history) + 
+	       scp->history_size-((i+1)*scp->xsize))%scp->history_size),
+	       scp->scr_buf + (scp->xsize * (scp->ysize-1 - i)),
+	       scp->xsize * sizeof(u_short));
+    scp->status |= UPDATE_SCREEN;
 }
 
 static int
 history_up_line(scr_stat *scp)
 {
-	if (WRAPHIST(scp, scp->history_pos, -(scp->xsize*scp->ysize)) !=
-	    scp->history_head) {
-		scp->history_pos = WRAPHIST(scp, scp->history_pos, -scp->xsize);
-		history_to_screen(scp);
-		return 0;
-	}
-	else
-		return -1;
+    if (WRAPHIST(scp, scp->history_pos, -(scp->xsize*scp->ysize)) !=
+	scp->history_head) {
+	scp->history_pos = WRAPHIST(scp, scp->history_pos, -scp->xsize);
+	history_to_screen(scp);
+	return 0;
+    }
+    else
+	return -1;
 }
 
 static int
 history_down_line(scr_stat *scp)
 {
-	if (scp->history_pos != scp->history_head) {
-		scp->history_pos = WRAPHIST(scp, scp->history_pos, scp->xsize);
-		history_to_screen(scp);
-		return 0;
-	}
-	else
-		return -1;
+    if (scp->history_pos != scp->history_head) {
+	scp->history_pos = WRAPHIST(scp, scp->history_pos, scp->xsize);
+	history_to_screen(scp);
+	return 0;
+    }
+    else
+	return -1;
 }
 
 /*
@@ -2503,875 +2088,882 @@ history_down_line(scr_stat *scp)
 u_int 
 scgetc(int noblock)
 {
-	u_char scancode, keycode;
-	u_int state, action;
-	struct key_t *key;
-	static u_char esc_flag = 0, compose = 0;
-	static u_int chr = 0;
+    u_char scancode, keycode;
+    u_int state, action;
+    struct key_t *key;
+    static u_char esc_flag = 0, compose = 0;
+    static u_int chr = 0;
 
 next_code:
-	kbd_wait();
-	/* First see if there is something in the keyboard port */
-	if (inb(KB_STAT) & KB_BUF_FULL)
-		scancode = inb(KB_DATA);
-	else if (noblock)
-		return(NOKEY);
-	else
-		goto next_code;
+    kbd_wait();
+    /* First see if there is something in the keyboard port */
+    if (inb(KB_STAT) & KB_BUF_FULL)
+	scancode = inb(KB_DATA);
+    else if (noblock)
+	return(NOKEY);
+    else
+	goto next_code;
 
-	if (cur_console->status & KBD_RAW_MODE)
-		return scancode;
+    if (cur_console->status & KBD_RAW_MODE)
+	return scancode;
 #if ASYNCH
-	if (scancode == KB_ACK || scancode == KB_RESEND) {
-		kbd_reply = scancode;
-		if (noblock)
-			return(NOKEY);
-		goto next_code;
-	}
+    if (scancode == KB_ACK || scancode == KB_RESEND) {
+	kbd_reply = scancode;
+	if (noblock)
+	    return(NOKEY);
+	goto next_code;
+    }
 #endif
-	keycode = scancode & 0x7F;
-	switch (esc_flag) {
-	case 0x00:		/* normal scancode */
-		switch(scancode) {
-		case 0xB8:	/* left alt  (compose key) */
-			if (compose) {
-				compose = 0;	
-				if (chr > 255) {
-					do_bell(cur_console, 
-						BELL_PITCH, BELL_DURATION);
-					chr = 0;
-				}
-			}
-			break;
-		case 0x38:
-			if (!compose) {
-				compose = 1;
-				chr = 0;
-			}
-			break;
-		case 0xE0:
-		case 0xE1:
-			esc_flag = scancode;
-			goto next_code;		
-		}
-		break;
-	case 0xE0:		/* 0xE0 prefix */
-		esc_flag = 0;
-		switch (keycode) {
-		case 0x1C:	/* right enter key */
-			keycode = 0x59;
-			break;
-		case 0x1D:	/* right ctrl key */
-			keycode = 0x5A;
-			break;
-		case 0x35:	/* keypad divide key */
-			keycode = 0x5B;
-			break;
-		case 0x37:	/* print scrn key */
-			keycode = 0x5C;
-			break;
-		case 0x38:	/* right alt key (alt gr) */
-			keycode = 0x5D;
-			break;
-		case 0x47:	/* grey home key */
-			keycode = 0x5E;
-			break;
-		case 0x48:	/* grey up arrow key */
-			keycode = 0x5F;
-			break;
-		case 0x49:	/* grey page up key */
-			keycode = 0x60;
-			break;
-		case 0x4B:	/* grey left arrow key */
-			keycode = 0x61;
-			break;
-		case 0x4D:	/* grey right arrow key */
-			keycode = 0x62;
-			break;
-		case 0x4F:	/* grey end key */
-			keycode = 0x63;
-			break;
-		case 0x50:	/* grey down arrow key */
-			keycode = 0x64;
-			break;
-		case 0x51:	/* grey page down key */
-			keycode = 0x65;
-			break;
-		case 0x52:	/* grey insert key */
-			keycode = 0x66;
-			break;
-		case 0x53:	/* grey delete key */
-			keycode = 0x67;
-			break;
-
-		/* the following 3 are only used on the MS "Natural" keyboard */
-		case 0x5b:	/* left Window key */
-			keycode = 0x69;
-			break;
-		case 0x5c:	/* right Window key */
-			keycode = 0x6a;
-			break;
-		case 0x5d:	/* menu key */
-			keycode = 0x6b;
-			break;
-		default:	/* ignore everything else */
-			goto next_code;
+    keycode = scancode & 0x7F;
+    switch (esc_flag) {
+    case 0x00:      /* normal scancode */
+	switch(scancode) {
+	case 0xB8:  /* left alt  (compose key) */
+	    if (compose) {
+		compose = 0;    
+		if (chr > 255) {
+		    do_bell(cur_console, 
+			BELL_PITCH, BELL_DURATION);
+		    chr = 0;
 		}
+	    }
+	    break;
+	case 0x38:
+	    if (!compose) {
+		compose = 1;
+		chr = 0;
+	    }
+	    break;
+	case 0xE0:
+	case 0xE1:
+	    esc_flag = scancode;
+	    goto next_code;     
+	}
+	break;
+    case 0xE0:      /* 0xE0 prefix */
+	esc_flag = 0;
+	switch (keycode) {
+	case 0x1C:  /* right enter key */
+	    keycode = 0x59;
+	    break;
+	case 0x1D:  /* right ctrl key */
+	    keycode = 0x5A;
+	    break;
+	case 0x35:  /* keypad divide key */
+	    keycode = 0x5B;
+	    break;
+	case 0x37:  /* print scrn key */
+	    keycode = 0x5C;
+	    break;
+	case 0x38:  /* right alt key (alt gr) */
+	    keycode = 0x5D;
+	    break;
+	case 0x47:  /* grey home key */
+	    keycode = 0x5E;
+	    break;
+	case 0x48:  /* grey up arrow key */
+	    keycode = 0x5F;
+	    break;
+	case 0x49:  /* grey page up key */
+	    keycode = 0x60;
+	    break;
+	case 0x4B:  /* grey left arrow key */
+	    keycode = 0x61;
+	    break;
+	case 0x4D:  /* grey right arrow key */
+	    keycode = 0x62;
+	    break;
+	case 0x4F:  /* grey end key */
+	    keycode = 0x63;
+	    break;
+	case 0x50:  /* grey down arrow key */
+	    keycode = 0x64;
+	    break;
+	case 0x51:  /* grey page down key */
+	    keycode = 0x65;
+	    break;
+	case 0x52:  /* grey insert key */
+	    keycode = 0x66;
+	    break;
+	case 0x53:  /* grey delete key */
+	    keycode = 0x67;
+	    break;
+
+	/* the following 3 are only used on the MS "Natural" keyboard */
+	case 0x5b:  /* left Window key */
+	    keycode = 0x69;
+	    break;
+	case 0x5c:  /* right Window key */
+	    keycode = 0x6a;
+	    break;
+	case 0x5d:  /* menu key */
+	    keycode = 0x6b;
+	    break;
+	default:    /* ignore everything else */
+	    goto next_code;
+	}
+	break;
+    case 0xE1:      /* 0xE1 prefix */
+	esc_flag = 0;   
+	if (keycode == 0x1D)
+	    esc_flag = 0x1D;
+	goto next_code;
+	/* NOT REACHED */
+    case 0x1D:      /* pause / break */
+	esc_flag = 0;   
+	if (keycode != 0x45)
+	    goto next_code;
+	keycode = 0x68;
+	break;
+    }
+
+    /* if scroll-lock pressed allow history browsing */
+    if (cur_console->history && cur_console->status & SLKED) {
+	int i;
+
+	cur_console->status &= ~CURSOR_ENABLED;
+	if (!(cur_console->status & BUFFER_SAVED)) {
+	    cur_console->status |= BUFFER_SAVED;
+	    cur_console->history_save = cur_console->history_head;
+
+	    /* copy screen into top of history buffer */
+	    for (i=0; i<cur_console->ysize; i++) {
+		bcopyw(cur_console->scr_buf + (cur_console->xsize * i), 
+		       cur_console->history_head,
+		       cur_console->xsize * sizeof(u_short));
+		cur_console->history_head += cur_console->xsize;
+		if (cur_console->history_head + cur_console->xsize >
+		    cur_console->history + cur_console->history_size)
+		    cur_console->history_head=cur_console->history;
+	    }
+	    cur_console->history_pos = cur_console->history_head;
+	    history_to_screen(cur_console);
+	}
+	switch (scancode) {
+	case 0x47:  /* home key */
+	    cur_console->history_pos = cur_console->history_head;
+	    history_to_screen(cur_console);
+	    goto next_code;
+
+	case 0x4F:  /* end key */
+	    cur_console->history_pos =
+		WRAPHIST(cur_console, cur_console->history_head, 
+			 cur_console->xsize*cur_console->ysize);
+	    history_to_screen(cur_console);
+	    goto next_code;
+
+	case 0x48:  /* up arrow key */
+	    if (history_up_line(cur_console))
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+	    goto next_code;
+
+	case 0x50:  /* down arrow key */
+	    if (history_down_line(cur_console))
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+	    goto next_code;
+
+	case 0x49:  /* page up key */
+	    for (i=0; i<cur_console->ysize; i++)
+	    if (history_up_line(cur_console)) {
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
 		break;
-	case 0xE1:		/* 0xE1 prefix */
-		esc_flag = 0;	
-		if (keycode == 0x1D)
-			esc_flag = 0x1D;
-		goto next_code;
-		/* NOT REACHED */
-	case 0x1D:		/* pause / break */
-		esc_flag = 0;	
-		if (keycode != 0x45)
-			goto next_code;
-		keycode = 0x68;
+	    }
+	    goto next_code;
+
+	case 0x51:  /* page down key */
+	    for (i=0; i<cur_console->ysize; i++)
+	    if (history_down_line(cur_console)) {
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
 		break;
+	    }
+	    goto next_code;
 	}
+    }
 
-	/* if scroll-lock pressed allow history browsing */
-	if (cur_console->history && cur_console->status & SLKED) {
-		int i;
-
-		cur_console->status &= ~CURSOR_ENABLED;
-		if (!(cur_console->status & BUFFER_SAVED)) {
-		    cur_console->status |= BUFFER_SAVED;
-		    cur_console->history_save = cur_console->history_head;
-		    /* copy screen into top of history buffer */
-		    for (i=0; i<cur_console->ysize; i++) {
-			bcopyw(cur_console->scr_buf + (cur_console->xsize * i), 
-			       cur_console->history_head,
-			       cur_console->xsize * sizeof(u_short));
-
-			cur_console->history_head += cur_console->xsize;
-			if (cur_console->history_head + cur_console->xsize >
-			    cur_console->history + cur_console->history_size)
-				cur_console->history_head=cur_console->history;
-		    }
-		    cur_console->history_pos = cur_console->history_head;
-		    history_to_screen(cur_console);
-		}
-		switch (scancode) {
-		case 0x47:	/* home key */
-		    cur_console->history_pos = cur_console->history_head;
-		    history_to_screen(cur_console);
-		    goto next_code;
-
-		case 0x4F:	/* end key */
-		    cur_console->history_pos =
-			WRAPHIST(cur_console, cur_console->history_head, 
-				 cur_console->xsize*cur_console->ysize);
-		    history_to_screen(cur_console);
-		    goto next_code;
-
-		case 0x48:	/* up arrow key */
-		    if (history_up_line(cur_console))
-			do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-		    goto next_code;
-
-		case 0x50:	/* down arrow key */
-		    if (history_down_line(cur_console))
-			do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-		    goto next_code;
-
-		case 0x49:	/* page up key */
-		    for (i=0; i<cur_console->ysize; i++)
-			if (history_up_line(cur_console)) {
-			    do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-			    break;
-		    }
-		    goto next_code;
-
-		case 0x51:	/* page down key */
-		    for (i=0; i<cur_console->ysize; i++)
-			if (history_down_line(cur_console)) {
-			    do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-			    break;
-		    }
-		    goto next_code;
-		}
+    if (compose) {
+	switch (scancode) {
+	/* key pressed process it */
+	case 0x47: case 0x48: case 0x49:    /* keypad 7,8,9 */
+	    chr = (scancode - 0x40) + chr*10;
+	    goto next_code;
+	case 0x4B: case 0x4C: case 0x4D:    /* keypad 4,5,6 */ 
+	    chr = (scancode - 0x47) + chr*10;
+	    goto next_code;
+	case 0x4F: case 0x50: case 0x51:    /* keypad 1,2,3 */ 
+	    chr = (scancode - 0x4E) + chr*10;
+	    goto next_code;
+	case 0x52:              /* keypad 0 */
+	    chr *= 10;
+	    goto next_code;
+
+	/* key release, no interest here */
+	case 0xC7: case 0xC8: case 0xC9:    /* keypad 7,8,9 */
+	case 0xCB: case 0xCC: case 0xCD:    /* keypad 4,5,6 */ 
+	case 0xCF: case 0xD0: case 0xD1:    /* keypad 1,2,3 */ 
+	case 0xD2:              /* keypad 0 */
+	    goto next_code;
+
+	case 0x38:              /* left alt key */
+	    break;
+	default:
+	    if (chr) {
+		compose = chr = 0;
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+		goto next_code;     
+	    }
+	    break;
 	}
-
-	if (compose) {
-		switch (scancode) {
-		/* key pressed process it */
-		case 0x47: case 0x48: case 0x49:	/* keypad 7,8,9 */
-			chr = (scancode - 0x40) + chr*10;
-			goto next_code;
-		case 0x4B: case 0x4C: case 0x4D:	/* keypad 4,5,6 */ 
-			chr = (scancode - 0x47) + chr*10;
-			goto next_code;
-		case 0x4F: case 0x50: case 0x51:	/* keypad 1,2,3 */ 
-			chr = (scancode - 0x4E) + chr*10;
-			goto next_code;
-		case 0x52:				/* keypad 0 */
-			chr *= 10;
-			goto next_code;
-
-		/* key release, no interest here */
-		case 0xC7: case 0xC8: case 0xC9:	/* keypad 7,8,9 */
-		case 0xCB: case 0xCC: case 0xCD:	/* keypad 4,5,6 */ 
-		case 0xCF: case 0xD0: case 0xD1:	/* keypad 1,2,3 */ 
-		case 0xD2:				/* keypad 0 */
-			goto next_code;
-
-		case 0x38:				/* left alt key */
-			break;
-		default:
-			if (chr) {
-				compose = chr = 0;
-				do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-				goto next_code;		
-			}
-			break;
-		}
+    }
+	
+    state = (shfts ? 1 : 0 ) | (2 * (ctls ? 1 : 0)) | (4 * (alts ? 1 : 0));
+    if ((!agrs && (cur_console->status & ALKED))
+	|| (agrs && !(cur_console->status & ALKED)))
+	keycode += ALTGR_OFFSET;
+    key = &key_map.key[keycode];
+    if ( ((key->flgs & FLAG_LOCK_C) && (cur_console->status & CLKED))
+	 || ((key->flgs & FLAG_LOCK_N) && (cur_console->status & NLKED)) )
+	state ^= 1;
+
+    /* Check for make/break */
+    action = key->map[state];
+    if (scancode & 0x80) {      /* key released */
+	if (key->spcl & 0x80) {
+	    switch (action) {
+	    case LSH:
+		shfts &= ~1;
+		break;
+	    case RSH:
+		shfts &= ~2;
+		break;
+	    case LCTR:
+		ctls &= ~1;
+		break;
+	    case RCTR:
+		ctls &= ~2;
+		break;
+	    case LALT:
+		alts &= ~1;
+		break;
+	    case RALT:
+		alts &= ~2;
+		break;
+	    case NLK:
+		nlkcnt = 0;             
+		break;
+	    case CLK:
+		clkcnt = 0;
+		break;
+	    case SLK:
+		slkcnt = 0;
+		break;
+	    case ASH:
+		agrs = 0;
+		break;
+	    case ALK:
+		alkcnt = 0;
+		break;
+	    case META:
+		metas = 0;
+		break;
+	    }
 	}
-		
-	state = (shfts ? 1 : 0 ) | (2 * (ctls ? 1 : 0)) | (4 * (alts ? 1 : 0));
-	if ((!agrs && (cur_console->status & ALKED))
-	    || (agrs && !(cur_console->status & ALKED)))
-		keycode += ALTGR_OFFSET;
-	key = &key_map.key[keycode];
-	if ( ((key->flgs & FLAG_LOCK_C) && (cur_console->status & CLKED))
-	     || ((key->flgs & FLAG_LOCK_N) && (cur_console->status & NLKED)) )
-		state ^= 1;
-
-	/* Check for make/break */
-	action = key->map[state];
-	if (scancode & 0x80) { 		/* key released */
-		if (key->spcl & 0x80) {
-			switch (action) {
-			case LSH:
-				shfts &= ~1;
-				break;
-			case RSH:
-				shfts &= ~2;
-				break;
-			case LCTR:
-				ctls &= ~1;
-				break;
-			case RCTR:
-				ctls &= ~2;
-				break;
-			case LALT:
-				alts &= ~1;
-				break;
-			case RALT:
-				alts &= ~2;
-				break;
-			case NLK:
-				nlkcnt = 0;				
-				break;
-			case CLK:
-				clkcnt = 0;
-				break;
-			case SLK:
-				slkcnt = 0;
-				break;
-			case ASH:
-				agrs = 0;
-				break;
-			case ALK:
-				alkcnt = 0;
-				break;
-			case META:
-				metas = 0;
-				break;
+	if (chr && !compose) {
+	    action = chr;
+	    chr = 0;
+	    return(action);
+	}
+    } else {
+	/* key pressed */
+	if (key->spcl & (0x80>>state)) {
+	    switch (action) {
+	    /* LOCKING KEYS */
+	    case NLK:
+		if (!nlkcnt) {
+		    nlkcnt++;
+		    if (cur_console->status & NLKED) 
+			cur_console->status &= ~NLKED;
+		    else
+			cur_console->status |= NLKED;
+		    update_leds(cur_console->status);
+		}
+		break;
+	    case CLK:
+		if (!clkcnt) {
+		    clkcnt++;
+		    if (cur_console->status & CLKED)
+			cur_console->status &= ~CLKED;
+		    else
+			cur_console->status |= CLKED;
+		    update_leds(cur_console->status);
+		}
+		break;
+	    case SLK:
+		if (!slkcnt) {
+		    slkcnt++;
+		    if (cur_console->status & SLKED) {
+			cur_console->status &= ~SLKED;
+			if (cur_console->status & BUFFER_SAVED){
+			    int i;
+			    u_short *ptr = cur_console->history_save;
+
+			    for (i=0; i<cur_console->ysize; i++) {
+				bcopyw(ptr, 
+				       cur_console->scr_buf +
+				       (cur_console->xsize*i),
+				       cur_console->xsize * sizeof(u_short));
+				ptr += cur_console->xsize;
+				if (ptr + cur_console->xsize >
+				    cur_console->history +
+				    cur_console->history_size)
+				    ptr = cur_console->history;
+			    }
+			    cur_console->status&=~BUFFER_SAVED;
+			    cur_console->history_head=cur_console->history_save;
+			    cur_console->status|=(CURSOR_ENABLED|UPDATE_SCREEN);
 			}
+			scstart(VIRTUAL_TTY(get_scr_num()));
+		    } 
+		    else 
+			cur_console->status |= SLKED;
+		    update_leds(cur_console->status);
 		}
-		if (chr && !compose) {
-			action = chr;
-			chr = 0;
-			return(action);
+		break;
+	    case ALK:
+		if (!alkcnt) {
+		    alkcnt++;
+		    if (cur_console->status & ALKED)
+			cur_console->status &= ~ALKED;
+		    else
+			cur_console->status |= ALKED;
+		    update_leds(cur_console->status);
 		}
-	} else {
-		/* key pressed */
-		if (key->spcl & (0x80>>state)) {
-			switch (action) {
-			/* LOCKING KEYS */
-			case NLK:
-				if (!nlkcnt) {
-					nlkcnt++;
-					if (cur_console->status & NLKED) 
-						cur_console->status &= ~NLKED;
-					else
-						cur_console->status |= NLKED;
-					update_leds(cur_console->status);
-				}
-				break;
-			case CLK:
-				if (!clkcnt) {
-					clkcnt++;
-					if (cur_console->status & CLKED)
-						cur_console->status &= ~CLKED;
-					else
-						cur_console->status |= CLKED;
-					update_leds(cur_console->status);
-				}
-				break;
-			case SLK:
-				if (!slkcnt) {
-				    slkcnt++;
-				    if (cur_console->status & SLKED) {
-					cur_console->status &= ~SLKED;
-					if (cur_console->status & BUFFER_SAVED){
-					    int i;
-		    for (i=0; i<cur_console->ysize; i++) {
-			bcopyw(cur_console->history_save+(cur_console->xsize*i),
-			       cur_console->scr_buf + (cur_console->xsize * i), 
-			       cur_console->xsize * sizeof(u_short));
-		    }
-					    cur_console->status&=~BUFFER_SAVED;
-					    cur_console->history_head =
-						cur_console->history_save;
-					    cur_console->status |= 
-						(CURSOR_ENABLED|UPDATE_SCREEN);
-					}
-					scstart(VIRTUAL_TTY(get_scr_num()));
-				    } 
-				    else 
-					cur_console->status |= SLKED;
-				    update_leds(cur_console->status);
-				}
-				break;
-			case ALK:
-				if (!alkcnt) {
-					alkcnt++;
-					if (cur_console->status & ALKED)
-						cur_console->status &= ~ALKED;
-					else
-						cur_console->status |= ALKED;
-					update_leds(cur_console->status);
-				}
-				break;
-
-			/* NON-LOCKING KEYS */
-			case NOP:
-				break;
-			case RBT:
-				shutdown_nice();
-				break;	
-			case SUSP:
+		break;
+
+	    /* NON-LOCKING KEYS */
+	    case NOP:
+		break;
+	    case RBT:
+		shutdown_nice();
+		break;  
+	    case SUSP:
 #if NAPM > 0 
-				apm_suspend();
+		apm_suspend();
 #endif
-				break;
-
-			case DBG:
-#ifdef DDB			/* try to switch to console 0 */
-				if (cur_console->smode.mode == VT_AUTO &&
-				    console[0]->smode.mode == VT_AUTO)
-					switch_scr(cur_console, 0); 
-				Debugger("manual escape to debugger");
-				return(NOKEY);
+		break;
+
+	    case DBG:
+#ifdef DDB          /* try to switch to console 0 */
+		if (cur_console->smode.mode == VT_AUTO &&
+		    console[0]->smode.mode == VT_AUTO)
+		    switch_scr(cur_console, 0); 
+		Debugger("manual escape to debugger");
+		return(NOKEY);
 #else
-				printf("No debugger in kernel\n");
+		printf("No debugger in kernel\n");
 #endif
-				break;
-			case LSH:
-				shfts |= 1;
-				break;
-			case RSH:
-				shfts |= 2;
-				break;
-			case LCTR:
-				ctls |= 1;
-				break;
-			case RCTR:
-				ctls |= 2;
-				break;
-			case LALT:
-				alts |= 1;
-				break;
-			case RALT:
-				alts |= 2;
-				break;
-			case ASH:
-				agrs = 1;
-				break;
-			case META:
-				metas = 1;
-				break;
-			case NEXT:
-				switch_scr(cur_console,
-					   (get_scr_num() + 1) % MAXCONS);
-				break;
-			case BTAB:
-				return(BKEY);
-			default:
-				if (action >= F_SCR && action <= L_SCR) {
-					switch_scr(cur_console, action - F_SCR);
-					break;
-				}
-				if (action >= F_FN && action <= L_FN) 
-					action |= FKEY;
-				return(action);
-			}
-		}
-		else {
-			if (metas)
-				action |= MKEY;
-			return(action);
+		break;
+	    case LSH:
+		shfts |= 1;
+		break;
+	    case RSH:
+		shfts |= 2;
+		break;
+	    case LCTR:
+		ctls |= 1;
+		break;
+	    case RCTR:
+		ctls |= 2;
+		break;
+	    case LALT:
+		alts |= 1;
+		break;
+	    case RALT:
+		alts |= 2;
+		break;
+	    case ASH:
+		agrs = 1;
+		break;
+	    case META:
+		metas = 1;
+		break;
+	    case NEXT:
+		switch_scr(cur_console, (get_scr_num() + 1) % MAXCONS);
+		break;
+	    case BTAB:
+		return(BKEY);
+	    default:
+		if (action >= F_SCR && action <= L_SCR) {
+		    switch_scr(cur_console, action - F_SCR);
+		    break;
 		}
+		if (action >= F_FN && action <= L_FN) 
+		    action |= FKEY;
+		return(action);
+	    }
 	}
-	goto next_code;
+	else {
+	    if (metas)
+		action |= MKEY;
+	    return(action);
+	}
+    }
+    goto next_code;
 }
 
 int 
 scmmap(dev_t dev, int offset, int nprot)
 {
-	if (offset > 0x20000 - PAGE_SIZE)
-		return -1;
-	return i386_btop((VIDEOMEM + offset));
+    if (offset > 0x20000 - PAGE_SIZE)
+	return -1;
+    return i386_btop((VIDEOMEM + offset));
 }
 
 static void 
 kbd_wait(void)
 {
-	int i = 1000;
+    int i = 1000;
 
-	while (i--) {
-		if ((inb(KB_STAT) & KB_READY) == 0) 
-			break;
-		DELAY (10);
-	}
+    while (i--) {
+	if ((inb(KB_STAT) & KB_READY) == 0) 
+	    break;
+	DELAY (10);
+    }
 }
 
 static void 
 kbd_cmd(u_char command)
 {
-	int retry = 5;
-	do {
-		int i = 100000;
+    int retry = 5;
+    do {
+	int i = 100000;
 
-		kbd_wait();
+	kbd_wait();
 #if ASYNCH
-		kbd_reply = 0;
-		outb(KB_DATA, command);
-		while (i--) {
-			if (kbd_reply == KB_ACK)
-				return;
-			if (kbd_reply == KB_RESEND)
-				break;
-		}
+	kbd_reply = 0;
+	outb(KB_DATA, command);
+	while (i--) {
+	    if (kbd_reply == KB_ACK)
+		return;
+	    if (kbd_reply == KB_RESEND)
+		break;
+	}
 #else
-		outb(KB_DATA, command);
-		while (i--) {
-			if (inb(KB_STAT) & KB_BUF_FULL) {
-				int val;
-				DELAY(10);
-				val = inb(KB_DATA);
-				if (val == KB_ACK)
-					return;
-				if (val == KB_RESEND)
-					break;
-			}
-		}
+	outb(KB_DATA, command);
+	while (i--) {
+	    if (inb(KB_STAT) & KB_BUF_FULL) {
+		int val;
+		DELAY(10);
+		val = inb(KB_DATA);
+		if (val == KB_ACK)
+		    return;
+		if (val == KB_RESEND)
+		    break;
+	    }
+	}
 #endif
-	} while (retry--);
+    } while (retry--);
 }
 
 static void 
 set_mode(scr_stat *scp)
 {
-	char *modetable;
-	char special_modetable[64];
-	int mode, font_size;
+    char *modetable;
+    char special_modetable[64];
+    int mode, font_size;
 
-	if (scp != cur_console)
-		return;
+    if (scp != cur_console)
+	return;
 
-	/* setup video hardware for the given mode */
-	switch (scp->mode) {
-	case M_VGA_M80x60: 
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x60;
-
-	case M_VGA_C80x60: 
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x60:	special_modetable[2]  = 0x08;
-		special_modetable[19] = 0x47;
-		goto special_480l;
-
-	case M_VGA_M80x30:
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x30;
-
-	case M_VGA_C80x30:
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x30:	special_modetable[19] = 0x4f;
-special_480l:	special_modetable[9] |= 0xc0;
-		special_modetable[16] = 0x08;
-		special_modetable[17] = 0x3e;
-		special_modetable[26] = 0xea;
-		special_modetable[28] = 0xdf; 
-		special_modetable[31] = 0xe7;
-		special_modetable[32] = 0x04;
-		modetable = special_modetable;
-		goto setup_mode;
-
-	case M_ENH_B80x43:
-		bcopyw(video_mode_ptr+(64*M_ENH_B80x25),&special_modetable, 64);
-		goto special_80x43;
-
-	case M_ENH_C80x43:
-		bcopyw(video_mode_ptr+(64*M_ENH_C80x25),&special_modetable, 64);
-special_80x43:	special_modetable[28] = 87;
-		goto special_80x50;
-
-	case M_VGA_M80x50: 
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x50;
-
-	case M_VGA_C80x50:
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x50: 	special_modetable[2] = 8;
-		special_modetable[19] = 7;
-		modetable = special_modetable;
-		goto setup_mode;
-
-	case M_VGA_C40x25: case M_VGA_C80x25:	/* VGA TEXT MODES */
-	case M_VGA_M80x25: 
-	case M_B40x25:     case M_C40x25:	
-	case M_B80x25:     case M_C80x25:
-	case M_ENH_B40x25: case M_ENH_C40x25: 
-	case M_ENH_B80x25: case M_ENH_C80x25:
-
-		modetable = video_mode_ptr + (scp->mode * 64);
+    /* setup video hardware for the given mode */
+    switch (scp->mode) {
+    case M_VGA_M80x60: 
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x60;
+
+    case M_VGA_C80x60: 
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x60:
+	special_modetable[2]  = 0x08;
+	special_modetable[19] = 0x47;
+	goto special_480l;
+
+    case M_VGA_M80x30:
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x30;
+
+    case M_VGA_C80x30:
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x30:
+	special_modetable[19] = 0x4f;
+special_480l:
+	special_modetable[9] |= 0xc0;
+	special_modetable[16] = 0x08;
+	special_modetable[17] = 0x3e;
+	special_modetable[26] = 0xea;
+	special_modetable[28] = 0xdf; 
+	special_modetable[31] = 0xe7;
+	special_modetable[32] = 0x04;
+	modetable = special_modetable;
+	goto setup_mode;
+
+    case M_ENH_B80x43:
+	bcopyw(video_mode_ptr+(64*M_ENH_B80x25),&special_modetable, 64);
+	goto special_80x43;
+
+    case M_ENH_C80x43:
+	bcopyw(video_mode_ptr+(64*M_ENH_C80x25),&special_modetable, 64);
+special_80x43:  
+	special_modetable[28] = 87;
+	goto special_80x50;
+
+    case M_VGA_M80x50: 
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x50;
+
+    case M_VGA_C80x50:
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x50:  
+	special_modetable[2] = 8;
+	special_modetable[19] = 7;
+	modetable = special_modetable;
+	goto setup_mode;
+
+    case M_VGA_C40x25: case M_VGA_C80x25:
+    case M_VGA_M80x25:
+    case M_B40x25:     case M_C40x25:
+    case M_B80x25:     case M_C80x25:
+    case M_ENH_B40x25: case M_ENH_C40x25:
+    case M_ENH_B80x25: case M_ENH_C80x25:
+
+	modetable = video_mode_ptr + (scp->mode * 64);
 setup_mode:
-		set_vgaregs(modetable);
-		font_size = *(modetable + 2);
-
-		/* set font type (size) */
-		switch (font_size) {
-		case 0x10:
-			outb(TSIDX, 0x03); outb(TSREG, 0x00);	/* font 0 */
-			scp->font = FONT_16;
-			break;
-		case 0x0E:
-			outb(TSIDX, 0x03); outb(TSREG, 0x05);	/* font 1 */
-			scp->font = FONT_14;
-			break;
-		default:
-		case 0x08:
-			outb(TSIDX, 0x03); outb(TSREG, 0x0A);	/* font 2 */
-			scp->font = FONT_8;
-			break;
-		}
-		break;
+	set_vgaregs(modetable);
+	font_size = *(modetable + 2);
+
+	/* set font type (size) */
+	switch (font_size) {
+	case 0x10:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x00);   /* font 0 */
+	    scp->font = FONT_16;
+	    break;
+	case 0x0E:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x05);   /* font 1 */
+	    scp->font = FONT_14;
+	    break;
+	default:
+	case 0x08:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x0A);   /* font 2 */
+	    scp->font = FONT_8;
+	    break;
+	}
+	break;
 
-	case M_BG320:      case M_CG320:      case M_BG640:
-	case M_CG320_D:    case M_CG640_E:
-	case M_CG640x350:  case M_ENH_CG640:
-	case M_BG640x480:  case M_CG640x480:  case M_VGA_CG320:
+    case M_BG320:     case M_CG320:     case M_BG640:
+    case M_CG320_D:   case M_CG640_E:
+    case M_CG640x350: case M_ENH_CG640:
+    case M_BG640x480: case M_CG640x480: case M_VGA_CG320:
  
-		set_vgaregs(video_mode_ptr + (scp->mode * 64));
-		break;
+	set_vgaregs(video_mode_ptr + (scp->mode * 64));
+	break;
 
-	default:
-		/* call user defined function XXX */
-		break;
-	}
+    default:
+	/* call user defined function XXX */
+	break;
+    }
 
-	/* set border color for this (virtual) console */
-	set_border(scp->border);
-	return;
+    /* set border color for this (virtual) console */
+    set_border(scp->border);
+    return;
 }
 
-static void 
+void 
 set_border(int color)
 {
-	inb(crtc_addr+6); 				/* reset flip-flop */
-	outb(ATC, 0x11); outb(ATC, color); 
-	inb(crtc_addr+6); 				/* reset flip-flop */
-	outb(ATC, 0x20);				/* enable Palette */
+    inb(crtc_addr+6);               /* reset flip-flop */
+    outb(ATC, 0x11); outb(ATC, color); 
+    inb(crtc_addr+6);               /* reset flip-flop */
+    outb(ATC, 0x20);                /* enable Palette */
 }
 
 static void
 set_vgaregs(char *modetable)
 {
-	int i, s = splhigh();
+    int i, s = splhigh();
 
-	outb(TSIDX, 0x00); outb(TSREG, 0x01);	/* stop sequencer */
-	outb(TSIDX, 0x07); outb(TSREG, 0x00);	/* unlock registers */
-	for (i=0; i<4; i++) {			/* program sequencer */
-		outb(TSIDX, i+1); 
-		outb(TSREG, modetable[i+5]);
-	}
-	outb(MISC, modetable[9]);		/* set dot-clock */
-	outb(TSIDX, 0x00); outb(TSREG, 0x03);	/* start sequencer */
-	outb(crtc_addr, 0x11);
-	outb(crtc_addr+1, inb(crtc_addr+1) & 0x7F);
-	for (i=0; i<25; i++) {			/* program crtc */
-		outb(crtc_addr, i); 
-		if (i == 14 || i == 15)		/* no hardware cursor */
-			outb(crtc_addr+1, 0xff);
-		else
-			outb(crtc_addr+1, modetable[i+10]);
-	}
-	inb(crtc_addr+6); 			/* reset flip-flop */
-	for (i=0; i<20; i++) {			/* program attribute ctrl */
-		outb(ATC, i); 
-		outb(ATC, modetable[i+35]);
-	}
-	for (i=0; i<9; i++) {			/* program graph data ctrl */
-		outb(GDCIDX, i); 
-		outb(GDCREG, modetable[i+55]);
-	}
-	inb(crtc_addr+6); 			/* reset flip-flop */
-	outb(ATC ,0x20);			/* enable palette */
-	splx(s);
+    outb(TSIDX, 0x00); outb(TSREG, 0x01);   	/* stop sequencer */
+    outb(TSIDX, 0x07); outb(TSREG, 0x00);   	/* unlock registers */
+    for (i=0; i<4; i++) {           		/* program sequencer */
+	outb(TSIDX, i+1); 
+	outb(TSREG, modetable[i+5]);
+    }
+    outb(MISC, modetable[9]);       		/* set dot-clock */
+    outb(TSIDX, 0x00); outb(TSREG, 0x03);   	/* start sequencer */
+    outb(crtc_addr, 0x11);
+    outb(crtc_addr+1, inb(crtc_addr+1) & 0x7F);
+    for (i=0; i<25; i++) {          		/* program crtc */
+	outb(crtc_addr, i); 
+	if (i == 14 || i == 15)     		/* no hardware cursor */
+	    outb(crtc_addr+1, 0xff);
+	else
+	    outb(crtc_addr+1, modetable[i+10]);
+    }
+    inb(crtc_addr+6);           		/* reset flip-flop */
+    for (i=0; i<20; i++) {          		/* program attribute ctrl */
+	outb(ATC, i); 
+	outb(ATC, modetable[i+35]);
+    }
+    for (i=0; i<9; i++) {           		/* program graph data ctrl */
+	outb(GDCIDX, i); 
+	outb(GDCREG, modetable[i+55]);
+    }
+    inb(crtc_addr+6);           		/* reset flip-flop */
+    outb(ATC ,0x20);            		/* enable palette */
+    splx(s);
 }
 
 static void
 set_font_mode()
 {
-	/* setup vga for loading fonts (graphics plane mode) */
-	inb(crtc_addr+6);				/* reset flip/flop */
-	outb(ATC, 0x30); outb(ATC, 0x01);
+    /* setup vga for loading fonts (graphics plane mode) */
+    inb(crtc_addr+6);
+    outb(ATC, 0x30); outb(ATC, 0x01);
 #if SLOW_VGA
-	outb(TSIDX, 0x02); outb(TSREG, 0x04);
-	outb(TSIDX, 0x04); outb(TSREG, 0x06);
-	outb(GDCIDX, 0x04); outb(GDCREG, 0x02);
-	outb(GDCIDX, 0x05); outb(GDCREG, 0x00);
-	outb(GDCIDX, 0x06); outb(GDCREG, 0x05);	
+    outb(TSIDX, 0x02); outb(TSREG, 0x04);
+    outb(TSIDX, 0x04); outb(TSREG, 0x06);
+    outb(GDCIDX, 0x04); outb(GDCREG, 0x02);
+    outb(GDCIDX, 0x05); outb(GDCREG, 0x00);
+    outb(GDCIDX, 0x06); outb(GDCREG, 0x05); 
 #else
-	outw(TSIDX, 0x0402);
-	outw(TSIDX, 0x0604);
-	outw(GDCIDX, 0x0204);
-	outw(GDCIDX, 0x0005);
-	outw(GDCIDX, 0x0506);				/* addr = a0000, 64kb */
+    outw(TSIDX, 0x0402);
+    outw(TSIDX, 0x0604);
+    outw(GDCIDX, 0x0204);
+    outw(GDCIDX, 0x0005);
+    outw(GDCIDX, 0x0506);               /* addr = a0000, 64kb */
 #endif
 }
 
 static void
 set_normal_mode()
 {
-	int s = splhigh();
+    int s = splhigh();
 
-	/* setup vga for normal operation mode again */
-	inb(crtc_addr+6);				/* reset flip/flop */
-	outb(ATC, 0x30); outb(ATC, 0x0C);
+    /* setup vga for normal operation mode again */
+    inb(crtc_addr+6);
+    outb(ATC, 0x30); outb(ATC, 0x0C);
 #if SLOW_VGA
-	outb(TSIDX, 0x02); outb(TSREG, 0x03);
-	outb(TSIDX, 0x04); outb(TSREG, 0x02);
-	outb(GDCIDX, 0x04); outb(GDCREG, 0x00);
-	outb(GDCIDX, 0x05); outb(GDCREG, 0x10);
-	if (crtc_addr == MONO_BASE) {
-		outb(GDCIDX, 0x06); outb(GDCREG, 0x0A);	/* addr = b0000, 32kb */
-	}
-	else {
-		outb(GDCIDX, 0x06); outb(GDCREG, 0x0E);	/* addr = b8000, 32kb */
-	}
+    outb(TSIDX, 0x02); outb(TSREG, 0x03);
+    outb(TSIDX, 0x04); outb(TSREG, 0x02);
+    outb(GDCIDX, 0x04); outb(GDCREG, 0x00);
+    outb(GDCIDX, 0x05); outb(GDCREG, 0x10);
+    if (crtc_addr == MONO_BASE) {
+	outb(GDCIDX, 0x06); outb(GDCREG, 0x0A); /* addr = b0000, 32kb */
+    }
+    else {
+	outb(GDCIDX, 0x06); outb(GDCREG, 0x0E); /* addr = b8000, 32kb */
+    }
 #else
-	outw(TSIDX, 0x0302);
-	outw(TSIDX, 0x0204);
-	outw(GDCIDX, 0x0004);
-	outw(GDCIDX, 0x1005);
-	if (crtc_addr == MONO_BASE)
-		outw(GDCIDX, 0x0A06);			/* addr = b0000, 32kb */
-	else
-		outw(GDCIDX, 0x0E06);			/* addr = b8000, 32kb */
+    outw(TSIDX, 0x0302);
+    outw(TSIDX, 0x0204);
+    outw(GDCIDX, 0x0004);
+    outw(GDCIDX, 0x1005);
+    if (crtc_addr == MONO_BASE)
+	outw(GDCIDX, 0x0A06);           /* addr = b0000, 32kb */
+    else
+	outw(GDCIDX, 0x0E06);           /* addr = b8000, 32kb */
 #endif
-	splx(s);
+    splx(s);
 }
 
 static void 
 copy_font(int operation, int font_type, char* font_image)
 {
-	int ch, line, segment, fontsize;
-	u_char val;
-
-	switch (font_type) {
-	default:
-	case FONT_8:
-		segment = 0x8000;
-		fontsize = 8;
-		break;
-	case FONT_14:
-		segment = 0x4000;
-		fontsize = 14;
-		break;
-	case FONT_16:
-		segment = 0x0000;
-		fontsize = 16;
-		break;
-	}
-	outb(TSIDX, 0x01); val = inb(TSREG); 		/* disable screen */
-	outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-	set_font_mode();
-	for (ch=0; ch < 256; ch++) 
-	    for (line=0; line < fontsize; line++) 
-		if (operation)
-		    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line) =
-					font_image[(ch*fontsize)+line];	
-		else
-		    font_image[(ch*fontsize)+line] =
-		    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line);
-	set_normal_mode();
-	outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);	/* enable screen */
+    int ch, line, segment, fontsize;
+    u_char val;
+
+    switch (font_type) {
+    default:
+    case FONT_8:
+	segment = 0x8000;
+	fontsize = 8;
+	break;
+    case FONT_14:
+	segment = 0x4000;
+	fontsize = 14;
+	break;
+    case FONT_16:
+	segment = 0x0000;
+	fontsize = 16;
+	break;
+    }
+    outb(TSIDX, 0x01); val = inb(TSREG);        /* disable screen */
+    outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+    set_font_mode();
+    for (ch=0; ch < 256; ch++) 
+	for (line=0; line < fontsize; line++) 
+	if (operation)
+	    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line) =
+		    font_image[(ch*fontsize)+line]; 
+	else
+	    font_image[(ch*fontsize)+line] =
+	    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line);
+    set_normal_mode();
+    outb(TSIDX, 0x01); outb(TSREG, val & 0xDF); /* enable screen */
 }
 
 static void
 draw_mouse_image(scr_stat *scp)
 {
-	caddr_t address;
-	int i, font_size;
-	char *font_buffer;
-	u_short buffer[32];
-	u_short xoffset, yoffset;
-	u_short *crt_pos = Crtat + (scp->mouse_pos - scp->scr_buf);
-
-	xoffset = scp->mouse_xpos % 8;
-	switch (scp->font) {
-	default:
-	case FONT_8:
-		font_size = 8;
-		font_buffer = font_8;
-		yoffset = scp->mouse_ypos % 8;
-		address = (caddr_t)VIDEOMEM+0x8000;
-		break;
-	case FONT_14:
-		font_size = 14;
-		font_buffer = font_14;
-		yoffset = scp->mouse_ypos % 14;
-		address = (caddr_t)VIDEOMEM+0x4000;
-		break;
-	case FONT_16:
-		font_size = 16;
-		font_buffer = font_16;
-		yoffset = scp->mouse_ypos % 16;
-		address = (caddr_t)VIDEOMEM;
-		break;
-	}
+    caddr_t address;
+    int i, font_size;
+    char *font_buffer;
+    u_short buffer[32];
+    u_short xoffset, yoffset;
+    u_short *crt_pos = Crtat + (scp->mouse_pos - scp->scr_buf);
+
+    xoffset = scp->mouse_xpos % 8;
+    switch (scp->font) {
+    default:
+    case FONT_8:
+	font_size = 8;
+	font_buffer = font_8;
+	yoffset = scp->mouse_ypos % 8;
+	address = (caddr_t)VIDEOMEM+0x8000;
+	break;
+    case FONT_14:
+	font_size = 14;
+	font_buffer = font_14;
+	yoffset = scp->mouse_ypos % 14;
+	address = (caddr_t)VIDEOMEM+0x4000;
+	break;
+    case FONT_16:
+	font_size = 16;
+	font_buffer = font_16;
+	yoffset = scp->mouse_ypos % 16;
+	address = (caddr_t)VIDEOMEM;
+	break;
+    }
 
-	bcopyw(font_buffer+((*(scp->mouse_pos) & 0xff)*font_size),
-	       &scp->mouse_cursor[0], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+1) & 0xff)*font_size),
-	       &scp->mouse_cursor[32], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize) & 0xff)*font_size),
-	       &scp->mouse_cursor[64], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize+1) & 0xff)*font_size),
-	       &scp->mouse_cursor[96], font_size);
-
-	for (i=0; i<font_size; i++) {
-		buffer[i] = 
-			scp->mouse_cursor[i]<<8 | scp->mouse_cursor[i+32];
-		buffer[i+font_size] = 
-			scp->mouse_cursor[i+64]<<8 | scp->mouse_cursor[i+96];
-	}
-	for (i=0; i<16; i++) {
-		buffer[i+yoffset] =
-			( buffer[i+yoffset] 
-			 & ~(mouse_and_mask[i] >> xoffset))
-			| (mouse_or_mask[i] >> xoffset);
-	}
-	for (i=0; i<font_size; i++) {
-		scp->mouse_cursor[i] = (buffer[i] & 0xff00) >> 8;
-		scp->mouse_cursor[i+32] = buffer[i] & 0xff;
-		scp->mouse_cursor[i+64] = (buffer[i+font_size] & 0xff00) >> 8;
-		scp->mouse_cursor[i+96] = buffer[i+font_size] & 0xff;
-	}
-	/*
-	 * if we didn't update entire screen, restore old mouse position
-	 * and check if we overwrote the cursor location..
-	 */
-	if ((scp->status & UPDATE_MOUSE) && !(scp->status & UPDATE_SCREEN)) {
-	    u_short *ptr = scp->scr_buf + (scp->mouse_oldpos - Crtat);
-	    if (crt_pos != scp->mouse_oldpos) {
-		*(scp->mouse_oldpos) = scp->mouse_saveunder[0];
-		*(scp->mouse_oldpos+1) = scp->mouse_saveunder[1];
-		*(scp->mouse_oldpos+scp->xsize) = scp->mouse_saveunder[2];
-		*(scp->mouse_oldpos+scp->xsize+1) = scp->mouse_saveunder[3];
-	    }
-	    scp->mouse_saveunder[0] = *(scp->mouse_pos);
-	    scp->mouse_saveunder[1] = *(scp->mouse_pos+1);
-	    scp->mouse_saveunder[2] = *(scp->mouse_pos+scp->xsize);
-	    scp->mouse_saveunder[3] = *(scp->mouse_pos+scp->xsize+1);
-	    if ((scp->cursor_pos == (ptr)) ||
-		(scp->cursor_pos == (ptr+1)) ||
-		(scp->cursor_pos == (ptr+scp->xsize)) ||
-		(scp->cursor_pos == (ptr+scp->xsize+1)) ||
-		(scp->cursor_pos == (scp->mouse_pos)) ||
-		(scp->cursor_pos == (scp->mouse_pos+1)) ||
-		(scp->cursor_pos == (scp->mouse_pos+scp->xsize)) ||
-		(scp->cursor_pos == (scp->mouse_pos+scp->xsize+1)))
-		    scp->status &= ~CURSOR_SHOWN;
-	}
-	scp->mouse_oldpos = crt_pos;
-	while (!(inb(crtc_addr+6) & 0x08)) /* wait for vertical retrace */ ;
-	*(crt_pos) = *(scp->mouse_pos)&0xff00|0xd0;
-	*(crt_pos+1) = *(scp->mouse_pos+1)&0xff00|0xd1;
-	*(crt_pos+scp->xsize) = *(scp->mouse_pos+scp->xsize)&0xff00|0xd2;
-	*(crt_pos+scp->xsize+1) = *(scp->mouse_pos+scp->xsize+1)&0xff00|0xd3;
-	set_font_mode();
-	bcopy(scp->mouse_cursor,
-	      (char *)pa_to_va(address) + 0xd0 * 32, 128);
-	set_normal_mode();
+    bcopyw(font_buffer+((*(scp->mouse_pos) & 0xff)*font_size),
+	   &scp->mouse_cursor[0], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+1) & 0xff)*font_size),
+	   &scp->mouse_cursor[32], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize) & 0xff)*font_size),
+	   &scp->mouse_cursor[64], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize+1) & 0xff)*font_size),
+	   &scp->mouse_cursor[96], font_size);
+
+    for (i=0; i<font_size; i++) {
+	buffer[i] = scp->mouse_cursor[i]<<8 | scp->mouse_cursor[i+32];
+	buffer[i+font_size]=scp->mouse_cursor[i+64]<<8|scp->mouse_cursor[i+96];
+    }
+    for (i=0; i<16; i++) {
+	buffer[i+yoffset] =
+	    ( buffer[i+yoffset] & ~(mouse_and_mask[i] >> xoffset))
+	    | (mouse_or_mask[i] >> xoffset);
+    }
+    for (i=0; i<font_size; i++) {
+	scp->mouse_cursor[i] = (buffer[i] & 0xff00) >> 8;
+	scp->mouse_cursor[i+32] = buffer[i] & 0xff;
+	scp->mouse_cursor[i+64] = (buffer[i+font_size] & 0xff00) >> 8;
+	scp->mouse_cursor[i+96] = buffer[i+font_size] & 0xff;
+    }
+    /*
+     * if we didn't update entire screen, restore old mouse position
+     * and check if we overwrote the cursor location..
+     */
+    if ((scp->status & UPDATE_MOUSE) && !(scp->status & UPDATE_SCREEN)) {
+	u_short *ptr = scp->scr_buf + (scp->mouse_oldpos - Crtat);
+
+	if (crt_pos != scp->mouse_oldpos) {
+	    *(scp->mouse_oldpos) = scp->mouse_saveunder[0];
+	    *(scp->mouse_oldpos+1) = scp->mouse_saveunder[1];
+	    *(scp->mouse_oldpos+scp->xsize) = scp->mouse_saveunder[2];
+	    *(scp->mouse_oldpos+scp->xsize+1) = scp->mouse_saveunder[3];
+	}
+	scp->mouse_saveunder[0] = *(scp->mouse_pos);
+	scp->mouse_saveunder[1] = *(scp->mouse_pos+1);
+	scp->mouse_saveunder[2] = *(scp->mouse_pos+scp->xsize);
+	scp->mouse_saveunder[3] = *(scp->mouse_pos+scp->xsize+1);
+	if ((scp->cursor_pos == (ptr)) ||
+	    (scp->cursor_pos == (ptr+1)) ||
+	    (scp->cursor_pos == (ptr+scp->xsize)) ||
+	    (scp->cursor_pos == (ptr+scp->xsize+1)) ||
+	    (scp->cursor_pos == (scp->mouse_pos)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+1)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+scp->xsize)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+scp->xsize+1)))
+	    scp->status &= ~CURSOR_SHOWN;
+    }
+    scp->mouse_oldpos = crt_pos;
+    while (!(inb(crtc_addr+6) & 0x08)) /* wait for vertical retrace */ ;
+    *(crt_pos) = *(scp->mouse_pos)&0xff00|0xd0;
+    *(crt_pos+1) = *(scp->mouse_pos+1)&0xff00|0xd1;
+    *(crt_pos+scp->xsize) = *(scp->mouse_pos+scp->xsize)&0xff00|0xd2;
+    *(crt_pos+scp->xsize+1) = *(scp->mouse_pos+scp->xsize+1)&0xff00|0xd3;
+    set_font_mode();
+    bcopy(scp->mouse_cursor, (char *)pa_to_va(address) + 0xd0 * 32, 128);
+    set_normal_mode();
 }
 
 static void 
 save_palette(void)
 {
-	int i;
+    int i;
 
-	outb(PALRADR, 0x00);	
-	for (i=0x00; i<0x300; i++)            
-		palette[i] = inb(PALDATA);
-	inb(crtc_addr+6);			/* reset flip/flop */
+    outb(PALRADR, 0x00);    
+    for (i=0x00; i<0x300; i++)            
+	palette[i] = inb(PALDATA);
+    inb(crtc_addr+6);           /* reset flip/flop */
 }
 
-static void 
+void 
 load_palette(void)
 {
-	int i;
-
-	outb(PIXMASK, 0xFF);			/* no pixelmask */
-	outb(PALWADR, 0x00);	
-	for (i=0x00; i<0x300; i++)            
-		 outb(PALDATA, palette[i]);
-	inb(crtc_addr+6);			/* reset flip/flop */
-	outb(ATC, 0x20);			/* enable palette */
+    int i;
+
+    outb(PIXMASK, 0xFF);            /* no pixelmask */
+    outb(PALWADR, 0x00);    
+    for (i=0x00; i<0x300; i++)            
+	 outb(PALDATA, palette[i]);
+    inb(crtc_addr+6);           /* reset flip/flop */
+    outb(ATC, 0x20);            /* enable palette */
 }
 
 static void
 do_bell(scr_stat *scp, int pitch, int duration)
 {
-	if (scp == cur_console) {
-		if (configuration & VISUAL_BELL) {
-			if (blink_in_progress)
-				return;
-			blink_in_progress = 4;
-			blink_screen(scp);
-			timeout((timeout_func_t)blink_screen, scp, hz/10);
-		}	
-		else
-			sysbeep(pitch, duration);
-	}
+    if (scp == cur_console) {
+	if (configuration & VISUAL_BELL) {
+	    if (blink_in_progress)
+		return;
+	    blink_in_progress = 4;
+	    blink_screen(scp);
+	    timeout((timeout_func_t)blink_screen, scp, hz/10);
+	}   
+	else
+	    sysbeep(pitch, duration);
+    }
 }
 
 static void
 blink_screen(scr_stat *scp)
 {
-	if (blink_in_progress > 1) {
-		if (blink_in_progress & 1)
-			fillw(kernel_default.std_attr | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-		else
-			fillw(kernel_default.rev_attr | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-		blink_in_progress--;
-		timeout((timeout_func_t)blink_screen, scp, hz/10);
-	}
-	else {
-		scp->status |= UPDATE_SCREEN;
-		blink_in_progress = FALSE;
-		if (delayed_next_scr)
-			switch_scr(scp, delayed_next_scr - 1);
-	}
+    if (blink_in_progress > 1) {
+	if (blink_in_progress & 1)
+	    fillw(kernel_default.std_attr | scr_map[0x20],
+		  Crtat, scp->xsize * scp->ysize);
+	else
+	    fillw(kernel_default.rev_attr | scr_map[0x20],
+		  Crtat, scp->xsize * scp->ysize);
+	blink_in_progress--;
+	timeout((timeout_func_t)blink_screen, scp, hz/10);
+    }
+    else {
+	scp->status |= UPDATE_SCREEN;
+	blink_in_progress = FALSE;
+	if (delayed_next_scr)
+	    switch_scr(scp, delayed_next_scr - 1);
+    }
 }
 
 #endif /* NSC */
diff --git a/sys/dev/syscons/syscons.h b/sys/dev/syscons/syscons.h
new file mode 100644
index 0000000..546b2de
--- /dev/null
+++ b/sys/dev/syscons/syscons.h
@@ -0,0 +1,203 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+/* vm things */
+#define	ISMAPPED(pa, width) \
+	(((pa) <= (u_long)0x1000 - (width)) \
+	 || ((pa) >= 0xa0000 && (pa) <= 0x100000 - (width)))
+#define	pa_to_va(pa)	(KERNBASE + (pa))	/* works if ISMAPPED(pa...) */
+
+/* printable chars */
+#define PRINTABLE(ch)	(ch>0x1B || (ch>0x0d && ch<0x1b) || ch<0x07)
+
+/* status flags */
+#define LOCK_KEY_MASK	0x0000F
+#define LED_MASK	0x00007
+#define UNKNOWN_MODE	0x00010
+#define KBD_RAW_MODE	0x00020
+#define SWITCH_WAIT_REL	0x00040
+#define SWITCH_WAIT_ACQ	0x00080
+#define BUFFER_SAVED	0x00100
+#define CURSOR_ENABLED 	0x00200
+#define CURSOR_SHOWN 	0x00400
+#define MOUSE_ENABLED	0x00800
+#define UPDATE_MOUSE	0x01000
+#define UPDATE_SCREEN	0x02000
+
+/* configuration flags */
+#define VISUAL_BELL	0x00001
+#define BLINK_CURSOR	0x00002
+#define CHAR_CURSOR	0x00004
+
+/* video hardware memory addresses */
+#define VIDEOMEM	0x000A0000
+
+/* misc defines */
+#define FALSE		0
+#define TRUE		1
+#define MAX_ESC_PAR 	5
+#define	LOAD		1
+#define SAVE		0
+#define	COL		80
+#define	ROW		25
+#define BELL_DURATION	5
+#define BELL_PITCH	800
+#define TIMER_FREQ	1193182			/* should be in isa.h */
+#define CONSOLE_BUFSIZE 1024
+#define PCBURST		128
+#define FONT_8		0x001
+#define FONT_14		0x002
+#define FONT_16		0x004
+#define HISTORY_SIZE	100*80
+
+/* defines related to hardware addresses */
+#define	MONO_BASE	0x3B4			/* crt controller base mono */
+#define	COLOR_BASE	0x3D4			/* crt controller base color */
+#define MISC		0x3C2			/* misc output register */
+#define ATC		IO_VGA+0x00		/* attribute controller */
+#define TSIDX		IO_VGA+0x04		/* timing sequencer idx */
+#define TSREG		IO_VGA+0x05		/* timing sequencer data */
+#define PIXMASK		IO_VGA+0x06		/* pixel write mask */
+#define PALRADR		IO_VGA+0x07		/* palette read address */
+#define PALWADR		IO_VGA+0x08		/* palette write address */
+#define PALDATA		IO_VGA+0x09		/* palette data register */
+#define GDCIDX		IO_VGA+0x0E		/* graph data controller idx */
+#define GDCREG		IO_VGA+0x0F		/* graph data controller data */
+
+/* special characters */
+#define cntlc	0x03	
+#define cntld	0x04
+#define bs	0x08
+#define lf	0x0a
+#define cr	0x0d	
+#define del	0x7f	
+
+typedef struct term_stat {
+	int 		esc;			/* processing escape sequence */
+	int 		num_param;		/* # of parameters to ESC */
+	int	 	last_param;		/* last parameter # */
+	int 		param[MAX_ESC_PAR];	/* contains ESC parameters */
+	int 		cur_attr;		/* current attributes */
+	int 		std_attr;		/* normal attributes */
+	int 		rev_attr;		/* reverse attributes */
+} term_stat;
+
+typedef struct scr_stat {
+	u_short 	*scr_buf;		/* buffer when off screen */
+	int 		xpos;			/* current X position */
+	int 		ypos;			/* current Y position */
+	int 		xsize;			/* X size */
+	int 		ysize;			/* Y size */
+	term_stat 	term;			/* terminal emulation stuff */
+	int	 	status;			/* status (bitfield) */
+	u_short 	*cursor_pos;		/* cursor buffer position */
+	u_short		cursor_saveunder;	/* saved chars under cursor */
+	char		cursor_start;		/* cursor start line # */
+	char		cursor_end;		/* cursor end line # */
+	u_short		*mouse_pos;		/* mouse buffer position */
+	u_short		*mouse_oldpos;		/* mouse old buffer position */
+	u_short		mouse_saveunder[4];	/* saved chars under mouse */
+	short		mouse_xpos;		/* mouse x coordinate */
+	short		mouse_ypos;		/* mouse y coordinate */
+	u_char		mouse_cursor[128];	/* mouse cursor bitmap store */
+	u_short		bell_duration;
+	u_short		bell_pitch;
+	u_char		border;			/* border color */
+	u_char	 	mode;			/* mode */
+	u_char		font;			/* font on this screen */
+	pid_t 		pid;			/* pid of controlling proc */
+	struct proc 	*proc;			/* proc* of controlling proc */
+	struct vt_mode 	smode;			/* switch mode */
+	u_short		*history;		/* circular history buffer */
+	u_short		*history_head;		/* current head position */
+	u_short		*history_pos;		/* position shown on screen */
+	u_short		*history_save;		/* save area index */
+	int		history_size;		/* size of history buffer */
+#if NAPM > 0
+	struct apmhook  r_hook;			/* reconfiguration support */
+#endif
+} scr_stat;
+
+typedef struct default_attr {
+	int             std_attr;               /* normal attributes */
+	int 		rev_attr;		/* reverse attributes */
+} default_attr;
+
+/* function prototypes */
+int scprobe(struct isa_device *dev);
+int scattach(struct isa_device *dev);
+int scopen(dev_t dev, int flag, int mode, struct proc *p);
+int scclose(dev_t dev, int flag, int mode, struct proc *p);
+int scread(dev_t dev, struct uio *uio, int flag);
+int scwrite(dev_t dev, struct uio *uio, int flag);
+int scparam(struct tty *tp, struct termios *t);
+int scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p);
+void scxint(dev_t dev);
+void scstart(struct tty *tp);
+void pccnprobe(struct consdev *cp);
+void pccninit(struct consdev *cp);
+void pccnputc(dev_t dev, char c);
+int pccngetc(dev_t dev);
+int pccncheckc(dev_t dev);
+void scintr(int unit);
+int pcmmap(dev_t dev, int offset, int nprot);
+static void scinit(void);
+static u_int scgetc(int noblock);
+static struct tty *get_tty_ptr(dev_t dev);
+static scr_stat *get_scr_stat(dev_t dev);
+static scr_stat *alloc_scp();
+static void init_scp(scr_stat *scp);
+static int get_scr_num();
+static void scrn_timer();
+static void clear_screen(scr_stat *scp);
+static int switch_scr(scr_stat *scp, u_int next_scr);
+static void exchange_scr(void);
+static inline void move_crsr(scr_stat *scp, int x, int y);
+static void scan_esc(scr_stat *scp, u_char c);
+static inline void draw_cursor(scr_stat *scp, int show);
+static void ansi_put(scr_stat *scp, u_char *buf, int len);
+static u_char *get_fstr(u_int c, u_int *len);
+static void update_leds(int which);
+static void history_to_screen(scr_stat *scp);
+static int history_up_line(scr_stat *scp);
+static int history_down_line(scr_stat *scp);
+static void kbd_wait(void);
+static void kbd_cmd(u_char command);
+static void set_mode(scr_stat *scp);
+       void set_border(int color);
+static void set_vgaregs(char *modetable);
+static void set_font_mode();
+static void set_normal_mode();
+static void copy_font(int operation, int font_type, char* font_image);
+static void draw_mouse_image(scr_stat *scp);
+static void save_palette(void);
+       void load_palette(void);
+static void do_bell(scr_stat *scp, int pitch, int duration);
+static void blink_screen(scr_stat *scp);
diff --git a/sys/i386/isa/syscons.c b/sys/i386/isa/syscons.c
index 102cc0e..1671125 100644
--- a/sys/i386/isa/syscons.c
+++ b/sys/i386/isa/syscons.c
@@ -1,47 +1,35 @@
 /*-
  * Copyright (c) 1992-1995 Søren Schmidt
- * Copyright (c) 1990 The Regents of the University of California.
  * All rights reserved.
  *
- * This code is derived from software contributed to Berkeley by
- * William Jolitz and Don Ahn.
- *
  * 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,
+ *    notice, this list of conditions and the following disclaimer 
  *    in this position and unchanged.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
  *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- *	$Id: syscons.c,v 1.102 1995/02/14 14:37:53 sos Exp $
+ *  $Id$
  */
 
 #include "sc.h"
-
 #if NSC > 0
-
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/conf.h>
@@ -68,6 +56,7 @@
 #include <i386/isa/timerreg.h>
 #include <i386/isa/kbdtables.h>
 #include <i386/i386/cons.h>
+#include <i386/isa/syscons.h>
 
 #if !defined(MAXCONS)
 #define MAXCONS 16
@@ -78,1484 +67,1109 @@
 #endif 
 
 /* this may break on older VGA's but is usefull on real 32 bit systems */
-#define	bcopyw	bcopy		
-
-/* vm things */
-#define	ISMAPPED(pa, width) \
-	(((pa) <= (u_long)0x1000 - (width)) \
-	 || ((pa) >= 0xa0000 && (pa) <= 0x100000 - (width)))
-#define	pa_to_va(pa)	(KERNBASE + (pa))	/* works if ISMAPPED(pa...) */
-
-/* printable chars */
-#define PRINTABLE(ch)	(ch>0x1B || (ch>0x0d && ch<0x1b) || ch<0x07)
-
-/* status flags */
-#define LOCK_KEY_MASK	0x0000F
-#define LED_MASK	0x00007
-#define UNKNOWN_MODE	0x00010
-#define KBD_RAW_MODE	0x00020
-#define SWITCH_WAIT_REL	0x00040
-#define SWITCH_WAIT_ACQ	0x00080
-#define BUFFER_SAVED	0x00100
-#define CURSOR_ENABLED 	0x00200
-#define CURSOR_SHOWN 	0x00400
-#define MOUSE_ENABLED	0x00800
-#define UPDATE_MOUSE	0x01000
-#define UPDATE_SCREEN	0x02000
-
-/* configuration flags */
-#define VISUAL_BELL	0x00001
-#define BLINK_CURSOR	0x00002
-#define CHAR_CURSOR	0x00004
-
-/* video hardware memory addresses */
-#define VIDEOMEM	0x000A0000
-
-/* misc defines */
-#define FALSE		0
-#define TRUE		1
-#define MAX_ESC_PAR 	5
-#define	LOAD		1
-#define SAVE		0
-#define	COL		80
-#define	ROW		25
-#define BELL_DURATION	5
-#define BELL_PITCH	800
-#define TIMER_FREQ	1193182			/* should be in isa.h */
-#define CONSOLE_BUFSIZE 1024
-#define PCBURST		128
-#define FONT_8		0x001
-#define FONT_14		0x002
-#define FONT_16		0x004
-#define HISTORY_SIZE	100*80
-
-/* defines related to hardware addresses */
-#define	MONO_BASE	0x3B4			/* crt controller base mono */
-#define	COLOR_BASE	0x3D4			/* crt controller base color */
-#define MISC		0x3C2			/* misc output register */
-#define ATC		IO_VGA+0x00		/* attribute controller */
-#define TSIDX		IO_VGA+0x04		/* timing sequencer idx */
-#define TSREG		IO_VGA+0x05		/* timing sequencer data */
-#define PIXMASK		IO_VGA+0x06		/* pixel write mask */
-#define PALRADR		IO_VGA+0x07		/* palette read address */
-#define PALWADR		IO_VGA+0x08		/* palette write address */
-#define PALDATA		IO_VGA+0x09		/* palette data register */
-#define GDCIDX		IO_VGA+0x0E		/* graph data controller idx */
-#define GDCREG		IO_VGA+0x0F		/* graph data controller data */
-
-/* special characters */
-#define cntlc	0x03	
-#define cntld	0x04
-#define bs	0x08
-#define lf	0x0a
-#define cr	0x0d	
-#define del	0x7f	
-
-typedef struct term_stat {
-	int 		esc;			/* processing escape sequence */
-	int 		num_param;		/* # of parameters to ESC */
-	int	 	last_param;		/* last parameter # */
-	int 		param[MAX_ESC_PAR];	/* contains ESC parameters */
-	int 		cur_attr;		/* current attributes */
-	int 		std_attr;		/* normal attributes */
-	int 		rev_attr;		/* reverse attributes */
-} term_stat;
-
-typedef struct scr_stat {
-	u_short 	*scr_buf;		/* buffer when off screen */
-	int 		xpos;			/* current X position */
-	int 		ypos;			/* current Y position */
-	int 		xsize;			/* X size */
-	int 		ysize;			/* Y size */
-	term_stat 	term;			/* terminal emulation stuff */
-	int	 	status;			/* status (bitfield) */
-	u_short 	*cursor_pos;		/* cursor buffer position */
-	u_short		cursor_saveunder;	/* saved chars under cursor */
-	char		cursor_start;		/* cursor start line # */
-	char		cursor_end;		/* cursor end line # */
-	u_short		*mouse_pos;		/* mouse buffer position */
-	u_short		*mouse_oldpos;		/* mouse old buffer position */
-	u_short		mouse_saveunder[4];	/* saved chars under mouse */
-	short		mouse_xpos;		/* mouse x coordinate */
-	short		mouse_ypos;		/* mouse y coordinate */
-	u_char		mouse_cursor[128];	/* mouse cursor bitmap store */
-	u_short		bell_duration;
-	u_short		bell_pitch;
-	u_char		border;			/* border color */
-	u_char	 	mode;			/* mode */
-	u_char		font;			/* font on this screen */
-	pid_t 		pid;			/* pid of controlling proc */
-	struct proc 	*proc;			/* proc* of controlling proc */
-	struct vt_mode 	smode;			/* switch mode */
-	u_short		*history;		/* circular history buffer */
-	u_short		*history_head;		/* current head position */
-	u_short		*history_pos;		/* position shown on screen */
-	u_short		*history_save;		/* save area index */
-	int		history_size;		/* size of history buffer */
-#if NAPM > 0
-	struct apmhook  r_hook;			/* reconfiguration support */
-#endif /* NAPM > 0 */
-} scr_stat;
-
-typedef struct default_attr {
-	int             std_attr;               /* normal attributes */
-	int 		rev_attr;		/* reverse attributes */
-} default_attr;
+#define bcopyw  bcopy       
 
 static default_attr user_default = {
-	(FG_LIGHTGREY | BG_BLACK) << 8,
-	(FG_BLACK | BG_LIGHTGREY) << 8
+    (FG_LIGHTGREY | BG_BLACK) << 8,
+    (FG_BLACK | BG_LIGHTGREY) << 8
 };
 
 static default_attr kernel_default = {
-	(FG_WHITE | BG_BLACK) << 8,
-	(FG_BLACK | BG_LIGHTGREY) << 8
+    (FG_WHITE | BG_BLACK) << 8,
+    (FG_BLACK | BG_LIGHTGREY) << 8
 };
 
-static	scr_stat	main_console;
-static	scr_stat	*console[MAXCONS];
-static	scr_stat	*cur_console;
-static	scr_stat	*new_scp, *old_scp;
-static	term_stat	kernel_console; 
-static	default_attr	*current_default;
-static 	char 		init_done = FALSE;
-static	char		switch_in_progress = FALSE;
-static	char		blink_in_progress = FALSE;
-static	char 		write_in_progress = FALSE;
-static	u_int		crtc_addr = MONO_BASE;
-static	char		crtc_vga = FALSE;
-static 	u_char		shfts = 0, ctls = 0, alts = 0, agrs = 0, metas = 0;
-static 	u_char		nlkcnt = 0, clkcnt = 0, slkcnt = 0, alkcnt = 0;
-static	char		*font_8 = NULL, *font_14 = NULL, *font_16 = NULL;
-static  int		fonts_loaded = 0;
-static	char		palette[3*256];
-static 	const u_int 	n_fkey_tab = sizeof(fkey_tab) / sizeof(*fkey_tab);
+static  scr_stat    	main_console;
+static  scr_stat    	*console[MAXCONS];
+	scr_stat    	*cur_console;
+static  scr_stat    	*new_scp, *old_scp;
+static  term_stat   	kernel_console; 
+static  default_attr    *current_default;
+static  char        	init_done = FALSE;
+static  char        	switch_in_progress = FALSE;
+static  char        	blink_in_progress = FALSE;
+static  char        	write_in_progress = FALSE;
+	u_int       	crtc_addr = MONO_BASE;
+static  char        	crtc_vga = FALSE;
+static  u_char      	shfts = 0, ctls = 0, alts = 0, agrs = 0, metas = 0;
+static  u_char      	nlkcnt = 0, clkcnt = 0, slkcnt = 0, alkcnt = 0;
+static  char        	*font_8 = NULL, *font_14 = NULL, *font_16 = NULL;
+static  int     	fonts_loaded = 0;
+	char        	palette[3*256];
+static  const u_int     n_fkey_tab = sizeof(fkey_tab) / sizeof(*fkey_tab);
 #if ASYNCH
-static  u_char		kbd_reply = 0;
+static  u_char      	kbd_reply = 0;
 #endif
-static	int	 	delayed_next_scr = FALSE;
-static	int		configuration = 0;	/* current setup */
-static	long		scrn_blank_time = 0;	/* screen saver timeout value */
-static	int		scrn_blanked = FALSE;	/* screen saver active flag */
-static	int		scrn_saver = 0;		/* screen saver routine */
-static	long 		scrn_time_stamp;
-static  u_char		scr_map[256];
-static	char 		*video_mode_ptr = NULL;
-static	u_short mouse_and_mask[16] = {	
-		0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
-		0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
-	};
-static	u_short mouse_or_mask[16] = {
-		0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
-		0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
-	};
-
-/* function prototypes */
-int scprobe(struct isa_device *dev);
-int scattach(struct isa_device *dev);
-int scopen(dev_t dev, int flag, int mode, struct proc *p);
-int scclose(dev_t dev, int flag, int mode, struct proc *p);
-int scread(dev_t dev, struct uio *uio, int flag);
-int scwrite(dev_t dev, struct uio *uio, int flag);
-int scparam(struct tty *tp, struct termios *t);
-int scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p);
-void scxint(dev_t dev);
-void scstart(struct tty *tp);
-void pccnprobe(struct consdev *cp);
-void pccninit(struct consdev *cp);
-void pccnputc(dev_t dev, char c);
-int pccngetc(dev_t dev);
-int pccncheckc(dev_t dev);
-void scintr(int unit);
-int pcmmap(dev_t dev, int offset, int nprot);
-static void scinit(void);
-static void scput(u_char c);
-static u_int scgetc(int noblock);
-static struct tty *get_tty_ptr(dev_t dev);
-static scr_stat *get_scr_stat(dev_t dev);
-static scr_stat *alloc_scp();
-static void init_scp(scr_stat *scp);
-static int get_scr_num();
-static void scrn_timer();
-static void clear_screen(scr_stat *scp);
-static int switch_scr(scr_stat *scp, u_int next_scr);
-static void exchange_scr(void);
-static inline void move_crsr(scr_stat *scp, int x, int y);
-static void scan_esc(scr_stat *scp, u_char c);
-static inline void draw_cursor(scr_stat *scp, int show);
-static void ansi_put(scr_stat *scp, u_char *buf, int len);
-static u_char *get_fstr(u_int c, u_int *len);
-static void update_leds(int which);
-static void history_to_screen(scr_stat *scp);
-static int history_up_line(scr_stat *scp);
-static int history_down_line(scr_stat *scp);
-static void kbd_wait(void);
-static void kbd_cmd(u_char command);
-static void set_mode(scr_stat *scp);
-static void set_border(int color);
-static void set_vgaregs(char *modetable);
-static void set_font_mode();
-static void set_normal_mode();
-static void copy_font(int operation, int font_type, char* font_image);
-static void draw_mouse_image(scr_stat *scp);
-static void save_palette(void);
-static void load_palette(void);
-static void do_bell(scr_stat *scp, int pitch, int duration);
-static void blink_screen(scr_stat *scp);
-
-/* available screen savers */
-static void none_saver(int blank);
-static void blank_saver(int blank);
-static void fade_saver(int blank);
-static void star_saver(int blank);
-static void snake_saver(int blank);
-static void green_saver(int blank);
-
-static const struct {
-	char	*name;
-	void	(*routine)();
-} screen_savers[] = {
-	{ "none",	none_saver },	/* 0 */
-	{ "blank",	blank_saver },	/* 1 */
-	{ "fade",	fade_saver },	/* 2 */
-	{ "star",	star_saver },	/* 3 */
-	{ "snake",	snake_saver },	/* 4 */
-	{ "green",	green_saver },	/* 5 */
+static  int     	delayed_next_scr = FALSE;
+static  int     	configuration = 0;  	/* current setup */
+static  long        	scrn_blank_time = 0;    /* screen saver timeout value */
+	int     	scrn_blanked = FALSE;   /* screen saver active flag */
+static  int     	scrn_saver = 0;    	/* screen saver routine */
+static  long       	scrn_time_stamp;
+	u_char      	scr_map[256];
+static  char        	*video_mode_ptr = NULL;
+
+static  u_short mouse_and_mask[16] = {  
+	0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
+	0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
 };
-#define SCRN_SAVER(arg)	(*screen_savers[scrn_saver].routine)(arg)
-#define NUM_SCRN_SAVERS	(sizeof(screen_savers) / sizeof(screen_savers[0]))
-#define WRAPHIST(scp, pointer, offset)\
-	((scp->history) + ((((pointer) - (scp->history)) + (scp->history_size)\
-	+ (offset)) % (scp->history_size)))
+static  u_short mouse_or_mask[16] = {
+	0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
+	0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
+};
+
+void    none_saver(int blank) { }
+void    (*current_saver)() = none_saver;
 
 /* OS specific stuff */
 #ifdef not_yet_done
-#define VIRTUAL_TTY(x)	(sccons[x] = ttymalloc(sccons[x]))
-struct	CONSOLE_TTY	(sccons[MAXCONS] = ttymalloc(sccons[MAXCONS]))
-struct	tty 		*sccons[MAXCONS+1];
+#define VIRTUAL_TTY(x)  (sccons[x] = ttymalloc(sccons[x]))
+struct  CONSOLE_TTY 	(sccons[MAXCONS] = ttymalloc(sccons[MAXCONS]))
+struct  tty         	*sccons[MAXCONS+1];
 #else
-#define VIRTUAL_TTY(x)	&sccons[x]
-#define CONSOLE_TTY	&sccons[MAXCONS]
-struct	tty 		sccons[MAXCONS+1];
+#define VIRTUAL_TTY(x)  &sccons[x]
+#define CONSOLE_TTY 	&sccons[MAXCONS]
+struct  tty         	sccons[MAXCONS+1];
 #endif
-#define	MONO_BUF	pa_to_va(0xB0000)
-#define	CGA_BUF		pa_to_va(0xB8000)
-u_short			*Crtat = (u_short *)MONO_BUF;
+#define MONO_BUF    	pa_to_va(0xB0000)
+#define CGA_BUF     	pa_to_va(0xB8000)
+u_short         	*Crtat = (u_short *)MONO_BUF;
+
+#define WRAPHIST(scp, pointer, offset)\
+    ((scp->history) + ((((pointer) - (scp->history)) + (scp->history_size)\
+    + (offset)) % (scp->history_size)))
 
-struct	isa_driver scdriver = {
-	scprobe, scattach, "sc", 1
+struct  isa_driver scdriver = {
+    scprobe, scattach, "sc", 1
 };
 
 int
 scprobe(struct isa_device *dev)
 {
-	int i, retries = 5;
-	unsigned char val;
+    int i, retries = 5;
+    unsigned char val;
+
+    /* Enable interrupts and keyboard controller */
+    kbd_wait();
+    outb(KB_STAT, KB_WRITE);
+    kbd_wait();
+    outb(KB_DATA, KB_MODE);
+
+    /* flush any noise in the buffer */
+    while (inb(KB_STAT) & KB_BUF_FULL) {
+	DELAY(10);
+	(void) inb(KB_DATA);
+    }
 
-	/* Enable interrupts and keyboard controller */
-	kbd_wait();
-	outb(KB_STAT, KB_WRITE);
+    /* Reset keyboard hardware */
+    while (retries--) {
 	kbd_wait();
-	outb(KB_DATA, KB_MODE);
-
-	/* flush any noise in the buffer */
-	while (inb(KB_STAT) & KB_BUF_FULL) {
-		DELAY(10);
-		(void) inb(KB_DATA);
-	}
-
-	/* Reset keyboard hardware */
-	while (retries--) {
-		kbd_wait();
-		outb(KB_DATA, KB_RESET);
-		for (i=0; i<100000; i++) {
-			DELAY(10);
-			val = inb(KB_DATA);
-			if (val == KB_ACK || val == KB_ECHO)
-				goto gotres;	
-			if (val == KB_RESEND)
-				break;
-		}
+	outb(KB_DATA, KB_RESET);
+	for (i=0; i<100000; i++) {
+	    DELAY(10);
+	    val = inb(KB_DATA);
+	    if (val == KB_ACK || val == KB_ECHO)
+		goto gotres;    
+	    if (val == KB_RESEND)
+		break;
 	}
+    }
 gotres:
-	if (!retries)
-		printf("scprobe: keyboard won't accept RESET command\n");
-	else {
+    if (!retries)
+	printf("scprobe: keyboard won't accept RESET command\n");
+    else {
 gotack:
-		DELAY(10);
-		while ((inb(KB_STAT) & KB_BUF_FULL) == 0) DELAY(10);
-		DELAY(10);
-		val = inb(KB_DATA);
-		if (val == KB_ACK)
-			goto gotack;
-		if (val != KB_RESET_DONE) 
-			printf("scprobe: keyboard RESET failed %02x\n", val);
-	}
+	DELAY(10);
+	while ((inb(KB_STAT) & KB_BUF_FULL) == 0) DELAY(10);
+	DELAY(10);
+	val = inb(KB_DATA);
+	if (val == KB_ACK)
+	    goto gotack;
+	if (val != KB_RESET_DONE) 
+	    printf("scprobe: keyboard RESET failed %02x\n", val);
+    }
 #ifdef XT_KEYBOARD
-	kbd_wait();
-	outb(KB_DATA, 0xF0);
-	kbd_wait();
-	outb(KB_DATA, 1)
-	kbd_wait();
+    kbd_wait();
+    outb(KB_DATA, 0xF0);
+    kbd_wait();
+    outb(KB_DATA, 1)
+    kbd_wait();
 #endif /* XT_KEYBOARD */
-	return (IO_KBDSIZE);
+    return (IO_KBDSIZE);
 }
 
-static struct kern_devconf kdc_sc[NSC] = { {
-	0, 0, 0,		/* filled in by dev_attach */
-	"sc", 0, { MDDT_ISA, 0, "tty" },
-	isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
-	&kdc_isa0,		/* parent */
-	0,			/* parentdata */
-	DC_BUSY,		/* the console is almost always busy */
-	"Graphics console"
-} };
+static struct kern_devconf kdc_sc[NSC] = {
+    0, 0, 0,        		/* filled in by dev_attach */
+    "sc", 0, { MDDT_ISA, 0, "tty" },
+    isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
+    &kdc_isa0,      		/* parent */
+    0,          		/* parentdata */
+    DC_BUSY,        		/* the console is almost always busy */
+    "Graphics console"
+};
 
 static inline void
 sc_registerdev(struct isa_device *id)
 {
-	if(id->id_unit)
-		kdc_sc[id->id_unit] = kdc_sc[0];
-	kdc_sc[id->id_unit].kdc_unit = id->id_unit;
-	kdc_sc[id->id_unit].kdc_isa = id;
-	dev_attach(&kdc_sc[id->id_unit]);
+    if(id->id_unit)
+	kdc_sc[id->id_unit] = kdc_sc[0];
+    kdc_sc[id->id_unit].kdc_unit = id->id_unit;
+    kdc_sc[id->id_unit].kdc_isa = id;
+    dev_attach(&kdc_sc[id->id_unit]);
 }
 
-#if NAPM > 0 
-/* ARGSUSED */
-static int 
-pcresume(void *dummy)
-{
-	shfts = 0;
-	ctls = 0;
-	alts = 0;
-	agrs = 0;
-	metas = 0;
-	return 0;
-}
-#endif /* NAPM > 0 */
-
-
 int
 scattach(struct isa_device *dev)
 {
-	scr_stat *scp;
+    scr_stat *scp;
 
-	scinit();
-	configuration = dev->id_flags;
-	printf("sc%d: ", dev->id_unit);
-	if (crtc_vga)
-		if (crtc_addr == MONO_BASE)
-			printf("VGA mono");
-		else	
-			printf("VGA color");
-	else
-		if (crtc_addr == MONO_BASE)
-			printf("MDA/hercules");
-		else	
-			printf("CGA/EGA");
-	printf(" <%d virtual consoles, flags=0x%x>\n", 
-			MAXCONS, configuration);
-	scp = console[0];
-	scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
-					 M_DEVBUF, M_NOWAIT);
-	/* copy screen to buffer */
-	bcopyw(Crtat, scp->scr_buf, scp->xsize * scp->ysize * sizeof(u_short));
-	scp->cursor_pos = scp->scr_buf + scp->xpos + scp->ypos * scp->xsize;
-	scp->mouse_pos = scp->scr_buf;
-
-	/* initialize history buffer & pointers */
-	scp->history_head = scp->history_pos = scp->history =
-		(u_short *)malloc(scp->history_size*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	bzero(scp->history_head, scp->history_size*sizeof(u_short));
-
-	if (crtc_vga) {
-		font_8 = (char *)malloc(8*256, M_DEVBUF, M_NOWAIT);
-		font_14 = (char *)malloc(14*256, M_DEVBUF, M_NOWAIT);
-		font_16 = (char *)malloc(16*256, M_DEVBUF, M_NOWAIT);
-		copy_font(SAVE, FONT_16, font_16);
-		fonts_loaded = FONT_16;
-		scp->font = FONT_16;
-		save_palette();
-	}
+    scinit();
+    configuration = dev->id_flags;
+    printf("sc%d: ", dev->id_unit);
+    if (crtc_vga)
+	if (crtc_addr == MONO_BASE)
+	    printf("VGA mono");
+	else    
+	    printf("VGA color");
+    else
+	if (crtc_addr == MONO_BASE)
+	    printf("MDA/hercules");
+	else    
+	    printf("CGA/EGA");
+    printf(" <%d virtual consoles, flags=0x%x>\n", MAXCONS, configuration);
+    scp = console[0];
+    scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+				     M_DEVBUF, M_NOWAIT);
+    /* copy screen to buffer */
+    bcopyw(Crtat, scp->scr_buf, scp->xsize * scp->ysize * sizeof(u_short));
+    scp->cursor_pos = scp->scr_buf + scp->xpos + scp->ypos * scp->xsize;
+    scp->mouse_pos = scp->scr_buf;
+
+    /* initialize history buffer & pointers */
+    scp->history_head = scp->history_pos = scp->history =
+	(u_short *)malloc(scp->history_size*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    bzero(scp->history_head, scp->history_size*sizeof(u_short));
+
+    if (crtc_vga) {
+	font_8 = (char *)malloc(8*256, M_DEVBUF, M_NOWAIT);
+	font_14 = (char *)malloc(14*256, M_DEVBUF, M_NOWAIT);
+	font_16 = (char *)malloc(16*256, M_DEVBUF, M_NOWAIT);
+	copy_font(SAVE, FONT_16, font_16);
+	fonts_loaded = FONT_16;
+	scp->font = FONT_16;
+	save_palette();
+    }
 
-	/* get screen update going */
-	scrn_timer();
+    /* get screen update going */
+    scrn_timer();
 
-	update_leds(scp->status);
-	sc_registerdev(dev);
+    update_leds(scp->status);
+    sc_registerdev(dev);
 #if NAPM > 0
-        scp->r_hook.ah_fun = pcresume;
-        scp->r_hook.ah_arg = NULL;
-        scp->r_hook.ah_name = "pccons keyboard";
-        scp->r_hook.ah_order = APM_MID_ORDER;
-        apm_hook_establish(APM_HOOK_RESUME , &scp->r_hook);
-#endif /* NAPM > 0*/
-	return 0;
+    scp->r_hook.ah_fun = pcresume;
+    scp->r_hook.ah_arg = NULL;
+    scp->r_hook.ah_name = "system keyboard";
+    scp->r_hook.ah_order = APM_MID_ORDER;
+    apm_hook_establish(APM_HOOK_RESUME , &scp->r_hook);
+#endif
+    return 0;
 }
 
 static struct tty 
 *get_tty_ptr(dev_t dev)
 {
-	int unit = minor(dev);
+    int unit = minor(dev);
 
-	if (unit > MAXCONS || unit < 0)
-		return(NULL);
-	if (unit == MAXCONS)
-		return CONSOLE_TTY;
-	return VIRTUAL_TTY(unit);
+    if (unit > MAXCONS || unit < 0)
+	return(NULL);
+    if (unit == MAXCONS)
+	return CONSOLE_TTY;
+    return VIRTUAL_TTY(unit);
 }
 
 static scr_stat 
 *get_scr_stat(dev_t dev)
 {
-	int unit = minor(dev);
+    int unit = minor(dev);
 
-	if (unit > MAXCONS || unit < 0)
-		return(NULL);
-	if (unit == MAXCONS)
-		return console[0];
-	return console[unit];
+    if (unit > MAXCONS || unit < 0)
+	return(NULL);
+    if (unit == MAXCONS)
+	return console[0];
+    return console[unit];
 }
 
 static int
 get_scr_num()
 {
-	int i = 0;
+    int i = 0;
 
-	while ((i < MAXCONS) && (cur_console != console[i])) i++;
-	return i < MAXCONS ? i : 0;
+    while ((i < MAXCONS) && (cur_console != console[i]))
+	i++;
+    return i < MAXCONS ? i : 0;
 }
 
 int 
 scopen(dev_t dev, int flag, int mode, struct proc *p)
 {
-	struct tty *tp = get_tty_ptr(dev);
-
-	if (!tp)
-		return(ENXIO);
-
-	tp->t_oproc = scstart;
-	tp->t_param = scparam;
-	tp->t_dev = dev;
-	if (!(tp->t_state & TS_ISOPEN)) {
-		ttychars(tp);
-		tp->t_iflag = TTYDEF_IFLAG;
-		tp->t_oflag = TTYDEF_OFLAG;
-		tp->t_cflag = TTYDEF_CFLAG;
-		tp->t_lflag = TTYDEF_LFLAG;
-		tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
-		scparam(tp, &tp->t_termios);
-		ttsetwater(tp);
-	} else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
-		return(EBUSY);
-	tp->t_state |= TS_CARR_ON;
-	tp->t_cflag |= CLOCAL;
-	if (!console[minor(dev)])
-		console[minor(dev)] = alloc_scp();
-	return((*linesw[tp->t_line].l_open)(dev, tp));
+    struct tty *tp = get_tty_ptr(dev);
+
+    if (!tp)
+	return(ENXIO);
+
+    tp->t_oproc = scstart;
+    tp->t_param = scparam;
+    tp->t_dev = dev;
+    if (!(tp->t_state & TS_ISOPEN)) {
+	ttychars(tp);
+	tp->t_iflag = TTYDEF_IFLAG;
+	tp->t_oflag = TTYDEF_OFLAG;
+	tp->t_cflag = TTYDEF_CFLAG;
+	tp->t_lflag = TTYDEF_LFLAG;
+	tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
+	scparam(tp, &tp->t_termios);
+	ttsetwater(tp);
+    } 
+    else 
+	if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
+	    return(EBUSY);
+    tp->t_state |= TS_CARR_ON;
+    tp->t_cflag |= CLOCAL;
+    if (!console[minor(dev)])
+	console[minor(dev)] = alloc_scp();
+    return((*linesw[tp->t_line].l_open)(dev, tp));
 }
 
 int 
 scclose(dev_t dev, int flag, int mode, struct proc *p)
 {
-	struct tty *tp = get_tty_ptr(dev);
-	struct scr_stat *scp;
-
-	if (!tp)
-		return(ENXIO);
-	if (minor(dev) < MAXCONS) {
-		scp = get_scr_stat(tp->t_dev);
-		if (scp->status & SWITCH_WAIT_ACQ)
-			wakeup((caddr_t)&scp->smode);
+    struct tty *tp = get_tty_ptr(dev);
+    struct scr_stat *scp;
+
+    if (!tp)
+	return(ENXIO);
+    if (minor(dev) < MAXCONS) {
+	scp = get_scr_stat(tp->t_dev);
+	if (scp->status & SWITCH_WAIT_ACQ)
+	    wakeup((caddr_t)&scp->smode);
 #if not_yet_done
-		if (scp == &main_console) {
-			scp->pid = 0;
-			scp->proc = NULL;
-			scp->smode.mode = VT_AUTO;
-		}
-		else {
-			free(scp->scr_buf, M_DEVBUF); 
-			free(scp->history, M_DEVBUF); 
-			free(scp, M_DEVBUF);
-			console[minor(dev)] = NULL;
-		}
+	if (scp == &main_console) {
+	    scp->pid = 0;
+	    scp->proc = NULL;
+	    scp->smode.mode = VT_AUTO;
+	}
+	else {
+	    free(scp->scr_buf, M_DEVBUF); 
+	    free(scp->history, M_DEVBUF); 
+	    free(scp, M_DEVBUF);
+	    console[minor(dev)] = NULL;
+	}
 #else
-		scp->pid = 0;
-		scp->proc = NULL;
-		scp->smode.mode = VT_AUTO;
+	scp->pid = 0;
+	scp->proc = NULL;
+	scp->smode.mode = VT_AUTO;
 #endif
-	}
-	(*linesw[tp->t_line].l_close)(tp, flag);
-	ttyclose(tp); 
-	return(0);
+    }
+    (*linesw[tp->t_line].l_close)(tp, flag);
+    ttyclose(tp); 
+    return(0);
 }
 
 int 
 scread(dev_t dev, struct uio *uio, int flag)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return(ENXIO);
-	return((*linesw[tp->t_line].l_read)(tp, uio, flag));
+    if (!tp)
+	return(ENXIO);
+    return((*linesw[tp->t_line].l_read)(tp, uio, flag));
 }
 
 int 
 scwrite(dev_t dev, struct uio *uio, int flag)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return(ENXIO);
-	return((*linesw[tp->t_line].l_write)(tp, uio, flag));
+    if (!tp)
+	return(ENXIO);
+    return((*linesw[tp->t_line].l_write)(tp, uio, flag));
 }
 
 void 
 scintr(int unit)
 {
-	static struct tty *cur_tty;
-	int c, len;
-	u_char *cp;
-
-	/* make screensaver happy */
-	scrn_time_stamp = time.tv_sec;
-	if (scrn_blanked) {
-		SCRN_SAVER(FALSE);
-		cur_console->status |= UPDATE_SCREEN;
-	}
-
-	c = scgetc(1);
-
-	cur_tty = VIRTUAL_TTY(get_scr_num());
-	if (!(cur_tty->t_state & TS_ISOPEN))
-		if (!((cur_tty = CONSOLE_TTY)->t_state & TS_ISOPEN))
-			return;
+    static struct tty *cur_tty;
+    int c, len;
+    u_char *cp;
+
+    /* make screensaver happy */
+    scrn_time_stamp = time.tv_sec;
+    if (scrn_blanked) {
+	(*current_saver)(FALSE);
+	cur_console->status |= UPDATE_SCREEN;
+    }
 
-	switch (c & 0xff00) {
-	case 0x0000: /* normal key */
-		(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
-		break;
-	case NOKEY:	/* nothing there */
-		break;
-	case FKEY:	/* function key, return string */
-		if (cp = get_fstr((u_int)c, (u_int *)&len)) {
-			while (len-- >  0)
-				(*linesw[cur_tty->t_line].l_rint)
-					(*cp++ & 0xFF, cur_tty);
-		}
-		break;
-	case MKEY:	/* meta is active, prepend ESC */
-		(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
-		break;
-	case BKEY:	/* backtab fixed sequence (esc [ Z) */
-		(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
-		break;
-	}	
+    c = scgetc(1);
+
+    cur_tty = VIRTUAL_TTY(get_scr_num());
+    if (!(cur_tty->t_state & TS_ISOPEN))
+	if (!((cur_tty = CONSOLE_TTY)->t_state & TS_ISOPEN))
+	    return;
+
+    switch (c & 0xff00) {
+    case 0x0000: /* normal key */
+	(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
+	break;
+    case NOKEY: /* nothing there */
+	break;
+    case FKEY:  /* function key, return string */
+	if (cp = get_fstr((u_int)c, (u_int *)&len)) {
+	    while (len-- >  0)
+		(*linesw[cur_tty->t_line].l_rint)(*cp++ & 0xFF, cur_tty);
+	}
+	break;
+    case MKEY:  /* meta is active, prepend ESC */
+	(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
+	break;
+    case BKEY:  /* backtab fixed sequence (esc [ Z) */
+	(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
+	break;
+    }   
 }
 
 int 
 scparam(struct tty *tp, struct termios *t)
 {
-	int cflag = t->c_cflag;
-
-	/* and copy to tty */
-	tp->t_ispeed = t->c_ispeed;
-	tp->t_ospeed = t->c_ospeed;
-	tp->t_cflag = cflag;
-	return 0;
+    tp->t_ispeed = t->c_ispeed;
+    tp->t_ospeed = t->c_ospeed;
+    tp->t_cflag = t->c_cflag;
+    return 0;
 }
 
 int 
 scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 {
-	int i, error;
-	struct tty *tp;
-	struct trapframe *fp;
-	scr_stat *scp; 
-
-	tp = get_tty_ptr(dev);
-	if (!tp)
-		return ENXIO;
-	scp = get_scr_stat(tp->t_dev);
+    int i, error;
+    struct tty *tp;
+    struct trapframe *fp;
+    scr_stat *scp; 
 
-	switch (cmd) {	/* process console hardware related ioctl's */
+    tp = get_tty_ptr(dev);
+    if (!tp)
+	return ENXIO;
+    scp = get_scr_stat(tp->t_dev);
 
-	case GIO_ATTR:		/* get current attributes */
-		*(int*)data = scp->term.cur_attr;
-		return 0;
+    switch (cmd) {  		/* process console hardware related ioctl's */
 
-	case GIO_COLOR:		/* is this a color console ? */
-		if (crtc_addr == COLOR_BASE)
-			*(int*)data = 1;
-		else
-			*(int*)data = 0;
-		return 0;
-			
-	case CONS_CURRENT:	/* get current adapter type */
-		if (crtc_vga)
-			*(int*)data = KD_VGA;
-		else
-			if (crtc_addr == MONO_BASE)
-				*(int*)data = KD_MONO;
-			else	
-				*(int*)data = KD_CGA;
-		return 0;
+    case GIO_ATTR:      	/* get current attributes */
+	*(int*)data = scp->term.cur_attr;
+	return 0;
 
-	case CONS_GET:		/* get current video mode */
-		*(int*)data = scp->mode;
-		return 0;
+    case GIO_COLOR:     	/* is this a color console ? */
+	if (crtc_addr == COLOR_BASE)
+	    *(int*)data = 1;
+	else
+	    *(int*)data = 0;
+	return 0;
+	    
+    case CONS_CURRENT:  	/* get current adapter type */
+	if (crtc_vga)
+	    *(int*)data = KD_VGA;
+	else
+	    if (crtc_addr == MONO_BASE)
+		*(int*)data = KD_MONO;
+	    else    
+		*(int*)data = KD_CGA;
+	return 0;
 
-	case CONS_BLANKTIME:	/* set screen saver timeout (0 = no saver) */
-		scrn_blank_time = *(int*)data;
-		return 0;
+    case CONS_GET:      	/* get current video mode */
+	*(int*)data = scp->mode;
+	return 0;
 
-#define	SAVER(p) ((ssaver_t *)(p))
-	case CONS_SSAVER:	/* set screen saver */
-		if (SAVER(data)->num < 0 
-		    || SAVER(data)->num >= NUM_SCRN_SAVERS)
-			return EIO;
-		if (scrn_blanked) {
-			SCRN_SAVER(FALSE);
-			cur_console->status |= UPDATE_SCREEN;
-		}
-		scrn_saver = SAVER(data)->num;
-		scrn_blank_time = SAVER(data)->time;
-		return 0;
+    case CONS_BLANKTIME:    	/* set screen saver timeout (0 = no saver) */
+	scrn_blank_time = *(int*)data;
+	return 0;
 
-	case CONS_GSAVER:	/* get screen saver info */
-		if (SAVER(data)->num < 0)
-			SAVER(data)->num = scrn_saver;
-		else if (SAVER(data)->num >= NUM_SCRN_SAVERS)
-			return EIO;
-		SAVER(data)->time = scrn_blank_time;
-		strcpy(SAVER(data)->name, screen_savers[SAVER(data)->num].name);
-		return 0;
+    case CONS_CURSORTYPE:   	/* set cursor type blink/noblink */
+	if ((*(int*)data) & 0x01)
+	    configuration |= BLINK_CURSOR;
+	else
+	    configuration &= ~BLINK_CURSOR;
+	if ((*(int*)data) & 0x02)
+	    configuration |= CHAR_CURSOR;
+	else
+	    configuration &= ~CHAR_CURSOR;
+	return 0;
 
-	case CONS_CURSORTYPE:	/* set cursor type blink/noblink */
-		if ((*(int*)data) & 0x01)
-			configuration |= BLINK_CURSOR;
-		else
-			configuration &= ~BLINK_CURSOR;
-		if ((*(int*)data) & 0x02)
-			configuration |= CHAR_CURSOR;
-		else
-			configuration &= ~CHAR_CURSOR;
-		return 0;
+    case CONS_BELLTYPE: 	/* set bell type sound/visual */
+	if (*data)
+	    configuration |= VISUAL_BELL;
+	else
+	    configuration &= ~VISUAL_BELL;
+	return 0;
 
-	case CONS_BELLTYPE:	/* set bell type sound/visual */
-		if (*data)
-			configuration |= VISUAL_BELL;
-		else
-			configuration &= ~VISUAL_BELL;
-		return 0;
+    case CONS_HISTORY:  	/* set history size */
+	if (*data) {
+	    free(scp->history, M_DEVBUF); 
+	    scp->history_size = *(int*)data;
+	    if (scp->history_size < scp->ysize)
+		scp->history = NULL;
+	    else {
+		scp->history_size *= scp->xsize;
+		scp->history_head = scp->history_pos = scp->history =
+		    (u_short *)malloc(scp->history_size*sizeof(u_short),
+				      M_DEVBUF, M_NOWAIT);
+		bzero(scp->history_head, scp->history_size*sizeof(u_short));
+	    }
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case CONS_HISTORY:	/* set history size */
-		if (*data) {
-		    free(scp->history, M_DEVBUF); 
-		    scp->history_size = *(int*)data;
-		    if (scp->history_size < scp->ysize)
-			scp->history = NULL;
-		    else {
-			scp->history_size *= scp->xsize;
-			scp->history_head = scp->history_pos = scp->history =
-			    (u_short *)malloc(scp->history_size*sizeof(u_short),
-					      M_DEVBUF, M_NOWAIT);
-			bzero(scp->history_head, 
-			      scp->history_size*sizeof(u_short));
-		    }
-		    return 0;
-		}
-		else
-			return EINVAL;
-
-	case CONS_MOUSECTL:
-	{
-		mouse_info_t *mouse = (mouse_info_t*)data;
-		int fontsize;
-
-		switch (scp->font) {
-		default:
-		case FONT_8:
-			fontsize = 8; break;
-		case FONT_14:
-			fontsize = 14; break;
-		case FONT_16:
-			fontsize = 16; break;
-		}
-		switch (mouse->operation) {
-		case MOUSE_SHOW:
-			if (!(scp->status & MOUSE_ENABLED)) {
-				scp->mouse_oldpos = 
-					Crtat + (scp->mouse_pos - scp->scr_buf);
-				scp->status |= (UPDATE_MOUSE | MOUSE_ENABLED);
-			}
-			else
-				return EINVAL;
-			break;
-
-		case MOUSE_HIDE:
-			if (scp->status & MOUSE_ENABLED) {
-				scp->status &= ~MOUSE_ENABLED;
-				scp->status |= UPDATE_MOUSE;
-			}
-			else
-				return EINVAL;
-			break;
-
-		case MOUSE_MOVEABS:
-			scp->mouse_xpos = mouse->x;
-			scp->mouse_ypos = mouse->y;
-			goto set_mouse_pos;
-
-		case MOUSE_MOVEREL:
-			scp->mouse_xpos += mouse->x;
-			scp->mouse_ypos += mouse->y;
+    case CONS_MOUSECTL:		/* control mouse arrow */
+    {
+	mouse_info_t *mouse = (mouse_info_t*)data;
+	int fontsize;
+
+	switch (scp->font) {
+	default:
+	case FONT_8:
+	    fontsize = 8; break;
+	case FONT_14:
+	    fontsize = 14; break;
+	case FONT_16:
+	    fontsize = 16; break;
+	}
+	switch (mouse->operation) {
+	case MOUSE_SHOW:
+	    if (!(scp->status & MOUSE_ENABLED)) {
+		scp->mouse_oldpos = Crtat + (scp->mouse_pos - scp->scr_buf);
+		scp->status |= (UPDATE_MOUSE | MOUSE_ENABLED);
+	    }
+	    else
+		return EINVAL;
+	    break;
+
+	case MOUSE_HIDE:
+	    if (scp->status & MOUSE_ENABLED) {
+		scp->status &= ~MOUSE_ENABLED;
+		scp->status |= UPDATE_MOUSE;
+	    }
+	    else
+		return EINVAL;
+	    break;
+
+	case MOUSE_MOVEABS:
+	    scp->mouse_xpos = mouse->x;
+	    scp->mouse_ypos = mouse->y;
+	    goto set_mouse_pos;
+
+	case MOUSE_MOVEREL:
+	    scp->mouse_xpos += mouse->x;
+	    scp->mouse_ypos += mouse->y;
 set_mouse_pos:
-			if (scp->mouse_xpos < 0)
-				scp->mouse_xpos = 0;
-			if (scp->mouse_ypos < 0)
-				scp->mouse_ypos = 0;
-			if (scp->mouse_xpos >= scp->xsize*8)
-				scp->mouse_xpos = (scp->xsize*8)-1;
-			if (scp->mouse_ypos >= scp->ysize*fontsize)
-				scp->mouse_ypos = (scp->ysize*fontsize)-1;
-			scp->mouse_pos = scp->scr_buf + 
-				(scp->mouse_ypos/fontsize)*scp->xsize + 
-				scp->mouse_xpos/8;
-			if (scp->status & MOUSE_ENABLED)
-				scp->status |= UPDATE_MOUSE;
-			break;
-
-		case MOUSE_GETPOS:
-			mouse->x = scp->mouse_xpos;
-			mouse->y = scp->mouse_ypos;
-			return 0;
-
-		default:
-			return EINVAL;
-		}
-		/* make screensaver happy */
-		if (scp == cur_console) {
-			scrn_time_stamp = time.tv_sec;
-			if (scrn_blanked) {
-				SCRN_SAVER(FALSE);
-				scp->status |= UPDATE_SCREEN;
-			}
-		}
-		return 0;
+	    if (scp->mouse_xpos < 0)
+		scp->mouse_xpos = 0;
+	    if (scp->mouse_ypos < 0)
+		scp->mouse_ypos = 0;
+	    if (scp->mouse_xpos >= scp->xsize*8)
+		scp->mouse_xpos = (scp->xsize*8)-1;
+	    if (scp->mouse_ypos >= scp->ysize*fontsize)
+		scp->mouse_ypos = (scp->ysize*fontsize)-1;
+	    scp->mouse_pos = scp->scr_buf + 
+		(scp->mouse_ypos/fontsize)*scp->xsize + scp->mouse_xpos/8;
+	    if (scp->status & MOUSE_ENABLED)
+		scp->status |= UPDATE_MOUSE;
+	    break;
+
+	case MOUSE_GETPOS:
+	    mouse->x = scp->mouse_xpos;
+	    mouse->y = scp->mouse_ypos;
+	    return 0;
+
+	default:
+	    return EINVAL;
+	}
+	/* make screensaver happy */
+	if (scp == cur_console) {
+	    scrn_time_stamp = time.tv_sec;
+	    if (scrn_blanked) {
+		(*current_saver)(FALSE);
+		scp->status |= UPDATE_SCREEN;
+	    }
 	}
+	return 0;
+    }
 
-	case CONS_GETINFO:	/* get current (virtual) console info */
-	{
-		vid_info_t *ptr = (vid_info_t*)data;
-		if (ptr->size == sizeof(struct vid_info)) {
-			ptr->m_num = get_scr_num();
-			ptr->mv_col = scp->xpos;
-			ptr->mv_row = scp->ypos;
-			ptr->mv_csz = scp->xsize;
-			ptr->mv_rsz = scp->ysize;
-			ptr->mv_norm.fore = (scp->term.std_attr & 0x0f00)>>8;
-			ptr->mv_norm.back = (scp->term.std_attr & 0xf000)>>12;
-			ptr->mv_rev.fore = (scp->term.rev_attr & 0x0f00)>>8;
-			ptr->mv_rev.back = (scp->term.rev_attr & 0xf000)>>12;
-			ptr->mv_grfc.fore = 0;		/* not supported */
-			ptr->mv_grfc.back = 0;		/* not supported */
-			ptr->mv_ovscan = scp->border;
-			ptr->mk_keylock = scp->status & LOCK_KEY_MASK;
-			return 0;
-		}
+    case CONS_GETINFO:  	/* get current (virtual) console info */
+    {
+	vid_info_t *ptr = (vid_info_t*)data;
+	if (ptr->size == sizeof(struct vid_info)) {
+	    ptr->m_num = get_scr_num();
+	    ptr->mv_col = scp->xpos;
+	    ptr->mv_row = scp->ypos;
+	    ptr->mv_csz = scp->xsize;
+	    ptr->mv_rsz = scp->ysize;
+	    ptr->mv_norm.fore = (scp->term.std_attr & 0x0f00)>>8;
+	    ptr->mv_norm.back = (scp->term.std_attr & 0xf000)>>12;
+	    ptr->mv_rev.fore = (scp->term.rev_attr & 0x0f00)>>8;
+	    ptr->mv_rev.back = (scp->term.rev_attr & 0xf000)>>12;
+	    ptr->mv_grfc.fore = 0;      /* not supported */
+	    ptr->mv_grfc.back = 0;      /* not supported */
+	    ptr->mv_ovscan = scp->border;
+	    ptr->mk_keylock = scp->status & LOCK_KEY_MASK;
+	    return 0;
+	}
+	return EINVAL;
+    }
+
+    case CONS_GETVERS:  	/* get version number */
+	*(int*)data = 0x200;    /* version 2.0 */
+	return 0;
+
+    /* VGA TEXT MODES */
+    case SW_VGA_C40x25:
+    case SW_VGA_C80x25: case SW_VGA_M80x25:
+    case SW_VGA_C80x30: case SW_VGA_M80x30:
+    case SW_VGA_C80x50: case SW_VGA_M80x50:
+    case SW_VGA_C80x60: case SW_VGA_M80x60:
+    case SW_B40x25:     case SW_C40x25:
+    case SW_B80x25:     case SW_C80x25:
+    case SW_ENH_B40x25: case SW_ENH_C40x25: 
+    case SW_ENH_B80x25: case SW_ENH_C80x25:
+    case SW_ENH_B80x43: case SW_ENH_C80x43:
+
+	if (!crtc_vga || video_mode_ptr == NULL)
+	    return ENXIO;
+	switch (cmd & 0xff) {
+	case M_VGA_C80x60: case M_VGA_M80x60:
+	    if (!(fonts_loaded & FONT_8))
+		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 60;
+	    break;
+	case M_VGA_C80x50: case M_VGA_M80x50:
+	    if (!(fonts_loaded & FONT_8))
+		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 50;
+	    break;
+	case M_ENH_B80x43: case M_ENH_C80x43:
+	    if (!(fonts_loaded & FONT_8))
 		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 43;
+	    break;
+	case M_VGA_C80x30: case M_VGA_M80x30:
+	    scp->xsize = 80;
+	    scp->ysize = 30;
+	    break;
+	default:
+	    if ((cmd & 0xff) > M_VGA_CG320)
+		return EINVAL;
+	    else 
+		scp->xsize = *(video_mode_ptr+((cmd&0xff)*64));
+		scp->ysize = *(video_mode_ptr+((cmd&0xff)*64)+1)+1;
+	    break;
+	}
+	scp->mode = cmd & 0xff;
+	scp->status &= ~UNKNOWN_MODE;   /* text mode */
+	free(scp->scr_buf, M_DEVBUF); 
+	scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+					 M_DEVBUF, M_NOWAIT);
+	if (scp == cur_console)
+	    set_mode(scp);
+	clear_screen(scp);
+	if (tp->t_winsize.ws_col != scp->xsize 
+	    || tp->t_winsize.ws_row != scp->ysize) {
+	    tp->t_winsize.ws_col = scp->xsize;
+	    tp->t_winsize.ws_row = scp->ysize;
+	    pgsignal(tp->t_pgrp, SIGWINCH, 1);
+	}
+	return 0; 
+
+    /* GRAPHICS MODES */
+    case SW_BG320:     case SW_BG640:
+    case SW_CG320:     case SW_CG320_D:   case SW_CG640_E:
+    case SW_CG640x350: case SW_ENH_CG640:
+    case SW_BG640x480: case SW_CG640x480: case SW_VGA_CG320:
+
+	if (!crtc_vga || video_mode_ptr == NULL)
+	    return ENXIO;
+	scp->mode = cmd & 0xFF;
+	scp->status |= UNKNOWN_MODE;    /* graphics mode */
+	scp->xsize = (*(video_mode_ptr + (scp->mode*64))) * 8;
+	scp->ysize = (*(video_mode_ptr + (scp->mode*64) + 1) + 1) *
+		     (*(video_mode_ptr + (scp->mode*64) + 2));
+	set_mode(scp);
+	/* clear_graphics();*/
+
+	if (tp->t_winsize.ws_xpixel != scp->xsize 
+	    || tp->t_winsize.ws_ypixel != scp->ysize) {
+	    tp->t_winsize.ws_xpixel = scp->xsize;
+	    tp->t_winsize.ws_ypixel = scp->ysize;
+	    pgsignal(tp->t_pgrp, SIGWINCH, 1);
 	}
+	return 0;
 
-	case CONS_GETVERS:	/* get version number */
-		*(int*)data = 0x200;	/* version 2.0 */
+    case VT_SETMODE:    	/* set screen switcher mode */
+	bcopy(data, &scp->smode, sizeof(struct vt_mode));
+	if (scp->smode.mode == VT_PROCESS) {
+	    scp->proc = p;
+	    scp->pid = scp->proc->p_pid;
+	}
+	return 0;
+    
+    case VT_GETMODE:    	/* get screen switcher mode */
+	bcopy(&scp->smode, data, sizeof(struct vt_mode));
+	return 0;
+    
+    case VT_RELDISP:    	/* screen switcher ioctl */
+	switch(*data) {
+	case VT_FALSE:  	/* user refuses to release screen, abort */
+	    if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
+		old_scp->status &= ~SWITCH_WAIT_REL;
+		switch_in_progress = FALSE;
 		return 0;
+	    }
+	    return EINVAL;
 
-	case SW_VGA_C40x25: case SW_VGA_C80x25:	/* VGA TEXT MODES */
-	case SW_VGA_M80x25:
-	case SW_VGA_C80x30: case SW_VGA_M80x30:
-	case SW_VGA_C80x50: case SW_VGA_M80x50:
-	case SW_VGA_C80x60: case SW_VGA_M80x60:
-	case SW_B40x25:     case SW_C40x25:
-	case SW_B80x25:     case SW_C80x25:
-	case SW_ENH_B40x25: case SW_ENH_C40x25: 
-	case SW_ENH_B80x25: case SW_ENH_C80x25:
-	case SW_ENH_B80x43: case SW_ENH_C80x43:
-
-		if (!crtc_vga || video_mode_ptr == NULL)
-			return ENXIO;
-		switch (cmd & 0xff) {
-		case M_VGA_C80x60: case M_VGA_M80x60:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 60;
-			break;
-		case M_VGA_C80x50: case M_VGA_M80x50:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 50;
-			break;
-		case M_ENH_B80x43: case M_ENH_C80x43:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 43;
-			break;
-		case M_VGA_C80x30: case M_VGA_M80x30:
-			scp->xsize = 80;
-			scp->ysize = 30;
-			break;
-		default:
-			if ((cmd & 0xff) > M_VGA_CG320)
-				return EINVAL;
-			else 
-			    scp->xsize = *(video_mode_ptr+((cmd&0xff)*64));
-			    scp->ysize = *(video_mode_ptr+((cmd&0xff)*64)+1)+1;
-			break;
-		}
-		scp->mode = cmd & 0xff;
-		scp->status &= ~UNKNOWN_MODE;	/* text mode */
-		free(scp->scr_buf, M_DEVBUF); 
-		scp->scr_buf = (u_short *)malloc(scp->xsize * scp->ysize * 
-				sizeof(u_short), M_DEVBUF, M_NOWAIT);
-		if (scp == cur_console)
-			set_mode(scp);
-		clear_screen(scp);
-		if (tp->t_winsize.ws_col != scp->xsize 
-		    || tp->t_winsize.ws_row != scp->ysize) {
-			tp->t_winsize.ws_col = scp->xsize;
-			tp->t_winsize.ws_row = scp->ysize;
-			pgsignal(tp->t_pgrp, SIGWINCH, 1);
+	case VT_TRUE:   	/* user has released screen, go on */
+	    if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
+		scp->status &= ~SWITCH_WAIT_REL;
+		exchange_scr();
+		if (new_scp->smode.mode == VT_PROCESS) {
+		    new_scp->status |= SWITCH_WAIT_ACQ;
+		    psignal(new_scp->proc, new_scp->smode.acqsig);
 		}
-		return 0; 
-
-	/* GRAPHICS MODES */
-	case SW_BG320:      case SW_CG320:      case SW_BG640:
-	case SW_CG320_D:    case SW_CG640_E:
-	case SW_CG640x350:  case SW_ENH_CG640:
-	case SW_BG640x480:  case SW_CG640x480:  case SW_VGA_CG320:
-
-		if (!crtc_vga || video_mode_ptr == NULL)
-			return ENXIO;
-		scp->mode = cmd & 0xFF;
-		scp->status |= UNKNOWN_MODE;	/* graphics mode */
-		scp->xsize = (*(video_mode_ptr + (scp->mode*64))) * 8;
-		scp->ysize = (*(video_mode_ptr + (scp->mode*64) + 1) + 1)
-			   * (*(video_mode_ptr + (scp->mode*64) + 2));
-		set_mode(scp);
-		/* clear_graphics();*/
+		else 
+		    switch_in_progress = FALSE;
+		return 0;
+	    }
+	    return EINVAL;
 
-		if (tp->t_winsize.ws_xpixel != scp->xsize 
-		    || tp->t_winsize.ws_ypixel != scp->ysize) {
-			tp->t_winsize.ws_xpixel = scp->xsize;
-			tp->t_winsize.ws_ypixel = scp->ysize;
-			pgsignal(tp->t_pgrp, SIGWINCH, 1);
-		}
+	case VT_ACKACQ: 	/* acquire acknowledged, switch completed */
+	    if (scp == new_scp && (scp->status & SWITCH_WAIT_ACQ)) {
+		scp->status &= ~SWITCH_WAIT_ACQ;
+		switch_in_progress = FALSE;
 		return 0;
+	    }
+	    return EINVAL;
 
-	case VT_SETMODE:	/* set screen switcher mode */
-		bcopy(data, &scp->smode, sizeof(struct vt_mode));
-		if (scp->smode.mode == VT_PROCESS) {
-			scp->proc = p;
-			scp->pid = scp->proc->p_pid;
-		}
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
+
+    case VT_OPENQRY:    	/* return free virtual console */
+	for (i = 0; i < MAXCONS; i++) {
+	    tp = VIRTUAL_TTY(i);
+	    if (!(tp->t_state & TS_ISOPEN)) {
+		*data = i + 1;
 		return 0;
-	
-	case VT_GETMODE:	/* get screen switcher mode */
-		bcopy(&scp->smode, data, sizeof(struct vt_mode));
+	    }
+	} 
+	return EINVAL;
+
+    case VT_ACTIVATE:   	/* switch to screen *data */
+	return switch_scr(scp, (*data) - 1);
+
+    case VT_WAITACTIVE: 	/* wait for switch to occur */
+	if (*data > MAXCONS || *data < 0) 
+	    return EINVAL;
+	if (minor(dev) == (*data) - 1) 
+	    return 0;
+	if (*data == 0) {
+	    if (scp == cur_console)
 		return 0;
-	
-	case VT_RELDISP:	/* screen switcher ioctl */
-		switch(*data) {
-		case VT_FALSE:	/* user refuses to release screen, abort */
-			if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
-				old_scp->status &= ~SWITCH_WAIT_REL;
-				switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
-
-		case VT_TRUE:	/* user has released screen, go on */
-			if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
-				scp->status &= ~SWITCH_WAIT_REL;
-				exchange_scr();
-				if (new_scp->smode.mode == VT_PROCESS) {
-					new_scp->status |= SWITCH_WAIT_ACQ;
-					psignal(new_scp->proc, 
-						new_scp->smode.acqsig);
-				}
-				else 
-					switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
+	}
+	else 
+	    scp = console[(*data) - 1];
+	while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH, 
+			     "waitvt", 0)) == ERESTART) ;
+	return error;
 
-		case VT_ACKACQ:	/* acquire acknowledged, switch completed */
-			if (scp == new_scp && (scp->status & SWITCH_WAIT_ACQ)) {
-				scp->status &= ~SWITCH_WAIT_ACQ;
-				switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
+    case VT_GETACTIVE:
+	*data = get_scr_num()+1;
+	return 0;
 
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
-
-	case VT_OPENQRY:	/* return free virtual console */
-		for (i = 0; i < MAXCONS; i++) {
-			tp = VIRTUAL_TTY(i);
-			if (!(tp->t_state & TS_ISOPEN)) {
-				*data = i + 1;
-				return 0;
-			}
-		} 
-		return EINVAL;
+    case KDENABIO:      	/* allow io operations */
+	fp = (struct trapframe *)p->p_md.md_regs;
+	fp->tf_eflags |= PSL_IOPL;
+	return 0; 
 
-	case VT_ACTIVATE:	/* switch to screen *data */
-		return switch_scr(scp, (*data) - 1);
-
-	case VT_WAITACTIVE:	/* wait for switch to occur */
-		if (*data > MAXCONS || *data < 0) 
-			return EINVAL;
-		if (minor(dev) == (*data) - 1) 
-			return 0;
-		if (*data == 0) {
-			if (scp == cur_console)
-				return 0;
-		}
-		else 
-			scp = console[(*data) - 1];
-		while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH, 
-			"waitvt", 0)) == ERESTART) ;
-		return error;
+    case KDDISABIO:     	/* disallow io operations (default) */
+	fp = (struct trapframe *)p->p_md.md_regs;
+	fp->tf_eflags &= ~PSL_IOPL;
+	return 0;
 
-	case VT_GETACTIVE:
-		*data = get_scr_num()+1;
-		return 0;
+    case KDSETMODE:     	/* set current mode of this (virtual) console */
+	switch (*data) {
+	case KD_TEXT:   	/* switch to TEXT (known) mode */
+	    /* restore fonts & palette ! */
+	    if (crtc_vga) {
+		if (fonts_loaded & FONT_8)
+		    copy_font(LOAD, FONT_8, font_8);
+		if (fonts_loaded & FONT_14)
+		    copy_font(LOAD, FONT_14, font_14);
+		if (fonts_loaded & FONT_16)
+		    copy_font(LOAD, FONT_16, font_16);
+		load_palette();
+	    }
+	    /* FALL THROUGH */
 
-	case KDENABIO:		/* allow io operations */
-		fp = (struct trapframe *)p->p_md.md_regs;
-		fp->tf_eflags |= PSL_IOPL;
-		return 0; 
+	case KD_TEXT1:  	/* switch to TEXT (known) mode */
+	    /* no restore fonts & palette */
+	    scp->status &= ~UNKNOWN_MODE;
+	    if (crtc_vga && video_mode_ptr)
+		set_mode(scp);
+	    clear_screen(scp);
+	    return 0;
 
-	case KDDISABIO:		/* disallow io operations (default) */
-		fp = (struct trapframe *)p->p_md.md_regs;
-		fp->tf_eflags &= ~PSL_IOPL;
-		return 0;
+	case KD_GRAPHICS:	/* switch to GRAPHICS (unknown) mode */
+	    scp->status |= UNKNOWN_MODE;
+	    return 0;
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
 
-	case KDSETMODE:		/* set current mode of this (virtual) console */
-		switch (*data) {
-		case KD_TEXT:	/* switch to TEXT (known) mode */
-				/* restore fonts & palette ! */
-			if (crtc_vga) {
-				if (fonts_loaded & FONT_8)
-					copy_font(LOAD, FONT_8, font_8);
-				if (fonts_loaded & FONT_14)
-					copy_font(LOAD, FONT_14, font_14);
-				if (fonts_loaded & FONT_16)
-					copy_font(LOAD, FONT_16, font_16);
-				load_palette();
-			}
-			/* FALL THROUGH */
-
-		case KD_TEXT1:	/* switch to TEXT (known) mode */
-				/* no restore fonts & palette */
-			scp->status &= ~UNKNOWN_MODE;
-			if (crtc_vga && video_mode_ptr)
-				set_mode(scp);
-			clear_screen(scp);
-			return 0;
-
-		case KD_GRAPHICS:/* switch to GRAPHICS (unknown) mode */
-			scp->status |= UNKNOWN_MODE;
-			return 0;
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
+    case KDGETMODE:     	/* get current mode of this (virtual) console */
+	*data = (scp->status & UNKNOWN_MODE) ? KD_GRAPHICS : KD_TEXT;
+	return 0;
 
-	case KDGETMODE:		/* get current mode of this (virtual) console */
-		*data = (scp->status & UNKNOWN_MODE) ? KD_GRAPHICS : KD_TEXT;
-		return 0;
+    case KDSBORDER:     	/* set border color of this (virtual) console */
+	if (!crtc_vga)
+	    return ENXIO;
+	scp->border = *data;
+	if (scp == cur_console) 
+	    set_border(scp->border);
+	return 0;
 
-	case KDSBORDER:		/* set border color of this (virtual) console */
-		if (!crtc_vga)
-			return ENXIO;
-		scp->border = *data;
-		if (scp == cur_console) 
-			set_border(scp->border);
-		return 0;
+    case KDSKBSTATE:    	/* set keyboard state (locks) */
+	if (*data >= 0 && *data <= LOCK_KEY_MASK) {
+	    scp->status &= ~LOCK_KEY_MASK;
+	    scp->status |= *data;
+	    if (scp == cur_console) 
+		update_leds(scp->status);
+	    return 0;
+	}
+	return EINVAL;
 
-	case KDSKBSTATE:	/* set keyboard state (locks) */
-		if (*data >= 0 && *data <= LOCK_KEY_MASK) {
-			scp->status &= ~LOCK_KEY_MASK;
-			scp->status |= *data;
-			if (scp == cur_console) 
-				update_leds(scp->status);
-			return 0;
-		}
-		return EINVAL;
+    case KDGKBSTATE:    	/* get keyboard state (locks) */
+	*data = scp->status & LOCK_KEY_MASK;
+	return 0;
 
-	case KDGKBSTATE:	/* get keyboard state (locks) */
-		*data = scp->status & LOCK_KEY_MASK;
-		return 0;
+    case KDSETRAD:      	/* set keyboard repeat & delay rates */
+	if (*data & 0x80)
+	    return EINVAL;
+	i = spltty();
+	kbd_cmd(KB_SETRAD);
+	kbd_cmd(*data);
+	splx(i);
+	return 0;
 
-	case KDSETRAD:		/* set keyboard repeat & delay rates */
-		if (*data & 0x80)
-			return EINVAL;
-		i = spltty();
-		kbd_cmd(KB_SETRAD);
-		kbd_cmd(*data);
-		splx(i);
-		return 0;
+    case KDSKBMODE:     	/* set keyboard mode */
+	switch (*data) {
+	case K_RAW: 		/* switch to RAW scancode mode */
+	    scp->status |= KBD_RAW_MODE;
+	    return 0;
 
-	case KDSKBMODE:		/* set keyboard mode */
-		switch (*data) {
-		case K_RAW:	/* switch to RAW scancode mode */
-			scp->status |= KBD_RAW_MODE;
-			return 0;
-
-		case K_XLATE:	/* switch to XLT ascii mode */
-			if (scp == cur_console && scp->status == KBD_RAW_MODE)
-				shfts = ctls = alts = agrs = metas = 0;
-			scp->status &= ~KBD_RAW_MODE;
-			return 0;
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
+	case K_XLATE:   	/* switch to XLT ascii mode */
+	    if (scp == cur_console && scp->status == KBD_RAW_MODE)
+		shfts = ctls = alts = agrs = metas = 0;
+	    scp->status &= ~KBD_RAW_MODE;
+	    return 0;
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
 
-	case KDGKBMODE:		/* get keyboard mode */
-		*data = (scp->status & KBD_RAW_MODE) ? K_RAW : K_XLATE;
-		return 0;
+    case KDGKBMODE:     	/* get keyboard mode */
+	*data = (scp->status & KBD_RAW_MODE) ? K_RAW : K_XLATE;
+	return 0;
 
-	case KDMKTONE:		/* sound the bell */
-		if (*(int*)data) {
-			do_bell(scp, (*(int*)data)&0xffff,
-				(((*(int*)data)>>16)&0xffff)*hz/1000);
-		}
-		else
-			do_bell(scp, scp->bell_pitch, scp->bell_duration);
-		return 0;
+    case KDMKTONE:      	/* sound the bell */
+	if (*(int*)data)
+	    do_bell(scp, (*(int*)data)&0xffff,
+		    (((*(int*)data)>>16)&0xffff)*hz/1000);
+	else
+	    do_bell(scp, scp->bell_pitch, scp->bell_duration);
+	return 0;
 
-	case KIOCSOUND:		/* make tone (*data) hz */
-		if (scp == cur_console) {
-			if (*(int*)data) {
-			int pitch = TIMER_FREQ/(*(int*)data);
-				/* set command for counter 2, 2 byte write */
-				if (acquire_timer2(TIMER_16BIT|TIMER_SQWAVE)) {
-					return EBUSY;
-				}
-				/* set pitch */
-				outb(TIMER_CNTR2, pitch);
-				outb(TIMER_CNTR2, (pitch>>8));
-				/* enable counter 2 output to speaker */
-				outb(IO_PPI, inb(IO_PPI) | 3);
-			}
-			else {
-				/* disable counter 2 output to speaker */
-				outb(IO_PPI, inb(IO_PPI) & 0xFC);
-				release_timer2();
-			}
-		}
-		return 0;
+    case KIOCSOUND:     	/* make tone (*data) hz */
+	if (scp == cur_console) {
+	    if (*(int*)data) {
+		int pitch = TIMER_FREQ/(*(int*)data);
 
-	case KDGKBTYPE:		/* get keyboard type */
-		*data = 0;	/* type not known (yet) */
-		return 0;
+		/* set command for counter 2, 2 byte write */
+		if (acquire_timer2(TIMER_16BIT|TIMER_SQWAVE))
+		    return EBUSY;
 
-	case KDSETLED:		/* set keyboard LED status */
-		if (*data >= 0 && *data <= LED_MASK) {
-			scp->status &= ~LED_MASK;
-			scp->status |= *data;
-			if (scp == cur_console)
-				update_leds(scp->status);
-			return 0;
-		}
-		return EINVAL;
+		/* set pitch */
+		outb(TIMER_CNTR2, pitch);
+		outb(TIMER_CNTR2, (pitch>>8));
 
-	case KDGETLED:		/* get keyboard LED status */
-		*data = scp->status & LED_MASK;
-		return 0;
+		/* enable counter 2 output to speaker */
+		outb(IO_PPI, inb(IO_PPI) | 3);
+	    }
+	    else {
+		/* disable counter 2 output to speaker */
+		outb(IO_PPI, inb(IO_PPI) & 0xFC);
+		release_timer2();
+	    }
+	}
+	return 0;
 
-	case GETFKEY:		/* get functionkey string */
-		if (*(u_short*)data < n_fkey_tab) {
-			fkeyarg_t *ptr = (fkeyarg_t*)data;
-			bcopy(&fkey_tab[ptr->keynum].str,
-			      ptr->keydef,
-			      fkey_tab[ptr->keynum].len);
-			ptr->flen = fkey_tab[ptr->keynum].len;
-			return 0;
-		}
-		else
-			return EINVAL;
-
-	case SETFKEY:		/* set functionkey string */
-		if (*(u_short*)data < n_fkey_tab) {
-			fkeyarg_t *ptr = (fkeyarg_t*)data;
-			bcopy(ptr->keydef, 
-			      &fkey_tab[ptr->keynum].str, 
-			      min(ptr->flen, MAXFK));
-			fkey_tab[ptr->keynum].len = min(ptr->flen, MAXFK);
-			return 0;
-		}
-		else
-			return EINVAL;
+    case KDGKBTYPE:     	/* get keyboard type */
+	*data = 0;  		/* type not known (yet) */
+	return 0;
 
-	case GIO_SCRNMAP: 	/* get output translation table */
-		bcopy(&scr_map, data, sizeof(scr_map));
-		return 0;
+    case KDSETLED:      	/* set keyboard LED status */
+	if (*data >= 0 && *data <= LED_MASK) {
+	    scp->status &= ~LED_MASK;
+	    scp->status |= *data;
+	    if (scp == cur_console)
+		update_leds(scp->status);
+	    return 0;
+	}
+	return EINVAL;
 
-	case PIO_SCRNMAP:	/* set output translation table */
-		bcopy(data, &scr_map, sizeof(scr_map));
-		return 0;
+    case KDGETLED:      	/* get keyboard LED status */
+	*data = scp->status & LED_MASK;
+	return 0;
 
-	case GIO_KEYMAP: 	/* get keyboard translation table */
-		bcopy(&key_map, data, sizeof(key_map));
-		return 0;
+    case GETFKEY:       	/* get functionkey string */
+	if (*(u_short*)data < n_fkey_tab) {
+	    fkeyarg_t *ptr = (fkeyarg_t*)data;
+	    bcopy(&fkey_tab[ptr->keynum].str, ptr->keydef,
+		  fkey_tab[ptr->keynum].len);
+	    ptr->flen = fkey_tab[ptr->keynum].len;
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case PIO_KEYMAP:	/* set keyboard translation table */
-		bcopy(data, &key_map, sizeof(key_map));
-		return 0;
+    case SETFKEY:       	/* set functionkey string */
+	if (*(u_short*)data < n_fkey_tab) {
+	    fkeyarg_t *ptr = (fkeyarg_t*)data;
+	    bcopy(ptr->keydef, &fkey_tab[ptr->keynum].str, 
+		  min(ptr->flen, MAXFK));
+	    fkey_tab[ptr->keynum].len = min(ptr->flen, MAXFK);
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case PIO_FONT8x8:	/* set 8x8 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_8, 8*256);
-		fonts_loaded |= FONT_8;
-		copy_font(LOAD, FONT_8, font_8);
-		return 0;
+    case GIO_SCRNMAP:   	/* get output translation table */
+	bcopy(&scr_map, data, sizeof(scr_map));
+	return 0;
 
-	case GIO_FONT8x8:	/* get 8x8 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_8) {
-			bcopy(font_8, data, 8*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-
-	case PIO_FONT8x14:	/* set 8x14 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_14, 14*256);
-		fonts_loaded |= FONT_14;
-		copy_font(LOAD, FONT_14, font_14);
-		return 0;
+    case PIO_SCRNMAP:   	/* set output translation table */
+	bcopy(data, &scr_map, sizeof(scr_map));
+	return 0;
 
-	case GIO_FONT8x14:	/* get 8x14 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_14) {
-			bcopy(font_14, data, 14*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-
-	case PIO_FONT8x16:	/* set 8x16 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_16, 16*256);
-		fonts_loaded |= FONT_16;
-		copy_font(LOAD, FONT_16, font_16);
-		return 0;
+    case GIO_KEYMAP:    	/* get keyboard translation table */
+	bcopy(&key_map, data, sizeof(key_map));
+	return 0;
 
-	case GIO_FONT8x16:	/* get 8x16 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_16) {
-			bcopy(font_16, data, 16*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-	default:
-		break;
-	}	
-	
-	error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
-	if (error >= 0)
-		return(error);
-	error = ttioctl(tp, cmd, data, flag);
-	if (error >= 0)
-		return(error);
-	return(ENOTTY);
+    case PIO_KEYMAP:    	/* set keyboard translation table */
+	bcopy(data, &key_map, sizeof(key_map));
+	return 0;
+
+    case PIO_FONT8x8:   	/* set 8x8 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_8, 8*256);
+	fonts_loaded |= FONT_8;
+	copy_font(LOAD, FONT_8, font_8);
+	return 0;
+
+    case GIO_FONT8x8:   	/* get 8x8 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_8) {
+	    bcopy(font_8, data, 8*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+
+    case PIO_FONT8x14:  	/* set 8x14 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_14, 14*256);
+	fonts_loaded |= FONT_14;
+	copy_font(LOAD, FONT_14, font_14);
+	return 0;
+
+    case GIO_FONT8x14:  	/* get 8x14 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_14) {
+	    bcopy(font_14, data, 14*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+
+    case PIO_FONT8x16:  	/* set 8x16 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_16, 16*256);
+	fonts_loaded |= FONT_16;
+	copy_font(LOAD, FONT_16, font_16);
+	return 0;
+
+    case GIO_FONT8x16:  	/* get 8x16 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_16) {
+	    bcopy(font_16, data, 16*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+    default:
+	break;
+    }   
+    
+    error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
+    if (error >= 0)
+	return(error);
+    error = ttioctl(tp, cmd, data, flag);
+    if (error >= 0)
+	return(error);
+    return(ENOTTY);
 }
 
 void 
 scxint(dev_t dev)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return;
-	tp->t_state &= ~TS_BUSY;
-	if (tp->t_line)
-		(*linesw[tp->t_line].l_start)(tp);
-	else
-		scstart(tp);
+    if (!tp)
+	return;
+    tp->t_state &= ~TS_BUSY;
+    if (tp->t_line)
+	(*linesw[tp->t_line].l_start)(tp);
+    else
+	scstart(tp);
 }
 
 void 
 scstart(struct tty *tp)
 {
-	struct clist *rbp;
-	int i, s, len;
-	u_char buf[PCBURST];
-	scr_stat *scp = get_scr_stat(tp->t_dev);
+    struct clist *rbp;
+    int i, s, len;
+    u_char buf[PCBURST];
+    scr_stat *scp = get_scr_stat(tp->t_dev);
 
-	if (scp->status & SLKED || blink_in_progress)
-		return;
+    if (scp->status & SLKED || blink_in_progress)
+	return;
+    s = spltty();
+    if (!(tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))) {
+	tp->t_state |= TS_BUSY;
+	splx(s);
+	rbp = &tp->t_outq;
+	while (rbp->c_cc) {
+	    len = q_to_b(rbp, buf, PCBURST);
+	    ansi_put(scp, buf, len);
+	}
+	scp->status |= UPDATE_SCREEN;
 	s = spltty();
-	if (!(tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))) {
-		tp->t_state |= TS_BUSY;
-		splx(s);
-		rbp = &tp->t_outq;
-		/* scp->status &= ~CURSOR_ENABLED; */
-		while (rbp->c_cc) {
-			len = q_to_b(rbp, buf, PCBURST);
-			ansi_put(scp, buf, len);
-		}
-		/* scp->status |= (CURSOR_ENABLED | UPDATE_SCREEN); */
-		scp->status |= UPDATE_SCREEN;
-		s = spltty();
-		tp->t_state &= ~TS_BUSY;
-		if (rbp->c_cc <= tp->t_lowat) {
-			if (tp->t_state & TS_ASLEEP) {
-				tp->t_state &= ~TS_ASLEEP;
-				wakeup((caddr_t)rbp);
-			}
-			selwakeup(&tp->t_wsel);
-		}
+	tp->t_state &= ~TS_BUSY;
+	if (rbp->c_cc <= tp->t_lowat) {
+	    if (tp->t_state & TS_ASLEEP) {
+		tp->t_state &= ~TS_ASLEEP;
+		wakeup((caddr_t)rbp);
+	    }
+	    selwakeup(&tp->t_wsel);
 	}
-	splx(s);
+    }
+    splx(s);
 }
 
+#if NAPM > 0 
+static int 
+scresume(void *dummy)
+{
+	shfts = 0;
+	ctls = 0;
+	alts = 0;
+	agrs = 0;
+	metas = 0;
+	return 0;
+}
+#endif
+
 void 
 pccnprobe(struct consdev *cp)
 {
-	int maj;
+    int maj;
 
-	/* locate the major number */
-	for (maj = 0; maj < nchrdev; maj++)
-		if ((void*)cdevsw[maj].d_open == (void*)scopen)
-			break;
+    /* locate the major number */
+    for (maj = 0; maj < nchrdev; maj++)
+	if ((void*)cdevsw[maj].d_open == (void*)scopen)
+	    break;
 
-	/* initialize required fields */
-	cp->cn_dev = makedev(maj, MAXCONS);
-	cp->cn_pri = CN_INTERNAL;
+    /* initialize required fields */
+    cp->cn_dev = makedev(maj, MAXCONS);
+    cp->cn_pri = CN_INTERNAL;
 }
 
 void 
 pccninit(struct consdev *cp)
 {
-	scinit();
+    scinit();
 }
 
 void 
 pccnputc(dev_t dev, char c)
 {
-	if (c == '\n')
-		scput('\r');
-	scput(c);
+    scr_stat *scp = console[0];
+    term_stat save = scp->term;
+
+    scp->term = kernel_console;
+    current_default = &kernel_default;
+    if (scp->scr_buf == Crtat)
+	draw_cursor(scp, FALSE);
+    if (c == '\n')
+	ansi_put(scp, "\r\n", 2);
+    else
+	ansi_put(scp, &c, 1);
+    scp->status |= UPDATE_SCREEN;
+    kernel_console = scp->term;
+    current_default = &user_default;
+    scp->term = save;
+    if (scp == cur_console /* && scrn_timer not running */) {
+	if (scp->scr_buf != Crtat) {
+	    bcopyw(scp->scr_buf, Crtat,
+		   (scp->xsize*scp->ysize)*sizeof(u_short));
+	    scp->status &= ~CURSOR_SHOWN;
+	}
+	draw_cursor(scp, TRUE);
+	scp->status &= ~UPDATE_SCREEN;
+    }
 }
 
 int 
 pccngetc(dev_t dev)
 {
-	int s = spltty();		/* block scintr while we poll */
-	int c = scgetc(0);
-	splx(s);
-	return(c);
+    int s = spltty();       /* block scintr while we poll */
+    int c = scgetc(0);
+    splx(s);
+    return(c);
 }
 
 int 
 pccncheckc(dev_t dev)
 {
-	return (scgetc(1) & 0xff);
-}
-
-static void 
-none_saver(int blank)
-{
-}
-
-static void 
-fade_saver(int blank)
-{
-	static int count = 0;
-	int i;
-
-	if (blank) {
-		scrn_blanked = 1;
-		if (count < 64) {
-			outb(PIXMASK, 0xFF);		/* no pixelmask */
-			outb(PALWADR, 0x00);
-			outb(PALDATA, 0);
-			outb(PALDATA, 0);
-			outb(PALDATA, 0);
-			for (i = 3; i < 768; i++) {
-				if (palette[i] - count > 15)
-					outb(PALDATA, palette[i]-count);
-				else
-					outb(PALDATA, 15);
-			}
-			inb(crtc_addr+6);		/* reset flip/flop */
-			outb(ATC, 0x20);		/* enable palette */
-			count++;
-		}
-	}
-	else {
-		load_palette();
-		count = scrn_blanked = 0;
-	}
-}
-
-static void 
-blank_saver(int blank)
-{
-	u_char val;
-	if (blank) {
-		scrn_blanked = 1;
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-	}
-	else {
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
-		scrn_blanked = 0;
-	}
-}
-
-static void 
-green_saver(int blank)
-{
-	u_char val;
-	if (blank) {
-		scrn_blanked = 1;
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
-		outb(crtc_addr + 1, val & ~0x80);
-	}
-	else {
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
-		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
-		outb(crtc_addr + 1, val | 0x80);
-		scrn_blanked = 0;
-	}
-}
-
-#define NUM_STARS	50
-
-/*
- * Alternate saver that got its inspiration from a well known utility
- * package for an inferior^H^H^H^H^H^Hfamous OS.
- */
-static void 
-star_saver(int blank)
-{
-	scr_stat	*scp = cur_console;
-	int		cell, i;
-	char 		pattern[] = {"...........++++***   "};
-	char		colors[] = {FG_DARKGREY, FG_LIGHTGREY, 
-				    FG_WHITE, FG_LIGHTCYAN};
-	static u_short 	stars[NUM_STARS][2];
- 
-	if (blank) {
-		if (!scrn_blanked) {
-			scrn_blanked = 1;
-			fillw((FG_LIGHTGREY|BG_BLACK)<<8|scr_map[0x20], Crtat, 
-			      scp->xsize * scp->ysize);
-			set_border(0);
-			for(i=0; i<NUM_STARS; i++) {
-				stars[i][0] = 
-					random() % (scp->xsize*scp->ysize);
-				stars[i][1] = 0;
-			}
-		}
-		cell = random() % NUM_STARS;
-		*((u_short*)(Crtat + stars[cell][0])) = 
-			scr_map[pattern[stars[cell][1]]] | 
-				colors[random()%sizeof(colors)] << 8;
-		if ((stars[cell][1]+=(random()%4)) >= sizeof(pattern)-1) {
-			stars[cell][0] = random() % (scp->xsize*scp->ysize);
-			stars[cell][1] = 0;
-		}
-	}
-	else {
-		if (scrn_blanked) {
-			set_border(scp->border);
-			scrn_blanked = 0;
-		}
-	}
-}
-
-static void 
-snake_saver(int blank)
-{
-	const char	saves[] = {"FreeBSD-2.0"};
-	static u_char	*savs[sizeof(saves)-1];
-	static int	dirx, diry;
-	int		f;
-	scr_stat	*scp = cur_console;
-
-	if (blank) {
-		if (!scrn_blanked) {
-			fillw((FG_LIGHTGREY|BG_BLACK)<<8 | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-			set_border(0);
-			dirx = (scp->xpos ? 1 : -1);
-			diry = (scp->ypos ?
-				scp->xsize : -scp->xsize);
-			for (f=0; f< sizeof(saves)-1; f++)
-				savs[f] = (u_char *)Crtat + 2 *
-					  (scp->xpos+scp->ypos*scp->xsize);
-			*(savs[0]) = scr_map[*saves];
-			f = scp->ysize * scp->xsize + 5;
-			outb(crtc_addr, 14);
-			outb(crtc_addr+1, f >> 8);
-			outb(crtc_addr, 15);
-			outb(crtc_addr+1, f & 0xff);
-			scrn_blanked = 1;
-		}
-		if (scrn_blanked++ < 4) 
-			return;
-		scrn_blanked = 1;
-		*(savs[sizeof(saves)-2]) = scr_map[0x20];
-		for (f=sizeof(saves)-2; f > 0; f--)
-			savs[f] = savs[f-1];
-		f = (savs[0] - (u_char *)Crtat) / 2;
-		if ((f % scp->xsize) == 0 ||
-		    (f % scp->xsize) == scp->xsize - 1 ||
-		    (random() % 50) == 0)
-			dirx = -dirx;
-		if ((f / scp->xsize) == 0 ||
-		    (f / scp->xsize) == scp->ysize - 1 ||
-		    (random() % 20) == 0)
-			diry = -diry;
-		savs[0] += 2*dirx + 2*diry;
-		for (f=sizeof(saves)-2; f>=0; f--)
-			*(savs[f]) = scr_map[saves[f]];
-	}
-	else {
-		if (scrn_blanked) {
-			set_border(scp->border);
-			scrn_blanked = 0;
-		}
-	}
+    return (scgetc(1) & 0xff);
 }
 
 static void 
@@ -1569,14 +1183,14 @@ scrn_timer()
 	timeout((timeout_func_t)scrn_timer, 0, hz/10);
 	return;
     }
-	
+    
     if (!scrn_blanked) {
 	/* update entire screen image */
 	if (scp->status & UPDATE_SCREEN) {
 	    bcopyw(scp->scr_buf, Crtat, scp->xsize*scp->ysize*sizeof(u_short));
 	    scp->status &= ~CURSOR_SHOWN;
 	}
-	/* update "pseudo" mouse */
+	/* update "pseudo" mouse arrow */
 	if ((scp->status & MOUSE_ENABLED) && 
 	    ((scp->status & UPDATE_MOUSE) || (scp->status & UPDATE_SCREEN)))
 	    draw_mouse_image(scp);
@@ -1590,909 +1204,880 @@ scrn_timer()
 	scp->status &= ~UPDATE_SCREEN;
     }
     if (scrn_blank_time && (time.tv_sec>scrn_time_stamp+scrn_blank_time))
-	SCRN_SAVER(TRUE);
+	(*current_saver)(TRUE);
     timeout((timeout_func_t)scrn_timer, 0, hz/25);
 }
-	
+
 static void 
 clear_screen(scr_stat *scp)
 {
-	move_crsr(scp, 0, 0);
-	fillw(scp->term.cur_attr | scr_map[0x20], scp->scr_buf,
-	       scp->xsize * scp->ysize);
+    move_crsr(scp, 0, 0);
+    fillw(scp->term.cur_attr | scr_map[0x20], scp->scr_buf,
+	  scp->xsize * scp->ysize);
 }
 
 static int 
 switch_scr(scr_stat *scp, u_int next_scr)
 {
-	if (switch_in_progress && (cur_console->proc != pfind(cur_console->pid)))
-		switch_in_progress = FALSE;
-
-	if (next_scr >= MAXCONS || switch_in_progress
-	    || (cur_console->smode.mode == VT_AUTO && cur_console->status & UNKNOWN_MODE)) {
-		do_bell(scp, BELL_PITCH, BELL_DURATION);
-		return EINVAL;
-	}
+    if (switch_in_progress && (cur_console->proc != pfind(cur_console->pid)))
+	switch_in_progress = FALSE;
+
+    if (next_scr >= MAXCONS || switch_in_progress || 
+	(cur_console->smode.mode == VT_AUTO 
+	 && cur_console->status & UNKNOWN_MODE)) {
+	do_bell(scp, BELL_PITCH, BELL_DURATION);
+	return EINVAL;
+    }
 
-	/* is the wanted virtual console open ? */
-	if (next_scr) {
-		struct tty *tp = VIRTUAL_TTY(next_scr);
-		if (!(tp->t_state & TS_ISOPEN)) {
-			do_bell(scp, BELL_PITCH, BELL_DURATION);
-			return EINVAL;
-		}
-	}
-	/* delay switch if actively updating screen */
-	if (write_in_progress || blink_in_progress) {
-		delayed_next_scr = next_scr+1;
-		return 0;
-	}
-	switch_in_progress = TRUE;
-	old_scp = cur_console;
-	new_scp = console[next_scr];
-	wakeup((caddr_t)&new_scp->smode);
-	if (new_scp == old_scp) {
-		switch_in_progress = FALSE;
-		delayed_next_scr = FALSE;
-		return 0;
-	}
-	
-	/* has controlling process died? */
-	if (old_scp->proc && (old_scp->proc != pfind(old_scp->pid)))
-		old_scp->smode.mode = VT_AUTO;
-	if (new_scp->proc && (new_scp->proc != pfind(new_scp->pid)))
-		new_scp->smode.mode = VT_AUTO;
-
-	/* check the modes and switch approbiatly */
-	if (old_scp->smode.mode == VT_PROCESS) {
-		old_scp->status |= SWITCH_WAIT_REL;
-		psignal(old_scp->proc, old_scp->smode.relsig);
-	}
-	else {
-		exchange_scr();
-		if (new_scp->smode.mode == VT_PROCESS) {
-			new_scp->status |= SWITCH_WAIT_ACQ;
-			psignal(new_scp->proc, new_scp->smode.acqsig);
-		}
-		else
-			switch_in_progress = FALSE;
+    /* is the wanted virtual console open ? */
+    if (next_scr) {
+	struct tty *tp = VIRTUAL_TTY(next_scr);
+	if (!(tp->t_state & TS_ISOPEN)) {
+	    do_bell(scp, BELL_PITCH, BELL_DURATION);
+	    return EINVAL;
 	}
+    }
+    /* delay switch if actively updating screen */
+    if (write_in_progress || blink_in_progress) {
+	delayed_next_scr = next_scr+1;
+	return 0;
+    }
+    switch_in_progress = TRUE;
+    old_scp = cur_console;
+    new_scp = console[next_scr];
+    wakeup((caddr_t)&new_scp->smode);
+    if (new_scp == old_scp) {
+	switch_in_progress = FALSE;
+	delayed_next_scr = FALSE;
 	return 0;
+    }
+    
+    /* has controlling process died? */
+    if (old_scp->proc && (old_scp->proc != pfind(old_scp->pid)))
+	old_scp->smode.mode = VT_AUTO;
+    if (new_scp->proc && (new_scp->proc != pfind(new_scp->pid)))
+	new_scp->smode.mode = VT_AUTO;
+
+    /* check the modes and switch approbiatly */
+    if (old_scp->smode.mode == VT_PROCESS) {
+	old_scp->status |= SWITCH_WAIT_REL;
+	psignal(old_scp->proc, old_scp->smode.relsig);
+    }
+    else {
+	exchange_scr();
+	if (new_scp->smode.mode == VT_PROCESS) {
+	    new_scp->status |= SWITCH_WAIT_ACQ;
+	    psignal(new_scp->proc, new_scp->smode.acqsig);
+	}
+	else
+	    switch_in_progress = FALSE;
+    }
+    return 0;
 }
 
 static void 
 exchange_scr(void) 
 {
-	move_crsr(old_scp, old_scp->xpos, old_scp->ypos);
-	cur_console = new_scp;
-	if (old_scp->mode != new_scp->mode || (old_scp->status & UNKNOWN_MODE)){
-		if (crtc_vga && video_mode_ptr)
-			set_mode(new_scp);
-	}
-	move_crsr(new_scp, new_scp->xpos, new_scp->ypos);
-	if ((old_scp->status & UNKNOWN_MODE) && crtc_vga) {
-		if (fonts_loaded & FONT_8)
-			copy_font(LOAD, FONT_8, font_8);
-		if (fonts_loaded & FONT_14)
-			copy_font(LOAD, FONT_14, font_14);
-		if (fonts_loaded & FONT_16)
-			copy_font(LOAD, FONT_16, font_16);
-		load_palette();
-	}
-	if (old_scp->status & KBD_RAW_MODE || new_scp->status & KBD_RAW_MODE)
-		shfts = ctls = alts = agrs = metas = 0;
-	update_leds(new_scp->status);
-	delayed_next_scr = FALSE;
-	new_scp->status |= UPDATE_SCREEN;
+    move_crsr(old_scp, old_scp->xpos, old_scp->ypos);
+    cur_console = new_scp;
+    if (old_scp->mode != new_scp->mode || (old_scp->status & UNKNOWN_MODE)){
+	if (crtc_vga && video_mode_ptr)
+	    set_mode(new_scp);
+    }
+    move_crsr(new_scp, new_scp->xpos, new_scp->ypos);
+    if ((old_scp->status & UNKNOWN_MODE) && crtc_vga) {
+	if (fonts_loaded & FONT_8)
+	    copy_font(LOAD, FONT_8, font_8);
+	if (fonts_loaded & FONT_14)
+	    copy_font(LOAD, FONT_14, font_14);
+	if (fonts_loaded & FONT_16)
+	    copy_font(LOAD, FONT_16, font_16);
+	load_palette();
+    }
+    if (old_scp->status & KBD_RAW_MODE || new_scp->status & KBD_RAW_MODE)
+	shfts = ctls = alts = agrs = metas = 0;
+    update_leds(new_scp->status);
+    delayed_next_scr = FALSE;
+    bcopyw(new_scp->scr_buf, Crtat,
+	   (new_scp->xsize*new_scp->ysize)*sizeof(u_short));
+    new_scp->status &= ~CURSOR_SHOWN;
 }
 
 static inline void 
 move_crsr(scr_stat *scp, int x, int y)
 {
-	if (x < 0 || y < 0 || x >= scp->xsize || y >= scp->ysize)
-		return;
-	scp->xpos = x;
-	scp->ypos = y;
-	scp->cursor_pos = scp->scr_buf + scp->ypos * scp->xsize + scp->xpos;
+    if (x < 0 || y < 0 || x >= scp->xsize || y >= scp->ysize)
+	return;
+    scp->xpos = x;
+    scp->ypos = y;
+    scp->cursor_pos = scp->scr_buf + scp->ypos * scp->xsize + scp->xpos;
 }
 
 static void 
 scan_esc(scr_stat *scp, u_char c)
 {
-	static u_char ansi_col[16] = 
-		{0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15};
-	int i, n;
-	u_short *src, *dst, count;
-
-	if (scp->term.esc == 1) {
-		switch (c) {
-
-		case '[': 	/* Start ESC [ sequence */
-			scp->term.esc = 2;
-			scp->term.last_param = -1;
-			for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
-				scp->term.param[i] = 1;
-			scp->term.num_param = 0;
-			return;
-
-		case 'M':	/* Move cursor up 1 line, scroll if at top */
-			if (scp->ypos > 0)
-				move_crsr(scp, scp->xpos, scp->ypos - 1);
-			else {
-				bcopyw(scp->scr_buf, 
-					scp->scr_buf + scp->xsize,
-					(scp->ysize - 1) * scp->xsize *
-					sizeof(u_short));
-				fillw(scp->term.cur_attr | scr_map[0x20], 
-				      scp->scr_buf, scp->xsize);
-			}
-			break;
+    static u_char ansi_col[16] = 
+	{0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15};
+    int i, n;
+    u_short *src, *dst, count;
+
+    if (scp->term.esc == 1) {
+	switch (c) {
+
+	case '[':   /* Start ESC [ sequence */
+	    scp->term.esc = 2;
+	    scp->term.last_param = -1;
+	    for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
+		scp->term.param[i] = 1;
+	    scp->term.num_param = 0;
+	    return;
+
+	case 'M':   /* Move cursor up 1 line, scroll if at top */
+	    if (scp->ypos > 0)
+		move_crsr(scp, scp->xpos, scp->ypos - 1);
+	    else {
+		bcopyw(scp->scr_buf, scp->scr_buf + scp->xsize,
+		       (scp->ysize - 1) * scp->xsize * sizeof(u_short));
+		fillw(scp->term.cur_attr | scr_map[0x20], 
+		      scp->scr_buf, scp->xsize);
+	    }
+	    break;
 #if notyet
-		case 'Q':
-			scp->term.esc = 4;
-			break;
+	case 'Q':
+	    scp->term.esc = 4;
+	    break;
 #endif
-		case 'c':	/* Clear screen & home */
-			clear_screen(scp);
-			break;
-		}
+	case 'c':   /* Clear screen & home */
+	    clear_screen(scp);
+	    break;
 	}
-	else if (scp->term.esc == 2) {
-		if (c >= '0' && c <= '9') {
-		    if (scp->term.num_param < MAX_ESC_PAR) {
-			if (scp->term.last_param != scp->term.num_param) {
-			    scp->term.last_param = scp->term.num_param;
-			    scp->term.param[scp->term.num_param] = 0;
-			}
-			else
-			    scp->term.param[scp->term.num_param] *= 10;
-			scp->term.param[scp->term.num_param] += c - '0';
-			return;
-		    }
-		}
-		scp->term.num_param = scp->term.last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (scp->term.num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case '=':
-			scp->term.esc = 3;
-			scp->term.last_param = -1;
-			for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
-				scp->term.param[i] = 1;
-			scp->term.num_param = 0;
-			return;
-
-		case 'A': /* up n rows */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos - n);
-			break;
-
-		case 'B': /* down n rows */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos + n);
-			break;
-
-		case 'C': /* right n columns */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos + n, scp->ypos);
-			break;
-
-		case 'D': /* left n columns */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos - n, scp->ypos);
-			break;
-
-		case 'E': /* cursor to start of line n lines down */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, 0, scp->ypos + n);
-			break;
-
-		case 'F': /* cursor to start of line n lines up */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, 0, scp->ypos - n);
-			break;
-
-		case 'f': /* System V consoles .. */
-		case 'H': /* Cursor move */
-			if (scp->term.num_param == 0) 
-				move_crsr(scp, 0, 0);
-			else if (scp->term.num_param == 2)
-				move_crsr(scp, scp->term.param[1] - 1, 
-					  scp->term.param[0] - 1);
-			break;
-
-		case 'J': /* Clear all or part of display */
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: /* clear form cursor to end of display */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->cursor_pos, scp->scr_buf + 
-				      scp->xsize * scp->ysize - 
-				      scp->cursor_pos);
-				break;
-			case 1: /* clear from beginning of display to cursor */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->scr_buf, 
-				      scp->cursor_pos - scp->scr_buf);
-				break;
-			case 2: /* clear entire display */
-				clear_screen(scp);
-				break;
-			}
-			break;
-
-		case 'K': /* Clear all or part of line */
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: /* clear form cursor to end of line */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->cursor_pos, scp->xsize - scp->xpos);
-				break;
-			case 1: /* clear from beginning of line to cursor */
-				fillw(scp->term.cur_attr|scr_map[0x20], 
-				      scp->cursor_pos - (scp->xsize - scp->xpos),
-				      (scp->xsize - scp->xpos) + 1);
-				break;
-			case 2: /* clear entire line */
-				fillw(scp->term.cur_attr|scr_map[0x20], 
-				      scp->cursor_pos - (scp->xsize - scp->xpos),
-				      scp->xsize);
-				break;
-			}
-			break;
-
-		case 'L':	/* Insert n lines */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->ysize - scp->ypos)
-				n = scp->ysize - scp->ypos;
-			src = scp->scr_buf + scp->ypos * scp->xsize;
-			dst = src + n * scp->xsize;
-			count = scp->ysize - (scp->ypos + n);
-			bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], src,
-			      n * scp->xsize);
-			break;
-
-		case 'M':	/* Delete n lines */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->ysize - scp->ypos)
-				n = scp->ysize - scp->ypos;
-			dst = scp->scr_buf + scp->ypos * scp->xsize;
-			src = dst + n * scp->xsize;
-			count = scp->ysize - (scp->ypos + n);
-			bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
-			src = dst + count * scp->xsize;
-			fillw(scp->term.cur_attr | scr_map[0x20], src,
-			      n * scp->xsize);
-			break;
-
-		case 'P':	/* Delete n chars */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			dst = scp->cursor_pos;
-			src = dst + n;
-			count = scp->xsize - (scp->xpos + n);
-			bcopyw(src, dst, count * sizeof(u_short));
-			src = dst + count;
-			fillw(scp->term.cur_attr | scr_map[0x20], src, n);
-			break;
-
-		case '@':	/* Insert n chars */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			src = scp->cursor_pos;
-			dst = src + n;
-			count = scp->xsize - (scp->xpos + n);
-			bcopyw(src, dst, count * sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], src, n);
-			break;
-
-		case 'S':	/* scroll up n lines */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->ysize)
-				n = scp->ysize;
-			bcopyw(scp->scr_buf + (scp->xsize * n),
-			      scp->scr_buf, 
-			      scp->xsize * (scp->ysize - n) * 
-			      sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20],
-			      scp->scr_buf + scp->xsize * 
-			      (scp->ysize - n),
-			      scp->xsize * n);
-			break;
-
-		case 'T':	/* scroll down n lines */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->ysize)
-				n = scp->ysize;
-			bcopyw(scp->scr_buf, 
-			      scp->scr_buf + (scp->xsize * n),
-			      scp->xsize * (scp->ysize - n) * 
-			      sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], 
-			      scp->scr_buf, scp->xsize * n);
-			break;
-
-		case 'X':	/* delete n characters in line */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			fillw(scp->term.cur_attr | scr_map[0x20], 
-			      scp->scr_buf + scp->xpos + 
-			      ((scp->xsize*scp->ypos) * sizeof(u_short)), n);
-			break;
-
-		case 'Z':	/* move n tabs backwards */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if ((i = scp->xpos & 0xf8) == scp->xpos)
-				i -= 8*n;
-			else 
-				i -= 8*(n-1); 
-			if (i < 0) 
-				i = 0;
-			move_crsr(scp, i, scp->ypos);
-			break;
-
-		case '`': 	/* move cursor to column n */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, n - 1, scp->ypos);
-			break;
-
-		case 'a': 	/* move cursor n columns to the right */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos + n, scp->ypos);
-			break;
-
-		case 'd': 	/* move cursor to row n */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos, n - 1);
-			break;
-
-		case 'e': 	/* move cursor n rows down */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos + n);
-			break;
-
-		case 'm': 	/* change attribute */
-			if (scp->term.num_param == 0) {
-				scp->term.cur_attr = scp->term.std_attr;
-				break;
-			}
-			for (i = 0; i < scp->term.num_param; i++) {
-				switch (n = scp->term.param[i]) {
-				case 0:	/* back to normal */
-					scp->term.cur_attr = scp->term.std_attr;
-					break;
-				case 1:	/* highlight (bold) */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x0800;
-					break;
-				case 4: /* highlight (underline) */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x0800;
-					break;
-				case 5: /* blink */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x8000;
-					break;
-				case 7: /* reverse video */
-					scp->term.cur_attr = scp->term.rev_attr;
-					break;
-				case 30: case 31: /* set fg color */
-				case 32: case 33: case 34: 
-				case 35: case 36: case 37:
-					scp->term.cur_attr = 
-						(scp->term.cur_attr & 0xF8FF)
-						| (ansi_col[(n-30) & 7] << 8);
-					break;
-				case 40: case 41: /* set bg color */
-				case 42: case 43: case 44: 
-				case 45: case 46: case 47:
-					scp->term.cur_attr = 
-						(scp->term.cur_attr & 0x8FFF)
-						| (ansi_col[(n-40) & 7] << 12);
-					break;
-				}
-			}
-			break;
-
-		case 'x':
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: 	/* reset attributes */
-				scp->term.cur_attr = scp->term.std_attr =
-				    current_default->std_attr;
-				scp->term.rev_attr = current_default->rev_attr;
-				break;
-			case 1: 	/* set ansi background */
-				scp->term.cur_attr = scp->term.std_attr =  
-				    (scp->term.std_attr & 0x0F00) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<12);
-				break;
-			case 2: 	/* set ansi foreground */
-				scp->term.cur_attr = scp->term.std_attr =  
-				    (scp->term.std_attr & 0xF000) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<8);
-				break;
-			case 3: 	/* set ansi attribute directly */
-				scp->term.cur_attr = scp->term.std_attr =
-				    (scp->term.param[1]&0xFF)<<8;
-				break;
-			case 5: 	/* set ansi reverse video background */
-				scp->term.rev_attr = 
-				    (scp->term.rev_attr & 0x0F00) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<12);
-				break;
-			case 6: 	/* set ansi reverse video foreground */
-				scp->term.rev_attr = 
-				    (scp->term.rev_attr & 0xF000) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<8);
-				break;
-			case 7: 	/* set ansi reverse video directly */
-				scp->term.rev_attr =
-				    (scp->term.param[1]&0xFF)<<8;
-				break;
-			}
-			break;
+    }
+    else if (scp->term.esc == 2) {
+	if (c >= '0' && c <= '9') {
+	    if (scp->term.num_param < MAX_ESC_PAR) {
+	    if (scp->term.last_param != scp->term.num_param) {
+		scp->term.last_param = scp->term.num_param;
+		scp->term.param[scp->term.num_param] = 0;
+	    }
+	    else
+		scp->term.param[scp->term.num_param] *= 10;
+	    scp->term.param[scp->term.num_param] += c - '0';
+	    return;
+	    }
+	}
+	scp->term.num_param = scp->term.last_param + 1;
+	switch (c) {
 
-		case 'z':	/* switch to (virtual) console n */
-			if (scp->term.num_param == 1)
-				switch_scr(scp, scp->term.param[0]);
-			break;
+	case ';':
+	    if (scp->term.num_param < MAX_ESC_PAR)
+		return;
+	    break;
+
+	case '=':
+	    scp->term.esc = 3;
+	    scp->term.last_param = -1;
+	    for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
+		scp->term.param[i] = 1;
+	    scp->term.num_param = 0;
+	    return;
+
+	case 'A':   /* up n rows */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos - n);
+	    break;
+
+	case 'B':   /* down n rows */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos + n);
+	    break;
+
+	case 'C':   /* right n columns */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos + n, scp->ypos);
+	    break;
+
+	case 'D':   /* left n columns */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos - n, scp->ypos);
+	    break;
+
+	case 'E':   /* cursor to start of line n lines down */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, 0, scp->ypos + n);
+	    break;
+
+	case 'F':   /* cursor to start of line n lines up */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, 0, scp->ypos - n);
+	    break;
+
+	case 'f':   /* Cursor move */
+	case 'H':
+	    if (scp->term.num_param == 0) 
+		move_crsr(scp, 0, 0);
+	    else if (scp->term.num_param == 2)
+		move_crsr(scp, scp->term.param[1] - 1, scp->term.param[0] - 1);
+	    break;
+
+	case 'J':   /* Clear all or part of display */
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0: /* clear form cursor to end of display */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->cursor_pos, 
+		      scp->scr_buf + scp->xsize * scp->ysize - scp->cursor_pos);
+		break;
+	    case 1: /* clear from beginning of display to cursor */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->scr_buf, 
+		      scp->cursor_pos - scp->scr_buf);
+		break;
+	    case 2: /* clear entire display */
+		clear_screen(scp);
+		break;
+	    }
+	    break;
+
+	case 'K':   /* Clear all or part of line */
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0: /* clear form cursor to end of line */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->cursor_pos, 
+		      scp->xsize - scp->xpos);
+		break;
+	    case 1: /* clear from beginning of line to cursor */
+		fillw(scp->term.cur_attr|scr_map[0x20], 
+		      scp->cursor_pos - (scp->xsize - scp->xpos),
+		      (scp->xsize - scp->xpos) + 1);
+		break;
+	    case 2: /* clear entire line */
+		fillw(scp->term.cur_attr|scr_map[0x20], 
+		      scp->cursor_pos - (scp->xsize - scp->xpos),
+		      scp->xsize);
+		break;
+	    }
+	    break;
+
+	case 'L':   /* Insert n lines */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->ysize - scp->ypos)
+		n = scp->ysize - scp->ypos;
+	    src = scp->scr_buf + scp->ypos * scp->xsize;
+	    dst = src + n * scp->xsize;
+	    count = scp->ysize - (scp->ypos + n);
+	    bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], src,
+		  n * scp->xsize);
+	    break;
+
+	case 'M':   /* Delete n lines */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->ysize - scp->ypos)
+		n = scp->ysize - scp->ypos;
+	    dst = scp->scr_buf + scp->ypos * scp->xsize;
+	    src = dst + n * scp->xsize;
+	    count = scp->ysize - (scp->ypos + n);
+	    bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
+	    src = dst + count * scp->xsize;
+	    fillw(scp->term.cur_attr | scr_map[0x20], src,
+		  n * scp->xsize);
+	    break;
+
+	case 'P':   /* Delete n chars */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    dst = scp->cursor_pos;
+	    src = dst + n;
+	    count = scp->xsize - (scp->xpos + n);
+	    bcopyw(src, dst, count * sizeof(u_short));
+	    src = dst + count;
+	    fillw(scp->term.cur_attr | scr_map[0x20], src, n);
+	    break;
+
+	case '@':   /* Insert n chars */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    src = scp->cursor_pos;
+	    dst = src + n;
+	    count = scp->xsize - (scp->xpos + n);
+	    bcopyw(src, dst, count * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], src, n);
+	    break;
+
+	case 'S':   /* scroll up n lines */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->ysize)
+		n = scp->ysize;
+	    bcopyw(scp->scr_buf + (scp->xsize * n), 
+		   scp->scr_buf, 
+		   scp->xsize * (scp->ysize - n) * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20],
+		  scp->scr_buf + scp->xsize * (scp->ysize - n), 
+		  scp->xsize * n);
+	    break;
+
+	case 'T':   /* scroll down n lines */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->ysize)
+		n = scp->ysize;
+	    bcopyw(scp->scr_buf, 
+		  scp->scr_buf + (scp->xsize * n),
+		  scp->xsize * (scp->ysize - n) * 
+		  sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], 
+		  scp->scr_buf, scp->xsize * n);
+	    break;
+
+	case 'X':   /* delete n characters in line */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    fillw(scp->term.cur_attr | scr_map[0x20], 
+		  scp->scr_buf + scp->xpos + 
+		  ((scp->xsize*scp->ypos) * sizeof(u_short)), n);
+	    break;
+
+	case 'Z':   /* move n tabs backwards */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if ((i = scp->xpos & 0xf8) == scp->xpos)
+		i -= 8*n;
+	    else 
+		i -= 8*(n-1); 
+	    if (i < 0) 
+		i = 0;
+	    move_crsr(scp, i, scp->ypos);
+	    break;
+
+	case '`':   /* move cursor to column n */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, n - 1, scp->ypos);
+	    break;
+
+	case 'a':   /* move cursor n columns to the right */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos + n, scp->ypos);
+	    break;
+
+	case 'd':   /* move cursor to row n */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos, n - 1);
+	    break;
+
+	case 'e':   /* move cursor n rows down */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos + n);
+	    break;
+
+	case 'm':   /* change attribute */
+	    if (scp->term.num_param == 0) {
+		scp->term.cur_attr = scp->term.std_attr;
+		break;
+	    }
+	    for (i = 0; i < scp->term.num_param; i++) {
+		switch (n = scp->term.param[i]) {
+		case 0: /* back to normal */
+		    scp->term.cur_attr = scp->term.std_attr;
+		    break;
+		case 1: /* highlight (bold) */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x0800;
+		    break;
+		case 4: /* highlight (underline) */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x0800;
+		    break;
+		case 5: /* blink */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x8000;
+		    break;
+		case 7: /* reverse video */
+		    scp->term.cur_attr = scp->term.rev_attr;
+		    break;
+		case 30: case 31: /* set fg color */
+		case 32: case 33: case 34: 
+		case 35: case 36: case 37:
+		    scp->term.cur_attr = 
+			(scp->term.cur_attr&0xF8FF) | (ansi_col[(n-30)&7]<<8);
+		    break;
+		case 40: case 41: /* set bg color */
+		case 42: case 43: case 44: 
+		case 45: case 46: case 47:
+		    scp->term.cur_attr = 
+			(scp->term.cur_attr&0x8FFF) | (ansi_col[(n-40)&7]<<12);
+		    break;
 		}
+	    }
+	    break;
+
+	case 'x':
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0:     /* reset attributes */
+		scp->term.cur_attr = scp->term.std_attr =
+		    current_default->std_attr;
+		scp->term.rev_attr = current_default->rev_attr;
+		break;
+	    case 1:     /* set ansi background */
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0x0F00) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<12);
+		break;
+	    case 2:     /* set ansi foreground */
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0xF000) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<8);
+		break;
+	    case 3:     /* set ansi attribute directly */
+		scp->term.cur_attr = scp->term.std_attr =
+		    (scp->term.param[1]&0xFF)<<8;
+		break;
+	    case 5:     /* set ansi reverse video background */
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0x0F00) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<12);
+		break;
+	    case 6:     /* set ansi reverse video foreground */
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0xF000) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<8);
+		break;
+	    case 7:     /* set ansi reverse video directly */
+		scp->term.rev_attr =
+		    (scp->term.param[1]&0xFF)<<8;
+		break;
+	    }
+	    break;
+
+	case 'z':   /* switch to (virtual) console n */
+	    if (scp->term.num_param == 1)
+		switch_scr(scp, scp->term.param[0]);
+	    break;
 	}
-	else if (scp->term.esc == 3) {
-		if (c >= '0' && c <= '9') {
-		    if (scp->term.num_param < MAX_ESC_PAR) {
-			if (scp->term.last_param != scp->term.num_param) {
-			    scp->term.last_param = scp->term.num_param;
-			    scp->term.param[scp->term.num_param] = 0;
-			}
-			else
-			    scp->term.param[scp->term.num_param] *= 10;
-			scp->term.param[scp->term.num_param] += c - '0';
-			return;
-		    }
-		}
-		scp->term.num_param = scp->term.last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (scp->term.num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case 'A':	/* set display border color */
-			if (scp->term.num_param == 1)
-				scp->border=scp->term.param[0] & 0xff;
-				if (scp == cur_console)
-					set_border(scp->border);
-			break;
-
-		case 'B':	/* set bell pitch and duration */
-			if (scp->term.num_param == 2) {
-				scp->bell_pitch = scp->term.param[0];
-				scp->bell_duration = scp->term.param[1]*10;
-			}
-			break;
-
-		case 'C': 	/* set cursor type & shape */
-			if (scp->term.num_param == 1) {
-				if (scp->term.param[0] & 0x01)
-					configuration |= BLINK_CURSOR;
-				else
-					configuration &= ~BLINK_CURSOR;
-				if (scp->term.param[0] & 0x02)
-					configuration |= CHAR_CURSOR;
-				else
-					configuration &= ~CHAR_CURSOR;
-			}
-			else if (scp->term.num_param == 2) {
-				scp->cursor_start = scp->term.param[0] & 0x1F; 
-				scp->cursor_end = scp->term.param[1] & 0x1F; 
-			}
-			break;
-
-		case 'F':	/* set ansi foreground */
-			if (scp->term.num_param == 1) 
-				scp->term.cur_attr = scp->term.std_attr =  
-					(scp->term.std_attr & 0xF000) 
-					| ((scp->term.param[0] & 0x0F) << 8);
-			break;
-
-		case 'G': 	/* set ansi background */
-			if (scp->term.num_param == 1) 
-				scp->term.cur_attr = scp->term.std_attr =  
-					(scp->term.std_attr & 0x0F00) 
-					| ((scp->term.param[0] & 0x0F) << 12);
-			break;
-
-		case 'H':	/* set ansi reverse video foreground */
-			if (scp->term.num_param == 1) 
-				scp->term.rev_attr = 
-					(scp->term.rev_attr & 0xF000) 
-					| ((scp->term.param[0] & 0x0F) << 8);
-			break;
-
-		case 'I': 	/* set ansi reverse video background */
-			if (scp->term.num_param == 1) 
-				scp->term.rev_attr = 
-					(scp->term.rev_attr & 0x0F00) 
-					| ((scp->term.param[0] & 0x0F) << 12);
-			break;
-		}
+    }
+    else if (scp->term.esc == 3) {
+	if (c >= '0' && c <= '9') {
+	    if (scp->term.num_param < MAX_ESC_PAR) {
+	    if (scp->term.last_param != scp->term.num_param) {
+		scp->term.last_param = scp->term.num_param;
+		scp->term.param[scp->term.num_param] = 0;
+	    }
+	    else
+		scp->term.param[scp->term.num_param] *= 10;
+	    scp->term.param[scp->term.num_param] += c - '0';
+	    return;
+	    }
+	}
+	scp->term.num_param = scp->term.last_param + 1;
+	switch (c) {
+
+	case ';':
+	    if (scp->term.num_param < MAX_ESC_PAR)
+		return;
+	    break;
+
+	case 'A':   /* set display border color */
+	    if (scp->term.num_param == 1)
+		scp->border=scp->term.param[0] & 0xff;
+		if (scp == cur_console)
+		    set_border(scp->border);
+	    break;
+
+	case 'B':   /* set bell pitch and duration */
+	    if (scp->term.num_param == 2) {
+		scp->bell_pitch = scp->term.param[0];
+		scp->bell_duration = scp->term.param[1]*10;
+	    }
+	    break;
+
+	case 'C':   /* set cursor type & shape */
+	    if (scp->term.num_param == 1) {
+		if (scp->term.param[0] & 0x01)
+		    configuration |= BLINK_CURSOR;
+		else
+		    configuration &= ~BLINK_CURSOR;
+		if (scp->term.param[0] & 0x02)
+		    configuration |= CHAR_CURSOR;
+		else
+		    configuration &= ~CHAR_CURSOR;
+	    }
+	    else if (scp->term.num_param == 2) {
+		scp->cursor_start = scp->term.param[0] & 0x1F; 
+		scp->cursor_end = scp->term.param[1] & 0x1F; 
+	    }
+	    break;
+
+	case 'F':   /* set ansi foreground */
+	    if (scp->term.num_param == 1) 
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0xF000) 
+		    | ((scp->term.param[0] & 0x0F) << 8);
+	    break;
+
+	case 'G':   /* set ansi background */
+	    if (scp->term.num_param == 1) 
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0x0F00) 
+		    | ((scp->term.param[0] & 0x0F) << 12);
+	    break;
+
+	case 'H':   /* set ansi reverse video foreground */
+	    if (scp->term.num_param == 1) 
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0xF000) 
+		    | ((scp->term.param[0] & 0x0F) << 8);
+	    break;
+
+	case 'I':   /* set ansi reverse video background */
+	    if (scp->term.num_param == 1) 
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0x0F00) 
+		    | ((scp->term.param[0] & 0x0F) << 12);
+	    break;
 	}
-	scp->term.esc = 0;
+    }
+    scp->term.esc = 0;
 }
 
 static inline void 
 draw_cursor(scr_stat *scp, int show)
 {
-	if (show && !(scp->status & CURSOR_SHOWN)) {
-	    u_short cursor_image = *(Crtat + (scp->cursor_pos - scp->scr_buf));
+    if (show && !(scp->status & CURSOR_SHOWN)) {
+	u_short cursor_image = *(Crtat + (scp->cursor_pos - scp->scr_buf));
 
-		scp->cursor_saveunder = cursor_image;
-		if (configuration & CHAR_CURSOR)
-			cursor_image = (cursor_image & 0xff00) | '_';
-		else {
-			if ((cursor_image & 0x7000) == 0x7000) {
-				cursor_image &= 0x8fff;
-				if(!(cursor_image & 0x0700))
-					cursor_image |= 0x0700;
-			} else {
-				cursor_image |= 0x7000;
-				if ((cursor_image & 0x0700) == 0x0700)
-					cursor_image &= 0xf0ff;
-			}
-		}
-		*(Crtat + (scp->cursor_pos - scp->scr_buf)) = cursor_image;
-		scp->status |= CURSOR_SHOWN;
-	}
-	if (!show && (scp->status & CURSOR_SHOWN)) {
-		*(Crtat+(scp->cursor_pos-scp->scr_buf)) = scp->cursor_saveunder;
-		scp->status &= ~CURSOR_SHOWN;
+	scp->cursor_saveunder = cursor_image;
+	if (configuration & CHAR_CURSOR)
+	    cursor_image = (cursor_image & 0xff00) | '_';
+	else {
+	    if ((cursor_image & 0x7000) == 0x7000) {
+		cursor_image &= 0x8fff;
+		if(!(cursor_image & 0x0700))
+		    cursor_image |= 0x0f00;
+	    } else {
+		cursor_image |= 0x7000;
+		if ((cursor_image & 0x0f00) == 0x0f00)
+		    cursor_image &= 0xf0ff;
+	    }
 	}
+	*(Crtat + (scp->cursor_pos - scp->scr_buf)) = cursor_image;
+	scp->status |= CURSOR_SHOWN;
+    }
+    if (!show && (scp->status & CURSOR_SHOWN)) {
+	*(Crtat+(scp->cursor_pos-scp->scr_buf)) = scp->cursor_saveunder;
+	scp->status &= ~CURSOR_SHOWN;
+    }
 }
 
 static void 
 ansi_put(scr_stat *scp, u_char *buf, int len)
 {
-	u_char *ptr = buf;
+    u_char *ptr = buf;
 
-	if (scp->status & UNKNOWN_MODE) 
-		return;
+    if (scp->status & UNKNOWN_MODE) 
+	return;
 
-	/* make screensaver happy */
-	if (scp == cur_console) {
-		scrn_time_stamp = time.tv_sec;
-		if (scrn_blanked)
-			SCRN_SAVER(FALSE);
-	}
-	write_in_progress++;
+    /* make screensaver happy */
+    if (scp == cur_console) {
+	scrn_time_stamp = time.tv_sec;
+	if (scrn_blanked)
+	    (*current_saver)(FALSE);
+    }
+    write_in_progress++;
 outloop:
-	if (scp->term.esc) {
-		scan_esc(scp, *ptr++);
-		len--;
+    if (scp->term.esc) {
+	scan_esc(scp, *ptr++);
+	len--;
+    }
+    else if (PRINTABLE(*ptr)) {     /* Print only printables */
+	do {
+	    *scp->cursor_pos++ = (scp->term.cur_attr | scr_map[*ptr++]);
+	    scp->xpos++;
+	    len--;
+	} while (len && PRINTABLE(*ptr) && (scp->xpos < scp->xsize));
+	if (scp->xpos >= scp->xsize) {
+	    scp->xpos = 0;
+	    scp->ypos++;
 	}
-	else if (PRINTABLE(*ptr)) { 	/* Print only printables */
-		do {
-			*scp->cursor_pos++ = 
-				(scp->term.cur_attr | scr_map[*ptr++]);
-			scp->xpos++;
-			len--;
-		} while (len && PRINTABLE(*ptr) && (scp->xpos < scp->xsize));
-		if (scp->xpos >= scp->xsize) {
-			scp->xpos = 0;
-			scp->ypos++;
+    }
+    else  {
+	switch(*ptr) {
+	case 0x07:
+	    do_bell(scp, scp->bell_pitch, scp->bell_duration);
+	    break;
+
+	case 0x08:      /* non-destructive backspace */
+	    if (scp->cursor_pos > scp->scr_buf) {
+		scp->cursor_pos--;
+		if (scp->xpos > 0)
+		    scp->xpos--;
+		else {
+		    scp->xpos += scp->xsize - 1;
+		    scp->ypos--;
 		}
-	}
-	else  {
-		switch(*ptr) {
-		case 0x07:
-			do_bell(scp, scp->bell_pitch, scp->bell_duration);
-			break;
-		case 0x08:      /* non-destructive backspace */
-			if (scp->cursor_pos > scp->scr_buf) {
-				scp->cursor_pos--;
-				if (scp->xpos > 0)
-					scp->xpos--;
-				else {
-					scp->xpos += scp->xsize - 1;
-					scp->ypos--;
-				}
-			}
-			break;
-		case 0x09:	/* non-destructive tab */
-			{
-				int i = 8 - scp->xpos % 8u;
-
-				scp->cursor_pos += i;
-				if ((scp->xpos += i) >= scp->xsize) {
-					scp->xpos = 0;
-					scp->ypos++;
-				}
-			}
-			break;
-		case 0x0a:	/* newline, same pos */
-			scp->cursor_pos += scp->xsize;
-			scp->ypos++;
-			break;
-		case 0x0c:	/* form feed, clears screen */
-			clear_screen(scp);
-			break;
-		case 0x0d:	/* return, return to pos 0 */
-			scp->cursor_pos -= scp->xpos;
-			scp->xpos = 0;
-			break;
-		case 0x1b:	/* start escape sequence */
-			scp->term.esc = 1;
-			scp->term.num_param = 0;
-			break;
+	    }
+	    break;
+
+	case 0x09:  /* non-destructive tab */
+	    {
+		int i = 8 - scp->xpos % 8u;
+
+		scp->cursor_pos += i;
+		if ((scp->xpos += i) >= scp->xsize) {
+		    scp->xpos = 0;
+		    scp->ypos++;
 		}
-		ptr++; len--;
-	}
-	/* do we have to scroll ?? */
-	if (scp->cursor_pos >= scp->scr_buf + scp->ysize * scp->xsize) {
-	    if (scp->history) {
-		bcopyw(scp->scr_buf, scp->history_head,
-		       scp->xsize * sizeof(u_short));
-
-		scp->history_head += scp->xsize;
-		if (scp->history_head + scp->xsize >
-		    scp->history + scp->history_size)
-			scp->history_head = scp->history;
 	    }
-	    bcopyw(scp->scr_buf + scp->xsize, scp->scr_buf,
-		   scp->xsize * (scp->ysize - 1) * sizeof(u_short));
-	    fillw(scp->term.cur_attr | scr_map[0x20],
-		  scp->scr_buf + scp->xsize * (scp->ysize - 1), 
-		  scp->xsize);
-	    scp->cursor_pos -= scp->xsize;
-	    scp->ypos--;
+	    break;
+
+	case 0x0a:  /* newline, same pos */
+	    scp->cursor_pos += scp->xsize;
+	    scp->ypos++;
+	    break;
+
+	case 0x0c:  /* form feed, clears screen */
+	    clear_screen(scp);
+	    break;
+
+	case 0x0d:  /* return, return to pos 0 */
+	    scp->cursor_pos -= scp->xpos;
+	    scp->xpos = 0;
+	    break;
+
+	case 0x1b:  /* start escape sequence */
+	    scp->term.esc = 1;
+	    scp->term.num_param = 0;
+	    break;
 	}
-	if (len)
-		goto outloop;
-	write_in_progress--;
-	if (delayed_next_scr)
-		switch_scr(scp, delayed_next_scr - 1);
+	ptr++; len--;
+    }
+    /* do we have to scroll ?? */
+    if (scp->cursor_pos >= scp->scr_buf + scp->ysize * scp->xsize) {
+	if (scp->history) {
+	    bcopyw(scp->scr_buf, scp->history_head,
+		   scp->xsize * sizeof(u_short));
+	    scp->history_head += scp->xsize;
+	    if (scp->history_head + scp->xsize >
+		scp->history + scp->history_size)
+		scp->history_head = scp->history;
+	}
+	bcopyw(scp->scr_buf + scp->xsize, scp->scr_buf,
+	       scp->xsize * (scp->ysize - 1) * sizeof(u_short));
+	fillw(scp->term.cur_attr | scr_map[0x20],
+	      scp->scr_buf + scp->xsize * (scp->ysize - 1), 
+	      scp->xsize);
+	scp->cursor_pos -= scp->xsize;
+	scp->ypos--;
+    }
+    if (len)
+	goto outloop;
+    write_in_progress--;
+    if (delayed_next_scr)
+	switch_scr(scp, delayed_next_scr - 1);
 }
 
 static void 
 scinit(void)
 {
-	u_short volatile *cp = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short), was;
-	unsigned hw_cursor;
-	int i;
+    u_short volatile *cp = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short), was;
+    unsigned hw_cursor;
+    int i;
+
+    if (init_done)  
+	return;
+    init_done = TRUE;
+    /*
+     * Crtat initialized to point to MONO buffer, if not present change
+     * to CGA_BUF offset. ONLY add the difference since locore.s adds
+     * in the remapped offset at the "right" time
+     */
+    was = *cp;
+    *cp = (u_short) 0xA55A;
+    if (*cp != 0xA55A)
+	crtc_addr = MONO_BASE;
+    else {
+	*cp = was;
+	crtc_addr = COLOR_BASE;
+	Crtat = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short);
+    }
+
+    /* extract cursor location */
+    outb(crtc_addr,14);
+    hw_cursor = inb(crtc_addr+1)<<8 ;
+    outb(crtc_addr,15);
+    hw_cursor |= inb(crtc_addr+1);
+
+    /* move hardware cursor out of the way */
+    outb(crtc_addr,14);
+    outb(crtc_addr+1, 0xff);
+    outb(crtc_addr,15);
+    outb(crtc_addr+1, 0xff);
+
+    /* is this a VGA or higher ? */
+    outb(crtc_addr, 7);
+    if (inb(crtc_addr) == 7) {
+	u_long  pa;
+	u_long  segoff;
+
+	crtc_vga = TRUE;
 
-	if (init_done) 	
-		return;
-	init_done = TRUE;
 	/*
-	 * Crtat initialized to point to MONO buffer, if not present change
-	 * to CGA_BUF offset. ONLY add the difference since locore.s adds
-	 * in the remapped offset at the "right" time
+	 * Get the BIOS video mode pointer.
 	 */
-	was = *cp;
-	*cp = (u_short) 0xA55A;
-	if (*cp != 0xA55A)
-		crtc_addr = MONO_BASE;
-	else {
-		*cp = was;
-		crtc_addr = COLOR_BASE;
-		Crtat = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short);
+	segoff = *(u_long *)pa_to_va(0x4a8);
+	pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
+	if (ISMAPPED(pa, sizeof(u_long))) {
+	    segoff = *(u_long *)pa_to_va(pa);
+	    pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
+	    if (ISMAPPED(pa, 64))
+		video_mode_ptr = (char *)pa_to_va(pa);
 	}
-
-	/* extract cursor location */
-	outb(crtc_addr,14);
-	hw_cursor = inb(crtc_addr+1)<<8 ;
-	outb(crtc_addr,15);
-	hw_cursor |= inb(crtc_addr+1);
-
-	/* move hardware cursor out of the way */
-	outb(crtc_addr,14);
-	outb(crtc_addr+1, 0xff);
-	outb(crtc_addr,15);
-	outb(crtc_addr+1, 0xff);
-
-	/* is this a VGA or higher ? */
-	outb(crtc_addr, 7);
-	if (inb(crtc_addr) == 7) {
-		u_long	pa;
-		u_long	segoff;
-
-		crtc_vga = TRUE;
-
-		/*
-		 * Get the BIOS video mode pointer.
-		 */
-		segoff = *(u_long *)pa_to_va(0x4a8);
-		pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
-		if (ISMAPPED(pa, sizeof(u_long))) {
-			segoff = *(u_long *)pa_to_va(pa);
-			pa = (((segoff & 0xffff0000) >> 12)
-			      + (segoff & 0xffff));
-			if (ISMAPPED(pa, 64))
-				video_mode_ptr = (char *)pa_to_va(pa);
-		}
-	}
-	current_default = &user_default;
-	console[0] = &main_console;
-	init_scp(console[0]);
-	console[0]->scr_buf = console[0]->mouse_pos =  Crtat;
-	console[0]->cursor_pos = Crtat + hw_cursor;
-	console[0]->xpos = hw_cursor % COL;
-	console[0]->ypos = hw_cursor / COL;
-	cur_console = console[0];
-	for (i=1; i<MAXCONS; i++)
-		console[i] = NULL;
-	kernel_console.esc = 0;
-	kernel_console.std_attr = kernel_default.std_attr;
-	kernel_console.rev_attr = kernel_default.rev_attr;
-	kernel_console.cur_attr = kernel_default.std_attr;
-	/* initialize mapscrn array to a one to one map */
-	for (i=0; i<sizeof(scr_map); i++)
-		scr_map[i] = i;
+    }
+    current_default = &user_default;
+    console[0] = &main_console;
+    init_scp(console[0]);
+    console[0]->scr_buf = console[0]->mouse_pos =  Crtat;
+    console[0]->cursor_pos = Crtat + hw_cursor;
+    console[0]->xpos = hw_cursor % COL;
+    console[0]->ypos = hw_cursor / COL;
+    cur_console = console[0];
+    for (i=1; i<MAXCONS; i++)
+	console[i] = NULL;
+    kernel_console.esc = 0;
+    kernel_console.std_attr = kernel_default.std_attr;
+    kernel_console.rev_attr = kernel_default.rev_attr;
+    kernel_console.cur_attr = kernel_default.std_attr;
+    /* initialize mapscrn array to a one to one map */
+    for (i=0; i<sizeof(scr_map); i++)
+	scr_map[i] = i;
 }
 
 static scr_stat 
 *alloc_scp()
 {
-	scr_stat *scp;
-
-	scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_NOWAIT);
-	init_scp(scp);
-	scp->scr_buf = scp->cursor_pos = scp->scr_buf = scp->mouse_pos =
-		(u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	scp->history_head = scp->history_pos = scp->history =
-		(u_short *)malloc(scp->history_size*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	bzero(scp->history_head, scp->history_size*sizeof(u_short));
-	if (crtc_vga && video_mode_ptr)
-		set_mode(scp);
-	clear_screen(scp);
-	return scp;
+    scr_stat *scp;
+
+    scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_NOWAIT);
+    init_scp(scp);
+    scp->scr_buf = scp->cursor_pos = scp->scr_buf = scp->mouse_pos =
+	(u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    scp->history_head = scp->history_pos = scp->history =
+	(u_short *)malloc(scp->history_size*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    bzero(scp->history_head, scp->history_size*sizeof(u_short));
+    if (crtc_vga && video_mode_ptr)
+	set_mode(scp);
+    clear_screen(scp);
+    return scp;
 }
 
 static void
 init_scp(scr_stat *scp)
 {
-	scp->mode = M_VGA_C80x25;
-	scp->font = FONT_16;
-	scp->xsize = COL;
-	scp->ysize = ROW;
-	scp->term.esc = 0;
-	scp->term.std_attr = current_default->std_attr;
-	scp->term.rev_attr = current_default->rev_attr;
-	scp->term.cur_attr = scp->term.std_attr;
-	scp->border = BG_BLACK;
-	scp->cursor_start = -1;
-	scp->cursor_end = -1;
-	scp->mouse_xpos = scp->mouse_ypos = 0;
-	scp->bell_pitch = BELL_PITCH;
-	scp->bell_duration = BELL_DURATION;
-	scp->status = (*(char *)pa_to_va(0x417) & 0x20) ? NLKED : 0;
-	scp->status |= CURSOR_ENABLED;
-	scp->pid = 0;
-	scp->proc = NULL;
-	scp->smode.mode = VT_AUTO;
-	scp->history_head = scp->history_pos = scp->history = NULL;
-	scp->history_size = HISTORY_SIZE;
-}
-
-static void 
-scput(u_char c)
-{
-	scr_stat *scp;
-	term_stat save;
-
-	scp = console[0];
-	save = scp->term;
-	scp->term = kernel_console;
-	current_default = &kernel_default;
-	if (scp->scr_buf == Crtat)
-		draw_cursor(scp, FALSE);
-	ansi_put(scp, &c, 1);
-	scp->status |= UPDATE_SCREEN;
-	kernel_console = scp->term;
-	current_default = &user_default;
-	scp->term = save;
-	if (scp == cur_console /* && scrn_timer not running */) {
-		if (scp->scr_buf != Crtat) {
-	    		bcopyw(scp->scr_buf, Crtat,
-			       (scp->xsize*scp->ysize)*sizeof(u_short));
-	    		scp->status &= ~CURSOR_SHOWN;
-		}
-		draw_cursor(scp, TRUE);
-		scp->status &= ~UPDATE_SCREEN;
-	}
+    scp->mode = M_VGA_C80x25;
+    scp->font = FONT_16;
+    scp->xsize = COL;
+    scp->ysize = ROW;
+    scp->term.esc = 0;
+    scp->term.std_attr = current_default->std_attr;
+    scp->term.rev_attr = current_default->rev_attr;
+    scp->term.cur_attr = scp->term.std_attr;
+    scp->border = BG_BLACK;
+    scp->cursor_start = -1;
+    scp->cursor_end = -1;
+    scp->mouse_xpos = scp->mouse_ypos = 0;
+    scp->bell_pitch = BELL_PITCH;
+    scp->bell_duration = BELL_DURATION;
+    scp->status = (*(char *)pa_to_va(0x417) & 0x20) ? NLKED : 0;
+    scp->status |= CURSOR_ENABLED;
+    scp->pid = 0;
+    scp->proc = NULL;
+    scp->smode.mode = VT_AUTO;
+    scp->history_head = scp->history_pos = scp->history = NULL;
+    scp->history_size = HISTORY_SIZE;
 }
 
 static u_char 
 *get_fstr(u_int c, u_int *len)
 {
-	u_int i;
-
-	if (!(c & FKEY))
-		return(NULL);
-	i = (c & 0xFF) - F_FN;
-	if (i > n_fkey_tab)
-		return(NULL);
-	*len = fkey_tab[i].len;
-	return(fkey_tab[i].str);
+    u_int i;
+
+    if (!(c & FKEY))
+	return(NULL);
+    i = (c & 0xFF) - F_FN;
+    if (i > n_fkey_tab)
+	return(NULL);
+    *len = fkey_tab[i].len;
+    return(fkey_tab[i].str);
 }
 
 static void 
 update_leds(int which)
 {
-	int s;
-	static u_char xlate_leds[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
+    int s;
+    static u_char xlate_leds[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
 
-	/* replace CAPS led with ALTGR led for ALTGR keyboards */
-	if (key_map.n_keys > ALTGR_OFFSET) {
-		if (which & ALKED)
-			which |= CLKED;
-		else
-			which &= ~CLKED;
-	}
-	s = spltty();
-	kbd_cmd(KB_SETLEDS);
-	kbd_cmd(xlate_leds[which & LED_MASK]);
-	splx(s);
+    /* replace CAPS led with ALTGR led for ALTGR keyboards */
+    if (key_map.n_keys > ALTGR_OFFSET) {
+	if (which & ALKED)
+	    which |= CLKED;
+	else
+	    which &= ~CLKED;
+    }
+    s = spltty();
+    kbd_cmd(KB_SETLEDS);
+    kbd_cmd(xlate_leds[which & LED_MASK]);
+    splx(s);
 }
   
 static void
 history_to_screen(scr_stat *scp)
 {
-	int i;
-
-	scp->status &= ~UPDATE_SCREEN;
-	for (i=0; i<scp->ysize; i++)
-		bcopyw(scp->history + (((scp->history_pos - scp->history) + 
-		       scp->history_size-((i+1)*scp->xsize))%scp->history_size),
-		       scp->scr_buf + (scp->xsize * (scp->ysize-1 - i)),
-		       scp->xsize * sizeof(u_short));
-	scp->status |= UPDATE_SCREEN;
+    int i;
+
+    scp->status &= ~UPDATE_SCREEN;
+    for (i=0; i<scp->ysize; i++)
+	bcopyw(scp->history + (((scp->history_pos - scp->history) + 
+	       scp->history_size-((i+1)*scp->xsize))%scp->history_size),
+	       scp->scr_buf + (scp->xsize * (scp->ysize-1 - i)),
+	       scp->xsize * sizeof(u_short));
+    scp->status |= UPDATE_SCREEN;
 }
 
 static int
 history_up_line(scr_stat *scp)
 {
-	if (WRAPHIST(scp, scp->history_pos, -(scp->xsize*scp->ysize)) !=
-	    scp->history_head) {
-		scp->history_pos = WRAPHIST(scp, scp->history_pos, -scp->xsize);
-		history_to_screen(scp);
-		return 0;
-	}
-	else
-		return -1;
+    if (WRAPHIST(scp, scp->history_pos, -(scp->xsize*scp->ysize)) !=
+	scp->history_head) {
+	scp->history_pos = WRAPHIST(scp, scp->history_pos, -scp->xsize);
+	history_to_screen(scp);
+	return 0;
+    }
+    else
+	return -1;
 }
 
 static int
 history_down_line(scr_stat *scp)
 {
-	if (scp->history_pos != scp->history_head) {
-		scp->history_pos = WRAPHIST(scp, scp->history_pos, scp->xsize);
-		history_to_screen(scp);
-		return 0;
-	}
-	else
-		return -1;
+    if (scp->history_pos != scp->history_head) {
+	scp->history_pos = WRAPHIST(scp, scp->history_pos, scp->xsize);
+	history_to_screen(scp);
+	return 0;
+    }
+    else
+	return -1;
 }
 
 /*
@@ -2503,875 +2088,882 @@ history_down_line(scr_stat *scp)
 u_int 
 scgetc(int noblock)
 {
-	u_char scancode, keycode;
-	u_int state, action;
-	struct key_t *key;
-	static u_char esc_flag = 0, compose = 0;
-	static u_int chr = 0;
+    u_char scancode, keycode;
+    u_int state, action;
+    struct key_t *key;
+    static u_char esc_flag = 0, compose = 0;
+    static u_int chr = 0;
 
 next_code:
-	kbd_wait();
-	/* First see if there is something in the keyboard port */
-	if (inb(KB_STAT) & KB_BUF_FULL)
-		scancode = inb(KB_DATA);
-	else if (noblock)
-		return(NOKEY);
-	else
-		goto next_code;
+    kbd_wait();
+    /* First see if there is something in the keyboard port */
+    if (inb(KB_STAT) & KB_BUF_FULL)
+	scancode = inb(KB_DATA);
+    else if (noblock)
+	return(NOKEY);
+    else
+	goto next_code;
 
-	if (cur_console->status & KBD_RAW_MODE)
-		return scancode;
+    if (cur_console->status & KBD_RAW_MODE)
+	return scancode;
 #if ASYNCH
-	if (scancode == KB_ACK || scancode == KB_RESEND) {
-		kbd_reply = scancode;
-		if (noblock)
-			return(NOKEY);
-		goto next_code;
-	}
+    if (scancode == KB_ACK || scancode == KB_RESEND) {
+	kbd_reply = scancode;
+	if (noblock)
+	    return(NOKEY);
+	goto next_code;
+    }
 #endif
-	keycode = scancode & 0x7F;
-	switch (esc_flag) {
-	case 0x00:		/* normal scancode */
-		switch(scancode) {
-		case 0xB8:	/* left alt  (compose key) */
-			if (compose) {
-				compose = 0;	
-				if (chr > 255) {
-					do_bell(cur_console, 
-						BELL_PITCH, BELL_DURATION);
-					chr = 0;
-				}
-			}
-			break;
-		case 0x38:
-			if (!compose) {
-				compose = 1;
-				chr = 0;
-			}
-			break;
-		case 0xE0:
-		case 0xE1:
-			esc_flag = scancode;
-			goto next_code;		
-		}
-		break;
-	case 0xE0:		/* 0xE0 prefix */
-		esc_flag = 0;
-		switch (keycode) {
-		case 0x1C:	/* right enter key */
-			keycode = 0x59;
-			break;
-		case 0x1D:	/* right ctrl key */
-			keycode = 0x5A;
-			break;
-		case 0x35:	/* keypad divide key */
-			keycode = 0x5B;
-			break;
-		case 0x37:	/* print scrn key */
-			keycode = 0x5C;
-			break;
-		case 0x38:	/* right alt key (alt gr) */
-			keycode = 0x5D;
-			break;
-		case 0x47:	/* grey home key */
-			keycode = 0x5E;
-			break;
-		case 0x48:	/* grey up arrow key */
-			keycode = 0x5F;
-			break;
-		case 0x49:	/* grey page up key */
-			keycode = 0x60;
-			break;
-		case 0x4B:	/* grey left arrow key */
-			keycode = 0x61;
-			break;
-		case 0x4D:	/* grey right arrow key */
-			keycode = 0x62;
-			break;
-		case 0x4F:	/* grey end key */
-			keycode = 0x63;
-			break;
-		case 0x50:	/* grey down arrow key */
-			keycode = 0x64;
-			break;
-		case 0x51:	/* grey page down key */
-			keycode = 0x65;
-			break;
-		case 0x52:	/* grey insert key */
-			keycode = 0x66;
-			break;
-		case 0x53:	/* grey delete key */
-			keycode = 0x67;
-			break;
-
-		/* the following 3 are only used on the MS "Natural" keyboard */
-		case 0x5b:	/* left Window key */
-			keycode = 0x69;
-			break;
-		case 0x5c:	/* right Window key */
-			keycode = 0x6a;
-			break;
-		case 0x5d:	/* menu key */
-			keycode = 0x6b;
-			break;
-		default:	/* ignore everything else */
-			goto next_code;
+    keycode = scancode & 0x7F;
+    switch (esc_flag) {
+    case 0x00:      /* normal scancode */
+	switch(scancode) {
+	case 0xB8:  /* left alt  (compose key) */
+	    if (compose) {
+		compose = 0;    
+		if (chr > 255) {
+		    do_bell(cur_console, 
+			BELL_PITCH, BELL_DURATION);
+		    chr = 0;
 		}
+	    }
+	    break;
+	case 0x38:
+	    if (!compose) {
+		compose = 1;
+		chr = 0;
+	    }
+	    break;
+	case 0xE0:
+	case 0xE1:
+	    esc_flag = scancode;
+	    goto next_code;     
+	}
+	break;
+    case 0xE0:      /* 0xE0 prefix */
+	esc_flag = 0;
+	switch (keycode) {
+	case 0x1C:  /* right enter key */
+	    keycode = 0x59;
+	    break;
+	case 0x1D:  /* right ctrl key */
+	    keycode = 0x5A;
+	    break;
+	case 0x35:  /* keypad divide key */
+	    keycode = 0x5B;
+	    break;
+	case 0x37:  /* print scrn key */
+	    keycode = 0x5C;
+	    break;
+	case 0x38:  /* right alt key (alt gr) */
+	    keycode = 0x5D;
+	    break;
+	case 0x47:  /* grey home key */
+	    keycode = 0x5E;
+	    break;
+	case 0x48:  /* grey up arrow key */
+	    keycode = 0x5F;
+	    break;
+	case 0x49:  /* grey page up key */
+	    keycode = 0x60;
+	    break;
+	case 0x4B:  /* grey left arrow key */
+	    keycode = 0x61;
+	    break;
+	case 0x4D:  /* grey right arrow key */
+	    keycode = 0x62;
+	    break;
+	case 0x4F:  /* grey end key */
+	    keycode = 0x63;
+	    break;
+	case 0x50:  /* grey down arrow key */
+	    keycode = 0x64;
+	    break;
+	case 0x51:  /* grey page down key */
+	    keycode = 0x65;
+	    break;
+	case 0x52:  /* grey insert key */
+	    keycode = 0x66;
+	    break;
+	case 0x53:  /* grey delete key */
+	    keycode = 0x67;
+	    break;
+
+	/* the following 3 are only used on the MS "Natural" keyboard */
+	case 0x5b:  /* left Window key */
+	    keycode = 0x69;
+	    break;
+	case 0x5c:  /* right Window key */
+	    keycode = 0x6a;
+	    break;
+	case 0x5d:  /* menu key */
+	    keycode = 0x6b;
+	    break;
+	default:    /* ignore everything else */
+	    goto next_code;
+	}
+	break;
+    case 0xE1:      /* 0xE1 prefix */
+	esc_flag = 0;   
+	if (keycode == 0x1D)
+	    esc_flag = 0x1D;
+	goto next_code;
+	/* NOT REACHED */
+    case 0x1D:      /* pause / break */
+	esc_flag = 0;   
+	if (keycode != 0x45)
+	    goto next_code;
+	keycode = 0x68;
+	break;
+    }
+
+    /* if scroll-lock pressed allow history browsing */
+    if (cur_console->history && cur_console->status & SLKED) {
+	int i;
+
+	cur_console->status &= ~CURSOR_ENABLED;
+	if (!(cur_console->status & BUFFER_SAVED)) {
+	    cur_console->status |= BUFFER_SAVED;
+	    cur_console->history_save = cur_console->history_head;
+
+	    /* copy screen into top of history buffer */
+	    for (i=0; i<cur_console->ysize; i++) {
+		bcopyw(cur_console->scr_buf + (cur_console->xsize * i), 
+		       cur_console->history_head,
+		       cur_console->xsize * sizeof(u_short));
+		cur_console->history_head += cur_console->xsize;
+		if (cur_console->history_head + cur_console->xsize >
+		    cur_console->history + cur_console->history_size)
+		    cur_console->history_head=cur_console->history;
+	    }
+	    cur_console->history_pos = cur_console->history_head;
+	    history_to_screen(cur_console);
+	}
+	switch (scancode) {
+	case 0x47:  /* home key */
+	    cur_console->history_pos = cur_console->history_head;
+	    history_to_screen(cur_console);
+	    goto next_code;
+
+	case 0x4F:  /* end key */
+	    cur_console->history_pos =
+		WRAPHIST(cur_console, cur_console->history_head, 
+			 cur_console->xsize*cur_console->ysize);
+	    history_to_screen(cur_console);
+	    goto next_code;
+
+	case 0x48:  /* up arrow key */
+	    if (history_up_line(cur_console))
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+	    goto next_code;
+
+	case 0x50:  /* down arrow key */
+	    if (history_down_line(cur_console))
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+	    goto next_code;
+
+	case 0x49:  /* page up key */
+	    for (i=0; i<cur_console->ysize; i++)
+	    if (history_up_line(cur_console)) {
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
 		break;
-	case 0xE1:		/* 0xE1 prefix */
-		esc_flag = 0;	
-		if (keycode == 0x1D)
-			esc_flag = 0x1D;
-		goto next_code;
-		/* NOT REACHED */
-	case 0x1D:		/* pause / break */
-		esc_flag = 0;	
-		if (keycode != 0x45)
-			goto next_code;
-		keycode = 0x68;
+	    }
+	    goto next_code;
+
+	case 0x51:  /* page down key */
+	    for (i=0; i<cur_console->ysize; i++)
+	    if (history_down_line(cur_console)) {
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
 		break;
+	    }
+	    goto next_code;
 	}
+    }
 
-	/* if scroll-lock pressed allow history browsing */
-	if (cur_console->history && cur_console->status & SLKED) {
-		int i;
-
-		cur_console->status &= ~CURSOR_ENABLED;
-		if (!(cur_console->status & BUFFER_SAVED)) {
-		    cur_console->status |= BUFFER_SAVED;
-		    cur_console->history_save = cur_console->history_head;
-		    /* copy screen into top of history buffer */
-		    for (i=0; i<cur_console->ysize; i++) {
-			bcopyw(cur_console->scr_buf + (cur_console->xsize * i), 
-			       cur_console->history_head,
-			       cur_console->xsize * sizeof(u_short));
-
-			cur_console->history_head += cur_console->xsize;
-			if (cur_console->history_head + cur_console->xsize >
-			    cur_console->history + cur_console->history_size)
-				cur_console->history_head=cur_console->history;
-		    }
-		    cur_console->history_pos = cur_console->history_head;
-		    history_to_screen(cur_console);
-		}
-		switch (scancode) {
-		case 0x47:	/* home key */
-		    cur_console->history_pos = cur_console->history_head;
-		    history_to_screen(cur_console);
-		    goto next_code;
-
-		case 0x4F:	/* end key */
-		    cur_console->history_pos =
-			WRAPHIST(cur_console, cur_console->history_head, 
-				 cur_console->xsize*cur_console->ysize);
-		    history_to_screen(cur_console);
-		    goto next_code;
-
-		case 0x48:	/* up arrow key */
-		    if (history_up_line(cur_console))
-			do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-		    goto next_code;
-
-		case 0x50:	/* down arrow key */
-		    if (history_down_line(cur_console))
-			do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-		    goto next_code;
-
-		case 0x49:	/* page up key */
-		    for (i=0; i<cur_console->ysize; i++)
-			if (history_up_line(cur_console)) {
-			    do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-			    break;
-		    }
-		    goto next_code;
-
-		case 0x51:	/* page down key */
-		    for (i=0; i<cur_console->ysize; i++)
-			if (history_down_line(cur_console)) {
-			    do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-			    break;
-		    }
-		    goto next_code;
-		}
+    if (compose) {
+	switch (scancode) {
+	/* key pressed process it */
+	case 0x47: case 0x48: case 0x49:    /* keypad 7,8,9 */
+	    chr = (scancode - 0x40) + chr*10;
+	    goto next_code;
+	case 0x4B: case 0x4C: case 0x4D:    /* keypad 4,5,6 */ 
+	    chr = (scancode - 0x47) + chr*10;
+	    goto next_code;
+	case 0x4F: case 0x50: case 0x51:    /* keypad 1,2,3 */ 
+	    chr = (scancode - 0x4E) + chr*10;
+	    goto next_code;
+	case 0x52:              /* keypad 0 */
+	    chr *= 10;
+	    goto next_code;
+
+	/* key release, no interest here */
+	case 0xC7: case 0xC8: case 0xC9:    /* keypad 7,8,9 */
+	case 0xCB: case 0xCC: case 0xCD:    /* keypad 4,5,6 */ 
+	case 0xCF: case 0xD0: case 0xD1:    /* keypad 1,2,3 */ 
+	case 0xD2:              /* keypad 0 */
+	    goto next_code;
+
+	case 0x38:              /* left alt key */
+	    break;
+	default:
+	    if (chr) {
+		compose = chr = 0;
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+		goto next_code;     
+	    }
+	    break;
 	}
-
-	if (compose) {
-		switch (scancode) {
-		/* key pressed process it */
-		case 0x47: case 0x48: case 0x49:	/* keypad 7,8,9 */
-			chr = (scancode - 0x40) + chr*10;
-			goto next_code;
-		case 0x4B: case 0x4C: case 0x4D:	/* keypad 4,5,6 */ 
-			chr = (scancode - 0x47) + chr*10;
-			goto next_code;
-		case 0x4F: case 0x50: case 0x51:	/* keypad 1,2,3 */ 
-			chr = (scancode - 0x4E) + chr*10;
-			goto next_code;
-		case 0x52:				/* keypad 0 */
-			chr *= 10;
-			goto next_code;
-
-		/* key release, no interest here */
-		case 0xC7: case 0xC8: case 0xC9:	/* keypad 7,8,9 */
-		case 0xCB: case 0xCC: case 0xCD:	/* keypad 4,5,6 */ 
-		case 0xCF: case 0xD0: case 0xD1:	/* keypad 1,2,3 */ 
-		case 0xD2:				/* keypad 0 */
-			goto next_code;
-
-		case 0x38:				/* left alt key */
-			break;
-		default:
-			if (chr) {
-				compose = chr = 0;
-				do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-				goto next_code;		
-			}
-			break;
-		}
+    }
+	
+    state = (shfts ? 1 : 0 ) | (2 * (ctls ? 1 : 0)) | (4 * (alts ? 1 : 0));
+    if ((!agrs && (cur_console->status & ALKED))
+	|| (agrs && !(cur_console->status & ALKED)))
+	keycode += ALTGR_OFFSET;
+    key = &key_map.key[keycode];
+    if ( ((key->flgs & FLAG_LOCK_C) && (cur_console->status & CLKED))
+	 || ((key->flgs & FLAG_LOCK_N) && (cur_console->status & NLKED)) )
+	state ^= 1;
+
+    /* Check for make/break */
+    action = key->map[state];
+    if (scancode & 0x80) {      /* key released */
+	if (key->spcl & 0x80) {
+	    switch (action) {
+	    case LSH:
+		shfts &= ~1;
+		break;
+	    case RSH:
+		shfts &= ~2;
+		break;
+	    case LCTR:
+		ctls &= ~1;
+		break;
+	    case RCTR:
+		ctls &= ~2;
+		break;
+	    case LALT:
+		alts &= ~1;
+		break;
+	    case RALT:
+		alts &= ~2;
+		break;
+	    case NLK:
+		nlkcnt = 0;             
+		break;
+	    case CLK:
+		clkcnt = 0;
+		break;
+	    case SLK:
+		slkcnt = 0;
+		break;
+	    case ASH:
+		agrs = 0;
+		break;
+	    case ALK:
+		alkcnt = 0;
+		break;
+	    case META:
+		metas = 0;
+		break;
+	    }
 	}
-		
-	state = (shfts ? 1 : 0 ) | (2 * (ctls ? 1 : 0)) | (4 * (alts ? 1 : 0));
-	if ((!agrs && (cur_console->status & ALKED))
-	    || (agrs && !(cur_console->status & ALKED)))
-		keycode += ALTGR_OFFSET;
-	key = &key_map.key[keycode];
-	if ( ((key->flgs & FLAG_LOCK_C) && (cur_console->status & CLKED))
-	     || ((key->flgs & FLAG_LOCK_N) && (cur_console->status & NLKED)) )
-		state ^= 1;
-
-	/* Check for make/break */
-	action = key->map[state];
-	if (scancode & 0x80) { 		/* key released */
-		if (key->spcl & 0x80) {
-			switch (action) {
-			case LSH:
-				shfts &= ~1;
-				break;
-			case RSH:
-				shfts &= ~2;
-				break;
-			case LCTR:
-				ctls &= ~1;
-				break;
-			case RCTR:
-				ctls &= ~2;
-				break;
-			case LALT:
-				alts &= ~1;
-				break;
-			case RALT:
-				alts &= ~2;
-				break;
-			case NLK:
-				nlkcnt = 0;				
-				break;
-			case CLK:
-				clkcnt = 0;
-				break;
-			case SLK:
-				slkcnt = 0;
-				break;
-			case ASH:
-				agrs = 0;
-				break;
-			case ALK:
-				alkcnt = 0;
-				break;
-			case META:
-				metas = 0;
-				break;
+	if (chr && !compose) {
+	    action = chr;
+	    chr = 0;
+	    return(action);
+	}
+    } else {
+	/* key pressed */
+	if (key->spcl & (0x80>>state)) {
+	    switch (action) {
+	    /* LOCKING KEYS */
+	    case NLK:
+		if (!nlkcnt) {
+		    nlkcnt++;
+		    if (cur_console->status & NLKED) 
+			cur_console->status &= ~NLKED;
+		    else
+			cur_console->status |= NLKED;
+		    update_leds(cur_console->status);
+		}
+		break;
+	    case CLK:
+		if (!clkcnt) {
+		    clkcnt++;
+		    if (cur_console->status & CLKED)
+			cur_console->status &= ~CLKED;
+		    else
+			cur_console->status |= CLKED;
+		    update_leds(cur_console->status);
+		}
+		break;
+	    case SLK:
+		if (!slkcnt) {
+		    slkcnt++;
+		    if (cur_console->status & SLKED) {
+			cur_console->status &= ~SLKED;
+			if (cur_console->status & BUFFER_SAVED){
+			    int i;
+			    u_short *ptr = cur_console->history_save;
+
+			    for (i=0; i<cur_console->ysize; i++) {
+				bcopyw(ptr, 
+				       cur_console->scr_buf +
+				       (cur_console->xsize*i),
+				       cur_console->xsize * sizeof(u_short));
+				ptr += cur_console->xsize;
+				if (ptr + cur_console->xsize >
+				    cur_console->history +
+				    cur_console->history_size)
+				    ptr = cur_console->history;
+			    }
+			    cur_console->status&=~BUFFER_SAVED;
+			    cur_console->history_head=cur_console->history_save;
+			    cur_console->status|=(CURSOR_ENABLED|UPDATE_SCREEN);
 			}
+			scstart(VIRTUAL_TTY(get_scr_num()));
+		    } 
+		    else 
+			cur_console->status |= SLKED;
+		    update_leds(cur_console->status);
 		}
-		if (chr && !compose) {
-			action = chr;
-			chr = 0;
-			return(action);
+		break;
+	    case ALK:
+		if (!alkcnt) {
+		    alkcnt++;
+		    if (cur_console->status & ALKED)
+			cur_console->status &= ~ALKED;
+		    else
+			cur_console->status |= ALKED;
+		    update_leds(cur_console->status);
 		}
-	} else {
-		/* key pressed */
-		if (key->spcl & (0x80>>state)) {
-			switch (action) {
-			/* LOCKING KEYS */
-			case NLK:
-				if (!nlkcnt) {
-					nlkcnt++;
-					if (cur_console->status & NLKED) 
-						cur_console->status &= ~NLKED;
-					else
-						cur_console->status |= NLKED;
-					update_leds(cur_console->status);
-				}
-				break;
-			case CLK:
-				if (!clkcnt) {
-					clkcnt++;
-					if (cur_console->status & CLKED)
-						cur_console->status &= ~CLKED;
-					else
-						cur_console->status |= CLKED;
-					update_leds(cur_console->status);
-				}
-				break;
-			case SLK:
-				if (!slkcnt) {
-				    slkcnt++;
-				    if (cur_console->status & SLKED) {
-					cur_console->status &= ~SLKED;
-					if (cur_console->status & BUFFER_SAVED){
-					    int i;
-		    for (i=0; i<cur_console->ysize; i++) {
-			bcopyw(cur_console->history_save+(cur_console->xsize*i),
-			       cur_console->scr_buf + (cur_console->xsize * i), 
-			       cur_console->xsize * sizeof(u_short));
-		    }
-					    cur_console->status&=~BUFFER_SAVED;
-					    cur_console->history_head =
-						cur_console->history_save;
-					    cur_console->status |= 
-						(CURSOR_ENABLED|UPDATE_SCREEN);
-					}
-					scstart(VIRTUAL_TTY(get_scr_num()));
-				    } 
-				    else 
-					cur_console->status |= SLKED;
-				    update_leds(cur_console->status);
-				}
-				break;
-			case ALK:
-				if (!alkcnt) {
-					alkcnt++;
-					if (cur_console->status & ALKED)
-						cur_console->status &= ~ALKED;
-					else
-						cur_console->status |= ALKED;
-					update_leds(cur_console->status);
-				}
-				break;
-
-			/* NON-LOCKING KEYS */
-			case NOP:
-				break;
-			case RBT:
-				shutdown_nice();
-				break;	
-			case SUSP:
+		break;
+
+	    /* NON-LOCKING KEYS */
+	    case NOP:
+		break;
+	    case RBT:
+		shutdown_nice();
+		break;  
+	    case SUSP:
 #if NAPM > 0 
-				apm_suspend();
+		apm_suspend();
 #endif
-				break;
-
-			case DBG:
-#ifdef DDB			/* try to switch to console 0 */
-				if (cur_console->smode.mode == VT_AUTO &&
-				    console[0]->smode.mode == VT_AUTO)
-					switch_scr(cur_console, 0); 
-				Debugger("manual escape to debugger");
-				return(NOKEY);
+		break;
+
+	    case DBG:
+#ifdef DDB          /* try to switch to console 0 */
+		if (cur_console->smode.mode == VT_AUTO &&
+		    console[0]->smode.mode == VT_AUTO)
+		    switch_scr(cur_console, 0); 
+		Debugger("manual escape to debugger");
+		return(NOKEY);
 #else
-				printf("No debugger in kernel\n");
+		printf("No debugger in kernel\n");
 #endif
-				break;
-			case LSH:
-				shfts |= 1;
-				break;
-			case RSH:
-				shfts |= 2;
-				break;
-			case LCTR:
-				ctls |= 1;
-				break;
-			case RCTR:
-				ctls |= 2;
-				break;
-			case LALT:
-				alts |= 1;
-				break;
-			case RALT:
-				alts |= 2;
-				break;
-			case ASH:
-				agrs = 1;
-				break;
-			case META:
-				metas = 1;
-				break;
-			case NEXT:
-				switch_scr(cur_console,
-					   (get_scr_num() + 1) % MAXCONS);
-				break;
-			case BTAB:
-				return(BKEY);
-			default:
-				if (action >= F_SCR && action <= L_SCR) {
-					switch_scr(cur_console, action - F_SCR);
-					break;
-				}
-				if (action >= F_FN && action <= L_FN) 
-					action |= FKEY;
-				return(action);
-			}
-		}
-		else {
-			if (metas)
-				action |= MKEY;
-			return(action);
+		break;
+	    case LSH:
+		shfts |= 1;
+		break;
+	    case RSH:
+		shfts |= 2;
+		break;
+	    case LCTR:
+		ctls |= 1;
+		break;
+	    case RCTR:
+		ctls |= 2;
+		break;
+	    case LALT:
+		alts |= 1;
+		break;
+	    case RALT:
+		alts |= 2;
+		break;
+	    case ASH:
+		agrs = 1;
+		break;
+	    case META:
+		metas = 1;
+		break;
+	    case NEXT:
+		switch_scr(cur_console, (get_scr_num() + 1) % MAXCONS);
+		break;
+	    case BTAB:
+		return(BKEY);
+	    default:
+		if (action >= F_SCR && action <= L_SCR) {
+		    switch_scr(cur_console, action - F_SCR);
+		    break;
 		}
+		if (action >= F_FN && action <= L_FN) 
+		    action |= FKEY;
+		return(action);
+	    }
 	}
-	goto next_code;
+	else {
+	    if (metas)
+		action |= MKEY;
+	    return(action);
+	}
+    }
+    goto next_code;
 }
 
 int 
 scmmap(dev_t dev, int offset, int nprot)
 {
-	if (offset > 0x20000 - PAGE_SIZE)
-		return -1;
-	return i386_btop((VIDEOMEM + offset));
+    if (offset > 0x20000 - PAGE_SIZE)
+	return -1;
+    return i386_btop((VIDEOMEM + offset));
 }
 
 static void 
 kbd_wait(void)
 {
-	int i = 1000;
+    int i = 1000;
 
-	while (i--) {
-		if ((inb(KB_STAT) & KB_READY) == 0) 
-			break;
-		DELAY (10);
-	}
+    while (i--) {
+	if ((inb(KB_STAT) & KB_READY) == 0) 
+	    break;
+	DELAY (10);
+    }
 }
 
 static void 
 kbd_cmd(u_char command)
 {
-	int retry = 5;
-	do {
-		int i = 100000;
+    int retry = 5;
+    do {
+	int i = 100000;
 
-		kbd_wait();
+	kbd_wait();
 #if ASYNCH
-		kbd_reply = 0;
-		outb(KB_DATA, command);
-		while (i--) {
-			if (kbd_reply == KB_ACK)
-				return;
-			if (kbd_reply == KB_RESEND)
-				break;
-		}
+	kbd_reply = 0;
+	outb(KB_DATA, command);
+	while (i--) {
+	    if (kbd_reply == KB_ACK)
+		return;
+	    if (kbd_reply == KB_RESEND)
+		break;
+	}
 #else
-		outb(KB_DATA, command);
-		while (i--) {
-			if (inb(KB_STAT) & KB_BUF_FULL) {
-				int val;
-				DELAY(10);
-				val = inb(KB_DATA);
-				if (val == KB_ACK)
-					return;
-				if (val == KB_RESEND)
-					break;
-			}
-		}
+	outb(KB_DATA, command);
+	while (i--) {
+	    if (inb(KB_STAT) & KB_BUF_FULL) {
+		int val;
+		DELAY(10);
+		val = inb(KB_DATA);
+		if (val == KB_ACK)
+		    return;
+		if (val == KB_RESEND)
+		    break;
+	    }
+	}
 #endif
-	} while (retry--);
+    } while (retry--);
 }
 
 static void 
 set_mode(scr_stat *scp)
 {
-	char *modetable;
-	char special_modetable[64];
-	int mode, font_size;
+    char *modetable;
+    char special_modetable[64];
+    int mode, font_size;
 
-	if (scp != cur_console)
-		return;
+    if (scp != cur_console)
+	return;
 
-	/* setup video hardware for the given mode */
-	switch (scp->mode) {
-	case M_VGA_M80x60: 
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x60;
-
-	case M_VGA_C80x60: 
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x60:	special_modetable[2]  = 0x08;
-		special_modetable[19] = 0x47;
-		goto special_480l;
-
-	case M_VGA_M80x30:
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x30;
-
-	case M_VGA_C80x30:
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x30:	special_modetable[19] = 0x4f;
-special_480l:	special_modetable[9] |= 0xc0;
-		special_modetable[16] = 0x08;
-		special_modetable[17] = 0x3e;
-		special_modetable[26] = 0xea;
-		special_modetable[28] = 0xdf; 
-		special_modetable[31] = 0xe7;
-		special_modetable[32] = 0x04;
-		modetable = special_modetable;
-		goto setup_mode;
-
-	case M_ENH_B80x43:
-		bcopyw(video_mode_ptr+(64*M_ENH_B80x25),&special_modetable, 64);
-		goto special_80x43;
-
-	case M_ENH_C80x43:
-		bcopyw(video_mode_ptr+(64*M_ENH_C80x25),&special_modetable, 64);
-special_80x43:	special_modetable[28] = 87;
-		goto special_80x50;
-
-	case M_VGA_M80x50: 
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x50;
-
-	case M_VGA_C80x50:
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x50: 	special_modetable[2] = 8;
-		special_modetable[19] = 7;
-		modetable = special_modetable;
-		goto setup_mode;
-
-	case M_VGA_C40x25: case M_VGA_C80x25:	/* VGA TEXT MODES */
-	case M_VGA_M80x25: 
-	case M_B40x25:     case M_C40x25:	
-	case M_B80x25:     case M_C80x25:
-	case M_ENH_B40x25: case M_ENH_C40x25: 
-	case M_ENH_B80x25: case M_ENH_C80x25:
-
-		modetable = video_mode_ptr + (scp->mode * 64);
+    /* setup video hardware for the given mode */
+    switch (scp->mode) {
+    case M_VGA_M80x60: 
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x60;
+
+    case M_VGA_C80x60: 
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x60:
+	special_modetable[2]  = 0x08;
+	special_modetable[19] = 0x47;
+	goto special_480l;
+
+    case M_VGA_M80x30:
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x30;
+
+    case M_VGA_C80x30:
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x30:
+	special_modetable[19] = 0x4f;
+special_480l:
+	special_modetable[9] |= 0xc0;
+	special_modetable[16] = 0x08;
+	special_modetable[17] = 0x3e;
+	special_modetable[26] = 0xea;
+	special_modetable[28] = 0xdf; 
+	special_modetable[31] = 0xe7;
+	special_modetable[32] = 0x04;
+	modetable = special_modetable;
+	goto setup_mode;
+
+    case M_ENH_B80x43:
+	bcopyw(video_mode_ptr+(64*M_ENH_B80x25),&special_modetable, 64);
+	goto special_80x43;
+
+    case M_ENH_C80x43:
+	bcopyw(video_mode_ptr+(64*M_ENH_C80x25),&special_modetable, 64);
+special_80x43:  
+	special_modetable[28] = 87;
+	goto special_80x50;
+
+    case M_VGA_M80x50: 
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x50;
+
+    case M_VGA_C80x50:
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x50:  
+	special_modetable[2] = 8;
+	special_modetable[19] = 7;
+	modetable = special_modetable;
+	goto setup_mode;
+
+    case M_VGA_C40x25: case M_VGA_C80x25:
+    case M_VGA_M80x25:
+    case M_B40x25:     case M_C40x25:
+    case M_B80x25:     case M_C80x25:
+    case M_ENH_B40x25: case M_ENH_C40x25:
+    case M_ENH_B80x25: case M_ENH_C80x25:
+
+	modetable = video_mode_ptr + (scp->mode * 64);
 setup_mode:
-		set_vgaregs(modetable);
-		font_size = *(modetable + 2);
-
-		/* set font type (size) */
-		switch (font_size) {
-		case 0x10:
-			outb(TSIDX, 0x03); outb(TSREG, 0x00);	/* font 0 */
-			scp->font = FONT_16;
-			break;
-		case 0x0E:
-			outb(TSIDX, 0x03); outb(TSREG, 0x05);	/* font 1 */
-			scp->font = FONT_14;
-			break;
-		default:
-		case 0x08:
-			outb(TSIDX, 0x03); outb(TSREG, 0x0A);	/* font 2 */
-			scp->font = FONT_8;
-			break;
-		}
-		break;
+	set_vgaregs(modetable);
+	font_size = *(modetable + 2);
+
+	/* set font type (size) */
+	switch (font_size) {
+	case 0x10:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x00);   /* font 0 */
+	    scp->font = FONT_16;
+	    break;
+	case 0x0E:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x05);   /* font 1 */
+	    scp->font = FONT_14;
+	    break;
+	default:
+	case 0x08:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x0A);   /* font 2 */
+	    scp->font = FONT_8;
+	    break;
+	}
+	break;
 
-	case M_BG320:      case M_CG320:      case M_BG640:
-	case M_CG320_D:    case M_CG640_E:
-	case M_CG640x350:  case M_ENH_CG640:
-	case M_BG640x480:  case M_CG640x480:  case M_VGA_CG320:
+    case M_BG320:     case M_CG320:     case M_BG640:
+    case M_CG320_D:   case M_CG640_E:
+    case M_CG640x350: case M_ENH_CG640:
+    case M_BG640x480: case M_CG640x480: case M_VGA_CG320:
  
-		set_vgaregs(video_mode_ptr + (scp->mode * 64));
-		break;
+	set_vgaregs(video_mode_ptr + (scp->mode * 64));
+	break;
 
-	default:
-		/* call user defined function XXX */
-		break;
-	}
+    default:
+	/* call user defined function XXX */
+	break;
+    }
 
-	/* set border color for this (virtual) console */
-	set_border(scp->border);
-	return;
+    /* set border color for this (virtual) console */
+    set_border(scp->border);
+    return;
 }
 
-static void 
+void 
 set_border(int color)
 {
-	inb(crtc_addr+6); 				/* reset flip-flop */
-	outb(ATC, 0x11); outb(ATC, color); 
-	inb(crtc_addr+6); 				/* reset flip-flop */
-	outb(ATC, 0x20);				/* enable Palette */
+    inb(crtc_addr+6);               /* reset flip-flop */
+    outb(ATC, 0x11); outb(ATC, color); 
+    inb(crtc_addr+6);               /* reset flip-flop */
+    outb(ATC, 0x20);                /* enable Palette */
 }
 
 static void
 set_vgaregs(char *modetable)
 {
-	int i, s = splhigh();
+    int i, s = splhigh();
 
-	outb(TSIDX, 0x00); outb(TSREG, 0x01);	/* stop sequencer */
-	outb(TSIDX, 0x07); outb(TSREG, 0x00);	/* unlock registers */
-	for (i=0; i<4; i++) {			/* program sequencer */
-		outb(TSIDX, i+1); 
-		outb(TSREG, modetable[i+5]);
-	}
-	outb(MISC, modetable[9]);		/* set dot-clock */
-	outb(TSIDX, 0x00); outb(TSREG, 0x03);	/* start sequencer */
-	outb(crtc_addr, 0x11);
-	outb(crtc_addr+1, inb(crtc_addr+1) & 0x7F);
-	for (i=0; i<25; i++) {			/* program crtc */
-		outb(crtc_addr, i); 
-		if (i == 14 || i == 15)		/* no hardware cursor */
-			outb(crtc_addr+1, 0xff);
-		else
-			outb(crtc_addr+1, modetable[i+10]);
-	}
-	inb(crtc_addr+6); 			/* reset flip-flop */
-	for (i=0; i<20; i++) {			/* program attribute ctrl */
-		outb(ATC, i); 
-		outb(ATC, modetable[i+35]);
-	}
-	for (i=0; i<9; i++) {			/* program graph data ctrl */
-		outb(GDCIDX, i); 
-		outb(GDCREG, modetable[i+55]);
-	}
-	inb(crtc_addr+6); 			/* reset flip-flop */
-	outb(ATC ,0x20);			/* enable palette */
-	splx(s);
+    outb(TSIDX, 0x00); outb(TSREG, 0x01);   	/* stop sequencer */
+    outb(TSIDX, 0x07); outb(TSREG, 0x00);   	/* unlock registers */
+    for (i=0; i<4; i++) {           		/* program sequencer */
+	outb(TSIDX, i+1); 
+	outb(TSREG, modetable[i+5]);
+    }
+    outb(MISC, modetable[9]);       		/* set dot-clock */
+    outb(TSIDX, 0x00); outb(TSREG, 0x03);   	/* start sequencer */
+    outb(crtc_addr, 0x11);
+    outb(crtc_addr+1, inb(crtc_addr+1) & 0x7F);
+    for (i=0; i<25; i++) {          		/* program crtc */
+	outb(crtc_addr, i); 
+	if (i == 14 || i == 15)     		/* no hardware cursor */
+	    outb(crtc_addr+1, 0xff);
+	else
+	    outb(crtc_addr+1, modetable[i+10]);
+    }
+    inb(crtc_addr+6);           		/* reset flip-flop */
+    for (i=0; i<20; i++) {          		/* program attribute ctrl */
+	outb(ATC, i); 
+	outb(ATC, modetable[i+35]);
+    }
+    for (i=0; i<9; i++) {           		/* program graph data ctrl */
+	outb(GDCIDX, i); 
+	outb(GDCREG, modetable[i+55]);
+    }
+    inb(crtc_addr+6);           		/* reset flip-flop */
+    outb(ATC ,0x20);            		/* enable palette */
+    splx(s);
 }
 
 static void
 set_font_mode()
 {
-	/* setup vga for loading fonts (graphics plane mode) */
-	inb(crtc_addr+6);				/* reset flip/flop */
-	outb(ATC, 0x30); outb(ATC, 0x01);
+    /* setup vga for loading fonts (graphics plane mode) */
+    inb(crtc_addr+6);
+    outb(ATC, 0x30); outb(ATC, 0x01);
 #if SLOW_VGA
-	outb(TSIDX, 0x02); outb(TSREG, 0x04);
-	outb(TSIDX, 0x04); outb(TSREG, 0x06);
-	outb(GDCIDX, 0x04); outb(GDCREG, 0x02);
-	outb(GDCIDX, 0x05); outb(GDCREG, 0x00);
-	outb(GDCIDX, 0x06); outb(GDCREG, 0x05);	
+    outb(TSIDX, 0x02); outb(TSREG, 0x04);
+    outb(TSIDX, 0x04); outb(TSREG, 0x06);
+    outb(GDCIDX, 0x04); outb(GDCREG, 0x02);
+    outb(GDCIDX, 0x05); outb(GDCREG, 0x00);
+    outb(GDCIDX, 0x06); outb(GDCREG, 0x05); 
 #else
-	outw(TSIDX, 0x0402);
-	outw(TSIDX, 0x0604);
-	outw(GDCIDX, 0x0204);
-	outw(GDCIDX, 0x0005);
-	outw(GDCIDX, 0x0506);				/* addr = a0000, 64kb */
+    outw(TSIDX, 0x0402);
+    outw(TSIDX, 0x0604);
+    outw(GDCIDX, 0x0204);
+    outw(GDCIDX, 0x0005);
+    outw(GDCIDX, 0x0506);               /* addr = a0000, 64kb */
 #endif
 }
 
 static void
 set_normal_mode()
 {
-	int s = splhigh();
+    int s = splhigh();
 
-	/* setup vga for normal operation mode again */
-	inb(crtc_addr+6);				/* reset flip/flop */
-	outb(ATC, 0x30); outb(ATC, 0x0C);
+    /* setup vga for normal operation mode again */
+    inb(crtc_addr+6);
+    outb(ATC, 0x30); outb(ATC, 0x0C);
 #if SLOW_VGA
-	outb(TSIDX, 0x02); outb(TSREG, 0x03);
-	outb(TSIDX, 0x04); outb(TSREG, 0x02);
-	outb(GDCIDX, 0x04); outb(GDCREG, 0x00);
-	outb(GDCIDX, 0x05); outb(GDCREG, 0x10);
-	if (crtc_addr == MONO_BASE) {
-		outb(GDCIDX, 0x06); outb(GDCREG, 0x0A);	/* addr = b0000, 32kb */
-	}
-	else {
-		outb(GDCIDX, 0x06); outb(GDCREG, 0x0E);	/* addr = b8000, 32kb */
-	}
+    outb(TSIDX, 0x02); outb(TSREG, 0x03);
+    outb(TSIDX, 0x04); outb(TSREG, 0x02);
+    outb(GDCIDX, 0x04); outb(GDCREG, 0x00);
+    outb(GDCIDX, 0x05); outb(GDCREG, 0x10);
+    if (crtc_addr == MONO_BASE) {
+	outb(GDCIDX, 0x06); outb(GDCREG, 0x0A); /* addr = b0000, 32kb */
+    }
+    else {
+	outb(GDCIDX, 0x06); outb(GDCREG, 0x0E); /* addr = b8000, 32kb */
+    }
 #else
-	outw(TSIDX, 0x0302);
-	outw(TSIDX, 0x0204);
-	outw(GDCIDX, 0x0004);
-	outw(GDCIDX, 0x1005);
-	if (crtc_addr == MONO_BASE)
-		outw(GDCIDX, 0x0A06);			/* addr = b0000, 32kb */
-	else
-		outw(GDCIDX, 0x0E06);			/* addr = b8000, 32kb */
+    outw(TSIDX, 0x0302);
+    outw(TSIDX, 0x0204);
+    outw(GDCIDX, 0x0004);
+    outw(GDCIDX, 0x1005);
+    if (crtc_addr == MONO_BASE)
+	outw(GDCIDX, 0x0A06);           /* addr = b0000, 32kb */
+    else
+	outw(GDCIDX, 0x0E06);           /* addr = b8000, 32kb */
 #endif
-	splx(s);
+    splx(s);
 }
 
 static void 
 copy_font(int operation, int font_type, char* font_image)
 {
-	int ch, line, segment, fontsize;
-	u_char val;
-
-	switch (font_type) {
-	default:
-	case FONT_8:
-		segment = 0x8000;
-		fontsize = 8;
-		break;
-	case FONT_14:
-		segment = 0x4000;
-		fontsize = 14;
-		break;
-	case FONT_16:
-		segment = 0x0000;
-		fontsize = 16;
-		break;
-	}
-	outb(TSIDX, 0x01); val = inb(TSREG); 		/* disable screen */
-	outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-	set_font_mode();
-	for (ch=0; ch < 256; ch++) 
-	    for (line=0; line < fontsize; line++) 
-		if (operation)
-		    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line) =
-					font_image[(ch*fontsize)+line];	
-		else
-		    font_image[(ch*fontsize)+line] =
-		    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line);
-	set_normal_mode();
-	outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);	/* enable screen */
+    int ch, line, segment, fontsize;
+    u_char val;
+
+    switch (font_type) {
+    default:
+    case FONT_8:
+	segment = 0x8000;
+	fontsize = 8;
+	break;
+    case FONT_14:
+	segment = 0x4000;
+	fontsize = 14;
+	break;
+    case FONT_16:
+	segment = 0x0000;
+	fontsize = 16;
+	break;
+    }
+    outb(TSIDX, 0x01); val = inb(TSREG);        /* disable screen */
+    outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+    set_font_mode();
+    for (ch=0; ch < 256; ch++) 
+	for (line=0; line < fontsize; line++) 
+	if (operation)
+	    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line) =
+		    font_image[(ch*fontsize)+line]; 
+	else
+	    font_image[(ch*fontsize)+line] =
+	    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line);
+    set_normal_mode();
+    outb(TSIDX, 0x01); outb(TSREG, val & 0xDF); /* enable screen */
 }
 
 static void
 draw_mouse_image(scr_stat *scp)
 {
-	caddr_t address;
-	int i, font_size;
-	char *font_buffer;
-	u_short buffer[32];
-	u_short xoffset, yoffset;
-	u_short *crt_pos = Crtat + (scp->mouse_pos - scp->scr_buf);
-
-	xoffset = scp->mouse_xpos % 8;
-	switch (scp->font) {
-	default:
-	case FONT_8:
-		font_size = 8;
-		font_buffer = font_8;
-		yoffset = scp->mouse_ypos % 8;
-		address = (caddr_t)VIDEOMEM+0x8000;
-		break;
-	case FONT_14:
-		font_size = 14;
-		font_buffer = font_14;
-		yoffset = scp->mouse_ypos % 14;
-		address = (caddr_t)VIDEOMEM+0x4000;
-		break;
-	case FONT_16:
-		font_size = 16;
-		font_buffer = font_16;
-		yoffset = scp->mouse_ypos % 16;
-		address = (caddr_t)VIDEOMEM;
-		break;
-	}
+    caddr_t address;
+    int i, font_size;
+    char *font_buffer;
+    u_short buffer[32];
+    u_short xoffset, yoffset;
+    u_short *crt_pos = Crtat + (scp->mouse_pos - scp->scr_buf);
+
+    xoffset = scp->mouse_xpos % 8;
+    switch (scp->font) {
+    default:
+    case FONT_8:
+	font_size = 8;
+	font_buffer = font_8;
+	yoffset = scp->mouse_ypos % 8;
+	address = (caddr_t)VIDEOMEM+0x8000;
+	break;
+    case FONT_14:
+	font_size = 14;
+	font_buffer = font_14;
+	yoffset = scp->mouse_ypos % 14;
+	address = (caddr_t)VIDEOMEM+0x4000;
+	break;
+    case FONT_16:
+	font_size = 16;
+	font_buffer = font_16;
+	yoffset = scp->mouse_ypos % 16;
+	address = (caddr_t)VIDEOMEM;
+	break;
+    }
 
-	bcopyw(font_buffer+((*(scp->mouse_pos) & 0xff)*font_size),
-	       &scp->mouse_cursor[0], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+1) & 0xff)*font_size),
-	       &scp->mouse_cursor[32], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize) & 0xff)*font_size),
-	       &scp->mouse_cursor[64], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize+1) & 0xff)*font_size),
-	       &scp->mouse_cursor[96], font_size);
-
-	for (i=0; i<font_size; i++) {
-		buffer[i] = 
-			scp->mouse_cursor[i]<<8 | scp->mouse_cursor[i+32];
-		buffer[i+font_size] = 
-			scp->mouse_cursor[i+64]<<8 | scp->mouse_cursor[i+96];
-	}
-	for (i=0; i<16; i++) {
-		buffer[i+yoffset] =
-			( buffer[i+yoffset] 
-			 & ~(mouse_and_mask[i] >> xoffset))
-			| (mouse_or_mask[i] >> xoffset);
-	}
-	for (i=0; i<font_size; i++) {
-		scp->mouse_cursor[i] = (buffer[i] & 0xff00) >> 8;
-		scp->mouse_cursor[i+32] = buffer[i] & 0xff;
-		scp->mouse_cursor[i+64] = (buffer[i+font_size] & 0xff00) >> 8;
-		scp->mouse_cursor[i+96] = buffer[i+font_size] & 0xff;
-	}
-	/*
-	 * if we didn't update entire screen, restore old mouse position
-	 * and check if we overwrote the cursor location..
-	 */
-	if ((scp->status & UPDATE_MOUSE) && !(scp->status & UPDATE_SCREEN)) {
-	    u_short *ptr = scp->scr_buf + (scp->mouse_oldpos - Crtat);
-	    if (crt_pos != scp->mouse_oldpos) {
-		*(scp->mouse_oldpos) = scp->mouse_saveunder[0];
-		*(scp->mouse_oldpos+1) = scp->mouse_saveunder[1];
-		*(scp->mouse_oldpos+scp->xsize) = scp->mouse_saveunder[2];
-		*(scp->mouse_oldpos+scp->xsize+1) = scp->mouse_saveunder[3];
-	    }
-	    scp->mouse_saveunder[0] = *(scp->mouse_pos);
-	    scp->mouse_saveunder[1] = *(scp->mouse_pos+1);
-	    scp->mouse_saveunder[2] = *(scp->mouse_pos+scp->xsize);
-	    scp->mouse_saveunder[3] = *(scp->mouse_pos+scp->xsize+1);
-	    if ((scp->cursor_pos == (ptr)) ||
-		(scp->cursor_pos == (ptr+1)) ||
-		(scp->cursor_pos == (ptr+scp->xsize)) ||
-		(scp->cursor_pos == (ptr+scp->xsize+1)) ||
-		(scp->cursor_pos == (scp->mouse_pos)) ||
-		(scp->cursor_pos == (scp->mouse_pos+1)) ||
-		(scp->cursor_pos == (scp->mouse_pos+scp->xsize)) ||
-		(scp->cursor_pos == (scp->mouse_pos+scp->xsize+1)))
-		    scp->status &= ~CURSOR_SHOWN;
-	}
-	scp->mouse_oldpos = crt_pos;
-	while (!(inb(crtc_addr+6) & 0x08)) /* wait for vertical retrace */ ;
-	*(crt_pos) = *(scp->mouse_pos)&0xff00|0xd0;
-	*(crt_pos+1) = *(scp->mouse_pos+1)&0xff00|0xd1;
-	*(crt_pos+scp->xsize) = *(scp->mouse_pos+scp->xsize)&0xff00|0xd2;
-	*(crt_pos+scp->xsize+1) = *(scp->mouse_pos+scp->xsize+1)&0xff00|0xd3;
-	set_font_mode();
-	bcopy(scp->mouse_cursor,
-	      (char *)pa_to_va(address) + 0xd0 * 32, 128);
-	set_normal_mode();
+    bcopyw(font_buffer+((*(scp->mouse_pos) & 0xff)*font_size),
+	   &scp->mouse_cursor[0], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+1) & 0xff)*font_size),
+	   &scp->mouse_cursor[32], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize) & 0xff)*font_size),
+	   &scp->mouse_cursor[64], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize+1) & 0xff)*font_size),
+	   &scp->mouse_cursor[96], font_size);
+
+    for (i=0; i<font_size; i++) {
+	buffer[i] = scp->mouse_cursor[i]<<8 | scp->mouse_cursor[i+32];
+	buffer[i+font_size]=scp->mouse_cursor[i+64]<<8|scp->mouse_cursor[i+96];
+    }
+    for (i=0; i<16; i++) {
+	buffer[i+yoffset] =
+	    ( buffer[i+yoffset] & ~(mouse_and_mask[i] >> xoffset))
+	    | (mouse_or_mask[i] >> xoffset);
+    }
+    for (i=0; i<font_size; i++) {
+	scp->mouse_cursor[i] = (buffer[i] & 0xff00) >> 8;
+	scp->mouse_cursor[i+32] = buffer[i] & 0xff;
+	scp->mouse_cursor[i+64] = (buffer[i+font_size] & 0xff00) >> 8;
+	scp->mouse_cursor[i+96] = buffer[i+font_size] & 0xff;
+    }
+    /*
+     * if we didn't update entire screen, restore old mouse position
+     * and check if we overwrote the cursor location..
+     */
+    if ((scp->status & UPDATE_MOUSE) && !(scp->status & UPDATE_SCREEN)) {
+	u_short *ptr = scp->scr_buf + (scp->mouse_oldpos - Crtat);
+
+	if (crt_pos != scp->mouse_oldpos) {
+	    *(scp->mouse_oldpos) = scp->mouse_saveunder[0];
+	    *(scp->mouse_oldpos+1) = scp->mouse_saveunder[1];
+	    *(scp->mouse_oldpos+scp->xsize) = scp->mouse_saveunder[2];
+	    *(scp->mouse_oldpos+scp->xsize+1) = scp->mouse_saveunder[3];
+	}
+	scp->mouse_saveunder[0] = *(scp->mouse_pos);
+	scp->mouse_saveunder[1] = *(scp->mouse_pos+1);
+	scp->mouse_saveunder[2] = *(scp->mouse_pos+scp->xsize);
+	scp->mouse_saveunder[3] = *(scp->mouse_pos+scp->xsize+1);
+	if ((scp->cursor_pos == (ptr)) ||
+	    (scp->cursor_pos == (ptr+1)) ||
+	    (scp->cursor_pos == (ptr+scp->xsize)) ||
+	    (scp->cursor_pos == (ptr+scp->xsize+1)) ||
+	    (scp->cursor_pos == (scp->mouse_pos)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+1)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+scp->xsize)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+scp->xsize+1)))
+	    scp->status &= ~CURSOR_SHOWN;
+    }
+    scp->mouse_oldpos = crt_pos;
+    while (!(inb(crtc_addr+6) & 0x08)) /* wait for vertical retrace */ ;
+    *(crt_pos) = *(scp->mouse_pos)&0xff00|0xd0;
+    *(crt_pos+1) = *(scp->mouse_pos+1)&0xff00|0xd1;
+    *(crt_pos+scp->xsize) = *(scp->mouse_pos+scp->xsize)&0xff00|0xd2;
+    *(crt_pos+scp->xsize+1) = *(scp->mouse_pos+scp->xsize+1)&0xff00|0xd3;
+    set_font_mode();
+    bcopy(scp->mouse_cursor, (char *)pa_to_va(address) + 0xd0 * 32, 128);
+    set_normal_mode();
 }
 
 static void 
 save_palette(void)
 {
-	int i;
+    int i;
 
-	outb(PALRADR, 0x00);	
-	for (i=0x00; i<0x300; i++)            
-		palette[i] = inb(PALDATA);
-	inb(crtc_addr+6);			/* reset flip/flop */
+    outb(PALRADR, 0x00);    
+    for (i=0x00; i<0x300; i++)            
+	palette[i] = inb(PALDATA);
+    inb(crtc_addr+6);           /* reset flip/flop */
 }
 
-static void 
+void 
 load_palette(void)
 {
-	int i;
-
-	outb(PIXMASK, 0xFF);			/* no pixelmask */
-	outb(PALWADR, 0x00);	
-	for (i=0x00; i<0x300; i++)            
-		 outb(PALDATA, palette[i]);
-	inb(crtc_addr+6);			/* reset flip/flop */
-	outb(ATC, 0x20);			/* enable palette */
+    int i;
+
+    outb(PIXMASK, 0xFF);            /* no pixelmask */
+    outb(PALWADR, 0x00);    
+    for (i=0x00; i<0x300; i++)            
+	 outb(PALDATA, palette[i]);
+    inb(crtc_addr+6);           /* reset flip/flop */
+    outb(ATC, 0x20);            /* enable palette */
 }
 
 static void
 do_bell(scr_stat *scp, int pitch, int duration)
 {
-	if (scp == cur_console) {
-		if (configuration & VISUAL_BELL) {
-			if (blink_in_progress)
-				return;
-			blink_in_progress = 4;
-			blink_screen(scp);
-			timeout((timeout_func_t)blink_screen, scp, hz/10);
-		}	
-		else
-			sysbeep(pitch, duration);
-	}
+    if (scp == cur_console) {
+	if (configuration & VISUAL_BELL) {
+	    if (blink_in_progress)
+		return;
+	    blink_in_progress = 4;
+	    blink_screen(scp);
+	    timeout((timeout_func_t)blink_screen, scp, hz/10);
+	}   
+	else
+	    sysbeep(pitch, duration);
+    }
 }
 
 static void
 blink_screen(scr_stat *scp)
 {
-	if (blink_in_progress > 1) {
-		if (blink_in_progress & 1)
-			fillw(kernel_default.std_attr | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-		else
-			fillw(kernel_default.rev_attr | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-		blink_in_progress--;
-		timeout((timeout_func_t)blink_screen, scp, hz/10);
-	}
-	else {
-		scp->status |= UPDATE_SCREEN;
-		blink_in_progress = FALSE;
-		if (delayed_next_scr)
-			switch_scr(scp, delayed_next_scr - 1);
-	}
+    if (blink_in_progress > 1) {
+	if (blink_in_progress & 1)
+	    fillw(kernel_default.std_attr | scr_map[0x20],
+		  Crtat, scp->xsize * scp->ysize);
+	else
+	    fillw(kernel_default.rev_attr | scr_map[0x20],
+		  Crtat, scp->xsize * scp->ysize);
+	blink_in_progress--;
+	timeout((timeout_func_t)blink_screen, scp, hz/10);
+    }
+    else {
+	scp->status |= UPDATE_SCREEN;
+	blink_in_progress = FALSE;
+	if (delayed_next_scr)
+	    switch_scr(scp, delayed_next_scr - 1);
+    }
 }
 
 #endif /* NSC */
diff --git a/sys/i386/isa/syscons.h b/sys/i386/isa/syscons.h
new file mode 100644
index 0000000..546b2de
--- /dev/null
+++ b/sys/i386/isa/syscons.h
@@ -0,0 +1,203 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+/* vm things */
+#define	ISMAPPED(pa, width) \
+	(((pa) <= (u_long)0x1000 - (width)) \
+	 || ((pa) >= 0xa0000 && (pa) <= 0x100000 - (width)))
+#define	pa_to_va(pa)	(KERNBASE + (pa))	/* works if ISMAPPED(pa...) */
+
+/* printable chars */
+#define PRINTABLE(ch)	(ch>0x1B || (ch>0x0d && ch<0x1b) || ch<0x07)
+
+/* status flags */
+#define LOCK_KEY_MASK	0x0000F
+#define LED_MASK	0x00007
+#define UNKNOWN_MODE	0x00010
+#define KBD_RAW_MODE	0x00020
+#define SWITCH_WAIT_REL	0x00040
+#define SWITCH_WAIT_ACQ	0x00080
+#define BUFFER_SAVED	0x00100
+#define CURSOR_ENABLED 	0x00200
+#define CURSOR_SHOWN 	0x00400
+#define MOUSE_ENABLED	0x00800
+#define UPDATE_MOUSE	0x01000
+#define UPDATE_SCREEN	0x02000
+
+/* configuration flags */
+#define VISUAL_BELL	0x00001
+#define BLINK_CURSOR	0x00002
+#define CHAR_CURSOR	0x00004
+
+/* video hardware memory addresses */
+#define VIDEOMEM	0x000A0000
+
+/* misc defines */
+#define FALSE		0
+#define TRUE		1
+#define MAX_ESC_PAR 	5
+#define	LOAD		1
+#define SAVE		0
+#define	COL		80
+#define	ROW		25
+#define BELL_DURATION	5
+#define BELL_PITCH	800
+#define TIMER_FREQ	1193182			/* should be in isa.h */
+#define CONSOLE_BUFSIZE 1024
+#define PCBURST		128
+#define FONT_8		0x001
+#define FONT_14		0x002
+#define FONT_16		0x004
+#define HISTORY_SIZE	100*80
+
+/* defines related to hardware addresses */
+#define	MONO_BASE	0x3B4			/* crt controller base mono */
+#define	COLOR_BASE	0x3D4			/* crt controller base color */
+#define MISC		0x3C2			/* misc output register */
+#define ATC		IO_VGA+0x00		/* attribute controller */
+#define TSIDX		IO_VGA+0x04		/* timing sequencer idx */
+#define TSREG		IO_VGA+0x05		/* timing sequencer data */
+#define PIXMASK		IO_VGA+0x06		/* pixel write mask */
+#define PALRADR		IO_VGA+0x07		/* palette read address */
+#define PALWADR		IO_VGA+0x08		/* palette write address */
+#define PALDATA		IO_VGA+0x09		/* palette data register */
+#define GDCIDX		IO_VGA+0x0E		/* graph data controller idx */
+#define GDCREG		IO_VGA+0x0F		/* graph data controller data */
+
+/* special characters */
+#define cntlc	0x03	
+#define cntld	0x04
+#define bs	0x08
+#define lf	0x0a
+#define cr	0x0d	
+#define del	0x7f	
+
+typedef struct term_stat {
+	int 		esc;			/* processing escape sequence */
+	int 		num_param;		/* # of parameters to ESC */
+	int	 	last_param;		/* last parameter # */
+	int 		param[MAX_ESC_PAR];	/* contains ESC parameters */
+	int 		cur_attr;		/* current attributes */
+	int 		std_attr;		/* normal attributes */
+	int 		rev_attr;		/* reverse attributes */
+} term_stat;
+
+typedef struct scr_stat {
+	u_short 	*scr_buf;		/* buffer when off screen */
+	int 		xpos;			/* current X position */
+	int 		ypos;			/* current Y position */
+	int 		xsize;			/* X size */
+	int 		ysize;			/* Y size */
+	term_stat 	term;			/* terminal emulation stuff */
+	int	 	status;			/* status (bitfield) */
+	u_short 	*cursor_pos;		/* cursor buffer position */
+	u_short		cursor_saveunder;	/* saved chars under cursor */
+	char		cursor_start;		/* cursor start line # */
+	char		cursor_end;		/* cursor end line # */
+	u_short		*mouse_pos;		/* mouse buffer position */
+	u_short		*mouse_oldpos;		/* mouse old buffer position */
+	u_short		mouse_saveunder[4];	/* saved chars under mouse */
+	short		mouse_xpos;		/* mouse x coordinate */
+	short		mouse_ypos;		/* mouse y coordinate */
+	u_char		mouse_cursor[128];	/* mouse cursor bitmap store */
+	u_short		bell_duration;
+	u_short		bell_pitch;
+	u_char		border;			/* border color */
+	u_char	 	mode;			/* mode */
+	u_char		font;			/* font on this screen */
+	pid_t 		pid;			/* pid of controlling proc */
+	struct proc 	*proc;			/* proc* of controlling proc */
+	struct vt_mode 	smode;			/* switch mode */
+	u_short		*history;		/* circular history buffer */
+	u_short		*history_head;		/* current head position */
+	u_short		*history_pos;		/* position shown on screen */
+	u_short		*history_save;		/* save area index */
+	int		history_size;		/* size of history buffer */
+#if NAPM > 0
+	struct apmhook  r_hook;			/* reconfiguration support */
+#endif
+} scr_stat;
+
+typedef struct default_attr {
+	int             std_attr;               /* normal attributes */
+	int 		rev_attr;		/* reverse attributes */
+} default_attr;
+
+/* function prototypes */
+int scprobe(struct isa_device *dev);
+int scattach(struct isa_device *dev);
+int scopen(dev_t dev, int flag, int mode, struct proc *p);
+int scclose(dev_t dev, int flag, int mode, struct proc *p);
+int scread(dev_t dev, struct uio *uio, int flag);
+int scwrite(dev_t dev, struct uio *uio, int flag);
+int scparam(struct tty *tp, struct termios *t);
+int scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p);
+void scxint(dev_t dev);
+void scstart(struct tty *tp);
+void pccnprobe(struct consdev *cp);
+void pccninit(struct consdev *cp);
+void pccnputc(dev_t dev, char c);
+int pccngetc(dev_t dev);
+int pccncheckc(dev_t dev);
+void scintr(int unit);
+int pcmmap(dev_t dev, int offset, int nprot);
+static void scinit(void);
+static u_int scgetc(int noblock);
+static struct tty *get_tty_ptr(dev_t dev);
+static scr_stat *get_scr_stat(dev_t dev);
+static scr_stat *alloc_scp();
+static void init_scp(scr_stat *scp);
+static int get_scr_num();
+static void scrn_timer();
+static void clear_screen(scr_stat *scp);
+static int switch_scr(scr_stat *scp, u_int next_scr);
+static void exchange_scr(void);
+static inline void move_crsr(scr_stat *scp, int x, int y);
+static void scan_esc(scr_stat *scp, u_char c);
+static inline void draw_cursor(scr_stat *scp, int show);
+static void ansi_put(scr_stat *scp, u_char *buf, int len);
+static u_char *get_fstr(u_int c, u_int *len);
+static void update_leds(int which);
+static void history_to_screen(scr_stat *scp);
+static int history_up_line(scr_stat *scp);
+static int history_down_line(scr_stat *scp);
+static void kbd_wait(void);
+static void kbd_cmd(u_char command);
+static void set_mode(scr_stat *scp);
+       void set_border(int color);
+static void set_vgaregs(char *modetable);
+static void set_font_mode();
+static void set_normal_mode();
+static void copy_font(int operation, int font_type, char* font_image);
+static void draw_mouse_image(scr_stat *scp);
+static void save_palette(void);
+       void load_palette(void);
+static void do_bell(scr_stat *scp, int pitch, int duration);
+static void blink_screen(scr_stat *scp);
diff --git a/sys/isa/syscons.c b/sys/isa/syscons.c
index 102cc0e..1671125 100644
--- a/sys/isa/syscons.c
+++ b/sys/isa/syscons.c
@@ -1,47 +1,35 @@
 /*-
  * Copyright (c) 1992-1995 Søren Schmidt
- * Copyright (c) 1990 The Regents of the University of California.
  * All rights reserved.
  *
- * This code is derived from software contributed to Berkeley by
- * William Jolitz and Don Ahn.
- *
  * 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,
+ *    notice, this list of conditions and the following disclaimer 
  *    in this position and unchanged.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
  *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- *	$Id: syscons.c,v 1.102 1995/02/14 14:37:53 sos Exp $
+ *  $Id$
  */
 
 #include "sc.h"
-
 #if NSC > 0
-
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/conf.h>
@@ -68,6 +56,7 @@
 #include <i386/isa/timerreg.h>
 #include <i386/isa/kbdtables.h>
 #include <i386/i386/cons.h>
+#include <i386/isa/syscons.h>
 
 #if !defined(MAXCONS)
 #define MAXCONS 16
@@ -78,1484 +67,1109 @@
 #endif 
 
 /* this may break on older VGA's but is usefull on real 32 bit systems */
-#define	bcopyw	bcopy		
-
-/* vm things */
-#define	ISMAPPED(pa, width) \
-	(((pa) <= (u_long)0x1000 - (width)) \
-	 || ((pa) >= 0xa0000 && (pa) <= 0x100000 - (width)))
-#define	pa_to_va(pa)	(KERNBASE + (pa))	/* works if ISMAPPED(pa...) */
-
-/* printable chars */
-#define PRINTABLE(ch)	(ch>0x1B || (ch>0x0d && ch<0x1b) || ch<0x07)
-
-/* status flags */
-#define LOCK_KEY_MASK	0x0000F
-#define LED_MASK	0x00007
-#define UNKNOWN_MODE	0x00010
-#define KBD_RAW_MODE	0x00020
-#define SWITCH_WAIT_REL	0x00040
-#define SWITCH_WAIT_ACQ	0x00080
-#define BUFFER_SAVED	0x00100
-#define CURSOR_ENABLED 	0x00200
-#define CURSOR_SHOWN 	0x00400
-#define MOUSE_ENABLED	0x00800
-#define UPDATE_MOUSE	0x01000
-#define UPDATE_SCREEN	0x02000
-
-/* configuration flags */
-#define VISUAL_BELL	0x00001
-#define BLINK_CURSOR	0x00002
-#define CHAR_CURSOR	0x00004
-
-/* video hardware memory addresses */
-#define VIDEOMEM	0x000A0000
-
-/* misc defines */
-#define FALSE		0
-#define TRUE		1
-#define MAX_ESC_PAR 	5
-#define	LOAD		1
-#define SAVE		0
-#define	COL		80
-#define	ROW		25
-#define BELL_DURATION	5
-#define BELL_PITCH	800
-#define TIMER_FREQ	1193182			/* should be in isa.h */
-#define CONSOLE_BUFSIZE 1024
-#define PCBURST		128
-#define FONT_8		0x001
-#define FONT_14		0x002
-#define FONT_16		0x004
-#define HISTORY_SIZE	100*80
-
-/* defines related to hardware addresses */
-#define	MONO_BASE	0x3B4			/* crt controller base mono */
-#define	COLOR_BASE	0x3D4			/* crt controller base color */
-#define MISC		0x3C2			/* misc output register */
-#define ATC		IO_VGA+0x00		/* attribute controller */
-#define TSIDX		IO_VGA+0x04		/* timing sequencer idx */
-#define TSREG		IO_VGA+0x05		/* timing sequencer data */
-#define PIXMASK		IO_VGA+0x06		/* pixel write mask */
-#define PALRADR		IO_VGA+0x07		/* palette read address */
-#define PALWADR		IO_VGA+0x08		/* palette write address */
-#define PALDATA		IO_VGA+0x09		/* palette data register */
-#define GDCIDX		IO_VGA+0x0E		/* graph data controller idx */
-#define GDCREG		IO_VGA+0x0F		/* graph data controller data */
-
-/* special characters */
-#define cntlc	0x03	
-#define cntld	0x04
-#define bs	0x08
-#define lf	0x0a
-#define cr	0x0d	
-#define del	0x7f	
-
-typedef struct term_stat {
-	int 		esc;			/* processing escape sequence */
-	int 		num_param;		/* # of parameters to ESC */
-	int	 	last_param;		/* last parameter # */
-	int 		param[MAX_ESC_PAR];	/* contains ESC parameters */
-	int 		cur_attr;		/* current attributes */
-	int 		std_attr;		/* normal attributes */
-	int 		rev_attr;		/* reverse attributes */
-} term_stat;
-
-typedef struct scr_stat {
-	u_short 	*scr_buf;		/* buffer when off screen */
-	int 		xpos;			/* current X position */
-	int 		ypos;			/* current Y position */
-	int 		xsize;			/* X size */
-	int 		ysize;			/* Y size */
-	term_stat 	term;			/* terminal emulation stuff */
-	int	 	status;			/* status (bitfield) */
-	u_short 	*cursor_pos;		/* cursor buffer position */
-	u_short		cursor_saveunder;	/* saved chars under cursor */
-	char		cursor_start;		/* cursor start line # */
-	char		cursor_end;		/* cursor end line # */
-	u_short		*mouse_pos;		/* mouse buffer position */
-	u_short		*mouse_oldpos;		/* mouse old buffer position */
-	u_short		mouse_saveunder[4];	/* saved chars under mouse */
-	short		mouse_xpos;		/* mouse x coordinate */
-	short		mouse_ypos;		/* mouse y coordinate */
-	u_char		mouse_cursor[128];	/* mouse cursor bitmap store */
-	u_short		bell_duration;
-	u_short		bell_pitch;
-	u_char		border;			/* border color */
-	u_char	 	mode;			/* mode */
-	u_char		font;			/* font on this screen */
-	pid_t 		pid;			/* pid of controlling proc */
-	struct proc 	*proc;			/* proc* of controlling proc */
-	struct vt_mode 	smode;			/* switch mode */
-	u_short		*history;		/* circular history buffer */
-	u_short		*history_head;		/* current head position */
-	u_short		*history_pos;		/* position shown on screen */
-	u_short		*history_save;		/* save area index */
-	int		history_size;		/* size of history buffer */
-#if NAPM > 0
-	struct apmhook  r_hook;			/* reconfiguration support */
-#endif /* NAPM > 0 */
-} scr_stat;
-
-typedef struct default_attr {
-	int             std_attr;               /* normal attributes */
-	int 		rev_attr;		/* reverse attributes */
-} default_attr;
+#define bcopyw  bcopy       
 
 static default_attr user_default = {
-	(FG_LIGHTGREY | BG_BLACK) << 8,
-	(FG_BLACK | BG_LIGHTGREY) << 8
+    (FG_LIGHTGREY | BG_BLACK) << 8,
+    (FG_BLACK | BG_LIGHTGREY) << 8
 };
 
 static default_attr kernel_default = {
-	(FG_WHITE | BG_BLACK) << 8,
-	(FG_BLACK | BG_LIGHTGREY) << 8
+    (FG_WHITE | BG_BLACK) << 8,
+    (FG_BLACK | BG_LIGHTGREY) << 8
 };
 
-static	scr_stat	main_console;
-static	scr_stat	*console[MAXCONS];
-static	scr_stat	*cur_console;
-static	scr_stat	*new_scp, *old_scp;
-static	term_stat	kernel_console; 
-static	default_attr	*current_default;
-static 	char 		init_done = FALSE;
-static	char		switch_in_progress = FALSE;
-static	char		blink_in_progress = FALSE;
-static	char 		write_in_progress = FALSE;
-static	u_int		crtc_addr = MONO_BASE;
-static	char		crtc_vga = FALSE;
-static 	u_char		shfts = 0, ctls = 0, alts = 0, agrs = 0, metas = 0;
-static 	u_char		nlkcnt = 0, clkcnt = 0, slkcnt = 0, alkcnt = 0;
-static	char		*font_8 = NULL, *font_14 = NULL, *font_16 = NULL;
-static  int		fonts_loaded = 0;
-static	char		palette[3*256];
-static 	const u_int 	n_fkey_tab = sizeof(fkey_tab) / sizeof(*fkey_tab);
+static  scr_stat    	main_console;
+static  scr_stat    	*console[MAXCONS];
+	scr_stat    	*cur_console;
+static  scr_stat    	*new_scp, *old_scp;
+static  term_stat   	kernel_console; 
+static  default_attr    *current_default;
+static  char        	init_done = FALSE;
+static  char        	switch_in_progress = FALSE;
+static  char        	blink_in_progress = FALSE;
+static  char        	write_in_progress = FALSE;
+	u_int       	crtc_addr = MONO_BASE;
+static  char        	crtc_vga = FALSE;
+static  u_char      	shfts = 0, ctls = 0, alts = 0, agrs = 0, metas = 0;
+static  u_char      	nlkcnt = 0, clkcnt = 0, slkcnt = 0, alkcnt = 0;
+static  char        	*font_8 = NULL, *font_14 = NULL, *font_16 = NULL;
+static  int     	fonts_loaded = 0;
+	char        	palette[3*256];
+static  const u_int     n_fkey_tab = sizeof(fkey_tab) / sizeof(*fkey_tab);
 #if ASYNCH
-static  u_char		kbd_reply = 0;
+static  u_char      	kbd_reply = 0;
 #endif
-static	int	 	delayed_next_scr = FALSE;
-static	int		configuration = 0;	/* current setup */
-static	long		scrn_blank_time = 0;	/* screen saver timeout value */
-static	int		scrn_blanked = FALSE;	/* screen saver active flag */
-static	int		scrn_saver = 0;		/* screen saver routine */
-static	long 		scrn_time_stamp;
-static  u_char		scr_map[256];
-static	char 		*video_mode_ptr = NULL;
-static	u_short mouse_and_mask[16] = {	
-		0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
-		0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
-	};
-static	u_short mouse_or_mask[16] = {
-		0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
-		0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
-	};
-
-/* function prototypes */
-int scprobe(struct isa_device *dev);
-int scattach(struct isa_device *dev);
-int scopen(dev_t dev, int flag, int mode, struct proc *p);
-int scclose(dev_t dev, int flag, int mode, struct proc *p);
-int scread(dev_t dev, struct uio *uio, int flag);
-int scwrite(dev_t dev, struct uio *uio, int flag);
-int scparam(struct tty *tp, struct termios *t);
-int scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p);
-void scxint(dev_t dev);
-void scstart(struct tty *tp);
-void pccnprobe(struct consdev *cp);
-void pccninit(struct consdev *cp);
-void pccnputc(dev_t dev, char c);
-int pccngetc(dev_t dev);
-int pccncheckc(dev_t dev);
-void scintr(int unit);
-int pcmmap(dev_t dev, int offset, int nprot);
-static void scinit(void);
-static void scput(u_char c);
-static u_int scgetc(int noblock);
-static struct tty *get_tty_ptr(dev_t dev);
-static scr_stat *get_scr_stat(dev_t dev);
-static scr_stat *alloc_scp();
-static void init_scp(scr_stat *scp);
-static int get_scr_num();
-static void scrn_timer();
-static void clear_screen(scr_stat *scp);
-static int switch_scr(scr_stat *scp, u_int next_scr);
-static void exchange_scr(void);
-static inline void move_crsr(scr_stat *scp, int x, int y);
-static void scan_esc(scr_stat *scp, u_char c);
-static inline void draw_cursor(scr_stat *scp, int show);
-static void ansi_put(scr_stat *scp, u_char *buf, int len);
-static u_char *get_fstr(u_int c, u_int *len);
-static void update_leds(int which);
-static void history_to_screen(scr_stat *scp);
-static int history_up_line(scr_stat *scp);
-static int history_down_line(scr_stat *scp);
-static void kbd_wait(void);
-static void kbd_cmd(u_char command);
-static void set_mode(scr_stat *scp);
-static void set_border(int color);
-static void set_vgaregs(char *modetable);
-static void set_font_mode();
-static void set_normal_mode();
-static void copy_font(int operation, int font_type, char* font_image);
-static void draw_mouse_image(scr_stat *scp);
-static void save_palette(void);
-static void load_palette(void);
-static void do_bell(scr_stat *scp, int pitch, int duration);
-static void blink_screen(scr_stat *scp);
-
-/* available screen savers */
-static void none_saver(int blank);
-static void blank_saver(int blank);
-static void fade_saver(int blank);
-static void star_saver(int blank);
-static void snake_saver(int blank);
-static void green_saver(int blank);
-
-static const struct {
-	char	*name;
-	void	(*routine)();
-} screen_savers[] = {
-	{ "none",	none_saver },	/* 0 */
-	{ "blank",	blank_saver },	/* 1 */
-	{ "fade",	fade_saver },	/* 2 */
-	{ "star",	star_saver },	/* 3 */
-	{ "snake",	snake_saver },	/* 4 */
-	{ "green",	green_saver },	/* 5 */
+static  int     	delayed_next_scr = FALSE;
+static  int     	configuration = 0;  	/* current setup */
+static  long        	scrn_blank_time = 0;    /* screen saver timeout value */
+	int     	scrn_blanked = FALSE;   /* screen saver active flag */
+static  int     	scrn_saver = 0;    	/* screen saver routine */
+static  long       	scrn_time_stamp;
+	u_char      	scr_map[256];
+static  char        	*video_mode_ptr = NULL;
+
+static  u_short mouse_and_mask[16] = {  
+	0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
+	0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
 };
-#define SCRN_SAVER(arg)	(*screen_savers[scrn_saver].routine)(arg)
-#define NUM_SCRN_SAVERS	(sizeof(screen_savers) / sizeof(screen_savers[0]))
-#define WRAPHIST(scp, pointer, offset)\
-	((scp->history) + ((((pointer) - (scp->history)) + (scp->history_size)\
-	+ (offset)) % (scp->history_size)))
+static  u_short mouse_or_mask[16] = {
+	0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
+	0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
+};
+
+void    none_saver(int blank) { }
+void    (*current_saver)() = none_saver;
 
 /* OS specific stuff */
 #ifdef not_yet_done
-#define VIRTUAL_TTY(x)	(sccons[x] = ttymalloc(sccons[x]))
-struct	CONSOLE_TTY	(sccons[MAXCONS] = ttymalloc(sccons[MAXCONS]))
-struct	tty 		*sccons[MAXCONS+1];
+#define VIRTUAL_TTY(x)  (sccons[x] = ttymalloc(sccons[x]))
+struct  CONSOLE_TTY 	(sccons[MAXCONS] = ttymalloc(sccons[MAXCONS]))
+struct  tty         	*sccons[MAXCONS+1];
 #else
-#define VIRTUAL_TTY(x)	&sccons[x]
-#define CONSOLE_TTY	&sccons[MAXCONS]
-struct	tty 		sccons[MAXCONS+1];
+#define VIRTUAL_TTY(x)  &sccons[x]
+#define CONSOLE_TTY 	&sccons[MAXCONS]
+struct  tty         	sccons[MAXCONS+1];
 #endif
-#define	MONO_BUF	pa_to_va(0xB0000)
-#define	CGA_BUF		pa_to_va(0xB8000)
-u_short			*Crtat = (u_short *)MONO_BUF;
+#define MONO_BUF    	pa_to_va(0xB0000)
+#define CGA_BUF     	pa_to_va(0xB8000)
+u_short         	*Crtat = (u_short *)MONO_BUF;
+
+#define WRAPHIST(scp, pointer, offset)\
+    ((scp->history) + ((((pointer) - (scp->history)) + (scp->history_size)\
+    + (offset)) % (scp->history_size)))
 
-struct	isa_driver scdriver = {
-	scprobe, scattach, "sc", 1
+struct  isa_driver scdriver = {
+    scprobe, scattach, "sc", 1
 };
 
 int
 scprobe(struct isa_device *dev)
 {
-	int i, retries = 5;
-	unsigned char val;
+    int i, retries = 5;
+    unsigned char val;
+
+    /* Enable interrupts and keyboard controller */
+    kbd_wait();
+    outb(KB_STAT, KB_WRITE);
+    kbd_wait();
+    outb(KB_DATA, KB_MODE);
+
+    /* flush any noise in the buffer */
+    while (inb(KB_STAT) & KB_BUF_FULL) {
+	DELAY(10);
+	(void) inb(KB_DATA);
+    }
 
-	/* Enable interrupts and keyboard controller */
-	kbd_wait();
-	outb(KB_STAT, KB_WRITE);
+    /* Reset keyboard hardware */
+    while (retries--) {
 	kbd_wait();
-	outb(KB_DATA, KB_MODE);
-
-	/* flush any noise in the buffer */
-	while (inb(KB_STAT) & KB_BUF_FULL) {
-		DELAY(10);
-		(void) inb(KB_DATA);
-	}
-
-	/* Reset keyboard hardware */
-	while (retries--) {
-		kbd_wait();
-		outb(KB_DATA, KB_RESET);
-		for (i=0; i<100000; i++) {
-			DELAY(10);
-			val = inb(KB_DATA);
-			if (val == KB_ACK || val == KB_ECHO)
-				goto gotres;	
-			if (val == KB_RESEND)
-				break;
-		}
+	outb(KB_DATA, KB_RESET);
+	for (i=0; i<100000; i++) {
+	    DELAY(10);
+	    val = inb(KB_DATA);
+	    if (val == KB_ACK || val == KB_ECHO)
+		goto gotres;    
+	    if (val == KB_RESEND)
+		break;
 	}
+    }
 gotres:
-	if (!retries)
-		printf("scprobe: keyboard won't accept RESET command\n");
-	else {
+    if (!retries)
+	printf("scprobe: keyboard won't accept RESET command\n");
+    else {
 gotack:
-		DELAY(10);
-		while ((inb(KB_STAT) & KB_BUF_FULL) == 0) DELAY(10);
-		DELAY(10);
-		val = inb(KB_DATA);
-		if (val == KB_ACK)
-			goto gotack;
-		if (val != KB_RESET_DONE) 
-			printf("scprobe: keyboard RESET failed %02x\n", val);
-	}
+	DELAY(10);
+	while ((inb(KB_STAT) & KB_BUF_FULL) == 0) DELAY(10);
+	DELAY(10);
+	val = inb(KB_DATA);
+	if (val == KB_ACK)
+	    goto gotack;
+	if (val != KB_RESET_DONE) 
+	    printf("scprobe: keyboard RESET failed %02x\n", val);
+    }
 #ifdef XT_KEYBOARD
-	kbd_wait();
-	outb(KB_DATA, 0xF0);
-	kbd_wait();
-	outb(KB_DATA, 1)
-	kbd_wait();
+    kbd_wait();
+    outb(KB_DATA, 0xF0);
+    kbd_wait();
+    outb(KB_DATA, 1)
+    kbd_wait();
 #endif /* XT_KEYBOARD */
-	return (IO_KBDSIZE);
+    return (IO_KBDSIZE);
 }
 
-static struct kern_devconf kdc_sc[NSC] = { {
-	0, 0, 0,		/* filled in by dev_attach */
-	"sc", 0, { MDDT_ISA, 0, "tty" },
-	isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
-	&kdc_isa0,		/* parent */
-	0,			/* parentdata */
-	DC_BUSY,		/* the console is almost always busy */
-	"Graphics console"
-} };
+static struct kern_devconf kdc_sc[NSC] = {
+    0, 0, 0,        		/* filled in by dev_attach */
+    "sc", 0, { MDDT_ISA, 0, "tty" },
+    isa_generic_externalize, 0, 0, ISA_EXTERNALLEN,
+    &kdc_isa0,      		/* parent */
+    0,          		/* parentdata */
+    DC_BUSY,        		/* the console is almost always busy */
+    "Graphics console"
+};
 
 static inline void
 sc_registerdev(struct isa_device *id)
 {
-	if(id->id_unit)
-		kdc_sc[id->id_unit] = kdc_sc[0];
-	kdc_sc[id->id_unit].kdc_unit = id->id_unit;
-	kdc_sc[id->id_unit].kdc_isa = id;
-	dev_attach(&kdc_sc[id->id_unit]);
+    if(id->id_unit)
+	kdc_sc[id->id_unit] = kdc_sc[0];
+    kdc_sc[id->id_unit].kdc_unit = id->id_unit;
+    kdc_sc[id->id_unit].kdc_isa = id;
+    dev_attach(&kdc_sc[id->id_unit]);
 }
 
-#if NAPM > 0 
-/* ARGSUSED */
-static int 
-pcresume(void *dummy)
-{
-	shfts = 0;
-	ctls = 0;
-	alts = 0;
-	agrs = 0;
-	metas = 0;
-	return 0;
-}
-#endif /* NAPM > 0 */
-
-
 int
 scattach(struct isa_device *dev)
 {
-	scr_stat *scp;
+    scr_stat *scp;
 
-	scinit();
-	configuration = dev->id_flags;
-	printf("sc%d: ", dev->id_unit);
-	if (crtc_vga)
-		if (crtc_addr == MONO_BASE)
-			printf("VGA mono");
-		else	
-			printf("VGA color");
-	else
-		if (crtc_addr == MONO_BASE)
-			printf("MDA/hercules");
-		else	
-			printf("CGA/EGA");
-	printf(" <%d virtual consoles, flags=0x%x>\n", 
-			MAXCONS, configuration);
-	scp = console[0];
-	scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
-					 M_DEVBUF, M_NOWAIT);
-	/* copy screen to buffer */
-	bcopyw(Crtat, scp->scr_buf, scp->xsize * scp->ysize * sizeof(u_short));
-	scp->cursor_pos = scp->scr_buf + scp->xpos + scp->ypos * scp->xsize;
-	scp->mouse_pos = scp->scr_buf;
-
-	/* initialize history buffer & pointers */
-	scp->history_head = scp->history_pos = scp->history =
-		(u_short *)malloc(scp->history_size*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	bzero(scp->history_head, scp->history_size*sizeof(u_short));
-
-	if (crtc_vga) {
-		font_8 = (char *)malloc(8*256, M_DEVBUF, M_NOWAIT);
-		font_14 = (char *)malloc(14*256, M_DEVBUF, M_NOWAIT);
-		font_16 = (char *)malloc(16*256, M_DEVBUF, M_NOWAIT);
-		copy_font(SAVE, FONT_16, font_16);
-		fonts_loaded = FONT_16;
-		scp->font = FONT_16;
-		save_palette();
-	}
+    scinit();
+    configuration = dev->id_flags;
+    printf("sc%d: ", dev->id_unit);
+    if (crtc_vga)
+	if (crtc_addr == MONO_BASE)
+	    printf("VGA mono");
+	else    
+	    printf("VGA color");
+    else
+	if (crtc_addr == MONO_BASE)
+	    printf("MDA/hercules");
+	else    
+	    printf("CGA/EGA");
+    printf(" <%d virtual consoles, flags=0x%x>\n", MAXCONS, configuration);
+    scp = console[0];
+    scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+				     M_DEVBUF, M_NOWAIT);
+    /* copy screen to buffer */
+    bcopyw(Crtat, scp->scr_buf, scp->xsize * scp->ysize * sizeof(u_short));
+    scp->cursor_pos = scp->scr_buf + scp->xpos + scp->ypos * scp->xsize;
+    scp->mouse_pos = scp->scr_buf;
+
+    /* initialize history buffer & pointers */
+    scp->history_head = scp->history_pos = scp->history =
+	(u_short *)malloc(scp->history_size*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    bzero(scp->history_head, scp->history_size*sizeof(u_short));
+
+    if (crtc_vga) {
+	font_8 = (char *)malloc(8*256, M_DEVBUF, M_NOWAIT);
+	font_14 = (char *)malloc(14*256, M_DEVBUF, M_NOWAIT);
+	font_16 = (char *)malloc(16*256, M_DEVBUF, M_NOWAIT);
+	copy_font(SAVE, FONT_16, font_16);
+	fonts_loaded = FONT_16;
+	scp->font = FONT_16;
+	save_palette();
+    }
 
-	/* get screen update going */
-	scrn_timer();
+    /* get screen update going */
+    scrn_timer();
 
-	update_leds(scp->status);
-	sc_registerdev(dev);
+    update_leds(scp->status);
+    sc_registerdev(dev);
 #if NAPM > 0
-        scp->r_hook.ah_fun = pcresume;
-        scp->r_hook.ah_arg = NULL;
-        scp->r_hook.ah_name = "pccons keyboard";
-        scp->r_hook.ah_order = APM_MID_ORDER;
-        apm_hook_establish(APM_HOOK_RESUME , &scp->r_hook);
-#endif /* NAPM > 0*/
-	return 0;
+    scp->r_hook.ah_fun = pcresume;
+    scp->r_hook.ah_arg = NULL;
+    scp->r_hook.ah_name = "system keyboard";
+    scp->r_hook.ah_order = APM_MID_ORDER;
+    apm_hook_establish(APM_HOOK_RESUME , &scp->r_hook);
+#endif
+    return 0;
 }
 
 static struct tty 
 *get_tty_ptr(dev_t dev)
 {
-	int unit = minor(dev);
+    int unit = minor(dev);
 
-	if (unit > MAXCONS || unit < 0)
-		return(NULL);
-	if (unit == MAXCONS)
-		return CONSOLE_TTY;
-	return VIRTUAL_TTY(unit);
+    if (unit > MAXCONS || unit < 0)
+	return(NULL);
+    if (unit == MAXCONS)
+	return CONSOLE_TTY;
+    return VIRTUAL_TTY(unit);
 }
 
 static scr_stat 
 *get_scr_stat(dev_t dev)
 {
-	int unit = minor(dev);
+    int unit = minor(dev);
 
-	if (unit > MAXCONS || unit < 0)
-		return(NULL);
-	if (unit == MAXCONS)
-		return console[0];
-	return console[unit];
+    if (unit > MAXCONS || unit < 0)
+	return(NULL);
+    if (unit == MAXCONS)
+	return console[0];
+    return console[unit];
 }
 
 static int
 get_scr_num()
 {
-	int i = 0;
+    int i = 0;
 
-	while ((i < MAXCONS) && (cur_console != console[i])) i++;
-	return i < MAXCONS ? i : 0;
+    while ((i < MAXCONS) && (cur_console != console[i]))
+	i++;
+    return i < MAXCONS ? i : 0;
 }
 
 int 
 scopen(dev_t dev, int flag, int mode, struct proc *p)
 {
-	struct tty *tp = get_tty_ptr(dev);
-
-	if (!tp)
-		return(ENXIO);
-
-	tp->t_oproc = scstart;
-	tp->t_param = scparam;
-	tp->t_dev = dev;
-	if (!(tp->t_state & TS_ISOPEN)) {
-		ttychars(tp);
-		tp->t_iflag = TTYDEF_IFLAG;
-		tp->t_oflag = TTYDEF_OFLAG;
-		tp->t_cflag = TTYDEF_CFLAG;
-		tp->t_lflag = TTYDEF_LFLAG;
-		tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
-		scparam(tp, &tp->t_termios);
-		ttsetwater(tp);
-	} else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
-		return(EBUSY);
-	tp->t_state |= TS_CARR_ON;
-	tp->t_cflag |= CLOCAL;
-	if (!console[minor(dev)])
-		console[minor(dev)] = alloc_scp();
-	return((*linesw[tp->t_line].l_open)(dev, tp));
+    struct tty *tp = get_tty_ptr(dev);
+
+    if (!tp)
+	return(ENXIO);
+
+    tp->t_oproc = scstart;
+    tp->t_param = scparam;
+    tp->t_dev = dev;
+    if (!(tp->t_state & TS_ISOPEN)) {
+	ttychars(tp);
+	tp->t_iflag = TTYDEF_IFLAG;
+	tp->t_oflag = TTYDEF_OFLAG;
+	tp->t_cflag = TTYDEF_CFLAG;
+	tp->t_lflag = TTYDEF_LFLAG;
+	tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
+	scparam(tp, &tp->t_termios);
+	ttsetwater(tp);
+    } 
+    else 
+	if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
+	    return(EBUSY);
+    tp->t_state |= TS_CARR_ON;
+    tp->t_cflag |= CLOCAL;
+    if (!console[minor(dev)])
+	console[minor(dev)] = alloc_scp();
+    return((*linesw[tp->t_line].l_open)(dev, tp));
 }
 
 int 
 scclose(dev_t dev, int flag, int mode, struct proc *p)
 {
-	struct tty *tp = get_tty_ptr(dev);
-	struct scr_stat *scp;
-
-	if (!tp)
-		return(ENXIO);
-	if (minor(dev) < MAXCONS) {
-		scp = get_scr_stat(tp->t_dev);
-		if (scp->status & SWITCH_WAIT_ACQ)
-			wakeup((caddr_t)&scp->smode);
+    struct tty *tp = get_tty_ptr(dev);
+    struct scr_stat *scp;
+
+    if (!tp)
+	return(ENXIO);
+    if (minor(dev) < MAXCONS) {
+	scp = get_scr_stat(tp->t_dev);
+	if (scp->status & SWITCH_WAIT_ACQ)
+	    wakeup((caddr_t)&scp->smode);
 #if not_yet_done
-		if (scp == &main_console) {
-			scp->pid = 0;
-			scp->proc = NULL;
-			scp->smode.mode = VT_AUTO;
-		}
-		else {
-			free(scp->scr_buf, M_DEVBUF); 
-			free(scp->history, M_DEVBUF); 
-			free(scp, M_DEVBUF);
-			console[minor(dev)] = NULL;
-		}
+	if (scp == &main_console) {
+	    scp->pid = 0;
+	    scp->proc = NULL;
+	    scp->smode.mode = VT_AUTO;
+	}
+	else {
+	    free(scp->scr_buf, M_DEVBUF); 
+	    free(scp->history, M_DEVBUF); 
+	    free(scp, M_DEVBUF);
+	    console[minor(dev)] = NULL;
+	}
 #else
-		scp->pid = 0;
-		scp->proc = NULL;
-		scp->smode.mode = VT_AUTO;
+	scp->pid = 0;
+	scp->proc = NULL;
+	scp->smode.mode = VT_AUTO;
 #endif
-	}
-	(*linesw[tp->t_line].l_close)(tp, flag);
-	ttyclose(tp); 
-	return(0);
+    }
+    (*linesw[tp->t_line].l_close)(tp, flag);
+    ttyclose(tp); 
+    return(0);
 }
 
 int 
 scread(dev_t dev, struct uio *uio, int flag)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return(ENXIO);
-	return((*linesw[tp->t_line].l_read)(tp, uio, flag));
+    if (!tp)
+	return(ENXIO);
+    return((*linesw[tp->t_line].l_read)(tp, uio, flag));
 }
 
 int 
 scwrite(dev_t dev, struct uio *uio, int flag)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return(ENXIO);
-	return((*linesw[tp->t_line].l_write)(tp, uio, flag));
+    if (!tp)
+	return(ENXIO);
+    return((*linesw[tp->t_line].l_write)(tp, uio, flag));
 }
 
 void 
 scintr(int unit)
 {
-	static struct tty *cur_tty;
-	int c, len;
-	u_char *cp;
-
-	/* make screensaver happy */
-	scrn_time_stamp = time.tv_sec;
-	if (scrn_blanked) {
-		SCRN_SAVER(FALSE);
-		cur_console->status |= UPDATE_SCREEN;
-	}
-
-	c = scgetc(1);
-
-	cur_tty = VIRTUAL_TTY(get_scr_num());
-	if (!(cur_tty->t_state & TS_ISOPEN))
-		if (!((cur_tty = CONSOLE_TTY)->t_state & TS_ISOPEN))
-			return;
+    static struct tty *cur_tty;
+    int c, len;
+    u_char *cp;
+
+    /* make screensaver happy */
+    scrn_time_stamp = time.tv_sec;
+    if (scrn_blanked) {
+	(*current_saver)(FALSE);
+	cur_console->status |= UPDATE_SCREEN;
+    }
 
-	switch (c & 0xff00) {
-	case 0x0000: /* normal key */
-		(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
-		break;
-	case NOKEY:	/* nothing there */
-		break;
-	case FKEY:	/* function key, return string */
-		if (cp = get_fstr((u_int)c, (u_int *)&len)) {
-			while (len-- >  0)
-				(*linesw[cur_tty->t_line].l_rint)
-					(*cp++ & 0xFF, cur_tty);
-		}
-		break;
-	case MKEY:	/* meta is active, prepend ESC */
-		(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
-		break;
-	case BKEY:	/* backtab fixed sequence (esc [ Z) */
-		(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
-		(*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
-		break;
-	}	
+    c = scgetc(1);
+
+    cur_tty = VIRTUAL_TTY(get_scr_num());
+    if (!(cur_tty->t_state & TS_ISOPEN))
+	if (!((cur_tty = CONSOLE_TTY)->t_state & TS_ISOPEN))
+	    return;
+
+    switch (c & 0xff00) {
+    case 0x0000: /* normal key */
+	(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
+	break;
+    case NOKEY: /* nothing there */
+	break;
+    case FKEY:  /* function key, return string */
+	if (cp = get_fstr((u_int)c, (u_int *)&len)) {
+	    while (len-- >  0)
+		(*linesw[cur_tty->t_line].l_rint)(*cp++ & 0xFF, cur_tty);
+	}
+	break;
+    case MKEY:  /* meta is active, prepend ESC */
+	(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)(c & 0xFF, cur_tty);
+	break;
+    case BKEY:  /* backtab fixed sequence (esc [ Z) */
+	(*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
+	(*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
+	break;
+    }   
 }
 
 int 
 scparam(struct tty *tp, struct termios *t)
 {
-	int cflag = t->c_cflag;
-
-	/* and copy to tty */
-	tp->t_ispeed = t->c_ispeed;
-	tp->t_ospeed = t->c_ospeed;
-	tp->t_cflag = cflag;
-	return 0;
+    tp->t_ispeed = t->c_ispeed;
+    tp->t_ospeed = t->c_ospeed;
+    tp->t_cflag = t->c_cflag;
+    return 0;
 }
 
 int 
 scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 {
-	int i, error;
-	struct tty *tp;
-	struct trapframe *fp;
-	scr_stat *scp; 
-
-	tp = get_tty_ptr(dev);
-	if (!tp)
-		return ENXIO;
-	scp = get_scr_stat(tp->t_dev);
+    int i, error;
+    struct tty *tp;
+    struct trapframe *fp;
+    scr_stat *scp; 
 
-	switch (cmd) {	/* process console hardware related ioctl's */
+    tp = get_tty_ptr(dev);
+    if (!tp)
+	return ENXIO;
+    scp = get_scr_stat(tp->t_dev);
 
-	case GIO_ATTR:		/* get current attributes */
-		*(int*)data = scp->term.cur_attr;
-		return 0;
+    switch (cmd) {  		/* process console hardware related ioctl's */
 
-	case GIO_COLOR:		/* is this a color console ? */
-		if (crtc_addr == COLOR_BASE)
-			*(int*)data = 1;
-		else
-			*(int*)data = 0;
-		return 0;
-			
-	case CONS_CURRENT:	/* get current adapter type */
-		if (crtc_vga)
-			*(int*)data = KD_VGA;
-		else
-			if (crtc_addr == MONO_BASE)
-				*(int*)data = KD_MONO;
-			else	
-				*(int*)data = KD_CGA;
-		return 0;
+    case GIO_ATTR:      	/* get current attributes */
+	*(int*)data = scp->term.cur_attr;
+	return 0;
 
-	case CONS_GET:		/* get current video mode */
-		*(int*)data = scp->mode;
-		return 0;
+    case GIO_COLOR:     	/* is this a color console ? */
+	if (crtc_addr == COLOR_BASE)
+	    *(int*)data = 1;
+	else
+	    *(int*)data = 0;
+	return 0;
+	    
+    case CONS_CURRENT:  	/* get current adapter type */
+	if (crtc_vga)
+	    *(int*)data = KD_VGA;
+	else
+	    if (crtc_addr == MONO_BASE)
+		*(int*)data = KD_MONO;
+	    else    
+		*(int*)data = KD_CGA;
+	return 0;
 
-	case CONS_BLANKTIME:	/* set screen saver timeout (0 = no saver) */
-		scrn_blank_time = *(int*)data;
-		return 0;
+    case CONS_GET:      	/* get current video mode */
+	*(int*)data = scp->mode;
+	return 0;
 
-#define	SAVER(p) ((ssaver_t *)(p))
-	case CONS_SSAVER:	/* set screen saver */
-		if (SAVER(data)->num < 0 
-		    || SAVER(data)->num >= NUM_SCRN_SAVERS)
-			return EIO;
-		if (scrn_blanked) {
-			SCRN_SAVER(FALSE);
-			cur_console->status |= UPDATE_SCREEN;
-		}
-		scrn_saver = SAVER(data)->num;
-		scrn_blank_time = SAVER(data)->time;
-		return 0;
+    case CONS_BLANKTIME:    	/* set screen saver timeout (0 = no saver) */
+	scrn_blank_time = *(int*)data;
+	return 0;
 
-	case CONS_GSAVER:	/* get screen saver info */
-		if (SAVER(data)->num < 0)
-			SAVER(data)->num = scrn_saver;
-		else if (SAVER(data)->num >= NUM_SCRN_SAVERS)
-			return EIO;
-		SAVER(data)->time = scrn_blank_time;
-		strcpy(SAVER(data)->name, screen_savers[SAVER(data)->num].name);
-		return 0;
+    case CONS_CURSORTYPE:   	/* set cursor type blink/noblink */
+	if ((*(int*)data) & 0x01)
+	    configuration |= BLINK_CURSOR;
+	else
+	    configuration &= ~BLINK_CURSOR;
+	if ((*(int*)data) & 0x02)
+	    configuration |= CHAR_CURSOR;
+	else
+	    configuration &= ~CHAR_CURSOR;
+	return 0;
 
-	case CONS_CURSORTYPE:	/* set cursor type blink/noblink */
-		if ((*(int*)data) & 0x01)
-			configuration |= BLINK_CURSOR;
-		else
-			configuration &= ~BLINK_CURSOR;
-		if ((*(int*)data) & 0x02)
-			configuration |= CHAR_CURSOR;
-		else
-			configuration &= ~CHAR_CURSOR;
-		return 0;
+    case CONS_BELLTYPE: 	/* set bell type sound/visual */
+	if (*data)
+	    configuration |= VISUAL_BELL;
+	else
+	    configuration &= ~VISUAL_BELL;
+	return 0;
 
-	case CONS_BELLTYPE:	/* set bell type sound/visual */
-		if (*data)
-			configuration |= VISUAL_BELL;
-		else
-			configuration &= ~VISUAL_BELL;
-		return 0;
+    case CONS_HISTORY:  	/* set history size */
+	if (*data) {
+	    free(scp->history, M_DEVBUF); 
+	    scp->history_size = *(int*)data;
+	    if (scp->history_size < scp->ysize)
+		scp->history = NULL;
+	    else {
+		scp->history_size *= scp->xsize;
+		scp->history_head = scp->history_pos = scp->history =
+		    (u_short *)malloc(scp->history_size*sizeof(u_short),
+				      M_DEVBUF, M_NOWAIT);
+		bzero(scp->history_head, scp->history_size*sizeof(u_short));
+	    }
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case CONS_HISTORY:	/* set history size */
-		if (*data) {
-		    free(scp->history, M_DEVBUF); 
-		    scp->history_size = *(int*)data;
-		    if (scp->history_size < scp->ysize)
-			scp->history = NULL;
-		    else {
-			scp->history_size *= scp->xsize;
-			scp->history_head = scp->history_pos = scp->history =
-			    (u_short *)malloc(scp->history_size*sizeof(u_short),
-					      M_DEVBUF, M_NOWAIT);
-			bzero(scp->history_head, 
-			      scp->history_size*sizeof(u_short));
-		    }
-		    return 0;
-		}
-		else
-			return EINVAL;
-
-	case CONS_MOUSECTL:
-	{
-		mouse_info_t *mouse = (mouse_info_t*)data;
-		int fontsize;
-
-		switch (scp->font) {
-		default:
-		case FONT_8:
-			fontsize = 8; break;
-		case FONT_14:
-			fontsize = 14; break;
-		case FONT_16:
-			fontsize = 16; break;
-		}
-		switch (mouse->operation) {
-		case MOUSE_SHOW:
-			if (!(scp->status & MOUSE_ENABLED)) {
-				scp->mouse_oldpos = 
-					Crtat + (scp->mouse_pos - scp->scr_buf);
-				scp->status |= (UPDATE_MOUSE | MOUSE_ENABLED);
-			}
-			else
-				return EINVAL;
-			break;
-
-		case MOUSE_HIDE:
-			if (scp->status & MOUSE_ENABLED) {
-				scp->status &= ~MOUSE_ENABLED;
-				scp->status |= UPDATE_MOUSE;
-			}
-			else
-				return EINVAL;
-			break;
-
-		case MOUSE_MOVEABS:
-			scp->mouse_xpos = mouse->x;
-			scp->mouse_ypos = mouse->y;
-			goto set_mouse_pos;
-
-		case MOUSE_MOVEREL:
-			scp->mouse_xpos += mouse->x;
-			scp->mouse_ypos += mouse->y;
+    case CONS_MOUSECTL:		/* control mouse arrow */
+    {
+	mouse_info_t *mouse = (mouse_info_t*)data;
+	int fontsize;
+
+	switch (scp->font) {
+	default:
+	case FONT_8:
+	    fontsize = 8; break;
+	case FONT_14:
+	    fontsize = 14; break;
+	case FONT_16:
+	    fontsize = 16; break;
+	}
+	switch (mouse->operation) {
+	case MOUSE_SHOW:
+	    if (!(scp->status & MOUSE_ENABLED)) {
+		scp->mouse_oldpos = Crtat + (scp->mouse_pos - scp->scr_buf);
+		scp->status |= (UPDATE_MOUSE | MOUSE_ENABLED);
+	    }
+	    else
+		return EINVAL;
+	    break;
+
+	case MOUSE_HIDE:
+	    if (scp->status & MOUSE_ENABLED) {
+		scp->status &= ~MOUSE_ENABLED;
+		scp->status |= UPDATE_MOUSE;
+	    }
+	    else
+		return EINVAL;
+	    break;
+
+	case MOUSE_MOVEABS:
+	    scp->mouse_xpos = mouse->x;
+	    scp->mouse_ypos = mouse->y;
+	    goto set_mouse_pos;
+
+	case MOUSE_MOVEREL:
+	    scp->mouse_xpos += mouse->x;
+	    scp->mouse_ypos += mouse->y;
 set_mouse_pos:
-			if (scp->mouse_xpos < 0)
-				scp->mouse_xpos = 0;
-			if (scp->mouse_ypos < 0)
-				scp->mouse_ypos = 0;
-			if (scp->mouse_xpos >= scp->xsize*8)
-				scp->mouse_xpos = (scp->xsize*8)-1;
-			if (scp->mouse_ypos >= scp->ysize*fontsize)
-				scp->mouse_ypos = (scp->ysize*fontsize)-1;
-			scp->mouse_pos = scp->scr_buf + 
-				(scp->mouse_ypos/fontsize)*scp->xsize + 
-				scp->mouse_xpos/8;
-			if (scp->status & MOUSE_ENABLED)
-				scp->status |= UPDATE_MOUSE;
-			break;
-
-		case MOUSE_GETPOS:
-			mouse->x = scp->mouse_xpos;
-			mouse->y = scp->mouse_ypos;
-			return 0;
-
-		default:
-			return EINVAL;
-		}
-		/* make screensaver happy */
-		if (scp == cur_console) {
-			scrn_time_stamp = time.tv_sec;
-			if (scrn_blanked) {
-				SCRN_SAVER(FALSE);
-				scp->status |= UPDATE_SCREEN;
-			}
-		}
-		return 0;
+	    if (scp->mouse_xpos < 0)
+		scp->mouse_xpos = 0;
+	    if (scp->mouse_ypos < 0)
+		scp->mouse_ypos = 0;
+	    if (scp->mouse_xpos >= scp->xsize*8)
+		scp->mouse_xpos = (scp->xsize*8)-1;
+	    if (scp->mouse_ypos >= scp->ysize*fontsize)
+		scp->mouse_ypos = (scp->ysize*fontsize)-1;
+	    scp->mouse_pos = scp->scr_buf + 
+		(scp->mouse_ypos/fontsize)*scp->xsize + scp->mouse_xpos/8;
+	    if (scp->status & MOUSE_ENABLED)
+		scp->status |= UPDATE_MOUSE;
+	    break;
+
+	case MOUSE_GETPOS:
+	    mouse->x = scp->mouse_xpos;
+	    mouse->y = scp->mouse_ypos;
+	    return 0;
+
+	default:
+	    return EINVAL;
+	}
+	/* make screensaver happy */
+	if (scp == cur_console) {
+	    scrn_time_stamp = time.tv_sec;
+	    if (scrn_blanked) {
+		(*current_saver)(FALSE);
+		scp->status |= UPDATE_SCREEN;
+	    }
 	}
+	return 0;
+    }
 
-	case CONS_GETINFO:	/* get current (virtual) console info */
-	{
-		vid_info_t *ptr = (vid_info_t*)data;
-		if (ptr->size == sizeof(struct vid_info)) {
-			ptr->m_num = get_scr_num();
-			ptr->mv_col = scp->xpos;
-			ptr->mv_row = scp->ypos;
-			ptr->mv_csz = scp->xsize;
-			ptr->mv_rsz = scp->ysize;
-			ptr->mv_norm.fore = (scp->term.std_attr & 0x0f00)>>8;
-			ptr->mv_norm.back = (scp->term.std_attr & 0xf000)>>12;
-			ptr->mv_rev.fore = (scp->term.rev_attr & 0x0f00)>>8;
-			ptr->mv_rev.back = (scp->term.rev_attr & 0xf000)>>12;
-			ptr->mv_grfc.fore = 0;		/* not supported */
-			ptr->mv_grfc.back = 0;		/* not supported */
-			ptr->mv_ovscan = scp->border;
-			ptr->mk_keylock = scp->status & LOCK_KEY_MASK;
-			return 0;
-		}
+    case CONS_GETINFO:  	/* get current (virtual) console info */
+    {
+	vid_info_t *ptr = (vid_info_t*)data;
+	if (ptr->size == sizeof(struct vid_info)) {
+	    ptr->m_num = get_scr_num();
+	    ptr->mv_col = scp->xpos;
+	    ptr->mv_row = scp->ypos;
+	    ptr->mv_csz = scp->xsize;
+	    ptr->mv_rsz = scp->ysize;
+	    ptr->mv_norm.fore = (scp->term.std_attr & 0x0f00)>>8;
+	    ptr->mv_norm.back = (scp->term.std_attr & 0xf000)>>12;
+	    ptr->mv_rev.fore = (scp->term.rev_attr & 0x0f00)>>8;
+	    ptr->mv_rev.back = (scp->term.rev_attr & 0xf000)>>12;
+	    ptr->mv_grfc.fore = 0;      /* not supported */
+	    ptr->mv_grfc.back = 0;      /* not supported */
+	    ptr->mv_ovscan = scp->border;
+	    ptr->mk_keylock = scp->status & LOCK_KEY_MASK;
+	    return 0;
+	}
+	return EINVAL;
+    }
+
+    case CONS_GETVERS:  	/* get version number */
+	*(int*)data = 0x200;    /* version 2.0 */
+	return 0;
+
+    /* VGA TEXT MODES */
+    case SW_VGA_C40x25:
+    case SW_VGA_C80x25: case SW_VGA_M80x25:
+    case SW_VGA_C80x30: case SW_VGA_M80x30:
+    case SW_VGA_C80x50: case SW_VGA_M80x50:
+    case SW_VGA_C80x60: case SW_VGA_M80x60:
+    case SW_B40x25:     case SW_C40x25:
+    case SW_B80x25:     case SW_C80x25:
+    case SW_ENH_B40x25: case SW_ENH_C40x25: 
+    case SW_ENH_B80x25: case SW_ENH_C80x25:
+    case SW_ENH_B80x43: case SW_ENH_C80x43:
+
+	if (!crtc_vga || video_mode_ptr == NULL)
+	    return ENXIO;
+	switch (cmd & 0xff) {
+	case M_VGA_C80x60: case M_VGA_M80x60:
+	    if (!(fonts_loaded & FONT_8))
+		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 60;
+	    break;
+	case M_VGA_C80x50: case M_VGA_M80x50:
+	    if (!(fonts_loaded & FONT_8))
+		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 50;
+	    break;
+	case M_ENH_B80x43: case M_ENH_C80x43:
+	    if (!(fonts_loaded & FONT_8))
 		return EINVAL;
+	    scp->xsize = 80;
+	    scp->ysize = 43;
+	    break;
+	case M_VGA_C80x30: case M_VGA_M80x30:
+	    scp->xsize = 80;
+	    scp->ysize = 30;
+	    break;
+	default:
+	    if ((cmd & 0xff) > M_VGA_CG320)
+		return EINVAL;
+	    else 
+		scp->xsize = *(video_mode_ptr+((cmd&0xff)*64));
+		scp->ysize = *(video_mode_ptr+((cmd&0xff)*64)+1)+1;
+	    break;
+	}
+	scp->mode = cmd & 0xff;
+	scp->status &= ~UNKNOWN_MODE;   /* text mode */
+	free(scp->scr_buf, M_DEVBUF); 
+	scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+					 M_DEVBUF, M_NOWAIT);
+	if (scp == cur_console)
+	    set_mode(scp);
+	clear_screen(scp);
+	if (tp->t_winsize.ws_col != scp->xsize 
+	    || tp->t_winsize.ws_row != scp->ysize) {
+	    tp->t_winsize.ws_col = scp->xsize;
+	    tp->t_winsize.ws_row = scp->ysize;
+	    pgsignal(tp->t_pgrp, SIGWINCH, 1);
+	}
+	return 0; 
+
+    /* GRAPHICS MODES */
+    case SW_BG320:     case SW_BG640:
+    case SW_CG320:     case SW_CG320_D:   case SW_CG640_E:
+    case SW_CG640x350: case SW_ENH_CG640:
+    case SW_BG640x480: case SW_CG640x480: case SW_VGA_CG320:
+
+	if (!crtc_vga || video_mode_ptr == NULL)
+	    return ENXIO;
+	scp->mode = cmd & 0xFF;
+	scp->status |= UNKNOWN_MODE;    /* graphics mode */
+	scp->xsize = (*(video_mode_ptr + (scp->mode*64))) * 8;
+	scp->ysize = (*(video_mode_ptr + (scp->mode*64) + 1) + 1) *
+		     (*(video_mode_ptr + (scp->mode*64) + 2));
+	set_mode(scp);
+	/* clear_graphics();*/
+
+	if (tp->t_winsize.ws_xpixel != scp->xsize 
+	    || tp->t_winsize.ws_ypixel != scp->ysize) {
+	    tp->t_winsize.ws_xpixel = scp->xsize;
+	    tp->t_winsize.ws_ypixel = scp->ysize;
+	    pgsignal(tp->t_pgrp, SIGWINCH, 1);
 	}
+	return 0;
 
-	case CONS_GETVERS:	/* get version number */
-		*(int*)data = 0x200;	/* version 2.0 */
+    case VT_SETMODE:    	/* set screen switcher mode */
+	bcopy(data, &scp->smode, sizeof(struct vt_mode));
+	if (scp->smode.mode == VT_PROCESS) {
+	    scp->proc = p;
+	    scp->pid = scp->proc->p_pid;
+	}
+	return 0;
+    
+    case VT_GETMODE:    	/* get screen switcher mode */
+	bcopy(&scp->smode, data, sizeof(struct vt_mode));
+	return 0;
+    
+    case VT_RELDISP:    	/* screen switcher ioctl */
+	switch(*data) {
+	case VT_FALSE:  	/* user refuses to release screen, abort */
+	    if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
+		old_scp->status &= ~SWITCH_WAIT_REL;
+		switch_in_progress = FALSE;
 		return 0;
+	    }
+	    return EINVAL;
 
-	case SW_VGA_C40x25: case SW_VGA_C80x25:	/* VGA TEXT MODES */
-	case SW_VGA_M80x25:
-	case SW_VGA_C80x30: case SW_VGA_M80x30:
-	case SW_VGA_C80x50: case SW_VGA_M80x50:
-	case SW_VGA_C80x60: case SW_VGA_M80x60:
-	case SW_B40x25:     case SW_C40x25:
-	case SW_B80x25:     case SW_C80x25:
-	case SW_ENH_B40x25: case SW_ENH_C40x25: 
-	case SW_ENH_B80x25: case SW_ENH_C80x25:
-	case SW_ENH_B80x43: case SW_ENH_C80x43:
-
-		if (!crtc_vga || video_mode_ptr == NULL)
-			return ENXIO;
-		switch (cmd & 0xff) {
-		case M_VGA_C80x60: case M_VGA_M80x60:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 60;
-			break;
-		case M_VGA_C80x50: case M_VGA_M80x50:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 50;
-			break;
-		case M_ENH_B80x43: case M_ENH_C80x43:
-			if (!(fonts_loaded & FONT_8))
-				return EINVAL;
-			scp->xsize = 80;
-			scp->ysize = 43;
-			break;
-		case M_VGA_C80x30: case M_VGA_M80x30:
-			scp->xsize = 80;
-			scp->ysize = 30;
-			break;
-		default:
-			if ((cmd & 0xff) > M_VGA_CG320)
-				return EINVAL;
-			else 
-			    scp->xsize = *(video_mode_ptr+((cmd&0xff)*64));
-			    scp->ysize = *(video_mode_ptr+((cmd&0xff)*64)+1)+1;
-			break;
-		}
-		scp->mode = cmd & 0xff;
-		scp->status &= ~UNKNOWN_MODE;	/* text mode */
-		free(scp->scr_buf, M_DEVBUF); 
-		scp->scr_buf = (u_short *)malloc(scp->xsize * scp->ysize * 
-				sizeof(u_short), M_DEVBUF, M_NOWAIT);
-		if (scp == cur_console)
-			set_mode(scp);
-		clear_screen(scp);
-		if (tp->t_winsize.ws_col != scp->xsize 
-		    || tp->t_winsize.ws_row != scp->ysize) {
-			tp->t_winsize.ws_col = scp->xsize;
-			tp->t_winsize.ws_row = scp->ysize;
-			pgsignal(tp->t_pgrp, SIGWINCH, 1);
+	case VT_TRUE:   	/* user has released screen, go on */
+	    if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
+		scp->status &= ~SWITCH_WAIT_REL;
+		exchange_scr();
+		if (new_scp->smode.mode == VT_PROCESS) {
+		    new_scp->status |= SWITCH_WAIT_ACQ;
+		    psignal(new_scp->proc, new_scp->smode.acqsig);
 		}
-		return 0; 
-
-	/* GRAPHICS MODES */
-	case SW_BG320:      case SW_CG320:      case SW_BG640:
-	case SW_CG320_D:    case SW_CG640_E:
-	case SW_CG640x350:  case SW_ENH_CG640:
-	case SW_BG640x480:  case SW_CG640x480:  case SW_VGA_CG320:
-
-		if (!crtc_vga || video_mode_ptr == NULL)
-			return ENXIO;
-		scp->mode = cmd & 0xFF;
-		scp->status |= UNKNOWN_MODE;	/* graphics mode */
-		scp->xsize = (*(video_mode_ptr + (scp->mode*64))) * 8;
-		scp->ysize = (*(video_mode_ptr + (scp->mode*64) + 1) + 1)
-			   * (*(video_mode_ptr + (scp->mode*64) + 2));
-		set_mode(scp);
-		/* clear_graphics();*/
+		else 
+		    switch_in_progress = FALSE;
+		return 0;
+	    }
+	    return EINVAL;
 
-		if (tp->t_winsize.ws_xpixel != scp->xsize 
-		    || tp->t_winsize.ws_ypixel != scp->ysize) {
-			tp->t_winsize.ws_xpixel = scp->xsize;
-			tp->t_winsize.ws_ypixel = scp->ysize;
-			pgsignal(tp->t_pgrp, SIGWINCH, 1);
-		}
+	case VT_ACKACQ: 	/* acquire acknowledged, switch completed */
+	    if (scp == new_scp && (scp->status & SWITCH_WAIT_ACQ)) {
+		scp->status &= ~SWITCH_WAIT_ACQ;
+		switch_in_progress = FALSE;
 		return 0;
+	    }
+	    return EINVAL;
 
-	case VT_SETMODE:	/* set screen switcher mode */
-		bcopy(data, &scp->smode, sizeof(struct vt_mode));
-		if (scp->smode.mode == VT_PROCESS) {
-			scp->proc = p;
-			scp->pid = scp->proc->p_pid;
-		}
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
+
+    case VT_OPENQRY:    	/* return free virtual console */
+	for (i = 0; i < MAXCONS; i++) {
+	    tp = VIRTUAL_TTY(i);
+	    if (!(tp->t_state & TS_ISOPEN)) {
+		*data = i + 1;
 		return 0;
-	
-	case VT_GETMODE:	/* get screen switcher mode */
-		bcopy(&scp->smode, data, sizeof(struct vt_mode));
+	    }
+	} 
+	return EINVAL;
+
+    case VT_ACTIVATE:   	/* switch to screen *data */
+	return switch_scr(scp, (*data) - 1);
+
+    case VT_WAITACTIVE: 	/* wait for switch to occur */
+	if (*data > MAXCONS || *data < 0) 
+	    return EINVAL;
+	if (minor(dev) == (*data) - 1) 
+	    return 0;
+	if (*data == 0) {
+	    if (scp == cur_console)
 		return 0;
-	
-	case VT_RELDISP:	/* screen switcher ioctl */
-		switch(*data) {
-		case VT_FALSE:	/* user refuses to release screen, abort */
-			if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
-				old_scp->status &= ~SWITCH_WAIT_REL;
-				switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
-
-		case VT_TRUE:	/* user has released screen, go on */
-			if (scp == old_scp && (scp->status & SWITCH_WAIT_REL)) {
-				scp->status &= ~SWITCH_WAIT_REL;
-				exchange_scr();
-				if (new_scp->smode.mode == VT_PROCESS) {
-					new_scp->status |= SWITCH_WAIT_ACQ;
-					psignal(new_scp->proc, 
-						new_scp->smode.acqsig);
-				}
-				else 
-					switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
+	}
+	else 
+	    scp = console[(*data) - 1];
+	while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH, 
+			     "waitvt", 0)) == ERESTART) ;
+	return error;
 
-		case VT_ACKACQ:	/* acquire acknowledged, switch completed */
-			if (scp == new_scp && (scp->status & SWITCH_WAIT_ACQ)) {
-				scp->status &= ~SWITCH_WAIT_ACQ;
-				switch_in_progress = FALSE;
-				return 0;
-			}
-			return EINVAL;
+    case VT_GETACTIVE:
+	*data = get_scr_num()+1;
+	return 0;
 
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
-
-	case VT_OPENQRY:	/* return free virtual console */
-		for (i = 0; i < MAXCONS; i++) {
-			tp = VIRTUAL_TTY(i);
-			if (!(tp->t_state & TS_ISOPEN)) {
-				*data = i + 1;
-				return 0;
-			}
-		} 
-		return EINVAL;
+    case KDENABIO:      	/* allow io operations */
+	fp = (struct trapframe *)p->p_md.md_regs;
+	fp->tf_eflags |= PSL_IOPL;
+	return 0; 
 
-	case VT_ACTIVATE:	/* switch to screen *data */
-		return switch_scr(scp, (*data) - 1);
-
-	case VT_WAITACTIVE:	/* wait for switch to occur */
-		if (*data > MAXCONS || *data < 0) 
-			return EINVAL;
-		if (minor(dev) == (*data) - 1) 
-			return 0;
-		if (*data == 0) {
-			if (scp == cur_console)
-				return 0;
-		}
-		else 
-			scp = console[(*data) - 1];
-		while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH, 
-			"waitvt", 0)) == ERESTART) ;
-		return error;
+    case KDDISABIO:     	/* disallow io operations (default) */
+	fp = (struct trapframe *)p->p_md.md_regs;
+	fp->tf_eflags &= ~PSL_IOPL;
+	return 0;
 
-	case VT_GETACTIVE:
-		*data = get_scr_num()+1;
-		return 0;
+    case KDSETMODE:     	/* set current mode of this (virtual) console */
+	switch (*data) {
+	case KD_TEXT:   	/* switch to TEXT (known) mode */
+	    /* restore fonts & palette ! */
+	    if (crtc_vga) {
+		if (fonts_loaded & FONT_8)
+		    copy_font(LOAD, FONT_8, font_8);
+		if (fonts_loaded & FONT_14)
+		    copy_font(LOAD, FONT_14, font_14);
+		if (fonts_loaded & FONT_16)
+		    copy_font(LOAD, FONT_16, font_16);
+		load_palette();
+	    }
+	    /* FALL THROUGH */
 
-	case KDENABIO:		/* allow io operations */
-		fp = (struct trapframe *)p->p_md.md_regs;
-		fp->tf_eflags |= PSL_IOPL;
-		return 0; 
+	case KD_TEXT1:  	/* switch to TEXT (known) mode */
+	    /* no restore fonts & palette */
+	    scp->status &= ~UNKNOWN_MODE;
+	    if (crtc_vga && video_mode_ptr)
+		set_mode(scp);
+	    clear_screen(scp);
+	    return 0;
 
-	case KDDISABIO:		/* disallow io operations (default) */
-		fp = (struct trapframe *)p->p_md.md_regs;
-		fp->tf_eflags &= ~PSL_IOPL;
-		return 0;
+	case KD_GRAPHICS:	/* switch to GRAPHICS (unknown) mode */
+	    scp->status |= UNKNOWN_MODE;
+	    return 0;
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
 
-	case KDSETMODE:		/* set current mode of this (virtual) console */
-		switch (*data) {
-		case KD_TEXT:	/* switch to TEXT (known) mode */
-				/* restore fonts & palette ! */
-			if (crtc_vga) {
-				if (fonts_loaded & FONT_8)
-					copy_font(LOAD, FONT_8, font_8);
-				if (fonts_loaded & FONT_14)
-					copy_font(LOAD, FONT_14, font_14);
-				if (fonts_loaded & FONT_16)
-					copy_font(LOAD, FONT_16, font_16);
-				load_palette();
-			}
-			/* FALL THROUGH */
-
-		case KD_TEXT1:	/* switch to TEXT (known) mode */
-				/* no restore fonts & palette */
-			scp->status &= ~UNKNOWN_MODE;
-			if (crtc_vga && video_mode_ptr)
-				set_mode(scp);
-			clear_screen(scp);
-			return 0;
-
-		case KD_GRAPHICS:/* switch to GRAPHICS (unknown) mode */
-			scp->status |= UNKNOWN_MODE;
-			return 0;
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
+    case KDGETMODE:     	/* get current mode of this (virtual) console */
+	*data = (scp->status & UNKNOWN_MODE) ? KD_GRAPHICS : KD_TEXT;
+	return 0;
 
-	case KDGETMODE:		/* get current mode of this (virtual) console */
-		*data = (scp->status & UNKNOWN_MODE) ? KD_GRAPHICS : KD_TEXT;
-		return 0;
+    case KDSBORDER:     	/* set border color of this (virtual) console */
+	if (!crtc_vga)
+	    return ENXIO;
+	scp->border = *data;
+	if (scp == cur_console) 
+	    set_border(scp->border);
+	return 0;
 
-	case KDSBORDER:		/* set border color of this (virtual) console */
-		if (!crtc_vga)
-			return ENXIO;
-		scp->border = *data;
-		if (scp == cur_console) 
-			set_border(scp->border);
-		return 0;
+    case KDSKBSTATE:    	/* set keyboard state (locks) */
+	if (*data >= 0 && *data <= LOCK_KEY_MASK) {
+	    scp->status &= ~LOCK_KEY_MASK;
+	    scp->status |= *data;
+	    if (scp == cur_console) 
+		update_leds(scp->status);
+	    return 0;
+	}
+	return EINVAL;
 
-	case KDSKBSTATE:	/* set keyboard state (locks) */
-		if (*data >= 0 && *data <= LOCK_KEY_MASK) {
-			scp->status &= ~LOCK_KEY_MASK;
-			scp->status |= *data;
-			if (scp == cur_console) 
-				update_leds(scp->status);
-			return 0;
-		}
-		return EINVAL;
+    case KDGKBSTATE:    	/* get keyboard state (locks) */
+	*data = scp->status & LOCK_KEY_MASK;
+	return 0;
 
-	case KDGKBSTATE:	/* get keyboard state (locks) */
-		*data = scp->status & LOCK_KEY_MASK;
-		return 0;
+    case KDSETRAD:      	/* set keyboard repeat & delay rates */
+	if (*data & 0x80)
+	    return EINVAL;
+	i = spltty();
+	kbd_cmd(KB_SETRAD);
+	kbd_cmd(*data);
+	splx(i);
+	return 0;
 
-	case KDSETRAD:		/* set keyboard repeat & delay rates */
-		if (*data & 0x80)
-			return EINVAL;
-		i = spltty();
-		kbd_cmd(KB_SETRAD);
-		kbd_cmd(*data);
-		splx(i);
-		return 0;
+    case KDSKBMODE:     	/* set keyboard mode */
+	switch (*data) {
+	case K_RAW: 		/* switch to RAW scancode mode */
+	    scp->status |= KBD_RAW_MODE;
+	    return 0;
 
-	case KDSKBMODE:		/* set keyboard mode */
-		switch (*data) {
-		case K_RAW:	/* switch to RAW scancode mode */
-			scp->status |= KBD_RAW_MODE;
-			return 0;
-
-		case K_XLATE:	/* switch to XLT ascii mode */
-			if (scp == cur_console && scp->status == KBD_RAW_MODE)
-				shfts = ctls = alts = agrs = metas = 0;
-			scp->status &= ~KBD_RAW_MODE;
-			return 0;
-		default:
-			return EINVAL;
-		}
-		/* NOT REACHED */
+	case K_XLATE:   	/* switch to XLT ascii mode */
+	    if (scp == cur_console && scp->status == KBD_RAW_MODE)
+		shfts = ctls = alts = agrs = metas = 0;
+	    scp->status &= ~KBD_RAW_MODE;
+	    return 0;
+	default:
+	    return EINVAL;
+	}
+	/* NOT REACHED */
 
-	case KDGKBMODE:		/* get keyboard mode */
-		*data = (scp->status & KBD_RAW_MODE) ? K_RAW : K_XLATE;
-		return 0;
+    case KDGKBMODE:     	/* get keyboard mode */
+	*data = (scp->status & KBD_RAW_MODE) ? K_RAW : K_XLATE;
+	return 0;
 
-	case KDMKTONE:		/* sound the bell */
-		if (*(int*)data) {
-			do_bell(scp, (*(int*)data)&0xffff,
-				(((*(int*)data)>>16)&0xffff)*hz/1000);
-		}
-		else
-			do_bell(scp, scp->bell_pitch, scp->bell_duration);
-		return 0;
+    case KDMKTONE:      	/* sound the bell */
+	if (*(int*)data)
+	    do_bell(scp, (*(int*)data)&0xffff,
+		    (((*(int*)data)>>16)&0xffff)*hz/1000);
+	else
+	    do_bell(scp, scp->bell_pitch, scp->bell_duration);
+	return 0;
 
-	case KIOCSOUND:		/* make tone (*data) hz */
-		if (scp == cur_console) {
-			if (*(int*)data) {
-			int pitch = TIMER_FREQ/(*(int*)data);
-				/* set command for counter 2, 2 byte write */
-				if (acquire_timer2(TIMER_16BIT|TIMER_SQWAVE)) {
-					return EBUSY;
-				}
-				/* set pitch */
-				outb(TIMER_CNTR2, pitch);
-				outb(TIMER_CNTR2, (pitch>>8));
-				/* enable counter 2 output to speaker */
-				outb(IO_PPI, inb(IO_PPI) | 3);
-			}
-			else {
-				/* disable counter 2 output to speaker */
-				outb(IO_PPI, inb(IO_PPI) & 0xFC);
-				release_timer2();
-			}
-		}
-		return 0;
+    case KIOCSOUND:     	/* make tone (*data) hz */
+	if (scp == cur_console) {
+	    if (*(int*)data) {
+		int pitch = TIMER_FREQ/(*(int*)data);
 
-	case KDGKBTYPE:		/* get keyboard type */
-		*data = 0;	/* type not known (yet) */
-		return 0;
+		/* set command for counter 2, 2 byte write */
+		if (acquire_timer2(TIMER_16BIT|TIMER_SQWAVE))
+		    return EBUSY;
 
-	case KDSETLED:		/* set keyboard LED status */
-		if (*data >= 0 && *data <= LED_MASK) {
-			scp->status &= ~LED_MASK;
-			scp->status |= *data;
-			if (scp == cur_console)
-				update_leds(scp->status);
-			return 0;
-		}
-		return EINVAL;
+		/* set pitch */
+		outb(TIMER_CNTR2, pitch);
+		outb(TIMER_CNTR2, (pitch>>8));
 
-	case KDGETLED:		/* get keyboard LED status */
-		*data = scp->status & LED_MASK;
-		return 0;
+		/* enable counter 2 output to speaker */
+		outb(IO_PPI, inb(IO_PPI) | 3);
+	    }
+	    else {
+		/* disable counter 2 output to speaker */
+		outb(IO_PPI, inb(IO_PPI) & 0xFC);
+		release_timer2();
+	    }
+	}
+	return 0;
 
-	case GETFKEY:		/* get functionkey string */
-		if (*(u_short*)data < n_fkey_tab) {
-			fkeyarg_t *ptr = (fkeyarg_t*)data;
-			bcopy(&fkey_tab[ptr->keynum].str,
-			      ptr->keydef,
-			      fkey_tab[ptr->keynum].len);
-			ptr->flen = fkey_tab[ptr->keynum].len;
-			return 0;
-		}
-		else
-			return EINVAL;
-
-	case SETFKEY:		/* set functionkey string */
-		if (*(u_short*)data < n_fkey_tab) {
-			fkeyarg_t *ptr = (fkeyarg_t*)data;
-			bcopy(ptr->keydef, 
-			      &fkey_tab[ptr->keynum].str, 
-			      min(ptr->flen, MAXFK));
-			fkey_tab[ptr->keynum].len = min(ptr->flen, MAXFK);
-			return 0;
-		}
-		else
-			return EINVAL;
+    case KDGKBTYPE:     	/* get keyboard type */
+	*data = 0;  		/* type not known (yet) */
+	return 0;
 
-	case GIO_SCRNMAP: 	/* get output translation table */
-		bcopy(&scr_map, data, sizeof(scr_map));
-		return 0;
+    case KDSETLED:      	/* set keyboard LED status */
+	if (*data >= 0 && *data <= LED_MASK) {
+	    scp->status &= ~LED_MASK;
+	    scp->status |= *data;
+	    if (scp == cur_console)
+		update_leds(scp->status);
+	    return 0;
+	}
+	return EINVAL;
 
-	case PIO_SCRNMAP:	/* set output translation table */
-		bcopy(data, &scr_map, sizeof(scr_map));
-		return 0;
+    case KDGETLED:      	/* get keyboard LED status */
+	*data = scp->status & LED_MASK;
+	return 0;
 
-	case GIO_KEYMAP: 	/* get keyboard translation table */
-		bcopy(&key_map, data, sizeof(key_map));
-		return 0;
+    case GETFKEY:       	/* get functionkey string */
+	if (*(u_short*)data < n_fkey_tab) {
+	    fkeyarg_t *ptr = (fkeyarg_t*)data;
+	    bcopy(&fkey_tab[ptr->keynum].str, ptr->keydef,
+		  fkey_tab[ptr->keynum].len);
+	    ptr->flen = fkey_tab[ptr->keynum].len;
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case PIO_KEYMAP:	/* set keyboard translation table */
-		bcopy(data, &key_map, sizeof(key_map));
-		return 0;
+    case SETFKEY:       	/* set functionkey string */
+	if (*(u_short*)data < n_fkey_tab) {
+	    fkeyarg_t *ptr = (fkeyarg_t*)data;
+	    bcopy(ptr->keydef, &fkey_tab[ptr->keynum].str, 
+		  min(ptr->flen, MAXFK));
+	    fkey_tab[ptr->keynum].len = min(ptr->flen, MAXFK);
+	    return 0;
+	}
+	else
+	    return EINVAL;
 
-	case PIO_FONT8x8:	/* set 8x8 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_8, 8*256);
-		fonts_loaded |= FONT_8;
-		copy_font(LOAD, FONT_8, font_8);
-		return 0;
+    case GIO_SCRNMAP:   	/* get output translation table */
+	bcopy(&scr_map, data, sizeof(scr_map));
+	return 0;
 
-	case GIO_FONT8x8:	/* get 8x8 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_8) {
-			bcopy(font_8, data, 8*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-
-	case PIO_FONT8x14:	/* set 8x14 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_14, 14*256);
-		fonts_loaded |= FONT_14;
-		copy_font(LOAD, FONT_14, font_14);
-		return 0;
+    case PIO_SCRNMAP:   	/* set output translation table */
+	bcopy(data, &scr_map, sizeof(scr_map));
+	return 0;
 
-	case GIO_FONT8x14:	/* get 8x14 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_14) {
-			bcopy(font_14, data, 14*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-
-	case PIO_FONT8x16:	/* set 8x16 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		bcopy(data, font_16, 16*256);
-		fonts_loaded |= FONT_16;
-		copy_font(LOAD, FONT_16, font_16);
-		return 0;
+    case GIO_KEYMAP:    	/* get keyboard translation table */
+	bcopy(&key_map, data, sizeof(key_map));
+	return 0;
 
-	case GIO_FONT8x16:	/* get 8x16 dot font */
-		if (!crtc_vga)
-			return ENXIO;
-		if (fonts_loaded & FONT_16) {
-			bcopy(font_16, data, 16*256);
-			return 0;
-		}
-		else
-			return ENXIO;
-	default:
-		break;
-	}	
-	
-	error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
-	if (error >= 0)
-		return(error);
-	error = ttioctl(tp, cmd, data, flag);
-	if (error >= 0)
-		return(error);
-	return(ENOTTY);
+    case PIO_KEYMAP:    	/* set keyboard translation table */
+	bcopy(data, &key_map, sizeof(key_map));
+	return 0;
+
+    case PIO_FONT8x8:   	/* set 8x8 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_8, 8*256);
+	fonts_loaded |= FONT_8;
+	copy_font(LOAD, FONT_8, font_8);
+	return 0;
+
+    case GIO_FONT8x8:   	/* get 8x8 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_8) {
+	    bcopy(font_8, data, 8*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+
+    case PIO_FONT8x14:  	/* set 8x14 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_14, 14*256);
+	fonts_loaded |= FONT_14;
+	copy_font(LOAD, FONT_14, font_14);
+	return 0;
+
+    case GIO_FONT8x14:  	/* get 8x14 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_14) {
+	    bcopy(font_14, data, 14*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+
+    case PIO_FONT8x16:  	/* set 8x16 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	bcopy(data, font_16, 16*256);
+	fonts_loaded |= FONT_16;
+	copy_font(LOAD, FONT_16, font_16);
+	return 0;
+
+    case GIO_FONT8x16:  	/* get 8x16 dot font */
+	if (!crtc_vga)
+	    return ENXIO;
+	if (fonts_loaded & FONT_16) {
+	    bcopy(font_16, data, 16*256);
+	    return 0;
+	}
+	else
+	    return ENXIO;
+    default:
+	break;
+    }   
+    
+    error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
+    if (error >= 0)
+	return(error);
+    error = ttioctl(tp, cmd, data, flag);
+    if (error >= 0)
+	return(error);
+    return(ENOTTY);
 }
 
 void 
 scxint(dev_t dev)
 {
-	struct tty *tp = get_tty_ptr(dev);
+    struct tty *tp = get_tty_ptr(dev);
 
-	if (!tp)
-		return;
-	tp->t_state &= ~TS_BUSY;
-	if (tp->t_line)
-		(*linesw[tp->t_line].l_start)(tp);
-	else
-		scstart(tp);
+    if (!tp)
+	return;
+    tp->t_state &= ~TS_BUSY;
+    if (tp->t_line)
+	(*linesw[tp->t_line].l_start)(tp);
+    else
+	scstart(tp);
 }
 
 void 
 scstart(struct tty *tp)
 {
-	struct clist *rbp;
-	int i, s, len;
-	u_char buf[PCBURST];
-	scr_stat *scp = get_scr_stat(tp->t_dev);
+    struct clist *rbp;
+    int i, s, len;
+    u_char buf[PCBURST];
+    scr_stat *scp = get_scr_stat(tp->t_dev);
 
-	if (scp->status & SLKED || blink_in_progress)
-		return;
+    if (scp->status & SLKED || blink_in_progress)
+	return;
+    s = spltty();
+    if (!(tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))) {
+	tp->t_state |= TS_BUSY;
+	splx(s);
+	rbp = &tp->t_outq;
+	while (rbp->c_cc) {
+	    len = q_to_b(rbp, buf, PCBURST);
+	    ansi_put(scp, buf, len);
+	}
+	scp->status |= UPDATE_SCREEN;
 	s = spltty();
-	if (!(tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))) {
-		tp->t_state |= TS_BUSY;
-		splx(s);
-		rbp = &tp->t_outq;
-		/* scp->status &= ~CURSOR_ENABLED; */
-		while (rbp->c_cc) {
-			len = q_to_b(rbp, buf, PCBURST);
-			ansi_put(scp, buf, len);
-		}
-		/* scp->status |= (CURSOR_ENABLED | UPDATE_SCREEN); */
-		scp->status |= UPDATE_SCREEN;
-		s = spltty();
-		tp->t_state &= ~TS_BUSY;
-		if (rbp->c_cc <= tp->t_lowat) {
-			if (tp->t_state & TS_ASLEEP) {
-				tp->t_state &= ~TS_ASLEEP;
-				wakeup((caddr_t)rbp);
-			}
-			selwakeup(&tp->t_wsel);
-		}
+	tp->t_state &= ~TS_BUSY;
+	if (rbp->c_cc <= tp->t_lowat) {
+	    if (tp->t_state & TS_ASLEEP) {
+		tp->t_state &= ~TS_ASLEEP;
+		wakeup((caddr_t)rbp);
+	    }
+	    selwakeup(&tp->t_wsel);
 	}
-	splx(s);
+    }
+    splx(s);
 }
 
+#if NAPM > 0 
+static int 
+scresume(void *dummy)
+{
+	shfts = 0;
+	ctls = 0;
+	alts = 0;
+	agrs = 0;
+	metas = 0;
+	return 0;
+}
+#endif
+
 void 
 pccnprobe(struct consdev *cp)
 {
-	int maj;
+    int maj;
 
-	/* locate the major number */
-	for (maj = 0; maj < nchrdev; maj++)
-		if ((void*)cdevsw[maj].d_open == (void*)scopen)
-			break;
+    /* locate the major number */
+    for (maj = 0; maj < nchrdev; maj++)
+	if ((void*)cdevsw[maj].d_open == (void*)scopen)
+	    break;
 
-	/* initialize required fields */
-	cp->cn_dev = makedev(maj, MAXCONS);
-	cp->cn_pri = CN_INTERNAL;
+    /* initialize required fields */
+    cp->cn_dev = makedev(maj, MAXCONS);
+    cp->cn_pri = CN_INTERNAL;
 }
 
 void 
 pccninit(struct consdev *cp)
 {
-	scinit();
+    scinit();
 }
 
 void 
 pccnputc(dev_t dev, char c)
 {
-	if (c == '\n')
-		scput('\r');
-	scput(c);
+    scr_stat *scp = console[0];
+    term_stat save = scp->term;
+
+    scp->term = kernel_console;
+    current_default = &kernel_default;
+    if (scp->scr_buf == Crtat)
+	draw_cursor(scp, FALSE);
+    if (c == '\n')
+	ansi_put(scp, "\r\n", 2);
+    else
+	ansi_put(scp, &c, 1);
+    scp->status |= UPDATE_SCREEN;
+    kernel_console = scp->term;
+    current_default = &user_default;
+    scp->term = save;
+    if (scp == cur_console /* && scrn_timer not running */) {
+	if (scp->scr_buf != Crtat) {
+	    bcopyw(scp->scr_buf, Crtat,
+		   (scp->xsize*scp->ysize)*sizeof(u_short));
+	    scp->status &= ~CURSOR_SHOWN;
+	}
+	draw_cursor(scp, TRUE);
+	scp->status &= ~UPDATE_SCREEN;
+    }
 }
 
 int 
 pccngetc(dev_t dev)
 {
-	int s = spltty();		/* block scintr while we poll */
-	int c = scgetc(0);
-	splx(s);
-	return(c);
+    int s = spltty();       /* block scintr while we poll */
+    int c = scgetc(0);
+    splx(s);
+    return(c);
 }
 
 int 
 pccncheckc(dev_t dev)
 {
-	return (scgetc(1) & 0xff);
-}
-
-static void 
-none_saver(int blank)
-{
-}
-
-static void 
-fade_saver(int blank)
-{
-	static int count = 0;
-	int i;
-
-	if (blank) {
-		scrn_blanked = 1;
-		if (count < 64) {
-			outb(PIXMASK, 0xFF);		/* no pixelmask */
-			outb(PALWADR, 0x00);
-			outb(PALDATA, 0);
-			outb(PALDATA, 0);
-			outb(PALDATA, 0);
-			for (i = 3; i < 768; i++) {
-				if (palette[i] - count > 15)
-					outb(PALDATA, palette[i]-count);
-				else
-					outb(PALDATA, 15);
-			}
-			inb(crtc_addr+6);		/* reset flip/flop */
-			outb(ATC, 0x20);		/* enable palette */
-			count++;
-		}
-	}
-	else {
-		load_palette();
-		count = scrn_blanked = 0;
-	}
-}
-
-static void 
-blank_saver(int blank)
-{
-	u_char val;
-	if (blank) {
-		scrn_blanked = 1;
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-	}
-	else {
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
-		scrn_blanked = 0;
-	}
-}
-
-static void 
-green_saver(int blank)
-{
-	u_char val;
-	if (blank) {
-		scrn_blanked = 1;
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
-		outb(crtc_addr + 1, val & ~0x80);
-	}
-	else {
-		outb(TSIDX, 0x01); val = inb(TSREG); 
-		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
-		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
-		outb(crtc_addr + 1, val | 0x80);
-		scrn_blanked = 0;
-	}
-}
-
-#define NUM_STARS	50
-
-/*
- * Alternate saver that got its inspiration from a well known utility
- * package for an inferior^H^H^H^H^H^Hfamous OS.
- */
-static void 
-star_saver(int blank)
-{
-	scr_stat	*scp = cur_console;
-	int		cell, i;
-	char 		pattern[] = {"...........++++***   "};
-	char		colors[] = {FG_DARKGREY, FG_LIGHTGREY, 
-				    FG_WHITE, FG_LIGHTCYAN};
-	static u_short 	stars[NUM_STARS][2];
- 
-	if (blank) {
-		if (!scrn_blanked) {
-			scrn_blanked = 1;
-			fillw((FG_LIGHTGREY|BG_BLACK)<<8|scr_map[0x20], Crtat, 
-			      scp->xsize * scp->ysize);
-			set_border(0);
-			for(i=0; i<NUM_STARS; i++) {
-				stars[i][0] = 
-					random() % (scp->xsize*scp->ysize);
-				stars[i][1] = 0;
-			}
-		}
-		cell = random() % NUM_STARS;
-		*((u_short*)(Crtat + stars[cell][0])) = 
-			scr_map[pattern[stars[cell][1]]] | 
-				colors[random()%sizeof(colors)] << 8;
-		if ((stars[cell][1]+=(random()%4)) >= sizeof(pattern)-1) {
-			stars[cell][0] = random() % (scp->xsize*scp->ysize);
-			stars[cell][1] = 0;
-		}
-	}
-	else {
-		if (scrn_blanked) {
-			set_border(scp->border);
-			scrn_blanked = 0;
-		}
-	}
-}
-
-static void 
-snake_saver(int blank)
-{
-	const char	saves[] = {"FreeBSD-2.0"};
-	static u_char	*savs[sizeof(saves)-1];
-	static int	dirx, diry;
-	int		f;
-	scr_stat	*scp = cur_console;
-
-	if (blank) {
-		if (!scrn_blanked) {
-			fillw((FG_LIGHTGREY|BG_BLACK)<<8 | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-			set_border(0);
-			dirx = (scp->xpos ? 1 : -1);
-			diry = (scp->ypos ?
-				scp->xsize : -scp->xsize);
-			for (f=0; f< sizeof(saves)-1; f++)
-				savs[f] = (u_char *)Crtat + 2 *
-					  (scp->xpos+scp->ypos*scp->xsize);
-			*(savs[0]) = scr_map[*saves];
-			f = scp->ysize * scp->xsize + 5;
-			outb(crtc_addr, 14);
-			outb(crtc_addr+1, f >> 8);
-			outb(crtc_addr, 15);
-			outb(crtc_addr+1, f & 0xff);
-			scrn_blanked = 1;
-		}
-		if (scrn_blanked++ < 4) 
-			return;
-		scrn_blanked = 1;
-		*(savs[sizeof(saves)-2]) = scr_map[0x20];
-		for (f=sizeof(saves)-2; f > 0; f--)
-			savs[f] = savs[f-1];
-		f = (savs[0] - (u_char *)Crtat) / 2;
-		if ((f % scp->xsize) == 0 ||
-		    (f % scp->xsize) == scp->xsize - 1 ||
-		    (random() % 50) == 0)
-			dirx = -dirx;
-		if ((f / scp->xsize) == 0 ||
-		    (f / scp->xsize) == scp->ysize - 1 ||
-		    (random() % 20) == 0)
-			diry = -diry;
-		savs[0] += 2*dirx + 2*diry;
-		for (f=sizeof(saves)-2; f>=0; f--)
-			*(savs[f]) = scr_map[saves[f]];
-	}
-	else {
-		if (scrn_blanked) {
-			set_border(scp->border);
-			scrn_blanked = 0;
-		}
-	}
+    return (scgetc(1) & 0xff);
 }
 
 static void 
@@ -1569,14 +1183,14 @@ scrn_timer()
 	timeout((timeout_func_t)scrn_timer, 0, hz/10);
 	return;
     }
-	
+    
     if (!scrn_blanked) {
 	/* update entire screen image */
 	if (scp->status & UPDATE_SCREEN) {
 	    bcopyw(scp->scr_buf, Crtat, scp->xsize*scp->ysize*sizeof(u_short));
 	    scp->status &= ~CURSOR_SHOWN;
 	}
-	/* update "pseudo" mouse */
+	/* update "pseudo" mouse arrow */
 	if ((scp->status & MOUSE_ENABLED) && 
 	    ((scp->status & UPDATE_MOUSE) || (scp->status & UPDATE_SCREEN)))
 	    draw_mouse_image(scp);
@@ -1590,909 +1204,880 @@ scrn_timer()
 	scp->status &= ~UPDATE_SCREEN;
     }
     if (scrn_blank_time && (time.tv_sec>scrn_time_stamp+scrn_blank_time))
-	SCRN_SAVER(TRUE);
+	(*current_saver)(TRUE);
     timeout((timeout_func_t)scrn_timer, 0, hz/25);
 }
-	
+
 static void 
 clear_screen(scr_stat *scp)
 {
-	move_crsr(scp, 0, 0);
-	fillw(scp->term.cur_attr | scr_map[0x20], scp->scr_buf,
-	       scp->xsize * scp->ysize);
+    move_crsr(scp, 0, 0);
+    fillw(scp->term.cur_attr | scr_map[0x20], scp->scr_buf,
+	  scp->xsize * scp->ysize);
 }
 
 static int 
 switch_scr(scr_stat *scp, u_int next_scr)
 {
-	if (switch_in_progress && (cur_console->proc != pfind(cur_console->pid)))
-		switch_in_progress = FALSE;
-
-	if (next_scr >= MAXCONS || switch_in_progress
-	    || (cur_console->smode.mode == VT_AUTO && cur_console->status & UNKNOWN_MODE)) {
-		do_bell(scp, BELL_PITCH, BELL_DURATION);
-		return EINVAL;
-	}
+    if (switch_in_progress && (cur_console->proc != pfind(cur_console->pid)))
+	switch_in_progress = FALSE;
+
+    if (next_scr >= MAXCONS || switch_in_progress || 
+	(cur_console->smode.mode == VT_AUTO 
+	 && cur_console->status & UNKNOWN_MODE)) {
+	do_bell(scp, BELL_PITCH, BELL_DURATION);
+	return EINVAL;
+    }
 
-	/* is the wanted virtual console open ? */
-	if (next_scr) {
-		struct tty *tp = VIRTUAL_TTY(next_scr);
-		if (!(tp->t_state & TS_ISOPEN)) {
-			do_bell(scp, BELL_PITCH, BELL_DURATION);
-			return EINVAL;
-		}
-	}
-	/* delay switch if actively updating screen */
-	if (write_in_progress || blink_in_progress) {
-		delayed_next_scr = next_scr+1;
-		return 0;
-	}
-	switch_in_progress = TRUE;
-	old_scp = cur_console;
-	new_scp = console[next_scr];
-	wakeup((caddr_t)&new_scp->smode);
-	if (new_scp == old_scp) {
-		switch_in_progress = FALSE;
-		delayed_next_scr = FALSE;
-		return 0;
-	}
-	
-	/* has controlling process died? */
-	if (old_scp->proc && (old_scp->proc != pfind(old_scp->pid)))
-		old_scp->smode.mode = VT_AUTO;
-	if (new_scp->proc && (new_scp->proc != pfind(new_scp->pid)))
-		new_scp->smode.mode = VT_AUTO;
-
-	/* check the modes and switch approbiatly */
-	if (old_scp->smode.mode == VT_PROCESS) {
-		old_scp->status |= SWITCH_WAIT_REL;
-		psignal(old_scp->proc, old_scp->smode.relsig);
-	}
-	else {
-		exchange_scr();
-		if (new_scp->smode.mode == VT_PROCESS) {
-			new_scp->status |= SWITCH_WAIT_ACQ;
-			psignal(new_scp->proc, new_scp->smode.acqsig);
-		}
-		else
-			switch_in_progress = FALSE;
+    /* is the wanted virtual console open ? */
+    if (next_scr) {
+	struct tty *tp = VIRTUAL_TTY(next_scr);
+	if (!(tp->t_state & TS_ISOPEN)) {
+	    do_bell(scp, BELL_PITCH, BELL_DURATION);
+	    return EINVAL;
 	}
+    }
+    /* delay switch if actively updating screen */
+    if (write_in_progress || blink_in_progress) {
+	delayed_next_scr = next_scr+1;
+	return 0;
+    }
+    switch_in_progress = TRUE;
+    old_scp = cur_console;
+    new_scp = console[next_scr];
+    wakeup((caddr_t)&new_scp->smode);
+    if (new_scp == old_scp) {
+	switch_in_progress = FALSE;
+	delayed_next_scr = FALSE;
 	return 0;
+    }
+    
+    /* has controlling process died? */
+    if (old_scp->proc && (old_scp->proc != pfind(old_scp->pid)))
+	old_scp->smode.mode = VT_AUTO;
+    if (new_scp->proc && (new_scp->proc != pfind(new_scp->pid)))
+	new_scp->smode.mode = VT_AUTO;
+
+    /* check the modes and switch approbiatly */
+    if (old_scp->smode.mode == VT_PROCESS) {
+	old_scp->status |= SWITCH_WAIT_REL;
+	psignal(old_scp->proc, old_scp->smode.relsig);
+    }
+    else {
+	exchange_scr();
+	if (new_scp->smode.mode == VT_PROCESS) {
+	    new_scp->status |= SWITCH_WAIT_ACQ;
+	    psignal(new_scp->proc, new_scp->smode.acqsig);
+	}
+	else
+	    switch_in_progress = FALSE;
+    }
+    return 0;
 }
 
 static void 
 exchange_scr(void) 
 {
-	move_crsr(old_scp, old_scp->xpos, old_scp->ypos);
-	cur_console = new_scp;
-	if (old_scp->mode != new_scp->mode || (old_scp->status & UNKNOWN_MODE)){
-		if (crtc_vga && video_mode_ptr)
-			set_mode(new_scp);
-	}
-	move_crsr(new_scp, new_scp->xpos, new_scp->ypos);
-	if ((old_scp->status & UNKNOWN_MODE) && crtc_vga) {
-		if (fonts_loaded & FONT_8)
-			copy_font(LOAD, FONT_8, font_8);
-		if (fonts_loaded & FONT_14)
-			copy_font(LOAD, FONT_14, font_14);
-		if (fonts_loaded & FONT_16)
-			copy_font(LOAD, FONT_16, font_16);
-		load_palette();
-	}
-	if (old_scp->status & KBD_RAW_MODE || new_scp->status & KBD_RAW_MODE)
-		shfts = ctls = alts = agrs = metas = 0;
-	update_leds(new_scp->status);
-	delayed_next_scr = FALSE;
-	new_scp->status |= UPDATE_SCREEN;
+    move_crsr(old_scp, old_scp->xpos, old_scp->ypos);
+    cur_console = new_scp;
+    if (old_scp->mode != new_scp->mode || (old_scp->status & UNKNOWN_MODE)){
+	if (crtc_vga && video_mode_ptr)
+	    set_mode(new_scp);
+    }
+    move_crsr(new_scp, new_scp->xpos, new_scp->ypos);
+    if ((old_scp->status & UNKNOWN_MODE) && crtc_vga) {
+	if (fonts_loaded & FONT_8)
+	    copy_font(LOAD, FONT_8, font_8);
+	if (fonts_loaded & FONT_14)
+	    copy_font(LOAD, FONT_14, font_14);
+	if (fonts_loaded & FONT_16)
+	    copy_font(LOAD, FONT_16, font_16);
+	load_palette();
+    }
+    if (old_scp->status & KBD_RAW_MODE || new_scp->status & KBD_RAW_MODE)
+	shfts = ctls = alts = agrs = metas = 0;
+    update_leds(new_scp->status);
+    delayed_next_scr = FALSE;
+    bcopyw(new_scp->scr_buf, Crtat,
+	   (new_scp->xsize*new_scp->ysize)*sizeof(u_short));
+    new_scp->status &= ~CURSOR_SHOWN;
 }
 
 static inline void 
 move_crsr(scr_stat *scp, int x, int y)
 {
-	if (x < 0 || y < 0 || x >= scp->xsize || y >= scp->ysize)
-		return;
-	scp->xpos = x;
-	scp->ypos = y;
-	scp->cursor_pos = scp->scr_buf + scp->ypos * scp->xsize + scp->xpos;
+    if (x < 0 || y < 0 || x >= scp->xsize || y >= scp->ysize)
+	return;
+    scp->xpos = x;
+    scp->ypos = y;
+    scp->cursor_pos = scp->scr_buf + scp->ypos * scp->xsize + scp->xpos;
 }
 
 static void 
 scan_esc(scr_stat *scp, u_char c)
 {
-	static u_char ansi_col[16] = 
-		{0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15};
-	int i, n;
-	u_short *src, *dst, count;
-
-	if (scp->term.esc == 1) {
-		switch (c) {
-
-		case '[': 	/* Start ESC [ sequence */
-			scp->term.esc = 2;
-			scp->term.last_param = -1;
-			for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
-				scp->term.param[i] = 1;
-			scp->term.num_param = 0;
-			return;
-
-		case 'M':	/* Move cursor up 1 line, scroll if at top */
-			if (scp->ypos > 0)
-				move_crsr(scp, scp->xpos, scp->ypos - 1);
-			else {
-				bcopyw(scp->scr_buf, 
-					scp->scr_buf + scp->xsize,
-					(scp->ysize - 1) * scp->xsize *
-					sizeof(u_short));
-				fillw(scp->term.cur_attr | scr_map[0x20], 
-				      scp->scr_buf, scp->xsize);
-			}
-			break;
+    static u_char ansi_col[16] = 
+	{0, 4, 2, 6, 1, 5, 3, 7, 8, 12, 10, 14, 9, 13, 11, 15};
+    int i, n;
+    u_short *src, *dst, count;
+
+    if (scp->term.esc == 1) {
+	switch (c) {
+
+	case '[':   /* Start ESC [ sequence */
+	    scp->term.esc = 2;
+	    scp->term.last_param = -1;
+	    for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
+		scp->term.param[i] = 1;
+	    scp->term.num_param = 0;
+	    return;
+
+	case 'M':   /* Move cursor up 1 line, scroll if at top */
+	    if (scp->ypos > 0)
+		move_crsr(scp, scp->xpos, scp->ypos - 1);
+	    else {
+		bcopyw(scp->scr_buf, scp->scr_buf + scp->xsize,
+		       (scp->ysize - 1) * scp->xsize * sizeof(u_short));
+		fillw(scp->term.cur_attr | scr_map[0x20], 
+		      scp->scr_buf, scp->xsize);
+	    }
+	    break;
 #if notyet
-		case 'Q':
-			scp->term.esc = 4;
-			break;
+	case 'Q':
+	    scp->term.esc = 4;
+	    break;
 #endif
-		case 'c':	/* Clear screen & home */
-			clear_screen(scp);
-			break;
-		}
+	case 'c':   /* Clear screen & home */
+	    clear_screen(scp);
+	    break;
 	}
-	else if (scp->term.esc == 2) {
-		if (c >= '0' && c <= '9') {
-		    if (scp->term.num_param < MAX_ESC_PAR) {
-			if (scp->term.last_param != scp->term.num_param) {
-			    scp->term.last_param = scp->term.num_param;
-			    scp->term.param[scp->term.num_param] = 0;
-			}
-			else
-			    scp->term.param[scp->term.num_param] *= 10;
-			scp->term.param[scp->term.num_param] += c - '0';
-			return;
-		    }
-		}
-		scp->term.num_param = scp->term.last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (scp->term.num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case '=':
-			scp->term.esc = 3;
-			scp->term.last_param = -1;
-			for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
-				scp->term.param[i] = 1;
-			scp->term.num_param = 0;
-			return;
-
-		case 'A': /* up n rows */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos - n);
-			break;
-
-		case 'B': /* down n rows */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos + n);
-			break;
-
-		case 'C': /* right n columns */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos + n, scp->ypos);
-			break;
-
-		case 'D': /* left n columns */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, scp->xpos - n, scp->ypos);
-			break;
-
-		case 'E': /* cursor to start of line n lines down */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, 0, scp->ypos + n);
-			break;
-
-		case 'F': /* cursor to start of line n lines up */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			move_crsr(scp, 0, scp->ypos - n);
-			break;
-
-		case 'f': /* System V consoles .. */
-		case 'H': /* Cursor move */
-			if (scp->term.num_param == 0) 
-				move_crsr(scp, 0, 0);
-			else if (scp->term.num_param == 2)
-				move_crsr(scp, scp->term.param[1] - 1, 
-					  scp->term.param[0] - 1);
-			break;
-
-		case 'J': /* Clear all or part of display */
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: /* clear form cursor to end of display */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->cursor_pos, scp->scr_buf + 
-				      scp->xsize * scp->ysize - 
-				      scp->cursor_pos);
-				break;
-			case 1: /* clear from beginning of display to cursor */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->scr_buf, 
-				      scp->cursor_pos - scp->scr_buf);
-				break;
-			case 2: /* clear entire display */
-				clear_screen(scp);
-				break;
-			}
-			break;
-
-		case 'K': /* Clear all or part of line */
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: /* clear form cursor to end of line */
-				fillw(scp->term.cur_attr | scr_map[0x20],
-				      scp->cursor_pos, scp->xsize - scp->xpos);
-				break;
-			case 1: /* clear from beginning of line to cursor */
-				fillw(scp->term.cur_attr|scr_map[0x20], 
-				      scp->cursor_pos - (scp->xsize - scp->xpos),
-				      (scp->xsize - scp->xpos) + 1);
-				break;
-			case 2: /* clear entire line */
-				fillw(scp->term.cur_attr|scr_map[0x20], 
-				      scp->cursor_pos - (scp->xsize - scp->xpos),
-				      scp->xsize);
-				break;
-			}
-			break;
-
-		case 'L':	/* Insert n lines */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->ysize - scp->ypos)
-				n = scp->ysize - scp->ypos;
-			src = scp->scr_buf + scp->ypos * scp->xsize;
-			dst = src + n * scp->xsize;
-			count = scp->ysize - (scp->ypos + n);
-			bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], src,
-			      n * scp->xsize);
-			break;
-
-		case 'M':	/* Delete n lines */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->ysize - scp->ypos)
-				n = scp->ysize - scp->ypos;
-			dst = scp->scr_buf + scp->ypos * scp->xsize;
-			src = dst + n * scp->xsize;
-			count = scp->ysize - (scp->ypos + n);
-			bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
-			src = dst + count * scp->xsize;
-			fillw(scp->term.cur_attr | scr_map[0x20], src,
-			      n * scp->xsize);
-			break;
-
-		case 'P':	/* Delete n chars */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			dst = scp->cursor_pos;
-			src = dst + n;
-			count = scp->xsize - (scp->xpos + n);
-			bcopyw(src, dst, count * sizeof(u_short));
-			src = dst + count;
-			fillw(scp->term.cur_attr | scr_map[0x20], src, n);
-			break;
-
-		case '@':	/* Insert n chars */
-			n = scp->term.param[0]; if (n < 1) n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			src = scp->cursor_pos;
-			dst = src + n;
-			count = scp->xsize - (scp->xpos + n);
-			bcopyw(src, dst, count * sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], src, n);
-			break;
-
-		case 'S':	/* scroll up n lines */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->ysize)
-				n = scp->ysize;
-			bcopyw(scp->scr_buf + (scp->xsize * n),
-			      scp->scr_buf, 
-			      scp->xsize * (scp->ysize - n) * 
-			      sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20],
-			      scp->scr_buf + scp->xsize * 
-			      (scp->ysize - n),
-			      scp->xsize * n);
-			break;
-
-		case 'T':	/* scroll down n lines */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->ysize)
-				n = scp->ysize;
-			bcopyw(scp->scr_buf, 
-			      scp->scr_buf + (scp->xsize * n),
-			      scp->xsize * (scp->ysize - n) * 
-			      sizeof(u_short));
-			fillw(scp->term.cur_attr | scr_map[0x20], 
-			      scp->scr_buf, scp->xsize * n);
-			break;
-
-		case 'X':	/* delete n characters in line */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if (n > scp->xsize - scp->xpos)
-				n = scp->xsize - scp->xpos;
-			fillw(scp->term.cur_attr | scr_map[0x20], 
-			      scp->scr_buf + scp->xpos + 
-			      ((scp->xsize*scp->ypos) * sizeof(u_short)), n);
-			break;
-
-		case 'Z':	/* move n tabs backwards */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			if ((i = scp->xpos & 0xf8) == scp->xpos)
-				i -= 8*n;
-			else 
-				i -= 8*(n-1); 
-			if (i < 0) 
-				i = 0;
-			move_crsr(scp, i, scp->ypos);
-			break;
-
-		case '`': 	/* move cursor to column n */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, n - 1, scp->ypos);
-			break;
-
-		case 'a': 	/* move cursor n columns to the right */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos + n, scp->ypos);
-			break;
-
-		case 'd': 	/* move cursor to row n */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos, n - 1);
-			break;
-
-		case 'e': 	/* move cursor n rows down */
-			n = scp->term.param[0]; if (n < 1)  n = 1;
-			move_crsr(scp, scp->xpos, scp->ypos + n);
-			break;
-
-		case 'm': 	/* change attribute */
-			if (scp->term.num_param == 0) {
-				scp->term.cur_attr = scp->term.std_attr;
-				break;
-			}
-			for (i = 0; i < scp->term.num_param; i++) {
-				switch (n = scp->term.param[i]) {
-				case 0:	/* back to normal */
-					scp->term.cur_attr = scp->term.std_attr;
-					break;
-				case 1:	/* highlight (bold) */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x0800;
-					break;
-				case 4: /* highlight (underline) */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x0800;
-					break;
-				case 5: /* blink */
-					scp->term.cur_attr &= 0xFF00;
-					scp->term.cur_attr |= 0x8000;
-					break;
-				case 7: /* reverse video */
-					scp->term.cur_attr = scp->term.rev_attr;
-					break;
-				case 30: case 31: /* set fg color */
-				case 32: case 33: case 34: 
-				case 35: case 36: case 37:
-					scp->term.cur_attr = 
-						(scp->term.cur_attr & 0xF8FF)
-						| (ansi_col[(n-30) & 7] << 8);
-					break;
-				case 40: case 41: /* set bg color */
-				case 42: case 43: case 44: 
-				case 45: case 46: case 47:
-					scp->term.cur_attr = 
-						(scp->term.cur_attr & 0x8FFF)
-						| (ansi_col[(n-40) & 7] << 12);
-					break;
-				}
-			}
-			break;
-
-		case 'x':
-			if (scp->term.num_param == 0)
-				n = 0;
-			else
-				n = scp->term.param[0];
-			switch (n) {
-			case 0: 	/* reset attributes */
-				scp->term.cur_attr = scp->term.std_attr =
-				    current_default->std_attr;
-				scp->term.rev_attr = current_default->rev_attr;
-				break;
-			case 1: 	/* set ansi background */
-				scp->term.cur_attr = scp->term.std_attr =  
-				    (scp->term.std_attr & 0x0F00) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<12);
-				break;
-			case 2: 	/* set ansi foreground */
-				scp->term.cur_attr = scp->term.std_attr =  
-				    (scp->term.std_attr & 0xF000) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<8);
-				break;
-			case 3: 	/* set ansi attribute directly */
-				scp->term.cur_attr = scp->term.std_attr =
-				    (scp->term.param[1]&0xFF)<<8;
-				break;
-			case 5: 	/* set ansi reverse video background */
-				scp->term.rev_attr = 
-				    (scp->term.rev_attr & 0x0F00) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<12);
-				break;
-			case 6: 	/* set ansi reverse video foreground */
-				scp->term.rev_attr = 
-				    (scp->term.rev_attr & 0xF000) |
-				    (ansi_col[(scp->term.param[1])&0x0F]<<8);
-				break;
-			case 7: 	/* set ansi reverse video directly */
-				scp->term.rev_attr =
-				    (scp->term.param[1]&0xFF)<<8;
-				break;
-			}
-			break;
+    }
+    else if (scp->term.esc == 2) {
+	if (c >= '0' && c <= '9') {
+	    if (scp->term.num_param < MAX_ESC_PAR) {
+	    if (scp->term.last_param != scp->term.num_param) {
+		scp->term.last_param = scp->term.num_param;
+		scp->term.param[scp->term.num_param] = 0;
+	    }
+	    else
+		scp->term.param[scp->term.num_param] *= 10;
+	    scp->term.param[scp->term.num_param] += c - '0';
+	    return;
+	    }
+	}
+	scp->term.num_param = scp->term.last_param + 1;
+	switch (c) {
 
-		case 'z':	/* switch to (virtual) console n */
-			if (scp->term.num_param == 1)
-				switch_scr(scp, scp->term.param[0]);
-			break;
+	case ';':
+	    if (scp->term.num_param < MAX_ESC_PAR)
+		return;
+	    break;
+
+	case '=':
+	    scp->term.esc = 3;
+	    scp->term.last_param = -1;
+	    for (i = scp->term.num_param; i < MAX_ESC_PAR; i++)
+		scp->term.param[i] = 1;
+	    scp->term.num_param = 0;
+	    return;
+
+	case 'A':   /* up n rows */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos - n);
+	    break;
+
+	case 'B':   /* down n rows */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos + n);
+	    break;
+
+	case 'C':   /* right n columns */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos + n, scp->ypos);
+	    break;
+
+	case 'D':   /* left n columns */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, scp->xpos - n, scp->ypos);
+	    break;
+
+	case 'E':   /* cursor to start of line n lines down */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, 0, scp->ypos + n);
+	    break;
+
+	case 'F':   /* cursor to start of line n lines up */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    move_crsr(scp, 0, scp->ypos - n);
+	    break;
+
+	case 'f':   /* Cursor move */
+	case 'H':
+	    if (scp->term.num_param == 0) 
+		move_crsr(scp, 0, 0);
+	    else if (scp->term.num_param == 2)
+		move_crsr(scp, scp->term.param[1] - 1, scp->term.param[0] - 1);
+	    break;
+
+	case 'J':   /* Clear all or part of display */
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0: /* clear form cursor to end of display */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->cursor_pos, 
+		      scp->scr_buf + scp->xsize * scp->ysize - scp->cursor_pos);
+		break;
+	    case 1: /* clear from beginning of display to cursor */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->scr_buf, 
+		      scp->cursor_pos - scp->scr_buf);
+		break;
+	    case 2: /* clear entire display */
+		clear_screen(scp);
+		break;
+	    }
+	    break;
+
+	case 'K':   /* Clear all or part of line */
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0: /* clear form cursor to end of line */
+		fillw(scp->term.cur_attr | scr_map[0x20],
+		      scp->cursor_pos, 
+		      scp->xsize - scp->xpos);
+		break;
+	    case 1: /* clear from beginning of line to cursor */
+		fillw(scp->term.cur_attr|scr_map[0x20], 
+		      scp->cursor_pos - (scp->xsize - scp->xpos),
+		      (scp->xsize - scp->xpos) + 1);
+		break;
+	    case 2: /* clear entire line */
+		fillw(scp->term.cur_attr|scr_map[0x20], 
+		      scp->cursor_pos - (scp->xsize - scp->xpos),
+		      scp->xsize);
+		break;
+	    }
+	    break;
+
+	case 'L':   /* Insert n lines */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->ysize - scp->ypos)
+		n = scp->ysize - scp->ypos;
+	    src = scp->scr_buf + scp->ypos * scp->xsize;
+	    dst = src + n * scp->xsize;
+	    count = scp->ysize - (scp->ypos + n);
+	    bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], src,
+		  n * scp->xsize);
+	    break;
+
+	case 'M':   /* Delete n lines */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->ysize - scp->ypos)
+		n = scp->ysize - scp->ypos;
+	    dst = scp->scr_buf + scp->ypos * scp->xsize;
+	    src = dst + n * scp->xsize;
+	    count = scp->ysize - (scp->ypos + n);
+	    bcopyw(src, dst, count * scp->xsize * sizeof(u_short));
+	    src = dst + count * scp->xsize;
+	    fillw(scp->term.cur_attr | scr_map[0x20], src,
+		  n * scp->xsize);
+	    break;
+
+	case 'P':   /* Delete n chars */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    dst = scp->cursor_pos;
+	    src = dst + n;
+	    count = scp->xsize - (scp->xpos + n);
+	    bcopyw(src, dst, count * sizeof(u_short));
+	    src = dst + count;
+	    fillw(scp->term.cur_attr | scr_map[0x20], src, n);
+	    break;
+
+	case '@':   /* Insert n chars */
+	    n = scp->term.param[0]; if (n < 1) n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    src = scp->cursor_pos;
+	    dst = src + n;
+	    count = scp->xsize - (scp->xpos + n);
+	    bcopyw(src, dst, count * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], src, n);
+	    break;
+
+	case 'S':   /* scroll up n lines */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->ysize)
+		n = scp->ysize;
+	    bcopyw(scp->scr_buf + (scp->xsize * n), 
+		   scp->scr_buf, 
+		   scp->xsize * (scp->ysize - n) * sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20],
+		  scp->scr_buf + scp->xsize * (scp->ysize - n), 
+		  scp->xsize * n);
+	    break;
+
+	case 'T':   /* scroll down n lines */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->ysize)
+		n = scp->ysize;
+	    bcopyw(scp->scr_buf, 
+		  scp->scr_buf + (scp->xsize * n),
+		  scp->xsize * (scp->ysize - n) * 
+		  sizeof(u_short));
+	    fillw(scp->term.cur_attr | scr_map[0x20], 
+		  scp->scr_buf, scp->xsize * n);
+	    break;
+
+	case 'X':   /* delete n characters in line */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if (n > scp->xsize - scp->xpos)
+		n = scp->xsize - scp->xpos;
+	    fillw(scp->term.cur_attr | scr_map[0x20], 
+		  scp->scr_buf + scp->xpos + 
+		  ((scp->xsize*scp->ypos) * sizeof(u_short)), n);
+	    break;
+
+	case 'Z':   /* move n tabs backwards */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    if ((i = scp->xpos & 0xf8) == scp->xpos)
+		i -= 8*n;
+	    else 
+		i -= 8*(n-1); 
+	    if (i < 0) 
+		i = 0;
+	    move_crsr(scp, i, scp->ypos);
+	    break;
+
+	case '`':   /* move cursor to column n */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, n - 1, scp->ypos);
+	    break;
+
+	case 'a':   /* move cursor n columns to the right */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos + n, scp->ypos);
+	    break;
+
+	case 'd':   /* move cursor to row n */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos, n - 1);
+	    break;
+
+	case 'e':   /* move cursor n rows down */
+	    n = scp->term.param[0]; if (n < 1)  n = 1;
+	    move_crsr(scp, scp->xpos, scp->ypos + n);
+	    break;
+
+	case 'm':   /* change attribute */
+	    if (scp->term.num_param == 0) {
+		scp->term.cur_attr = scp->term.std_attr;
+		break;
+	    }
+	    for (i = 0; i < scp->term.num_param; i++) {
+		switch (n = scp->term.param[i]) {
+		case 0: /* back to normal */
+		    scp->term.cur_attr = scp->term.std_attr;
+		    break;
+		case 1: /* highlight (bold) */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x0800;
+		    break;
+		case 4: /* highlight (underline) */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x0800;
+		    break;
+		case 5: /* blink */
+		    scp->term.cur_attr &= 0xFF00;
+		    scp->term.cur_attr |= 0x8000;
+		    break;
+		case 7: /* reverse video */
+		    scp->term.cur_attr = scp->term.rev_attr;
+		    break;
+		case 30: case 31: /* set fg color */
+		case 32: case 33: case 34: 
+		case 35: case 36: case 37:
+		    scp->term.cur_attr = 
+			(scp->term.cur_attr&0xF8FF) | (ansi_col[(n-30)&7]<<8);
+		    break;
+		case 40: case 41: /* set bg color */
+		case 42: case 43: case 44: 
+		case 45: case 46: case 47:
+		    scp->term.cur_attr = 
+			(scp->term.cur_attr&0x8FFF) | (ansi_col[(n-40)&7]<<12);
+		    break;
 		}
+	    }
+	    break;
+
+	case 'x':
+	    if (scp->term.num_param == 0)
+		n = 0;
+	    else
+		n = scp->term.param[0];
+	    switch (n) {
+	    case 0:     /* reset attributes */
+		scp->term.cur_attr = scp->term.std_attr =
+		    current_default->std_attr;
+		scp->term.rev_attr = current_default->rev_attr;
+		break;
+	    case 1:     /* set ansi background */
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0x0F00) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<12);
+		break;
+	    case 2:     /* set ansi foreground */
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0xF000) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<8);
+		break;
+	    case 3:     /* set ansi attribute directly */
+		scp->term.cur_attr = scp->term.std_attr =
+		    (scp->term.param[1]&0xFF)<<8;
+		break;
+	    case 5:     /* set ansi reverse video background */
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0x0F00) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<12);
+		break;
+	    case 6:     /* set ansi reverse video foreground */
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0xF000) |
+		    (ansi_col[(scp->term.param[1])&0x0F]<<8);
+		break;
+	    case 7:     /* set ansi reverse video directly */
+		scp->term.rev_attr =
+		    (scp->term.param[1]&0xFF)<<8;
+		break;
+	    }
+	    break;
+
+	case 'z':   /* switch to (virtual) console n */
+	    if (scp->term.num_param == 1)
+		switch_scr(scp, scp->term.param[0]);
+	    break;
 	}
-	else if (scp->term.esc == 3) {
-		if (c >= '0' && c <= '9') {
-		    if (scp->term.num_param < MAX_ESC_PAR) {
-			if (scp->term.last_param != scp->term.num_param) {
-			    scp->term.last_param = scp->term.num_param;
-			    scp->term.param[scp->term.num_param] = 0;
-			}
-			else
-			    scp->term.param[scp->term.num_param] *= 10;
-			scp->term.param[scp->term.num_param] += c - '0';
-			return;
-		    }
-		}
-		scp->term.num_param = scp->term.last_param + 1;
-		switch (c) {
-
-		case ';':
-			if (scp->term.num_param < MAX_ESC_PAR)
-				return;
-			break;
-
-		case 'A':	/* set display border color */
-			if (scp->term.num_param == 1)
-				scp->border=scp->term.param[0] & 0xff;
-				if (scp == cur_console)
-					set_border(scp->border);
-			break;
-
-		case 'B':	/* set bell pitch and duration */
-			if (scp->term.num_param == 2) {
-				scp->bell_pitch = scp->term.param[0];
-				scp->bell_duration = scp->term.param[1]*10;
-			}
-			break;
-
-		case 'C': 	/* set cursor type & shape */
-			if (scp->term.num_param == 1) {
-				if (scp->term.param[0] & 0x01)
-					configuration |= BLINK_CURSOR;
-				else
-					configuration &= ~BLINK_CURSOR;
-				if (scp->term.param[0] & 0x02)
-					configuration |= CHAR_CURSOR;
-				else
-					configuration &= ~CHAR_CURSOR;
-			}
-			else if (scp->term.num_param == 2) {
-				scp->cursor_start = scp->term.param[0] & 0x1F; 
-				scp->cursor_end = scp->term.param[1] & 0x1F; 
-			}
-			break;
-
-		case 'F':	/* set ansi foreground */
-			if (scp->term.num_param == 1) 
-				scp->term.cur_attr = scp->term.std_attr =  
-					(scp->term.std_attr & 0xF000) 
-					| ((scp->term.param[0] & 0x0F) << 8);
-			break;
-
-		case 'G': 	/* set ansi background */
-			if (scp->term.num_param == 1) 
-				scp->term.cur_attr = scp->term.std_attr =  
-					(scp->term.std_attr & 0x0F00) 
-					| ((scp->term.param[0] & 0x0F) << 12);
-			break;
-
-		case 'H':	/* set ansi reverse video foreground */
-			if (scp->term.num_param == 1) 
-				scp->term.rev_attr = 
-					(scp->term.rev_attr & 0xF000) 
-					| ((scp->term.param[0] & 0x0F) << 8);
-			break;
-
-		case 'I': 	/* set ansi reverse video background */
-			if (scp->term.num_param == 1) 
-				scp->term.rev_attr = 
-					(scp->term.rev_attr & 0x0F00) 
-					| ((scp->term.param[0] & 0x0F) << 12);
-			break;
-		}
+    }
+    else if (scp->term.esc == 3) {
+	if (c >= '0' && c <= '9') {
+	    if (scp->term.num_param < MAX_ESC_PAR) {
+	    if (scp->term.last_param != scp->term.num_param) {
+		scp->term.last_param = scp->term.num_param;
+		scp->term.param[scp->term.num_param] = 0;
+	    }
+	    else
+		scp->term.param[scp->term.num_param] *= 10;
+	    scp->term.param[scp->term.num_param] += c - '0';
+	    return;
+	    }
+	}
+	scp->term.num_param = scp->term.last_param + 1;
+	switch (c) {
+
+	case ';':
+	    if (scp->term.num_param < MAX_ESC_PAR)
+		return;
+	    break;
+
+	case 'A':   /* set display border color */
+	    if (scp->term.num_param == 1)
+		scp->border=scp->term.param[0] & 0xff;
+		if (scp == cur_console)
+		    set_border(scp->border);
+	    break;
+
+	case 'B':   /* set bell pitch and duration */
+	    if (scp->term.num_param == 2) {
+		scp->bell_pitch = scp->term.param[0];
+		scp->bell_duration = scp->term.param[1]*10;
+	    }
+	    break;
+
+	case 'C':   /* set cursor type & shape */
+	    if (scp->term.num_param == 1) {
+		if (scp->term.param[0] & 0x01)
+		    configuration |= BLINK_CURSOR;
+		else
+		    configuration &= ~BLINK_CURSOR;
+		if (scp->term.param[0] & 0x02)
+		    configuration |= CHAR_CURSOR;
+		else
+		    configuration &= ~CHAR_CURSOR;
+	    }
+	    else if (scp->term.num_param == 2) {
+		scp->cursor_start = scp->term.param[0] & 0x1F; 
+		scp->cursor_end = scp->term.param[1] & 0x1F; 
+	    }
+	    break;
+
+	case 'F':   /* set ansi foreground */
+	    if (scp->term.num_param == 1) 
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0xF000) 
+		    | ((scp->term.param[0] & 0x0F) << 8);
+	    break;
+
+	case 'G':   /* set ansi background */
+	    if (scp->term.num_param == 1) 
+		scp->term.cur_attr = scp->term.std_attr =  
+		    (scp->term.std_attr & 0x0F00) 
+		    | ((scp->term.param[0] & 0x0F) << 12);
+	    break;
+
+	case 'H':   /* set ansi reverse video foreground */
+	    if (scp->term.num_param == 1) 
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0xF000) 
+		    | ((scp->term.param[0] & 0x0F) << 8);
+	    break;
+
+	case 'I':   /* set ansi reverse video background */
+	    if (scp->term.num_param == 1) 
+		scp->term.rev_attr = 
+		    (scp->term.rev_attr & 0x0F00) 
+		    | ((scp->term.param[0] & 0x0F) << 12);
+	    break;
 	}
-	scp->term.esc = 0;
+    }
+    scp->term.esc = 0;
 }
 
 static inline void 
 draw_cursor(scr_stat *scp, int show)
 {
-	if (show && !(scp->status & CURSOR_SHOWN)) {
-	    u_short cursor_image = *(Crtat + (scp->cursor_pos - scp->scr_buf));
+    if (show && !(scp->status & CURSOR_SHOWN)) {
+	u_short cursor_image = *(Crtat + (scp->cursor_pos - scp->scr_buf));
 
-		scp->cursor_saveunder = cursor_image;
-		if (configuration & CHAR_CURSOR)
-			cursor_image = (cursor_image & 0xff00) | '_';
-		else {
-			if ((cursor_image & 0x7000) == 0x7000) {
-				cursor_image &= 0x8fff;
-				if(!(cursor_image & 0x0700))
-					cursor_image |= 0x0700;
-			} else {
-				cursor_image |= 0x7000;
-				if ((cursor_image & 0x0700) == 0x0700)
-					cursor_image &= 0xf0ff;
-			}
-		}
-		*(Crtat + (scp->cursor_pos - scp->scr_buf)) = cursor_image;
-		scp->status |= CURSOR_SHOWN;
-	}
-	if (!show && (scp->status & CURSOR_SHOWN)) {
-		*(Crtat+(scp->cursor_pos-scp->scr_buf)) = scp->cursor_saveunder;
-		scp->status &= ~CURSOR_SHOWN;
+	scp->cursor_saveunder = cursor_image;
+	if (configuration & CHAR_CURSOR)
+	    cursor_image = (cursor_image & 0xff00) | '_';
+	else {
+	    if ((cursor_image & 0x7000) == 0x7000) {
+		cursor_image &= 0x8fff;
+		if(!(cursor_image & 0x0700))
+		    cursor_image |= 0x0f00;
+	    } else {
+		cursor_image |= 0x7000;
+		if ((cursor_image & 0x0f00) == 0x0f00)
+		    cursor_image &= 0xf0ff;
+	    }
 	}
+	*(Crtat + (scp->cursor_pos - scp->scr_buf)) = cursor_image;
+	scp->status |= CURSOR_SHOWN;
+    }
+    if (!show && (scp->status & CURSOR_SHOWN)) {
+	*(Crtat+(scp->cursor_pos-scp->scr_buf)) = scp->cursor_saveunder;
+	scp->status &= ~CURSOR_SHOWN;
+    }
 }
 
 static void 
 ansi_put(scr_stat *scp, u_char *buf, int len)
 {
-	u_char *ptr = buf;
+    u_char *ptr = buf;
 
-	if (scp->status & UNKNOWN_MODE) 
-		return;
+    if (scp->status & UNKNOWN_MODE) 
+	return;
 
-	/* make screensaver happy */
-	if (scp == cur_console) {
-		scrn_time_stamp = time.tv_sec;
-		if (scrn_blanked)
-			SCRN_SAVER(FALSE);
-	}
-	write_in_progress++;
+    /* make screensaver happy */
+    if (scp == cur_console) {
+	scrn_time_stamp = time.tv_sec;
+	if (scrn_blanked)
+	    (*current_saver)(FALSE);
+    }
+    write_in_progress++;
 outloop:
-	if (scp->term.esc) {
-		scan_esc(scp, *ptr++);
-		len--;
+    if (scp->term.esc) {
+	scan_esc(scp, *ptr++);
+	len--;
+    }
+    else if (PRINTABLE(*ptr)) {     /* Print only printables */
+	do {
+	    *scp->cursor_pos++ = (scp->term.cur_attr | scr_map[*ptr++]);
+	    scp->xpos++;
+	    len--;
+	} while (len && PRINTABLE(*ptr) && (scp->xpos < scp->xsize));
+	if (scp->xpos >= scp->xsize) {
+	    scp->xpos = 0;
+	    scp->ypos++;
 	}
-	else if (PRINTABLE(*ptr)) { 	/* Print only printables */
-		do {
-			*scp->cursor_pos++ = 
-				(scp->term.cur_attr | scr_map[*ptr++]);
-			scp->xpos++;
-			len--;
-		} while (len && PRINTABLE(*ptr) && (scp->xpos < scp->xsize));
-		if (scp->xpos >= scp->xsize) {
-			scp->xpos = 0;
-			scp->ypos++;
+    }
+    else  {
+	switch(*ptr) {
+	case 0x07:
+	    do_bell(scp, scp->bell_pitch, scp->bell_duration);
+	    break;
+
+	case 0x08:      /* non-destructive backspace */
+	    if (scp->cursor_pos > scp->scr_buf) {
+		scp->cursor_pos--;
+		if (scp->xpos > 0)
+		    scp->xpos--;
+		else {
+		    scp->xpos += scp->xsize - 1;
+		    scp->ypos--;
 		}
-	}
-	else  {
-		switch(*ptr) {
-		case 0x07:
-			do_bell(scp, scp->bell_pitch, scp->bell_duration);
-			break;
-		case 0x08:      /* non-destructive backspace */
-			if (scp->cursor_pos > scp->scr_buf) {
-				scp->cursor_pos--;
-				if (scp->xpos > 0)
-					scp->xpos--;
-				else {
-					scp->xpos += scp->xsize - 1;
-					scp->ypos--;
-				}
-			}
-			break;
-		case 0x09:	/* non-destructive tab */
-			{
-				int i = 8 - scp->xpos % 8u;
-
-				scp->cursor_pos += i;
-				if ((scp->xpos += i) >= scp->xsize) {
-					scp->xpos = 0;
-					scp->ypos++;
-				}
-			}
-			break;
-		case 0x0a:	/* newline, same pos */
-			scp->cursor_pos += scp->xsize;
-			scp->ypos++;
-			break;
-		case 0x0c:	/* form feed, clears screen */
-			clear_screen(scp);
-			break;
-		case 0x0d:	/* return, return to pos 0 */
-			scp->cursor_pos -= scp->xpos;
-			scp->xpos = 0;
-			break;
-		case 0x1b:	/* start escape sequence */
-			scp->term.esc = 1;
-			scp->term.num_param = 0;
-			break;
+	    }
+	    break;
+
+	case 0x09:  /* non-destructive tab */
+	    {
+		int i = 8 - scp->xpos % 8u;
+
+		scp->cursor_pos += i;
+		if ((scp->xpos += i) >= scp->xsize) {
+		    scp->xpos = 0;
+		    scp->ypos++;
 		}
-		ptr++; len--;
-	}
-	/* do we have to scroll ?? */
-	if (scp->cursor_pos >= scp->scr_buf + scp->ysize * scp->xsize) {
-	    if (scp->history) {
-		bcopyw(scp->scr_buf, scp->history_head,
-		       scp->xsize * sizeof(u_short));
-
-		scp->history_head += scp->xsize;
-		if (scp->history_head + scp->xsize >
-		    scp->history + scp->history_size)
-			scp->history_head = scp->history;
 	    }
-	    bcopyw(scp->scr_buf + scp->xsize, scp->scr_buf,
-		   scp->xsize * (scp->ysize - 1) * sizeof(u_short));
-	    fillw(scp->term.cur_attr | scr_map[0x20],
-		  scp->scr_buf + scp->xsize * (scp->ysize - 1), 
-		  scp->xsize);
-	    scp->cursor_pos -= scp->xsize;
-	    scp->ypos--;
+	    break;
+
+	case 0x0a:  /* newline, same pos */
+	    scp->cursor_pos += scp->xsize;
+	    scp->ypos++;
+	    break;
+
+	case 0x0c:  /* form feed, clears screen */
+	    clear_screen(scp);
+	    break;
+
+	case 0x0d:  /* return, return to pos 0 */
+	    scp->cursor_pos -= scp->xpos;
+	    scp->xpos = 0;
+	    break;
+
+	case 0x1b:  /* start escape sequence */
+	    scp->term.esc = 1;
+	    scp->term.num_param = 0;
+	    break;
 	}
-	if (len)
-		goto outloop;
-	write_in_progress--;
-	if (delayed_next_scr)
-		switch_scr(scp, delayed_next_scr - 1);
+	ptr++; len--;
+    }
+    /* do we have to scroll ?? */
+    if (scp->cursor_pos >= scp->scr_buf + scp->ysize * scp->xsize) {
+	if (scp->history) {
+	    bcopyw(scp->scr_buf, scp->history_head,
+		   scp->xsize * sizeof(u_short));
+	    scp->history_head += scp->xsize;
+	    if (scp->history_head + scp->xsize >
+		scp->history + scp->history_size)
+		scp->history_head = scp->history;
+	}
+	bcopyw(scp->scr_buf + scp->xsize, scp->scr_buf,
+	       scp->xsize * (scp->ysize - 1) * sizeof(u_short));
+	fillw(scp->term.cur_attr | scr_map[0x20],
+	      scp->scr_buf + scp->xsize * (scp->ysize - 1), 
+	      scp->xsize);
+	scp->cursor_pos -= scp->xsize;
+	scp->ypos--;
+    }
+    if (len)
+	goto outloop;
+    write_in_progress--;
+    if (delayed_next_scr)
+	switch_scr(scp, delayed_next_scr - 1);
 }
 
 static void 
 scinit(void)
 {
-	u_short volatile *cp = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short), was;
-	unsigned hw_cursor;
-	int i;
+    u_short volatile *cp = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short), was;
+    unsigned hw_cursor;
+    int i;
+
+    if (init_done)  
+	return;
+    init_done = TRUE;
+    /*
+     * Crtat initialized to point to MONO buffer, if not present change
+     * to CGA_BUF offset. ONLY add the difference since locore.s adds
+     * in the remapped offset at the "right" time
+     */
+    was = *cp;
+    *cp = (u_short) 0xA55A;
+    if (*cp != 0xA55A)
+	crtc_addr = MONO_BASE;
+    else {
+	*cp = was;
+	crtc_addr = COLOR_BASE;
+	Crtat = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short);
+    }
+
+    /* extract cursor location */
+    outb(crtc_addr,14);
+    hw_cursor = inb(crtc_addr+1)<<8 ;
+    outb(crtc_addr,15);
+    hw_cursor |= inb(crtc_addr+1);
+
+    /* move hardware cursor out of the way */
+    outb(crtc_addr,14);
+    outb(crtc_addr+1, 0xff);
+    outb(crtc_addr,15);
+    outb(crtc_addr+1, 0xff);
+
+    /* is this a VGA or higher ? */
+    outb(crtc_addr, 7);
+    if (inb(crtc_addr) == 7) {
+	u_long  pa;
+	u_long  segoff;
+
+	crtc_vga = TRUE;
 
-	if (init_done) 	
-		return;
-	init_done = TRUE;
 	/*
-	 * Crtat initialized to point to MONO buffer, if not present change
-	 * to CGA_BUF offset. ONLY add the difference since locore.s adds
-	 * in the remapped offset at the "right" time
+	 * Get the BIOS video mode pointer.
 	 */
-	was = *cp;
-	*cp = (u_short) 0xA55A;
-	if (*cp != 0xA55A)
-		crtc_addr = MONO_BASE;
-	else {
-		*cp = was;
-		crtc_addr = COLOR_BASE;
-		Crtat = Crtat + (CGA_BUF-MONO_BUF)/sizeof(u_short);
+	segoff = *(u_long *)pa_to_va(0x4a8);
+	pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
+	if (ISMAPPED(pa, sizeof(u_long))) {
+	    segoff = *(u_long *)pa_to_va(pa);
+	    pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
+	    if (ISMAPPED(pa, 64))
+		video_mode_ptr = (char *)pa_to_va(pa);
 	}
-
-	/* extract cursor location */
-	outb(crtc_addr,14);
-	hw_cursor = inb(crtc_addr+1)<<8 ;
-	outb(crtc_addr,15);
-	hw_cursor |= inb(crtc_addr+1);
-
-	/* move hardware cursor out of the way */
-	outb(crtc_addr,14);
-	outb(crtc_addr+1, 0xff);
-	outb(crtc_addr,15);
-	outb(crtc_addr+1, 0xff);
-
-	/* is this a VGA or higher ? */
-	outb(crtc_addr, 7);
-	if (inb(crtc_addr) == 7) {
-		u_long	pa;
-		u_long	segoff;
-
-		crtc_vga = TRUE;
-
-		/*
-		 * Get the BIOS video mode pointer.
-		 */
-		segoff = *(u_long *)pa_to_va(0x4a8);
-		pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
-		if (ISMAPPED(pa, sizeof(u_long))) {
-			segoff = *(u_long *)pa_to_va(pa);
-			pa = (((segoff & 0xffff0000) >> 12)
-			      + (segoff & 0xffff));
-			if (ISMAPPED(pa, 64))
-				video_mode_ptr = (char *)pa_to_va(pa);
-		}
-	}
-	current_default = &user_default;
-	console[0] = &main_console;
-	init_scp(console[0]);
-	console[0]->scr_buf = console[0]->mouse_pos =  Crtat;
-	console[0]->cursor_pos = Crtat + hw_cursor;
-	console[0]->xpos = hw_cursor % COL;
-	console[0]->ypos = hw_cursor / COL;
-	cur_console = console[0];
-	for (i=1; i<MAXCONS; i++)
-		console[i] = NULL;
-	kernel_console.esc = 0;
-	kernel_console.std_attr = kernel_default.std_attr;
-	kernel_console.rev_attr = kernel_default.rev_attr;
-	kernel_console.cur_attr = kernel_default.std_attr;
-	/* initialize mapscrn array to a one to one map */
-	for (i=0; i<sizeof(scr_map); i++)
-		scr_map[i] = i;
+    }
+    current_default = &user_default;
+    console[0] = &main_console;
+    init_scp(console[0]);
+    console[0]->scr_buf = console[0]->mouse_pos =  Crtat;
+    console[0]->cursor_pos = Crtat + hw_cursor;
+    console[0]->xpos = hw_cursor % COL;
+    console[0]->ypos = hw_cursor / COL;
+    cur_console = console[0];
+    for (i=1; i<MAXCONS; i++)
+	console[i] = NULL;
+    kernel_console.esc = 0;
+    kernel_console.std_attr = kernel_default.std_attr;
+    kernel_console.rev_attr = kernel_default.rev_attr;
+    kernel_console.cur_attr = kernel_default.std_attr;
+    /* initialize mapscrn array to a one to one map */
+    for (i=0; i<sizeof(scr_map); i++)
+	scr_map[i] = i;
 }
 
 static scr_stat 
 *alloc_scp()
 {
-	scr_stat *scp;
-
-	scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_NOWAIT);
-	init_scp(scp);
-	scp->scr_buf = scp->cursor_pos = scp->scr_buf = scp->mouse_pos =
-		(u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	scp->history_head = scp->history_pos = scp->history =
-		(u_short *)malloc(scp->history_size*sizeof(u_short),
-				  M_DEVBUF, M_NOWAIT);
-	bzero(scp->history_head, scp->history_size*sizeof(u_short));
-	if (crtc_vga && video_mode_ptr)
-		set_mode(scp);
-	clear_screen(scp);
-	return scp;
+    scr_stat *scp;
+
+    scp = (scr_stat *)malloc(sizeof(scr_stat), M_DEVBUF, M_NOWAIT);
+    init_scp(scp);
+    scp->scr_buf = scp->cursor_pos = scp->scr_buf = scp->mouse_pos =
+	(u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    scp->history_head = scp->history_pos = scp->history =
+	(u_short *)malloc(scp->history_size*sizeof(u_short),
+			  M_DEVBUF, M_NOWAIT);
+    bzero(scp->history_head, scp->history_size*sizeof(u_short));
+    if (crtc_vga && video_mode_ptr)
+	set_mode(scp);
+    clear_screen(scp);
+    return scp;
 }
 
 static void
 init_scp(scr_stat *scp)
 {
-	scp->mode = M_VGA_C80x25;
-	scp->font = FONT_16;
-	scp->xsize = COL;
-	scp->ysize = ROW;
-	scp->term.esc = 0;
-	scp->term.std_attr = current_default->std_attr;
-	scp->term.rev_attr = current_default->rev_attr;
-	scp->term.cur_attr = scp->term.std_attr;
-	scp->border = BG_BLACK;
-	scp->cursor_start = -1;
-	scp->cursor_end = -1;
-	scp->mouse_xpos = scp->mouse_ypos = 0;
-	scp->bell_pitch = BELL_PITCH;
-	scp->bell_duration = BELL_DURATION;
-	scp->status = (*(char *)pa_to_va(0x417) & 0x20) ? NLKED : 0;
-	scp->status |= CURSOR_ENABLED;
-	scp->pid = 0;
-	scp->proc = NULL;
-	scp->smode.mode = VT_AUTO;
-	scp->history_head = scp->history_pos = scp->history = NULL;
-	scp->history_size = HISTORY_SIZE;
-}
-
-static void 
-scput(u_char c)
-{
-	scr_stat *scp;
-	term_stat save;
-
-	scp = console[0];
-	save = scp->term;
-	scp->term = kernel_console;
-	current_default = &kernel_default;
-	if (scp->scr_buf == Crtat)
-		draw_cursor(scp, FALSE);
-	ansi_put(scp, &c, 1);
-	scp->status |= UPDATE_SCREEN;
-	kernel_console = scp->term;
-	current_default = &user_default;
-	scp->term = save;
-	if (scp == cur_console /* && scrn_timer not running */) {
-		if (scp->scr_buf != Crtat) {
-	    		bcopyw(scp->scr_buf, Crtat,
-			       (scp->xsize*scp->ysize)*sizeof(u_short));
-	    		scp->status &= ~CURSOR_SHOWN;
-		}
-		draw_cursor(scp, TRUE);
-		scp->status &= ~UPDATE_SCREEN;
-	}
+    scp->mode = M_VGA_C80x25;
+    scp->font = FONT_16;
+    scp->xsize = COL;
+    scp->ysize = ROW;
+    scp->term.esc = 0;
+    scp->term.std_attr = current_default->std_attr;
+    scp->term.rev_attr = current_default->rev_attr;
+    scp->term.cur_attr = scp->term.std_attr;
+    scp->border = BG_BLACK;
+    scp->cursor_start = -1;
+    scp->cursor_end = -1;
+    scp->mouse_xpos = scp->mouse_ypos = 0;
+    scp->bell_pitch = BELL_PITCH;
+    scp->bell_duration = BELL_DURATION;
+    scp->status = (*(char *)pa_to_va(0x417) & 0x20) ? NLKED : 0;
+    scp->status |= CURSOR_ENABLED;
+    scp->pid = 0;
+    scp->proc = NULL;
+    scp->smode.mode = VT_AUTO;
+    scp->history_head = scp->history_pos = scp->history = NULL;
+    scp->history_size = HISTORY_SIZE;
 }
 
 static u_char 
 *get_fstr(u_int c, u_int *len)
 {
-	u_int i;
-
-	if (!(c & FKEY))
-		return(NULL);
-	i = (c & 0xFF) - F_FN;
-	if (i > n_fkey_tab)
-		return(NULL);
-	*len = fkey_tab[i].len;
-	return(fkey_tab[i].str);
+    u_int i;
+
+    if (!(c & FKEY))
+	return(NULL);
+    i = (c & 0xFF) - F_FN;
+    if (i > n_fkey_tab)
+	return(NULL);
+    *len = fkey_tab[i].len;
+    return(fkey_tab[i].str);
 }
 
 static void 
 update_leds(int which)
 {
-	int s;
-	static u_char xlate_leds[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
+    int s;
+    static u_char xlate_leds[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
 
-	/* replace CAPS led with ALTGR led for ALTGR keyboards */
-	if (key_map.n_keys > ALTGR_OFFSET) {
-		if (which & ALKED)
-			which |= CLKED;
-		else
-			which &= ~CLKED;
-	}
-	s = spltty();
-	kbd_cmd(KB_SETLEDS);
-	kbd_cmd(xlate_leds[which & LED_MASK]);
-	splx(s);
+    /* replace CAPS led with ALTGR led for ALTGR keyboards */
+    if (key_map.n_keys > ALTGR_OFFSET) {
+	if (which & ALKED)
+	    which |= CLKED;
+	else
+	    which &= ~CLKED;
+    }
+    s = spltty();
+    kbd_cmd(KB_SETLEDS);
+    kbd_cmd(xlate_leds[which & LED_MASK]);
+    splx(s);
 }
   
 static void
 history_to_screen(scr_stat *scp)
 {
-	int i;
-
-	scp->status &= ~UPDATE_SCREEN;
-	for (i=0; i<scp->ysize; i++)
-		bcopyw(scp->history + (((scp->history_pos - scp->history) + 
-		       scp->history_size-((i+1)*scp->xsize))%scp->history_size),
-		       scp->scr_buf + (scp->xsize * (scp->ysize-1 - i)),
-		       scp->xsize * sizeof(u_short));
-	scp->status |= UPDATE_SCREEN;
+    int i;
+
+    scp->status &= ~UPDATE_SCREEN;
+    for (i=0; i<scp->ysize; i++)
+	bcopyw(scp->history + (((scp->history_pos - scp->history) + 
+	       scp->history_size-((i+1)*scp->xsize))%scp->history_size),
+	       scp->scr_buf + (scp->xsize * (scp->ysize-1 - i)),
+	       scp->xsize * sizeof(u_short));
+    scp->status |= UPDATE_SCREEN;
 }
 
 static int
 history_up_line(scr_stat *scp)
 {
-	if (WRAPHIST(scp, scp->history_pos, -(scp->xsize*scp->ysize)) !=
-	    scp->history_head) {
-		scp->history_pos = WRAPHIST(scp, scp->history_pos, -scp->xsize);
-		history_to_screen(scp);
-		return 0;
-	}
-	else
-		return -1;
+    if (WRAPHIST(scp, scp->history_pos, -(scp->xsize*scp->ysize)) !=
+	scp->history_head) {
+	scp->history_pos = WRAPHIST(scp, scp->history_pos, -scp->xsize);
+	history_to_screen(scp);
+	return 0;
+    }
+    else
+	return -1;
 }
 
 static int
 history_down_line(scr_stat *scp)
 {
-	if (scp->history_pos != scp->history_head) {
-		scp->history_pos = WRAPHIST(scp, scp->history_pos, scp->xsize);
-		history_to_screen(scp);
-		return 0;
-	}
-	else
-		return -1;
+    if (scp->history_pos != scp->history_head) {
+	scp->history_pos = WRAPHIST(scp, scp->history_pos, scp->xsize);
+	history_to_screen(scp);
+	return 0;
+    }
+    else
+	return -1;
 }
 
 /*
@@ -2503,875 +2088,882 @@ history_down_line(scr_stat *scp)
 u_int 
 scgetc(int noblock)
 {
-	u_char scancode, keycode;
-	u_int state, action;
-	struct key_t *key;
-	static u_char esc_flag = 0, compose = 0;
-	static u_int chr = 0;
+    u_char scancode, keycode;
+    u_int state, action;
+    struct key_t *key;
+    static u_char esc_flag = 0, compose = 0;
+    static u_int chr = 0;
 
 next_code:
-	kbd_wait();
-	/* First see if there is something in the keyboard port */
-	if (inb(KB_STAT) & KB_BUF_FULL)
-		scancode = inb(KB_DATA);
-	else if (noblock)
-		return(NOKEY);
-	else
-		goto next_code;
+    kbd_wait();
+    /* First see if there is something in the keyboard port */
+    if (inb(KB_STAT) & KB_BUF_FULL)
+	scancode = inb(KB_DATA);
+    else if (noblock)
+	return(NOKEY);
+    else
+	goto next_code;
 
-	if (cur_console->status & KBD_RAW_MODE)
-		return scancode;
+    if (cur_console->status & KBD_RAW_MODE)
+	return scancode;
 #if ASYNCH
-	if (scancode == KB_ACK || scancode == KB_RESEND) {
-		kbd_reply = scancode;
-		if (noblock)
-			return(NOKEY);
-		goto next_code;
-	}
+    if (scancode == KB_ACK || scancode == KB_RESEND) {
+	kbd_reply = scancode;
+	if (noblock)
+	    return(NOKEY);
+	goto next_code;
+    }
 #endif
-	keycode = scancode & 0x7F;
-	switch (esc_flag) {
-	case 0x00:		/* normal scancode */
-		switch(scancode) {
-		case 0xB8:	/* left alt  (compose key) */
-			if (compose) {
-				compose = 0;	
-				if (chr > 255) {
-					do_bell(cur_console, 
-						BELL_PITCH, BELL_DURATION);
-					chr = 0;
-				}
-			}
-			break;
-		case 0x38:
-			if (!compose) {
-				compose = 1;
-				chr = 0;
-			}
-			break;
-		case 0xE0:
-		case 0xE1:
-			esc_flag = scancode;
-			goto next_code;		
-		}
-		break;
-	case 0xE0:		/* 0xE0 prefix */
-		esc_flag = 0;
-		switch (keycode) {
-		case 0x1C:	/* right enter key */
-			keycode = 0x59;
-			break;
-		case 0x1D:	/* right ctrl key */
-			keycode = 0x5A;
-			break;
-		case 0x35:	/* keypad divide key */
-			keycode = 0x5B;
-			break;
-		case 0x37:	/* print scrn key */
-			keycode = 0x5C;
-			break;
-		case 0x38:	/* right alt key (alt gr) */
-			keycode = 0x5D;
-			break;
-		case 0x47:	/* grey home key */
-			keycode = 0x5E;
-			break;
-		case 0x48:	/* grey up arrow key */
-			keycode = 0x5F;
-			break;
-		case 0x49:	/* grey page up key */
-			keycode = 0x60;
-			break;
-		case 0x4B:	/* grey left arrow key */
-			keycode = 0x61;
-			break;
-		case 0x4D:	/* grey right arrow key */
-			keycode = 0x62;
-			break;
-		case 0x4F:	/* grey end key */
-			keycode = 0x63;
-			break;
-		case 0x50:	/* grey down arrow key */
-			keycode = 0x64;
-			break;
-		case 0x51:	/* grey page down key */
-			keycode = 0x65;
-			break;
-		case 0x52:	/* grey insert key */
-			keycode = 0x66;
-			break;
-		case 0x53:	/* grey delete key */
-			keycode = 0x67;
-			break;
-
-		/* the following 3 are only used on the MS "Natural" keyboard */
-		case 0x5b:	/* left Window key */
-			keycode = 0x69;
-			break;
-		case 0x5c:	/* right Window key */
-			keycode = 0x6a;
-			break;
-		case 0x5d:	/* menu key */
-			keycode = 0x6b;
-			break;
-		default:	/* ignore everything else */
-			goto next_code;
+    keycode = scancode & 0x7F;
+    switch (esc_flag) {
+    case 0x00:      /* normal scancode */
+	switch(scancode) {
+	case 0xB8:  /* left alt  (compose key) */
+	    if (compose) {
+		compose = 0;    
+		if (chr > 255) {
+		    do_bell(cur_console, 
+			BELL_PITCH, BELL_DURATION);
+		    chr = 0;
 		}
+	    }
+	    break;
+	case 0x38:
+	    if (!compose) {
+		compose = 1;
+		chr = 0;
+	    }
+	    break;
+	case 0xE0:
+	case 0xE1:
+	    esc_flag = scancode;
+	    goto next_code;     
+	}
+	break;
+    case 0xE0:      /* 0xE0 prefix */
+	esc_flag = 0;
+	switch (keycode) {
+	case 0x1C:  /* right enter key */
+	    keycode = 0x59;
+	    break;
+	case 0x1D:  /* right ctrl key */
+	    keycode = 0x5A;
+	    break;
+	case 0x35:  /* keypad divide key */
+	    keycode = 0x5B;
+	    break;
+	case 0x37:  /* print scrn key */
+	    keycode = 0x5C;
+	    break;
+	case 0x38:  /* right alt key (alt gr) */
+	    keycode = 0x5D;
+	    break;
+	case 0x47:  /* grey home key */
+	    keycode = 0x5E;
+	    break;
+	case 0x48:  /* grey up arrow key */
+	    keycode = 0x5F;
+	    break;
+	case 0x49:  /* grey page up key */
+	    keycode = 0x60;
+	    break;
+	case 0x4B:  /* grey left arrow key */
+	    keycode = 0x61;
+	    break;
+	case 0x4D:  /* grey right arrow key */
+	    keycode = 0x62;
+	    break;
+	case 0x4F:  /* grey end key */
+	    keycode = 0x63;
+	    break;
+	case 0x50:  /* grey down arrow key */
+	    keycode = 0x64;
+	    break;
+	case 0x51:  /* grey page down key */
+	    keycode = 0x65;
+	    break;
+	case 0x52:  /* grey insert key */
+	    keycode = 0x66;
+	    break;
+	case 0x53:  /* grey delete key */
+	    keycode = 0x67;
+	    break;
+
+	/* the following 3 are only used on the MS "Natural" keyboard */
+	case 0x5b:  /* left Window key */
+	    keycode = 0x69;
+	    break;
+	case 0x5c:  /* right Window key */
+	    keycode = 0x6a;
+	    break;
+	case 0x5d:  /* menu key */
+	    keycode = 0x6b;
+	    break;
+	default:    /* ignore everything else */
+	    goto next_code;
+	}
+	break;
+    case 0xE1:      /* 0xE1 prefix */
+	esc_flag = 0;   
+	if (keycode == 0x1D)
+	    esc_flag = 0x1D;
+	goto next_code;
+	/* NOT REACHED */
+    case 0x1D:      /* pause / break */
+	esc_flag = 0;   
+	if (keycode != 0x45)
+	    goto next_code;
+	keycode = 0x68;
+	break;
+    }
+
+    /* if scroll-lock pressed allow history browsing */
+    if (cur_console->history && cur_console->status & SLKED) {
+	int i;
+
+	cur_console->status &= ~CURSOR_ENABLED;
+	if (!(cur_console->status & BUFFER_SAVED)) {
+	    cur_console->status |= BUFFER_SAVED;
+	    cur_console->history_save = cur_console->history_head;
+
+	    /* copy screen into top of history buffer */
+	    for (i=0; i<cur_console->ysize; i++) {
+		bcopyw(cur_console->scr_buf + (cur_console->xsize * i), 
+		       cur_console->history_head,
+		       cur_console->xsize * sizeof(u_short));
+		cur_console->history_head += cur_console->xsize;
+		if (cur_console->history_head + cur_console->xsize >
+		    cur_console->history + cur_console->history_size)
+		    cur_console->history_head=cur_console->history;
+	    }
+	    cur_console->history_pos = cur_console->history_head;
+	    history_to_screen(cur_console);
+	}
+	switch (scancode) {
+	case 0x47:  /* home key */
+	    cur_console->history_pos = cur_console->history_head;
+	    history_to_screen(cur_console);
+	    goto next_code;
+
+	case 0x4F:  /* end key */
+	    cur_console->history_pos =
+		WRAPHIST(cur_console, cur_console->history_head, 
+			 cur_console->xsize*cur_console->ysize);
+	    history_to_screen(cur_console);
+	    goto next_code;
+
+	case 0x48:  /* up arrow key */
+	    if (history_up_line(cur_console))
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+	    goto next_code;
+
+	case 0x50:  /* down arrow key */
+	    if (history_down_line(cur_console))
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+	    goto next_code;
+
+	case 0x49:  /* page up key */
+	    for (i=0; i<cur_console->ysize; i++)
+	    if (history_up_line(cur_console)) {
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
 		break;
-	case 0xE1:		/* 0xE1 prefix */
-		esc_flag = 0;	
-		if (keycode == 0x1D)
-			esc_flag = 0x1D;
-		goto next_code;
-		/* NOT REACHED */
-	case 0x1D:		/* pause / break */
-		esc_flag = 0;	
-		if (keycode != 0x45)
-			goto next_code;
-		keycode = 0x68;
+	    }
+	    goto next_code;
+
+	case 0x51:  /* page down key */
+	    for (i=0; i<cur_console->ysize; i++)
+	    if (history_down_line(cur_console)) {
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
 		break;
+	    }
+	    goto next_code;
 	}
+    }
 
-	/* if scroll-lock pressed allow history browsing */
-	if (cur_console->history && cur_console->status & SLKED) {
-		int i;
-
-		cur_console->status &= ~CURSOR_ENABLED;
-		if (!(cur_console->status & BUFFER_SAVED)) {
-		    cur_console->status |= BUFFER_SAVED;
-		    cur_console->history_save = cur_console->history_head;
-		    /* copy screen into top of history buffer */
-		    for (i=0; i<cur_console->ysize; i++) {
-			bcopyw(cur_console->scr_buf + (cur_console->xsize * i), 
-			       cur_console->history_head,
-			       cur_console->xsize * sizeof(u_short));
-
-			cur_console->history_head += cur_console->xsize;
-			if (cur_console->history_head + cur_console->xsize >
-			    cur_console->history + cur_console->history_size)
-				cur_console->history_head=cur_console->history;
-		    }
-		    cur_console->history_pos = cur_console->history_head;
-		    history_to_screen(cur_console);
-		}
-		switch (scancode) {
-		case 0x47:	/* home key */
-		    cur_console->history_pos = cur_console->history_head;
-		    history_to_screen(cur_console);
-		    goto next_code;
-
-		case 0x4F:	/* end key */
-		    cur_console->history_pos =
-			WRAPHIST(cur_console, cur_console->history_head, 
-				 cur_console->xsize*cur_console->ysize);
-		    history_to_screen(cur_console);
-		    goto next_code;
-
-		case 0x48:	/* up arrow key */
-		    if (history_up_line(cur_console))
-			do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-		    goto next_code;
-
-		case 0x50:	/* down arrow key */
-		    if (history_down_line(cur_console))
-			do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-		    goto next_code;
-
-		case 0x49:	/* page up key */
-		    for (i=0; i<cur_console->ysize; i++)
-			if (history_up_line(cur_console)) {
-			    do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-			    break;
-		    }
-		    goto next_code;
-
-		case 0x51:	/* page down key */
-		    for (i=0; i<cur_console->ysize; i++)
-			if (history_down_line(cur_console)) {
-			    do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-			    break;
-		    }
-		    goto next_code;
-		}
+    if (compose) {
+	switch (scancode) {
+	/* key pressed process it */
+	case 0x47: case 0x48: case 0x49:    /* keypad 7,8,9 */
+	    chr = (scancode - 0x40) + chr*10;
+	    goto next_code;
+	case 0x4B: case 0x4C: case 0x4D:    /* keypad 4,5,6 */ 
+	    chr = (scancode - 0x47) + chr*10;
+	    goto next_code;
+	case 0x4F: case 0x50: case 0x51:    /* keypad 1,2,3 */ 
+	    chr = (scancode - 0x4E) + chr*10;
+	    goto next_code;
+	case 0x52:              /* keypad 0 */
+	    chr *= 10;
+	    goto next_code;
+
+	/* key release, no interest here */
+	case 0xC7: case 0xC8: case 0xC9:    /* keypad 7,8,9 */
+	case 0xCB: case 0xCC: case 0xCD:    /* keypad 4,5,6 */ 
+	case 0xCF: case 0xD0: case 0xD1:    /* keypad 1,2,3 */ 
+	case 0xD2:              /* keypad 0 */
+	    goto next_code;
+
+	case 0x38:              /* left alt key */
+	    break;
+	default:
+	    if (chr) {
+		compose = chr = 0;
+		do_bell(cur_console, BELL_PITCH, BELL_DURATION);
+		goto next_code;     
+	    }
+	    break;
 	}
-
-	if (compose) {
-		switch (scancode) {
-		/* key pressed process it */
-		case 0x47: case 0x48: case 0x49:	/* keypad 7,8,9 */
-			chr = (scancode - 0x40) + chr*10;
-			goto next_code;
-		case 0x4B: case 0x4C: case 0x4D:	/* keypad 4,5,6 */ 
-			chr = (scancode - 0x47) + chr*10;
-			goto next_code;
-		case 0x4F: case 0x50: case 0x51:	/* keypad 1,2,3 */ 
-			chr = (scancode - 0x4E) + chr*10;
-			goto next_code;
-		case 0x52:				/* keypad 0 */
-			chr *= 10;
-			goto next_code;
-
-		/* key release, no interest here */
-		case 0xC7: case 0xC8: case 0xC9:	/* keypad 7,8,9 */
-		case 0xCB: case 0xCC: case 0xCD:	/* keypad 4,5,6 */ 
-		case 0xCF: case 0xD0: case 0xD1:	/* keypad 1,2,3 */ 
-		case 0xD2:				/* keypad 0 */
-			goto next_code;
-
-		case 0x38:				/* left alt key */
-			break;
-		default:
-			if (chr) {
-				compose = chr = 0;
-				do_bell(cur_console, BELL_PITCH, BELL_DURATION);
-				goto next_code;		
-			}
-			break;
-		}
+    }
+	
+    state = (shfts ? 1 : 0 ) | (2 * (ctls ? 1 : 0)) | (4 * (alts ? 1 : 0));
+    if ((!agrs && (cur_console->status & ALKED))
+	|| (agrs && !(cur_console->status & ALKED)))
+	keycode += ALTGR_OFFSET;
+    key = &key_map.key[keycode];
+    if ( ((key->flgs & FLAG_LOCK_C) && (cur_console->status & CLKED))
+	 || ((key->flgs & FLAG_LOCK_N) && (cur_console->status & NLKED)) )
+	state ^= 1;
+
+    /* Check for make/break */
+    action = key->map[state];
+    if (scancode & 0x80) {      /* key released */
+	if (key->spcl & 0x80) {
+	    switch (action) {
+	    case LSH:
+		shfts &= ~1;
+		break;
+	    case RSH:
+		shfts &= ~2;
+		break;
+	    case LCTR:
+		ctls &= ~1;
+		break;
+	    case RCTR:
+		ctls &= ~2;
+		break;
+	    case LALT:
+		alts &= ~1;
+		break;
+	    case RALT:
+		alts &= ~2;
+		break;
+	    case NLK:
+		nlkcnt = 0;             
+		break;
+	    case CLK:
+		clkcnt = 0;
+		break;
+	    case SLK:
+		slkcnt = 0;
+		break;
+	    case ASH:
+		agrs = 0;
+		break;
+	    case ALK:
+		alkcnt = 0;
+		break;
+	    case META:
+		metas = 0;
+		break;
+	    }
 	}
-		
-	state = (shfts ? 1 : 0 ) | (2 * (ctls ? 1 : 0)) | (4 * (alts ? 1 : 0));
-	if ((!agrs && (cur_console->status & ALKED))
-	    || (agrs && !(cur_console->status & ALKED)))
-		keycode += ALTGR_OFFSET;
-	key = &key_map.key[keycode];
-	if ( ((key->flgs & FLAG_LOCK_C) && (cur_console->status & CLKED))
-	     || ((key->flgs & FLAG_LOCK_N) && (cur_console->status & NLKED)) )
-		state ^= 1;
-
-	/* Check for make/break */
-	action = key->map[state];
-	if (scancode & 0x80) { 		/* key released */
-		if (key->spcl & 0x80) {
-			switch (action) {
-			case LSH:
-				shfts &= ~1;
-				break;
-			case RSH:
-				shfts &= ~2;
-				break;
-			case LCTR:
-				ctls &= ~1;
-				break;
-			case RCTR:
-				ctls &= ~2;
-				break;
-			case LALT:
-				alts &= ~1;
-				break;
-			case RALT:
-				alts &= ~2;
-				break;
-			case NLK:
-				nlkcnt = 0;				
-				break;
-			case CLK:
-				clkcnt = 0;
-				break;
-			case SLK:
-				slkcnt = 0;
-				break;
-			case ASH:
-				agrs = 0;
-				break;
-			case ALK:
-				alkcnt = 0;
-				break;
-			case META:
-				metas = 0;
-				break;
+	if (chr && !compose) {
+	    action = chr;
+	    chr = 0;
+	    return(action);
+	}
+    } else {
+	/* key pressed */
+	if (key->spcl & (0x80>>state)) {
+	    switch (action) {
+	    /* LOCKING KEYS */
+	    case NLK:
+		if (!nlkcnt) {
+		    nlkcnt++;
+		    if (cur_console->status & NLKED) 
+			cur_console->status &= ~NLKED;
+		    else
+			cur_console->status |= NLKED;
+		    update_leds(cur_console->status);
+		}
+		break;
+	    case CLK:
+		if (!clkcnt) {
+		    clkcnt++;
+		    if (cur_console->status & CLKED)
+			cur_console->status &= ~CLKED;
+		    else
+			cur_console->status |= CLKED;
+		    update_leds(cur_console->status);
+		}
+		break;
+	    case SLK:
+		if (!slkcnt) {
+		    slkcnt++;
+		    if (cur_console->status & SLKED) {
+			cur_console->status &= ~SLKED;
+			if (cur_console->status & BUFFER_SAVED){
+			    int i;
+			    u_short *ptr = cur_console->history_save;
+
+			    for (i=0; i<cur_console->ysize; i++) {
+				bcopyw(ptr, 
+				       cur_console->scr_buf +
+				       (cur_console->xsize*i),
+				       cur_console->xsize * sizeof(u_short));
+				ptr += cur_console->xsize;
+				if (ptr + cur_console->xsize >
+				    cur_console->history +
+				    cur_console->history_size)
+				    ptr = cur_console->history;
+			    }
+			    cur_console->status&=~BUFFER_SAVED;
+			    cur_console->history_head=cur_console->history_save;
+			    cur_console->status|=(CURSOR_ENABLED|UPDATE_SCREEN);
 			}
+			scstart(VIRTUAL_TTY(get_scr_num()));
+		    } 
+		    else 
+			cur_console->status |= SLKED;
+		    update_leds(cur_console->status);
 		}
-		if (chr && !compose) {
-			action = chr;
-			chr = 0;
-			return(action);
+		break;
+	    case ALK:
+		if (!alkcnt) {
+		    alkcnt++;
+		    if (cur_console->status & ALKED)
+			cur_console->status &= ~ALKED;
+		    else
+			cur_console->status |= ALKED;
+		    update_leds(cur_console->status);
 		}
-	} else {
-		/* key pressed */
-		if (key->spcl & (0x80>>state)) {
-			switch (action) {
-			/* LOCKING KEYS */
-			case NLK:
-				if (!nlkcnt) {
-					nlkcnt++;
-					if (cur_console->status & NLKED) 
-						cur_console->status &= ~NLKED;
-					else
-						cur_console->status |= NLKED;
-					update_leds(cur_console->status);
-				}
-				break;
-			case CLK:
-				if (!clkcnt) {
-					clkcnt++;
-					if (cur_console->status & CLKED)
-						cur_console->status &= ~CLKED;
-					else
-						cur_console->status |= CLKED;
-					update_leds(cur_console->status);
-				}
-				break;
-			case SLK:
-				if (!slkcnt) {
-				    slkcnt++;
-				    if (cur_console->status & SLKED) {
-					cur_console->status &= ~SLKED;
-					if (cur_console->status & BUFFER_SAVED){
-					    int i;
-		    for (i=0; i<cur_console->ysize; i++) {
-			bcopyw(cur_console->history_save+(cur_console->xsize*i),
-			       cur_console->scr_buf + (cur_console->xsize * i), 
-			       cur_console->xsize * sizeof(u_short));
-		    }
-					    cur_console->status&=~BUFFER_SAVED;
-					    cur_console->history_head =
-						cur_console->history_save;
-					    cur_console->status |= 
-						(CURSOR_ENABLED|UPDATE_SCREEN);
-					}
-					scstart(VIRTUAL_TTY(get_scr_num()));
-				    } 
-				    else 
-					cur_console->status |= SLKED;
-				    update_leds(cur_console->status);
-				}
-				break;
-			case ALK:
-				if (!alkcnt) {
-					alkcnt++;
-					if (cur_console->status & ALKED)
-						cur_console->status &= ~ALKED;
-					else
-						cur_console->status |= ALKED;
-					update_leds(cur_console->status);
-				}
-				break;
-
-			/* NON-LOCKING KEYS */
-			case NOP:
-				break;
-			case RBT:
-				shutdown_nice();
-				break;	
-			case SUSP:
+		break;
+
+	    /* NON-LOCKING KEYS */
+	    case NOP:
+		break;
+	    case RBT:
+		shutdown_nice();
+		break;  
+	    case SUSP:
 #if NAPM > 0 
-				apm_suspend();
+		apm_suspend();
 #endif
-				break;
-
-			case DBG:
-#ifdef DDB			/* try to switch to console 0 */
-				if (cur_console->smode.mode == VT_AUTO &&
-				    console[0]->smode.mode == VT_AUTO)
-					switch_scr(cur_console, 0); 
-				Debugger("manual escape to debugger");
-				return(NOKEY);
+		break;
+
+	    case DBG:
+#ifdef DDB          /* try to switch to console 0 */
+		if (cur_console->smode.mode == VT_AUTO &&
+		    console[0]->smode.mode == VT_AUTO)
+		    switch_scr(cur_console, 0); 
+		Debugger("manual escape to debugger");
+		return(NOKEY);
 #else
-				printf("No debugger in kernel\n");
+		printf("No debugger in kernel\n");
 #endif
-				break;
-			case LSH:
-				shfts |= 1;
-				break;
-			case RSH:
-				shfts |= 2;
-				break;
-			case LCTR:
-				ctls |= 1;
-				break;
-			case RCTR:
-				ctls |= 2;
-				break;
-			case LALT:
-				alts |= 1;
-				break;
-			case RALT:
-				alts |= 2;
-				break;
-			case ASH:
-				agrs = 1;
-				break;
-			case META:
-				metas = 1;
-				break;
-			case NEXT:
-				switch_scr(cur_console,
-					   (get_scr_num() + 1) % MAXCONS);
-				break;
-			case BTAB:
-				return(BKEY);
-			default:
-				if (action >= F_SCR && action <= L_SCR) {
-					switch_scr(cur_console, action - F_SCR);
-					break;
-				}
-				if (action >= F_FN && action <= L_FN) 
-					action |= FKEY;
-				return(action);
-			}
-		}
-		else {
-			if (metas)
-				action |= MKEY;
-			return(action);
+		break;
+	    case LSH:
+		shfts |= 1;
+		break;
+	    case RSH:
+		shfts |= 2;
+		break;
+	    case LCTR:
+		ctls |= 1;
+		break;
+	    case RCTR:
+		ctls |= 2;
+		break;
+	    case LALT:
+		alts |= 1;
+		break;
+	    case RALT:
+		alts |= 2;
+		break;
+	    case ASH:
+		agrs = 1;
+		break;
+	    case META:
+		metas = 1;
+		break;
+	    case NEXT:
+		switch_scr(cur_console, (get_scr_num() + 1) % MAXCONS);
+		break;
+	    case BTAB:
+		return(BKEY);
+	    default:
+		if (action >= F_SCR && action <= L_SCR) {
+		    switch_scr(cur_console, action - F_SCR);
+		    break;
 		}
+		if (action >= F_FN && action <= L_FN) 
+		    action |= FKEY;
+		return(action);
+	    }
 	}
-	goto next_code;
+	else {
+	    if (metas)
+		action |= MKEY;
+	    return(action);
+	}
+    }
+    goto next_code;
 }
 
 int 
 scmmap(dev_t dev, int offset, int nprot)
 {
-	if (offset > 0x20000 - PAGE_SIZE)
-		return -1;
-	return i386_btop((VIDEOMEM + offset));
+    if (offset > 0x20000 - PAGE_SIZE)
+	return -1;
+    return i386_btop((VIDEOMEM + offset));
 }
 
 static void 
 kbd_wait(void)
 {
-	int i = 1000;
+    int i = 1000;
 
-	while (i--) {
-		if ((inb(KB_STAT) & KB_READY) == 0) 
-			break;
-		DELAY (10);
-	}
+    while (i--) {
+	if ((inb(KB_STAT) & KB_READY) == 0) 
+	    break;
+	DELAY (10);
+    }
 }
 
 static void 
 kbd_cmd(u_char command)
 {
-	int retry = 5;
-	do {
-		int i = 100000;
+    int retry = 5;
+    do {
+	int i = 100000;
 
-		kbd_wait();
+	kbd_wait();
 #if ASYNCH
-		kbd_reply = 0;
-		outb(KB_DATA, command);
-		while (i--) {
-			if (kbd_reply == KB_ACK)
-				return;
-			if (kbd_reply == KB_RESEND)
-				break;
-		}
+	kbd_reply = 0;
+	outb(KB_DATA, command);
+	while (i--) {
+	    if (kbd_reply == KB_ACK)
+		return;
+	    if (kbd_reply == KB_RESEND)
+		break;
+	}
 #else
-		outb(KB_DATA, command);
-		while (i--) {
-			if (inb(KB_STAT) & KB_BUF_FULL) {
-				int val;
-				DELAY(10);
-				val = inb(KB_DATA);
-				if (val == KB_ACK)
-					return;
-				if (val == KB_RESEND)
-					break;
-			}
-		}
+	outb(KB_DATA, command);
+	while (i--) {
+	    if (inb(KB_STAT) & KB_BUF_FULL) {
+		int val;
+		DELAY(10);
+		val = inb(KB_DATA);
+		if (val == KB_ACK)
+		    return;
+		if (val == KB_RESEND)
+		    break;
+	    }
+	}
 #endif
-	} while (retry--);
+    } while (retry--);
 }
 
 static void 
 set_mode(scr_stat *scp)
 {
-	char *modetable;
-	char special_modetable[64];
-	int mode, font_size;
+    char *modetable;
+    char special_modetable[64];
+    int mode, font_size;
 
-	if (scp != cur_console)
-		return;
+    if (scp != cur_console)
+	return;
 
-	/* setup video hardware for the given mode */
-	switch (scp->mode) {
-	case M_VGA_M80x60: 
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x60;
-
-	case M_VGA_C80x60: 
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x60:	special_modetable[2]  = 0x08;
-		special_modetable[19] = 0x47;
-		goto special_480l;
-
-	case M_VGA_M80x30:
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x30;
-
-	case M_VGA_C80x30:
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x30:	special_modetable[19] = 0x4f;
-special_480l:	special_modetable[9] |= 0xc0;
-		special_modetable[16] = 0x08;
-		special_modetable[17] = 0x3e;
-		special_modetable[26] = 0xea;
-		special_modetable[28] = 0xdf; 
-		special_modetable[31] = 0xe7;
-		special_modetable[32] = 0x04;
-		modetable = special_modetable;
-		goto setup_mode;
-
-	case M_ENH_B80x43:
-		bcopyw(video_mode_ptr+(64*M_ENH_B80x25),&special_modetable, 64);
-		goto special_80x43;
-
-	case M_ENH_C80x43:
-		bcopyw(video_mode_ptr+(64*M_ENH_C80x25),&special_modetable, 64);
-special_80x43:	special_modetable[28] = 87;
-		goto special_80x50;
-
-	case M_VGA_M80x50: 
-		bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
-		goto special_80x50;
-
-	case M_VGA_C80x50:
-		bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
-special_80x50: 	special_modetable[2] = 8;
-		special_modetable[19] = 7;
-		modetable = special_modetable;
-		goto setup_mode;
-
-	case M_VGA_C40x25: case M_VGA_C80x25:	/* VGA TEXT MODES */
-	case M_VGA_M80x25: 
-	case M_B40x25:     case M_C40x25:	
-	case M_B80x25:     case M_C80x25:
-	case M_ENH_B40x25: case M_ENH_C40x25: 
-	case M_ENH_B80x25: case M_ENH_C80x25:
-
-		modetable = video_mode_ptr + (scp->mode * 64);
+    /* setup video hardware for the given mode */
+    switch (scp->mode) {
+    case M_VGA_M80x60: 
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x60;
+
+    case M_VGA_C80x60: 
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x60:
+	special_modetable[2]  = 0x08;
+	special_modetable[19] = 0x47;
+	goto special_480l;
+
+    case M_VGA_M80x30:
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x30;
+
+    case M_VGA_C80x30:
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x30:
+	special_modetable[19] = 0x4f;
+special_480l:
+	special_modetable[9] |= 0xc0;
+	special_modetable[16] = 0x08;
+	special_modetable[17] = 0x3e;
+	special_modetable[26] = 0xea;
+	special_modetable[28] = 0xdf; 
+	special_modetable[31] = 0xe7;
+	special_modetable[32] = 0x04;
+	modetable = special_modetable;
+	goto setup_mode;
+
+    case M_ENH_B80x43:
+	bcopyw(video_mode_ptr+(64*M_ENH_B80x25),&special_modetable, 64);
+	goto special_80x43;
+
+    case M_ENH_C80x43:
+	bcopyw(video_mode_ptr+(64*M_ENH_C80x25),&special_modetable, 64);
+special_80x43:  
+	special_modetable[28] = 87;
+	goto special_80x50;
+
+    case M_VGA_M80x50: 
+	bcopyw(video_mode_ptr+(64*M_VGA_M80x25),&special_modetable, 64);
+	goto special_80x50;
+
+    case M_VGA_C80x50:
+	bcopyw(video_mode_ptr+(64*M_VGA_C80x25),&special_modetable, 64);
+special_80x50:  
+	special_modetable[2] = 8;
+	special_modetable[19] = 7;
+	modetable = special_modetable;
+	goto setup_mode;
+
+    case M_VGA_C40x25: case M_VGA_C80x25:
+    case M_VGA_M80x25:
+    case M_B40x25:     case M_C40x25:
+    case M_B80x25:     case M_C80x25:
+    case M_ENH_B40x25: case M_ENH_C40x25:
+    case M_ENH_B80x25: case M_ENH_C80x25:
+
+	modetable = video_mode_ptr + (scp->mode * 64);
 setup_mode:
-		set_vgaregs(modetable);
-		font_size = *(modetable + 2);
-
-		/* set font type (size) */
-		switch (font_size) {
-		case 0x10:
-			outb(TSIDX, 0x03); outb(TSREG, 0x00);	/* font 0 */
-			scp->font = FONT_16;
-			break;
-		case 0x0E:
-			outb(TSIDX, 0x03); outb(TSREG, 0x05);	/* font 1 */
-			scp->font = FONT_14;
-			break;
-		default:
-		case 0x08:
-			outb(TSIDX, 0x03); outb(TSREG, 0x0A);	/* font 2 */
-			scp->font = FONT_8;
-			break;
-		}
-		break;
+	set_vgaregs(modetable);
+	font_size = *(modetable + 2);
+
+	/* set font type (size) */
+	switch (font_size) {
+	case 0x10:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x00);   /* font 0 */
+	    scp->font = FONT_16;
+	    break;
+	case 0x0E:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x05);   /* font 1 */
+	    scp->font = FONT_14;
+	    break;
+	default:
+	case 0x08:
+	    outb(TSIDX, 0x03); outb(TSREG, 0x0A);   /* font 2 */
+	    scp->font = FONT_8;
+	    break;
+	}
+	break;
 
-	case M_BG320:      case M_CG320:      case M_BG640:
-	case M_CG320_D:    case M_CG640_E:
-	case M_CG640x350:  case M_ENH_CG640:
-	case M_BG640x480:  case M_CG640x480:  case M_VGA_CG320:
+    case M_BG320:     case M_CG320:     case M_BG640:
+    case M_CG320_D:   case M_CG640_E:
+    case M_CG640x350: case M_ENH_CG640:
+    case M_BG640x480: case M_CG640x480: case M_VGA_CG320:
  
-		set_vgaregs(video_mode_ptr + (scp->mode * 64));
-		break;
+	set_vgaregs(video_mode_ptr + (scp->mode * 64));
+	break;
 
-	default:
-		/* call user defined function XXX */
-		break;
-	}
+    default:
+	/* call user defined function XXX */
+	break;
+    }
 
-	/* set border color for this (virtual) console */
-	set_border(scp->border);
-	return;
+    /* set border color for this (virtual) console */
+    set_border(scp->border);
+    return;
 }
 
-static void 
+void 
 set_border(int color)
 {
-	inb(crtc_addr+6); 				/* reset flip-flop */
-	outb(ATC, 0x11); outb(ATC, color); 
-	inb(crtc_addr+6); 				/* reset flip-flop */
-	outb(ATC, 0x20);				/* enable Palette */
+    inb(crtc_addr+6);               /* reset flip-flop */
+    outb(ATC, 0x11); outb(ATC, color); 
+    inb(crtc_addr+6);               /* reset flip-flop */
+    outb(ATC, 0x20);                /* enable Palette */
 }
 
 static void
 set_vgaregs(char *modetable)
 {
-	int i, s = splhigh();
+    int i, s = splhigh();
 
-	outb(TSIDX, 0x00); outb(TSREG, 0x01);	/* stop sequencer */
-	outb(TSIDX, 0x07); outb(TSREG, 0x00);	/* unlock registers */
-	for (i=0; i<4; i++) {			/* program sequencer */
-		outb(TSIDX, i+1); 
-		outb(TSREG, modetable[i+5]);
-	}
-	outb(MISC, modetable[9]);		/* set dot-clock */
-	outb(TSIDX, 0x00); outb(TSREG, 0x03);	/* start sequencer */
-	outb(crtc_addr, 0x11);
-	outb(crtc_addr+1, inb(crtc_addr+1) & 0x7F);
-	for (i=0; i<25; i++) {			/* program crtc */
-		outb(crtc_addr, i); 
-		if (i == 14 || i == 15)		/* no hardware cursor */
-			outb(crtc_addr+1, 0xff);
-		else
-			outb(crtc_addr+1, modetable[i+10]);
-	}
-	inb(crtc_addr+6); 			/* reset flip-flop */
-	for (i=0; i<20; i++) {			/* program attribute ctrl */
-		outb(ATC, i); 
-		outb(ATC, modetable[i+35]);
-	}
-	for (i=0; i<9; i++) {			/* program graph data ctrl */
-		outb(GDCIDX, i); 
-		outb(GDCREG, modetable[i+55]);
-	}
-	inb(crtc_addr+6); 			/* reset flip-flop */
-	outb(ATC ,0x20);			/* enable palette */
-	splx(s);
+    outb(TSIDX, 0x00); outb(TSREG, 0x01);   	/* stop sequencer */
+    outb(TSIDX, 0x07); outb(TSREG, 0x00);   	/* unlock registers */
+    for (i=0; i<4; i++) {           		/* program sequencer */
+	outb(TSIDX, i+1); 
+	outb(TSREG, modetable[i+5]);
+    }
+    outb(MISC, modetable[9]);       		/* set dot-clock */
+    outb(TSIDX, 0x00); outb(TSREG, 0x03);   	/* start sequencer */
+    outb(crtc_addr, 0x11);
+    outb(crtc_addr+1, inb(crtc_addr+1) & 0x7F);
+    for (i=0; i<25; i++) {          		/* program crtc */
+	outb(crtc_addr, i); 
+	if (i == 14 || i == 15)     		/* no hardware cursor */
+	    outb(crtc_addr+1, 0xff);
+	else
+	    outb(crtc_addr+1, modetable[i+10]);
+    }
+    inb(crtc_addr+6);           		/* reset flip-flop */
+    for (i=0; i<20; i++) {          		/* program attribute ctrl */
+	outb(ATC, i); 
+	outb(ATC, modetable[i+35]);
+    }
+    for (i=0; i<9; i++) {           		/* program graph data ctrl */
+	outb(GDCIDX, i); 
+	outb(GDCREG, modetable[i+55]);
+    }
+    inb(crtc_addr+6);           		/* reset flip-flop */
+    outb(ATC ,0x20);            		/* enable palette */
+    splx(s);
 }
 
 static void
 set_font_mode()
 {
-	/* setup vga for loading fonts (graphics plane mode) */
-	inb(crtc_addr+6);				/* reset flip/flop */
-	outb(ATC, 0x30); outb(ATC, 0x01);
+    /* setup vga for loading fonts (graphics plane mode) */
+    inb(crtc_addr+6);
+    outb(ATC, 0x30); outb(ATC, 0x01);
 #if SLOW_VGA
-	outb(TSIDX, 0x02); outb(TSREG, 0x04);
-	outb(TSIDX, 0x04); outb(TSREG, 0x06);
-	outb(GDCIDX, 0x04); outb(GDCREG, 0x02);
-	outb(GDCIDX, 0x05); outb(GDCREG, 0x00);
-	outb(GDCIDX, 0x06); outb(GDCREG, 0x05);	
+    outb(TSIDX, 0x02); outb(TSREG, 0x04);
+    outb(TSIDX, 0x04); outb(TSREG, 0x06);
+    outb(GDCIDX, 0x04); outb(GDCREG, 0x02);
+    outb(GDCIDX, 0x05); outb(GDCREG, 0x00);
+    outb(GDCIDX, 0x06); outb(GDCREG, 0x05); 
 #else
-	outw(TSIDX, 0x0402);
-	outw(TSIDX, 0x0604);
-	outw(GDCIDX, 0x0204);
-	outw(GDCIDX, 0x0005);
-	outw(GDCIDX, 0x0506);				/* addr = a0000, 64kb */
+    outw(TSIDX, 0x0402);
+    outw(TSIDX, 0x0604);
+    outw(GDCIDX, 0x0204);
+    outw(GDCIDX, 0x0005);
+    outw(GDCIDX, 0x0506);               /* addr = a0000, 64kb */
 #endif
 }
 
 static void
 set_normal_mode()
 {
-	int s = splhigh();
+    int s = splhigh();
 
-	/* setup vga for normal operation mode again */
-	inb(crtc_addr+6);				/* reset flip/flop */
-	outb(ATC, 0x30); outb(ATC, 0x0C);
+    /* setup vga for normal operation mode again */
+    inb(crtc_addr+6);
+    outb(ATC, 0x30); outb(ATC, 0x0C);
 #if SLOW_VGA
-	outb(TSIDX, 0x02); outb(TSREG, 0x03);
-	outb(TSIDX, 0x04); outb(TSREG, 0x02);
-	outb(GDCIDX, 0x04); outb(GDCREG, 0x00);
-	outb(GDCIDX, 0x05); outb(GDCREG, 0x10);
-	if (crtc_addr == MONO_BASE) {
-		outb(GDCIDX, 0x06); outb(GDCREG, 0x0A);	/* addr = b0000, 32kb */
-	}
-	else {
-		outb(GDCIDX, 0x06); outb(GDCREG, 0x0E);	/* addr = b8000, 32kb */
-	}
+    outb(TSIDX, 0x02); outb(TSREG, 0x03);
+    outb(TSIDX, 0x04); outb(TSREG, 0x02);
+    outb(GDCIDX, 0x04); outb(GDCREG, 0x00);
+    outb(GDCIDX, 0x05); outb(GDCREG, 0x10);
+    if (crtc_addr == MONO_BASE) {
+	outb(GDCIDX, 0x06); outb(GDCREG, 0x0A); /* addr = b0000, 32kb */
+    }
+    else {
+	outb(GDCIDX, 0x06); outb(GDCREG, 0x0E); /* addr = b8000, 32kb */
+    }
 #else
-	outw(TSIDX, 0x0302);
-	outw(TSIDX, 0x0204);
-	outw(GDCIDX, 0x0004);
-	outw(GDCIDX, 0x1005);
-	if (crtc_addr == MONO_BASE)
-		outw(GDCIDX, 0x0A06);			/* addr = b0000, 32kb */
-	else
-		outw(GDCIDX, 0x0E06);			/* addr = b8000, 32kb */
+    outw(TSIDX, 0x0302);
+    outw(TSIDX, 0x0204);
+    outw(GDCIDX, 0x0004);
+    outw(GDCIDX, 0x1005);
+    if (crtc_addr == MONO_BASE)
+	outw(GDCIDX, 0x0A06);           /* addr = b0000, 32kb */
+    else
+	outw(GDCIDX, 0x0E06);           /* addr = b8000, 32kb */
 #endif
-	splx(s);
+    splx(s);
 }
 
 static void 
 copy_font(int operation, int font_type, char* font_image)
 {
-	int ch, line, segment, fontsize;
-	u_char val;
-
-	switch (font_type) {
-	default:
-	case FONT_8:
-		segment = 0x8000;
-		fontsize = 8;
-		break;
-	case FONT_14:
-		segment = 0x4000;
-		fontsize = 14;
-		break;
-	case FONT_16:
-		segment = 0x0000;
-		fontsize = 16;
-		break;
-	}
-	outb(TSIDX, 0x01); val = inb(TSREG); 		/* disable screen */
-	outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
-	set_font_mode();
-	for (ch=0; ch < 256; ch++) 
-	    for (line=0; line < fontsize; line++) 
-		if (operation)
-		    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line) =
-					font_image[(ch*fontsize)+line];	
-		else
-		    font_image[(ch*fontsize)+line] =
-		    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line);
-	set_normal_mode();
-	outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);	/* enable screen */
+    int ch, line, segment, fontsize;
+    u_char val;
+
+    switch (font_type) {
+    default:
+    case FONT_8:
+	segment = 0x8000;
+	fontsize = 8;
+	break;
+    case FONT_14:
+	segment = 0x4000;
+	fontsize = 14;
+	break;
+    case FONT_16:
+	segment = 0x0000;
+	fontsize = 16;
+	break;
+    }
+    outb(TSIDX, 0x01); val = inb(TSREG);        /* disable screen */
+    outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+    set_font_mode();
+    for (ch=0; ch < 256; ch++) 
+	for (line=0; line < fontsize; line++) 
+	if (operation)
+	    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line) =
+		    font_image[(ch*fontsize)+line]; 
+	else
+	    font_image[(ch*fontsize)+line] =
+	    *(char *)pa_to_va(VIDEOMEM+(segment)+(ch*32)+line);
+    set_normal_mode();
+    outb(TSIDX, 0x01); outb(TSREG, val & 0xDF); /* enable screen */
 }
 
 static void
 draw_mouse_image(scr_stat *scp)
 {
-	caddr_t address;
-	int i, font_size;
-	char *font_buffer;
-	u_short buffer[32];
-	u_short xoffset, yoffset;
-	u_short *crt_pos = Crtat + (scp->mouse_pos - scp->scr_buf);
-
-	xoffset = scp->mouse_xpos % 8;
-	switch (scp->font) {
-	default:
-	case FONT_8:
-		font_size = 8;
-		font_buffer = font_8;
-		yoffset = scp->mouse_ypos % 8;
-		address = (caddr_t)VIDEOMEM+0x8000;
-		break;
-	case FONT_14:
-		font_size = 14;
-		font_buffer = font_14;
-		yoffset = scp->mouse_ypos % 14;
-		address = (caddr_t)VIDEOMEM+0x4000;
-		break;
-	case FONT_16:
-		font_size = 16;
-		font_buffer = font_16;
-		yoffset = scp->mouse_ypos % 16;
-		address = (caddr_t)VIDEOMEM;
-		break;
-	}
+    caddr_t address;
+    int i, font_size;
+    char *font_buffer;
+    u_short buffer[32];
+    u_short xoffset, yoffset;
+    u_short *crt_pos = Crtat + (scp->mouse_pos - scp->scr_buf);
+
+    xoffset = scp->mouse_xpos % 8;
+    switch (scp->font) {
+    default:
+    case FONT_8:
+	font_size = 8;
+	font_buffer = font_8;
+	yoffset = scp->mouse_ypos % 8;
+	address = (caddr_t)VIDEOMEM+0x8000;
+	break;
+    case FONT_14:
+	font_size = 14;
+	font_buffer = font_14;
+	yoffset = scp->mouse_ypos % 14;
+	address = (caddr_t)VIDEOMEM+0x4000;
+	break;
+    case FONT_16:
+	font_size = 16;
+	font_buffer = font_16;
+	yoffset = scp->mouse_ypos % 16;
+	address = (caddr_t)VIDEOMEM;
+	break;
+    }
 
-	bcopyw(font_buffer+((*(scp->mouse_pos) & 0xff)*font_size),
-	       &scp->mouse_cursor[0], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+1) & 0xff)*font_size),
-	       &scp->mouse_cursor[32], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize) & 0xff)*font_size),
-	       &scp->mouse_cursor[64], font_size);
-	bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize+1) & 0xff)*font_size),
-	       &scp->mouse_cursor[96], font_size);
-
-	for (i=0; i<font_size; i++) {
-		buffer[i] = 
-			scp->mouse_cursor[i]<<8 | scp->mouse_cursor[i+32];
-		buffer[i+font_size] = 
-			scp->mouse_cursor[i+64]<<8 | scp->mouse_cursor[i+96];
-	}
-	for (i=0; i<16; i++) {
-		buffer[i+yoffset] =
-			( buffer[i+yoffset] 
-			 & ~(mouse_and_mask[i] >> xoffset))
-			| (mouse_or_mask[i] >> xoffset);
-	}
-	for (i=0; i<font_size; i++) {
-		scp->mouse_cursor[i] = (buffer[i] & 0xff00) >> 8;
-		scp->mouse_cursor[i+32] = buffer[i] & 0xff;
-		scp->mouse_cursor[i+64] = (buffer[i+font_size] & 0xff00) >> 8;
-		scp->mouse_cursor[i+96] = buffer[i+font_size] & 0xff;
-	}
-	/*
-	 * if we didn't update entire screen, restore old mouse position
-	 * and check if we overwrote the cursor location..
-	 */
-	if ((scp->status & UPDATE_MOUSE) && !(scp->status & UPDATE_SCREEN)) {
-	    u_short *ptr = scp->scr_buf + (scp->mouse_oldpos - Crtat);
-	    if (crt_pos != scp->mouse_oldpos) {
-		*(scp->mouse_oldpos) = scp->mouse_saveunder[0];
-		*(scp->mouse_oldpos+1) = scp->mouse_saveunder[1];
-		*(scp->mouse_oldpos+scp->xsize) = scp->mouse_saveunder[2];
-		*(scp->mouse_oldpos+scp->xsize+1) = scp->mouse_saveunder[3];
-	    }
-	    scp->mouse_saveunder[0] = *(scp->mouse_pos);
-	    scp->mouse_saveunder[1] = *(scp->mouse_pos+1);
-	    scp->mouse_saveunder[2] = *(scp->mouse_pos+scp->xsize);
-	    scp->mouse_saveunder[3] = *(scp->mouse_pos+scp->xsize+1);
-	    if ((scp->cursor_pos == (ptr)) ||
-		(scp->cursor_pos == (ptr+1)) ||
-		(scp->cursor_pos == (ptr+scp->xsize)) ||
-		(scp->cursor_pos == (ptr+scp->xsize+1)) ||
-		(scp->cursor_pos == (scp->mouse_pos)) ||
-		(scp->cursor_pos == (scp->mouse_pos+1)) ||
-		(scp->cursor_pos == (scp->mouse_pos+scp->xsize)) ||
-		(scp->cursor_pos == (scp->mouse_pos+scp->xsize+1)))
-		    scp->status &= ~CURSOR_SHOWN;
-	}
-	scp->mouse_oldpos = crt_pos;
-	while (!(inb(crtc_addr+6) & 0x08)) /* wait for vertical retrace */ ;
-	*(crt_pos) = *(scp->mouse_pos)&0xff00|0xd0;
-	*(crt_pos+1) = *(scp->mouse_pos+1)&0xff00|0xd1;
-	*(crt_pos+scp->xsize) = *(scp->mouse_pos+scp->xsize)&0xff00|0xd2;
-	*(crt_pos+scp->xsize+1) = *(scp->mouse_pos+scp->xsize+1)&0xff00|0xd3;
-	set_font_mode();
-	bcopy(scp->mouse_cursor,
-	      (char *)pa_to_va(address) + 0xd0 * 32, 128);
-	set_normal_mode();
+    bcopyw(font_buffer+((*(scp->mouse_pos) & 0xff)*font_size),
+	   &scp->mouse_cursor[0], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+1) & 0xff)*font_size),
+	   &scp->mouse_cursor[32], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize) & 0xff)*font_size),
+	   &scp->mouse_cursor[64], font_size);
+    bcopyw(font_buffer+((*(scp->mouse_pos+scp->xsize+1) & 0xff)*font_size),
+	   &scp->mouse_cursor[96], font_size);
+
+    for (i=0; i<font_size; i++) {
+	buffer[i] = scp->mouse_cursor[i]<<8 | scp->mouse_cursor[i+32];
+	buffer[i+font_size]=scp->mouse_cursor[i+64]<<8|scp->mouse_cursor[i+96];
+    }
+    for (i=0; i<16; i++) {
+	buffer[i+yoffset] =
+	    ( buffer[i+yoffset] & ~(mouse_and_mask[i] >> xoffset))
+	    | (mouse_or_mask[i] >> xoffset);
+    }
+    for (i=0; i<font_size; i++) {
+	scp->mouse_cursor[i] = (buffer[i] & 0xff00) >> 8;
+	scp->mouse_cursor[i+32] = buffer[i] & 0xff;
+	scp->mouse_cursor[i+64] = (buffer[i+font_size] & 0xff00) >> 8;
+	scp->mouse_cursor[i+96] = buffer[i+font_size] & 0xff;
+    }
+    /*
+     * if we didn't update entire screen, restore old mouse position
+     * and check if we overwrote the cursor location..
+     */
+    if ((scp->status & UPDATE_MOUSE) && !(scp->status & UPDATE_SCREEN)) {
+	u_short *ptr = scp->scr_buf + (scp->mouse_oldpos - Crtat);
+
+	if (crt_pos != scp->mouse_oldpos) {
+	    *(scp->mouse_oldpos) = scp->mouse_saveunder[0];
+	    *(scp->mouse_oldpos+1) = scp->mouse_saveunder[1];
+	    *(scp->mouse_oldpos+scp->xsize) = scp->mouse_saveunder[2];
+	    *(scp->mouse_oldpos+scp->xsize+1) = scp->mouse_saveunder[3];
+	}
+	scp->mouse_saveunder[0] = *(scp->mouse_pos);
+	scp->mouse_saveunder[1] = *(scp->mouse_pos+1);
+	scp->mouse_saveunder[2] = *(scp->mouse_pos+scp->xsize);
+	scp->mouse_saveunder[3] = *(scp->mouse_pos+scp->xsize+1);
+	if ((scp->cursor_pos == (ptr)) ||
+	    (scp->cursor_pos == (ptr+1)) ||
+	    (scp->cursor_pos == (ptr+scp->xsize)) ||
+	    (scp->cursor_pos == (ptr+scp->xsize+1)) ||
+	    (scp->cursor_pos == (scp->mouse_pos)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+1)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+scp->xsize)) ||
+	    (scp->cursor_pos == (scp->mouse_pos+scp->xsize+1)))
+	    scp->status &= ~CURSOR_SHOWN;
+    }
+    scp->mouse_oldpos = crt_pos;
+    while (!(inb(crtc_addr+6) & 0x08)) /* wait for vertical retrace */ ;
+    *(crt_pos) = *(scp->mouse_pos)&0xff00|0xd0;
+    *(crt_pos+1) = *(scp->mouse_pos+1)&0xff00|0xd1;
+    *(crt_pos+scp->xsize) = *(scp->mouse_pos+scp->xsize)&0xff00|0xd2;
+    *(crt_pos+scp->xsize+1) = *(scp->mouse_pos+scp->xsize+1)&0xff00|0xd3;
+    set_font_mode();
+    bcopy(scp->mouse_cursor, (char *)pa_to_va(address) + 0xd0 * 32, 128);
+    set_normal_mode();
 }
 
 static void 
 save_palette(void)
 {
-	int i;
+    int i;
 
-	outb(PALRADR, 0x00);	
-	for (i=0x00; i<0x300; i++)            
-		palette[i] = inb(PALDATA);
-	inb(crtc_addr+6);			/* reset flip/flop */
+    outb(PALRADR, 0x00);    
+    for (i=0x00; i<0x300; i++)            
+	palette[i] = inb(PALDATA);
+    inb(crtc_addr+6);           /* reset flip/flop */
 }
 
-static void 
+void 
 load_palette(void)
 {
-	int i;
-
-	outb(PIXMASK, 0xFF);			/* no pixelmask */
-	outb(PALWADR, 0x00);	
-	for (i=0x00; i<0x300; i++)            
-		 outb(PALDATA, palette[i]);
-	inb(crtc_addr+6);			/* reset flip/flop */
-	outb(ATC, 0x20);			/* enable palette */
+    int i;
+
+    outb(PIXMASK, 0xFF);            /* no pixelmask */
+    outb(PALWADR, 0x00);    
+    for (i=0x00; i<0x300; i++)            
+	 outb(PALDATA, palette[i]);
+    inb(crtc_addr+6);           /* reset flip/flop */
+    outb(ATC, 0x20);            /* enable palette */
 }
 
 static void
 do_bell(scr_stat *scp, int pitch, int duration)
 {
-	if (scp == cur_console) {
-		if (configuration & VISUAL_BELL) {
-			if (blink_in_progress)
-				return;
-			blink_in_progress = 4;
-			blink_screen(scp);
-			timeout((timeout_func_t)blink_screen, scp, hz/10);
-		}	
-		else
-			sysbeep(pitch, duration);
-	}
+    if (scp == cur_console) {
+	if (configuration & VISUAL_BELL) {
+	    if (blink_in_progress)
+		return;
+	    blink_in_progress = 4;
+	    blink_screen(scp);
+	    timeout((timeout_func_t)blink_screen, scp, hz/10);
+	}   
+	else
+	    sysbeep(pitch, duration);
+    }
 }
 
 static void
 blink_screen(scr_stat *scp)
 {
-	if (blink_in_progress > 1) {
-		if (blink_in_progress & 1)
-			fillw(kernel_default.std_attr | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-		else
-			fillw(kernel_default.rev_attr | scr_map[0x20],
-			      Crtat, scp->xsize * scp->ysize);
-		blink_in_progress--;
-		timeout((timeout_func_t)blink_screen, scp, hz/10);
-	}
-	else {
-		scp->status |= UPDATE_SCREEN;
-		blink_in_progress = FALSE;
-		if (delayed_next_scr)
-			switch_scr(scp, delayed_next_scr - 1);
-	}
+    if (blink_in_progress > 1) {
+	if (blink_in_progress & 1)
+	    fillw(kernel_default.std_attr | scr_map[0x20],
+		  Crtat, scp->xsize * scp->ysize);
+	else
+	    fillw(kernel_default.rev_attr | scr_map[0x20],
+		  Crtat, scp->xsize * scp->ysize);
+	blink_in_progress--;
+	timeout((timeout_func_t)blink_screen, scp, hz/10);
+    }
+    else {
+	scp->status |= UPDATE_SCREEN;
+	blink_in_progress = FALSE;
+	if (delayed_next_scr)
+	    switch_scr(scp, delayed_next_scr - 1);
+    }
 }
 
 #endif /* NSC */
diff --git a/sys/isa/syscons.h b/sys/isa/syscons.h
new file mode 100644
index 0000000..546b2de
--- /dev/null
+++ b/sys/isa/syscons.h
@@ -0,0 +1,203 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+/* vm things */
+#define	ISMAPPED(pa, width) \
+	(((pa) <= (u_long)0x1000 - (width)) \
+	 || ((pa) >= 0xa0000 && (pa) <= 0x100000 - (width)))
+#define	pa_to_va(pa)	(KERNBASE + (pa))	/* works if ISMAPPED(pa...) */
+
+/* printable chars */
+#define PRINTABLE(ch)	(ch>0x1B || (ch>0x0d && ch<0x1b) || ch<0x07)
+
+/* status flags */
+#define LOCK_KEY_MASK	0x0000F
+#define LED_MASK	0x00007
+#define UNKNOWN_MODE	0x00010
+#define KBD_RAW_MODE	0x00020
+#define SWITCH_WAIT_REL	0x00040
+#define SWITCH_WAIT_ACQ	0x00080
+#define BUFFER_SAVED	0x00100
+#define CURSOR_ENABLED 	0x00200
+#define CURSOR_SHOWN 	0x00400
+#define MOUSE_ENABLED	0x00800
+#define UPDATE_MOUSE	0x01000
+#define UPDATE_SCREEN	0x02000
+
+/* configuration flags */
+#define VISUAL_BELL	0x00001
+#define BLINK_CURSOR	0x00002
+#define CHAR_CURSOR	0x00004
+
+/* video hardware memory addresses */
+#define VIDEOMEM	0x000A0000
+
+/* misc defines */
+#define FALSE		0
+#define TRUE		1
+#define MAX_ESC_PAR 	5
+#define	LOAD		1
+#define SAVE		0
+#define	COL		80
+#define	ROW		25
+#define BELL_DURATION	5
+#define BELL_PITCH	800
+#define TIMER_FREQ	1193182			/* should be in isa.h */
+#define CONSOLE_BUFSIZE 1024
+#define PCBURST		128
+#define FONT_8		0x001
+#define FONT_14		0x002
+#define FONT_16		0x004
+#define HISTORY_SIZE	100*80
+
+/* defines related to hardware addresses */
+#define	MONO_BASE	0x3B4			/* crt controller base mono */
+#define	COLOR_BASE	0x3D4			/* crt controller base color */
+#define MISC		0x3C2			/* misc output register */
+#define ATC		IO_VGA+0x00		/* attribute controller */
+#define TSIDX		IO_VGA+0x04		/* timing sequencer idx */
+#define TSREG		IO_VGA+0x05		/* timing sequencer data */
+#define PIXMASK		IO_VGA+0x06		/* pixel write mask */
+#define PALRADR		IO_VGA+0x07		/* palette read address */
+#define PALWADR		IO_VGA+0x08		/* palette write address */
+#define PALDATA		IO_VGA+0x09		/* palette data register */
+#define GDCIDX		IO_VGA+0x0E		/* graph data controller idx */
+#define GDCREG		IO_VGA+0x0F		/* graph data controller data */
+
+/* special characters */
+#define cntlc	0x03	
+#define cntld	0x04
+#define bs	0x08
+#define lf	0x0a
+#define cr	0x0d	
+#define del	0x7f	
+
+typedef struct term_stat {
+	int 		esc;			/* processing escape sequence */
+	int 		num_param;		/* # of parameters to ESC */
+	int	 	last_param;		/* last parameter # */
+	int 		param[MAX_ESC_PAR];	/* contains ESC parameters */
+	int 		cur_attr;		/* current attributes */
+	int 		std_attr;		/* normal attributes */
+	int 		rev_attr;		/* reverse attributes */
+} term_stat;
+
+typedef struct scr_stat {
+	u_short 	*scr_buf;		/* buffer when off screen */
+	int 		xpos;			/* current X position */
+	int 		ypos;			/* current Y position */
+	int 		xsize;			/* X size */
+	int 		ysize;			/* Y size */
+	term_stat 	term;			/* terminal emulation stuff */
+	int	 	status;			/* status (bitfield) */
+	u_short 	*cursor_pos;		/* cursor buffer position */
+	u_short		cursor_saveunder;	/* saved chars under cursor */
+	char		cursor_start;		/* cursor start line # */
+	char		cursor_end;		/* cursor end line # */
+	u_short		*mouse_pos;		/* mouse buffer position */
+	u_short		*mouse_oldpos;		/* mouse old buffer position */
+	u_short		mouse_saveunder[4];	/* saved chars under mouse */
+	short		mouse_xpos;		/* mouse x coordinate */
+	short		mouse_ypos;		/* mouse y coordinate */
+	u_char		mouse_cursor[128];	/* mouse cursor bitmap store */
+	u_short		bell_duration;
+	u_short		bell_pitch;
+	u_char		border;			/* border color */
+	u_char	 	mode;			/* mode */
+	u_char		font;			/* font on this screen */
+	pid_t 		pid;			/* pid of controlling proc */
+	struct proc 	*proc;			/* proc* of controlling proc */
+	struct vt_mode 	smode;			/* switch mode */
+	u_short		*history;		/* circular history buffer */
+	u_short		*history_head;		/* current head position */
+	u_short		*history_pos;		/* position shown on screen */
+	u_short		*history_save;		/* save area index */
+	int		history_size;		/* size of history buffer */
+#if NAPM > 0
+	struct apmhook  r_hook;			/* reconfiguration support */
+#endif
+} scr_stat;
+
+typedef struct default_attr {
+	int             std_attr;               /* normal attributes */
+	int 		rev_attr;		/* reverse attributes */
+} default_attr;
+
+/* function prototypes */
+int scprobe(struct isa_device *dev);
+int scattach(struct isa_device *dev);
+int scopen(dev_t dev, int flag, int mode, struct proc *p);
+int scclose(dev_t dev, int flag, int mode, struct proc *p);
+int scread(dev_t dev, struct uio *uio, int flag);
+int scwrite(dev_t dev, struct uio *uio, int flag);
+int scparam(struct tty *tp, struct termios *t);
+int scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p);
+void scxint(dev_t dev);
+void scstart(struct tty *tp);
+void pccnprobe(struct consdev *cp);
+void pccninit(struct consdev *cp);
+void pccnputc(dev_t dev, char c);
+int pccngetc(dev_t dev);
+int pccncheckc(dev_t dev);
+void scintr(int unit);
+int pcmmap(dev_t dev, int offset, int nprot);
+static void scinit(void);
+static u_int scgetc(int noblock);
+static struct tty *get_tty_ptr(dev_t dev);
+static scr_stat *get_scr_stat(dev_t dev);
+static scr_stat *alloc_scp();
+static void init_scp(scr_stat *scp);
+static int get_scr_num();
+static void scrn_timer();
+static void clear_screen(scr_stat *scp);
+static int switch_scr(scr_stat *scp, u_int next_scr);
+static void exchange_scr(void);
+static inline void move_crsr(scr_stat *scp, int x, int y);
+static void scan_esc(scr_stat *scp, u_char c);
+static inline void draw_cursor(scr_stat *scp, int show);
+static void ansi_put(scr_stat *scp, u_char *buf, int len);
+static u_char *get_fstr(u_int c, u_int *len);
+static void update_leds(int which);
+static void history_to_screen(scr_stat *scp);
+static int history_up_line(scr_stat *scp);
+static int history_down_line(scr_stat *scp);
+static void kbd_wait(void);
+static void kbd_cmd(u_char command);
+static void set_mode(scr_stat *scp);
+       void set_border(int color);
+static void set_vgaregs(char *modetable);
+static void set_font_mode();
+static void set_normal_mode();
+static void copy_font(int operation, int font_type, char* font_image);
+static void draw_mouse_image(scr_stat *scp);
+static void save_palette(void);
+       void load_palette(void);
+static void do_bell(scr_stat *scp, int pitch, int duration);
+static void blink_screen(scr_stat *scp);
diff --git a/sys/modules/Makefile b/sys/modules/Makefile
index 3d98fa7..e6f2d66 100644
--- a/sys/modules/Makefile
+++ b/sys/modules/Makefile
@@ -1,7 +1,7 @@
-#	$Id: Makefile,v 1.6 1994/10/16 20:39:52 sos Exp $
+#	$Id: Makefile,v 1.7 1995/01/30 14:21:46 ugen Exp $
 
 SUBDIR=	cd9660 coff fdesc ibcs2 ip_mroute_mod ipfw kernfs msdos nfs nullfs \
-	portal procfs socksys umapfs union
+	portal procfs socksys syscons umapfs union
 #
 # Doesn't work:
 # mfs
diff --git a/sys/modules/syscons/Makefile b/sys/modules/syscons/Makefile
new file mode 100644
index 0000000..edd608e
--- /dev/null
+++ b/sys/modules/syscons/Makefile
@@ -0,0 +1,5 @@
+#	$Id$
+
+SUBDIR=	blank fade green snake star
+
+.include <bsd.subdir.mk>
diff --git a/sys/modules/syscons/blank/Makefile b/sys/modules/syscons/blank/Makefile
new file mode 100644
index 0000000..c920cf4
--- /dev/null
+++ b/sys/modules/syscons/blank/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	blank_saver_mod
+SRCS= 	blank_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/syscons/blank/blank_saver.c b/sys/modules/syscons/blank/blank_saver.c
new file mode 100644
index 0000000..9362c0b
--- /dev/null
+++ b/sys/modules/syscons/blank/blank_saver.c
@@ -0,0 +1,81 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("blank_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+blank_saver(int blank)
+{
+	u_char val;
+	if (blank) {
+		scrn_blanked = 1;
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+	}
+	else {
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
+		scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = blank_saver;
+	uprintf("blank screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("blank screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/modules/syscons/fade/Makefile b/sys/modules/syscons/fade/Makefile
new file mode 100644
index 0000000..610a195
--- /dev/null
+++ b/sys/modules/syscons/fade/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	fade_saver_mod
+SRCS= 	fade_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/syscons/fade/fade_saver.c b/sys/modules/syscons/fade/fade_saver.c
new file mode 100644
index 0000000..a58eaa0
--- /dev/null
+++ b/sys/modules/syscons/fade/fade_saver.c
@@ -0,0 +1,96 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("fade_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+fade_saver(int blank)
+{
+	static int count = 0;
+	int i;
+
+	if (blank) {
+		scrn_blanked = 1;
+		if (count < 64) {
+			outb(PIXMASK, 0xFF);		/* no pixelmask */
+			outb(PALWADR, 0x00);
+			outb(PALDATA, 0);
+			outb(PALDATA, 0);
+			outb(PALDATA, 0);
+			for (i = 3; i < 768; i++) {
+				if (palette[i] - count > 15)
+					outb(PALDATA, palette[i]-count);
+				else
+					outb(PALDATA, 15);
+			}
+			inb(crtc_addr+6);		/* reset flip/flop */
+			outb(ATC, 0x20);		/* enable palette */
+			count++;
+		}
+	}
+	else {
+		load_palette();
+		count = scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = fade_saver;
+	uprintf("fade screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("fade screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/modules/syscons/green/Makefile b/sys/modules/syscons/green/Makefile
new file mode 100644
index 0000000..9c1ae14
--- /dev/null
+++ b/sys/modules/syscons/green/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	green_saver_mod
+SRCS= 	green_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/syscons/green/green_saver.c b/sys/modules/syscons/green/green_saver.c
new file mode 100644
index 0000000..e6ed074
--- /dev/null
+++ b/sys/modules/syscons/green/green_saver.c
@@ -0,0 +1,85 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("green_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+green_saver(int blank)
+{
+	u_char val;
+	if (blank) {
+		scrn_blanked = 1;
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val | 0x20);
+		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
+		outb(crtc_addr + 1, val & ~0x80);
+	}
+	else {
+		outb(TSIDX, 0x01); val = inb(TSREG); 
+		outb(TSIDX, 0x01); outb(TSREG, val & 0xDF);
+		outb(crtc_addr, 0x17); val = inb(crtc_addr + 1);
+		outb(crtc_addr + 1, val | 0x80);
+		scrn_blanked = 0;
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = green_saver;
+	uprintf("green screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("green screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/modules/syscons/saver.h b/sys/modules/syscons/saver.h
new file mode 100644
index 0000000..a51c72c
--- /dev/null
+++ b/sys/modules/syscons/saver.h
@@ -0,0 +1,16 @@
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/tty.h>
+#include <i386/include/pc/display.h>
+#include <i386/include/console.h>
+#include <i386/i386/cons.h>
+#include <i386/isa/isa.h>
+#include <i386/isa/isa_device.h>
+#include <i386/isa/syscons.h>
+
+extern scr_stat	*cur_console;
+extern u_short	*Crtat;
+extern u_int	crtc_addr;
+extern char	scr_map[];
+extern int	scrn_blanked;
+extern char	*palette;
diff --git a/sys/modules/syscons/snake/Makefile b/sys/modules/syscons/snake/Makefile
new file mode 100644
index 0000000..bc8b2b2
--- /dev/null
+++ b/sys/modules/syscons/snake/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	snake_saver_mod
+SRCS= 	snake_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/syscons/snake/snake_saver.c b/sys/modules/syscons/snake/snake_saver.c
new file mode 100644
index 0000000..1974980
--- /dev/null
+++ b/sys/modules/syscons/snake/snake_saver.c
@@ -0,0 +1,121 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("snake_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+static void 
+snake_saver(int blank)
+{
+	const char	saves[] = {"FreeBSD-2.1"};
+	static u_char	*savs[sizeof(saves)-1];
+	static int	dirx, diry;
+	int		f;
+	scr_stat	*scp = cur_console;
+
+	if (blank) {
+		if (!scrn_blanked) {
+			fillw((FG_LIGHTGREY|BG_BLACK)<<8 | scr_map[0x20],
+			      Crtat, scp->xsize * scp->ysize);
+			set_border(0);
+			dirx = (scp->xpos ? 1 : -1);
+			diry = (scp->ypos ?
+				scp->xsize : -scp->xsize);
+			for (f=0; f< sizeof(saves)-1; f++)
+				savs[f] = (u_char *)Crtat + 2 *
+					  (scp->xpos+scp->ypos*scp->xsize);
+			*(savs[0]) = scr_map[*saves];
+			f = scp->ysize * scp->xsize + 5;
+			outb(crtc_addr, 14);
+			outb(crtc_addr+1, f >> 8);
+			outb(crtc_addr, 15);
+			outb(crtc_addr+1, f & 0xff);
+			scrn_blanked = 1;
+		}
+		if (scrn_blanked++ < 4) 
+			return;
+		scrn_blanked = 1;
+		*(savs[sizeof(saves)-2]) = scr_map[0x20];
+		for (f=sizeof(saves)-2; f > 0; f--)
+			savs[f] = savs[f-1];
+		f = (savs[0] - (u_char *)Crtat) / 2;
+		if ((f % scp->xsize) == 0 ||
+		    (f % scp->xsize) == scp->xsize - 1 ||
+		    (random() % 50) == 0)
+			dirx = -dirx;
+		if ((f / scp->xsize) == 0 ||
+		    (f / scp->xsize) == scp->ysize - 1 ||
+		    (random() % 20) == 0)
+			diry = -diry;
+		savs[0] += 2*dirx + 2*diry;
+		for (f=sizeof(saves)-2; f>=0; f--)
+			*(savs[f]) = scr_map[saves[f]];
+	}
+	else {
+		if (scrn_blanked) {
+			set_border(scp->border);
+			scrn_blanked = 0;
+			scp->status |= UPDATE_SCREEN;
+		}
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = snake_saver;
+	uprintf("snake screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("snake screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/sys/modules/syscons/star/Makefile b/sys/modules/syscons/star/Makefile
new file mode 100644
index 0000000..fc2ae17
--- /dev/null
+++ b/sys/modules/syscons/star/Makefile
@@ -0,0 +1,10 @@
+#	$Id$
+
+BINDIR=	${DESTDIR}/lkm
+KMOD=	star_saver_mod
+SRCS= 	star_saver.c
+
+NOMAN=
+CFLAGS+= -DLKM -I${.CURDIR}/.. -I${.CURDIR}/../../../sys
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/syscons/star/star_saver.c b/sys/modules/syscons/star/star_saver.c
new file mode 100644
index 0000000..f18dc09
--- /dev/null
+++ b/sys/modules/syscons/star/star_saver.c
@@ -0,0 +1,111 @@
+/*-
+ * Copyright (c) 1995 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 
+ *    in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software withough specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+#include <sys/errno.h>
+#include <saver.h>
+
+MOD_MISC("star_saver")
+
+void (*current_saver)();
+void (*old_saver)();
+
+#define NUM_STARS	50
+
+/*
+ * Alternate saver that got its inspiration from a well known utility
+ * package for an inferior^H^H^H^H^H^Hfamous OS.
+ */
+void 
+star_saver(int blank)
+{
+	scr_stat	*scp = cur_console;
+	int		cell, i;
+	char 		pattern[] = {"...........++++***   "};
+	char		colors[] = {FG_DARKGREY, FG_LIGHTGREY, 
+				    FG_WHITE, FG_LIGHTCYAN};
+	static u_short 	stars[NUM_STARS][2];
+ 
+	if (blank) {
+		if (!scrn_blanked) {
+			scrn_blanked = 1;
+			fillw((FG_LIGHTGREY|BG_BLACK)<<8|scr_map[0x20], Crtat, 
+			      scp->xsize * scp->ysize);
+			set_border(0);
+			for(i=0; i<NUM_STARS; i++) {
+				stars[i][0] = 
+					random() % (scp->xsize*scp->ysize);
+				stars[i][1] = 0;
+			}
+		}
+		cell = random() % NUM_STARS;
+		*((u_short*)(Crtat + stars[cell][0])) = 
+			scr_map[pattern[stars[cell][1]]] | 
+				colors[random()%sizeof(colors)] << 8;
+		if ((stars[cell][1]+=(random()%4)) >= sizeof(pattern)-1) {
+			stars[cell][0] = random() % (scp->xsize*scp->ysize);
+			stars[cell][1] = 0;
+		}
+	}
+	else {
+		if (scrn_blanked) {
+			set_border(scp->border);
+			scrn_blanked = 0;
+			scp->status |= UPDATE_SCREEN;
+		}
+	}
+}
+
+saver_load(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	old_saver = current_saver;
+	current_saver = star_saver;
+	uprintf("star screen saver installed\n");
+	return 0;
+}
+
+saver_unload(struct lkm_table *lkmtp, int cmd)
+{
+	(*current_saver)(0);
+	current_saver = old_saver;
+	uprintf("star screen saver removed\n");
+	return 0;
+}
+
+saver_init(struct lkm_table *lkmtp, int cmd, int ver)
+{
+	DISPATCH(lkmtp, cmd, ver, saver_load, saver_unload, nosys);
+}
diff --git a/usr.sbin/vidcontrol/vidcontrol.1 b/usr.sbin/vidcontrol/vidcontrol.1
index 9fc4b8a..94a13d4 100644
--- a/usr.sbin/vidcontrol/vidcontrol.1
+++ b/usr.sbin/vidcontrol/vidcontrol.1
@@ -94,11 +94,6 @@ Sets the screensaver timeout to
 seconds, or turns it
 .I off
 .TP
-.BI "\-s\ " NAME|help
-Sets the screensaver appearance to
-.I NAME .
-Use \-s help to print a list of the available screen savers.
-.TP
 .BI "\-x\ "
 Use hexadecimal digits for output.
 .PP
diff --git a/usr.sbin/vidcontrol/vidcontrol.c b/usr.sbin/vidcontrol/vidcontrol.c
index 4793102..5af8e50 100644
--- a/usr.sbin/vidcontrol/vidcontrol.c
+++ b/usr.sbin/vidcontrol/vidcontrol.c
@@ -25,7 +25,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- *	$Id: vidcontrol.c,v 1.7 1995/02/07 11:56:21 sos Exp $
+ *	$Id: vidcontrol.c,v 1.8 1995/02/08 01:07:16 dima Exp $
  */
 
 #include <ctype.h>
@@ -34,19 +34,44 @@
 #include <sys/errno.h>
 #include "path.h"
 
-
 char 	legal_colors[16][16] = {
 	"black", "blue", "green", "cyan",
 	"red", "magenta", "brown", "white",
 	"grey", "lightblue", "lightgreen", "lightcyan",
 	"lightred", "lightmagenta", "yellow", "lightwhite"
-	};
+};
 int 	hex = 0;
 int 	number;
 char 	letter;
 struct 	vid_info info;
 
 
+void
+usage()
+{
+	fprintf(stderr,
+"Usage: vidcontrol mode             (available modes: VGA_40x25, VGA_80x25,\n"
+"                                                     VGA_80x50, VGA_320x200,\n"
+"                                                     EGA_80x25, EGA_80x43)\n"
+"                                   (experimental)    VGA_80x30, VGA_80x60)\n"
+"\n"
+"                  show             (show available colors)\n"
+"                  fgcol bgcol      (set fore- & background colors)\n"
+"                  -r fgcol bgcol   (set reverse fore- & background colors)\n"
+"                  -b color         (set border color)\n"
+"                  -c normal        (set cursor to inverting block)\n"
+"                  -c blink         (set cursor to blinking inverted block)\n"
+"                  -c destructive   (set cursor to blinking destructive char)\n"
+"                  -d               (dump screenmap to stdout)\n"
+"                  -l filename      (load srceenmap file filename)\n"
+"                  -L               (load default screenmap)\n"
+"                  -f DxL filename  (load font, D dots wide & L lines high)\n"
+"                  -s saver | help  (set screensaver type or help for a list)\n"
+"                  -t N             (set screensaver timeout in seconds)\n"
+"                  -x               (use hex numbers for output)\n"
+	);
+}
+
 char *
 nextarg(int ac, char **av, int *indp, int oc)
 {
@@ -58,14 +83,12 @@ nextarg(int ac, char **av, int *indp, int oc)
 	return("");
 }
 
-
 char *
 mkfullname(const char *s1, const char *s2, const char *s3)
 {
-static char	*buf = NULL;
-static int	bufl = 0;
-int		f;
-
+	static char *buf = NULL;
+	static int bufl = 0;
+	int f;
 
 	f = strlen(s1) + strlen(s2) + strlen(s3) + 1;
 	if (f > bufl)
@@ -85,7 +108,6 @@ int		f;
 	return(buf);
 }
 
-
 void
 load_scrnmap(char *filename)
 {
@@ -119,12 +141,11 @@ load_scrnmap(char *filename)
 	close(fd);
 }
 
-
 void
 load_default_scrnmap()
 {
-	int i;
 	scrmap_t scrnmap;
+	int i;
 
 	for (i=0; i<256; i++)
 		*((char*)&scrnmap + i) = i;
@@ -132,7 +153,6 @@ load_default_scrnmap()
 		perror("can't load default screenmap");
 }
 
-
 void
 print_scrnmap()
 {
@@ -155,7 +175,6 @@ print_scrnmap()
 
 }
 
-
 void 
 load_font(char *type, char *filename)
 {
@@ -207,7 +226,6 @@ load_font(char *type, char *filename)
 	free(fontmap);
 }
 
-
 void
 set_screensaver_timeout(char *arg)
 {
@@ -226,44 +244,6 @@ set_screensaver_timeout(char *arg)
 		perror("setting screensaver period");
 }
 
-
-void
-set_screensaver_type(char *type)
-{
-	ssaver_t saver;
-	int i, e;
-
-	if (!strcmp(type, "help")) {
-		i = 0;
-		printf("available screen saver types:\n");
-		do {
-			saver.num = i;
-			e = ioctl(0, CONS_GSAVER, &saver);
-			i ++;
-			if (e == 0)
-				printf("\t%s\n", saver.name);
-		} while (e == 0);
-		if (e == -1 && errno != EIO)
-			perror("getting screensaver info");
-	} else {
-		i = 0;
-		do {
-			saver.num = i;
-			e = ioctl(0, CONS_GSAVER, &saver);
-			i ++;
-			if (e == 0 && !strcmp(type, saver.name)) {
-				if (ioctl(0, CONS_SSAVER, &saver) == -1)
-					perror("setting screensaver type");
-				return;
-			}
-		} while (e == 0);
-		if (e == -1 && errno != EIO)
-			perror("getting screensaver info");
-		else
-			fprintf(stderr, "%s: No such screensaver\n", type);
-	}
-}
-
 void
 set_cursor_type(char *appearence)
 {
@@ -283,7 +263,6 @@ set_cursor_type(char *appearence)
 	ioctl(0, CONS_CURSORTYPE, &type);
 }
 
-
 int
 video_mode(int argc, char **argv, int *index)
 {
@@ -315,7 +294,6 @@ video_mode(int argc, char **argv, int *index)
 	return;
 }
 		
-
 int
 get_color_number(char *color)
 {
@@ -327,7 +305,6 @@ get_color_number(char *color)
 	return -1;
 }
 
-
 int
 set_normal_colors(int argc, char **argv, int *index)
 {
@@ -345,7 +322,6 @@ set_normal_colors(int argc, char **argv, int *index)
 	}
 }
 
-
 set_reverse_colors(int argc, char **argv, int *index)
 {
 	int color;
@@ -361,7 +337,6 @@ set_reverse_colors(int argc, char **argv, int *index)
 	}
 }
 
-
 set_border_color(char *arg)
 {
 	int color;
@@ -373,7 +348,6 @@ set_border_color(char *arg)
 		usage(); 
 }
 
-
 test_frame()
 {
 	int i;
@@ -391,33 +365,6 @@ test_frame()
 		info.mv_rev.fore, info.mv_rev.back);
 }
 
-
-usage()
-{
-	fprintf(stderr,
-"Usage: vidcontrol mode             (available modes: VGA_40x25, VGA_80x25,\n"
-"                                                     VGA_80x50, VGA_320x200,\n"
-"                                                     EGA_80x25, EGA_80x43)\n"
-"                                   (experimental)    VGA_80x30, VGA_80x60)\n"
-"\n"
-"                  show             (show available colors)\n"
-"                  fgcol bgcol      (set fore- & background colors)\n"
-"                  -r fgcol bgcol   (set reverse fore- & background colors)\n"
-"                  -b color         (set border color)\n"
-"                  -c normal        (set cursor to inverting block)\n"
-"                  -c blink         (set cursor to blinking inverted block)\n"
-"                  -c destructive   (set cursor to blinking destructive char)\n"
-"                  -d               (dump screenmap to stdout)\n"
-"                  -l filename      (load srceenmap file filename)\n"
-"                  -L               (load default screenmap)\n"
-"                  -f DxL filename  (load font, D dots wide & L lines high)\n"
-"                  -s saver | help  (set screensaver type or help for a list)\n"
-"                  -t N             (set screensaver timeout in seconds)\n"
-"                  -x               (use hex numbers for output)\n"
-	);
-}
-
-
 void
 main(int argc, char **argv)
 {
@@ -428,10 +375,10 @@ main(int argc, char **argv)
 	
 	info.size = sizeof(info);
 	if (ioctl(0, CONS_GETINFO, &info) < 0) {
-		perror("Must be on a vrtual console");
+		perror("Must be on a virtual console");
 		exit(1);
 	}
-	while((opt = getopt(argc, argv, "b:c:df:l:Lr:s:t:x")) != -1)
+	while((opt = getopt(argc, argv, "b:c:df:l:Lr:t:x")) != -1)
 		switch(opt) {
 			case 'c':
 				set_cursor_type(optarg);
@@ -455,9 +402,6 @@ main(int argc, char **argv)
 			case 'r':
 				set_reverse_colors(argc, argv, &optind);
 				break;
-			case 's':
-				set_screensaver_type(optarg);
-				break;
 			case 't':
 				set_screensaver_timeout(optarg);
 				break;