summaryrefslogtreecommitdiff
path: root/sys
diff options
context:
space:
mode:
authorkstailey <kstailey@cvs.openbsd.org>1997-08-19 11:48:11 +0000
committerkstailey <kstailey@cvs.openbsd.org>1997-08-19 11:48:11 +0000
commit94a6b31f7f0b2ef35fa6bdc9c484b20b3602b046 (patch)
treebff91e4e298bed4f05523d7f6538f7e02e8f345f /sys
parentbf0fc80e550f918964af7dde47adea1db7437f3e (diff)
temporary work around
Diffstat (limited to 'sys')
-rw-r--r--sys/arch/sun3/conf/files.sun38
-rw-r--r--sys/arch/sun3/dev/kbd.c1424
-rw-r--r--sys/arch/sun3/dev/kbd_tables.c935
-rw-r--r--sys/arch/sun3/dev/kbd_tables.h151
-rw-r--r--sys/arch/sun3/dev/kbd_xlate.h92
-rw-r--r--sys/arch/sun3/dev/ms.c638
6 files changed, 3244 insertions, 4 deletions
diff --git a/sys/arch/sun3/conf/files.sun3 b/sys/arch/sun3/conf/files.sun3
index 24d71bbf0f2..f2f7934bac5 100644
--- a/sys/arch/sun3/conf/files.sun3
+++ b/sys/arch/sun3/conf/files.sun3
@@ -1,4 +1,4 @@
-# $OpenBSD: files.sun3,v 1.10 1997/04/04 14:56:57 kstailey Exp $
+# $OpenBSD: files.sun3,v 1.11 1997/08/19 11:48:10 kstailey Exp $
# $NetBSD: files.sun3,v 1.26 1996/10/29 19:58:14 gwr Exp $
#
@@ -169,13 +169,13 @@ file dev/sun/event.c zsevent
device kbd: zsevent
attach kbd at zsc
-file dev/sun/kbd.c kbd needs-flag
-file dev/sun/kbd_tables.c kbd
+file arch/sun3/dev/kbd.c kbd needs-flag
+file arch/sun3/dev/kbd_tables.c kbd
file arch/sun3/dev/kd.c kbd
device ms: zsevent
attach ms at zsc
-file dev/sun/ms.c ms needs-flag
+file arch/sun3/dev/ms.c ms needs-flag
# RAM Disk for boot tape
diff --git a/sys/arch/sun3/dev/kbd.c b/sys/arch/sun3/dev/kbd.c
new file mode 100644
index 00000000000..d7994f2ee39
--- /dev/null
+++ b/sys/arch/sun3/dev/kbd.c
@@ -0,0 +1,1424 @@
+/* $OpenBSD: kbd.c,v 1.3 1997/08/19 11:48:04 kstailey Exp $ */
+/* $NetBSD: kbd.c,v 1.8 1996/05/17 19:32:06 gwr Exp $ */
+
+/*
+ * Copyright (c) 1992, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This software was developed by the Computer Systems Engineering group
+ * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
+ * contributed to Berkeley.
+ *
+ * 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, Lawrence Berkeley Laboratory.
+ *
+ * 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.
+ *
+ * @(#)kbd.c 8.2 (Berkeley) 10/30/93
+ */
+
+/*
+ * Keyboard driver (/dev/kbd -- note that we do not have minor numbers
+ * [yet?]). Translates incoming bytes to ASCII or to `firm_events' and
+ * passes them up to the appropriate reader.
+ */
+
+/*
+ * Zilog Z8530 Dual UART driver (keyboard interface)
+ *
+ * This is the "slave" driver that will be attached to
+ * the "zsc" driver for a Sun keyboard.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/device.h>
+#include <sys/conf.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/signalvar.h>
+#include <sys/time.h>
+#include <sys/kernel.h>
+#include <sys/syslog.h>
+
+#include <dev/ic/z8530reg.h>
+#include <machine/z8530var.h>
+#include <machine/vuid_event.h>
+#include <machine/kbd.h>
+#include <machine/kbio.h>
+
+#include "event_var.h"
+#include "kbd_xlate.h"
+
+/*
+ * Ideas:
+ * /dev/kbd is not a tty (plain device)
+ */
+
+/*
+ * How many input characters we can buffer.
+ * The port-specific var.h may override this.
+ * Note: must be a power of two!
+ */
+#define KBD_RX_RING_SIZE 256
+#define KBD_RX_RING_MASK (KBD_RX_RING_SIZE-1)
+/*
+ * Output buffer. Only need a few chars.
+ */
+#define KBD_TX_RING_SIZE 16
+#define KBD_TX_RING_MASK (KBD_TX_RING_SIZE-1)
+/*
+ * Keyboard serial line speed is fixed at 1200 bps.
+ */
+#define KBD_BPS 1200
+#define KBD_RESET_TIMO 1000 /* mS. */
+
+/*
+ * XXX - Historical comment - no longer quite right...
+ * Keyboard driver state. The ascii and kbd links go up and down and
+ * we just sit in the middle doing translation. Note that it is possible
+ * to get just one of the two links, in which case /dev/kbd is unavailable.
+ * The downlink supplies us with `internal' open and close routines which
+ * will enable dataflow across the downlink. We promise to call open when
+ * we are willing to take keystrokes, and to call close when we are not.
+ * If /dev/kbd is not the console tty input source, we do this whenever
+ * /dev/kbd is in use; otherwise we just leave it open forever.
+ */
+struct kbd_softc {
+ struct device k_dev; /* required first: base device */
+ struct zs_chanstate *k_cs;
+
+ /* Flags to communicate with kbd_softint() */
+ volatile int k_intr_flags;
+#define INTR_RX_OVERRUN 1
+#define INTR_TX_EMPTY 2
+#define INTR_ST_CHECK 4
+
+ /* Transmit state */
+ volatile int k_txflags;
+#define K_TXBUSY 1
+#define K_TXWANT 2
+
+ /*
+ * State of upper interface.
+ */
+ int k_isopen; /* set if open has been done */
+ int k_evmode; /* set if we should produce events */
+ struct evvar k_events; /* event queue state */
+
+ /*
+ * ACSI translation state
+ */
+ int k_repeat_start; /* initial delay */
+ int k_repeat_step; /* inter-char delay */
+ int k_repeatsym; /* repeating symbol */
+ int k_repeating; /* we've called timeout() */
+ struct kbd_state k_state; /* ASCII translation state */
+
+ /*
+ * Magic sequence stuff (L1-A)
+ */
+ char k_isconsole;
+ char k_magic1_down;
+ u_char k_magic1; /* L1 */
+ u_char k_magic2; /* A */
+
+ /*
+ * The transmit ring buffer.
+ */
+ volatile u_int k_tbget; /* transmit buffer `get' index */
+ volatile u_int k_tbput; /* transmit buffer `put' index */
+ u_char k_tbuf[KBD_TX_RING_SIZE]; /* data */
+
+ /*
+ * The receive ring buffer.
+ */
+ u_int k_rbget; /* ring buffer `get' index */
+ volatile u_int k_rbput; /* ring buffer `put' index */
+ u_short k_rbuf[KBD_RX_RING_SIZE]; /* rr1, data pairs */
+
+};
+
+/* Prototypes */
+int kbd_docmd(struct kbd_softc *k, int cmd);
+int kbd_iopen(int unit);
+void kbd_new_layout(struct kbd_softc *k);
+void kbd_output(struct kbd_softc *k, int c);
+void kbd_repeat(void *arg);
+void kbd_set_leds(struct kbd_softc *k, int leds);
+void kbd_start_tx(struct kbd_softc *k);
+void kbd_update_leds(struct kbd_softc *k);
+void kbd_was_reset(struct kbd_softc *k);
+
+extern void kd_input(int ascii);
+
+cdev_decl(kbd); /* open, close, read, write, ioctl, stop, ... */
+
+struct zsops zsops_kbd;
+
+/****************************************************************
+ * Definition of the driver for autoconfig.
+ ****************************************************************/
+
+static int kbd_match __P((struct device *, void *, void *));
+static void kbd_attach __P((struct device *, struct device *, void *));
+
+static int kbd_drain_tx __P((struct kbd_softc *));
+static void kbd_input_string __P((struct kbd_softc *, char *str));
+static void kbd_input_funckey __P((struct kbd_softc *,register int));
+static void kbd_input_keysym __P((struct kbd_softc *,register int));
+static void kbd_input_raw __P((struct kbd_softc *,register int));
+static void kbd_rxint __P((register struct zs_chanstate *));
+static void kbd_txint __P((register struct zs_chanstate *));
+static void kbd_stint __P((register struct zs_chanstate *));
+static void kbd_softint __P((register struct zs_chanstate *));
+
+struct cfattach kbd_ca = {
+ sizeof(struct kbd_softc), kbd_match, kbd_attach
+};
+
+struct cfdriver kbd_cd = {
+ NULL, "kbd", DV_DULL
+};
+
+
+/*
+ * kbd_match: how is this zs channel configured?
+ */
+int
+kbd_match(parent, match, aux)
+ struct device *parent;
+ void *match, *aux;
+{
+ struct cfdata *cf = match;
+ struct zsc_attach_args *args = aux;
+
+ /* Exact match required for keyboard. */
+ if (cf->cf_loc[0] == args->channel)
+ return 2;
+
+ return 0;
+}
+
+void
+kbd_attach(parent, self, aux)
+ struct device *parent, *self;
+ void *aux;
+
+{
+ struct zsc_softc *zsc = (void *) parent;
+ struct kbd_softc *k = (void *) self;
+ struct zsc_attach_args *args = aux;
+ struct zs_chanstate *cs;
+ struct cfdata *cf;
+ int channel, kbd_unit;
+ int reset, s, tconst;
+
+ cf = k->k_dev.dv_cfdata;
+ kbd_unit = k->k_dev.dv_unit;
+ channel = args->channel;
+ cs = &zsc->zsc_cs[channel];
+ cs->cs_private = k;
+ cs->cs_ops = &zsops_kbd;
+ k->k_cs = cs;
+
+ if (args->hwflags & ZS_HWFLAG_CONSOLE) {
+ k->k_isconsole = 1;
+ printf(" (console)");
+ }
+ printf("\n");
+
+ /* Initialize the speed, etc. */
+ tconst = BPS_TO_TCONST(cs->cs_brg_clk, KBD_BPS);
+ s = splzs();
+ if (k->k_isconsole == 0) {
+ /* Not the console; may need reset. */
+ reset = (channel == 0) ?
+ ZSWR9_A_RESET : ZSWR9_B_RESET;
+ zs_write_reg(cs, 9, reset);
+ }
+ /* These are OK as set by zscc: WR3, WR4, WR5 */
+ cs->cs_preg[5] |= ZSWR5_DTR | ZSWR5_RTS;
+ cs->cs_preg[12] = tconst;
+ cs->cs_preg[13] = tconst >> 8;
+ zs_loadchannelregs(cs);
+ splx(s);
+
+ /* Do this before any calls to kbd_rint(). */
+ kbd_xlate_init(&k->k_state);
+
+ /* XXX - Do this in open? */
+ k->k_repeat_start = hz/2;
+ k->k_repeat_step = hz/20;
+
+ /* Magic sequence. */
+ k->k_magic1 = KBD_L1;
+ k->k_magic2 = KBD_A;
+
+ /* Now attach the (kd) pseudo-driver. */
+ kd_init(kbd_unit);
+}
+
+
+/****************************************************************
+ * Entry points for /dev/kbd
+ * (open,close,read,write,...)
+ ****************************************************************/
+
+/*
+ * Open:
+ * Check exclusion, open actual device (_iopen),
+ * setup event channel, clear ASCII repeat stuff.
+ */
+int
+kbdopen(dev, flags, mode, p)
+ dev_t dev;
+ int flags, mode;
+ struct proc *p;
+{
+ struct kbd_softc *k;
+ int error, unit;
+
+ unit = minor(dev);
+ if (unit >= kbd_cd.cd_ndevs)
+ return (ENXIO);
+ k = kbd_cd.cd_devs[unit];
+ if (k == NULL)
+ return (ENXIO);
+
+ /* Exclusive open required for /dev/kbd */
+ if (k->k_events.ev_io)
+ return (EBUSY);
+ k->k_events.ev_io = p;
+
+ if ((error = kbd_iopen(unit)) != 0) {
+ k->k_events.ev_io = NULL;
+ return (error);
+ }
+ ev_init(&k->k_events);
+ k->k_evmode = 1; /* XXX: OK? */
+
+ if (k->k_repeating) {
+ k->k_repeating = 0;
+ untimeout(kbd_repeat, k);
+ }
+
+ return (0);
+}
+
+/*
+ * Close:
+ * Turn off event mode, dump the queue, and close the keyboard
+ * unless it is supplying console input.
+ */
+int
+kbdclose(dev, flags, mode, p)
+ dev_t dev;
+ int flags, mode;
+ struct proc *p;
+{
+ struct kbd_softc *k;
+
+ k = kbd_cd.cd_devs[minor(dev)];
+ k->k_evmode = 0;
+ ev_fini(&k->k_events);
+ k->k_events.ev_io = NULL;
+ return (0);
+}
+
+int
+kbdread(dev, uio, flags)
+ dev_t dev;
+ struct uio *uio;
+ int flags;
+{
+ struct kbd_softc *k;
+
+ k = kbd_cd.cd_devs[minor(dev)];
+ return (ev_read(&k->k_events, uio, flags));
+}
+
+/* this routine should not exist, but is convenient to write here for now */
+int
+kbdwrite(dev, uio, flags)
+ dev_t dev;
+ struct uio *uio;
+ int flags;
+{
+
+ return (EOPNOTSUPP);
+}
+
+int
+kbdselect(dev, rw, p)
+ dev_t dev;
+ int rw;
+ struct proc *p;
+{
+ struct kbd_softc *k;
+
+ k = kbd_cd.cd_devs[minor(dev)];
+ return (ev_select(&k->k_events, rw, p));
+}
+
+
+static int kbd_ioccmd(struct kbd_softc *k, int *data);
+static int kbd_iockeymap __P((struct kbd_state *ks,
+ u_long cmd, struct kiockeymap *kio));
+
+static int kbd_iocsled(struct kbd_softc *k, int *data);
+
+#ifdef KIOCGETKEY
+static int kbd_oldkeymap __P((struct kbd_state *ks,
+ u_long cmd, struct okiockey *okio));
+#endif
+
+int
+kbdioctl(dev, cmd, data, flag, p)
+ dev_t dev;
+ u_long cmd;
+ register caddr_t data;
+ int flag;
+ struct proc *p;
+{
+ struct kbd_softc *k;
+ struct kbd_state *ks;
+ int *ip;
+ int error = 0;
+
+ k = kbd_cd.cd_devs[minor(dev)];
+ ks = &k->k_state;
+
+ switch (cmd) {
+
+ case KIOCTRANS: /* Set translation mode */
+ ip = (int *)data;
+ /* We only support "raw" mode on /dev/kbd */
+ if (*ip != TR_UNTRANS_EVENT)
+ error = EINVAL;
+ break;
+
+ case KIOCGTRANS: /* Get translation mode */
+ ip = (int *)data;
+ /* We only support "raw" mode on /dev/kbd */
+ *ip = TR_UNTRANS_EVENT;
+ break;
+
+#ifdef KIOCGETKEY
+ case KIOCGETKEY: /* Get keymap entry (old format) */
+ error = kbd_oldkeymap(ks, cmd, (struct okiockey *)data);
+ break;
+#endif KIOCGETKEY */
+
+ case KIOCSKEY: /* Set keymap entry */
+ /* Don't let just anyone hose the keyboard. */
+ if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
+ return (error);
+ /* fallthrough */
+ case KIOCGKEY: /* Get keymap entry */
+ error = kbd_iockeymap(ks, cmd, (struct kiockeymap *)data);
+ break;
+
+ case KIOCCMD: /* Send a command to the keyboard */
+ error = kbd_ioccmd(k, (int *)data);
+ break;
+
+ case KIOCTYPE: /* Get keyboard type */
+ ip = (int *)data;
+ *ip = ks->kbd_id;
+ break;
+
+ case KIOCSDIRECT: /* where to send input */
+ ip = (int *)data;
+ k->k_evmode = *ip;
+ break;
+
+ case KIOCLAYOUT: /* Get keyboard layout */
+ *data = ks->kbd_layout;
+ break;
+
+ case KIOCSLED:
+ error = kbd_iocsled(k, (int *)data);
+ break;
+
+ case KIOCGLED:
+ *(char *)data = ks->kbd_leds;
+ break;
+
+ case FIONBIO: /* we will remove this someday (soon???) */
+ break;
+
+ case FIOASYNC:
+ k->k_events.ev_async = *(int *)data != 0;
+ break;
+
+ case TIOCSPGRP:
+ ip = (int *)data;
+ if (*ip != k->k_events.ev_io->p_pgid)
+ error = EPERM;
+ break;
+
+ }
+
+ return (error);
+}
+
+/****************************************************************
+ * ioctl helpers
+ ****************************************************************/
+
+/*
+ * Get/Set keymap entry
+ */
+static int
+kbd_iockeymap(ks, cmd, kio)
+ struct kbd_state *ks;
+ u_long cmd;
+ struct kiockeymap *kio;
+{
+ struct keymap *km;
+ u_int station;
+
+ switch (kio->kio_tablemask) {
+ case KIOC_NOMASK:
+ km = ks->kbd_k.k_normal;
+ break;
+ case KIOC_SHIFTMASK:
+ km = ks->kbd_k.k_shifted;
+ break;
+ case KIOC_CTRLMASK:
+ km = ks->kbd_k.k_control;
+ break;
+ case KIOC_UPMASK:
+ km = ks->kbd_k.k_release;
+ break;
+ default:
+ /* Silently ignore unsupported masks */
+ return (0);
+ }
+
+ /* Range-check the table position. */
+ station = kio->kio_station;
+ if (station >= KEYMAP_SIZE)
+ return (EINVAL);
+
+ switch (cmd) {
+
+ case KIOCGKEY: /* Get keymap entry */
+ kio->kio_entry = km->keymap[station];
+ break;
+
+ case KIOCSKEY: /* Set keymap entry */
+ km->keymap[station] = kio->kio_entry;
+ break;
+
+ default:
+ return(ENOTTY);
+ }
+ return (0);
+}
+
+#ifdef KIOCGETKEY
+/*
+ * Get/Set keymap entry,
+ * old format (compatibility)
+ */
+int
+kbd_oldkeymap(ks, cmd, kio)
+ struct kbd_state *ks;
+ u_long cmd;
+ struct okiockey *kio;
+{
+ int error = 0;
+
+ switch (cmd) {
+
+ case KIOCGETKEY:
+ if (kio->kio_station == 118) {
+ /*
+ * This is X11 asking if a type 3 keyboard is
+ * really a type 3 keyboard. Say yes, it is,
+ * by reporting key station 118 as a "hole".
+ * Note old (SunOS 3.5) definition of HOLE!
+ */
+ kio->kio_entry = 0xA2;
+ break;
+ }
+ /* fall through */
+
+ default:
+ error = ENOTTY;
+ break;
+ }
+
+ return (error);
+}
+#endif /* KIOCGETKEY */
+
+
+/*
+ * keyboard command ioctl
+ * ``unimplemented commands are ignored'' (blech)
+ */
+static int
+kbd_ioccmd(k, data)
+ struct kbd_softc *k;
+ int *data;
+{
+ struct kbd_state *ks = &k->k_state;
+ int cmd, error, s;
+
+ cmd = *data;
+ switch (cmd) {
+
+ case KBD_CMD_BELL:
+ case KBD_CMD_NOBELL:
+ /* Supported by type 2, 3, and 4 keyboards */
+ break;
+
+ case KBD_CMD_CLICK:
+ case KBD_CMD_NOCLICK:
+ /* Unsupported by type 2 keyboards */
+ if (ks->kbd_id <= KB_SUN2)
+ return (0);
+ ks->kbd_click = (cmd == KBD_CMD_CLICK);
+ break;
+
+ default:
+ return (0);
+ }
+
+ s = spltty();
+
+ error = kbd_drain_tx(k);
+ if (error == 0) {
+ kbd_output(k, cmd);
+ kbd_start_tx(k);
+ }
+
+ splx(s);
+
+ return (error);
+}
+
+/*
+ * Set LEDs ioctl.
+ */
+static int
+kbd_iocsled(k, data)
+ struct kbd_softc *k;
+ int *data;
+{
+ int leds, error, s;
+
+ leds = *data;
+
+ s = spltty();
+ error = kbd_drain_tx(k);
+ if (error == 0) {
+ kbd_set_leds(k, leds);
+ }
+ splx(s);
+
+ return (error);
+}
+
+
+/****************************************************************
+ * middle layers:
+ * - keysym to ASCII sequence
+ * - raw key codes to keysym
+ ****************************************************************/
+
+
+/*
+ * Initialization done by either kdcninit or kbd_iopen
+ */
+void
+kbd_xlate_init(ks)
+ struct kbd_state *ks;
+{
+ struct keyboard *ktbls;
+ int id;
+
+ id = ks->kbd_id;
+ if (id < KBD_MIN_TYPE)
+ id = KBD_MIN_TYPE;
+ if (id > kbd_max_type)
+ id = kbd_max_type;
+ ktbls = keyboards[id];
+
+ ks->kbd_k = *ktbls; /* struct assignment */
+ ks->kbd_modbits = 0;
+}
+
+/*
+ * Turn keyboard up/down codes into a KEYSYM.
+ * Note that the "kd" driver uses this too!
+ */
+int
+kbd_code_to_keysym(ks, c)
+ register struct kbd_state *ks;
+ register int c;
+{
+ struct keymap *km;
+ int keysym;
+
+ /*
+ * Get keymap pointer. One of these:
+ * release, control, shifted, normal, ...
+ */
+ if (KEY_UP(c))
+ km = ks->kbd_k.k_release;
+ else if (ks->kbd_modbits & KBMOD_CTRL_MASK)
+ km = ks->kbd_k.k_control;
+ else if (ks->kbd_modbits & KBMOD_SHIFT_MASK)
+ km = ks->kbd_k.k_shifted;
+ else
+ km = ks->kbd_k.k_normal;
+
+ if (km == NULL) {
+ /*
+ * Do not know how to translate yet.
+ * We will find out when a RESET comes along.
+ */
+ return (KEYSYM_NOP);
+ }
+ keysym = km->keymap[KEY_CODE(c)];
+
+ /*
+ * Post-processing for Caps-lock
+ */
+ if ((ks->kbd_modbits & (1 << KBMOD_CAPSLOCK)) &&
+ (KEYSYM_CLASS(keysym) == KEYSYM_ASCII) )
+ {
+ if (('a' <= keysym) && (keysym <= 'z'))
+ keysym -= ('a' - 'A');
+ }
+
+ /*
+ * Post-processing for Num-lock
+ */
+ if ((ks->kbd_modbits & (1 << KBMOD_NUMLOCK)) &&
+ (KEYSYM_CLASS(keysym) == KEYSYM_FUNC) )
+ {
+ keysym = kbd_numlock_map[keysym & 0x3F];
+ }
+
+ return (keysym);
+}
+
+static void
+kbd_input_string(k, str)
+ struct kbd_softc *k;
+ char *str;
+{
+ while (*str) {
+ kd_input(*str);
+ str++;
+ }
+}
+
+static void
+kbd_input_funckey(k, keysym)
+ struct kbd_softc *k;
+ register int keysym;
+{
+ register int n;
+ char str[12];
+
+ /*
+ * Format the F-key sequence and send as a string.
+ * XXX: Ugly compatibility mappings.
+ */
+ n = 0xC0 + (keysym & 0x3F);
+ sprintf(str, "\033[%dz", n);
+ kbd_input_string(k, str);
+}
+
+/*
+ * This is called by kbd_input_raw() or by kb_repeat()
+ * to deliver ASCII input. Called at spltty().
+ */
+static void
+kbd_input_keysym(k, keysym)
+ struct kbd_softc *k;
+ register int keysym;
+{
+ struct kbd_state *ks = &k->k_state;
+ register int data;
+
+ switch (KEYSYM_CLASS(keysym)) {
+
+ case KEYSYM_ASCII:
+ data = KEYSYM_DATA(keysym);
+ if (ks->kbd_modbits & KBMOD_META_MASK)
+ data |= 0x80;
+ kd_input(data);
+ break;
+
+ case KEYSYM_STRING:
+ data = keysym & 0xF;
+ kbd_input_string(k, kbd_stringtab[data]);
+ break;
+
+ case KEYSYM_FUNC:
+ kbd_input_funckey(k, keysym);
+ break;
+
+ case KEYSYM_CLRMOD:
+ data = 1 << (keysym & 0x1F);
+ ks->kbd_modbits &= ~data;
+ break;
+
+ case KEYSYM_SETMOD:
+ data = 1 << (keysym & 0x1F);
+ ks->kbd_modbits |= data;
+ break;
+
+ case KEYSYM_INVMOD:
+ data = 1 << (keysym & 0x1F);
+ ks->kbd_modbits ^= data;
+ kbd_update_leds(k);
+ break;
+
+ case KEYSYM_ALL_UP:
+ ks->kbd_modbits &= ~0xFFFF;
+ break;
+
+ case KEYSYM_SPECIAL:
+ if (keysym == KEYSYM_NOP)
+ break;
+ /* fall through */
+ default:
+ log(LOG_WARNING, "%s: unexpected keysym 0x%x\n",
+ k->k_dev.dv_xname, keysym);
+ break;
+ }
+}
+
+/*
+ * This is the autorepeat timeout function.
+ * Called at splsoftclock().
+ */
+void
+kbd_repeat(void *arg)
+{
+ struct kbd_softc *k = (struct kbd_softc *)arg;
+ int s = spltty();
+
+ if (k->k_repeating && k->k_repeatsym >= 0) {
+ kbd_input_keysym(k, k->k_repeatsym);
+ timeout(kbd_repeat, k, k->k_repeat_step);
+ }
+ splx(s);
+}
+
+/*
+ * Called by our kbd_softint() routine on input,
+ * which passes the raw hardware scan codes.
+ * Called at spltty()
+ */
+void
+kbd_input_raw(k, c)
+ struct kbd_softc *k;
+ register int c;
+{
+ struct kbd_state *ks = &k->k_state;
+ struct firm_event *fe;
+ int put, keysym;
+
+ /* XXX - Input errors already handled. */
+
+ /* Are we expecting special input? */
+ if (ks->kbd_expect) {
+ if (ks->kbd_expect & KBD_EXPECT_IDCODE) {
+ /* We read a KBD_RESET last time. */
+ ks->kbd_id = c;
+ kbd_was_reset(k);
+ }
+ if (ks->kbd_expect & KBD_EXPECT_LAYOUT) {
+ /* We read a KBD_LAYOUT last time. */
+ ks->kbd_layout = c;
+ kbd_new_layout(k);
+ }
+ ks->kbd_expect = 0;
+ return;
+ }
+
+ /* Is this one of the "special" input codes? */
+ if (KBD_SPECIAL(c)) {
+ switch (c) {
+ case KBD_RESET:
+ ks->kbd_expect |= KBD_EXPECT_IDCODE;
+ /* Fake an "all-up" to resync. translation. */
+ c = KBD_IDLE;
+ break;
+
+ case KBD_LAYOUT:
+ ks->kbd_expect |= KBD_EXPECT_LAYOUT;
+ return;
+
+ case KBD_ERROR:
+ log(LOG_WARNING, "%s: received error indicator\n",
+ k->k_dev.dv_xname);
+ return;
+
+ case KBD_IDLE:
+ /* Let this go to the translator. */
+ break;
+ }
+ }
+
+ /*
+ * If /dev/kbd is not connected in event mode,
+ * translate and send upstream (to console).
+ */
+ if (!k->k_evmode) {
+
+ /* Any input stops auto-repeat (i.e. key release). */
+ if (k->k_repeating) {
+ k->k_repeating = 0;
+ untimeout(kbd_repeat, k);
+ }
+
+ /* Translate this code to a keysym */
+ keysym = kbd_code_to_keysym(ks, c);
+
+ /* Pass up to the next layer. */
+ kbd_input_keysym(k, keysym);
+
+ /* Does this symbol get auto-repeat? */
+ if (KEYSYM_NOREPEAT(keysym))
+ return;
+
+ /* Setup for auto-repeat after initial delay. */
+ k->k_repeating = 1;
+ k->k_repeatsym = keysym;
+ timeout(kbd_repeat, k, k->k_repeat_start);
+ return;
+ }
+
+ /*
+ * IDLEs confuse the MIT X11R4 server badly, so we must drop them.
+ * This is bad as it means the server will not automatically resync
+ * on all-up IDLEs, but I did not drop them before, and the server
+ * goes crazy when it comes time to blank the screen....
+ */
+ if (c == KBD_IDLE)
+ return;
+
+ /*
+ * Keyboard is generating events. Turn this keystroke into an
+ * event and put it in the queue. If the queue is full, the
+ * keystroke is lost (sorry!).
+ */
+ put = k->k_events.ev_put;
+ fe = &k->k_events.ev_q[put];
+ put = (put + 1) % EV_QSIZE;
+ if (put == k->k_events.ev_get) {
+ log(LOG_WARNING, "%s: event queue overflow\n",
+ k->k_dev.dv_xname); /* ??? */
+ return;
+ }
+ fe->id = KEY_CODE(c);
+ fe->value = KEY_UP(c) ? VKEY_UP : VKEY_DOWN;
+ fe->time = time;
+ k->k_events.ev_put = put;
+ EV_WAKEUP(&k->k_events);
+}
+
+/****************************************************************
+ * Interface to the lower layer (zscc)
+ ****************************************************************/
+
+static void
+kbd_rxint(cs)
+ register struct zs_chanstate *cs;
+{
+ register struct kbd_softc *k;
+ register int put, put_next;
+ register u_char c, rr1;
+
+ k = cs->cs_private;
+ put = k->k_rbput;
+
+ /*
+ * First read the status, because reading the received char
+ * destroys the status of this char.
+ */
+ rr1 = zs_read_reg(cs, 1);
+ c = zs_read_data(cs);
+
+ if (rr1 & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) {
+ /* Clear the receive error. */
+ zs_write_csr(cs, ZSWR0_RESET_ERRORS);
+ }
+
+ /*
+ * Check NOW for a console abort sequence, so that we can
+ * abort even when interrupts are locking up the machine.
+ */
+ if (k->k_magic1_down) {
+ /* The last keycode was "MAGIC1" down. */
+ k->k_magic1_down = 0;
+ if ((c == k->k_magic2) && k->k_isconsole) {
+ /* Magic "L1-A" sequence; enter debugger. */
+ zs_abort();
+ /* Debugger done. Fake L1-up to finish it. */
+ c = k->k_magic1 | KBD_UP;
+ }
+ }
+ if (c == k->k_magic1) {
+ k->k_magic1_down = 1;
+ }
+
+ k->k_rbuf[put] = (c << 8) | rr1;
+ put_next = (put + 1) & KBD_RX_RING_MASK;
+
+ /* Would overrun if increment makes (put==get). */
+ if (put_next == k->k_rbget) {
+ k->k_intr_flags |= INTR_RX_OVERRUN;
+ } else {
+ /* OK, really increment. */
+ put = put_next;
+ }
+
+ /* Done reading. */
+ k->k_rbput = put;
+
+ /* Ask for softint() call. */
+ cs->cs_softreq = 1;
+}
+
+
+static void
+kbd_txint(cs)
+ register struct zs_chanstate *cs;
+{
+ register struct kbd_softc *k;
+
+ k = cs->cs_private;
+ zs_write_csr(cs, ZSWR0_RESET_TXINT);
+ k->k_intr_flags |= INTR_TX_EMPTY;
+ /* Ask for softint() call. */
+ cs->cs_softreq = 1;
+}
+
+
+static void
+kbd_stint(cs)
+ register struct zs_chanstate *cs;
+{
+ register struct kbd_softc *k;
+ register int rr0;
+
+ k = cs->cs_private;
+
+ rr0 = zs_read_csr(cs);
+ zs_write_csr(cs, ZSWR0_RESET_STATUS);
+
+#if 0
+ if (rr0 & ZSRR0_BREAK) {
+ /* Keyboard unplugged? */
+ zs_abort();
+ return (0);
+ }
+#endif
+
+ cs->cs_rr0_delta |= (cs->cs_rr0 ^ rr0);
+ cs->cs_rr0 = rr0;
+ k->k_intr_flags |= INTR_ST_CHECK;
+
+ /* Ask for softint() call. */
+ cs->cs_softreq = 1;
+}
+
+/*
+ * Get input from the recieve ring and pass it on.
+ * Note: this is called at splsoftclock()
+ */
+static void
+kbd_softint(cs)
+ struct zs_chanstate *cs;
+{
+ register struct kbd_softc *k;
+ register int get, c, s;
+ int intr_flags;
+ register u_short ring_data;
+
+ k = cs->cs_private;
+
+ /* Atomically get and clear flags. */
+ s = splzs();
+ intr_flags = k->k_intr_flags;
+ k->k_intr_flags = 0;
+
+ /* Now lower to spltty for the rest. */
+ (void) spltty();
+
+ /*
+ * Copy data from the receive ring to the event layer.
+ */
+ get = k->k_rbget;
+ while (get != k->k_rbput) {
+ ring_data = k->k_rbuf[get];
+ get = (get + 1) & KBD_RX_RING_MASK;
+
+ /* low byte of ring_data is rr1 */
+ c = (ring_data >> 8) & 0xff;
+
+ if (ring_data & ZSRR1_DO)
+ intr_flags |= INTR_RX_OVERRUN;
+ if (ring_data & (ZSRR1_FE | ZSRR1_PE)) {
+ /*
+ * After garbage, flush pending input, and
+ * send a reset to resync key translation.
+ */
+ log(LOG_ERR, "%s: input error (0x%x)\n",
+ k->k_dev.dv_xname, ring_data);
+ get = k->k_rbput; /* flush */
+ goto send_reset;
+ }
+
+ /* Pass this up to the "middle" layer. */
+ kbd_input_raw(k, c);
+ }
+ if (intr_flags & INTR_RX_OVERRUN) {
+ log(LOG_ERR, "%s: input overrun\n",
+ k->k_dev.dv_xname);
+ send_reset:
+ /* Send a reset to resync translation. */
+ kbd_output(k, KBD_CMD_RESET);
+ kbd_start_tx(k);
+ }
+ k->k_rbget = get;
+
+ if (intr_flags & INTR_TX_EMPTY) {
+ /*
+ * Transmit done. Try to send more, or
+ * clear busy and wakeup drain waiters.
+ */
+ k->k_txflags &= ~K_TXBUSY;
+ kbd_start_tx(k);
+ }
+
+ if (intr_flags & INTR_ST_CHECK) {
+ /*
+ * Status line change. (Not expected.)
+ */
+ log(LOG_ERR, "%s: status interrupt?\n",
+ k->k_dev.dv_xname);
+ cs->cs_rr0_delta = 0;
+ }
+
+ splx(s);
+}
+
+struct zsops zsops_kbd = {
+ kbd_rxint, /* receive char available */
+ kbd_stint, /* external/status */
+ kbd_txint, /* xmit buffer empty */
+ kbd_softint, /* process software interrupt */
+};
+
+/****************************************************************
+ * misc...
+ ****************************************************************/
+
+/*
+ * Initialization to be done at first open.
+ * This is called from kbdopen or kdopen (in kd.c)
+ * Called with user context.
+ */
+int
+kbd_iopen(unit)
+ int unit;
+{
+ struct kbd_softc *k;
+ struct kbd_state *ks;
+ int error, s;
+
+ if (unit >= kbd_cd.cd_ndevs)
+ return (ENXIO);
+ k = kbd_cd.cd_devs[unit];
+ if (k == NULL)
+ return (ENXIO);
+ ks = &k->k_state;
+ error = 0;
+
+ /* Tolerate extra calls. */
+ if (k->k_isopen)
+ return (error);
+
+ s = spltty();
+
+ /* Reset the keyboard and find out its type. */
+ kbd_output(k, KBD_CMD_RESET);
+ kbd_start_tx(k);
+ kbd_drain_tx(k);
+ /* The wakeup for this is in kbd_was_reset(). */
+ error = tsleep((caddr_t)&ks->kbd_id,
+ PZERO | PCATCH, devopn, hz);
+ if (error == EWOULDBLOCK) { /* no response */
+ error = 0;
+ log(LOG_ERR, "%s: reset failed\n",
+ k->k_dev.dv_xname);
+ /*
+ * Allow the open anyway (to keep getty happy)
+ * but assume the "least common denominator".
+ */
+ ks->kbd_id = KB_SUN2;
+ }
+
+ /* Earlier than type 4 does not know "layout". */
+ if (ks->kbd_id < KB_SUN4)
+ goto out;
+
+ /* Ask for the layout. */
+ kbd_output(k, KBD_CMD_GETLAYOUT);
+ kbd_start_tx(k);
+ kbd_drain_tx(k);
+ /* The wakeup for this is in kbd_new_layout(). */
+ error = tsleep((caddr_t)&ks->kbd_layout,
+ PZERO | PCATCH, devopn, hz);
+ if (error == EWOULDBLOCK) { /* no response */
+ error = 0;
+ log(LOG_ERR, "%s: no response to get_layout\n",
+ k->k_dev.dv_xname);
+ ks->kbd_layout = 0;
+ }
+
+out:
+ splx(s);
+
+ if (error == 0)
+ k->k_isopen = 1;
+
+ return error;
+}
+
+/*
+ * Called by kbd_input_raw, at spltty()
+ */
+void
+kbd_was_reset(k)
+ struct kbd_softc *k;
+{
+ struct kbd_state *ks = &k->k_state;
+
+ /*
+ * On first identification, wake up anyone waiting for type
+ * and set up the table pointers.
+ */
+ wakeup((caddr_t)&ks->kbd_id);
+
+ /* Restore keyclick, if necessary */
+ switch (ks->kbd_id) {
+
+ case KB_SUN2:
+ /* Type 2 keyboards don't support keyclick */
+ break;
+
+ case KB_SUN3:
+ /* Type 3 keyboards come up with keyclick on */
+ if (!ks->kbd_click) {
+ /* turn off the click */
+ kbd_output(k, KBD_CMD_NOCLICK);
+ kbd_start_tx(k);
+ }
+ break;
+
+ case KB_SUN4:
+ /* Type 4 keyboards come up with keyclick off */
+ if (ks->kbd_click) {
+ /* turn on the click */
+ kbd_output(k, KBD_CMD_CLICK);
+ kbd_start_tx(k);
+ }
+ break;
+ }
+
+ /* LEDs are off after reset. */
+ ks->kbd_leds = 0;
+}
+
+/*
+ * Called by kbd_input_raw, at spltty()
+ */
+void
+kbd_new_layout(k)
+ struct kbd_softc *k;
+{
+ struct kbd_state *ks = &k->k_state;
+
+ /*
+ * On first identification, wake up anyone waiting for type
+ * and set up the table pointers.
+ */
+ wakeup((caddr_t)&ks->kbd_layout);
+
+ /* XXX: switch decoding tables? */
+}
+
+
+/*
+ * Wait for output to finish.
+ * Called at spltty(). Has user context.
+ */
+static int
+kbd_drain_tx(k)
+ struct kbd_softc *k;
+{
+ int error;
+
+ error = 0;
+
+ while (k->k_txflags & K_TXBUSY) {
+ k->k_txflags |= K_TXWANT;
+ error = tsleep((caddr_t)&k->k_txflags,
+ PZERO | PCATCH, "kbdout", 0);
+ }
+
+ return (error);
+}
+
+/*
+ * Enqueue some output for the keyboard
+ * Called at spltty().
+ */
+void
+kbd_output(k, c)
+ struct kbd_softc *k;
+ int c; /* the data */
+{
+ int put;
+
+ put = k->k_tbput;
+ k->k_tbuf[put] = (u_char)c;
+ put = (put + 1) & KBD_TX_RING_MASK;
+
+ /* Would overrun if increment makes (put==get). */
+ if (put == k->k_tbget) {
+ log(LOG_WARNING, "%s: output overrun\n",
+ k->k_dev.dv_xname);
+ } else {
+ /* OK, really increment. */
+ k->k_tbput = put;
+ }
+}
+
+/*
+ * Start the sending data from the output queue
+ * Called at spltty().
+ */
+void
+kbd_start_tx(k)
+ struct kbd_softc *k;
+{
+ struct zs_chanstate *cs = k->k_cs;
+ int get, s;
+ u_char c;
+
+ if (k->k_txflags & K_TXBUSY)
+ return;
+
+ /* Is there anything to send? */
+ get = k->k_tbget;
+ if (get == k->k_tbput) {
+ /* Nothing to send. Wake drain waiters. */
+ if (k->k_txflags & K_TXWANT) {
+ k->k_txflags &= ~K_TXWANT;
+ wakeup((caddr_t)&k->k_txflags);
+ }
+ return;
+ }
+
+ /* Have something to send. */
+ c = k->k_tbuf[get];
+ get = (get + 1) & KBD_TX_RING_MASK;
+ k->k_tbget = get;
+ k->k_txflags |= K_TXBUSY;
+
+ /* Need splzs to avoid interruption of the delay. */
+ s = splzs();
+ zs_write_data(cs, c);
+ splx(s);
+}
+
+/*
+ * Called at spltty by:
+ * kbd_update_leds, kbd_iocsled
+ */
+void
+kbd_set_leds(k, new_leds)
+ struct kbd_softc *k;
+ int new_leds;
+{
+ struct kbd_state *ks = &k->k_state;
+
+ /* Don't send unless state changes. */
+ if (ks->kbd_leds == new_leds)
+ return;
+
+ ks->kbd_leds = new_leds;
+
+ /* Only type 4 and later has LEDs anyway. */
+ if (ks->kbd_id < 4)
+ return;
+
+ kbd_output(k, KBD_CMD_SETLED);
+ kbd_output(k, new_leds);
+ kbd_start_tx(k);
+}
+
+/*
+ * Called at spltty by:
+ * kbd_input_keysym
+ */
+void
+kbd_update_leds(k)
+ struct kbd_softc *k;
+{
+ struct kbd_state *ks = &k->k_state;
+ register char leds;
+
+ leds = ks->kbd_leds;
+ leds &= ~(LED_CAPS_LOCK|LED_NUM_LOCK);
+
+ if (ks->kbd_modbits & (1 << KBMOD_CAPSLOCK))
+ leds |= LED_CAPS_LOCK;
+ if (ks->kbd_modbits & (1 << KBMOD_NUMLOCK))
+ leds |= LED_NUM_LOCK;
+
+ kbd_set_leds(k, leds);
+}
diff --git a/sys/arch/sun3/dev/kbd_tables.c b/sys/arch/sun3/dev/kbd_tables.c
new file mode 100644
index 00000000000..5999e026892
--- /dev/null
+++ b/sys/arch/sun3/dev/kbd_tables.c
@@ -0,0 +1,935 @@
+/* $OpenBSD: kbd_tables.c,v 1.1 1997/08/19 11:48:05 kstailey Exp $ */
+/* $NetBSD: kbd_tables.c,v 1.2 1996/02/29 19:32:18 gwr Exp $ */
+
+/*
+ * Copyright (c) 1996 Gordon W. Ross
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ * 4. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by Gordon Ross
+ *
+ * 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.
+ */
+
+/*
+ * Keyboard translation tables. (See kbd_tables.h)
+ */
+
+#define _KERNEL 1
+#include "kbd_tables.h"
+
+
+/*
+ * Toggle keys are not yet supported, but could be with
+ * fairly simple changes. Both CapsLock and NumLock
+ * could be easily done with "post-translation" on the
+ * keysymbols from these tables (WITHOUT new tables).
+ *
+ * The "compose" operations are not implemented.
+ */
+
+#define KEYSYM_COMPOSE KEYSYM_NOP
+
+
+/*
+ * Key release codes are decoded in this map.
+ */
+struct keymap keymap_release = {{
+ /* 0: */ KEYSYM_HOLE,
+ /* 1: L1/Stop */ KEYSYM_NOP,
+ /* 2: */ KEYSYM_HOLE,
+ /* 3: L2/Again */ KEYSYM_NOP,
+ /* 4: */ KEYSYM_HOLE,
+ /* 5: F1 */ KEYSYM_NOP,
+ /* 6: F2 */ KEYSYM_NOP,
+ /* 7: F10 */ KEYSYM_NOP,
+ /* 8: F3 */ KEYSYM_NOP,
+ /* 9: F11 */ KEYSYM_NOP,
+ /* 10: F4 */ KEYSYM_NOP,
+ /* 11: F12 */ KEYSYM_NOP,
+ /* 12: F5 */ KEYSYM_NOP,
+ /* 13: AltGraph */ KEYSYM_CLRMOD | KBMOD_ALTGRAPH,
+ /* 14: F6 */ KEYSYM_NOP,
+ /* 15: */ KEYSYM_HOLE,
+ /* 16: F7 */ KEYSYM_NOP,
+ /* 17: F8 */ KEYSYM_NOP,
+ /* 18: F9 */ KEYSYM_NOP,
+ /* 19: Alt_L */ KEYSYM_CLRMOD | KBMOD_ALT_L,
+ /* 20: T5_Up */ KEYSYM_HOLE,
+ /* 21: R1/Pause */ KEYSYM_NOP,
+ /* 22: R2/Print */ KEYSYM_NOP,
+ /* 23: R3/Break */ KEYSYM_NOP,
+ /* 24: T5_Left */ KEYSYM_HOLE,
+ /* 25: L3/Props */ KEYSYM_NOP,
+ /* 26: L4/Undo */ KEYSYM_NOP,
+ /* 27: T5_Down */ KEYSYM_HOLE,
+ /* 28: T5_Right */ KEYSYM_HOLE,
+ /* 29: Esc */ KEYSYM_NOP,
+ /* 30: 1 */ KEYSYM_NOP,
+ /* 31: 2 */ KEYSYM_NOP,
+ /* 32: 3 */ KEYSYM_NOP,
+ /* 33: 4 */ KEYSYM_NOP,
+ /* 34: 5 */ KEYSYM_NOP,
+ /* 35: 6 */ KEYSYM_NOP,
+ /* 36: 7 */ KEYSYM_NOP,
+ /* 37: 8 */ KEYSYM_NOP,
+ /* 38: 9 */ KEYSYM_NOP,
+ /* 39: 0 */ KEYSYM_NOP,
+ /* 40: minus */ KEYSYM_NOP,
+ /* 41: equal */ KEYSYM_NOP,
+ /* 42: grave/tilde */ KEYSYM_NOP,
+ /* 43: BackSpace */ KEYSYM_NOP,
+ /* 44: */ KEYSYM_HOLE,
+ /* 45: R4/KP_Equal */ KEYSYM_NOP,
+ /* 46: R5/KP_Div */ KEYSYM_NOP,
+ /* 47: R6/KP_Mult */ KEYSYM_NOP,
+ /* 48: */ KEYSYM_NOP,
+ /* 49: L5/Front */ KEYSYM_NOP,
+ /* 50: KP_Delete */ KEYSYM_NOP,
+ /* 51: L6/Copy */ KEYSYM_NOP,
+ /* 52: */ KEYSYM_HOLE,
+ /* 53: Tab */ KEYSYM_NOP,
+ /* 54: Q */ KEYSYM_NOP,
+ /* 55: W */ KEYSYM_NOP,
+ /* 56: E */ KEYSYM_NOP,
+ /* 57: R */ KEYSYM_NOP,
+ /* 58: T */ KEYSYM_NOP,
+ /* 59: Y */ KEYSYM_NOP,
+ /* 60: U */ KEYSYM_NOP,
+ /* 61: I */ KEYSYM_NOP,
+ /* 62: O */ KEYSYM_NOP,
+ /* 63: P */ KEYSYM_NOP,
+ /* 64: [ */ KEYSYM_NOP,
+ /* 65: ] */ KEYSYM_NOP,
+ /* 66: Delete */ KEYSYM_NOP,
+ /* 67: Compose */ KEYSYM_NOP,
+ /* 68: R7/Home */ KEYSYM_NOP,
+ /* 69: R8/Up */ KEYSYM_NOP,
+ /* 70: R9/PgUp */ KEYSYM_NOP,
+ /* 71: KP_Minus */ KEYSYM_NOP,
+ /* 72: L7/Open */ KEYSYM_NOP,
+ /* 73: L8/Paste */ KEYSYM_NOP,
+ /* 74: */ KEYSYM_HOLE,
+ /* 75: */ KEYSYM_HOLE,
+ /* 76: Ctrl_L */ KEYSYM_CLRMOD | KBMOD_CTRL_L,
+ /* 77: A */ KEYSYM_NOP,
+ /* 78: S */ KEYSYM_NOP,
+ /* 79: D */ KEYSYM_NOP,
+ /* 80: F */ KEYSYM_NOP,
+ /* 81: G */ KEYSYM_NOP,
+ /* 82: H */ KEYSYM_NOP,
+ /* 83: J */ KEYSYM_NOP,
+ /* 84: K */ KEYSYM_NOP,
+ /* 85: L */ KEYSYM_NOP,
+ /* 86: ; */ KEYSYM_NOP,
+ /* 87: apostr. */ KEYSYM_NOP,
+ /* 88: backslash */ KEYSYM_NOP,
+ /* 89: Return */ KEYSYM_NOP,
+ /* 90: KP_Enter */ KEYSYM_NOP,
+ /* 91: R10/Left */ KEYSYM_NOP,
+ /* 92: R11/KP_5 */ KEYSYM_NOP,
+ /* 93: R12/Right */ KEYSYM_NOP,
+ /* 94: KP_Insert */ KEYSYM_NOP,
+ /* 95: L9/Find */ KEYSYM_NOP,
+ /* 96: */ KEYSYM_HOLE,
+ /* 97: L10/Cut */ KEYSYM_NOP,
+ /* 98: Num_Lock */ KEYSYM_NOP,
+ /* 99: Shift_L */ KEYSYM_CLRMOD | KBMOD_SHIFT_L,
+ /* 100: Z */ KEYSYM_NOP,
+ /* 101: X */ KEYSYM_NOP,
+ /* 102: C */ KEYSYM_NOP,
+ /* 103: V */ KEYSYM_NOP,
+ /* 104: B */ KEYSYM_NOP,
+ /* 105: N */ KEYSYM_NOP,
+ /* 106: M */ KEYSYM_NOP,
+ /* 107: , */ KEYSYM_NOP,
+ /* 108: . */ KEYSYM_NOP,
+ /* 109: / */ KEYSYM_NOP,
+ /* 110: Shift_R */ KEYSYM_CLRMOD | KBMOD_SHIFT_R,
+ /* 111: Linefeed */ KEYSYM_NOP,
+ /* 112: R13/End */ KEYSYM_NOP,
+ /* 113: R14/Down */ KEYSYM_NOP,
+ /* 114: R15/PgDn */ KEYSYM_NOP,
+ /* 115: */ KEYSYM_HOLE,
+ /* 116: */ KEYSYM_HOLE,
+ /* 117: */ KEYSYM_HOLE,
+ /* 118: L16/Help */ KEYSYM_NOP,
+ /* 119: CapsLock */ KEYSYM_NOP,
+ /* 120: Meta_L */ KEYSYM_CLRMOD | KBMOD_META_L,
+ /* 121: SpaceBar */ KEYSYM_NOP,
+ /* 122: Meta_R */ KEYSYM_CLRMOD | KBMOD_META_R,
+ /* 123: */ KEYSYM_HOLE,
+ /* 124: */ KEYSYM_HOLE,
+ /* 125: KP_Add */ KEYSYM_NOP,
+ /* 126: */ KEYSYM_LAYOUT, /* layout next */
+ /* 127: */ KEYSYM_RESET, /* kbd ID next */
+}};
+
+
+/*
+ * This map is used when a control key is down.
+ */
+#define CTL(c) ((c)&0x1F)
+struct keymap keymap_control = {{
+ /* 0: */ KEYSYM_HOLE,
+ /* 1: L1/Stop */ KEYSYM_NOP,
+ /* 2: */ KEYSYM_HOLE,
+ /* 3: L2/Again */ KEYSYM_NOP,
+ /* 4: */ KEYSYM_HOLE,
+ /* 5: F1 */ KEYSYM_NOP,
+ /* 6: F2 */ KEYSYM_NOP,
+ /* 7: F10 */ KEYSYM_NOP,
+ /* 8: F3 */ KEYSYM_NOP,
+ /* 9: F11 */ KEYSYM_NOP,
+ /* 10: F4 */ KEYSYM_NOP,
+ /* 11: F12 */ KEYSYM_NOP,
+ /* 12: F5 */ KEYSYM_NOP,
+ /* 13: AltGraph */ KEYSYM_SETMOD | KBMOD_ALTGRAPH,
+ /* 14: F6 */ KEYSYM_NOP,
+ /* 15: */ KEYSYM_HOLE,
+ /* 16: F7 */ KEYSYM_NOP,
+ /* 17: F8 */ KEYSYM_NOP,
+ /* 18: F9 */ KEYSYM_NOP,
+ /* 19: Alt_L */ KEYSYM_SETMOD | KBMOD_ALT_L,
+ /* 20: T5_Up */ KEYSYM_HOLE,
+ /* 21: R1/Pause */ KEYSYM_NOP,
+ /* 22: R2/Print */ KEYSYM_NOP,
+ /* 23: R3/Break */ KEYSYM_NOP,
+ /* 24: T5_Left */ KEYSYM_HOLE,
+ /* 25: L3/Props */ KEYSYM_NOP,
+ /* 26: L4/Undo */ KEYSYM_NOP,
+ /* 27: T5_Down */ KEYSYM_HOLE,
+ /* 28: T5_Right */ KEYSYM_HOLE,
+ /* 29: Esc */ 0x1b,
+ /* 30: 1 */ KEYSYM_NOP,
+ /* 31: 2 */ CTL('@'),
+ /* 32: 3 */ KEYSYM_NOP,
+ /* 33: 4 */ KEYSYM_NOP,
+ /* 34: 5 */ KEYSYM_NOP,
+ /* 35: 6 */ CTL('^'),
+ /* 36: 7 */ KEYSYM_NOP,
+ /* 37: 8 */ KEYSYM_NOP,
+ /* 38: 9 */ KEYSYM_NOP,
+ /* 39: 0 */ KEYSYM_NOP,
+ /* 40: minus _ */ CTL('_'),
+ /* 41: equal */ KEYSYM_NOP,
+ /* 42: grave/tilde */ CTL('~'),
+ /* 43: BackSpace */ '\b',
+ /* 44: */ KEYSYM_HOLE,
+ /* 45: R4/KP_Equal */ KEYSYM_NOP,
+ /* 46: R5/KP_Div */ KEYSYM_NOP,
+ /* 47: R6/KP_Mult */ KEYSYM_NOP,
+ /* 48: */ KEYSYM_NOP,
+ /* 49: L5/Front */ KEYSYM_NOP,
+ /* 50: KP_Delete */ KEYSYM_NOP,
+ /* 51: L6/Copy */ KEYSYM_NOP,
+ /* 52: */ KEYSYM_HOLE,
+ /* 53: Tab */ '\t',
+ /* 54: Q */ CTL('Q'),
+ /* 55: W */ CTL('W'),
+ /* 56: E */ CTL('E'),
+ /* 57: R */ CTL('R'),
+ /* 58: T */ CTL('T'),
+ /* 59: Y */ CTL('Y'),
+ /* 60: U */ CTL('U'),
+ /* 61: I */ CTL('I'),
+ /* 62: O */ CTL('O'),
+ /* 63: P */ CTL('P'),
+ /* 64: [ */ CTL('['),
+ /* 65: ] */ CTL(']'),
+ /* 66: Delete */ 0x7f,
+ /* 67: Compose */ KEYSYM_COMPOSE,
+ /* 68: R7/Home */ CTL('A'), /* emacs */
+ /* 69: R8/Up */ CTL('P'), /* emacs */
+ /* 70: R9/PgUp */ 0x80|'v', /* emacs */
+ /* 71: KP_Minus */ KEYSYM_NOP,
+ /* 72: L7/Open */ KEYSYM_NOP,
+ /* 73: L8/Paste */ KEYSYM_NOP,
+ /* 74: */ KEYSYM_HOLE,
+ /* 75: */ KEYSYM_HOLE,
+ /* 76: Ctrl_L */ KEYSYM_SETMOD | KBMOD_CTRL_L,
+ /* 77: A */ CTL('A'),
+ /* 78: S */ CTL('S'),
+ /* 79: D */ CTL('D'),
+ /* 80: F */ CTL('F'),
+ /* 81: G */ CTL('G'),
+ /* 82: H */ CTL('H'),
+ /* 83: J */ CTL('J'),
+ /* 84: K */ CTL('K'),
+ /* 85: L */ CTL('L'),
+ /* 86: ; */ KEYSYM_NOP,
+ /* 87: apostr. */ KEYSYM_NOP,
+ /* 88: backslash */ CTL('\\'),
+ /* 89: Return */ '\r',
+ /* 90: KP_Enter */ KEYSYM_NOP,
+ /* 91: R10/Left */ CTL('B'), /* emacs */
+ /* 92: R11/KP_5 */ KEYSYM_NOP,
+ /* 93: R12/Right */ CTL('F'), /* emacs */
+ /* 94: KP_Insert */ KEYSYM_NOP,
+ /* 95: L9/Find */ KEYSYM_NOP,
+ /* 96: */ KEYSYM_HOLE,
+ /* 97: L10/Cut */ KEYSYM_NOP,
+ /* 98: Num_Lock */ KEYSYM_INVMOD | KBMOD_NUMLOCK,
+ /* 99: Shift_L */ KEYSYM_SETMOD | KBMOD_SHIFT_L,
+ /* 100: Z */ CTL('Z'),
+ /* 101: X */ CTL('X'),
+ /* 102: C */ CTL('C'),
+ /* 103: V */ CTL('V'),
+ /* 104: B */ CTL('B'),
+ /* 105: N */ CTL('N'),
+ /* 106: M */ CTL('M'),
+ /* 107: , */ KEYSYM_NOP,
+ /* 108: . */ KEYSYM_NOP,
+ /* 109: / ? */ CTL('?'),
+ /* 110: Shift_R */ KEYSYM_SETMOD | KBMOD_SHIFT_R,
+ /* 111: Linefeed */ '\n',
+ /* 112: R13/End */ CTL('E'), /* emacs */
+ /* 113: R14/Down */ CTL('N'), /* emacs */
+ /* 114: R15/PgDn */ CTL('V'), /* emacs */
+ /* 115: */ KEYSYM_HOLE,
+ /* 116: */ KEYSYM_HOLE,
+ /* 117: */ KEYSYM_HOLE,
+ /* 118: L16/Help */ KEYSYM_NOP,
+ /* 119: CapsLock */ KEYSYM_INVMOD | KBMOD_CAPSLOCK,
+ /* 120: Meta_L */ KEYSYM_SETMOD | KBMOD_META_L,
+ /* 121: SpaceBar */ CTL(' '),
+ /* 122: Meta_R */ KEYSYM_SETMOD | KBMOD_META_R,
+ /* 123: */ KEYSYM_HOLE,
+ /* 124: */ KEYSYM_HOLE,
+ /* 125: KP_Add */ KEYSYM_NOP,
+ /* 126: */ KEYSYM_HW_ERR,
+ /* 127: */ KEYSYM_ALL_UP,
+}};
+#undef CTL
+
+
+/*
+ * Keymaps for the "type 3" keyboard.
+ * (lower-case, upper-case)
+ */
+
+struct keymap keymap_s3_lc = {{
+ /* 0: */ KEYSYM_HOLE,
+ /* 1: L1/Stop */ KEYSYM_FUNC_L(1),
+ /* 2: */ KEYSYM_HOLE,
+ /* 3: L2/Again */ KEYSYM_FUNC_L(2),
+ /* 4: */ KEYSYM_HOLE,
+ /* 5: F1 */ KEYSYM_FUNC_F(1),
+ /* 6: F2 */ KEYSYM_FUNC_F(2),
+ /* 7: F10 */ KEYSYM_HOLE,
+ /* 8: F3 */ KEYSYM_FUNC_F(3),
+ /* 9: F11 */ KEYSYM_HOLE,
+ /* 10: F4 */ KEYSYM_FUNC_F(4),
+ /* 11: F12 */ KEYSYM_HOLE,
+ /* 12: F5 */ KEYSYM_FUNC_F(5),
+ /* 13: AltGraph */ KEYSYM_HOLE,
+ /* 14: F6 */ KEYSYM_FUNC_F(6),
+ /* 15: */ KEYSYM_HOLE,
+ /* 16: F7 */ KEYSYM_FUNC_F(7),
+ /* 17: F8 */ KEYSYM_FUNC_F(8),
+ /* 18: F9 */ KEYSYM_FUNC_F(9),
+ /* 19: Alt_L */ KEYSYM_SETMOD | KBMOD_ALT_L,
+ /* 20: T5_Up */ KEYSYM_HOLE,
+ /* 21: R1/Pause */ KEYSYM_FUNC_R(1),
+ /* 22: R2/Print */ KEYSYM_FUNC_R(2),
+ /* 23: R3/Break */ KEYSYM_FUNC_R(3),
+ /* 24: T5_Left */ KEYSYM_HOLE,
+ /* 25: L3/Props */ KEYSYM_FUNC_L(3),
+ /* 26: L4/Undo */ KEYSYM_FUNC_L(4),
+ /* 27: T5_Down */ KEYSYM_HOLE,
+ /* 28: T5_Right */ KEYSYM_HOLE,
+ /* 29: Esc */ 0x1b,
+ /* 30: 1 */ '1',
+ /* 31: 2 */ '2',
+ /* 32: 3 */ '3',
+ /* 33: 4 */ '4',
+ /* 34: 5 */ '5',
+ /* 35: 6 */ '6',
+ /* 36: 7 */ '7',
+ /* 37: 8 */ '8',
+ /* 38: 9 */ '9',
+ /* 39: 0 */ '0',
+ /* 40: minus */ '-',
+ /* 41: equal */ '=',
+ /* 42: grave/tilde */ '`',
+ /* 43: BackSpace */ '\b',
+ /* 44: */ KEYSYM_HOLE,
+ /* 45: R4/KP_Equal */ KEYSYM_FUNC_R(4),
+ /* 46: R5/KP_Div */ KEYSYM_FUNC_R(5),
+ /* 47: R6/KP_Mult */ KEYSYM_FUNC_R(6),
+ /* 48: */ KEYSYM_HOLE,
+ /* 49: L5/Front */ KEYSYM_FUNC_L(5),
+ /* 50: KP_Delete */ KEYSYM_HOLE,
+ /* 51: L6/Copy */ KEYSYM_FUNC_L(6),
+ /* 52: */ KEYSYM_HOLE,
+ /* 53: Tab */ '\t',
+ /* 54: Q */ 'q',
+ /* 55: W */ 'w',
+ /* 56: E */ 'e',
+ /* 57: R */ 'r',
+ /* 58: T */ 't',
+ /* 59: Y */ 'y',
+ /* 60: U */ 'u',
+ /* 61: I */ 'i',
+ /* 62: O */ 'o',
+ /* 63: P */ 'p',
+ /* 64: [ */ '[',
+ /* 65: ] */ ']',
+ /* 66: Delete */ 0x7f,
+ /* 67: Compose */ KEYSYM_HOLE,
+ /* 68: R7/Home */ KEYSYM_FUNC_R(7),
+ /* 69: R8/Up */ KEYSYM_STRING | 1,
+ /* 70: R9/PgUp */ KEYSYM_FUNC_R(9),
+ /* 71: KP_Minus */ KEYSYM_HOLE,
+ /* 72: L7/Open */ KEYSYM_FUNC_L(7),
+ /* 73: L8/Paste */ KEYSYM_FUNC_L(8),
+ /* 74: */ KEYSYM_HOLE,
+ /* 75: */ KEYSYM_HOLE,
+ /* 76: Ctrl_L */ KEYSYM_SETMOD | KBMOD_CTRL_L,
+ /* 77: A */ 'a',
+ /* 78: S */ 's',
+ /* 79: D */ 'd',
+ /* 80: F */ 'f',
+ /* 81: G */ 'g',
+ /* 82: H */ 'h',
+ /* 83: J */ 'j',
+ /* 84: K */ 'k',
+ /* 85: L */ 'l',
+ /* 86: ; */ ';',
+ /* 87: apostr. */ '\'',
+ /* 88: backslash */ '\\',
+ /* 89: Return */ '\r',
+ /* 90: KP_Enter */ KEYSYM_HOLE,
+ /* 91: R10/Left */ KEYSYM_STRING | 3,
+ /* 92: R11/KP_5 */ KEYSYM_FUNC_R(11),
+ /* 93: R12/Right */ KEYSYM_STRING | 4,
+ /* 94: KP_Insert */ KEYSYM_HOLE,
+ /* 95: L9/Find */ KEYSYM_FUNC_L(9),
+ /* 96: */ KEYSYM_HOLE,
+ /* 97: L10/Cut */ KEYSYM_FUNC_L(10),
+ /* 98: Num_Lock */ KEYSYM_HOLE,
+ /* 99: Shift_L */ KEYSYM_SETMOD | KBMOD_SHIFT_L,
+ /* 100: Z */ 'z',
+ /* 101: X */ 'x',
+ /* 102: C */ 'c',
+ /* 103: V */ 'v',
+ /* 104: B */ 'b',
+ /* 105: N */ 'n',
+ /* 106: M */ 'm',
+ /* 107: , */ ',',
+ /* 108: . */ '.',
+ /* 109: / */ '/',
+ /* 110: Shift_R */ KEYSYM_SETMOD | KBMOD_SHIFT_R,
+ /* 111: Linefeed */ '\n',
+ /* 112: R13/End */ KEYSYM_FUNC_R(13),
+ /* 113: R14/Down */ KEYSYM_STRING | 2,
+ /* 114: R15/PgDn */ KEYSYM_FUNC_R(15),
+ /* 115: */ KEYSYM_HOLE,
+ /* 116: */ KEYSYM_HOLE,
+ /* 117: */ KEYSYM_HOLE,
+ /* 118: L16/Help */ KEYSYM_HOLE,
+ /* 119: CapsLock */ KEYSYM_INVMOD | KBMOD_CAPSLOCK,
+ /* 120: Meta_L */ KEYSYM_SETMOD | KBMOD_META_L,
+ /* 121: SpaceBar */ ' ',
+ /* 122: Meta_R */ KEYSYM_SETMOD | KBMOD_META_R,
+ /* 123: */ KEYSYM_HOLE,
+ /* 124: */ KEYSYM_HOLE,
+ /* 125: KP_Add */ KEYSYM_HOLE,
+ /* 126: */ KEYSYM_HW_ERR,
+ /* 127: */ KEYSYM_ALL_UP,
+}};
+
+
+struct keymap keymap_s3_uc = {{
+ /* 0: */ KEYSYM_HOLE,
+ /* 1: L1/Stop */ KEYSYM_FUNC_L(1),
+ /* 2: */ KEYSYM_HOLE,
+ /* 3: L2/Again */ KEYSYM_FUNC_L(2),
+ /* 4: */ KEYSYM_HOLE,
+ /* 5: F1 */ KEYSYM_FUNC_F(1),
+ /* 6: F2 */ KEYSYM_FUNC_F(2),
+ /* 7: F10 */ KEYSYM_HOLE,
+ /* 8: F3 */ KEYSYM_FUNC_F(3),
+ /* 9: F11 */ KEYSYM_HOLE,
+ /* 10: F4 */ KEYSYM_FUNC_F(4),
+ /* 11: F12 */ KEYSYM_HOLE,
+ /* 12: F5 */ KEYSYM_FUNC_F(5),
+ /* 13: AltGraph */ KEYSYM_HOLE,
+ /* 14: F6 */ KEYSYM_FUNC_F(6),
+ /* 15: */ KEYSYM_HOLE,
+ /* 16: F7 */ KEYSYM_FUNC_F(7),
+ /* 17: F8 */ KEYSYM_FUNC_F(8),
+ /* 18: F9 */ KEYSYM_FUNC_F(9),
+ /* 19: Alt_L */ KEYSYM_SETMOD | KBMOD_ALT_L,
+ /* 20: T5_Up */ KEYSYM_HOLE,
+ /* 21: R1/Pause */ KEYSYM_FUNC_R(1),
+ /* 22: R2/Print */ KEYSYM_FUNC_R(2),
+ /* 23: R3/Break */ KEYSYM_FUNC_R(3),
+ /* 24: T5_Left */ KEYSYM_HOLE,
+ /* 25: L3/Props */ KEYSYM_FUNC_L(3),
+ /* 26: L4/Undo */ KEYSYM_FUNC_L(4),
+ /* 27: T5_Down */ KEYSYM_HOLE,
+ /* 28: T5_Right */ KEYSYM_HOLE,
+ /* 29: Esc */ 0x1b,
+ /* 30: 1 */ '!',
+ /* 31: 2 */ '@',
+ /* 32: 3 */ '#',
+ /* 33: 4 */ '$',
+ /* 34: 5 */ '%',
+ /* 35: 6 */ '^',
+ /* 36: 7 */ '&',
+ /* 37: 8 */ '*',
+ /* 38: 9 */ '(',
+ /* 39: 0 */ ')',
+ /* 40: minus */ '_',
+ /* 41: equal */ '+',
+ /* 42: grave/tilde */ '~',
+ /* 43: BackSpace */ '\b',
+ /* 44: */ KEYSYM_HOLE,
+ /* 45: R4/KP_Equal */ KEYSYM_FUNC_R(4),
+ /* 46: R5/KP_Div */ KEYSYM_FUNC_R(5),
+ /* 47: R6/KP_Mult */ KEYSYM_FUNC_R(6),
+ /* 48: */ KEYSYM_HOLE,
+ /* 49: L5/Front */ KEYSYM_FUNC_L(5),
+ /* 50: KP_Delete */ KEYSYM_HOLE,
+ /* 51: L6/Copy */ KEYSYM_FUNC_L(6),
+ /* 52: */ KEYSYM_HOLE,
+ /* 53: Tab */ '\t',
+ /* 54: Q */ 'Q',
+ /* 55: W */ 'W',
+ /* 56: E */ 'E',
+ /* 57: R */ 'R',
+ /* 58: T */ 'T',
+ /* 59: Y */ 'Y',
+ /* 60: U */ 'U',
+ /* 61: I */ 'I',
+ /* 62: O */ 'O',
+ /* 63: P */ 'P',
+ /* 64: [ */ '{',
+ /* 65: ] */ '}',
+ /* 66: Delete */ 0x7f,
+ /* 67: Compose */ KEYSYM_HOLE,
+ /* 68: R7/Home */ KEYSYM_FUNC_R(7),
+ /* 69: R8/Up */ KEYSYM_STRING | 1,
+ /* 70: R9/PgUp */ KEYSYM_FUNC_R(9),
+ /* 71: KP_Minus */ KEYSYM_HOLE,
+ /* 72: L7/Open */ KEYSYM_FUNC_L(7),
+ /* 73: L8/Paste */ KEYSYM_FUNC_L(8),
+ /* 74: */ KEYSYM_HOLE,
+ /* 75: */ KEYSYM_HOLE,
+ /* 76: Ctrl_L */ KEYSYM_SETMOD | KBMOD_CTRL_L,
+ /* 77: A */ 'A',
+ /* 78: S */ 'S',
+ /* 79: D */ 'D',
+ /* 80: F */ 'F',
+ /* 81: G */ 'G',
+ /* 82: H */ 'H',
+ /* 83: J */ 'J',
+ /* 84: K */ 'K',
+ /* 85: L */ 'L',
+ /* 86: ; */ ':',
+ /* 87: apostr. */ '"',
+ /* 88: backslash */ '|',
+ /* 89: Return */ '\r',
+ /* 90: KP_Enter */ KEYSYM_HOLE,
+ /* 91: R10/Left */ KEYSYM_STRING | 3,
+ /* 92: R11/KP_5 */ KEYSYM_FUNC_R(11),
+ /* 93: R12/Right */ KEYSYM_STRING | 4,
+ /* 94: KP_Insert */ KEYSYM_HOLE,
+ /* 95: L9/Find */ KEYSYM_FUNC_L(9),
+ /* 96: */ KEYSYM_HOLE,
+ /* 97: L10/Cut */ KEYSYM_FUNC_L(10),
+ /* 98: Num_Lock */ KEYSYM_HOLE,
+ /* 99: Shift_L */ KEYSYM_SETMOD | KBMOD_SHIFT_L,
+ /* 100: Z */ 'Z',
+ /* 101: X */ 'X',
+ /* 102: C */ 'C',
+ /* 103: V */ 'V',
+ /* 104: B */ 'B',
+ /* 105: N */ 'N',
+ /* 106: M */ 'M',
+ /* 107: , */ '<',
+ /* 108: . */ '>',
+ /* 109: / */ '?',
+ /* 110: Shift_R */ KEYSYM_SETMOD | KBMOD_SHIFT_R,
+ /* 111: Linefeed */ '\n',
+ /* 112: R13/End */ KEYSYM_FUNC_R(13),
+ /* 113: R14/Down */ KEYSYM_STRING | 2,
+ /* 114: R15/PgDn */ KEYSYM_FUNC_R(15),
+ /* 115: */ KEYSYM_HOLE,
+ /* 116: */ KEYSYM_HOLE,
+ /* 117: */ KEYSYM_HOLE,
+ /* 118: L16/Help */ KEYSYM_HOLE,
+ /* 119: CapsLock */ KEYSYM_INVMOD | KBMOD_CAPSLOCK,
+ /* 120: Meta_L */ KEYSYM_SETMOD | KBMOD_META_L,
+ /* 121: SpaceBar */ ' ',
+ /* 122: Meta_R */ KEYSYM_SETMOD | KBMOD_META_R,
+ /* 123: */ KEYSYM_HOLE,
+ /* 124: */ KEYSYM_HOLE,
+ /* 125: KP_Add */ KEYSYM_HOLE,
+ /* 126: */ KEYSYM_HW_ERR,
+ /* 127: */ KEYSYM_ALL_UP,
+}};
+
+
+/*
+ * Keymaps for the "type 4" keyboard.
+ * (lower-case, upper-case)
+ */
+
+struct keymap keymap_s4_lc = {{
+ /* 0: */ KEYSYM_HOLE,
+ /* 1: L1/Stop */ KEYSYM_FUNC_L(1),
+ /* 2: */ KEYSYM_HOLE,
+ /* 3: L2/Again */ KEYSYM_FUNC_L(2),
+ /* 4: */ KEYSYM_HOLE,
+ /* 5: F1 */ KEYSYM_FUNC_F(1),
+ /* 6: F2 */ KEYSYM_FUNC_F(2),
+ /* 7: F10 */ KEYSYM_FUNC_F(10),
+ /* 8: F3 */ KEYSYM_FUNC_F(3),
+ /* 9: F11 */ KEYSYM_FUNC_F(11),
+ /* 10: F4 */ KEYSYM_FUNC_F(4),
+ /* 11: F12 */ KEYSYM_FUNC_F(12),
+ /* 12: F5 */ KEYSYM_FUNC_F(5),
+ /* 13: AltGraph */ KEYSYM_SETMOD | KBMOD_ALTGRAPH,
+ /* 14: F6 */ KEYSYM_FUNC_F(6),
+ /* 15: */ KEYSYM_HOLE,
+ /* 16: F7 */ KEYSYM_FUNC_F(7),
+ /* 17: F8 */ KEYSYM_FUNC_F(8),
+ /* 18: F9 */ KEYSYM_FUNC_F(9),
+ /* 19: Alt_L */ KEYSYM_SETMOD | KBMOD_ALT_L,
+ /* 20: T5_Up */ KEYSYM_HOLE,
+ /* 21: R1/Pause */ KEYSYM_FUNC_R(1),
+ /* 22: R2/Print */ KEYSYM_FUNC_R(2),
+ /* 23: R3/Break */ KEYSYM_FUNC_R(3),
+ /* 24: T5_Left */ KEYSYM_HOLE,
+ /* 25: L3/Props */ KEYSYM_FUNC_L(3),
+ /* 26: L4/Undo */ KEYSYM_FUNC_L(4),
+ /* 27: T5_Down */ KEYSYM_HOLE,
+ /* 28: T5_Right */ KEYSYM_HOLE,
+ /* 29: Esc */ 0x1b,
+ /* 30: 1 */ '1',
+ /* 31: 2 */ '2',
+ /* 32: 3 */ '3',
+ /* 33: 4 */ '4',
+ /* 34: 5 */ '5',
+ /* 35: 6 */ '6',
+ /* 36: 7 */ '7',
+ /* 37: 8 */ '8',
+ /* 38: 9 */ '9',
+ /* 39: 0 */ '0',
+ /* 40: minus */ '-',
+ /* 41: equal */ '=',
+ /* 42: grave/tilde */ '`',
+ /* 43: BackSpace */ '\b',
+ /* 44: */ KEYSYM_HOLE,
+ /* 45: R4/KP_Equal */ KEYSYM_FUNC_R(4),
+ /* 46: R5/KP_Div */ KEYSYM_FUNC_R(5),
+ /* 47: R6/KP_Mult */ KEYSYM_FUNC_R(6),
+ /* 48: */ KEYSYM_FUNC_N(13),
+ /* 49: L5/Front */ KEYSYM_FUNC_L(5),
+ /* 50: KP_Delete */ KEYSYM_FUNC_N(10),
+ /* 51: L6/Copy */ KEYSYM_FUNC_L(6),
+ /* 52: */ KEYSYM_HOLE,
+ /* 53: Tab */ '\t',
+ /* 54: Q */ 'q',
+ /* 55: W */ 'w',
+ /* 56: E */ 'e',
+ /* 57: R */ 'r',
+ /* 58: T */ 't',
+ /* 59: Y */ 'y',
+ /* 60: U */ 'u',
+ /* 61: I */ 'i',
+ /* 62: O */ 'o',
+ /* 63: P */ 'p',
+ /* 64: [ */ '[',
+ /* 65: ] */ ']',
+ /* 66: Delete */ 0x7f,
+ /* 67: Compose */ KEYSYM_COMPOSE,
+ /* 68: R7/Home */ KEYSYM_FUNC_R(7),
+ /* 69: R8/Up */ KEYSYM_STRING | 1,
+ /* 70: R9/PgUp */ KEYSYM_FUNC_R(9),
+ /* 71: KP_Minus */ KEYSYM_FUNC_N(15),
+ /* 72: L7/Open */ KEYSYM_FUNC_L(7),
+ /* 73: L8/Paste */ KEYSYM_FUNC_L(8),
+ /* 74: */ KEYSYM_HOLE,
+ /* 75: */ KEYSYM_HOLE,
+ /* 76: Ctrl_L */ KEYSYM_SETMOD | KBMOD_CTRL_L,
+ /* 77: A */ 'a',
+ /* 78: S */ 's',
+ /* 79: D */ 'd',
+ /* 80: F */ 'f',
+ /* 81: G */ 'g',
+ /* 82: H */ 'h',
+ /* 83: J */ 'j',
+ /* 84: K */ 'k',
+ /* 85: L */ 'l',
+ /* 86: ; */ ';',
+ /* 87: apostr. */ '\'',
+ /* 88: backslash */ '\\',
+ /* 89: Return */ '\r',
+ /* 90: KP_Enter */ KEYSYM_FUNC_N(11),
+ /* 91: R10/Left */ KEYSYM_STRING | 3,
+ /* 92: R11/KP_5 */ KEYSYM_FUNC_R(11),
+ /* 93: R12/Right */ KEYSYM_STRING | 4,
+ /* 94: KP_Insert */ KEYSYM_FUNC_N(8),
+ /* 95: L9/Find */ KEYSYM_FUNC_L(9),
+ /* 96: */ KEYSYM_HOLE,
+ /* 97: L10/Cut */ KEYSYM_FUNC_L(10),
+ /* 98: Num_Lock */ KEYSYM_INVMOD | KBMOD_NUMLOCK,
+ /* 99: Shift_L */ KEYSYM_SETMOD | KBMOD_SHIFT_L,
+ /* 100: Z */ 'z',
+ /* 101: X */ 'x',
+ /* 102: C */ 'c',
+ /* 103: V */ 'v',
+ /* 104: B */ 'b',
+ /* 105: N */ 'n',
+ /* 106: M */ 'm',
+ /* 107: , */ ',',
+ /* 108: . */ '.',
+ /* 109: / */ '/',
+ /* 110: Shift_R */ KEYSYM_SETMOD | KBMOD_SHIFT_R,
+ /* 111: Linefeed */ '\n',
+ /* 112: R13/End */ KEYSYM_FUNC_R(13),
+ /* 113: R14/Down */ KEYSYM_STRING | 2,
+ /* 114: R15/PgDn */ KEYSYM_FUNC_R(15),
+ /* 115: */ KEYSYM_HOLE,
+ /* 116: */ KEYSYM_HOLE,
+ /* 117: */ KEYSYM_HOLE,
+ /* 118: L16/Help */ KEYSYM_FUNC_L(16),
+ /* 119: CapsLock */ KEYSYM_INVMOD | KBMOD_CAPSLOCK,
+ /* 120: Meta_L */ KEYSYM_SETMOD | KBMOD_META_L,
+ /* 121: SpaceBar */ ' ',
+ /* 122: Meta_R */ KEYSYM_SETMOD | KBMOD_META_R,
+ /* 123: */ KEYSYM_HOLE,
+ /* 124: */ KEYSYM_HOLE,
+ /* 125: KP_Add */ KEYSYM_FUNC_N(14),
+ /* 126: */ KEYSYM_HW_ERR,
+ /* 127: */ KEYSYM_ALL_UP,
+}};
+
+
+struct keymap keymap_s4_uc = {{
+ /* 0: */ KEYSYM_HOLE,
+ /* 1: L1/Stop */ KEYSYM_FUNC_L(1),
+ /* 2: */ KEYSYM_HOLE,
+ /* 3: L2/Again */ KEYSYM_FUNC_L(2),
+ /* 4: */ KEYSYM_HOLE,
+ /* 5: F1 */ KEYSYM_FUNC_F(1),
+ /* 6: F2 */ KEYSYM_FUNC_F(2),
+ /* 7: F10 */ KEYSYM_FUNC_F(10),
+ /* 8: F3 */ KEYSYM_FUNC_F(3),
+ /* 9: F11 */ KEYSYM_FUNC_F(11),
+ /* 10: F4 */ KEYSYM_FUNC_F(4),
+ /* 11: F12 */ KEYSYM_FUNC_F(12),
+ /* 12: F5 */ KEYSYM_FUNC_F(5),
+ /* 13: AltGraph */ KEYSYM_SETMOD | KBMOD_ALTGRAPH,
+ /* 14: F6 */ KEYSYM_FUNC_F(6),
+ /* 15: */ KEYSYM_HOLE,
+ /* 16: F7 */ KEYSYM_FUNC_F(7),
+ /* 17: F8 */ KEYSYM_FUNC_F(8),
+ /* 18: F9 */ KEYSYM_FUNC_F(9),
+ /* 19: Alt_L */ KEYSYM_SETMOD | KBMOD_ALT_L,
+ /* 20: T5_Up */ KEYSYM_HOLE,
+ /* 21: R1/Pause */ KEYSYM_FUNC_R(1),
+ /* 22: R2/Print */ KEYSYM_FUNC_R(2),
+ /* 23: R3/Break */ KEYSYM_FUNC_R(3),
+ /* 24: T5_Left */ KEYSYM_HOLE,
+ /* 25: L3/Props */ KEYSYM_FUNC_L(3),
+ /* 26: L4/Undo */ KEYSYM_FUNC_L(4),
+ /* 27: T5_Down */ KEYSYM_HOLE,
+ /* 28: T5_Right */ KEYSYM_HOLE,
+ /* 29: Esc */ 0x1b,
+ /* 30: 1 */ '!',
+ /* 31: 2 */ '@',
+ /* 32: 3 */ '#',
+ /* 33: 4 */ '$',
+ /* 34: 5 */ '%',
+ /* 35: 6 */ '^',
+ /* 36: 7 */ '&',
+ /* 37: 8 */ '*',
+ /* 38: 9 */ '(',
+ /* 39: 0 */ ')',
+ /* 40: minus */ '_',
+ /* 41: equal */ '+',
+ /* 42: grave/tilde */ '~',
+ /* 43: BackSpace */ '\b',
+ /* 44: */ KEYSYM_HOLE,
+ /* 45: R4/KP_Equal */ KEYSYM_FUNC_R(4),
+ /* 46: R5/KP_Div */ KEYSYM_FUNC_R(5),
+ /* 47: R6/KP_Mult */ KEYSYM_FUNC_R(6),
+ /* 48: */ KEYSYM_FUNC_N(13),
+ /* 49: L5/Front */ KEYSYM_FUNC_L(5),
+ /* 50: KP_Delete */ KEYSYM_FUNC_N(10),
+ /* 51: L6/Copy */ KEYSYM_FUNC_L(6),
+ /* 52: */ KEYSYM_HOLE,
+ /* 53: Tab */ '\t',
+ /* 54: Q */ 'Q',
+ /* 55: W */ 'W',
+ /* 56: E */ 'E',
+ /* 57: R */ 'R',
+ /* 58: T */ 'T',
+ /* 59: Y */ 'Y',
+ /* 60: U */ 'U',
+ /* 61: I */ 'I',
+ /* 62: O */ 'O',
+ /* 63: P */ 'P',
+ /* 64: [ */ '{',
+ /* 65: ] */ '}',
+ /* 66: Delete */ 0x7f,
+ /* 67: Compose */ KEYSYM_COMPOSE,
+ /* 68: R7/Home */ KEYSYM_FUNC_R(7),
+ /* 69: R8/Up */ KEYSYM_STRING | 1,
+ /* 70: R9/PgUp */ KEYSYM_FUNC_R(9),
+ /* 71: KP_Minus */ KEYSYM_FUNC_N(15),
+ /* 72: L7/Open */ KEYSYM_FUNC_L(7),
+ /* 73: L8/Paste */ KEYSYM_FUNC_L(8),
+ /* 74: */ KEYSYM_HOLE,
+ /* 75: */ KEYSYM_HOLE,
+ /* 76: Ctrl_L */ KEYSYM_SETMOD | KBMOD_CTRL_L,
+ /* 77: A */ 'A',
+ /* 78: S */ 'S',
+ /* 79: D */ 'D',
+ /* 80: F */ 'F',
+ /* 81: G */ 'G',
+ /* 82: H */ 'H',
+ /* 83: J */ 'J',
+ /* 84: K */ 'K',
+ /* 85: L */ 'L',
+ /* 86: ; */ ':',
+ /* 87: apostr. */ '"',
+ /* 88: backslash */ '|',
+ /* 89: Return */ '\r',
+ /* 90: KP_Enter */ KEYSYM_FUNC_N(11),
+ /* 91: R10/Left */ KEYSYM_STRING | 3,
+ /* 92: R11/KP_5 */ KEYSYM_FUNC_R(11),
+ /* 93: R12/Right */ KEYSYM_STRING | 4,
+ /* 94: KP_Insert */ KEYSYM_FUNC_N(8),
+ /* 95: L9/Find */ KEYSYM_FUNC_L(9),
+ /* 96: */ KEYSYM_HOLE,
+ /* 97: L10/Cut */ KEYSYM_FUNC_L(10),
+ /* 98: Num_Lock */ KEYSYM_INVMOD | KBMOD_NUMLOCK,
+ /* 99: Shift_L */ KEYSYM_SETMOD | KBMOD_SHIFT_L,
+ /* 100: Z */ 'Z',
+ /* 101: X */ 'X',
+ /* 102: C */ 'C',
+ /* 103: V */ 'V',
+ /* 104: B */ 'B',
+ /* 105: N */ 'N',
+ /* 106: M */ 'M',
+ /* 107: , */ '<',
+ /* 108: . */ '>',
+ /* 109: / */ '?',
+ /* 110: Shift_R */ KEYSYM_SETMOD | KBMOD_SHIFT_R,
+ /* 111: Linefeed */ '\n',
+ /* 112: R13/End */ KEYSYM_FUNC_R(13),
+ /* 113: R14/Down */ KEYSYM_STRING | 2,
+ /* 114: R15/PgDn */ KEYSYM_FUNC_R(15),
+ /* 115: */ KEYSYM_HOLE,
+ /* 116: */ KEYSYM_HOLE,
+ /* 117: */ KEYSYM_HOLE,
+ /* 118: L16/Help */ KEYSYM_FUNC_L(16),
+ /* 119: CapsLock */ KEYSYM_INVMOD | KBMOD_CAPSLOCK,
+ /* 120: Meta_L */ KEYSYM_SETMOD | KBMOD_META_L,
+ /* 121: SpaceBar */ ' ',
+ /* 122: Meta_R */ KEYSYM_SETMOD | KBMOD_META_R,
+ /* 123: */ KEYSYM_HOLE,
+ /* 124: */ KEYSYM_HOLE,
+ /* 125: KP_Add */ KEYSYM_FUNC_N(14),
+ /* 126: */ KEYSYM_HW_ERR,
+ /* 127: */ KEYSYM_ALL_UP,
+}};
+
+
+
+/*
+ * Strings indexed by: (KEYSYM_STRING | idx)
+ */
+char kbd_stringtab[16][10] = {
+ { 0x1b, '[', 'H', 0 }, /* Home */
+ { 0x1b, '[', 'A', 0 }, /* Up */
+ { 0x1b, '[', 'B', 0 }, /* Down */
+ { 0x1b, '[', 'D', 0 }, /* Left */
+ { 0x1b, '[', 'C', 0 }, /* Right */
+};
+
+/*
+ * The "NumLock" map, which is used to remap
+ * function keysyms when NumLock is on.
+ */
+unsigned short kbd_numlock_map[64] = {
+ /* KEYSYM_FUNC_L: Identity map */
+ 0x600, 0x601, 0x602, 0x603, 0x604, 0x605, 0x606, 0x607,
+ 0x608, 0x609, 0x60a, 0x60b, 0x60c, 0x60d, 0x60e, 0x60f,
+
+ /* KEYSYM_FUNC_R: remap to numbers... */
+ 0x610, 0x611, 0x612,
+ '=', '/', '*',
+ '7', '8', '9',
+ '4', '5', '6',
+ '1', '2', '3',
+ 0x61f,
+
+ /* KEYSYM_FUNC_F: Identity map */
+ 0x620, 0x621, 0x622, 0x623, 0x624, 0x625, 0x626, 0x627,
+ 0x628, 0x629, 0x62a, 0x62b, 0x62c, 0x62d, 0x62e, 0x62f,
+
+ /* KEYSYM_FUNC_N: remap just a few... */
+ 0x630, 0x631, 0x632, 0x633, 0x634, 0x635, 0x636, '0',
+ 0x638, '.', '\r', 0x63b, 0x63c, '+', '-', 0x63f,
+};
+
+
+/*
+ * Keyboard descriptions for each type.
+ */
+
+/* Treat type 2 as type 3 (close enough) */
+#define kbd_type2 kbd_type3
+
+static struct keyboard kbd_type3 = {
+ &keymap_release,
+ &keymap_control,
+ &keymap_s3_lc,
+ &keymap_s3_uc,
+};
+
+static struct keyboard kbd_type4 = {
+ &keymap_release,
+ &keymap_control,
+ &keymap_s4_lc,
+ &keymap_s4_uc,
+};
+
+/* Treat type 5 as type 4 (close enough) */
+#define kbd_type5 kbd_type4
+
+struct keyboard * keyboards[] = {
+ 0, /* type 0 */
+ 0, /* type 1 */
+ &kbd_type2,
+ &kbd_type3,
+ &kbd_type4,
+ &kbd_type5,
+};
+int kbd_max_type = 5;
diff --git a/sys/arch/sun3/dev/kbd_tables.h b/sys/arch/sun3/dev/kbd_tables.h
new file mode 100644
index 00000000000..b29f28e88ac
--- /dev/null
+++ b/sys/arch/sun3/dev/kbd_tables.h
@@ -0,0 +1,151 @@
+/* $OpenBSD: kbd_tables.h,v 1.1 1997/08/19 11:48:06 kstailey Exp $ */
+/* $NetBSD: kbd_tables.h,v 1.3 1996/02/29 19:37:53 gwr Exp $ */
+
+/*
+ * Copyright (c) 1996 Gordon W. Ross
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ * 4. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by Gordon Ross
+ *
+ * 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.
+ */
+
+/*
+ * Keyboard translation tables. These tables contain
+ * "Key symbols" (or "keysyms", to use X terminology).
+ * The key symbol space is divided into "classes" where
+ * the high 8 bits determine the symbol class, and the
+ * low 8 bits are interpreted in a way specific to each
+ * class. The simplest class is ASCII, which is defined
+ * as class zero in order to simplify table definition.
+ *
+ * For convenience in the driver, all keysyms that
+ * deserve autorepeat are below 0x8000. The driver
+ * uses the following macro to determine if a keysym
+ * should NOT get autorepeat.
+ */
+#define KEYSYM_NOREPEAT(sym) ((sym) & 0x8000)
+
+#define KEYSYM_CLASS(sym) ((sym) & 0xFF00)
+#define KEYSYM_DATA(sym) ((sym) & 0x00FF)
+
+/*
+ * The ACSII class. Low 8 bits are the character.
+ */
+#define KEYSYM_ASCII 0
+
+/*
+ * The "special" class.
+ * We don't expect to receive any of these often,
+ * except for KEYSYM_NOP. All can be ignored,
+ * because HW_ERR, LAYOUT, RESET, are all handled
+ * at a lower layer, before the translation code.
+ */
+#define KEYSYM_SPECIAL 0x8300
+#define KEYSYM_NOP 0x8300
+#define KEYSYM_OOPS 0x8301
+#define KEYSYM_HOLE 0x8302
+#define KEYSYM_HW_ERR 0x8307 /* kbd sent 0x7e */
+#define KEYSYM_LAYOUT 0x830e /* kbd sent 0xfe */
+#define KEYSYM_RESET 0x830f /* kbd sent 0xff */
+
+
+/*
+ * Floating accents class: (not implemented)
+ * umlaut, circumflex, tilde, cedilla, acute, grave,...
+ */
+#define KEYSYM_ACCENT 0x0400
+
+/*
+ * The string entry class.
+ * The low 4 bits select one of the entries from
+ * the string table. (see kbd_stringtab[])
+ * By default, the string table has ANSI movement
+ * sequences for the arrow keys.
+ */
+#define KEYSYM_STRING 0x0500
+
+/*
+ * Function keys (compatible with SunOS 4.1)
+ * L:left, R:right, F:func(top), N:numeric
+ */
+#define KEYSYM_FUNC 0x0600
+#define KEYSYM_FUNC_L(x) (KEYSYM_FUNC | ((x) - 1))
+#define KEYSYM_FUNC_R(x) (KEYSYM_FUNC | ((x) - 1 + 0x10))
+#define KEYSYM_FUNC_F(x) (KEYSYM_FUNC | ((x) - 1 + 0x20))
+#define KEYSYM_FUNC_N(x) (KEYSYM_FUNC | ((x) - 1 + 0x30))
+
+/*
+ * Modifier symbols, to set/clear/toggle a modifier
+ * The low 5 bits define the position of a modifier
+ * bit to be cleared, set, or inverted. The meanings
+ * of the modifier bit positions are defined below.
+ */
+#define KEYSYM_CLRMOD 0x9000
+#define KEYSYM_SETMOD 0x9100
+#define KEYSYM_INVMOD 0x9200
+#define KEYSYM_ALL_UP 0x9300
+
+/*
+ * Modifier indices.
+ * (logical OR with {CLR,SET,TOG}MOD above)
+ */
+#define KBMOD_CTRL_L 0
+#define KBMOD_CTRL_R 1
+#define KBMOD_SHIFT_L 2
+#define KBMOD_SHIFT_R 3
+#define KBMOD_META_L 4
+#define KBMOD_META_R 5
+#define KBMOD_ALT_L 6
+#define KBMOD_ALT_R 7
+/* Note 0-15 are cleared by ALL_UP */
+#define KBMOD_CAPSLOCK 16
+#define KBMOD_NUMLOCK 17
+
+#define KBMOD_ALTGRAPH KBMOD_ALT_R
+
+
+#ifdef _KERNEL
+
+#define KEYMAP_SIZE 128
+
+struct keymap {
+ unsigned short keymap[KEYMAP_SIZE];
+};
+
+struct keyboard {
+ struct keymap *k_release; /* Key released */
+ struct keymap *k_control; /* Ctrl is down */
+ struct keymap *k_normal; /* No shifts */
+ struct keymap *k_shifted; /* Shift is down */
+};
+
+extern char kbd_stringtab[16][10];
+extern unsigned short kbd_numlock_map[64];
+
+extern struct keyboard * keyboards[];
+extern int kbd_max_type;
+#define KBD_MIN_TYPE 2
+
+#endif /* _KERNEL */
diff --git a/sys/arch/sun3/dev/kbd_xlate.h b/sys/arch/sun3/dev/kbd_xlate.h
new file mode 100644
index 00000000000..a7cf47061ae
--- /dev/null
+++ b/sys/arch/sun3/dev/kbd_xlate.h
@@ -0,0 +1,92 @@
+/* $OpenBSD: kbd_xlate.h,v 1.1 1997/08/19 11:48:07 kstailey Exp $ */
+/* $NetBSD: kbd_xlate.h,v 1.1.1.1 1996/01/24 01:15:35 gwr Exp $ */
+
+/*
+ * Copyright (c) 1992, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This software was developed by the Computer Systems Engineering group
+ * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
+ * contributed to Berkeley.
+ *
+ * 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, Lawrence Berkeley Laboratory.
+ *
+ * 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.
+ *
+ * @(#)kbd.c 8.2 (Berkeley) 10/30/93
+ */
+
+/*
+ * This defines the interface provided by kbd_xlate()
+ */
+
+#include <dev/sun/kbd_tables.h>
+
+#define KEY_CODE(c) ((c) & KBD_KEYMASK) /* keyboard code index */
+#define KEY_UP(c) ((c) & KBD_UP) /* true => key went up */
+
+#define KBMOD_CTRL_MASK ((1 << KBMOD_CTRL_L) | (1 << KBMOD_CTRL_R))
+#define KBMOD_SHIFT_MASK ((1 << KBMOD_SHIFT_L) | (1 << KBMOD_SHIFT_R))
+#define KBMOD_META_MASK ((1 << KBMOD_META_L) | (1 << KBMOD_META_R))
+#define KBMOD_ALT_MASK ((1 << KBMOD_ALT_L) | (1 << KBMOD_ALT_R))
+
+
+/*
+ * Keycode translator state.
+ * We need to remember the state of the keyboard's shift and
+ * control keys, and we need a per-type translation table.
+ */
+struct kbd_state {
+ struct keyboard kbd_k; /* table pointers */
+ int kbd_modbits; /* modifier keys */
+ int kbd_expect; /* expect ID or layout byte */
+#define KBD_EXPECT_IDCODE 1
+#define KBD_EXPECT_LAYOUT 2
+
+ u_char kbd_id; /* a place to store the ID */
+ u_char kbd_layout; /* which keyboard layout */
+ u_char kbd_click; /* true => keyclick enabled */
+ u_char kbd_leds; /* LED state */
+
+};
+
+extern void kbd_xlate_init __P((struct kbd_state *ks));
+extern int kbd_code_to_keysym __P((struct kbd_state *ks, int c));
+
+/*
+ * XXX: kd/kbd interface... Does this belong elsewhere?
+ * This is the only header shared between them...
+ */
+
+extern int kbd_iopen __P((int unit));
+extern void kd_init __P((int unit));
+extern void kd_input __P((int c));
diff --git a/sys/arch/sun3/dev/ms.c b/sys/arch/sun3/dev/ms.c
new file mode 100644
index 00000000000..69be7655788
--- /dev/null
+++ b/sys/arch/sun3/dev/ms.c
@@ -0,0 +1,638 @@
+/* $OpenBSD: ms.c,v 1.3 1997/08/19 11:48:08 kstailey Exp $ */
+/* $NetBSD: ms.c,v 1.6 1996/05/17 19:32:09 gwr Exp $ */
+
+/*
+ * Copyright (c) 1992, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This software was developed by the Computer Systems Engineering group
+ * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
+ * contributed to Berkeley.
+ *
+ * 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, Lawrence Berkeley Laboratory.
+ *
+ * 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.
+ *
+ * @(#)ms.c 8.1 (Berkeley) 6/11/93
+ */
+
+/*
+ * Mouse driver (/dev/mouse)
+ */
+
+/*
+ * Zilog Z8530 Dual UART driver (mouse interface)
+ *
+ * This is the "slave" driver that will be attached to
+ * the "zsc" driver for a Sun mouse.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/device.h>
+#include <sys/conf.h>
+#include <sys/ioctl.h>
+#include <sys/kernel.h>
+#include <sys/signalvar.h>
+#include <sys/syslog.h>
+
+#include <dev/ic/z8530reg.h>
+#include <machine/z8530var.h>
+#include <machine/vuid_event.h>
+
+#include "event_var.h"
+
+/*
+ * How many input characters we can buffer.
+ * The port-specific var.h may override this.
+ * Note: must be a power of two!
+ */
+#define MS_RX_RING_SIZE 256
+#define MS_RX_RING_MASK (MS_RX_RING_SIZE-1)
+/*
+ * Output buffer. Only need a few chars.
+ */
+#define MS_TX_RING_SIZE 16
+#define MS_TX_RING_MASK (MS_TX_RING_SIZE-1)
+/*
+ * Keyboard serial line speed is fixed at 1200 bps.
+ */
+#define MS_BPS 1200
+
+/*
+ * Mouse state. A Mouse Systems mouse is a fairly simple device,
+ * producing five-byte blobs of the form:
+ *
+ * b dx dy dx dy
+ *
+ * where b is the button state, encoded as 0x80|(~buttons)---there are
+ * three buttons (4=left, 2=middle, 1=right)---and dx,dy are X and Y
+ * delta values, none of which have are in [0x80..0x87]. (This lets
+ * us sync up with the mouse after an error.)
+ */
+struct ms_softc {
+ struct device ms_dev; /* required first: base device */
+ struct zs_chanstate *ms_cs;
+
+ /* Flags to communicate with ms_softintr() */
+ volatile int ms_intr_flags;
+#define INTR_RX_OVERRUN 1
+#define INTR_TX_EMPTY 2
+#define INTR_ST_CHECK 4
+
+ /*
+ * The receive ring buffer.
+ */
+ u_int ms_rbget; /* ring buffer `get' index */
+ volatile u_int ms_rbput; /* ring buffer `put' index */
+ u_short ms_rbuf[MS_RX_RING_SIZE]; /* rr1, data pairs */
+
+ /*
+ * State of input translator
+ */
+ short ms_byteno; /* input byte number, for decode */
+ char ms_mb; /* mouse button state */
+ char ms_ub; /* user button state */
+ int ms_dx; /* delta-x */
+ int ms_dy; /* delta-y */
+
+ /*
+ * State of upper interface.
+ */
+ volatile int ms_ready; /* event queue is ready */
+ struct evvar ms_events; /* event queue state */
+} ms_softc;
+
+cdev_decl(ms); /* open, close, read, write, ioctl, stop, ... */
+
+struct zsops zsops_ms;
+
+/****************************************************************
+ * Definition of the driver for autoconfig.
+ ****************************************************************/
+
+static int ms_match __P((struct device *, void *, void *));
+static void ms_attach __P((struct device *, struct device *, void *));
+
+static void ms_input __P((register struct ms_softc *, register int));
+static void ms_rxint __P((register struct zs_chanstate *));
+static void ms_txint __P((register struct zs_chanstate *));
+static void ms_stint __P((register struct zs_chanstate *));
+static void ms_softint __P((struct zs_chanstate *));
+
+struct cfattach ms_ca = {
+ sizeof(struct ms_softc), ms_match, ms_attach
+};
+
+struct cfdriver ms_cd = {
+ NULL, "ms", DV_DULL
+};
+
+
+/*
+ * ms_match: how is this zs channel configured?
+ */
+int
+ms_match(parent, match, aux)
+ struct device *parent;
+ void *match, *aux;
+{
+ struct cfdata *cf = match;
+ struct zsc_attach_args *args = aux;
+
+ /* Exact match required for keyboard. */
+ if (cf->cf_loc[0] == args->channel)
+ return 2;
+
+ return 0;
+}
+
+void
+ms_attach(parent, self, aux)
+ struct device *parent, *self;
+ void *aux;
+
+{
+ struct zsc_softc *zsc = (void *) parent;
+ struct ms_softc *ms = (void *) self;
+ struct zsc_attach_args *args = aux;
+ struct zs_chanstate *cs;
+ struct cfdata *cf;
+ int channel, ms_unit;
+ int reset, s, tconst;
+
+ cf = ms->ms_dev.dv_cfdata;
+ ms_unit = ms->ms_dev.dv_unit;
+ channel = args->channel;
+ cs = &zsc->zsc_cs[channel];
+ cs->cs_private = ms;
+ cs->cs_ops = &zsops_ms;
+ ms->ms_cs = cs;
+
+ printf("\n");
+
+ /* Initialize the speed, etc. */
+ tconst = BPS_TO_TCONST(cs->cs_brg_clk, MS_BPS);
+ s = splzs();
+ /* May need reset... */
+ reset = (channel == 0) ?
+ ZSWR9_A_RESET : ZSWR9_B_RESET;
+ zs_write_reg(cs, 9, reset);
+ /* These are OK as set by zscc: WR3, WR4, WR5 */
+ cs->cs_preg[5] |= ZSWR5_DTR | ZSWR5_RTS;
+ cs->cs_preg[12] = tconst;
+ cs->cs_preg[13] = tconst >> 8;
+ zs_loadchannelregs(cs);
+ splx(s);
+
+ /* Initialize translator. */
+ ms->ms_byteno = -1;
+}
+
+/****************************************************************
+ * Entry points for /dev/mouse
+ * (open,close,read,write,...)
+ ****************************************************************/
+
+int
+msopen(dev, flags, mode, p)
+ dev_t dev;
+ int flags, mode;
+ struct proc *p;
+{
+ struct ms_softc *ms;
+ int unit;
+
+ unit = minor(dev);
+ if (unit >= ms_cd.cd_ndevs)
+ return (ENXIO);
+ ms = ms_cd.cd_devs[unit];
+ if (ms == NULL)
+ return (ENXIO);
+
+ /* This is an exclusive open device. */
+ if (ms->ms_events.ev_io)
+ return (EBUSY);
+ ms->ms_events.ev_io = p;
+ ev_init(&ms->ms_events); /* may cause sleep */
+
+ ms->ms_ready = 1; /* start accepting events */
+ return (0);
+}
+
+int
+msclose(dev, flags, mode, p)
+ dev_t dev;
+ int flags, mode;
+ struct proc *p;
+{
+ struct ms_softc *ms;
+
+ ms = ms_cd.cd_devs[minor(dev)];
+ ms->ms_ready = 0; /* stop accepting events */
+ ev_fini(&ms->ms_events);
+
+ ms->ms_events.ev_io = NULL;
+ return (0);
+}
+
+int
+msread(dev, uio, flags)
+ dev_t dev;
+ struct uio *uio;
+ int flags;
+{
+ struct ms_softc *ms;
+
+ ms = ms_cd.cd_devs[minor(dev)];
+ return (ev_read(&ms->ms_events, uio, flags));
+}
+
+/* this routine should not exist, but is convenient to write here for now */
+int
+mswrite(dev, uio, flags)
+ dev_t dev;
+ struct uio *uio;
+ int flags;
+{
+
+ return (EOPNOTSUPP);
+}
+
+int
+msioctl(dev, cmd, data, flag, p)
+ dev_t dev;
+ u_long cmd;
+ register caddr_t data;
+ int flag;
+ struct proc *p;
+{
+ struct ms_softc *ms;
+
+ ms = ms_cd.cd_devs[minor(dev)];
+
+ switch (cmd) {
+
+ case FIONBIO: /* we will remove this someday (soon???) */
+ return (0);
+
+ case FIOASYNC:
+ ms->ms_events.ev_async = *(int *)data != 0;
+ return (0);
+
+ case TIOCSPGRP:
+ if (*(int *)data != ms->ms_events.ev_io->p_pgid)
+ return (EPERM);
+ return (0);
+
+ case VUIDGFORMAT:
+ /* we only do firm_events */
+ *(int *)data = VUID_FIRM_EVENT;
+ return (0);
+
+ case VUIDSFORMAT:
+ if (*(int *)data != VUID_FIRM_EVENT)
+ return (EINVAL);
+ return (0);
+ }
+ return (ENOTTY);
+}
+
+int
+msselect(dev, rw, p)
+ dev_t dev;
+ int rw;
+ struct proc *p;
+{
+ struct ms_softc *ms;
+
+ ms = ms_cd.cd_devs[minor(dev)];
+ return (ev_select(&ms->ms_events, rw, p));
+}
+
+
+/****************************************************************
+ * Middle layer (translator)
+ ****************************************************************/
+
+/*
+ * Called by our ms_softint() routine on input.
+ */
+void
+ms_input(ms, c)
+ register struct ms_softc *ms;
+ register int c;
+{
+ register struct firm_event *fe;
+ register int mb, ub, d, get, put, any;
+ static const char to_one[] = { 1, 2, 2, 4, 4, 4, 4 };
+ static const int to_id[] = { MS_RIGHT, MS_MIDDLE, 0, MS_LEFT };
+
+ /*
+ * Discard input if not ready. Drop sync on parity or framing
+ * error; gain sync on button byte.
+ */
+ if (ms->ms_ready == 0)
+ return;
+ if (c == -1) {
+ ms->ms_byteno = -1;
+ return;
+ }
+ if ((c & ~7) == 0x80) /* if in 0x80..0x87 */
+ ms->ms_byteno = 0;
+
+ /*
+ * Run the decode loop, adding to the current information.
+ * We add, rather than replace, deltas, so that if the event queue
+ * fills, we accumulate data for when it opens up again.
+ */
+ switch (ms->ms_byteno) {
+
+ case -1:
+ return;
+
+ case 0:
+ /* buttons */
+ ms->ms_byteno = 1;
+ ms->ms_mb = (~c) & 0x7;
+ return;
+
+ case 1:
+ /* first delta-x */
+ ms->ms_byteno = 2;
+ ms->ms_dx += (char)c;
+ return;
+
+ case 2:
+ /* first delta-y */
+ ms->ms_byteno = 3;
+ ms->ms_dy += (char)c;
+ return;
+
+ case 3:
+ /* second delta-x */
+ ms->ms_byteno = 4;
+ ms->ms_dx += (char)c;
+ return;
+
+ case 4:
+ /* second delta-x */
+ ms->ms_byteno = -1; /* wait for button-byte again */
+ ms->ms_dy += (char)c;
+ break;
+
+ default:
+ panic("ms_rint");
+ /* NOTREACHED */
+ }
+
+ /*
+ * We have at least one event (mouse button, delta-X, or
+ * delta-Y; possibly all three, and possibly three separate
+ * button events). Deliver these events until we are out
+ * of changes or out of room. As events get delivered,
+ * mark them `unchanged'.
+ */
+ any = 0;
+ get = ms->ms_events.ev_get;
+ put = ms->ms_events.ev_put;
+ fe = &ms->ms_events.ev_q[put];
+
+ /* NEXT prepares to put the next event, backing off if necessary */
+#define NEXT \
+ if ((++put) % EV_QSIZE == get) { \
+ put--; \
+ goto out; \
+ }
+ /* ADVANCE completes the `put' of the event */
+#define ADVANCE \
+ fe++; \
+ if (put >= EV_QSIZE) { \
+ put = 0; \
+ fe = &ms->ms_events.ev_q[0]; \
+ } \
+ any = 1
+
+ mb = ms->ms_mb;
+ ub = ms->ms_ub;
+ while ((d = mb ^ ub) != 0) {
+ /*
+ * Mouse button change. Convert up to three changes
+ * to the `first' change, and drop it into the event queue.
+ */
+ NEXT;
+ d = to_one[d - 1]; /* from 1..7 to {1,2,4} */
+ fe->id = to_id[d - 1]; /* from {1,2,4} to ID */
+ fe->value = mb & d ? VKEY_DOWN : VKEY_UP;
+ fe->time = time;
+ ADVANCE;
+ ub ^= d;
+ }
+ if (ms->ms_dx) {
+ NEXT;
+ fe->id = LOC_X_DELTA;
+ fe->value = ms->ms_dx;
+ fe->time = time;
+ ADVANCE;
+ ms->ms_dx = 0;
+ }
+ if (ms->ms_dy) {
+ NEXT;
+ fe->id = LOC_Y_DELTA;
+ fe->value = ms->ms_dy;
+ fe->time = time;
+ ADVANCE;
+ ms->ms_dy = 0;
+ }
+out:
+ if (any) {
+ ms->ms_ub = ub;
+ ms->ms_events.ev_put = put;
+ EV_WAKEUP(&ms->ms_events);
+ }
+}
+
+/****************************************************************
+ * Interface to the lower layer (zscc)
+ ****************************************************************/
+
+static void
+ms_rxint(cs)
+ register struct zs_chanstate *cs;
+{
+ register struct ms_softc *ms;
+ register int put, put_next;
+ register u_char c, rr1;
+
+ ms = cs->cs_private;
+ put = ms->ms_rbput;
+
+ /*
+ * First read the status, because reading the received char
+ * destroys the status of this char.
+ */
+ rr1 = zs_read_reg(cs, 1);
+ c = zs_read_data(cs);
+
+ if (rr1 & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) {
+ /* Clear the receive error. */
+ zs_write_csr(cs, ZSWR0_RESET_ERRORS);
+ }
+
+ ms->ms_rbuf[put] = (c << 8) | rr1;
+ put_next = (put + 1) & MS_RX_RING_MASK;
+
+ /* Would overrun if increment makes (put==get). */
+ if (put_next == ms->ms_rbget) {
+ ms->ms_intr_flags |= INTR_RX_OVERRUN;
+ } else {
+ /* OK, really increment. */
+ put = put_next;
+ }
+
+ /* Done reading. */
+ ms->ms_rbput = put;
+
+ /* Ask for softint() call. */
+ cs->cs_softreq = 1;
+}
+
+
+static void
+ms_txint(cs)
+ register struct zs_chanstate *cs;
+{
+ register struct ms_softc *ms;
+
+ ms = cs->cs_private;
+ zs_write_csr(cs, ZSWR0_RESET_TXINT);
+ ms->ms_intr_flags |= INTR_TX_EMPTY;
+ /* Ask for softint() call. */
+ cs->cs_softreq = 1;
+}
+
+
+static void
+ms_stint(cs)
+ register struct zs_chanstate *cs;
+{
+ register struct ms_softc *ms;
+ register int rr0;
+
+ ms = cs->cs_private;
+
+ rr0 = zs_read_csr(cs);
+ zs_write_csr(cs, ZSWR0_RESET_STATUS);
+
+ cs->cs_rr0_delta |= (cs->cs_rr0 ^ rr0);
+ cs->cs_rr0 = rr0;
+ ms->ms_intr_flags |= INTR_ST_CHECK;
+
+ /* Ask for softint() call. */
+ cs->cs_softreq = 1;
+}
+
+
+static void
+ms_softint(cs)
+ struct zs_chanstate *cs;
+{
+ register struct ms_softc *ms;
+ register int get, c, s;
+ int intr_flags;
+ register u_short ring_data;
+
+ ms = cs->cs_private;
+
+ /* Atomically get and clear flags. */
+ s = splzs();
+ intr_flags = ms->ms_intr_flags;
+ ms->ms_intr_flags = 0;
+
+ /* Now lower to spltty for the rest. */
+ (void) spltty();
+
+ /*
+ * Copy data from the receive ring to the event layer.
+ */
+ get = ms->ms_rbget;
+ while (get != ms->ms_rbput) {
+ ring_data = ms->ms_rbuf[get];
+ get = (get + 1) & MS_RX_RING_MASK;
+
+ /* low byte of ring_data is rr1 */
+ c = (ring_data >> 8) & 0xff;
+
+ if (ring_data & ZSRR1_DO)
+ intr_flags |= INTR_RX_OVERRUN;
+ if (ring_data & (ZSRR1_FE | ZSRR1_PE)) {
+ log(LOG_ERR, "%s: input error (0x%x)\n",
+ ms->ms_dev.dv_xname, ring_data);
+ c = -1; /* signal input error */
+ }
+
+ /* Pass this up to the "middle" layer. */
+ ms_input(ms, c);
+ }
+ if (intr_flags & INTR_RX_OVERRUN) {
+ log(LOG_ERR, "%s: input overrun\n",
+ ms->ms_dev.dv_xname);
+ }
+ ms->ms_rbget = get;
+
+ if (intr_flags & INTR_TX_EMPTY) {
+ /*
+ * Transmit done. (Not expected.)
+ */
+ log(LOG_ERR, "%s: transmit interrupt?\n",
+ ms->ms_dev.dv_xname);
+ }
+
+ if (intr_flags & INTR_ST_CHECK) {
+ /*
+ * Status line change. (Not expected.)
+ */
+ log(LOG_ERR, "%s: status interrupt?\n",
+ ms->ms_dev.dv_xname);
+ cs->cs_rr0_delta = 0;
+ }
+
+ splx(s);
+}
+
+struct zsops zsops_ms = {
+ ms_rxint, /* receive char available */
+ ms_stint, /* external/status */
+ ms_txint, /* xmit buffer empty */
+ ms_softint, /* process software interrupt */
+};
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-27 10:50:43 +0000