/* $NetBSD: ewskbd.c,v 1.14 2021/09/18 15:14:40 tsutsui Exp $ */ /*- * Copyright (c) 2005 Izumi Tsutsui. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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. */ /* * Copyright (c) 2004 Steve Rumble * 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. * * 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. */ /* * EWS4800 serial keyboard driver attached to zs channel 0 at 4800 bps. * This layer is the parent of wskbd. * * This driver is taken from sgimips. */ #include __KERNEL_RCSID(0, "$NetBSD: ewskbd.c,v 1.14 2021/09/18 15:14:40 tsutsui Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #define EWSKBD_BAUD 4800 #define EWSKBD_TXQ_LEN 16 /* power of 2 */ #define EWSKBD_TXQ_LEN_MASK (EWSKBD_TXQ_LEN - 1) #define EWSKBD_NEXTTXQ(x) (((x) + 1) & EWSKBD_TXQ_LEN_MASK) #define EWSKBD_RXQ_LEN 64 /* power of 2 */ #define EWSKBD_RXQ_LEN_MASK (EWSKBD_RXQ_LEN - 1) #define EWSKBD_NEXTRXQ(x) (((x) + 1) & EWSKBD_RXQ_LEN_MASK) #define EWSKBD_KEY_UP 0x80 #define EWSKBD_KEY_MASK 0x7f #ifdef EWSKBD_DEBUG int ewskbd_debug = 0; #define DPRINTF(_x) if (ewskbd_debug) printf _x #else #define DPRINTF(_x) #endif struct ewskbd_softc { device_t sc_dev; struct ewskbd_devconfig *sc_dc; }; struct ewskbd_devconfig { /* transmit tail-chasing fifo */ uint8_t txq[EWSKBD_TXQ_LEN]; u_int txq_head; u_int txq_tail; /* receive tail-chasing fifo */ uint8_t rxq[EWSKBD_RXQ_LEN]; u_int rxq_head; u_int rxq_tail; /* state */ u_int state; #define TX_READY 0x01 /* LED status */ uint8_t leds; #define EWSKBD_SETLEDS 0x90 #define EWSKBD_CAPSLOCK 0x02 #define EWSKBD_KANA 0x04 /* wscons glue */ device_t wskbddev; int enabled; }; static int ewskbd_zsc_match(device_t, cfdata_t, void *); static void ewskbd_zsc_attach(device_t, device_t, void *); static int ewskbd_zsc_init(struct zs_chanstate *); static void ewskbd_zsc_rxint(struct zs_chanstate *); static void ewskbd_zsc_stint(struct zs_chanstate *, int); static void ewskbd_zsc_txint(struct zs_chanstate *); static void ewskbd_zsc_softint(struct zs_chanstate *); static void ewskbd_zsc_send(struct zs_chanstate *, uint8_t *, u_int); static void ewskbd_wskbd_input(struct zs_chanstate *, u_char); static int ewskbd_wskbd_enable(void *, int); static void ewskbd_wskbd_set_leds(void *, int); static int ewskbd_wskbd_get_leds(void *); static int ewskbd_wskbd_ioctl(void *, u_long, void *, int, struct lwp *); void ewskbd_zsc_cnattach(uint32_t, uint32_t, int); static void ewskbd_zsc_wskbd_getc(void *, u_int *, int *); static void ewskbd_wskbd_pollc(void *, int); static void ewskbd_wskbd_bell(void *, u_int, u_int, u_int); CFATTACH_DECL_NEW(ewskbd_zsc, sizeof(struct ewskbd_softc), ewskbd_zsc_match, ewskbd_zsc_attach, NULL, NULL); static struct zsops ewskbd_zsops = { ewskbd_zsc_rxint, ewskbd_zsc_stint, ewskbd_zsc_txint, ewskbd_zsc_softint }; const struct wskbd_mapdata ews4800kbd_wskbd_keymapdata = { ews4800kbd_keydesctab, KB_JP }; const struct wskbd_accessops ewskbd_wskbd_accessops = { ewskbd_wskbd_enable, ewskbd_wskbd_set_leds, ewskbd_wskbd_ioctl }; const struct wskbd_consops ewskbd_wskbd_consops = { ewskbd_zsc_wskbd_getc, ewskbd_wskbd_pollc, ewskbd_wskbd_bell }; static struct ewskbd_devconfig ewskbd_console_dc; static struct zs_chanstate conschan; static int ewskbd_is_console; static int ewskbd_zsc_match(device_t parent, cfdata_t cf, void *aux) { struct zsc_attach_args *zsc_args = aux; struct zsc_softc *zsc = device_private(parent); /* keyboard is on channel B */ if ((zsc->zsc_flags & 0x0001 /* kbms port */) != 0 && zsc_args->channel == 1) /* prior to generic zstty(4) */ return 3; return 0; } static void ewskbd_zsc_attach(device_t parent, device_t self, void *aux) { struct ewskbd_softc *sc; struct zsc_softc *zsc; struct zs_chanstate *cs; struct zsc_attach_args *zsc_args; struct wskbddev_attach_args wskaa; int channel; sc = device_private(self); zsc = device_private(parent); sc->sc_dev = self; zsc_args = aux; /* Establish ourself with the MD z8530 driver */ channel = zsc_args->channel; cs = zsc->zsc_cs[channel]; if (ewskbd_is_console) { sc->sc_dc = &ewskbd_console_dc; wskaa.console = 1; sc->sc_dc->enabled = 1; } else { wskaa.console = 0; sc->sc_dc = kmem_zalloc(sizeof(struct ewskbd_devconfig), KM_SLEEP); if (sc->sc_dc == NULL) { printf(": can't allocate memory\n"); return; } sc->sc_dc->enabled = 0; } cs->cs_defspeed = EWSKBD_BAUD; cs->cs_ops = &ewskbd_zsops; cs->cs_private = sc; sc->sc_dc->txq_head = 0; sc->sc_dc->txq_tail = 0; sc->sc_dc->rxq_head = 0; sc->sc_dc->rxq_tail = 0; sc->sc_dc->state = TX_READY; sc->sc_dc->leds = 0; ewskbd_zsc_init(cs); /* set default LED */ ewskbd_wskbd_set_leds(cs, 0); printf(": baud rate %d\n", EWSKBD_BAUD); /* attach wskbd */ wskaa.keymap = &ews4800kbd_wskbd_keymapdata; wskaa.accessops = &ewskbd_wskbd_accessops; wskaa.accesscookie = cs; sc->sc_dc->wskbddev = config_found(self, &wskaa, wskbddevprint, CFARGS_NONE); } static int ewskbd_zsc_init(struct zs_chanstate *cs) { int s; s = splzs(); zs_write_reg(cs, 9, ZSWR9_B_RESET); DELAY(100); zs_write_reg(cs, 9, ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR); cs->cs_preg[1] = ZSWR1_RIE | ZSWR1_TIE; cs->cs_preg[2] = 0; cs->cs_preg[3] = ZSWR3_RX_8 | ZSWR3_RX_ENABLE; cs->cs_preg[4] = ZSWR4_CLK_X16 | ZSWR4_ONESB | ZSWR4_PARENB; cs->cs_preg[5] = ZSWR5_TX_8 | ZSWR5_RTS | ZSWR5_TX_ENABLE; cs->cs_preg[6] = 0; cs->cs_preg[7] = 0; cs->cs_preg[8] = 0; cs->cs_preg[9] = ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR; cs->cs_preg[10] = 0; cs->cs_preg[11] = ZSWR11_RXCLK_BAUD | ZSWR11_TXCLK_BAUD | ZSWR11_TRXC_OUT_ENA | ZSWR11_TRXC_BAUD; /* reg[11] and reg[12] are set by zs_set_speed() with cs_brg_clk */ zs_set_speed(cs, EWSKBD_BAUD); cs->cs_preg[14] = ZSWR14_BAUD_FROM_PCLK | ZSWR14_BAUD_ENA; cs->cs_preg[15] = 0; zs_loadchannelregs(cs); splx(s); return 0; } static void ewskbd_zsc_rxint(struct zs_chanstate *cs) { struct ewskbd_softc *sc; struct ewskbd_devconfig *dc; uint8_t c, r; sc = cs->cs_private; dc = sc->sc_dc; /* clear errors */ r = zs_read_reg(cs, 1); if (r & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) zs_write_csr(cs, ZSWR0_RESET_ERRORS); /* read byte and append to our queue */ c = zs_read_data(cs); dc->rxq[dc->rxq_tail] = c; dc->rxq_tail = EWSKBD_NEXTRXQ(dc->rxq_tail); cs->cs_softreq = 1; } static void ewskbd_zsc_stint(struct zs_chanstate *cs, int force) { zs_write_csr(cs, ZSWR0_RESET_STATUS); cs->cs_softreq = 1; } static void ewskbd_zsc_txint(struct zs_chanstate *cs) { struct ewskbd_softc *sc; sc = cs->cs_private; zs_write_reg(cs, 0, ZSWR0_RESET_TXINT); sc->sc_dc->state |= TX_READY; cs->cs_softreq = 1; } static void ewskbd_zsc_softint(struct zs_chanstate *cs) { struct ewskbd_softc *sc; struct ewskbd_devconfig *dc; sc = cs->cs_private; dc = sc->sc_dc; /* handle pending transmissions */ if (dc->txq_head != dc->txq_tail && (dc->state & TX_READY)) { int s; dc->state &= ~TX_READY; s = splzs(); zs_write_data(cs, dc->txq[dc->txq_head]); splx(s); dc->txq_head = EWSKBD_NEXTTXQ(dc->txq_head); } /* don't bother if nobody is listening */ if (!dc->enabled) { dc->rxq_head = dc->rxq_tail; return; } /* handle incoming keystrokes/config */ while (dc->rxq_head != dc->rxq_tail) { uint8_t key = dc->rxq[dc->rxq_head]; /* toss wskbd a bone */ ewskbd_wskbd_input(cs, key); dc->rxq_head = EWSKBD_NEXTRXQ(dc->rxq_head); } } /* expects to be in splzs() */ static void ewskbd_zsc_send(struct zs_chanstate *cs, uint8_t *c, u_int len) { struct ewskbd_softc *sc; struct ewskbd_devconfig *dc; int i; sc = cs->cs_private; dc = sc->sc_dc; for (i = 0; i < len; i++) { if (dc->state & TX_READY) { zs_write_data(cs, c[i]); dc->state &= ~TX_READY; } else { dc->txq[dc->txq_tail] = c[i]; dc->txq_tail = EWSKBD_NEXTTXQ(dc->txq_tail); cs->cs_softreq = 1; } } } /****************************************************************************** * wskbd glue ******************************************************************************/ static void ewskbd_wskbd_input(struct zs_chanstate *cs, uint8_t key) { struct ewskbd_softc *sc; u_int type; sc = cs->cs_private; if (key & EWSKBD_KEY_UP) type = WSCONS_EVENT_KEY_UP; else type = WSCONS_EVENT_KEY_DOWN; wskbd_input(sc->sc_dc->wskbddev, type, (key & EWSKBD_KEY_MASK)); DPRINTF(("ewskbd_wskbd_input: inputted key 0x%x\n", key)); #ifdef WSDISPLAY_COMPAT_RAWKBD wskbd_rawinput(sc->sc_dc->wskbddev, &key, 1); #endif } static int ewskbd_wskbd_enable(void *cookie, int on) { struct zs_chanstate *cs; struct ewskbd_softc *sc; cs = cookie; sc = cs->cs_private; if (on) { if (sc->sc_dc->enabled) return EBUSY; else sc->sc_dc->enabled = 1; } else sc->sc_dc->enabled = 0; DPRINTF(("ewskbd_wskbd_enable: %s\n", on ? "enabled" : "disabled")); return 0; } static void ewskbd_wskbd_set_leds(void *cookie, int leds) { struct zs_chanstate *cs; struct ewskbd_softc *sc; int s; uint8_t cmd; cs = cookie; sc = cs->cs_private; cmd = 0; if (leds & WSKBD_LED_CAPS) cmd |= EWSKBD_CAPSLOCK; sc->sc_dc->leds = cmd; cmd |= EWSKBD_SETLEDS; s = splzs(); ewskbd_zsc_send(cs, &cmd, 1); splx(s); } static int ewskbd_wskbd_get_leds(void *cookie) { struct zs_chanstate *cs; struct ewskbd_softc *sc; int leds; cs = cookie; sc = cs->cs_private; leds = 0; if (sc->sc_dc->leds & EWSKBD_CAPSLOCK) leds |= WSKBD_LED_CAPS; return leds; } static int ewskbd_wskbd_ioctl(void *cookie, u_long cmd, void *data, int flag, struct lwp *l) { switch (cmd) { case WSKBDIO_GTYPE: *(int *)data = WSKBD_TYPE_EWS4800; break; #ifdef notyet case WSKBDIO_COMPLEXBELL: case WSKBDIO_SETKEYREPEAT: case WSKBDIO_GETKEYREPEAT: case WSKBDIO_SETDEFAULTKEYREPEAT: case WSKBDIO_GETDEFAULTKEYREPEAT: #endif case WSKBDIO_SETLEDS: ewskbd_wskbd_set_leds(cookie, *(int *)data); break; case WSKBDIO_GETLEDS: *(int *)data = ewskbd_wskbd_get_leds(cookie); break; #ifdef notyet case WSKBDIO_GETMAP: case WSKBDIO_SETMAP: case WSKBDIO_GETENCODING: case WSKBDIO_SETENCODING: case WSKBDIO_SETMODE: case WSKBDIO_GETMODE: case WSKBDIO_SETKEYCLICK: case WSKBDIO_GETKEYCLICK: #endif default: return EPASSTHROUGH; } return 0; } /* * console routines */ void ewskbd_zsc_cnattach(uint32_t csr, uint32_t data, int pclk) { struct zs_chanstate *cs; cs = &conschan; cs->cs_reg_csr = (void *)csr; cs->cs_reg_data = (void *)data; cs->cs_brg_clk = pclk / 16; cs->cs_defspeed = EWSKBD_BAUD; ewskbd_zsc_init(cs); zs_putc(cs, EWSKBD_SETLEDS); wskbd_cnattach(&ewskbd_wskbd_consops, cs, &ews4800kbd_wskbd_keymapdata); ewskbd_is_console = 1; } static void ewskbd_zsc_wskbd_getc(void *cookie, u_int *type, int *data) { int key; key = zs_getc(cookie); if (key & EWSKBD_KEY_UP) *type = WSCONS_EVENT_KEY_UP; else *type = WSCONS_EVENT_KEY_DOWN; *data = key & EWSKBD_KEY_MASK; } static void ewskbd_wskbd_pollc(void *cookie, int on) { static bool __polling = false; static int s; if (on && !__polling) { /* disable interrupt driven I/O */ s = splhigh(); __polling = true; } else if (!on && __polling) { /* enable interrupt driven I/O */ __polling = false; splx(s); } } static void ewskbd_wskbd_bell(void *cookie, u_int pitch, u_int period, u_int volume) { /* nothing */ }