1 /* $NetBSD: g42xxeb_kmkbd.c,v 1.18 2024/02/09 22:08:32 andvar Exp $ */
2
3 /*-
4 * Copyright (c) 2002, 2003, 2005 Genetec corp.
5 * All rights reserved.
6 *
7 * 4x5 matrix key switch driver for TWINTAIL.
8 * Written by Hiroyuki Bessho for Genetec corp.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of The NetBSD Foundation nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 /*
36 * Use on-board matrix switches as wskbd.
37 */
38
39 #include <sys/cdefs.h>
40 __KERNEL_RCSID(0, "$NetBSD: g42xxeb_kmkbd.c,v 1.18 2024/02/09 22:08:32 andvar Exp $" );
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/device.h>
45 #include <sys/ioctl.h>
46 #include <sys/callout.h>
47 #include <sys/kernel.h> /* for hz */
48
49 #include <sys/bus.h>
50
51 #include <dev/wscons/wsconsio.h>
52 #include <dev/wscons/wskbdvar.h>
53 #include <dev/wscons/wsksymdef.h>
54 #include <dev/wscons/wsksymvar.h>
55
56 #include <arch/evbarm/g42xxeb/g42xxeb_var.h>
57
58 #include "locators.h"
59 #include "opt_wsdisplay_compat.h"
60
61 #define DEBOUNCE_TICKS ((hz<=50)?1:hz/50) /* 20ms */
62 #define RELEASE_WATCH_TICKS (hz/10) /* 100ms */
63
64 #define NUMKEYS (4*5) /* the number of keys */
65
66 struct kmkbd_softc {
67 device_t dev;
68
69 device_t wskbddev;
70 void *ih; /* interrupt handler */
71 struct callout callout;
72
73 uint32_t notified_bits; /* reported state of keys */
74 uint32_t last_bits; /* used for debounce */
75 u_char debounce_counter;
76 #define DEBOUNCE_COUNT 3
77 u_char polling;
78 u_char rawkbd;
79 enum kmkbd_state {
80 ST_INIT,
81 ST_DISABLED,
82 ST_ALL_UP, /* waiting for interrupt */
83 ST_DEBOUNCE, /* doing debounce */
84 ST_KEY_PRESSED /* some keys are pressed */
85 } state;
86 };
87
88
89 int kmkbd_match(device_t, cfdata_t, void *);
90 void kmkbd_attach(device_t, device_t, void *);
91
92 CFATTACH_DECL_NEW(kmkbd, sizeof(struct kmkbd_softc),
93 kmkbd_match, kmkbd_attach, NULL, NULL);
94
95 static int kmkbd_enable(void *, int);
96 static void kmkbd_set_leds(void *, int);
97 static int kmkbd_ioctl(void *, u_long, void *, int, struct lwp *);
98
99 const struct wskbd_accessops kmkbd_accessops = {
100 kmkbd_enable,
101 kmkbd_set_leds,
102 kmkbd_ioctl,
103 };
104
105 #if 0
106 void kmkbd_cngetc(void *, u_int *, int *);
107 void kmkbd_cnpollc(void *, int);
108 void kmkbd_cnbell(void *, u_int, u_int, u_int);
109
110 const struct wskbd_consops kmkbd_consops = {
111 kmkbd_cngetc,
112 kmkbd_cnpollc,
113 kmkbd_cnbell,
114 };
115 #endif
116
117 static const keysym_t kmkbd_keydesc_0[] = {
118 /* pos normal shifted */
119 KS_KEYCODE(0), KS_a, KS_A,
120 KS_KEYCODE(1), KS_b, KS_B,
121 KS_KEYCODE(2), KS_c, KS_C,
122 KS_KEYCODE(3), KS_d, KS_D,
123 KS_KEYCODE(4), KS_e, KS_E,
124 KS_KEYCODE(5), KS_f, KS_F,
125 KS_KEYCODE(6), KS_g, KS_G,
126 KS_KEYCODE(7), KS_h, KS_H,
127 KS_KEYCODE(8), KS_i, KS_I,
128 KS_KEYCODE(9), KS_j, KS_J,
129 KS_KEYCODE(10), KS_k, KS_K,
130 KS_KEYCODE(11), KS_l, KS_L,
131 KS_KEYCODE(12), KS_m, KS_M,
132 KS_KEYCODE(13), KS_n, KS_N,
133 KS_KEYCODE(14), KS_o, KS_O,
134 KS_KEYCODE(15), KS_p, KS_P,
135 KS_KEYCODE(16), KS_q, KS_Q,
136 KS_KEYCODE(17), KS_r, KS_R,
137 KS_KEYCODE(18), '\003', '\003',
138 KS_KEYCODE(19), KS_Return, KS_Linefeed,
139 };
140
141 #define KBD_MAP(name, base, map) \
142 { name, base, sizeof(map)/sizeof(keysym_t), map }
143
144 static const struct wscons_keydesc kmkbd_keydesctab[] = {
145 KBD_MAP(KB_MACHDEP, 0, kmkbd_keydesc_0),
146 {0, 0, 0, 0}
147 };
148
149 const struct wskbd_mapdata kmkbd_keymapdata = {
150 kmkbd_keydesctab,
151 #ifdef KMKBD_LAYOUT
152 KMKBD_LAYOUT,
153 #else
154 KB_MACHDEP,
155 #endif
156 };
157
158 /*
159 * Hackish support for a bell on the PC Keyboard; when a suitable beeper
160 * is found, it attaches itself into the pckbd driver here.
161 */
162 void (*kmkbd_bell_fn)(void *, u_int, u_int, u_int, int);
163 void *kmkbd_bell_fn_arg;
164
165 void kmkbd_bell(u_int, u_int, u_int, int);
166 void kmkbd_hookup_bell(void (* fn)(void *, u_int, u_int, u_int, int), void *arg);
167
168 static int kmkbd_intr(void *);
169 static void kmkbd_new_state(struct kmkbd_softc *, enum kmkbd_state);
170
171 /*struct kmkbd_internal kmkbd_consdata;*/
172
173 static int
kmkbd_is_console(void)174 kmkbd_is_console(void)
175 {
176 #if 0
177 return (kmkbd_consdata.t_isconsole &&
178 (tag == kmkbd_consdata.t_kbctag) &&
179 (slot == kmkbd_consdata.t_kbcslot));
180 #else
181 return 0;
182 #endif
183 }
184
185 int
kmkbd_match(device_t parent,cfdata_t cf,void * aux)186 kmkbd_match(device_t parent, cfdata_t cf, void *aux)
187 {
188 return 1;
189 }
190
191 void
kmkbd_attach(device_t parent,device_t self,void * aux)192 kmkbd_attach(device_t parent, device_t self, void *aux)
193 {
194 struct kmkbd_softc *sc = device_private(self);
195 /*struct obio_attach_args *oa = aux;*/
196 int state0;
197 struct wskbddev_attach_args a;
198 struct obio_softc *osc = device_private(parent);
199 int s;
200
201 printf("\n");
202
203 sc->dev = self;
204 sc->state = ST_INIT;
205
206 if (kmkbd_is_console()){
207 a.console = 1;
208 state0 = ST_ALL_UP;
209 } else {
210 a.console = 0;
211 state0 = ST_DISABLED;
212 }
213
214 #ifdef WSDISPLAY_COMPAT_RAWKBD
215 sc->rawkbd = 0;
216 #endif
217 callout_init(&sc->callout, 0);
218
219 s = spltty();
220 sc->ih = obio_intr_establish(osc, G42XXEB_INT_KEY, IPL_TTY,
221 IST_EDGE_FALLING, kmkbd_intr, (void *)sc);
222 kmkbd_new_state(sc, state0);
223 splx(s);
224
225 a.keymap = &kmkbd_keymapdata;
226
227 a.accessops = &kmkbd_accessops;
228 a.accesscookie = sc;
229
230
231 /* Attach the wskbd. */
232 sc->wskbddev = config_found(self, &a, wskbddevprint, CFARGS_NONE);
233
234 }
235
236 static int
kmkbd_enable(void * v,int on)237 kmkbd_enable(void *v, int on)
238 {
239 struct kmkbd_softc *sc = v;
240
241 if (on) {
242 if (sc->state != ST_DISABLED) {
243 #ifdef DIAGNOSTIC
244 printf("kmkbd_enable: bad enable (state=%d)\n", sc->state);
245 #endif
246 return (EBUSY);
247 }
248
249 kmkbd_new_state(sc, ST_ALL_UP);
250 } else {
251 #if 0
252 if (sc->id->t_isconsole)
253 return (EBUSY);
254 #endif
255
256 kmkbd_new_state(sc, ST_DISABLED);
257 }
258
259 return (0);
260 }
261
262
263
264 static void
kmkbd_set_leds(void * v,int leds)265 kmkbd_set_leds(void *v, int leds)
266 {
267 }
268
269 static int
kmkbd_ioctl(void * v,u_long cmd,void * data,int flag,struct lwp * l)270 kmkbd_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
271 {
272 #ifdef WSDISPLAY_COMPAT_RAWKBD
273 struct kmkbd_softc *sc = v;
274 #endif
275
276 switch (cmd) {
277 case WSKBDIO_GTYPE:
278 *(int *)data = WSKBD_TYPE_PC_XT; /* XXX */
279 return 0;
280 case WSKBDIO_COMPLEXBELL:
281 #define d ((struct wskbd_bell_data *)data)
282 /*
283 * Keyboard can't beep directly; we have an
284 * externally-provided global hook to do this.
285 */
286 kmkbd_bell(d->pitch, d->period, d->volume, 0);
287 #undef d
288 return (0);
289 #ifdef WSDISPLAY_COMPAT_RAWKBD
290 case WSKBDIO_SETMODE:
291 sc->rawkbd = (*(int *)data == WSKBD_RAW);
292 return (0);
293 #endif
294
295 #if 0
296 case WSKBDIO_SETLEDS:
297 case WSKBDIO_GETLEDS:
298 /* no LED support */
299 #endif
300 }
301 return EPASSTHROUGH;
302 }
303
304 void
kmkbd_bell(u_int pitch,u_int period,u_int volume,int poll)305 kmkbd_bell(u_int pitch, u_int period, u_int volume, int poll)
306 {
307
308 if (kmkbd_bell_fn != NULL)
309 (*kmkbd_bell_fn)(kmkbd_bell_fn_arg, pitch, period,
310 volume, poll);
311 }
312
313 void
kmkbd_hookup_bell(void (* fn)(void *,u_int,u_int,u_int,int),void * arg)314 kmkbd_hookup_bell(void (* fn)(void *, u_int, u_int, u_int, int), void *arg)
315 {
316
317 if (kmkbd_bell_fn == NULL) {
318 kmkbd_bell_fn = fn;
319 kmkbd_bell_fn_arg = arg;
320 }
321 }
322
323 #if 0
324 int
325 kmkbd_cnattach(pckbc_tag_t kbctag, int kbcslot)
326 {
327 int res;
328
329 res = kmkbd_init(&kmkbd_consdata, kbctag, kbcslot, 1);
330
331 wskbd_cnattach(&kmkbd_consops, &kmkbd_consdata, &kmkbd_keymapdata);
332
333 return (0);
334 }
335
336 void
337 kmkbd_cngetc(void *v, u_int type, int *data)
338 {
339 struct kmkbd_internal *t = v;
340 int val;
341
342 for (;;) {
343 val = pckbc_poll_data(t->t_kbctag, t->t_kbcslot);
344 if ((val != -1) && kmkbd_decode(t, val, type, data))
345 return;
346 }
347 }
348
349 void
350 kmkbd_cnpollc(void *v, int on)
351 {
352 struct kmkbd_internal *t = v;
353
354 pckbc_set_poll(t->t_kbctag, t->t_kbcslot, on);
355 }
356
357 void
358 kmkbd_cnbell(void *v, u_int pitch, u_int period, u_int volume)
359 {
360
361 kmkbd_bell(pitch, period, volume, 1);
362 }
363 #endif
364
365
366 /*
367 * low level access to key matrix
368 *
369 * returns bitset of keys being pressed.
370 */
371 static u_int
kmkbd_read_matrix(struct kmkbd_softc * sc)372 kmkbd_read_matrix(struct kmkbd_softc *sc)
373 {
374 int i;
375 u_int ret, data;
376 struct obio_softc *osc = device_private(device_parent(sc->dev));
377 bus_space_tag_t iot = osc->sc_iot;
378 bus_space_handle_t ioh = osc->sc_obioreg_ioh;
379
380 #define KMDELAY() delay(3)
381
382 bus_space_write_2( iot, ioh, G42XXEB_KEYSCAN, 0 );
383 KMDELAY();
384
385 data = KEYSCAN_SENSE_IN &
386 bus_space_read_2(iot, ioh, G42XXEB_KEYSCAN);
387
388 bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, KEYSCAN_SCAN_OUT);
389
390 if (data == KEYSCAN_SENSE_IN)
391 return 0;
392
393 ret = 0;
394 for( i=0; i<5; ++i ){
395 /* scan one line */
396 bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, ~(0x0100<<i));
397 KMDELAY();
398 data = bus_space_read_2(iot, ioh, G42XXEB_KEYSCAN );
399
400 data = ~data & KEYSCAN_SENSE_IN;
401 ret |= data << (i*4);
402 }
403
404 bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, KEYSCAN_SCAN_OUT);
405 return ret;
406
407 #undef KMDELAY
408
409 }
410
411 /*
412 * report key status change to wskbd subsystem.
413 */
414 static void
kmkbd_report(struct kmkbd_softc * sc,u_int bitset)415 kmkbd_report(struct kmkbd_softc *sc, u_int bitset)
416 {
417 u_int changed;
418 int i;
419
420 if (bitset == sc->notified_bits)
421 return;
422
423 if (sc->notified_bits && bitset == 0){
424 wskbd_input(sc->wskbddev, WSCONS_EVENT_ALL_KEYS_UP, 0);
425 sc->notified_bits = 0;
426 return;
427 }
428
429 changed = bitset ^ sc->notified_bits;
430 for( i=0; changed; ++i){
431 if ((changed & (1<<i)) == 0)
432 continue;
433 changed &= ~(1<<i);
434
435 wskbd_input(sc->wskbddev,
436 (bitset & (1<<i)) ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP,
437 i);
438 }
439
440 sc->notified_bits = bitset;
441 }
442
443 #ifdef WSDISPLAY_COMPAT_RAWKBD
444 static void
kmkbd_report_raw(struct kmkbd_softc * sc,u_int bitset)445 kmkbd_report_raw(struct kmkbd_softc *sc, u_int bitset)
446 {
447 int i, nc;
448 char cbuf[NUMKEYS];
449 u_int changed;
450
451 if (bitset == sc->notified_bits)
452 return;
453
454 nc = 0;
455 changed = bitset ^ sc->notified_bits;
456
457 while (changed) {
458 i = ffs(changed) - 1;
459 if (nc < NUMKEYS) {
460 cbuf[nc] = i + 1;
461 if (0 == (bitset & (1<<i))) {
462 /* the key is released */
463 cbuf[nc] |= 0x80;
464 }
465 ++nc;
466 }
467
468 changed &= ~(1<<i);
469 }
470
471 wskbd_rawinput(sc->wskbddev, cbuf, nc);
472 sc->notified_bits = bitset;
473 }
474 #endif
475
476 static int
kmkbd_intr(void * arg)477 kmkbd_intr(void *arg)
478 {
479 struct kmkbd_softc *sc = arg;
480 struct obio_softc *osc = device_private(device_parent(sc->dev));
481
482 if ( sc->state != ST_ALL_UP ){
483 printf("Spurious interrupt from key matrix\n");
484 obio_intr_mask(osc, sc->ih);
485 return 1;
486 }
487
488 kmkbd_new_state(sc, ST_DEBOUNCE);
489
490 return 1;
491 }
492
493 static void
kmkbd_debounce(void * arg)494 kmkbd_debounce(void *arg)
495 {
496 struct kmkbd_softc *sc = arg;
497 u_int newbits;
498 enum kmkbd_state new_state = ST_DEBOUNCE;
499 int s = spltty();
500
501 newbits = kmkbd_read_matrix(sc);
502
503 if (newbits != sc->last_bits){
504 sc->last_bits = newbits;
505 sc->debounce_counter = 0;
506 }
507 else if( ++(sc->debounce_counter) >= DEBOUNCE_COUNT ){
508 new_state = newbits == 0 ? ST_ALL_UP : ST_KEY_PRESSED;
509 #ifdef WSDISPLAY_COMPAT_RAWKBD
510 if (sc->rawkbd)
511 kmkbd_report_raw(sc, newbits);
512 else
513 #endif
514 kmkbd_report(sc, newbits);
515 }
516
517 kmkbd_new_state(sc, new_state);
518 splx(s);
519 }
520
521 /* callout routine to watch key release */
522 static void
kmkbd_watch(void * arg)523 kmkbd_watch(void *arg)
524 {
525 int s = spltty();
526 struct kmkbd_softc *sc = arg;
527 u_int newbits;
528 int new_state = ST_KEY_PRESSED;
529
530 newbits = kmkbd_read_matrix(sc);
531
532 if (newbits != sc->last_bits){
533 /* some keys are released or new keys are pressed.
534 start debounce */
535 new_state = ST_DEBOUNCE;
536 sc->last_bits = newbits;
537 }
538
539 kmkbd_new_state(sc, new_state);
540 splx(s);
541 }
542
543 static void
kmkbd_new_state(struct kmkbd_softc * sc,enum kmkbd_state new_state)544 kmkbd_new_state(struct kmkbd_softc *sc, enum kmkbd_state new_state)
545 {
546 struct obio_softc *osc = device_private(device_parent(sc->dev));
547
548 switch(new_state){
549 case ST_DISABLED:
550 if (sc->state != ST_DISABLED){
551 callout_stop(&sc->callout);
552 obio_intr_mask(osc,sc->ih);
553 }
554 break;
555 case ST_DEBOUNCE:
556 if (sc->state == ST_ALL_UP){
557 obio_intr_mask(osc, sc->ih);
558 sc->last_bits = kmkbd_read_matrix(sc);
559 }
560 if (sc->state != ST_DEBOUNCE)
561 sc->debounce_counter = 0;
562
563 /* start debounce timer */
564 callout_reset(&sc->callout, DEBOUNCE_TICKS, kmkbd_debounce, sc);
565 break;
566 case ST_KEY_PRESSED:
567 /* start timer to check key release */
568 callout_reset(&sc->callout, RELEASE_WATCH_TICKS, kmkbd_watch, sc);
569 break;
570 case ST_ALL_UP:
571 if (sc->state != ST_ALL_UP){
572 bus_space_tag_t iot = osc->sc_iot;
573 bus_space_handle_t ioh = osc->sc_obioreg_ioh;
574
575 obio_intr_unmask(osc, sc->ih);
576 bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, 0);
577 }
578 break;
579 case ST_INIT:
580 ; /* Nothing to do */
581 }
582
583 sc->state = new_state;
584 }
585