1 /*-
2 * Copyright (c) 2014 Ruslan Bukin <br@bsdpad.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 /*
28 * Samsung Chromebook Keyboard
29 */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/bus.h>
37 #include <sys/kernel.h>
38 #include <sys/module.h>
39 #include <sys/malloc.h>
40 #include <sys/rman.h>
41 #include <sys/proc.h>
42 #include <sys/sched.h>
43 #include <sys/kdb.h>
44 #include <sys/timeet.h>
45 #include <sys/timetc.h>
46 #include <sys/mutex.h>
47 #include <sys/gpio.h>
48
49 #include <dev/ofw/openfirm.h>
50 #include <dev/ofw/ofw_bus.h>
51 #include <dev/ofw/ofw_bus_subr.h>
52
53 #include <sys/ioccom.h>
54 #include <sys/filio.h>
55 #include <sys/tty.h>
56 #include <sys/kbio.h>
57
58 #include <machine/bus.h>
59 #include <machine/cpu.h>
60 #include <machine/intr.h>
61
62 #include "gpio_if.h"
63
64 #include <arm/samsung/exynos/chrome_ec.h>
65 #include <arm/samsung/exynos/chrome_kb.h>
66
67 #include <arm/samsung/exynos/exynos5_combiner.h>
68 #include <arm/samsung/exynos/exynos5_pad.h>
69
70 #define CKB_LOCK() mtx_lock(&Giant)
71 #define CKB_UNLOCK() mtx_unlock(&Giant)
72
73 #ifdef INVARIANTS
74 /*
75 * Assert that the lock is held in all contexts
76 * where the code can be executed.
77 */
78 #define CKB_LOCK_ASSERT() mtx_assert(&Giant, MA_OWNED)
79 /*
80 * Assert that the lock is held in the contexts
81 * where it really has to be so.
82 */
83 #define CKB_CTX_LOCK_ASSERT() \
84 do { \
85 if (!kdb_active && panicstr == NULL) \
86 mtx_assert(&Giant, MA_OWNED); \
87 } while (0)
88 #else
89 #define CKB_LOCK_ASSERT() (void)0
90 #define CKB_CTX_LOCK_ASSERT() (void)0
91 #endif
92
93 /*
94 * Define a stub keyboard driver in case one hasn't been
95 * compiled into the kernel
96 */
97 #include <sys/kbio.h>
98 #include <dev/kbd/kbdreg.h>
99 #include <dev/kbd/kbdtables.h>
100
101 #define CKB_NFKEY 12
102 #define CKB_FLAG_COMPOSE 0x1
103 #define CKB_FLAG_POLLING 0x2
104 #define KBD_DRIVER_NAME "ckbd"
105
106 struct ckb_softc {
107 keyboard_t sc_kbd;
108 keymap_t sc_keymap;
109 accentmap_t sc_accmap;
110 fkeytab_t sc_fkeymap[CKB_NFKEY];
111
112 struct resource* sc_mem_res;
113 struct resource* sc_irq_res;
114 void* sc_intr_hl;
115
116 int sc_mode; /* input mode (K_XLATE,K_RAW,K_CODE) */
117 int sc_state; /* shift/lock key state */
118 int sc_accents; /* accent key index (> 0) */
119 int sc_flags; /* flags */
120
121 struct callout sc_repeat_callout;
122 int sc_repeat_key;
123 int sc_repeating;
124
125 int flag;
126 int rows;
127 int cols;
128 int gpio;
129 device_t dev;
130 device_t gpio_dev;
131 struct thread *sc_poll_thread;
132 uint16_t *keymap;
133
134 uint8_t *scan_local;
135 uint8_t *scan;
136 };
137
138 /* prototypes */
139 static int ckb_set_typematic(keyboard_t *, int);
140 static uint32_t ckb_read_char(keyboard_t *, int);
141 static void ckb_clear_state(keyboard_t *);
142 static int ckb_ioctl(keyboard_t *, u_long, caddr_t);
143 static int ckb_enable(keyboard_t *);
144 static int ckb_disable(keyboard_t *);
145
146 static void
ckb_repeat(void * arg)147 ckb_repeat(void *arg)
148 {
149 struct ckb_softc *sc;
150
151 sc = arg;
152
153 if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) {
154 if (sc->sc_repeat_key != -1) {
155 sc->sc_repeating = 1;
156 sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd,
157 KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg);
158 }
159 }
160 }
161
162 /* detect a keyboard, not used */
163 static int
ckb__probe(int unit,void * arg,int flags)164 ckb__probe(int unit, void *arg, int flags)
165 {
166
167 return (ENXIO);
168 }
169
170 /* reset and initialize the device, not used */
171 static int
ckb_init(int unit,keyboard_t ** kbdp,void * arg,int flags)172 ckb_init(int unit, keyboard_t **kbdp, void *arg, int flags)
173 {
174
175 return (ENXIO);
176 }
177
178 /* test the interface to the device, not used */
179 static int
ckb_test_if(keyboard_t * kbd)180 ckb_test_if(keyboard_t *kbd)
181 {
182
183 return (0);
184 }
185
186 /* finish using this keyboard, not used */
187 static int
ckb_term(keyboard_t * kbd)188 ckb_term(keyboard_t *kbd)
189 {
190
191 return (ENXIO);
192 }
193
194 /* keyboard interrupt routine, not used */
195 static int
ckb_intr(keyboard_t * kbd,void * arg)196 ckb_intr(keyboard_t *kbd, void *arg)
197 {
198
199 return (0);
200 }
201
202 /* lock the access to the keyboard, not used */
203 static int
ckb_lock(keyboard_t * kbd,int lock)204 ckb_lock(keyboard_t *kbd, int lock)
205 {
206
207 return (1);
208 }
209
210 /* clear the internal state of the keyboard */
211 static void
ckb_clear_state(keyboard_t * kbd)212 ckb_clear_state(keyboard_t *kbd)
213 {
214 struct ckb_softc *sc;
215
216 sc = kbd->kb_data;
217
218 CKB_CTX_LOCK_ASSERT();
219
220 sc->sc_flags &= ~(CKB_FLAG_COMPOSE | CKB_FLAG_POLLING);
221 sc->sc_state &= LOCK_MASK; /* preserve locking key state */
222 sc->sc_accents = 0;
223 }
224
225 /* save the internal state, not used */
226 static int
ckb_get_state(keyboard_t * kbd,void * buf,size_t len)227 ckb_get_state(keyboard_t *kbd, void *buf, size_t len)
228 {
229
230 return (len == 0) ? 1 : -1;
231 }
232
233 /* set the internal state, not used */
234 static int
ckb_set_state(keyboard_t * kbd,void * buf,size_t len)235 ckb_set_state(keyboard_t *kbd, void *buf, size_t len)
236 {
237
238 return (EINVAL);
239 }
240
241
242 /* check if data is waiting */
243 static int
ckb_check(keyboard_t * kbd)244 ckb_check(keyboard_t *kbd)
245 {
246 struct ckb_softc *sc;
247 int i;
248
249 sc = kbd->kb_data;
250
251 CKB_CTX_LOCK_ASSERT();
252
253 if (!KBD_IS_ACTIVE(kbd))
254 return (0);
255
256 if (sc->sc_flags & CKB_FLAG_POLLING) {
257 return (1);
258 };
259
260 for (i = 0; i < sc->cols; i++)
261 if (sc->scan_local[i] != sc->scan[i]) {
262 return (1);
263 };
264
265 if (sc->sc_repeating)
266 return (1);
267
268 return (0);
269 }
270
271 /* check if char is waiting */
272 static int
ckb_check_char_locked(keyboard_t * kbd)273 ckb_check_char_locked(keyboard_t *kbd)
274 {
275 CKB_CTX_LOCK_ASSERT();
276
277 if (!KBD_IS_ACTIVE(kbd))
278 return (0);
279
280 return (ckb_check(kbd));
281 }
282
283 static int
ckb_check_char(keyboard_t * kbd)284 ckb_check_char(keyboard_t *kbd)
285 {
286 int result;
287
288 CKB_LOCK();
289 result = ckb_check_char_locked(kbd);
290 CKB_UNLOCK();
291
292 return (result);
293 }
294
295 /* read one byte from the keyboard if it's allowed */
296 /* Currently unused. */
297 static int
ckb_read(keyboard_t * kbd,int wait)298 ckb_read(keyboard_t *kbd, int wait)
299 {
300 CKB_CTX_LOCK_ASSERT();
301
302 if (!KBD_IS_ACTIVE(kbd))
303 return (-1);
304
305 printf("Implement ME: %s\n", __func__);
306 return (0);
307 }
308
309 static uint16_t
keymap_read(struct ckb_softc * sc,int col,int row)310 keymap_read(struct ckb_softc *sc, int col, int row)
311 {
312
313 KASSERT(sc->keymap != NULL, "keymap_read: no keymap");
314 if (col >= 0 && col < sc->cols &&
315 row >= 0 && row < sc->rows) {
316 return sc->keymap[row * sc->cols + col];
317 }
318
319 return (0);
320 }
321
322 static int
keymap_write(struct ckb_softc * sc,int col,int row,uint16_t key)323 keymap_write(struct ckb_softc *sc, int col, int row, uint16_t key)
324 {
325
326 KASSERT(sc->keymap != NULL, "keymap_write: no keymap");
327 if (col >= 0 && col < sc->cols &&
328 row >= 0 && row < sc->rows) {
329 sc->keymap[row * sc->cols + col] = key;
330 return (0);
331 }
332
333 return (-1);
334 }
335
336 /* read char from the keyboard */
337 static uint32_t
ckb_read_char_locked(keyboard_t * kbd,int wait)338 ckb_read_char_locked(keyboard_t *kbd, int wait)
339 {
340 struct ckb_softc *sc;
341 int i,j;
342 uint16_t key;
343 int oldbit;
344 int newbit;
345 int status;
346
347 sc = kbd->kb_data;
348
349 CKB_CTX_LOCK_ASSERT();
350
351 if (!KBD_IS_ACTIVE(kbd))
352 return (NOKEY);
353
354 if (sc->sc_repeating) {
355 sc->sc_repeating = 0;
356 callout_reset(&sc->sc_repeat_callout, hz / 10,
357 ckb_repeat, sc);
358 return (sc->sc_repeat_key);
359 };
360
361 if (sc->sc_flags & CKB_FLAG_POLLING) {
362 for (;;) {
363 GPIO_PIN_GET(sc->gpio_dev, sc->gpio, &status);
364 if (status == 0) {
365 if (ec_command(EC_CMD_MKBP_STATE, sc->scan,
366 sc->cols,
367 sc->scan, sc->cols)) {
368 return (NOKEY);
369 }
370 break;
371 }
372 if (!wait) {
373 return (NOKEY);
374 }
375 DELAY(1000);
376 }
377 };
378
379 for (i = 0; i < sc->cols; i++) {
380 for (j = 0; j < sc->rows; j++) {
381 oldbit = (sc->scan_local[i] & (1 << j));
382 newbit = (sc->scan[i] & (1 << j));
383
384 if (oldbit == newbit)
385 continue;
386
387 key = keymap_read(sc, i, j);
388 if (key == 0) {
389 continue;
390 };
391
392 if (newbit > 0) {
393 /* key pressed */
394 sc->scan_local[i] |= (1 << j);
395
396 /* setup repeating */
397 sc->sc_repeat_key = key;
398 callout_reset(&sc->sc_repeat_callout,
399 hz / 2, ckb_repeat, sc);
400
401 } else {
402 /* key released */
403 sc->scan_local[i] &= ~(1 << j);
404
405 /* release flag */
406 key |= 0x80;
407
408 /* unsetup repeating */
409 sc->sc_repeat_key = -1;
410 callout_stop(&sc->sc_repeat_callout);
411 }
412
413 return (key);
414 }
415 }
416
417 return (NOKEY);
418 }
419
420 /* Currently wait is always false. */
421 static uint32_t
ckb_read_char(keyboard_t * kbd,int wait)422 ckb_read_char(keyboard_t *kbd, int wait)
423 {
424 uint32_t keycode;
425
426 CKB_LOCK();
427 keycode = ckb_read_char_locked(kbd, wait);
428 CKB_UNLOCK();
429
430 return (keycode);
431 }
432
433
434 /* some useful control functions */
435 static int
ckb_ioctl_locked(keyboard_t * kbd,u_long cmd,caddr_t arg)436 ckb_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg)
437 {
438 struct ckb_softc *sc;
439 int i;
440
441 sc = kbd->kb_data;
442
443 CKB_LOCK_ASSERT();
444
445 switch (cmd) {
446 case KDGKBMODE: /* get keyboard mode */
447 *(int *)arg = sc->sc_mode;
448 break;
449
450 case KDSKBMODE: /* set keyboard mode */
451 switch (*(int *)arg) {
452 case K_XLATE:
453 if (sc->sc_mode != K_XLATE) {
454 /* make lock key state and LED state match */
455 sc->sc_state &= ~LOCK_MASK;
456 sc->sc_state |= KBD_LED_VAL(kbd);
457 }
458 /* FALLTHROUGH */
459 case K_RAW:
460 case K_CODE:
461 if (sc->sc_mode != *(int *)arg) {
462 if ((sc->sc_flags & CKB_FLAG_POLLING) == 0)
463 ckb_clear_state(kbd);
464 sc->sc_mode = *(int *)arg;
465 }
466 break;
467 default:
468 return (EINVAL);
469 }
470 break;
471
472 case KDGETLED: /* get keyboard LED */
473 *(int *)arg = KBD_LED_VAL(kbd);
474 break;
475
476 case KDSETLED: /* set keyboard LED */
477 /* NOTE: lock key state in "sc_state" won't be changed */
478 if (*(int *)arg & ~LOCK_MASK)
479 return (EINVAL);
480
481 i = *(int *)arg;
482
483 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */
484 if (sc->sc_mode == K_XLATE &&
485 kbd->kb_keymap->n_keys > ALTGR_OFFSET) {
486 if (i & ALKED)
487 i |= CLKED;
488 else
489 i &= ~CLKED;
490 }
491 if (KBD_HAS_DEVICE(kbd)) {
492 /* Configure LED */
493 }
494
495 KBD_LED_VAL(kbd) = *(int *)arg;
496 break;
497 case KDGKBSTATE: /* get lock key state */
498 *(int *)arg = sc->sc_state & LOCK_MASK;
499 break;
500
501 case KDSKBSTATE: /* set lock key state */
502 if (*(int *)arg & ~LOCK_MASK) {
503 return (EINVAL);
504 }
505 sc->sc_state &= ~LOCK_MASK;
506 sc->sc_state |= *(int *)arg;
507
508 /* set LEDs and quit */
509 return (ckb_ioctl(kbd, KDSETLED, arg));
510
511 case KDSETREPEAT: /* set keyboard repeat rate (new
512 * interface) */
513
514 if (!KBD_HAS_DEVICE(kbd)) {
515 return (0);
516 }
517 if (((int *)arg)[1] < 0) {
518 return (EINVAL);
519 }
520 if (((int *)arg)[0] < 0) {
521 return (EINVAL);
522 }
523 if (((int *)arg)[0] < 200) /* fastest possible value */
524 kbd->kb_delay1 = 200;
525 else
526 kbd->kb_delay1 = ((int *)arg)[0];
527 kbd->kb_delay2 = ((int *)arg)[1];
528 return (0);
529
530 case KDSETRAD: /* set keyboard repeat rate (old
531 * interface) */
532 return (ckb_set_typematic(kbd, *(int *)arg));
533
534 case PIO_KEYMAP: /* set keyboard translation table */
535 case OPIO_KEYMAP: /* set keyboard translation table
536 * (compat) */
537 case PIO_KEYMAPENT: /* set keyboard translation table
538 * entry */
539 case PIO_DEADKEYMAP: /* set accent key translation table */
540 sc->sc_accents = 0;
541 /* FALLTHROUGH */
542 default:
543 return (genkbd_commonioctl(kbd, cmd, arg));
544 }
545
546 return (0);
547 }
548
549 static int
ckb_ioctl(keyboard_t * kbd,u_long cmd,caddr_t arg)550 ckb_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
551 {
552 int result;
553
554 /*
555 * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any
556 * context where printf(9) can be called, which among other things
557 * includes interrupt filters and threads with any kinds of locks
558 * already held. For this reason it would be dangerous to acquire
559 * the Giant here unconditionally. On the other hand we have to
560 * have it to handle the ioctl.
561 * So we make our best effort to auto-detect whether we can grab
562 * the Giant or not. Blame syscons(4) for this.
563 */
564 switch (cmd) {
565 case KDGKBSTATE:
566 case KDSKBSTATE:
567 case KDSETLED:
568 if (!mtx_owned(&Giant) && !SCHEDULER_STOPPED())
569 return (EDEADLK); /* best I could come up with */
570 /* FALLTHROUGH */
571 default:
572 CKB_LOCK();
573 result = ckb_ioctl_locked(kbd, cmd, arg);
574 CKB_UNLOCK();
575 return (result);
576 }
577 }
578
579
580 /*
581 * Enable the access to the device; until this function is called,
582 * the client cannot read from the keyboard.
583 */
584 static int
ckb_enable(keyboard_t * kbd)585 ckb_enable(keyboard_t *kbd)
586 {
587
588 CKB_LOCK();
589 KBD_ACTIVATE(kbd);
590 CKB_UNLOCK();
591
592 return (0);
593 }
594
595 /* disallow the access to the device */
596 static int
ckb_disable(keyboard_t * kbd)597 ckb_disable(keyboard_t *kbd)
598 {
599
600 CKB_LOCK();
601 KBD_DEACTIVATE(kbd);
602 CKB_UNLOCK();
603
604 return (0);
605 }
606
607 /* local functions */
608
609 static int
ckb_set_typematic(keyboard_t * kbd,int code)610 ckb_set_typematic(keyboard_t *kbd, int code)
611 {
612 static const int delays[] = {250, 500, 750, 1000};
613 static const int rates[] = {34, 38, 42, 46, 50, 55, 59, 63,
614 68, 76, 84, 92, 100, 110, 118, 126,
615 136, 152, 168, 184, 200, 220, 236, 252,
616 272, 304, 336, 368, 400, 440, 472, 504};
617
618 if (code & ~0x7f) {
619 return (EINVAL);
620 }
621 kbd->kb_delay1 = delays[(code >> 5) & 3];
622 kbd->kb_delay2 = rates[code & 0x1f];
623 return (0);
624 }
625
626 static int
ckb_poll(keyboard_t * kbd,int on)627 ckb_poll(keyboard_t *kbd, int on)
628 {
629 struct ckb_softc *sc;
630
631 sc = kbd->kb_data;
632
633 CKB_LOCK();
634 if (on) {
635 sc->sc_flags |= CKB_FLAG_POLLING;
636 sc->sc_poll_thread = curthread;
637 } else {
638 sc->sc_flags &= ~CKB_FLAG_POLLING;
639 }
640 CKB_UNLOCK();
641
642 return (0);
643 }
644
645 /* local functions */
646
647 static int dummy_kbd_configure(int flags);
648
649 keyboard_switch_t ckbdsw = {
650 .probe = &ckb__probe,
651 .init = &ckb_init,
652 .term = &ckb_term,
653 .intr = &ckb_intr,
654 .test_if = &ckb_test_if,
655 .enable = &ckb_enable,
656 .disable = &ckb_disable,
657 .read = &ckb_read,
658 .check = &ckb_check,
659 .read_char = &ckb_read_char,
660 .check_char = &ckb_check_char,
661 .ioctl = &ckb_ioctl,
662 .lock = &ckb_lock,
663 .clear_state = &ckb_clear_state,
664 .get_state = &ckb_get_state,
665 .set_state = &ckb_set_state,
666 .get_fkeystr = &genkbd_get_fkeystr,
667 .poll = &ckb_poll,
668 .diag = &genkbd_diag,
669 };
670
671 static int
dummy_kbd_configure(int flags)672 dummy_kbd_configure(int flags)
673 {
674
675 return (0);
676 }
677
678 KEYBOARD_DRIVER(ckbd, ckbdsw, dummy_kbd_configure);
679
680 /*
681 * Parses 'keymap' into sc->keymap.
682 * Requires sc->cols and sc->rows to be set.
683 */
684 static int
parse_keymap(struct ckb_softc * sc,pcell_t * keymap,size_t len)685 parse_keymap(struct ckb_softc *sc, pcell_t *keymap, size_t len)
686 {
687 int i;
688
689 sc->keymap = malloc(sc->cols * sc->rows * sizeof(sc->keymap[0]),
690 M_DEVBUF, M_NOWAIT | M_ZERO);
691 if (sc->keymap == NULL) {
692 return (ENOMEM);
693 }
694
695 for (i = 0; i < len; i++) {
696 /*
697 * Return value is ignored, we just write whatever fits into
698 * specified number of rows and columns and silently ignore
699 * everything else.
700 * Keymap entries follow this format: 0xRRCCKKKK
701 * RR - row number, CC - column number, KKKK - key code
702 */
703 keymap_write(sc, (keymap[i] >> 16) & 0xff,
704 (keymap[i] >> 24) & 0xff,
705 keymap[i] & 0xffff);
706 }
707
708 return (0);
709 }
710
711 /* Allocates a new array for keymap and returns it in 'keymap'. */
712 static int
read_keymap(phandle_t node,const char * prop,pcell_t ** keymap,size_t * len)713 read_keymap(phandle_t node, const char *prop, pcell_t **keymap, size_t *len)
714 {
715
716 if ((*len = OF_getproplen(node, prop)) <= 0) {
717 return (ENXIO);
718 }
719 if ((*keymap = malloc(*len, M_DEVBUF, M_NOWAIT)) == NULL) {
720 return (ENOMEM);
721 }
722 if (OF_getencprop(node, prop, *keymap, *len) != *len) {
723 return (ENXIO);
724 }
725 return (0);
726 }
727
728 static int
parse_dts(struct ckb_softc * sc)729 parse_dts(struct ckb_softc *sc)
730 {
731 phandle_t node;
732 pcell_t dts_value;
733 pcell_t *keymap;
734 int len, ret;
735 const char *keymap_prop = NULL;
736
737 if ((node = ofw_bus_get_node(sc->dev)) == -1)
738 return (ENXIO);
739
740 if ((len = OF_getproplen(node, "google,key-rows")) <= 0)
741 return (ENXIO);
742 OF_getencprop(node, "google,key-rows", &dts_value, len);
743 sc->rows = dts_value;
744
745 if ((len = OF_getproplen(node, "google,key-columns")) <= 0)
746 return (ENXIO);
747 OF_getencprop(node, "google,key-columns", &dts_value, len);
748 sc->cols = dts_value;
749
750 if ((len = OF_getproplen(node, "freebsd,intr-gpio")) <= 0)
751 return (ENXIO);
752 OF_getencprop(node, "freebsd,intr-gpio", &dts_value, len);
753 sc->gpio = dts_value;
754
755 if (OF_hasprop(node, "freebsd,keymap")) {
756 keymap_prop = "freebsd,keymap";
757 device_printf(sc->dev, "using FreeBSD-specific keymap from FDT\n");
758 } else if (OF_hasprop(node, "linux,keymap")) {
759 keymap_prop = "linux,keymap";
760 device_printf(sc->dev, "using Linux keymap from FDT\n");
761 } else {
762 device_printf(sc->dev, "using built-in keymap\n");
763 }
764
765 if (keymap_prop != NULL) {
766 if ((ret = read_keymap(node, keymap_prop, &keymap, &len))) {
767 device_printf(sc->dev,
768 "failed to read keymap from FDT: %d\n", ret);
769 return (ret);
770 }
771 ret = parse_keymap(sc, keymap, len);
772 free(keymap, M_DEVBUF);
773 if (ret) {
774 return (ret);
775 }
776 } else {
777 if ((ret = parse_keymap(sc, default_keymap, KEYMAP_LEN))) {
778 return (ret);
779 }
780 }
781
782 if ((sc->rows == 0) || (sc->cols == 0) || (sc->gpio == 0))
783 return (ENXIO);
784
785 return (0);
786 }
787
788 void
ckb_ec_intr(void * arg)789 ckb_ec_intr(void *arg)
790 {
791 struct ckb_softc *sc;
792
793 sc = arg;
794
795 if (sc->sc_flags & CKB_FLAG_POLLING)
796 return;
797
798 ec_command(EC_CMD_MKBP_STATE, sc->scan, sc->cols,
799 sc->scan, sc->cols);
800
801 (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT,
802 sc->sc_kbd.kb_callback.kc_arg);
803 };
804
805 static int
chrome_kb_attach(device_t dev)806 chrome_kb_attach(device_t dev)
807 {
808 struct ckb_softc *sc;
809 keyboard_t *kbd;
810 int error;
811 int rid;
812 int i;
813
814 sc = device_get_softc(dev);
815
816 sc->dev = dev;
817 sc->keymap = NULL;
818
819 if ((error = parse_dts(sc)) != 0)
820 return error;
821
822 sc->gpio_dev = devclass_get_device(devclass_find("gpio"), 0);
823 if (sc->gpio_dev == NULL) {
824 device_printf(sc->dev, "Can't find gpio device.\n");
825 return (ENXIO);
826 }
827
828 #if 0
829 device_printf(sc->dev, "Keyboard matrix [%dx%d]\n",
830 sc->cols, sc->rows);
831 #endif
832
833 pad_setup_intr(sc->gpio, ckb_ec_intr, sc);
834
835 kbd = &sc->sc_kbd;
836 rid = 0;
837
838 sc->scan_local = malloc(sc->cols, M_DEVBUF, M_NOWAIT);
839 sc->scan = malloc(sc->cols, M_DEVBUF, M_NOWAIT);
840
841 for (i = 0; i < sc->cols; i++) {
842 sc->scan_local[i] = 0;
843 sc->scan[i] = 0;
844 };
845
846 kbd_init_struct(kbd, KBD_DRIVER_NAME, KB_OTHER,
847 device_get_unit(dev), 0, 0, 0);
848 kbd->kb_data = (void *)sc;
849
850 sc->sc_keymap = key_map;
851 sc->sc_accmap = accent_map;
852 for (i = 0; i < CKB_NFKEY; i++) {
853 sc->sc_fkeymap[i] = fkey_tab[i];
854 }
855
856 kbd_set_maps(kbd, &sc->sc_keymap, &sc->sc_accmap,
857 sc->sc_fkeymap, CKB_NFKEY);
858
859 KBD_FOUND_DEVICE(kbd);
860 ckb_clear_state(kbd);
861 KBD_PROBE_DONE(kbd);
862
863 callout_init(&sc->sc_repeat_callout, 0);
864
865 KBD_INIT_DONE(kbd);
866
867 if (kbd_register(kbd) < 0) {
868 return (ENXIO);
869 };
870 KBD_CONFIG_DONE(kbd);
871
872 return (0);
873 }
874
875 static int
chrome_kb_probe(device_t dev)876 chrome_kb_probe(device_t dev)
877 {
878
879 if (!ofw_bus_status_okay(dev))
880 return (ENXIO);
881
882 if (ofw_bus_is_compatible(dev, "google,cros-ec-keyb") ||
883 ofw_bus_is_compatible(dev, "google,mkbp-keyb")) {
884 device_set_desc(dev, "Chrome EC Keyboard");
885 return (BUS_PROBE_DEFAULT);
886 }
887
888 return (ENXIO);
889 }
890
891 static int
chrome_kb_detach(device_t dev)892 chrome_kb_detach(device_t dev)
893 {
894 struct ckb_softc *sc;
895
896 sc = device_get_softc(dev);
897
898 if (sc->keymap != NULL) {
899 free(sc->keymap, M_DEVBUF);
900 }
901
902 return 0;
903 }
904
905 static device_method_t chrome_kb_methods[] = {
906 DEVMETHOD(device_probe, chrome_kb_probe),
907 DEVMETHOD(device_attach, chrome_kb_attach),
908 DEVMETHOD(device_detach, chrome_kb_detach),
909 { 0, 0 }
910 };
911
912 static driver_t chrome_kb_driver = {
913 "chrome_kb",
914 chrome_kb_methods,
915 sizeof(struct ckb_softc),
916 };
917
918 static devclass_t chrome_kb_devclass;
919
920 DRIVER_MODULE(chrome_kb, simplebus, chrome_kb_driver,
921 chrome_kb_devclass, 0, 0);
922