path: root/sys/arch/i386/isa/pcvt/pcvt_kbd.c

/*	$OpenBSD: pcvt_kbd.c,v 1.33 2000/02/27 20:34:36 aaron Exp $	*/

/*
 * Copyright (c) 1992, 1995 Hellmuth Michaelis and Joerg Wunsch.
 *
 * Copyright (c) 1992, 1993 Brian Dunford-Shore and Holger Veit.
 *
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * William Jolitz and Don Ahn.
 *
 * This code is derived from software contributed to 386BSD by
 * Holger Veit.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Hellmuth Michaelis,
 *	Brian Dunford-Shore and Joerg Wunsch.
 * 4. The name authors may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * @(#)pcvt_kbd.c, 3.32, Last Edit-Date: [Tue Oct  3 11:19:48 1995]
 *
 */

/*---------------------------------------------------------------------------*
 *
 *	pcvt_kbd.c	VT220 Driver Keyboard Interface Code
 *	----------------------------------------------------
 *	-hm	------------ Release 3.00 --------------
 *	-hm	integrating NetBSD-current patches
 *	-jw	introduced kbd_emulate_pc() if scanset > 1
 *	-hm	patch from joerg for timeout in kbd_emulate_pc()
 *	-hm	starting to implement alt-shift/ctrl key mappings
 *	-hm	Gateway 2000 Keyboard fix from Brian Moore
 *	-hm	some #if adjusting for NetBSD 0.9
 *	-hm	split off pcvt_kbd.h
 *	-hm	applying Joerg's patches for FreeBSD 2.0
 *	-hm	patch from Martin, PCVT_NO_LED_UPDATE
 *	-hm	PCVT_VT220KEYB patches from Lon Willet
 *	-hm	PR #399, patch from Bill Sommerfeld: Return with PCVT_META_ESC
 *	-hm	allow keyboard-less kernel boot for serial consoles and such ..
 *	-hm	patch from Lon Willett for led-update and showkey()
 *	-hm	patch from Lon Willett to fix mapping of Control-R scancode
 *	-hm	delay patch from Martin Husemann after port-i386 ml-discussion
 *	-hm	added PCVT_NONRESP_KEYB_TRY definition to doreset()
 *	-hm	keyboard code bugfix from Jukka A. Ukkonen (ukkonen@csc.fi)
 *	-hm	---------------- Release 3.30 -----------------------
 *	-hm	patch from Frank van der Linden for keyboard state per VT
 *	-hm	removed KBDGLEDS and KBDSLEDS ioctls
 *	-hm	---------------- Release 3.32 -----------------------
 *
 *---------------------------------------------------------------------------*/

#include "vt.h"
/* #if NVT > 0 */

#include "pcvt_hdr.h"		/* global include */

#define LEDSTATE_UPDATE_PENDING (1 << 3)

static void fkey1(void), fkey2(void),  fkey3(void),  fkey4(void);
static void fkey5(void), fkey6(void),  fkey7(void),  fkey8(void);
static void fkey9(void), fkey10(void), fkey11(void), fkey12(void);

static void sfkey1(void), sfkey2(void),  sfkey3(void),  sfkey4(void);
static void sfkey5(void), sfkey6(void),  sfkey7(void),  sfkey8(void);
static void sfkey9(void), sfkey10(void), sfkey11(void), sfkey12(void);

static void cfkey1(void), cfkey2(void),  cfkey3(void),  cfkey4(void);
static void cfkey5(void), cfkey6(void),  cfkey7(void),  cfkey8(void);
static void cfkey9(void), cfkey10(void), cfkey11(void), cfkey12(void);

static inline int kbd_wait_output(void);
static inline int kbd_wait_input(void);
int kbd_response(void);

static void	doreset ( void );
static void	ovlinit ( int force );
static void 	settpmrate ( int rate );
static void	setlockkeys ( int snc );
static int	kbc_8042cmd ( int val );
static int	getokeydef ( unsigned key, struct kbd_ovlkey *thisdef );
static int 	getckeydef ( unsigned key, struct kbd_ovlkey *thisdef );
static int	rmkeydef ( int key );
static int	setkeydef ( struct kbd_ovlkey *data );
static u_char *	xlatkey2ascii( U_short key );

#if !PCVT_NO_LED_UPDATE
static int	ledstate  = LEDSTATE_UPDATE_PENDING;	/* keyboard led's */
#endif
static int	tpmrate   = KBD_TPD500|KBD_TPM100;
static u_char	altkpflag = 0;
static u_short	altkpval  = 0;

static u_short *scrollback_savedscreen = (u_short *)0;
static size_t scrnsv_size = (size_t)-1;
static void scrollback_save_screen ( void );
static void scrollback_restore_screen ( void );

extern int kbd_reset;

#include "pcvt_kbd.h"		/* tables etc */

/*---------------------------------------------------------------------------*
 *	function to switch to another virtual screen
 *---------------------------------------------------------------------------*/
static void
do_vgapage(int page)
{
	if (critical_scroll)		/* executing critical region ? */
		switch_page = page;	/* yes, auto switch later */
	else
		vgapage(page);		/* no, switch now */
}

/*
 * This code from Lon Willett enclosed in #if PCVT_UPDLED_LOSES_INTR is
 * disabled because it crashes FreeBSD 1.1.5.1 at boot time.
 * The cause is obviously that the timeout queue is not yet initialized
 * timeout is called from here the first time.
 * Anyway it is a pointer in the right direction so it is included for
 * reference here.
 */

#define PCVT_UPDLED_LOSES_INTR	0	/* disabled for now */

#if PCVT_UPDLED_LOSES_INTR

/*---------------------------------------------------------------------------*
 *	check for lost keyboard interrupts
 *---------------------------------------------------------------------------*/

/*
 * The two commands to change the LEDs generate two KEYB_R_ACK responses
 * from the keyboard, which aren't explicitly checked for (maybe they
 * should be?).  However, when a lot of other I/O is happening, one of
 * the interrupts sometimes gets lost (I'm not sure of the details of
 * how and why and what hardware this happens with).
 *
 * This is a real problem, because normally the keyboard is only polled
 * by pcrint(), and no more interrupts will be generated until the ACK
 * has been read.  So the keyboard is hung.  This code polls a little
 * while after changing the LEDs to make sure that this hasn't happened.
 *
 * XXX Quite possibly we should poll the kbd on a regular basis anyway,
 * in the interest of robustness.  It may be possible that interrupts
 * get lost other times as well.
 */

static int lost_intr_timeout_queued = 0;

static void
check_for_lost_intr (void *arg)
{
	lost_intr_timeout_queued = 0;
	if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF) {
		int opri = spltty();
		(void)pcrint();
		splx(opri);
	}
}

#endif /* PCVT_UPDLED_LOSES_INTR */

/*---------------------------------------------------------------------------*
 *	update keyboard led's
 *---------------------------------------------------------------------------*/
void
update_led(void)
{
#if !PCVT_NO_LED_UPDATE
	/* Don't update LED's unless necessary. */

	int opri, new_ledstate, response1, response2;

	opri = spltty();
	new_ledstate = ((vsp->scroll_lock) | (vsp->num_lock * 2) |
			(vsp->caps_lock * 4));

	if (new_ledstate != ledstate) {
		ledstate = LEDSTATE_UPDATE_PENDING;

		if (kbd_cmd(KEYB_C_LEDS) != 0) {
			printf("pcvt: kbd led cmd timeout\n");
			goto bail;
		}

		/*
		 * For some keyboards or keyboard controllers, it is an
		 * error to issue a command without waiting long enough
		 * for an ACK for the previous command.  The keyboard
		 * gets confused, and responds with KEYB_R_RESEND, but
		 * we ignore that.  Wait for the ACK here.  The busy
		 * waiting doesn't matter much, since we lose anyway by
		 * busy waiting to send the command.
		 *
		 * XXX actually wait for any response, since we can't
		 * handle normal scancodes here.
		 *
		 * XXX all this should be interrupt driven.  Issue only
		 * one command at a time wait for a ACK before proceeding.
		 * Retry after a timeout or on receipt of a KEYB_R_RESEND.
		 * KEYB_R_RESENDs seem to be guaranteed by working
		 * keyboard controllers with broken (or disconnected)
		 * keyboards.  There is another code for keyboard
		 * reconnects.  The keyboard hardware is very simple and
		 * well designed :-).
		 */
		response1 = kbd_response();

		if (kbd_cmd(new_ledstate) != 0) {
			printf("pcvt: kbd led data timeout\n");
			goto bail;
		}
		response2 = kbd_response();

		if (response1 == KEYB_R_ACK && response2 == KEYB_R_ACK)
			ledstate = new_ledstate;
		else {
			printf("pcvt: kbd led cmd not ack'd (resp %#x %#x)\n",
			    response1, response2);
		}

#if PCVT_UPDLED_LOSES_INTR
		if (lost_intr_timeout_queued)
			untimeout(check_for_lost_intr, (void *)NULL);

		timeout(check_for_lost_intr, (void *)NULL, hz);
		lost_intr_timeout_queued = 1;
#endif /* PCVT_UPDLED_LOSES_INTR */
	}
bail:
	splx(opri);
#endif /* !PCVT_NO_LED_UPDATE */
}

/*---------------------------------------------------------------------------*
 *	set typematic rate
 *---------------------------------------------------------------------------*/
static void
settpmrate(int rate)
{
	int opri, response1, response2;

	opri = spltty();
	tpmrate = rate & 0x7f;

	if (kbd_cmd(KEYB_C_TYPEM) != 0) {
		printf("pcvt: kbd tpm cmd timeout\n");
		goto fail;
	}
	response1 = kbd_response();		/* wait for ACK */

	if (kbd_cmd(tpmrate) != 0) {
		printf("pcvt: kbd tpm data timeout\n");
		goto fail;
	}
	response2 = kbd_response();		/* wait for ACK */

	if (response1 != KEYB_R_ACK || response2 != KEYB_R_ACK) {
		printf("pcvt: kbd tpm cmd not ack'd (resp %#x %#x)\n",
		   response1, response2);
	}
fail:
	splx(opri);
}

/*---------------------------------------------------------------------------*
 *	Pass command to keyboard controller (8042)
 *---------------------------------------------------------------------------*/
static inline int
kbd_wait_output()
{
	u_int i;

	/* > 100 msec */
	for (i = 100; i; i--) {
		if ((inb(CONTROLLER_CTRL) & STATUS_INPBF) == 0) {
			PCVT_KBD_DELAY();
			return (1);
		}
		DELAY(1000);
	}
	return (0);
}

static inline int
kbd_wait_input()
{
	u_int i;

	/* > 500 msec */
	for (i = 500; i; i--) {
		if ((inb(CONTROLLER_CTRL) & STATUS_OUTPBF) != 0) {
			PCVT_KBD_DELAY();
			return (1);
		}
		DELAY(1000);
	}
	return (0);
}

static int
kbc_8042cmd(int val)
{
	if (!kbd_wait_output())
		return (-1);
	outb(CONTROLLER_CTRL, val);

	return (0);
}

/*---------------------------------------------------------------------------*
 *	Pass command to keyboard itself
 *---------------------------------------------------------------------------*/
int
kbd_cmd(int val)
{
	if (!kbd_wait_output())
		return (-1);
	outb(CONTROLLER_DATA, val);

	return (0);
}

/*---------------------------------------------------------------------------*
 *	Read response from keyboard
 *	NB: make sure to call spltty() before kbd_cmd(), kbd_response().
 *---------------------------------------------------------------------------*/
int
kbd_response(void)
{
	u_char ch;

	if (!kbd_wait_input())
		return (-1);
	ch = inb(CONTROLLER_DATA);

	return (ch);
}

/*---------------------------------------------------------------------------*
 *	switch to/from PC scan code emulation mode
 *---------------------------------------------------------------------------*/
void
kbd_setmode(int mode)
{
#if PCVT_SCANSET > 1		/* switch only if we are running scancode 2 */
	int cmd;
#if PCVT_USEKBDSEC
	cmd = COMMAND_SYSFLG | COMMAND_IRQEN;
#else
	cmd = COMMAND_INHOVR | COMMAND_SYSFLG | COMMAND_IRQEN;
#endif

	if (mode == K_RAW)		/* switch to scancode 1 ? */
		cmd |= COMMAND_PCSCAN;	/*     yes, setup command */

	kbc_8042cmd(CONTR_WRITE);
	kbd_cmd(cmd);
	
#endif /* PCVT_SCANSET > 1 */

	if (mode == K_RAW)
		shift_down = meta_down = altgr_down = ctrl_down = 0;
}


#ifndef PCVT_NONRESP_KEYB_TRY
#define PCVT_NONRESP_KEYB_TRY	25	/* no of times to try to detect	*/
#endif					/* a nonresponding keyboard	*/

/*---------------------------------------------------------------------------*
 *	try to force keyboard into a known state ..
 *---------------------------------------------------------------------------*/
static
void doreset(void)
{
	int again = 0;
	int once = 0;
	int response, opri;
	unsigned int wait_retries, seen_negative_response;

	/* Enable interrupts and keyboard, etc. */
	if (kbc_8042cmd(CONTR_WRITE) != 0)
		printf("pcvt: timeout controller write cmd\n");

#if PCVT_USEKBDSEC		/* security enabled */

#  if PCVT_SCANSET == 2
#    define KBDINITCMD COMMAND_SYSFLG|COMMAND_IRQEN
#  else /* PCVT_SCANSET != 2 */
#    define KBDINITCMD COMMAND_PCSCAN|COMMAND_SYSFLG|COMMAND_IRQEN
#  endif /* PCVT_SCANSET == 2 */

#else /* ! PCVT_USEKBDSEC */	/* security disabled */

#  if PCVT_SCANSET == 2
#    define KBDINITCMD COMMAND_INHOVR|COMMAND_SYSFLG|COMMAND_IRQEN
#  else /* PCVT_SCANSET != 2 */
#    define KBDINITCMD COMMAND_PCSCAN|COMMAND_INHOVR|COMMAND_SYSFLG\
	|COMMAND_IRQEN
#  endif /* PCVT_SCANSET == 2 */

#endif /* PCVT_USEKBDSEC */

	if (kbd_cmd(KBDINITCMD) != 0)
		printf("pcvt: timeout writing kbd init cmd\n");

	/*
	 * Discard any stale keyboard activity.  The 0.1 boot code isn't
	 * very careful and sometimes leaves a KEYB_R_RESEND.
	 */
	while (1) {
		if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF)
			kbd_response();
		else {
			DELAY(10000);
			if (!(inb(CONTROLLER_CTRL) & STATUS_OUTPBF))
				break;
		}
	}

	/* Start keyboard reset */
	opri = spltty();

	if (kbd_cmd(KEYB_C_RESET) != 0)
		printf("pcvt: kbd reset cmd timeout\n");

	/* Wait for the first response to reset and handle retries */
	while ((response = kbd_response()) != KEYB_R_ACK) {
		if (response < 0) {
			if (!again)	/* print message only once ! */
				printf("pcvt: response != ack\n");
			response = KEYB_R_RESEND;
		}
		if (response == KEYB_R_RESEND) {
			if (!again)	/* print message only once ! */
				printf("pcvt: got KEYB_R_RESEND\n");

			if (++again > PCVT_NONRESP_KEYB_TRY) {
				printf("pcvt: no kbd detected\n");
				keyboard_type = KB_UNKNOWN;
				splx(opri);
				return;
			}

			if ((kbd_cmd(KEYB_C_RESET) != 0) && (once == 0)) {
				once++;		/* print message only once ! */
				printf("pcvt: timeout for loop\n");
			}
		}
	}

	/* Wait for the second response to reset */

	wait_retries = seen_negative_response = 0;

	while ((response = kbd_response()) != KEYB_R_SELFOK) {
		/*
		 *  Let's be a little more tolerant here...
		 *  Receiving a -1 could indicate that the keyboard
		 *  is not ready to answer just yet.
		 *  Such cases have been noticed with e.g. Alps Membrane.
		 */

		if (response < 0)
			seen_negative_response = 1;

		if (seen_negative_response && (wait_retries >= 10)) {
			printf("pcvt: response != OK\n");

			/*
			 * If KEYB_R_SELFOK never arrives, the loop will
			 * finish here unless the keyboard babbles or
			 * STATUS_OUTPBF gets stuck.
			 */
			break;
		}
		wait_retries++;
	}

#if PCVT_SCANSET == 1
	/* 
	 * Pcvt has been compiled for scanset 1, which requires that
	 * the mainboard controller translates. If it is not able to,
	 * try to set the keyboard to XT mode so that pcvt will see AT
	 * scan codes after all. If it fails, we're out of luck.
	 */
	kbc_8042cmd(CONTR_READ);
	response = kbd_response();

	if (!(response & COMMAND_PCSCAN)) {
		if (kbd_cmd(KEYB_C_SCANSET) != 0)
			printf("pcvt: kbd SCANSET cmd timeout\n");
		else if (kbd_cmd(1) != 0)
			printf("pcvt: kbd SCANSET data timeout\n");
		else
			printf("pcvt: kbd set to XT mode\n");
	 }
#endif
	splx(opri);

#if PCVT_KEYBDID

query_kbd_id:
	opri = spltty();

	if (kbd_cmd(KEYB_C_ID) != 0) {
		printf("pcvt: timeout for kbd ID cmd\n");
		keyboard_type = KB_UNKNOWN;
	}
	else {
r_entry:
		if ((response = kbd_response()) == KEYB_R_MF2ID1) {
			switch ((response = kbd_response())) {
			case KEYB_R_RESEND:
				/*
				 *  Let's give other priority levels
				 *  a chance instead of blocking at
				 *  tty level.
				 */
				splx(opri);
				goto query_kbd_id;
					
			case KEYB_R_MF2ID2:
			case KEYB_R_MF2ID2HP:
			case KEYB_R_MF2ID2TP:
			case KEYB_R_MF2ID2TP2:
				keyboard_type = KB_MFII;
				break;

			default:
				printf("pcvt: kbdid (resp 2 = %d)\n", response);
				keyboard_type = KB_UNKNOWN;
				break;
			}
		}
		else if (response == KEYB_R_ACK)
			goto r_entry;
		else if (response == -1)
			keyboard_type = KB_AT;
		else
			printf("pcvt: kbdid (resp 1 = %d)\n", response);
	}
	splx(opri);

#else /* PCVT_KEYBDID */
	keyboard_type = KB_MFII;	/* force it .. */
#endif /* PCVT_KEYBDID */
}

/*---------------------------------------------------------------------------*
 *	init keyboard code
 *---------------------------------------------------------------------------*/
void
kbd_code_init(void)
{
	doreset();
	ovlinit(0);
	keyboard_is_initialized = 1;
}

/*---------------------------------------------------------------------------*
 *	init keyboard code, this initializes the keyboard subsystem
 *	just "a bit" so the very very first ddb session is able to
 *	get proper keystrokes - in other words, it's a hack ....
 *---------------------------------------------------------------------------*/
void
kbd_code_init1(void)
{
	doreset();
	keyboard_is_initialized = 1;
}

/*---------------------------------------------------------------------------*
 *	init keyboard overlay table
 *---------------------------------------------------------------------------*/
static
void ovlinit(int force)
{
	int i;

	if (force || ovlinitflag == 0) {
		if (ovlinitflag == 0 &&
		   (ovltbl = (Ovl_tbl *)malloc(sizeof(Ovl_tbl) * OVLTBL_SIZE,
					       M_DEVBUF, M_WAITOK)) == NULL)
			panic("pcvt_kbd: malloc of Ovl_tbl failed");

		for(i = 0; i < OVLTBL_SIZE; i++) {
			ovltbl[i].keynum =
			ovltbl[i].type = 0;
			ovltbl[i].unshift[0] =
			ovltbl[i].shift[0] =
			ovltbl[i].ctrl[0] =
			ovltbl[i].altgr[0] = 0;
			ovltbl[i].subu =
			ovltbl[i].subs =
			ovltbl[i].subc =
			ovltbl[i].suba = KBD_SUBT_STR;	/* just strings .. */
		}
		for(i = 0; i <= MAXKEYNUM; i++)
			key2ascii[i].type &= KBD_MASK;

		ovlinitflag = 1;
	}
}

/*---------------------------------------------------------------------------*
 *	get original key definition
 *---------------------------------------------------------------------------*/
static int
getokeydef(unsigned key, Ovl_tbl *thisdef)
{
	if (key == 0 || key > MAXKEYNUM)
		return (EINVAL);

	thisdef->keynum = key;
	thisdef->type = key2ascii[key].type;

	if (key2ascii[key].unshift.subtype == STR) {
		bcopy((u_char *)(key2ascii[key].unshift.what.string),
		    thisdef->unshift, CODE_SIZE);
		thisdef->subu = KBD_SUBT_STR;
	}
	else {
		bcopy("", thisdef->unshift, CODE_SIZE);
		thisdef->subu = KBD_SUBT_FNC;
	}

	if (key2ascii[key].shift.subtype == STR) {
		bcopy((u_char *)(key2ascii[key].shift.what.string),
		    thisdef->shift, CODE_SIZE);
		thisdef->subs = KBD_SUBT_STR;
	}
	else {
		bcopy("", thisdef->shift,CODE_SIZE);
		thisdef->subs = KBD_SUBT_FNC;
	}

	if (key2ascii[key].ctrl.subtype == STR) {
		bcopy((u_char *)(key2ascii[key].ctrl.what.string),
		    thisdef->ctrl, CODE_SIZE);
		thisdef->subc = KBD_SUBT_STR;
	}
	else {
		bcopy("",thisdef->ctrl,CODE_SIZE);
		thisdef->subc = KBD_SUBT_FNC;
	}

	/* deliver at least anything for ALTGR settings ... */
	if (key2ascii[key].unshift.subtype == STR) {
		bcopy((u_char *)(key2ascii[key].unshift.what.string),
		    thisdef->altgr, CODE_SIZE);
		thisdef->suba = KBD_SUBT_STR;
	}
	else {
		bcopy("", thisdef->altgr, CODE_SIZE);
		thisdef->suba = KBD_SUBT_FNC;
	}
	return (0);
}

/*---------------------------------------------------------------------------*
 *	get current key definition
 *---------------------------------------------------------------------------*/
static int
getckeydef(unsigned key, Ovl_tbl *thisdef)
{
	u_short type = key2ascii[key].type;

	if (key > MAXKEYNUM)
		return (EINVAL);

	if (type & KBD_OVERLOAD)
		*thisdef = ovltbl[key2ascii[key].ovlindex];
	else
		getokeydef(key,thisdef);

	return (0);
}

/*---------------------------------------------------------------------------*
 *	translate keynumber and returns ptr to associated ascii string
 *	if key is bound to a function, executes it, and ret empty ptr
 *---------------------------------------------------------------------------*/
static u_char *
xlatkey2ascii(U_short key)
{
	int		n;
	static u_char	capchar[2] = {0, 0};
#if PCVT_META_ESC
	static u_char	metachar[3] = {0x1b, 0, 0};
#else
	static u_char	metachar[2] = {0, 0};
#endif
	static Ovl_tbl	thisdef;
	static u_char altgr_shft_key[KBDMAXOVLKEYSIZE];
	
	void		(*fnc)(void);

	/* ignore the NON-KEY */
	if (key == 0)
		return (0);

	/* get the current ASCII value */
	getckeydef(key & 0x7F, &thisdef);

	thisdef.type &= KBD_MASK;

	if (key & 0x80) {		/* special handling of ALT-KEYPAD */
		/* is the ALT Key released? */
		if (thisdef.type == KBD_META || thisdef.type == KBD_ALTGR) {
			if (altkpflag) { /* have we been in altkp mode? */
				capchar[0] = altkpval;
				altkpflag = 0;
				altkpval = 0;
				return (capchar);
			}
		}
		return (0);
	}

	switch (thisdef.type) {		/* convert the keys */
	case KBD_BREAK:
	case KBD_ASCII:
	case KBD_FUNC:
		fnc = NULL;
		more_chars = NULL;

		if (altgr_down) {
			/* XXX this is hack to support simple AltGr + Shift
	 	 	 * remapping. This should work for KOI-8 keymap style.
			 */
			if (shift_down) {
                		altgr_shft_key[0] = *(u_char*)thisdef.altgr+040;
                		more_chars = (u_char*)altgr_shft_key;
                	}
                	else
				more_chars = (u_char *)thisdef.altgr;
		}
		else if (!ctrl_down && (shift_down || vsp->shift_lock)) {
			if (key2ascii[key].shift.subtype == STR)
				more_chars = (u_char *)thisdef.shift;
			else
				fnc = key2ascii[key].shift.what.func;
		     }
		else if (ctrl_down) {
			if (key2ascii[key].ctrl.subtype == STR)
				more_chars = (u_char *)thisdef.ctrl;
			else
				fnc = key2ascii[key].ctrl.what.func;
		     }
		else {
			if (key2ascii[key].unshift.subtype == STR)
				more_chars = (u_char *)thisdef.unshift;
			else
				fnc = key2ascii[key].unshift.what.func;
		}

		if (fnc)
			(*fnc)();	/* execute function */

		if ((more_chars != NULL) && (more_chars[1] == 0)) {
			if (vsp->caps_lock && more_chars[0] >= 'a'
			   && more_chars[0] <= 'z') {
				capchar[0] = *more_chars - ('a' - 'A');
				more_chars = capchar;
			}
			if (meta_down) {
#if PCVT_META_ESC
				metachar[1] = *more_chars;
#else
				metachar[0] = *more_chars | 0x80;
#endif
				more_chars = metachar;
			}
		}
		return (more_chars);

	case KBD_KP:
		fnc = NULL;
		more_chars = NULL;

		if (meta_down) {
			switch (key) {
			case 95:	/* / */
				altkpflag = 0;
				more_chars = (u_char *)"\033OQ";
				return (more_chars);

			case 100:	/* * */
				altkpflag = 0;
				more_chars = (u_char *)"\033OR";
				return (more_chars);

			case 105:	/* - */
				altkpflag = 0;
		 		more_chars = (u_char *)"\033OS";
				return (more_chars);
			}
		}

		if (meta_down || altgr_down) {
			if ((n = keypad2num[key-91]) >= 0) {
				if (!altkpflag) {
					/* start ALT-KP mode */
					altkpflag = 1;
					altkpval = 0;
				}
				altkpval *= 10;
				altkpval += n;
			}
			else
				altkpflag = 0;
			return (0);
		}

		if (!vsp->num_lock) {
			if (key2ascii[key].shift.subtype == STR)
				more_chars = (u_char *)thisdef.shift;
			else
				fnc = key2ascii[key].shift.what.func;
		}
		else {
			if (key2ascii[key].unshift.subtype == STR)
				more_chars = (u_char *)thisdef.unshift;
			else
				fnc = key2ascii[key].unshift.what.func;
		}

		if (fnc)
			(*fnc)();	/* execute function */

		return (more_chars);

	case KBD_CURSOR:
		fnc = NULL;
		more_chars = NULL;

		if (vsp->ckm) {
			if (key2ascii[key].shift.subtype == STR)
				more_chars = (u_char *)thisdef.shift;
			else
				fnc = key2ascii[key].shift.what.func;
		}
		else {
			if (key2ascii[key].unshift.subtype == STR)
				more_chars = (u_char *)thisdef.unshift;
			else
				fnc = key2ascii[key].unshift.what.func;
		}

		if (fnc)
			(*fnc)();	/* execute function */

		return (more_chars);

	case KBD_NUM:		/*  special kp-num handling */
		more_chars = NULL;

		if (meta_down)
			more_chars = (u_char *)"\033OP"; /* PF1 */
		else {
			vsp->num_lock ^= 1;
			update_led();
		}
		return (more_chars);

	case KBD_RETURN:
		more_chars = NULL;

		if (!vsp->num_lock)
			more_chars = (u_char *)thisdef.shift;
		else
			more_chars = (u_char *)thisdef.unshift;

		if (vsp->lnm && (*more_chars == '\r'))
			more_chars = (u_char *)"\r\n"; /* CR LF */

		if (meta_down) {
#if PCVT_META_ESC
			metachar[1] = *more_chars;
#else
			metachar[0] = *more_chars | 0x80;
#endif
			more_chars = metachar;
		}
		return (more_chars);

	case KBD_META:		/* these keys are	*/
	case KBD_ALTGR:		/*  handled directly	*/
	case KBD_SCROLL:	/*  by the keyboard	*/
	case KBD_CAPS:		/*  handler - they are	*/
	case KBD_SHFTLOCK:	/*  ignored here	*/
	case KBD_CTL:
	case KBD_NONE:
	default:
		return (0);
	}
}

/*---------------------------------------------------------------------------*
 *	get keystrokes from the keyboard.
 *	if noblock = 0, wait until a key is pressed.
 *	else return NULL if no characters present.
 *---------------------------------------------------------------------------*/

#if PCVT_KBD_FIFO
extern	u_char	pcvt_kbd_fifo[];
extern	int	pcvt_kbd_rptr;
extern	short	pcvt_kbd_count;
#endif

u_char *
sgetc(int noblock)
{
#if PCVT_KBD_FIFO
	int		s;
#endif
	u_char *cp, dt, key;
	u_short	type;
	static u_char kbd_lastkey = 0; /* last keystroke */
#ifdef XSERVER
	static char	keybuf[2] = {0}; /* the second 0 is a delimiter! */
#endif /* XSERVER */

	static struct {
		u_char extended: 1;	/* extended prefix seen */
		u_char ext1: 1;		/* extended prefix 1 seen */
		u_char breakseen: 1;	/* break code seen */
		u_char vshift: 1;	/* virtual shift pending */
		u_char vcontrol: 1;	/* virtual control pending */
		u_char sysrq: 1;	/* sysrq pressed */
	} kbd_status = {0};

loop:

#ifdef XSERVER

#if PCVT_KBD_FIFO

	if (noblock == 31337) {
		vsp->scrolling = 1;
		goto scroll_reset;
	}

	/* see if there is data from the keyboard available either from */
	/* the keyboard fifo or from the 8042 keyboard controller	*/

	if ((( noblock) && (pcvt_kbd_count)) ||
	    ((!noblock) && (inb(CONTROLLER_CTRL) & STATUS_OUTPBF))) {
		if (!noblock) {		/* source = 8042 */
			PCVT_KBD_DELAY();	/* 7 us delay */
			dt = inb(CONTROLLER_DATA);	/* get from obuf */
		}
		else {			/* source = keyboard fifo */
			dt = pcvt_kbd_fifo[pcvt_kbd_rptr++];
			s = spltty();
			pcvt_kbd_count--;
			splx(s);
			if (pcvt_kbd_rptr >= PCVT_KBD_FIFO_SZ)
				pcvt_kbd_rptr = 0;
		}

#else /* !PCVT_KB_FIFO */

	/* see if there is data from the keyboard available from the 8042 */
	if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF) {
		PCVT_KBD_DELAY();		/* 7 us delay */
		dt = inb(CONTROLLER_DATA);	/* yes, get data */
#endif /* !PCVT_KBD_FIFO */

		/*
		 * If x mode is active, only care for locking keys, then
		 * return the scan code instead of any key translation.
		 * Additionally, this prevents us from any attempts to
		 * execute pcvt internal functions caused by keys (such
		 * as screen flipping).
		 */
 		if (vsp->kbd_state == K_RAW) {
			keybuf[0] = dt;
			return ((u_char *)keybuf);
		}
	}

#else /* !XSERVER */

#  if PCVT_KBD_FIFO

	/* see if there is data from the keyboard available either from */
	/* the keyboard fifo or from the 8042 keyboard controller	*/

	if ((( noblock) && (pcvt_kbd_count)) ||
	    ((!noblock) && (inb(CONTROLLER_CTRL) & STATUS_OUTPBF))) {
		if (!noblock) {		/* source = 8042 */
			PCVT_KBD_DELAY();	/* 7 us delay */
			dt = inb(CONTROLLER_DATA);
		}
		else {			/* source = keyboard fifo */
			dt = pcvt_kbd_fifo[pcvt_kbd_rptr++]; /* yes, get it ! */
			s = spltty();
			pcvt_kbd_count--;
			splx(s);
			if (pcvt_kbd_rptr >= PCVT_KBD_FIFO_SZ)
				pcvt_kbd_rptr = 0;
		}
	}

#else /* !PCVT_KBD_FIFO */

	/* see if there is data from the keyboard available from the 8042 */
	if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF) {
		PCVT_KBD_DELAY();		/* 7 us delay */
		dt = inb(CONTROLLER_DATA);	/* yes, get data ! */
	}

#endif /* !PCVT_KBD_FIFO */

#endif /* !XSERVER */

	else {
		if (noblock)
			return (NULL);
		else
			goto loop;
	}

	/* lets look what we got */
	switch (dt) {
	case KEYB_R_OVERRUN0:	/* keyboard buffer overflow */
#if PCVT_SCANSET == 2
	case KEYB_R_SELFOK:	/* keyboard selftest ok */
#endif /* PCVT_SCANSET == 2 */
	case KEYB_R_ECHO:	/* keyboard response to KEYB_C_ECHO */
	case KEYB_R_ACK:	/* acknowledge after command has rx'd*/
	case KEYB_R_SELFBAD:	/* keyboard selftest FAILED */
	case KEYB_R_DIAGBAD:	/* keyboard self diagnostic failure */
	case KEYB_R_RESEND:	/* keyboard wants us to resend cmnd */
	case KEYB_R_OVERRUN1:	/* keyboard buffer overflow */
		break;

	case KEYB_R_EXT1:	/* keyboard extended scancode pfx 2 */
		kbd_status.ext1 = 1;
		/* FALLTHROUGH */

	case KEYB_R_EXT0:	/* keyboard extended scancode pfx 1 */
		kbd_status.extended = 1;
		break;

#if PCVT_SCANSET == 2
	case KEYB_R_BREAKPFX:	/* break code prefix for set 2 and 3 */
		kbd_status.breakseen = 1;
		break;
#endif /* PCVT_SCANSET == 2 */

	default:
		goto regular;	/* regular key */
	}

	if (noblock)
		return (NULL);
	else
		goto loop;

	/* got a normal scan key */
regular:
#if PCVT_SCANSET == 1
	kbd_status.breakseen = dt & 0x80 ? 1 : 0;
	dt &= 0x7f;
#endif	/* PCVT_SCANSET == 1 */

	/*   make a keycode from scan code	*/
	if (dt >= sizeof scantokey / sizeof(u_char))
		key = 0;
	else
		key = kbd_status.extended ? extscantokey[dt] : scantokey[dt];

	if (kbd_status.ext1 && key == 64)
		/* virtual control key */
		key = 129;

	kbd_status.extended = kbd_status.ext1 = 0;

	if ((key == 85) && shift_down &&
	    (kbd_lastkey != 85 || !kbd_status.breakseen)) {
		if (vsp->scr_offset >= vsp->row) {
			if (!vsp->scrolling) {
				vsp->scrolling += vsp->row - 1;
				if (vsp->Scrollback) {
					scrollback_save_screen();
					if (vsp->scr_offset == vsp->max_off) {
						bcopy(vsp->Scrollback +
						      vsp->maxcol,
						      vsp->Scrollback,
						      vsp->maxcol *
						      vsp->max_off * CHR);
						vsp->scr_offset--;
					}
					bcopy(vsp->Crtat + vsp->cur_offset -
					      vsp->col, vsp->Scrollback +
				      	      (vsp->scr_offset + 1) *
					      vsp->maxcol, vsp->maxcol * CHR);
				}

				if (vsp->cursor_on)
					sw_cursor(0);
			}

			vsp->scrolling += vsp->screen_rows - 1;
			if (vsp->scrolling > vsp->scr_offset)
				vsp->scrolling = vsp->scr_offset;

			bcopy(vsp->Scrollback + ((vsp->scr_offset -
			      vsp->scrolling) * vsp->maxcol), vsp->Crtat,
			      vsp->screen_rows * vsp->maxcol * CHR);
		}

		kbd_lastkey = 85;
		goto loop;
	}
	else if ((key == 86) && shift_down &&
		(kbd_lastkey != 86 || !kbd_status.breakseen)) {
scroll_reset:
		if (vsp->scrolling > 0) {
			vsp->scrolling -= vsp->screen_rows - 1;
			if (vsp->scrolling < 0)
				vsp->scrolling = 0;

			if (vsp->scrolling <= vsp->row) {
				vsp->scrolling = 0;
				scrollback_restore_screen();
			}
			else {
				if (vsp->scrolling + 2 < vsp->screen_rows)
					fillw(user_attr | ' ',
					      (caddr_t)vsp->Crtat,
					      vsp->screen_rows * vsp->maxcol);

				bcopy(vsp->Scrollback + ((vsp->scr_offset -
			      	      vsp->scrolling) * vsp->maxcol),
			              vsp->Crtat, (vsp->scrolling + 2 <
				      vsp->screen_rows ? vsp->scrolling + 2 :
				      vsp->screen_rows) * vsp->maxcol * CHR);
			}
		}

		if (vsp->scrolling == 0) {
			if (vsp->cursor_on)
				sw_cursor(1);
		}

		if (noblock == 31337)
			return (NULL);

		if (key != 86)
			goto regular;
		else {
			kbd_lastkey = 86;
			goto loop;
		}
	}
	else if (vsp->scrolling && key != 128 && key != 44 && key != 85 &&
		 key != 86) {
			vsp->scrolling = 1;
			goto scroll_reset;
	     }

	if (kbd_reset && (key == 76) && ctrl_down && (meta_down||altgr_down)) {
		printf("\nconsole halt requested: going down.\n");
		kbd_reset = 0;
		psignal(initproc, SIGUSR1);
	}

#if NDDB > 0 || defined(DDB)		 /*   Check for cntl-alt-esc	*/
  	if ((key == 110) && ctrl_down && (meta_down || altgr_down)) {
 		static u_char in_Debugger;

 		if (!in_Debugger) {
 			in_Debugger = 1;
			if (db_console)
	 			Debugger();
 			in_Debugger = 0;

 			if (noblock)
 				return (NULL);
 			else
 				goto loop;
 		}
 	}
#endif /* NDDB > 0 || defined(DDB) */

	/* look for keys with special handling */
	if (key == 128) {
		/*
		 * virtual shift; sent around PrtScr, and around the arrow
		 * keys if the NumLck LED is on
		 */
		kbd_status.vshift = !kbd_status.breakseen;
		key = 0;	/* no key */
	}
	else if (key == 129) {
		/*
		 * virtual control - the most ugly thingie at all
		 * the Pause key sends:
		 * <virtual control make> <numlock make> <virtual control
		 * break> <numlock break>
		 */
		if (!kbd_status.breakseen)
			kbd_status.vcontrol = 1;
		/* else: let the numlock hook clear this */
		key = 0;	/* no key */
	}
	else if (key == 90) {
		/* NumLock, look whether this is rather a Pause */
		if (kbd_status.vcontrol)
			key = 126;
		/*
		 * if this is the final break code of a Pause key,
		 * clear the virtual control status, too
		 */
		if (kbd_status.vcontrol && kbd_status.breakseen)
			kbd_status.vcontrol = 0;
	}
	else if (key == 127) {
		/*
		 * a SysRq; some keyboards are brain-dead enough to
		 * repeat the SysRq key make code by sending PrtScr
		 * make codes; other keyboards do not repeat SysRq
		 * at all. We keep track of the SysRq state here.
		 */
		kbd_status.sysrq = !kbd_status.breakseen;
	}
	else if (key == 124) {
		/*
		 * PrtScr; look whether this is really PrtScr or rather
		 * a silly repeat of a SysRq key
		 */
		if (kbd_status.sysrq)
			/* ignore the garbage */
			key = 0;
	}

	/* in NOREPEAT MODE ignore the key if it was the same as before */

	if (!kbrepflag && key == kbd_lastkey && !kbd_status.breakseen) {
		if (noblock)
			return (NULL);
		else
			goto loop;
	}

	type = key2ascii[key].type;

	if (type & KBD_OVERLOAD)
		type = ovltbl[key2ascii[key].ovlindex].type;

	type &= KBD_MASK;

	switch (type) {
	case KBD_SHFTLOCK:
		if (!kbd_status.breakseen && key != kbd_lastkey)
			vsp->shift_lock ^= 1;
		break;

	case KBD_CAPS:
		if (!kbd_status.breakseen && key != kbd_lastkey) {
			vsp->caps_lock ^= 1;
			update_led();
		}
		break;

	case KBD_SCROLL:
		if (!kbd_status.breakseen && key != kbd_lastkey) {
			vsp->scroll_lock ^= 1;
			update_led();

			if (!(vsp->scroll_lock))
				wakeup((caddr_t)&(vsp->scroll_lock));
		}
		break;

	case KBD_SHIFT:
		shift_down = kbd_status.breakseen ? 0 : 1;
		break;

	case KBD_META:
		meta_down = kbd_status.breakseen ? 0 : 0x80;
		break;

	case KBD_ALTGR:
		altgr_down = kbd_status.breakseen ? 0 : 1;
		break;

	case KBD_CTL:
		ctrl_down = kbd_status.breakseen ? 0 : 1;
		break;

	case KBD_NONE:
	default:
		break;			/* deliver a key */
	}

	if (kbd_status.breakseen) {
		key |= 0x80;
		kbd_status.breakseen = 0;
		kbd_lastkey = 0; /* -hv- I know this is a bug with */
	}			 /* N-Key-Rollover, but I ignore that */
	else			 /* because avoidance is too complicated */
		kbd_lastkey = key;

	cp = xlatkey2ascii(key);	/* have a key */

	if (cp == NULL && !noblock)
		goto loop;

	return (cp);
}

/*---------------------------------------------------------------------------*
 *	reflect status of locking keys & set led's
 *---------------------------------------------------------------------------*/
static void
setlockkeys(int snc)
{
	vsp->scroll_lock = snc & 1;
	vsp->num_lock	 = (snc & 2) ? 1 : 0;
	vsp->caps_lock	 = (snc & 4) ? 1 : 0;
	update_led();
}

/*---------------------------------------------------------------------------*
 *	remove a key definition
 *---------------------------------------------------------------------------*/
static int
rmkeydef(int key)
{
	register Ovl_tbl *ref;

	if (key == 0 || key > MAXKEYNUM)
		return (EINVAL);

	if (key2ascii[key].type & KBD_OVERLOAD) {
		ref = &ovltbl[key2ascii[key].ovlindex];
		ref->keynum = 0;
		ref->type = 0;
		ref->unshift[0] =
		ref->shift[0] =
		ref->ctrl[0] =
		ref->altgr[0] = 0;
		key2ascii[key].type &= KBD_MASK;
	}
	return (0);
}

/*---------------------------------------------------------------------------*
 *	overlay a key
 *---------------------------------------------------------------------------*/
static int
setkeydef(Ovl_tbl *data)
{
	int i;

	if ( data->keynum > MAXKEYNUM		 ||
	    (data->type & KBD_MASK) == KBD_BREAK ||
	    (data->type & KBD_MASK) > KBD_SHFTLOCK)
		return (EINVAL);

	data->unshift[KBDMAXOVLKEYSIZE] =
	data->shift[KBDMAXOVLKEYSIZE] =
	data->ctrl[KBDMAXOVLKEYSIZE] =
	data->altgr[KBDMAXOVLKEYSIZE] = 0;

	data->subu =
	data->subs =
	data->subc =
	data->suba = KBD_SUBT_STR;		/* just strings .. */

	data->type |= KBD_OVERLOAD;		/* mark overloaded */

	/* if key already overloaded, use that slot else find free slot */

	if (key2ascii[data->keynum].type & KBD_OVERLOAD)
		i = key2ascii[data->keynum].ovlindex;
	else {
		for (i = 0; i < OVLTBL_SIZE; i++)
			if (ovltbl[i].keynum==0)
				break;

		if (i == OVLTBL_SIZE)
			return (ENOSPC); /* no space, abuse of ENOSPC(!) */
	}

	ovltbl[i] = *data;		/* copy new data string */

	key2ascii[data->keynum].type |= KBD_OVERLOAD; 	/* mark key */
	key2ascii[data->keynum].ovlindex = i;

	return (0);
}

/*---------------------------------------------------------------------------*
 *	keyboard ioctl's entry
 *---------------------------------------------------------------------------*/
int
kbdioctl(Dev_t dev, u_long cmd, caddr_t data, int flag)
{
	int key;

	switch (cmd) {
	case KBDRESET:
		doreset();
		ovlinit(1);
		settpmrate(KBD_TPD500 | KBD_TPM100);
		setlockkeys(0);
		break;

	case KBDGTPMAT:
		*(int *)data = tpmrate;
		break;

	case KBDSTPMAT:
		settpmrate(*(int *)data);
		break;

	case KBDGREPSW:
		*(int *)data = kbrepflag;
		break;

	case KBDSREPSW:
		kbrepflag = (*(int *)data) & 1;
		break;

	case KBDGLOCK:
		*(int *)data = ( (vsp->scroll_lock) | (vsp->num_lock * 2) |
				 (vsp->caps_lock * 4));
		break;

	case KBDSLOCK:
		setlockkeys(*(int *)data);
		break;

	case KBDGCKEY:
		key = ((Ovl_tbl *)data)->keynum;
		return (getckeydef(key,(Ovl_tbl *)data));

	case KBDSCKEY:
		key = ((Ovl_tbl *)data)->keynum;
		return (setkeydef((Ovl_tbl *)data));

	case KBDGOKEY:
		key = ((Ovl_tbl *)data)->keynum;
		return (getokeydef(key,(Ovl_tbl *)data));

	case KBDRMKEY:
		key = *(int *)data;
		return (rmkeydef(key));

	case KBDDEFAULT:
		ovlinit(1);
		break;

	default:
		/* proceed with vga ioctls */
		return (-1);
	}
	return (0);
}

/*---------------------------------------------------------------------------*
 *	convert ISO-8859 style keycode into IBM 437
 *---------------------------------------------------------------------------*/
static inline u_char
iso2ibm(u_char c)
{
	if (c < 0x80)
		return (c);
	return (iso2ibm437[c - 0x80]);
}

/*---------------------------------------------------------------------------*
 *	build up a USL style keyboard map
 *---------------------------------------------------------------------------*/
void
get_usl_keymap(keymap_t *map)
{
	int i;

	bzero((caddr_t)map, sizeof(keymap_t));

	map->n_keys = 0x59;	/* that many keys we know about */

	for(i = 1; i < N_KEYNUMS; i++) {
		Ovl_tbl kdef;
		u_char c;
		int j;
		int idx = key2scan1[i];

		if (idx == 0 || idx >= map->n_keys)
			continue;

		getckeydef(i, &kdef);
		kdef.type &= KBD_MASK;

		switch (kdef.type) {
		case KBD_ASCII:
		case KBD_RETURN:
			map->key[idx].map[0] = iso2ibm(kdef.unshift[0]);
			map->key[idx].map[1] = iso2ibm(kdef.shift[0]);
			map->key[idx].map[2] = map->key[idx].map[3] =
				iso2ibm(kdef.ctrl[0]);
			map->key[idx].map[4] = map->key[idx].map[5] =
				iso2ibm(c = kdef.altgr[0]);
			/*
			 * XXX this is a hack
			 * since we currently do not map strings to AltGr +
			 * shift, we attempt to use the unshifted AltGr
			 * definition here and try to toggle the case
			 * this should at least work for ISO8859 letters,
			 * but also for (e.g.) russian KOI-8 style
			 */
			if ((c & 0x7f) >= 0x40)
				map->key[idx].map[5] = iso2ibm(c ^ 0x20);
			break;

		case KBD_FUNC:
			/* we are only interested in F1 thru F12 here */
			if (i >= 112 && i <= 123) {
				map->key[idx].map[0] = i - 112 + 27;
				map->key[idx].spcl = 0x80;
			}
			break;

		case KBD_SHIFT:
			c = i == 44 ? 2 /* lSh */ : 3 /* rSh */;
			goto special;

		case KBD_CAPS:
			c = 4;
			goto special;

		case KBD_NUM:
			c = 5;
			goto special;

		case KBD_SCROLL:
			c = 6;
			goto special;

		case KBD_META:
			c = 7;
			goto special;

		case KBD_CTL:
			c = 9;
special:
			for(j = 0; j < NUM_STATES; j++)
				map->key[idx].map[j] = c;
			map->key[idx].spcl = 0xff;
			break;

		default:
			break;
		}
	}
}

/*---------------------------------------------------------------------------*
 *	switch keypad to numeric mode
 *---------------------------------------------------------------------------*/
void
vt_keynum(struct video_state *svsp)
{
	svsp->num_lock = 1;
	update_led();
}

/*---------------------------------------------------------------------------*
 *	switch keypad to application mode
 *---------------------------------------------------------------------------*/
void
vt_keyappl(struct video_state *svsp)
{
	svsp->num_lock = 0;
	update_led();
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 1
 *---------------------------------------------------------------------------*/
static void
fkey1(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[23~"; /* F11 */
	else
		more_chars = (u_char *)"\033OP"; /* F1 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 2
 *---------------------------------------------------------------------------*/
static void
fkey2(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[24~"; /* F12 */
	else
		more_chars = (u_char *)"\033OQ"; /* F2 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 3
 *---------------------------------------------------------------------------*/
static void
fkey3(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[25~"; /* F13 */
	else
		more_chars = (u_char *)"\033OR"; /* F3 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 4
 *---------------------------------------------------------------------------*/
static void
fkey4(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[26~"; /* F14 */
	else
		more_chars = (u_char *)"\033OS"; /* F4 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 5
 *---------------------------------------------------------------------------*/
static void
fkey5(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[28~"; /* Help */
	else
		more_chars = (u_char *)"\033[17~"; /* F5 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 6
 *---------------------------------------------------------------------------*/
static void
fkey6(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[29~"; /* DO */
	else
		more_chars = (u_char *)"\033[18~"; /* F6 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 7
 *---------------------------------------------------------------------------*/
static void
fkey7(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[31~"; /* F17 */
	else
		more_chars = (u_char *)"\033[19~"; /* F7 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 8
 *---------------------------------------------------------------------------*/
static void
fkey8(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[32~"; /* F18 */
	else
		more_chars = (u_char *)"\033[20~"; /* F8 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 9
 *---------------------------------------------------------------------------*/
static void
fkey9(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[33~"; /* F19 */
	else
		more_chars = (u_char *)"\033[21~"; /* F9 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 10
 *---------------------------------------------------------------------------*/
static void
fkey10(void)
{
	if (meta_down)
		more_chars = (u_char *)"\033[34~"; /* F20 */
	else
		more_chars = (u_char *)"\033[29~"; /* F10 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 11
 *---------------------------------------------------------------------------*/
static void
fkey11(void)
{
	if (meta_down)
		more_chars = (u_char *)"\0x8FP"; /* PF1 */
	else
		more_chars = (u_char *)"\033[23~"; /* F11 */
}

/*---------------------------------------------------------------------------*
 *	function bound to function key 12
 *---------------------------------------------------------------------------*/
static void
fkey12(void)
{
	if (meta_down)
		more_chars = (u_char *)"\0x8FQ"; /* PF2 */
	else
		more_chars = (u_char *)"\033[24~"; /* F12 */
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 1
 *---------------------------------------------------------------------------*/
static void
sfkey1(void)
{
	if (meta_down) {
		if (vsp->ukt.length[6])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[6]]);
		else
			more_chars = (u_char *)"\033[23~"; /* F11 */
	}
	else
		do_vgapage(4);
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 2
 *---------------------------------------------------------------------------*/
static void
sfkey2(void)
{
	if (meta_down) {
		if (vsp->ukt.length[7])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[7]]);
		else
			more_chars = (u_char *)"\033[24~"; /* F12 */
	}
	else
		do_vgapage(5);
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 3
 *---------------------------------------------------------------------------*/
static void
sfkey3(void)
{
	if (meta_down) {
		if (vsp->ukt.length[8])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[8]]);
		else
			more_chars = (u_char *)"\033[25~"; /* F13 */
	}
	else
		do_vgapage(6);
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 4
 *---------------------------------------------------------------------------*/
static void
sfkey4(void)
{
	if (meta_down) {
		if (vsp->ukt.length[9])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[9]]);
		else
			more_chars = (u_char *)"\033[26~"; /* F14 */
	}
	else
		do_vgapage(7);
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 5
 *---------------------------------------------------------------------------*/
static void
sfkey5(void)
{
	if (meta_down) {
		if (vsp->ukt.length[11])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[11]]);
		else
			more_chars = (u_char *)"\033[28~"; /* Help */
	}
	else {
		if (current_video_screen <= 0)
			do_vgapage(totalscreens-1);
		else
			do_vgapage(current_video_screen - 1);
	}
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 6
 *---------------------------------------------------------------------------*/
static void
sfkey6(void)
{
	if (!meta_down) {
		if (vsp->ukt.length[0])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[0]]);
		else
			more_chars = (u_char *)"\033[17~"; /* F6 */
	}
	else if (vsp->ukt.length[12])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[12]]);
	     else
			more_chars = (u_char *)"\033[29~"; /* DO */
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 7
 *---------------------------------------------------------------------------*/
static void
sfkey7(void)
{
	if (!meta_down) {
		if (vsp->ukt.length[1])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[1]]);
		else
			more_chars = (u_char *)"\033[18~"; /* F7 */
	}
	else if (vsp->ukt.length[14])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[14]]);
	     else
			more_chars = (u_char *)"\033[31~"; /* F17 */
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 8
 *---------------------------------------------------------------------------*/
static void
sfkey8(void)
{
	if (!meta_down) {
		if (vsp->ukt.length[2])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[2]]);
		else
			more_chars = (u_char *)"\033[19~"; /* F8 */
	}
	else if (vsp->ukt.length[14])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[15]]);
	     else
			more_chars = (u_char *)"\033[32~"; /* F18 */
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 9
 *---------------------------------------------------------------------------*/
static void
sfkey9(void)
{
	if (!meta_down) {
		if (vsp->ukt.length[3])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[3]]);
		else
			more_chars = (u_char *)"\033[20~"; /* F9 */
	}
	else if (vsp->ukt.length[16])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[16]]);
	     else
			more_chars = (u_char *)"\033[33~"; /* F19 */
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 10
 *---------------------------------------------------------------------------*/
static void
sfkey10(void)
{
	if (!meta_down) {
		if (vsp->ukt.length[4])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[4]]);
		else
			more_chars = (u_char *)"\033[21~"; /* F10 */
	}
	else if (vsp->ukt.length[17])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[17]]);
	     else
			more_chars = (u_char *)"\033[34~"; /* F20 */
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 11
 *---------------------------------------------------------------------------*/
static void
sfkey11(void)
{
	if (!meta_down) {
		if (vsp->ukt.length[6])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[6]]);
		else
			more_chars = (u_char *)"\033[23~"; /* F11 */
	}
}

/*---------------------------------------------------------------------------*
 *	function bound to SHIFTED function key 12
 *---------------------------------------------------------------------------*/
static void
sfkey12(void)
{
	if (!meta_down) {
		if (vsp->ukt.length[7])	/* entry available ? */
			more_chars = (u_char *)
				&(vsp->udkbuf[vsp->ukt.first[7]]);
		else
			more_chars = (u_char *)"\033[24~"; /* F12 */
	}
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 1
 *---------------------------------------------------------------------------*/
static void
cfkey1(void)
{
	if (meta_down)
		do_vgapage(0);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 2
 *---------------------------------------------------------------------------*/
static void
cfkey2(void)
{
	if (meta_down)
		do_vgapage(1);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 3
 *---------------------------------------------------------------------------*/
static void
cfkey3(void)
{
	if (meta_down)
		do_vgapage(2);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 4
 *---------------------------------------------------------------------------*/
static void
cfkey4(void)
{
	if (meta_down)
		do_vgapage(3);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 5
 *---------------------------------------------------------------------------*/
static void
cfkey5(void)
{
	if (meta_down)
		do_vgapage(4);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 6
 *---------------------------------------------------------------------------*/
static void
cfkey6(void)
{
	if (meta_down)
		do_vgapage(5);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 7
 *---------------------------------------------------------------------------*/
static void
cfkey7(void)
{
	if (meta_down)
		do_vgapage(6);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 8
 *---------------------------------------------------------------------------*/
static void
cfkey8(void)
{
	if (meta_down)
		do_vgapage(7);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 9
 *---------------------------------------------------------------------------*/
static void
cfkey9(void)
{
	if (meta_down)
		do_vgapage(8);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 10
 *---------------------------------------------------------------------------*/
static void
cfkey10(void)
{
	if (meta_down)
		do_vgapage(9);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 11
 *---------------------------------------------------------------------------*/
static void
cfkey11(void)
{
	if (meta_down)
		do_vgapage(10);
}

/*---------------------------------------------------------------------------*
 *	function bound to control function key 12
 *---------------------------------------------------------------------------*/
static void
cfkey12(void)
{
	if (meta_down)
		do_vgapage(11);
}

/* #endif */	/* NVT > 0 */

static void
scrollback_save_screen(void)
{
	int x = spltty();
	register size_t s;

	s = sizeof(u_short) * vsp->screen_rowsize * vsp->maxcol;

	if (scrollback_savedscreen)
		free(scrollback_savedscreen, M_TEMP);

	scrnsv_size = s;

	if (!(scrollback_savedscreen = (u_short *)malloc(s, M_TEMP, M_NOWAIT))){
		splx(x);
		return;
	}
	bcopy(vsp->Crtat, scrollback_savedscreen, scrnsv_size);
	splx(x);
}

static void
scrollback_restore_screen(void)
{
	if (scrollback_savedscreen)
		bcopy(scrollback_savedscreen, vsp->Crtat, scrnsv_size);
}

/* ------------------------------- EOF -------------------------------------*/