1 /*-
2 * Copyright (c) 2017 Microsoft Corp.
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 unmodified, this list of conditions, and the following
10 * disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 #include "opt_evdev.h"
29
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/conf.h>
33 #include <sys/uio.h>
34 #include <sys/bus.h>
35 #include <sys/malloc.h>
36 #include <sys/mbuf.h>
37 #include <sys/module.h>
38 #include <sys/limits.h>
39 #include <sys/lock.h>
40 #include <sys/taskqueue.h>
41 #include <sys/selinfo.h>
42 #include <sys/sysctl.h>
43 #include <sys/poll.h>
44 #include <sys/proc.h>
45 #include <sys/queue.h>
46 #include <sys/kthread.h>
47 #include <sys/syscallsubr.h>
48 #include <sys/sysproto.h>
49 #include <sys/sema.h>
50 #include <sys/signal.h>
51 #include <sys/syslog.h>
52 #include <sys/systm.h>
53 #include <sys/mutex.h>
54 #include <sys/callout.h>
55
56 #include <sys/kbio.h>
57 #include <dev/kbd/kbdreg.h>
58 #include <dev/kbd/kbdtables.h>
59
60 #ifdef EVDEV_SUPPORT
61 #include <dev/evdev/evdev.h>
62 #include <dev/evdev/input.h>
63 #endif
64
65 #include "dev/hyperv/input/hv_kbdc.h"
66
67 #define HVKBD_MTX_LOCK(_m) do { \
68 mtx_lock(_m); \
69 } while (0)
70
71 #define HVKBD_MTX_UNLOCK(_m) do { \
72 mtx_unlock(_m); \
73 } while (0)
74
75 #define HVKBD_MTX_ASSERT(_m, _t) do { \
76 mtx_assert(_m, _t); \
77 } while (0)
78
79 #define HVKBD_LOCK() HVKBD_MTX_LOCK(&Giant)
80 #define HVKBD_UNLOCK() HVKBD_MTX_UNLOCK(&Giant)
81 #define HVKBD_LOCK_ASSERT() HVKBD_MTX_ASSERT(&Giant, MA_OWNED)
82
83 #define HVKBD_FLAG_COMPOSE 0x00000001 /* compose char flag */
84 #define HVKBD_FLAG_POLLING 0x00000002
85
86 #ifdef EVDEV_SUPPORT
87 static evdev_event_t hvkbd_ev_event;
88
89 static const struct evdev_methods hvkbd_evdev_methods = {
90 .ev_event = hvkbd_ev_event,
91 };
92 #endif
93
94 /* early keyboard probe, not supported */
95 static int
hvkbd_configure(int flags)96 hvkbd_configure(int flags)
97 {
98 return (0);
99 }
100
101 /* detect a keyboard, not used */
102 static int
hvkbd_probe(int unit,void * arg,int flags)103 hvkbd_probe(int unit, void *arg, int flags)
104 {
105 return (ENXIO);
106 }
107
108 /* reset and initialize the device, not used */
109 static int
hvkbd_init(int unit,keyboard_t ** kbdp,void * arg,int flags)110 hvkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
111 {
112 DEBUG_HVKBD(*kbdp, "%s\n", __func__);
113 return (ENXIO);
114 }
115
116 /* test the interface to the device, not used */
117 static int
hvkbd_test_if(keyboard_t * kbd)118 hvkbd_test_if(keyboard_t *kbd)
119 {
120 DEBUG_HVKBD(kbd, "%s\n", __func__);
121 return (0);
122 }
123
124 /* finish using this keyboard, not used */
125 static int
hvkbd_term(keyboard_t * kbd)126 hvkbd_term(keyboard_t *kbd)
127 {
128 DEBUG_HVKBD(kbd, "%s\n", __func__);
129 return (ENXIO);
130 }
131
132 /* keyboard interrupt routine, not used */
133 static int
hvkbd_intr(keyboard_t * kbd,void * arg)134 hvkbd_intr(keyboard_t *kbd, void *arg)
135 {
136 DEBUG_HVKBD(kbd, "%s\n", __func__);
137 return (0);
138 }
139
140 /* lock the access to the keyboard, not used */
141 static int
hvkbd_lock(keyboard_t * kbd,int lock)142 hvkbd_lock(keyboard_t *kbd, int lock)
143 {
144 DEBUG_HVKBD(kbd, "%s\n", __func__);
145 return (1);
146 }
147
148 /* save the internal state, not used */
149 static int
hvkbd_get_state(keyboard_t * kbd,void * buf,size_t len)150 hvkbd_get_state(keyboard_t *kbd, void *buf, size_t len)
151 {
152 DEBUG_HVKBD(kbd,"%s\n", __func__);
153 return (len == 0) ? 1 : -1;
154 }
155
156 /* set the internal state, not used */
157 static int
hvkbd_set_state(keyboard_t * kbd,void * buf,size_t len)158 hvkbd_set_state(keyboard_t *kbd, void *buf, size_t len)
159 {
160 DEBUG_HVKBD(kbd, "%s\n", __func__);
161 return (EINVAL);
162 }
163
164 static int
hvkbd_poll(keyboard_t * kbd,int on)165 hvkbd_poll(keyboard_t *kbd, int on)
166 {
167 hv_kbd_sc *sc = kbd->kb_data;
168
169 HVKBD_LOCK();
170 /*
171 * Keep a reference count on polling to allow recursive
172 * cngrab() during a panic for example.
173 */
174 if (on)
175 sc->sc_polling++;
176 else if (sc->sc_polling > 0)
177 sc->sc_polling--;
178
179 if (sc->sc_polling != 0) {
180 sc->sc_flags |= HVKBD_FLAG_POLLING;
181 } else {
182 sc->sc_flags &= ~HVKBD_FLAG_POLLING;
183 }
184 HVKBD_UNLOCK();
185 return (0);
186 }
187
188 /*
189 * Enable the access to the device; until this function is called,
190 * the client cannot read from the keyboard.
191 */
192 static int
hvkbd_enable(keyboard_t * kbd)193 hvkbd_enable(keyboard_t *kbd)
194 {
195 HVKBD_LOCK();
196 KBD_ACTIVATE(kbd);
197 HVKBD_UNLOCK();
198 return (0);
199 }
200
201 /* disallow the access to the device */
202 static int
hvkbd_disable(keyboard_t * kbd)203 hvkbd_disable(keyboard_t *kbd)
204 {
205 DEBUG_HVKBD(kbd, "%s\n", __func__);
206 HVKBD_LOCK();
207 KBD_DEACTIVATE(kbd);
208 HVKBD_UNLOCK();
209 return (0);
210 }
211
212 static void
hvkbd_do_poll(hv_kbd_sc * sc,uint8_t wait)213 hvkbd_do_poll(hv_kbd_sc *sc, uint8_t wait)
214 {
215 while (!hv_kbd_prod_is_ready(sc)) {
216 hv_kbd_read_channel(sc->hs_chan, sc);
217 if (!wait)
218 break;
219 }
220 }
221
222 /* check if data is waiting */
223 /* Currently unused. */
224 static int
hvkbd_check(keyboard_t * kbd)225 hvkbd_check(keyboard_t *kbd)
226 {
227 DEBUG_HVKBD(kbd, "%s\n", __func__);
228 return (0);
229 }
230
231 /* check if char is waiting */
232 static int
hvkbd_check_char_locked(keyboard_t * kbd)233 hvkbd_check_char_locked(keyboard_t *kbd)
234 {
235 HVKBD_LOCK_ASSERT();
236 if (!KBD_IS_ACTIVE(kbd))
237 return (FALSE);
238
239 hv_kbd_sc *sc = kbd->kb_data;
240 if (!(sc->sc_flags & HVKBD_FLAG_COMPOSE) && sc->sc_composed_char != 0)
241 return (TRUE);
242 if (sc->sc_flags & HVKBD_FLAG_POLLING)
243 hvkbd_do_poll(sc, 0);
244 if (hv_kbd_prod_is_ready(sc)) {
245 return (TRUE);
246 }
247 return (FALSE);
248 }
249
250 static int
hvkbd_check_char(keyboard_t * kbd)251 hvkbd_check_char(keyboard_t *kbd)
252 {
253 int result;
254
255 HVKBD_LOCK();
256 result = hvkbd_check_char_locked(kbd);
257 HVKBD_UNLOCK();
258
259 return (result);
260 }
261
262 /* read char from the keyboard */
263 static uint32_t
hvkbd_read_char_locked(keyboard_t * kbd,int wait)264 hvkbd_read_char_locked(keyboard_t *kbd, int wait)
265 {
266 uint32_t scancode = NOKEY;
267 uint32_t action;
268 keystroke ks;
269 hv_kbd_sc *sc = kbd->kb_data;
270 int keycode;
271
272 HVKBD_LOCK_ASSERT();
273
274 if (!KBD_IS_ACTIVE(kbd) || !hv_kbd_prod_is_ready(sc))
275 return (NOKEY);
276
277 next_code:
278
279 /* do we have a composed char to return? */
280 if (!(sc->sc_flags & HVKBD_FLAG_COMPOSE) && sc->sc_composed_char > 0) {
281 action = sc->sc_composed_char;
282 sc->sc_composed_char = 0;
283 if (action > UCHAR_MAX) {
284 return (ERRKEY);
285 }
286 return (action);
287 }
288
289 if (hv_kbd_fetch_top(sc, &ks)) {
290 return (NOKEY);
291 }
292 if ((ks.info & IS_E0) || (ks.info & IS_E1)) {
293 /**
294 * Emulate the generation of E0 or E1 scancode,
295 * the real scancode will be consumed next time.
296 */
297 if (ks.info & IS_E0) {
298 scancode = XTKBD_EMUL0;
299 ks.info &= ~IS_E0;
300 } else if (ks.info & IS_E1) {
301 scancode = XTKBD_EMUL1;
302 ks.info &= ~IS_E1;
303 }
304 /**
305 * Change the top item to avoid encountering
306 * E0 or E1 twice.
307 */
308 hv_kbd_modify_top(sc, &ks);
309 } else if (ks.info & IS_UNICODE) {
310 /**
311 * XXX: Hyperv host send unicode to VM through
312 * 'Type clipboard text', the mapping from
313 * unicode to scancode depends on the keymap.
314 * It is so complicated that we do not plan to
315 * support it yet.
316 */
317 if (bootverbose)
318 device_printf(sc->dev, "Unsupported unicode\n");
319 hv_kbd_remove_top(sc);
320 return (NOKEY);
321 } else {
322 scancode = ks.makecode;
323 if (ks.info & IS_BREAK) {
324 scancode |= XTKBD_RELEASE;
325 }
326 hv_kbd_remove_top(sc);
327 }
328 #ifdef EVDEV_SUPPORT
329 /* push evdev event */
330 if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD &&
331 sc->ks_evdev != NULL) {
332 keycode = evdev_scancode2key(&sc->ks_evdev_state,
333 scancode);
334
335 if (keycode != KEY_RESERVED) {
336 evdev_push_event(sc->ks_evdev, EV_KEY,
337 (uint16_t)keycode, scancode & 0x80 ? 0 : 1);
338 evdev_sync(sc->ks_evdev);
339 }
340 }
341 if (sc->ks_evdev != NULL && evdev_is_grabbed(sc->ks_evdev))
342 return (NOKEY);
343 #endif
344 ++kbd->kb_count;
345 DEBUG_HVKBD(kbd, "read scan: 0x%x\n", scancode);
346
347 /* return the byte as is for the K_RAW mode */
348 if (sc->sc_mode == K_RAW)
349 return scancode;
350
351 /* translate the scan code into a keycode */
352 keycode = scancode & 0x7F;
353 switch (sc->sc_prefix) {
354 case 0x00: /* normal scancode */
355 switch(scancode) {
356 case 0xB8: /* left alt (compose key) released */
357 if (sc->sc_flags & HVKBD_FLAG_COMPOSE) {
358 sc->sc_flags &= ~HVKBD_FLAG_COMPOSE;
359 if (sc->sc_composed_char > UCHAR_MAX)
360 sc->sc_composed_char = 0;
361 }
362 break;
363 case 0x38: /* left alt (compose key) pressed */
364 if (!(sc->sc_flags & HVKBD_FLAG_COMPOSE)) {
365 sc->sc_flags |= HVKBD_FLAG_COMPOSE;
366 sc->sc_composed_char = 0;
367 }
368 break;
369 case 0xE0:
370 case 0xE1:
371 sc->sc_prefix = scancode;
372 goto next_code;
373 }
374 break;
375 case 0xE0: /* 0xE0 prefix */
376 sc->sc_prefix = 0;
377 switch (keycode) {
378 case 0x1C: /* right enter key */
379 keycode = 0x59;
380 break;
381 case 0x1D: /* right ctrl key */
382 keycode = 0x5A;
383 break;
384 case 0x35: /* keypad divide key */
385 keycode = 0x5B;
386 break;
387 case 0x37: /* print scrn key */
388 keycode = 0x5C;
389 break;
390 case 0x38: /* right alt key (alt gr) */
391 keycode = 0x5D;
392 break;
393 case 0x46: /* ctrl-pause/break on AT 101 (see below) */
394 keycode = 0x68;
395 break;
396 case 0x47: /* grey home key */
397 keycode = 0x5E;
398 break;
399 case 0x48: /* grey up arrow key */
400 keycode = 0x5F;
401 break;
402 case 0x49: /* grey page up key */
403 keycode = 0x60;
404 break;
405 case 0x4B: /* grey left arrow key */
406 keycode = 0x61;
407 break;
408 case 0x4D: /* grey right arrow key */
409 keycode = 0x62;
410 break;
411 case 0x4F: /* grey end key */
412 keycode = 0x63;
413 break;
414 case 0x50: /* grey down arrow key */
415 keycode = 0x64;
416 break;
417 case 0x51: /* grey page down key */
418 keycode = 0x65;
419 break;
420 case 0x52: /* grey insert key */
421 keycode = 0x66;
422 break;
423 case 0x53: /* grey delete key */
424 keycode = 0x67;
425 break;
426 /* the following 3 are only used on the MS "Natural" keyboard */
427 case 0x5b: /* left Window key */
428 keycode = 0x69;
429 break;
430 case 0x5c: /* right Window key */
431 keycode = 0x6a;
432 break;
433 case 0x5d: /* menu key */
434 keycode = 0x6b;
435 break;
436 case 0x5e: /* power key */
437 keycode = 0x6d;
438 break;
439 case 0x5f: /* sleep key */
440 keycode = 0x6e;
441 break;
442 case 0x63: /* wake key */
443 keycode = 0x6f;
444 break;
445 default: /* ignore everything else */
446 goto next_code;
447 }
448 break;
449 case 0xE1: /* 0xE1 prefix */
450 /*
451 * The pause/break key on the 101 keyboard produces:
452 * E1-1D-45 E1-9D-C5
453 * Ctrl-pause/break produces:
454 * E0-46 E0-C6 (See above.)
455 */
456 sc->sc_prefix = 0;
457 if (keycode == 0x1D)
458 sc->sc_prefix = 0x1D;
459 goto next_code;
460 /* NOT REACHED */
461 case 0x1D: /* pause / break */
462 sc->sc_prefix = 0;
463 if (keycode != 0x45)
464 goto next_code;
465 keycode = 0x68;
466 break;
467 }
468
469 /* XXX assume 101/102 keys AT keyboard */
470 switch (keycode) {
471 case 0x5c: /* print screen */
472 if (sc->sc_flags & ALTS)
473 keycode = 0x54; /* sysrq */
474 break;
475 case 0x68: /* pause/break */
476 if (sc->sc_flags & CTLS)
477 keycode = 0x6c; /* break */
478 break;
479 }
480
481 /* return the key code in the K_CODE mode */
482 if (sc->sc_mode == K_CODE)
483 return (keycode | (scancode & 0x80));
484
485 /* compose a character code */
486 if (sc->sc_flags & HVKBD_FLAG_COMPOSE) {
487 switch (keycode | (scancode & 0x80)) {
488 /* key pressed, process it */
489 case 0x47: case 0x48: case 0x49: /* keypad 7,8,9 */
490 sc->sc_composed_char *= 10;
491 sc->sc_composed_char += keycode - 0x40;
492 if (sc->sc_composed_char > UCHAR_MAX)
493 return ERRKEY;
494 goto next_code;
495 case 0x4B: case 0x4C: case 0x4D: /* keypad 4,5,6 */
496 sc->sc_composed_char *= 10;
497 sc->sc_composed_char += keycode - 0x47;
498 if (sc->sc_composed_char > UCHAR_MAX)
499 return ERRKEY;
500 goto next_code;
501 case 0x4F: case 0x50: case 0x51: /* keypad 1,2,3 */
502 sc->sc_composed_char *= 10;
503 sc->sc_composed_char += keycode - 0x4E;
504 if (sc->sc_composed_char > UCHAR_MAX)
505 return ERRKEY;
506 goto next_code;
507 case 0x52: /* keypad 0 */
508 sc->sc_composed_char *= 10;
509 if (sc->sc_composed_char > UCHAR_MAX)
510 return ERRKEY;
511 goto next_code;
512
513 /* key released, no interest here */
514 case 0xC7: case 0xC8: case 0xC9: /* keypad 7,8,9 */
515 case 0xCB: case 0xCC: case 0xCD: /* keypad 4,5,6 */
516 case 0xCF: case 0xD0: case 0xD1: /* keypad 1,2,3 */
517 case 0xD2: /* keypad 0 */
518 goto next_code;
519
520 case 0x38: /* left alt key */
521 break;
522
523 default:
524 if (sc->sc_composed_char > 0) {
525 sc->sc_flags &= ~HVKBD_FLAG_COMPOSE;
526 sc->sc_composed_char = 0;
527 return (ERRKEY);
528 }
529 break;
530 }
531 }
532
533 /* keycode to key action */
534 action = genkbd_keyaction(kbd, keycode, scancode & 0x80,
535 &sc->sc_state, &sc->sc_accents);
536 if (action == NOKEY)
537 goto next_code;
538 else
539 return (action);
540 }
541
542 /* Currently wait is always false. */
543 static uint32_t
hvkbd_read_char(keyboard_t * kbd,int wait)544 hvkbd_read_char(keyboard_t *kbd, int wait)
545 {
546 uint32_t keycode;
547
548 HVKBD_LOCK();
549 keycode = hvkbd_read_char_locked(kbd, wait);
550 HVKBD_UNLOCK();
551
552 return (keycode);
553 }
554
555 /* clear the internal state of the keyboard */
556 static void
hvkbd_clear_state(keyboard_t * kbd)557 hvkbd_clear_state(keyboard_t *kbd)
558 {
559 hv_kbd_sc *sc = kbd->kb_data;
560 sc->sc_state &= LOCK_MASK; /* preserve locking key state */
561 sc->sc_flags &= ~(HVKBD_FLAG_POLLING | HVKBD_FLAG_COMPOSE);
562 sc->sc_accents = 0;
563 sc->sc_composed_char = 0;
564 }
565
566 static int
hvkbd_ioctl_locked(keyboard_t * kbd,u_long cmd,caddr_t arg)567 hvkbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg)
568 {
569 int i;
570 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
571 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
572 int ival;
573 #endif
574 hv_kbd_sc *sc = kbd->kb_data;
575 switch (cmd) {
576 case KDGKBMODE:
577 *(int *)arg = sc->sc_mode;
578 break;
579 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
580 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
581 case _IO('K', 7):
582 ival = IOCPARM_IVAL(arg);
583 arg = (caddr_t)&ival;
584 /* FALLTHROUGH */
585 #endif
586 case KDSKBMODE: /* set keyboard mode */
587 DEBUG_HVKBD(kbd, "expected mode: %x\n", *(int *)arg);
588 switch (*(int *)arg) {
589 case K_XLATE:
590 if (sc->sc_mode != K_XLATE) {
591 /* make lock key state and LED state match */
592 sc->sc_state &= ~LOCK_MASK;
593 sc->sc_state |= KBD_LED_VAL(kbd);
594 }
595 /* FALLTHROUGH */
596 case K_RAW:
597 case K_CODE:
598 if (sc->sc_mode != *(int *)arg) {
599 DEBUG_HVKBD(kbd, "mod changed to %x\n", *(int *)arg);
600 if ((sc->sc_flags & HVKBD_FLAG_POLLING) == 0)
601 hvkbd_clear_state(kbd);
602 sc->sc_mode = *(int *)arg;
603 }
604 break;
605 default:
606 return (EINVAL);
607 }
608 break;
609 case KDGKBSTATE: /* get lock key state */
610 *(int *)arg = sc->sc_state & LOCK_MASK;
611 break;
612 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
613 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
614 case _IO('K', 20):
615 ival = IOCPARM_IVAL(arg);
616 arg = (caddr_t)&ival;
617 /* FALLTHROUGH */
618 #endif
619 case KDSKBSTATE: /* set lock key state */
620 if (*(int *)arg & ~LOCK_MASK) {
621 return (EINVAL);
622 }
623 sc->sc_state &= ~LOCK_MASK;
624 sc->sc_state |= *(int *)arg;
625 return hvkbd_ioctl_locked(kbd, KDSETLED, arg);
626 case KDGETLED: /* get keyboard LED */
627 *(int *)arg = KBD_LED_VAL(kbd);
628 break;
629 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
630 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
631 case _IO('K', 66):
632 ival = IOCPARM_IVAL(arg);
633 arg = (caddr_t)&ival;
634 /* FALLTHROUGH */
635 #endif
636 case KDSETLED: /* set keyboard LED */
637 /* NOTE: lock key state in "sc_state" won't be changed */
638 if (*(int *)arg & ~LOCK_MASK)
639 return (EINVAL);
640
641 i = *(int *)arg;
642
643 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */
644 if (sc->sc_mode == K_XLATE &&
645 kbd->kb_keymap->n_keys > ALTGR_OFFSET) {
646 if (i & ALKED)
647 i |= CLKED;
648 else
649 i &= ~CLKED;
650 }
651 if (KBD_HAS_DEVICE(kbd)) {
652 DEBUG_HVSC(sc, "setled 0x%x\n", *(int *)arg);
653 }
654
655 #ifdef EVDEV_SUPPORT
656 /* push LED states to evdev */
657 if (sc->ks_evdev != NULL &&
658 evdev_rcpt_mask & EVDEV_RCPT_HW_KBD)
659 evdev_push_leds(sc->ks_evdev, *(int *)arg);
660 #endif
661 KBD_LED_VAL(kbd) = *(int *)arg;
662 break;
663 case PIO_KEYMAP: /* set keyboard translation table */
664 case PIO_KEYMAPENT: /* set keyboard translation table entry */
665 case PIO_DEADKEYMAP: /* set accent key translation table */
666 #ifdef COMPAT_FREEBSD13
667 case OPIO_KEYMAP: /* set keyboard translation table (compat) */
668 case OPIO_DEADKEYMAP: /* set accent key translation table (compat) */
669 #endif /* COMPAT_FREEBSD13 */
670 sc->sc_accents = 0;
671 /* FALLTHROUGH */
672 default:
673 return (genkbd_commonioctl(kbd, cmd, arg));
674 }
675 return (0);
676 }
677
678 /* some useful control functions */
679 static int
hvkbd_ioctl(keyboard_t * kbd,u_long cmd,caddr_t arg)680 hvkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
681 {
682 DEBUG_HVKBD(kbd, "%s: %lx start\n", __func__, cmd);
683 HVKBD_LOCK();
684 int ret = hvkbd_ioctl_locked(kbd, cmd, arg);
685 HVKBD_UNLOCK();
686 DEBUG_HVKBD(kbd, "%s: %lx end %d\n", __func__, cmd, ret);
687 return (ret);
688 }
689
690 /* read one byte from the keyboard if it's allowed */
691 /* Currently unused. */
692 static int
hvkbd_read(keyboard_t * kbd,int wait)693 hvkbd_read(keyboard_t *kbd, int wait)
694 {
695 DEBUG_HVKBD(kbd, "%s\n", __func__);
696 HVKBD_LOCK_ASSERT();
697 if (!KBD_IS_ACTIVE(kbd))
698 return (-1);
699 return hvkbd_read_char_locked(kbd, wait);
700 }
701
702 #ifdef EVDEV_SUPPORT
703 static void
hvkbd_ev_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t value)704 hvkbd_ev_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
705 int32_t value)
706 {
707 keyboard_t *kbd = evdev_get_softc(evdev);
708
709 if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD &&
710 (type == EV_LED || type == EV_REP)) {
711 mtx_lock(&Giant);
712 kbd_ev_event(kbd, type, code, value);
713 mtx_unlock(&Giant);
714 }
715 }
716 #endif
717
718 static keyboard_switch_t hvkbdsw = {
719 .probe = hvkbd_probe, /* not used */
720 .init = hvkbd_init,
721 .term = hvkbd_term, /* not used */
722 .intr = hvkbd_intr, /* not used */
723 .test_if = hvkbd_test_if, /* not used */
724 .enable = hvkbd_enable,
725 .disable = hvkbd_disable,
726 .read = hvkbd_read,
727 .check = hvkbd_check,
728 .read_char = hvkbd_read_char,
729 .check_char = hvkbd_check_char,
730 .ioctl = hvkbd_ioctl,
731 .lock = hvkbd_lock, /* not used */
732 .clear_state = hvkbd_clear_state,
733 .get_state = hvkbd_get_state, /* not used */
734 .set_state = hvkbd_set_state, /* not used */
735 .poll = hvkbd_poll,
736 };
737
738 KEYBOARD_DRIVER(hvkbd, hvkbdsw, hvkbd_configure);
739
740 void
hv_kbd_intr(hv_kbd_sc * sc)741 hv_kbd_intr(hv_kbd_sc *sc)
742 {
743 uint32_t c;
744 if ((sc->sc_flags & HVKBD_FLAG_POLLING) != 0)
745 return;
746
747 if (KBD_IS_ACTIVE(&sc->sc_kbd) &&
748 KBD_IS_BUSY(&sc->sc_kbd)) {
749 /* let the callback function process the input */
750 (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT,
751 sc->sc_kbd.kb_callback.kc_arg);
752 } else {
753 /* read and discard the input, no one is waiting for it */
754 do {
755 c = hvkbd_read_char(&sc->sc_kbd, 0);
756 } while (c != NOKEY);
757 }
758 }
759
760 int
hvkbd_driver_load(module_t mod,int what,void * arg)761 hvkbd_driver_load(module_t mod, int what, void *arg)
762 {
763 switch (what) {
764 case MOD_LOAD:
765 kbd_add_driver(&hvkbd_kbd_driver);
766 break;
767 case MOD_UNLOAD:
768 kbd_delete_driver(&hvkbd_kbd_driver);
769 break;
770 }
771 return (0);
772 }
773
774 int
hv_kbd_drv_attach(device_t dev)775 hv_kbd_drv_attach(device_t dev)
776 {
777 hv_kbd_sc *sc = device_get_softc(dev);
778 int unit = device_get_unit(dev);
779 keyboard_t *kbd = &sc->sc_kbd;
780 keyboard_switch_t *sw;
781 #ifdef EVDEV_SUPPORT
782 struct evdev_dev *evdev;
783 #endif
784
785 sw = kbd_get_switch(HVKBD_DRIVER_NAME);
786 if (sw == NULL) {
787 return (ENXIO);
788 }
789
790 kbd_init_struct(kbd, HVKBD_DRIVER_NAME, KB_OTHER, unit, 0, 0, 0);
791 kbd->kb_data = (void *)sc;
792 kbd_set_maps(kbd, &key_map, &accent_map, fkey_tab, nitems(fkey_tab));
793 KBD_FOUND_DEVICE(kbd);
794 hvkbd_clear_state(kbd);
795 KBD_PROBE_DONE(kbd);
796 KBD_INIT_DONE(kbd);
797 sc->sc_mode = K_XLATE;
798 (*sw->enable)(kbd);
799
800 #ifdef EVDEV_SUPPORT
801 evdev = evdev_alloc();
802 evdev_set_name(evdev, "Hyper-V keyboard");
803 evdev_set_phys(evdev, device_get_nameunit(dev));
804 evdev_set_id(evdev, BUS_VIRTUAL, 0, 0, 0);
805 evdev_set_methods(evdev, kbd, &hvkbd_evdev_methods);
806 evdev_support_event(evdev, EV_SYN);
807 evdev_support_event(evdev, EV_KEY);
808 evdev_support_event(evdev, EV_LED);
809 evdev_support_event(evdev, EV_REP);
810 evdev_support_all_known_keys(evdev);
811 evdev_support_led(evdev, LED_NUML);
812 evdev_support_led(evdev, LED_CAPSL);
813 evdev_support_led(evdev, LED_SCROLLL);
814 if (evdev_register_mtx(evdev, &Giant))
815 evdev_free(evdev);
816 else
817 sc->ks_evdev = evdev;
818 sc->ks_evdev_state = 0;
819 #endif
820
821 if (kbd_register(kbd) < 0) {
822 goto detach;
823 }
824 KBD_CONFIG_DONE(kbd);
825 #ifdef KBD_INSTALL_CDEV
826 if (kbd_attach(kbd)) {
827 goto detach;
828 }
829 #endif
830 if (bootverbose) {
831 kbdd_diag(kbd, bootverbose);
832 }
833 return (0);
834 detach:
835 hv_kbd_drv_detach(dev);
836 return (ENXIO);
837 }
838
839 int
hv_kbd_drv_detach(device_t dev)840 hv_kbd_drv_detach(device_t dev)
841 {
842 int error = 0;
843 hv_kbd_sc *sc = device_get_softc(dev);
844 hvkbd_disable(&sc->sc_kbd);
845 #ifdef EVDEV_SUPPORT
846 evdev_free(sc->ks_evdev);
847 #endif
848 if (KBD_IS_CONFIGURED(&sc->sc_kbd)) {
849 error = kbd_unregister(&sc->sc_kbd);
850 if (error) {
851 device_printf(dev, "WARNING: kbd_unregister() "
852 "returned non-zero! (ignored)\n");
853 }
854 }
855 #ifdef KBD_INSTALL_CDEV
856 error = kbd_detach(&sc->sc_kbd);
857 #endif
858 return (error);
859 }
860
861