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
zskbd_match(device_t parent,cfdata_t cf,void * aux)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
zskbd_attach(device_t parent,device_t self,void * aux)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
zskbd_rxint(struct zs_chanstate * cs)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
zskbd_stint(struct zs_chanstate * cs,int force)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
zskbd_txint(struct zs_chanstate * cs)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
zskbd_softint(struct zs_chanstate * cs)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
zskbd_send(struct zs_chanstate * cs,uint8_t * c,u_int len)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
zskbd_ctrl(struct zs_chanstate * cs,uint8_t a_on,uint8_t a_off,uint8_t b_on,uint8_t b_off)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
zskbd_wskbd_input(struct zs_chanstate * cs,uint8_t key)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
zskbd_wskbd_enable(void * cookie,int on)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
zskbd_wskbd_set_leds(void * cookie,int leds)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
zskbd_wskbd_get_leds(void * cookie)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
zskbd_wskbd_set_keyclick(void * cookie,int on)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
zskbd_wskbd_get_keyclick(void * cookie)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
zskbd_wskbd_ioctl(void * cookie,u_long cmd,void * data,int flag,struct lwp * l)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
zskbd_cnattach(int zsunit,int zschan)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
zskbd_wskbd_getc(void * cookie,u_int * type,int * data)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
zskbd_wskbd_pollc(void * cookie,int on)606 zskbd_wskbd_pollc(void *cookie, int on)
607 {
608 }
609
610 static void
zskbd_wskbd_bell(void * cookie,u_int pitch,u_int period,u_int volume)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