Home | History | Annotate | Line # | Download | only in dev
      1 /*	$NetBSD: zs_kbd.c,v 1.14 2021/09/18 15:14:41 tsutsui Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2004 Steve Rumble
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. The name of the author may not be used to endorse or promote products
     16  *    derived from this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28  */
     29 
     30 /*
     31  * IP12/IP20 serial keyboard driver attached to zs channel 0 at 600bps.
     32  * This layer is the parent of wskbd.
     33  */
     34 
     35 #include <sys/cdefs.h>
     36 __KERNEL_RCSID(0, "$NetBSD: zs_kbd.c,v 1.14 2021/09/18 15:14:41 tsutsui Exp $");
     37 
     38 #include <sys/param.h>
     39 #include <sys/kmem.h>
     40 #include <sys/systm.h>
     41 #include <sys/conf.h>
     42 #include <sys/device.h>
     43 
     44 #include <dev/wscons/wsconsio.h>
     45 #include <dev/wscons/wskbdvar.h>
     46 #include <dev/wscons/wsksymdef.h>
     47 #include <dev/wscons/wsksymvar.h>
     48 
     49 #include <dev/ic/z8530reg.h>
     50 #include <machine/machtype.h>
     51 #include <machine/z8530var.h>
     52 
     53 #define ZSKBD_BAUD	600
     54 #define ZSKBD_TXQ_LEN	16		/* power of 2 */
     55 #define ZSKBD_RXQ_LEN	64		/* power of 2 */
     56 
     57 #define ZSKBD_DIP_SYNC	0x6E
     58 #define ZSKBD_KEY_UP	0x80
     59 
     60 #ifdef ZSKBD_DEBUG
     61 int zskbd_debug = 0;
     62 
     63 #define DPRINTF(_x) if (zskbd_debug) printf _x
     64 #else
     65 #define DPRINTF(_x)
     66 #endif
     67 
     68 struct zskbd_softc {
     69 	device_t   	sc_dev;
     70 
     71 	struct zskbd_devconfig *sc_dc;
     72 };
     73 
     74 struct zskbd_devconfig {
     75 	/* transmit tail-chasing fifo */
     76 	uint8_t		txq[ZSKBD_TXQ_LEN];
     77 	u_int		txq_head;
     78 	u_int		txq_tail;
     79 
     80 	/* receive tail-chasing fifo */
     81 	uint8_t		rxq[ZSKBD_RXQ_LEN];
     82 	u_int		rxq_head;
     83 	u_int		rxq_tail;
     84 
     85 	/* state */
     86 #define TX_READY	0x1
     87 #define RX_DIP		0x2
     88 	u_int		state;
     89 
     90 	/* keyboard configuration */
     91 #define ZSKBD_CTRL_A		0x0
     92 #define ZSKBD_CTRL_A_SBEEP	0x2	/* 200 ms */
     93 #define ZSKBD_CTRL_A_LBEEP	0x4	/* 1000 ms */
     94 #define ZSKBD_CTRL_A_NOCLICK	0x8	/* turn off keyboard click */
     95 #define ZSKBD_CTRL_A_RCB	0x10	/* request config byte */
     96 #define ZSKBD_CTRL_A_NUMLK	0x20	/* num lock led */
     97 #define ZSKBD_CTRL_A_CAPSLK	0x40	/* caps lock led */
     98 #define ZSKBD_CTRL_A_AUTOREP	0x80	/* auto-repeat after 650 ms, 28x/sec */
     99 
    100 #define ZSKBD_CTRL_B		0x1
    101 #define ZSKBD_CTRL_B_CMPL_DS1_2	0x2	/* complement of ds1+ds2 (num+capslk) */
    102 #define ZSKBD_CTRL_B_SCRLK	0x4	/* scroll lock light */
    103 #define ZSKBD_CTRL_B_L1		0x8	/* user-configurable lights */
    104 #define ZSKBD_CTRL_B_L2		0x10
    105 #define ZSKBD_CTRL_B_L3		0x20
    106 #define ZSKBD_CTRL_B_L4		0x40
    107 	uint8_t		kbd_conf[2];
    108 
    109 	/* dip switch settings */
    110 	uint8_t		dip;
    111 
    112 	/* wscons glue */
    113 	device_t	wskbddev;
    114 	int		enabled;
    115 };
    116 
    117 static int	zskbd_match(device_t, cfdata_t, void *);
    118 static void	zskbd_attach(device_t, device_t, void *);
    119 static void	zskbd_rxint(struct zs_chanstate *);
    120 static void	zskbd_stint(struct zs_chanstate *, int);
    121 static void	zskbd_txint(struct zs_chanstate *);
    122 static void	zskbd_softint(struct zs_chanstate *);
    123 static void	zskbd_send(struct zs_chanstate *, uint8_t *, u_int);
    124 static void	zskbd_ctrl(struct zs_chanstate *, uint8_t, uint8_t,
    125 						  uint8_t, uint8_t);
    126 
    127 static void	zskbd_wskbd_input(struct zs_chanstate *, uint8_t);
    128 static int	zskbd_wskbd_enable(void *, int);
    129 static void	zskbd_wskbd_set_leds(void *, int);
    130 static int	zskbd_wskbd_get_leds(void *);
    131 static void	zskbd_wskbd_set_keyclick(void *, int);
    132 static int	zskbd_wskbd_get_keyclick(void *);
    133 static int	zskbd_wskbd_ioctl(void *, u_long, void *, int, struct lwp *);
    134 
    135 void		zskbd_cnattach(int, int);
    136 static void	zskbd_wskbd_getc(void *, u_int *, int *);
    137 static void	zskbd_wskbd_pollc(void *, int);
    138 static void	zskbd_wskbd_bell(void *, u_int, u_int, u_int);
    139 
    140 extern struct zschan   *zs_get_chan_addr(int, int);
    141 extern int		zs_getc(void *);
    142 extern void		zs_putc(void *, int);
    143 
    144 CFATTACH_DECL_NEW(zskbd, sizeof(struct zskbd_softc),
    145     zskbd_match, zskbd_attach, NULL, NULL);
    146 
    147 static struct zsops zskbd_zsops = {
    148 	zskbd_rxint,
    149 	zskbd_stint,
    150 	zskbd_txint,
    151 	zskbd_softint
    152 };
    153 
    154 extern const struct wscons_keydesc wssgi_keydesctab[];
    155 const struct wskbd_mapdata sgikbd_wskbd_keymapdata = {
    156 	wssgi_keydesctab, KB_US
    157 };
    158 
    159 const struct wskbd_accessops zskbd_wskbd_accessops = {
    160 	zskbd_wskbd_enable,
    161 	zskbd_wskbd_set_leds,
    162 	zskbd_wskbd_ioctl
    163 };
    164 
    165 const struct wskbd_consops zskbd_wskbd_consops = {
    166 	zskbd_wskbd_getc,
    167 	zskbd_wskbd_pollc,
    168 	zskbd_wskbd_bell
    169 };
    170 
    171 static struct zskbd_devconfig	zskbd_console_dc;
    172 static int			zskbd_is_console = 0;
    173 
    174 static int
    175 zskbd_match(device_t parent, cfdata_t cf, void *aux)
    176 {
    177 
    178 	if (mach_type == MACH_SGI_IP12 || mach_type == MACH_SGI_IP20) {
    179 		struct zsc_attach_args *args = aux;
    180 
    181 		if (args->channel == 0)
    182 			return (1);
    183 	}
    184 
    185 	return (0);
    186 }
    187 
    188 static void
    189 zskbd_attach(device_t parent, device_t self, void *aux)
    190 {
    191 	struct zskbd_softc	       *sc;
    192 	struct zs_chanstate	       *cs;
    193 	struct zsc_softc      	       *zsc;
    194 	struct zsc_attach_args	       *args;
    195 	struct wskbddev_attach_args	wskaa;
    196 	int				s, channel;
    197 
    198 	zsc = device_private(parent);
    199 	sc = device_private(self);
    200 	sc->sc_dev = self;
    201 	args = aux;
    202 
    203 	/* Establish ourself with the MD z8530 driver */
    204 	channel = args->channel;
    205 	cs = zsc->zsc_cs[channel];
    206 	cs->cs_ops = &zskbd_zsops;
    207 	cs->cs_private = sc;
    208 
    209 	if (zskbd_is_console) {
    210 		sc->sc_dc = &zskbd_console_dc;
    211 		wskaa.console = 1;
    212 		sc->sc_dc->enabled = 1;
    213 	} else {
    214 		wskaa.console = 0;
    215 
    216 		sc->sc_dc = kmem_alloc(sizeof(struct zskbd_devconfig),
    217 		    KM_SLEEP);
    218 
    219 		sc->sc_dc->enabled = 0;
    220 	}
    221 
    222 	sc->sc_dc->txq_head = 0;
    223 	sc->sc_dc->txq_tail = 0;
    224 	sc->sc_dc->rxq_head = 0;
    225 	sc->sc_dc->rxq_tail = 0;
    226 	sc->sc_dc->state = TX_READY;
    227 	sc->sc_dc->dip = 0;
    228 	sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] = 0;
    229 	sc->sc_dc->kbd_conf[ZSKBD_CTRL_B] = 0;
    230 
    231 	aprint_normal(": baud rate %d\n", ZSKBD_BAUD);
    232 
    233 	s = splzs();
    234 	zs_write_reg(cs, 9, (channel == 0) ? ZSWR9_A_RESET : ZSWR9_B_RESET);
    235 	cs->cs_preg[1] = ZSWR1_RIE | ZSWR1_TIE;
    236 	cs->cs_preg[4] = (cs->cs_preg[4] & ZSWR4_CLK_MASK) |
    237 			 (ZSWR4_ONESB | ZSWR4_PARENB);	/* 1 stop, odd parity */
    238 	zs_set_speed(cs, ZSKBD_BAUD);
    239 	zs_loadchannelregs(cs);
    240 
    241 	/* request DIP switch settings just in case */
    242 	zskbd_ctrl(cs, ZSKBD_CTRL_A_RCB, 0, 0, 0);
    243 
    244 	splx(s);
    245 
    246 	/* attach wskbd */
    247 	wskaa.keymap =		&sgikbd_wskbd_keymapdata;
    248 	wskaa.accessops =	&zskbd_wskbd_accessops;
    249 	wskaa.accesscookie =	cs;
    250 	sc->sc_dc->wskbddev =	config_found(self, &wskaa, wskbddevprint,
    251 					     CFARGS_NONE);
    252 }
    253 
    254 static void
    255 zskbd_rxint(struct zs_chanstate *cs)
    256 {
    257 	struct zskbd_softc     *sc;
    258 	struct zskbd_devconfig *dc;
    259 	uint8_t			c, r;
    260 
    261 	sc = cs->cs_private;
    262 	dc = sc->sc_dc;
    263 
    264 	/* clear errors */
    265 	r = zs_read_reg(cs, 1);
    266 	if (r & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE))
    267 		zs_write_csr(cs, ZSWR0_RESET_ERRORS);
    268 
    269 	/* read byte and append to our queue */
    270 	c = zs_read_data(cs);
    271 
    272 	dc->rxq[dc->rxq_tail] = c;
    273 	dc->rxq_tail = (dc->rxq_tail + 1) & ~ZSKBD_RXQ_LEN;
    274 
    275 	cs->cs_softreq = 1;
    276 }
    277 
    278 static void
    279 zskbd_stint(struct zs_chanstate *cs, int force)
    280 {
    281 
    282 	zs_write_csr(cs, ZSWR0_RESET_STATUS);
    283 	cs->cs_softreq = 1;
    284 }
    285 
    286 static void
    287 zskbd_txint(struct zs_chanstate *cs)
    288 {
    289 	struct zskbd_softc *sc;
    290 
    291 	sc = cs->cs_private;
    292 	zs_write_reg(cs, 0, ZSWR0_RESET_TXINT);
    293 	sc->sc_dc->state |= TX_READY;
    294 	cs->cs_softreq = 1;
    295 }
    296 
    297 static void
    298 zskbd_softint(struct zs_chanstate *cs)
    299 {
    300 	struct zskbd_softc	*sc;
    301 	struct zskbd_devconfig	*dc;
    302 
    303 	sc = cs->cs_private;
    304 	dc = sc->sc_dc;
    305 
    306 	/* handle pending transmissions */
    307 	if (dc->txq_head != dc->txq_tail && (dc->state & TX_READY)) {
    308 		int s;
    309 
    310 		dc->state &= ~TX_READY;
    311 
    312 		s = splzs();
    313 		zs_write_data(cs, dc->txq[dc->txq_head]);
    314 		splx(s);
    315 
    316 		dc->txq_head = (dc->txq_head + 1) & ~ZSKBD_TXQ_LEN;
    317 	}
    318 
    319 	/* don't bother if nobody is listening */
    320 	if (!dc->enabled) {
    321 		dc->rxq_head = dc->rxq_tail;
    322 		return;
    323 	}
    324 
    325 	/* handle incoming keystrokes/config */
    326 	while (dc->rxq_head != dc->rxq_tail) {
    327 		uint8_t key = dc->rxq[dc->rxq_head];
    328 
    329 		if (dc->state & RX_DIP) {
    330 			dc->dip = key;
    331 			dc->state &= ~RX_DIP;
    332 		} else if (key == ZSKBD_DIP_SYNC) {
    333 			dc->state |= RX_DIP;
    334 		} else {
    335 			/* toss wskbd a bone */
    336 			zskbd_wskbd_input(cs, key);
    337 		}
    338 
    339 		dc->rxq_head = (dc->rxq_head + 1) & ~ZSKBD_RXQ_LEN;
    340 	}
    341 }
    342 
    343 /* expects to be in splzs() */
    344 static void
    345 zskbd_send(struct zs_chanstate *cs, uint8_t *c, u_int len)
    346 {
    347 	u_int			i;
    348 	struct zskbd_softc     *sc;
    349 	struct zskbd_devconfig *dc;
    350 
    351 	sc = cs->cs_private;
    352 	dc = sc->sc_dc;
    353 
    354 	for (i = 0; i < len; i++) {
    355 		if (dc->state & TX_READY) {
    356 			zs_write_data(cs, c[i]);
    357 			dc->state &= ~TX_READY;
    358 		} else {
    359 			dc->txq[dc->txq_tail] = c[i];
    360 			dc->txq_tail = (dc->txq_tail + 1) & ~ZSKBD_TXQ_LEN;
    361 			cs->cs_softreq = 1;
    362 		}
    363 	}
    364 }
    365 
    366 /* expects to be in splzs() */
    367 static void
    368 zskbd_ctrl(struct zs_chanstate *cs, uint8_t a_on, uint8_t a_off,
    369 	   uint8_t b_on, uint8_t b_off)
    370 {
    371 	struct zskbd_softc	*sc;
    372 	struct zskbd_devconfig	*dc;
    373 
    374 	sc = cs->cs_private;
    375 	dc = sc->sc_dc;
    376 
    377 	dc->kbd_conf[ZSKBD_CTRL_A] |=   a_on;
    378 	dc->kbd_conf[ZSKBD_CTRL_A] &= ~(a_off | ZSKBD_CTRL_B);
    379 	dc->kbd_conf[ZSKBD_CTRL_B] &=  ~b_off;
    380 	dc->kbd_conf[ZSKBD_CTRL_B] |=  (b_on | ZSKBD_CTRL_B);
    381 
    382 	zskbd_send(cs, dc->kbd_conf, 2);
    383 
    384 	/* make sure we don't resend these each time */
    385 	dc->kbd_conf[ZSKBD_CTRL_A] &= ~(ZSKBD_CTRL_A_RCB | ZSKBD_CTRL_A_SBEEP |
    386 	    ZSKBD_CTRL_A_LBEEP);
    387 }
    388 
    389 /******************************************************************************
    390  * wskbd glue
    391  ******************************************************************************/
    392 
    393 static void
    394 zskbd_wskbd_input(struct zs_chanstate *cs, uint8_t key)
    395 {
    396 	struct zskbd_softc     *sc;
    397 	u_int			type;
    398 
    399 	sc = cs->cs_private;
    400 
    401 	if (key & ZSKBD_KEY_UP)
    402 		type = WSCONS_EVENT_KEY_UP;
    403 	else
    404 		type = WSCONS_EVENT_KEY_DOWN;
    405 
    406 	wskbd_input(sc->sc_dc->wskbddev, type, (key & ~ZSKBD_KEY_UP));
    407 
    408 	DPRINTF(("zskbd_wskbd_input: inputted key 0x%x\n", key));
    409 
    410 #ifdef WSDISPLAY_COMPAT_RAWKBD
    411 	wskbd_rawinput(sc->sc_dc->wskbddev, &key, 1);
    412 #endif
    413 }
    414 
    415 static int
    416 zskbd_wskbd_enable(void *cookie, int on)
    417 {
    418 	struct zskbd_softc *sc;
    419 	struct zs_chanstate *cs;
    420 
    421 	cs = cookie;
    422 	sc = cs->cs_private;
    423 
    424 	if (on) {
    425 		if (sc->sc_dc->enabled)
    426 			return (EBUSY);
    427 		else
    428 			sc->sc_dc->enabled = 1;
    429 	} else
    430 		sc->sc_dc->enabled = 0;
    431 
    432 	DPRINTF(("zskbd_wskbd_enable: %s\n", on ? "enabled" : "disabled"));
    433 
    434 	return (0);
    435 }
    436 
    437 static void
    438 zskbd_wskbd_set_leds(void *cookie, int leds)
    439 {
    440 	struct zs_chanstate *cs;
    441 	int 	s;
    442 	uint8_t	a_on, a_off, b_on, b_off;
    443 
    444 	a_on = a_off = b_on = b_off = 0;
    445 
    446 	if (leds & WSKBD_LED_CAPS)
    447 		a_on |=  ZSKBD_CTRL_A_CAPSLK;
    448 	else
    449 		a_off |= ZSKBD_CTRL_A_CAPSLK;
    450 
    451 	if (leds & WSKBD_LED_NUM)
    452 		a_on |=  ZSKBD_CTRL_A_NUMLK;
    453 	else
    454 		a_off |= ZSKBD_CTRL_A_NUMLK;
    455 
    456 	if (leds & WSKBD_LED_SCROLL)
    457 		b_on |=  ZSKBD_CTRL_B_SCRLK;
    458 	else
    459 		b_off |= ZSKBD_CTRL_B_SCRLK;
    460 
    461 	cs = cookie;
    462 	s = splzs();
    463 	zskbd_ctrl(cs, a_on, a_off, b_on, b_off);
    464 	splx(s);
    465 }
    466 
    467 static int
    468 zskbd_wskbd_get_leds(void *cookie)
    469 {
    470 	struct zskbd_softc     *sc;
    471 	struct zs_chanstate    *cs;
    472 	int		 	leds;
    473 
    474 	cs = cookie;
    475 	sc = cs->cs_private;
    476 	leds = 0;
    477 
    478 	if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_NUMLK)
    479 		leds |= WSKBD_LED_NUM;
    480 
    481 	if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_CAPSLK)
    482 		leds |= WSKBD_LED_CAPS;
    483 
    484 	if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_B] & ZSKBD_CTRL_B_SCRLK)
    485 		leds |= WSKBD_LED_SCROLL;
    486 
    487 	return (leds);
    488 }
    489 
    490 static void
    491 zskbd_wskbd_set_keyclick(void *cookie, int on)
    492 {
    493 	int			s;
    494 	struct zs_chanstate    *cs;
    495 
    496 	cs = cookie;
    497 
    498 	if (on) {
    499 		if (!zskbd_wskbd_get_keyclick(cookie)) {
    500 			s = splzs();
    501 			zskbd_ctrl(cs, 0, ZSKBD_CTRL_A_NOCLICK, 0, 0);
    502 			splx(s);
    503 		}
    504 	} else {
    505 		if (zskbd_wskbd_get_keyclick(cookie)) {
    506 			s = splzs();
    507 			zskbd_ctrl(cs, ZSKBD_CTRL_A_NOCLICK, 0, 0, 0);
    508 			splx(s);
    509 		}
    510 	}
    511 }
    512 
    513 static int
    514 zskbd_wskbd_get_keyclick(void *cookie)
    515 {
    516 	struct zskbd_softc *sc;
    517 	struct zs_chanstate *cs;
    518 
    519 	cs = cookie;
    520 	sc = cs->cs_private;
    521 
    522 	if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_NOCLICK)
    523 		return (0);
    524 	else
    525 		return (1);
    526 }
    527 
    528 static int
    529 zskbd_wskbd_ioctl(void *cookie, u_long cmd,
    530 		  void *data, int flag, struct lwp *l)
    531 {
    532 
    533 	switch (cmd) {
    534 	case WSKBDIO_GTYPE:
    535 		*(int *)data = WSKBD_TYPE_SGI;
    536 		break;
    537 
    538 #ifdef notyet
    539 	case WSKBDIO_COMPLEXBELL:
    540 	case WSKBDIO_SETKEYREPEAT:
    541 	case WSKBDIO_GETKEYREPEAT:
    542 	case WSKBDIO_SETDEFAULTKEYREPEAT:
    543 	case WSKBDIO_GETDEFAULTKEYREPEAT:
    544 #endif
    545 
    546 	case WSKBDIO_SETLEDS:
    547 		zskbd_wskbd_set_leds(cookie, *(int *)data);
    548 		break;
    549 
    550 	case WSKBDIO_GETLEDS:
    551 		*(int *)data = zskbd_wskbd_get_leds(cookie);
    552 		break;
    553 
    554 #ifdef notyet
    555 	case WSKBDIO_GETMAP:
    556 	case WSKBDIO_SETMAP:
    557 	case WSKBDIO_GETENCODING:
    558 	case WSKBDIO_SETENCODING:
    559 	case WSKBDIO_SETMODE:
    560 	case WSKBDIO_GETMODE:
    561 #endif
    562 
    563 	case WSKBDIO_SETKEYCLICK:
    564 		zskbd_wskbd_set_keyclick(cookie, *(int *)data);
    565 		break;
    566 
    567 	case WSKBDIO_GETKEYCLICK:
    568 		*(int *)data = zskbd_wskbd_get_keyclick(cookie);
    569 		break;
    570 
    571 	default:
    572 		return (EPASSTHROUGH);
    573 	}
    574 
    575 	return (0);
    576 }
    577 
    578 /*
    579  * console routines
    580  */
    581 void
    582 zskbd_cnattach(int zsunit, int zschan)
    583 {
    584 
    585 	wskbd_cnattach(&zskbd_wskbd_consops, zs_get_chan_addr(zsunit, zschan),
    586 	    &sgikbd_wskbd_keymapdata);
    587 	zskbd_is_console = 1;
    588 }
    589 
    590 static void
    591 zskbd_wskbd_getc(void *cookie, u_int *type, int *data)
    592 {
    593 	int key;
    594 
    595 	key = zs_getc(cookie);
    596 
    597 	if (key & ZSKBD_KEY_UP)
    598 		*type = WSCONS_EVENT_KEY_UP;
    599 	else
    600 		*type = WSCONS_EVENT_KEY_DOWN;
    601 
    602 	*data = key & ~ZSKBD_KEY_UP;
    603 }
    604 
    605 static void
    606 zskbd_wskbd_pollc(void *cookie, int on)
    607 {
    608 }
    609 
    610 static void
    611 zskbd_wskbd_bell(void *cookie, u_int pitch, u_int period, u_int volume)
    612 {
    613 
    614 	/*
    615 	 * Since we don't have any state, this'll nuke our lights,
    616 	 * key click, and other bits in ZSKBD_CTRL_A.
    617 	 */
    618 	if (period >= 1000)
    619 		zs_putc(cookie, ZSKBD_CTRL_A_LBEEP);
    620 	else
    621 		zs_putc(cookie, ZSKBD_CTRL_A_SBEEP);
    622 }
    623