initial import of NetBSD tree

1 files changed, 861 insertions, 0 deletions

diff --git a/sys/arch/alpha/isa/pckbd.c b/sys/arch/alpha/isa/pckbd.c
new file mode 100644
index 00000000000..4dacd3f1d3b
--- /dev/null
+++ b/sys/arch/alpha/isa/pckbd.c
@@ -0,0 +1,861 @@
+/*	$NetBSD: pckbd.c,v 1.1 1995/08/03 00:48:25 cgd Exp $	*/
+
+/*-
+ * Copyright (c) 1993, 1994, 1995 Charles Hannum.  All rights reserved.
+ * 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.
+ * 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.
+ *
+ * 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.
+ *
+ *	@(#)pccons.c	5.11 (Berkeley) 5/21/91
+ */
+
+/*
+ * code to work keyboard & display for PC-style console
+ */
+
+#include <sys/param.h>
+#include <sys/conf.h>
+#include <sys/ioctl.h>
+#include <sys/proc.h>
+#include <sys/user.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/device.h>
+
+#include <machine/cpu.h>
+#include <machine/pio.h>
+
+#include <dev/isa/isareg.h>
+#include <dev/isa/isavar.h>
+#include <alpha/isa/pckbdreg.h>
+
+static volatile u_char ack, nak;	/* Don't ask. */
+static u_char async, kernel, polling;	/* Really, you don't want to know. */
+static u_char lock_state = 0x00,	/* all off */
+	      old_lock_state = 0xff,
+	      typematic_rate = 0xff,	/* don't update until set by user */
+	      old_typematic_rate = 0xff;
+
+struct pckbd_softc {
+        struct  device sc_dev;
+        void    *sc_ih;
+};
+
+int pckbdprobe __P((struct device *, void *, void *));
+void pckbdattach __P((struct device *, struct device *, void *));
+int pckbdintr __P((void *));
+
+struct cfdriver pckbdcd = {
+	NULL, "pckbd", pckbdprobe, pckbdattach, DV_DULL,
+	    sizeof(struct pckbd_softc)
+};
+
+char *sget __P((void));
+int pccngetc __P((void *));
+void pccnpollc __P((void *, int));
+
+/*
+ * DANGER WIL ROBINSON -- the values of SCROLL, NUM, CAPS, and ALT are
+ * important.
+ */
+#define	SCROLL		0x0001	/* stop output */
+#define	NUM		0x0002	/* numeric shift  cursors vs. numeric */
+#define	CAPS		0x0004	/* caps shift -- swaps case of letter */
+#define	SHIFT		0x0008	/* keyboard shift */
+#define	CTL		0x0010	/* control shift  -- allows ctl function */
+#define	ASCII		0x0020	/* ascii code for this key */
+#define	ALT		0x0080	/* alternate shift -- alternate chars */
+#define	FUNC		0x0100	/* function key */
+#define	KP		0x0200	/* Keypad keys */
+#define	NONE		0x0400	/* no function */
+
+#define	KBD_DELAY \
+	{ u_char x = inb(0x84); } \
+	{ u_char x = inb(0x84); } \
+	{ u_char x = inb(0x84); } \
+	{ u_char x = inb(0x84); }
+
+static inline int
+kbd_wait_output()
+{
+	u_int i;
+
+	for (i = 100000; i; i--)
+		if ((inb(KBSTATP) & KBS_IBF) == 0) {
+			KBD_DELAY;
+			return 1;
+		}
+	return 0;
+}
+
+static inline int
+kbd_wait_input()
+{
+	u_int i;
+
+	for (i = 100000; i; i--)
+		if ((inb(KBSTATP) & KBS_DIB) != 0) {
+			KBD_DELAY;
+			return 1;
+		}
+	return 0;
+}
+
+static inline void
+kbd_flush_input()
+{
+	u_int i;
+
+	for (i = 10; i; i--) {
+		if ((inb(KBSTATP) & KBS_DIB) == 0)
+			return;
+		KBD_DELAY;
+		(void) inb(KBDATAP);
+	}
+}
+
+#if 1
+/*
+ * Get the current command byte.
+ */
+static u_char
+kbc_get8042cmd()
+{
+
+	if (!kbd_wait_output())
+		return -1;
+	outb(KBCMDP, K_RDCMDBYTE);
+	if (!kbd_wait_input())
+		return -1;
+	return inb(KBDATAP);
+}
+#endif
+
+/*
+ * Pass command byte to keyboard controller (8042).
+ */
+static int
+kbc_put8042cmd(val)
+	u_char val;
+{
+
+	if (!kbd_wait_output())
+		return 0;
+	outb(KBCMDP, K_LDCMDBYTE);
+	if (!kbd_wait_output())
+		return 0;
+	outb(KBOUTP, val);
+	return 1;
+}
+
+/*
+ * Pass command to keyboard itself
+ */
+int
+kbd_cmd(val, polling)
+	u_char val;
+	u_char polling;
+{
+	u_int retries = 3;
+	register u_int i;
+
+	do {
+		if (!kbd_wait_output())
+			return 0;
+		ack = nak = 0;
+		outb(KBOUTP, val);
+		if (polling)
+			for (i = 100000; i; i--) {
+				if (inb(KBSTATP) & KBS_DIB) {
+					register u_char c;
+
+					KBD_DELAY;
+					c = inb(KBDATAP);
+					if (c == KBR_ACK || c == KBR_ECHO) {
+						ack = 1;
+						return 1;
+					}
+					if (c == KBR_RESEND) {
+						nak = 1;
+						break;
+					}
+#ifdef DIAGNOSTIC
+					printf("kbd_cmd: input char %x lost\n", c);
+#endif
+				}
+			}
+		else
+			for (i = 100000; i; i--) {
+				(void) inb(KBSTATP);
+				if (ack)
+					return 1;
+				if (nak)
+					break;
+			}
+		if (!nak)
+			return 0;
+	} while (--retries);
+	return 0;
+}
+
+/*
+ * these are both bad jokes
+ */
+int
+pckbdprobe(parent, match, aux)
+	struct device *parent;
+	void *match, *aux;
+{
+	struct isa_attach_args *ia = aux;
+	u_int i;
+
+	/* Enable interrupts and keyboard, etc. */
+	if (!kbc_put8042cmd(CMDBYTE)) {
+		printf("pcprobe: command error\n");
+		return 0;
+	}
+
+#if 1
+	/* Flush any garbage. */
+	kbd_flush_input();
+	/* Reset the keyboard. */
+	if (!kbd_cmd(KBC_RESET, 1)) {
+		printf("pcprobe: reset error %d\n", 1);
+		goto lose;
+	}
+	for (i = 600000; i; i--)
+		if ((inb(KBSTATP) & KBS_DIB) != 0) {
+			KBD_DELAY;
+			break;
+		}
+	if (i == 0 || inb(KBDATAP) != KBR_RSTDONE) {
+		printf("pcprobe: reset error %d\n", 2);
+		goto lose;
+	}
+	/*
+	 * Some keyboards seem to leave a second ack byte after the reset.
+	 * This is kind of stupid, but we account for them anyway by just
+	 * flushing the buffer.
+	 */
+	kbd_flush_input();
+	/* Just to be sure. */
+	if (!kbd_cmd(KBC_ENABLE, 1)) {
+		printf("pcprobe: reset error %d\n", 3);
+		goto lose;
+	}
+
+	/*
+	 * Some keyboard/8042 combinations do not seem to work if the keyboard
+	 * is set to table 1; in fact, it would appear that some keyboards just
+	 * ignore the command altogether.  So by default, we use the AT scan
+	 * codes and have the 8042 translate them.  Unfortunately, this is
+	 * known to not work on some PS/2 machines.  We try desparately to deal
+	 * with this by checking the (lack of a) translate bit in the 8042 and
+	 * attempting to set the keyboard to XT mode.  If this all fails, well,
+	 * tough luck.
+	 *
+	 * XXX It would perhaps be a better choice to just use AT scan codes
+	 * and not bother with this.
+	 */
+	if (kbc_get8042cmd() & KC8_TRANS) {
+		/* The 8042 is translating for us; use AT codes. */
+		if (!kbd_cmd(KBC_SETTABLE, 1) || !kbd_cmd(2, 1)) {
+			printf("pcprobe: reset error %d\n", 4);
+			goto lose;
+		}
+	} else {
+		/* Stupid 8042; set keyboard to XT codes. */
+		if (!kbd_cmd(KBC_SETTABLE, 1) || !kbd_cmd(1, 1)) {
+			printf("pcprobe: reset error %d\n", 5);
+			goto lose;
+		}
+	}
+
+lose:
+	/*
+	 * Technically, we should probably fail the probe.  But we'll be nice
+	 * and allow keyboard-less machines to boot with the console.
+	 */
+#endif
+
+	ia->ia_iosize = 16;
+	ia->ia_msize = 0;
+	return 1;
+}
+
+void
+pckbdattach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+	struct pckbd_softc *sc = (void *)self;
+	struct isa_attach_args *ia = aux;
+
+	printf("\n");
+	sc->sc_ih = isa_intr_establish(ia->ia_irq, ISA_IST_EDGE, ISA_IPL_TTY,
+	    pckbdintr, sc);
+	wscattach_input(self, self, pccngetc, pccnpollc);
+}
+
+/*
+ * Got a console receive interrupt -
+ * the console processor wants to give us a character.
+ * Catch the character, and see who it goes to.
+ */
+int
+pckbdintr(arg)
+	void *arg;
+{
+	struct pckbd_softc *sc = arg;
+	u_char *cp;
+
+	if ((inb(KBSTATP) & KBS_DIB) == 0)
+		return 0;
+	if (polling)
+		return 1;
+	do {
+		cp = sget();
+		if (cp)
+			wscons_kbdinput(cp);
+	} while (inb(KBSTATP) & KBS_DIB);
+	return 1;
+}
+
+void
+do_async_update(poll)
+	u_char poll;
+{
+	int pos;
+	static int old_pos = -1;
+
+	async = 0;
+
+	if (lock_state != old_lock_state) {
+		old_lock_state = lock_state;
+		if (!kbd_cmd(KBC_MODEIND, poll) ||
+		    !kbd_cmd(lock_state, poll)) {
+			printf("pc: timeout updating leds\n");
+			(void) kbd_cmd(KBC_ENABLE, poll);
+		}
+	}
+	if (typematic_rate != old_typematic_rate) {
+		old_typematic_rate = typematic_rate;
+		if (!kbd_cmd(KBC_TYPEMATIC, poll) ||
+		    !kbd_cmd(typematic_rate, poll)) {
+			printf("pc: timeout updating typematic rate\n");
+			(void) kbd_cmd(KBC_ENABLE, poll);
+		}
+	}
+}
+
+void
+async_update()
+{
+
+	if (kernel || polling) {
+		if (async)
+			untimeout(do_async_update, NULL);
+		do_async_update(1);
+	} else {
+		if (async)
+			return;
+		async = 1;
+		timeout(do_async_update, NULL, 1);
+	}
+}
+
+#if 0
+int
+pcioctl(dev, cmd, data, flag, p)
+	dev_t dev;
+	u_long cmd;
+	caddr_t data;
+	int flag;
+	struct proc *p;
+{
+	struct pc_softc *sc = pccd.cd_devs[PCUNIT(dev)];
+	int error;
+
+	error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
+	if (error >= 0)
+		return error;
+	error = ttioctl(tp, cmd, data, flag, p);
+	if (error >= 0)
+		return error;
+
+	switch (cmd) {
+	case CONSOLE_X_MODE_ON:
+		pc_xmode_on();
+		return 0;
+	case CONSOLE_X_MODE_OFF:
+		pc_xmode_off();
+		return 0;
+	case CONSOLE_X_BELL:
+		/*
+		 * If set, data is a pointer to a length 2 array of
+		 * integers.  data[0] is the pitch in Hz and data[1]
+		 * is the duration in msec.
+		 */
+		if (data)
+			sysbeep(((int*)data)[0],
+				(((int*)data)[1] * hz) / 1000);
+		else
+			sysbeep(BEEP_FREQ, BEEP_TIME);
+		return 0;
+	case CONSOLE_SET_TYPEMATIC_RATE: {
+ 		u_char	rate;
+
+ 		if (!data)
+			return EINVAL;
+		rate = *((u_char *)data);
+		/*
+		 * Check that it isn't too big (which would cause it to be
+		 * confused with a command).
+		 */
+		if (rate & 0x80)
+			return EINVAL;
+		typematic_rate = rate;
+		async_update();
+		return 0;
+ 	}
+	default:
+		return ENOTTY;
+	}
+
+#ifdef DIAGNOSTIC
+	panic("pcioctl: impossible");
+#endif
+}
+#endif
+
+#define	CODE_SIZE	4		/* Use a max of 4 for now... */
+typedef struct {
+	u_short	type;
+	char unshift[CODE_SIZE];
+	char shift[CODE_SIZE];
+	char ctl[CODE_SIZE];
+} Scan_def;
+
+static Scan_def	scan_codes[] = {
+	NONE,	"",		"",		"",		/* 0 unused */
+	ASCII,	"\033",		"\033",		"\033",		/* 1 ESCape */
+	ASCII,	"1",		"!",		"!",		/* 2 1 */
+	ASCII,	"2",		"@",		"\000",		/* 3 2 */
+	ASCII,	"3",		"#",		"#",		/* 4 3 */
+	ASCII,	"4",		"$",		"$",		/* 5 4 */
+	ASCII,	"5",		"%",		"%",		/* 6 5 */
+	ASCII,	"6",		"^",		"\036",		/* 7 6 */
+	ASCII,	"7",		"&",		"&",		/* 8 7 */
+	ASCII,	"8",		"*",		"\010",		/* 9 8 */
+	ASCII,	"9",		"(",		"(",		/* 10 9 */
+	ASCII,	"0",		")",		")",		/* 11 0 */
+	ASCII,	"-",		"_",		"\037",		/* 12 - */
+	ASCII,	"=",		"+",		"+",		/* 13 = */
+	ASCII,	"\177",		"\177",		"\010",		/* 14 backspace */
+	ASCII,	"\t",		"\177\t",	"\t",		/* 15 tab */
+	ASCII,	"q",		"Q",		"\021",		/* 16 q */
+	ASCII,	"w",		"W",		"\027",		/* 17 w */
+	ASCII,	"e",		"E",		"\005",		/* 18 e */
+	ASCII,	"r",		"R",		"\022",		/* 19 r */
+	ASCII,	"t",		"T",		"\024",		/* 20 t */
+	ASCII,	"y",		"Y",		"\031",		/* 21 y */
+	ASCII,	"u",		"U",		"\025",		/* 22 u */
+	ASCII,	"i",		"I",		"\011",		/* 23 i */
+	ASCII,	"o",		"O",		"\017",		/* 24 o */
+	ASCII,	"p",		"P",		"\020",		/* 25 p */
+	ASCII,	"[",		"{",		"\033",		/* 26 [ */
+	ASCII,	"]",		"}",		"\035",		/* 27 ] */
+	ASCII,	"\r",		"\r",		"\n",		/* 28 return */
+	CTL,	"",		"",		"",		/* 29 control */
+	ASCII,	"a",		"A",		"\001",		/* 30 a */
+	ASCII,	"s",		"S",		"\023",		/* 31 s */
+	ASCII,	"d",		"D",		"\004",		/* 32 d */
+	ASCII,	"f",		"F",		"\006",		/* 33 f */
+	ASCII,	"g",		"G",		"\007",		/* 34 g */
+	ASCII,	"h",		"H",		"\010",		/* 35 h */
+	ASCII,	"j",		"J",		"\n",		/* 36 j */
+	ASCII,	"k",		"K",		"\013",		/* 37 k */
+	ASCII,	"l",		"L",		"\014",		/* 38 l */
+	ASCII,	";",		":",		";",		/* 39 ; */
+	ASCII,	"'",		"\"",		"'",		/* 40 ' */
+	ASCII,	"`",		"~",		"`",		/* 41 ` */
+	SHIFT,	"",		"",		"",		/* 42 shift */
+	ASCII,	"\\",		"|",		"\034",		/* 43 \ */
+	ASCII,	"z",		"Z",		"\032",		/* 44 z */
+	ASCII,	"x",		"X",		"\030",		/* 45 x */
+	ASCII,	"c",		"C",		"\003",		/* 46 c */
+	ASCII,	"v",		"V",		"\026",		/* 47 v */
+	ASCII,	"b",		"B",		"\002",		/* 48 b */
+	ASCII,	"n",		"N",		"\016",		/* 49 n */
+	ASCII,	"m",		"M",		"\r",		/* 50 m */
+	ASCII,	",",		"<",		"<",		/* 51 , */
+	ASCII,	".",		">",		">",		/* 52 . */
+	ASCII,	"/",		"?",		"\037",		/* 53 / */
+	SHIFT,	"",		"",		"",		/* 54 shift */
+	KP,	"*",		"*",		"*",		/* 55 kp * */
+	ALT,	"",		"",		"",		/* 56 alt */
+	ASCII,	" ",		" ",		"\000",		/* 57 space */
+	CAPS,	"",		"",		"",		/* 58 caps */
+	FUNC,	"\033[M",	"\033[Y",	"\033[k",	/* 59 f1 */
+	FUNC,	"\033[N",	"\033[Z",	"\033[l",	/* 60 f2 */
+	FUNC,	"\033[O",	"\033[a",	"\033[m",	/* 61 f3 */
+	FUNC,	"\033[P",	"\033[b",	"\033[n",	/* 62 f4 */
+	FUNC,	"\033[Q",	"\033[c",	"\033[o",	/* 63 f5 */
+	FUNC,	"\033[R",	"\033[d",	"\033[p",	/* 64 f6 */
+	FUNC,	"\033[S",	"\033[e",	"\033[q",	/* 65 f7 */
+	FUNC,	"\033[T",	"\033[f",	"\033[r",	/* 66 f8 */
+	FUNC,	"\033[U",	"\033[g",	"\033[s",	/* 67 f9 */
+	FUNC,	"\033[V",	"\033[h",	"\033[t",	/* 68 f10 */
+	NUM,	"",		"",		"",		/* 69 num lock */
+	SCROLL,	"",		"",		"",		/* 70 scroll lock */
+	KP,	"7",		"\033[H",	"7",		/* 71 kp 7 */
+	KP,	"8",		"\033[A",	"8",		/* 72 kp 8 */
+	KP,	"9",		"\033[I",	"9",		/* 73 kp 9 */
+	KP,	"-",		"-",		"-",		/* 74 kp - */
+	KP,	"4",		"\033[D",	"4",		/* 75 kp 4 */
+	KP,	"5",		"\033[E",	"5",		/* 76 kp 5 */
+	KP,	"6",		"\033[C",	"6",		/* 77 kp 6 */
+	KP,	"+",		"+",		"+",		/* 78 kp + */
+	KP,	"1",		"\033[F",	"1",		/* 79 kp 1 */
+	KP,	"2",		"\033[B",	"2",		/* 80 kp 2 */
+	KP,	"3",		"\033[G",	"3",		/* 81 kp 3 */
+	KP,	"0",		"\033[L",	"0",		/* 82 kp 0 */
+	KP,	".",		"\177",		".",		/* 83 kp . */
+	NONE,	"",		"",		"",		/* 84 0 */
+	NONE,	"100",		"",		"",		/* 85 0 */
+	NONE,	"101",		"",		"",		/* 86 0 */
+	FUNC,	"\033[W",	"\033[i",	"\033[u",	/* 87 f11 */
+	FUNC,	"\033[X",	"\033[j",	"\033[v",	/* 88 f12 */
+	NONE,	"102",		"",		"",		/* 89 0 */
+	NONE,	"103",		"",		"",		/* 90 0 */
+	NONE,	"",		"",		"",		/* 91 0 */
+	NONE,	"",		"",		"",		/* 92 0 */
+	NONE,	"",		"",		"",		/* 93 0 */
+	NONE,	"",		"",		"",		/* 94 0 */
+	NONE,	"",		"",		"",		/* 95 0 */
+	NONE,	"",		"",		"",		/* 96 0 */
+	NONE,	"",		"",		"",		/* 97 0 */
+	NONE,	"",		"",		"",		/* 98 0 */
+	NONE,	"",		"",		"",		/* 99 0 */
+	NONE,	"",		"",		"",		/* 100 */
+	NONE,	"",		"",		"",		/* 101 */
+	NONE,	"",		"",		"",		/* 102 */
+	NONE,	"",		"",		"",		/* 103 */
+	NONE,	"",		"",		"",		/* 104 */
+	NONE,	"",		"",		"",		/* 105 */
+	NONE,	"",		"",		"",		/* 106 */
+	NONE,	"",		"",		"",		/* 107 */
+	NONE,	"",		"",		"",		/* 108 */
+	NONE,	"",		"",		"",		/* 109 */
+	NONE,	"",		"",		"",		/* 110 */
+	NONE,	"",		"",		"",		/* 111 */
+	NONE,	"",		"",		"",		/* 112 */
+	NONE,	"",		"",		"",		/* 113 */
+	NONE,	"",		"",		"",		/* 114 */
+	NONE,	"",		"",		"",		/* 115 */
+	NONE,	"",		"",		"",		/* 116 */
+	NONE,	"",		"",		"",		/* 117 */
+	NONE,	"",		"",		"",		/* 118 */
+	NONE,	"",		"",		"",		/* 119 */
+	NONE,	"",		"",		"",		/* 120 */
+	NONE,	"",		"",		"",		/* 121 */
+	NONE,	"",		"",		"",		/* 122 */
+	NONE,	"",		"",		"",		/* 123 */
+	NONE,	"",		"",		"",		/* 124 */
+	NONE,	"",		"",		"",		/* 125 */
+	NONE,	"",		"",		"",		/* 126 */
+	NONE,	"",		"",		"",		/* 127 */
+};
+
+/*
+ * Get characters from the keyboard.  If none are present, return NULL.
+ */
+char *
+sget()
+{
+	u_char dt;
+	static u_char extended = 0, shift_state = 0;
+	static u_char capchar[2];
+
+top:
+	KBD_DELAY;
+	dt = inb(KBDATAP);
+
+	switch (dt) {
+	case KBR_ACK:
+		ack = 1;
+		goto loop;
+	case KBR_RESEND:
+		nak = 1;
+		goto loop;
+	}
+
+#if 0
+	if (pc_xmode > 0) {
+#if defined(DDB) && defined(XSERVER_DDB)
+		/* F12 enters the debugger while in X mode */
+		if (dt == 88)
+			Debugger();
+#endif
+		capchar[0] = dt;
+		capchar[1] = 0;
+		/*
+		 * Check for locking keys.
+		 *
+		 * XXX Setting the LEDs this way is a bit bogus.  What if the
+		 * keyboard has been remapped in X?
+		 */
+		switch (scan_codes[dt & 0x7f].type) {
+		case NUM:
+			if (dt & 0x80) {
+				shift_state &= ~NUM;
+				break;
+			}
+			if (shift_state & NUM)
+				break;
+			shift_state |= NUM;
+			lock_state ^= NUM;
+			async_update();
+			break;
+		case CAPS:
+			if (dt & 0x80) {
+				shift_state &= ~CAPS;
+				break;
+			}
+			if (shift_state & CAPS)
+				break;
+			shift_state |= CAPS;
+			lock_state ^= CAPS;
+			async_update();
+			break;
+		case SCROLL:
+			if (dt & 0x80) {
+				shift_state &= ~SCROLL;
+				break;
+			}
+			if (shift_state & SCROLL)
+				break;
+			shift_state |= SCROLL;
+			lock_state ^= SCROLL;
+			if ((lock_state & SCROLL) == 0)
+				wakeup((caddr_t)&lock_state);
+			async_update();
+			break;
+		}
+		return capchar;
+	}
+#endif /* 0 */
+
+	switch (dt) {
+	case KBR_EXTENDED:
+		extended = 1;
+		goto loop;
+	}
+
+#ifdef DDB
+	/*
+	 * Check for cntl-alt-esc.
+	 */
+	if ((dt == 1) && (shift_state & (CTL | ALT)) == (CTL | ALT)) {
+		Debugger();
+		dt |= 0x80;	/* discard esc (ddb discarded ctl-alt) */
+	}
+#endif
+
+	/*
+	 * Check for make/break.
+	 */
+	if (dt & 0x80) {
+		/*
+		 * break
+		 */
+		dt &= 0x7f;
+		switch (scan_codes[dt].type) {
+		case NUM:
+			shift_state &= ~NUM;
+			break;
+		case CAPS:
+			shift_state &= ~CAPS;
+			break;
+		case SCROLL:
+			shift_state &= ~SCROLL;
+			break;
+		case SHIFT:
+			shift_state &= ~SHIFT;
+			break;
+		case ALT:
+			shift_state &= ~ALT;
+			break;
+		case CTL:
+			shift_state &= ~CTL;
+			break;
+		}
+	} else {
+		/*
+		 * make
+		 */
+		switch (scan_codes[dt].type) {
+		/*
+		 * locking keys
+		 */
+		case NUM:
+			if (shift_state & NUM)
+				break;
+			shift_state |= NUM;
+			lock_state ^= NUM;
+			async_update();
+			break;
+		case CAPS:
+			if (shift_state & CAPS)
+				break;
+			shift_state |= CAPS;
+			lock_state ^= CAPS;
+			async_update();
+			break;
+		case SCROLL:
+			if (shift_state & SCROLL)
+				break;
+			shift_state |= SCROLL;
+			lock_state ^= SCROLL;
+			if ((lock_state & SCROLL) == 0)
+				wakeup((caddr_t)&lock_state);
+			async_update();
+			break;
+		/*
+		 * non-locking keys
+		 */
+		case SHIFT:
+			shift_state |= SHIFT;
+			break;
+		case ALT:
+			shift_state |= ALT;
+			break;
+		case CTL:
+			shift_state |= CTL;
+			break;
+		case ASCII:
+			/* control has highest priority */
+			if (shift_state & CTL)
+				capchar[0] = scan_codes[dt].ctl[0];
+			else if (shift_state & SHIFT)
+				capchar[0] = scan_codes[dt].shift[0];
+			else
+				capchar[0] = scan_codes[dt].unshift[0];
+			if ((lock_state & CAPS) && capchar[0] >= 'a' &&
+			    capchar[0] <= 'z') {
+				capchar[0] -= ('a' - 'A');
+			}
+			capchar[0] |= (shift_state & ALT);
+			extended = 0;
+			return capchar;
+		case NONE:
+			break;
+		case FUNC: {
+			char *more_chars;
+			if (shift_state & SHIFT)
+				more_chars = scan_codes[dt].shift;
+			else if (shift_state & CTL)
+				more_chars = scan_codes[dt].ctl;
+			else
+				more_chars = scan_codes[dt].unshift;
+			extended = 0;
+			return more_chars;
+		}
+		case KP: {
+			char *more_chars;
+			if (shift_state & (SHIFT | CTL) ||
+			    (lock_state & NUM) == 0 || extended)
+				more_chars = scan_codes[dt].shift;
+			else
+				more_chars = scan_codes[dt].unshift;
+			extended = 0;
+			return more_chars;
+		}
+		}
+	}
+
+	extended = 0;
+loop:
+	if ((inb(KBSTATP) & KBS_DIB) == 0)
+		return 0;
+	goto top;
+}
+
+
+/* ARGSUSED */
+int
+pccngetc(cookie)
+        void *cookie;
+{
+        register char *cp;
+
+#if 0
+        if (pc_xmode > 0)
+                return 0;
+#endif
+
+        do {
+                /* wait for byte */
+                while ((inb(KBSTATP) & KBS_DIB) == 0);
+                /* see if it's worthwhile */
+                cp = sget();
+        } while (!cp);
+        if (*cp == '\r')
+                return '\n';
+        return *cp;
+}
+
+void
+pccnpollc(cookie, on)
+        void *cookie;
+        int on;
+{
+	struct pckbd_softc *sc = cookie;
+
+        polling = on;
+        if (!on) {
+                int s;
+
+                /*
+                 * If disabling polling on a device that's been configured,
+                 * make sure there are no bytes left in the FIFO, holding up
+                 * the interrupt line.  Otherwise we won't get any further
+                 * interrupts.
+                 */
+		if (sc != 0) {
+			s = spltty();
+			pckbdintr(sc);
+			splx(s);
+		}
+        }
+}