2 * Copyright (c) 2017 Microsoft Corp.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
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.
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.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
31 #include <sys/kernel.h>
35 #include <sys/malloc.h>
37 #include <sys/module.h>
39 #include <sys/taskqueue.h>
40 #include <sys/selinfo.h>
41 #include <sys/sysctl.h>
44 #include <sys/queue.h>
45 #include <sys/kthread.h>
46 #include <sys/syscallsubr.h>
47 #include <sys/sysproto.h>
49 #include <sys/signal.h>
50 #include <sys/syslog.h>
51 #include <sys/systm.h>
52 #include <sys/mutex.h>
53 #include <sys/callout.h>
56 #include <dev/kbd/kbdreg.h>
57 #include <dev/kbd/kbdtables.h>
59 #include "dev/hyperv/input/hv_kbdc.h"
61 #define HVKBD_MTX_LOCK(_m) do { \
65 #define HVKBD_MTX_UNLOCK(_m) do { \
69 #define HVKBD_MTX_ASSERT(_m, _t) do { \
73 #define HVKBD_LOCK() HVKBD_MTX_LOCK(&Giant)
74 #define HVKBD_UNLOCK() HVKBD_MTX_UNLOCK(&Giant)
75 #define HVKBD_LOCK_ASSERT() HVKBD_MTX_ASSERT(&Giant, MA_OWNED)
77 #define HVKBD_FLAG_POLLING 0x00000002
79 /* early keyboard probe, not supported */
81 hvkbd_configure(int flags)
86 /* detect a keyboard, not used */
88 hvkbd_probe(int unit, void *arg, int flags)
93 /* reset and initialize the device, not used */
95 hvkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
97 DEBUG_HVKBD(*kbdp, "%s\n", __func__);
101 /* test the interface to the device, not used */
103 hvkbd_test_if(keyboard_t *kbd)
105 DEBUG_HVKBD(kbd, "%s\n", __func__);
109 /* finish using this keyboard, not used */
111 hvkbd_term(keyboard_t *kbd)
113 DEBUG_HVKBD(kbd, "%s\n", __func__);
117 /* keyboard interrupt routine, not used */
119 hvkbd_intr(keyboard_t *kbd, void *arg)
121 DEBUG_HVKBD(kbd, "%s\n", __func__);
125 /* lock the access to the keyboard, not used */
127 hvkbd_lock(keyboard_t *kbd, int lock)
129 DEBUG_HVKBD(kbd, "%s\n", __func__);
133 /* save the internal state, not used */
135 hvkbd_get_state(keyboard_t *kbd, void *buf, size_t len)
137 DEBUG_HVKBD(kbd,"%s\n", __func__);
138 return (len == 0) ? 1 : -1;
141 /* set the internal state, not used */
143 hvkbd_set_state(keyboard_t *kbd, void *buf, size_t len)
145 DEBUG_HVKBD(kbd, "%s\n", __func__);
150 hvkbd_poll(keyboard_t *kbd, int on)
152 hv_kbd_sc *sc = kbd->kb_data;
156 * Keep a reference count on polling to allow recursive
157 * cngrab() during a panic for example.
161 else if (sc->sc_polling > 0)
164 if (sc->sc_polling != 0) {
165 sc->sc_flags |= HVKBD_FLAG_POLLING;
167 sc->sc_flags &= ~HVKBD_FLAG_POLLING;
174 * Enable the access to the device; until this function is called,
175 * the client cannot read from the keyboard.
178 hvkbd_enable(keyboard_t *kbd)
186 /* disallow the access to the device */
188 hvkbd_disable(keyboard_t *kbd)
190 DEBUG_HVKBD(kbd, "%s\n", __func__);
198 hvkbd_do_poll(hv_kbd_sc *sc, uint8_t wait)
200 while (!hv_kbd_prod_is_ready(sc)) {
201 hv_kbd_read_channel(sc->hs_chan, sc);
207 /* check if data is waiting */
208 /* Currently unused. */
210 hvkbd_check(keyboard_t *kbd)
212 DEBUG_HVKBD(kbd, "%s\n", __func__);
216 /* check if char is waiting */
218 hvkbd_check_char_locked(keyboard_t *kbd)
221 if (!KBD_IS_ACTIVE(kbd))
224 hv_kbd_sc *sc = kbd->kb_data;
225 if (sc->sc_flags & HVKBD_FLAG_POLLING)
226 hvkbd_do_poll(sc, 0);
227 if (hv_kbd_prod_is_ready(sc)) {
234 hvkbd_check_char(keyboard_t *kbd)
239 result = hvkbd_check_char_locked(kbd);
245 /* read char from the keyboard */
247 hvkbd_read_char_locked(keyboard_t *kbd, int wait)
249 uint32_t scancode = NOKEY;
251 hv_kbd_sc *sc = kbd->kb_data;
254 if (!KBD_IS_ACTIVE(kbd) || !hv_kbd_prod_is_ready(sc))
256 if (sc->sc_mode == K_RAW) {
257 if (hv_kbd_fetch_top(sc, &ks)) {
260 if ((ks.info & IS_E0) || (ks.info & IS_E1)) {
262 * Emulate the generation of E0 or E1 scancode,
263 * the real scancode will be consumed next time.
265 if (ks.info & IS_E0) {
266 scancode = XTKBD_EMUL0;
268 } else if (ks.info & IS_E1) {
269 scancode = XTKBD_EMUL1;
273 * Change the top item to avoid encountering
276 hv_kbd_modify_top(sc, &ks);
277 } else if (ks.info & IS_UNICODE) {
279 * XXX: Hyperv host send unicode to VM through
280 * 'Type clipboard text', the mapping from
281 * unicode to scancode depends on the keymap.
282 * It is so complicated that we do not plan to
286 device_printf(sc->dev, "Unsupported unicode\n");
287 hv_kbd_remove_top(sc);
290 scancode = ks.makecode;
291 if (ks.info & IS_BREAK) {
292 scancode |= XTKBD_RELEASE;
294 hv_kbd_remove_top(sc);
298 device_printf(sc->dev, "Unsupported mode: %d\n", sc->sc_mode);
301 DEBUG_HVKBD(kbd, "read scan: 0x%x\n", scancode);
305 /* Currently wait is always false. */
307 hvkbd_read_char(keyboard_t *kbd, int wait)
312 keycode = hvkbd_read_char_locked(kbd, wait);
318 /* clear the internal state of the keyboard */
320 hvkbd_clear_state(keyboard_t *kbd)
322 hv_kbd_sc *sc = kbd->kb_data;
323 sc->sc_state &= LOCK_MASK; /* preserve locking key state */
324 sc->sc_flags &= ~HVKBD_FLAG_POLLING;
328 hvkbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg)
331 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
332 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
335 hv_kbd_sc *sc = kbd->kb_data;
338 *(int *)arg = sc->sc_mode;
340 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
341 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
343 ival = IOCPARM_IVAL(arg);
344 arg = (caddr_t)&ival;
347 case KDSKBMODE: /* set keyboard mode */
348 DEBUG_HVKBD(kbd, "expected mode: %x\n", *(int *)arg);
349 switch (*(int *)arg) {
351 if (sc->sc_mode != K_XLATE) {
352 /* make lock key state and LED state match */
353 sc->sc_state &= ~LOCK_MASK;
354 sc->sc_state |= KBD_LED_VAL(kbd);
359 if (sc->sc_mode != *(int *)arg) {
360 DEBUG_HVKBD(kbd, "mod changed to %x\n", *(int *)arg);
361 if ((sc->sc_flags & HVKBD_FLAG_POLLING) == 0)
362 hvkbd_clear_state(kbd);
363 sc->sc_mode = *(int *)arg;
370 case KDGKBSTATE: /* get lock key state */
371 *(int *)arg = sc->sc_state & LOCK_MASK;
373 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
374 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
376 ival = IOCPARM_IVAL(arg);
377 arg = (caddr_t)&ival;
380 case KDSKBSTATE: /* set lock key state */
381 if (*(int *)arg & ~LOCK_MASK) {
384 sc->sc_state &= ~LOCK_MASK;
385 sc->sc_state |= *(int *)arg;
386 return hvkbd_ioctl_locked(kbd, KDSETLED, arg);
387 case KDGETLED: /* get keyboard LED */
388 *(int *)arg = KBD_LED_VAL(kbd);
390 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
391 defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
393 ival = IOCPARM_IVAL(arg);
394 arg = (caddr_t)&ival;
397 case KDSETLED: /* set keyboard LED */
398 /* NOTE: lock key state in "sc_state" won't be changed */
399 if (*(int *)arg & ~LOCK_MASK)
404 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */
405 if (sc->sc_mode == K_XLATE &&
406 kbd->kb_keymap->n_keys > ALTGR_OFFSET) {
412 if (KBD_HAS_DEVICE(kbd)) {
413 DEBUG_HVSC(sc, "setled 0x%x\n", *(int *)arg);
416 KBD_LED_VAL(kbd) = *(int *)arg;
419 return (genkbd_commonioctl(kbd, cmd, arg));
424 /* some useful control functions */
426 hvkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
428 DEBUG_HVKBD(kbd, "%s: %lx start\n", __func__, cmd);
430 int ret = hvkbd_ioctl_locked(kbd, cmd, arg);
432 DEBUG_HVKBD(kbd, "%s: %lx end %d\n", __func__, cmd, ret);
436 /* read one byte from the keyboard if it's allowed */
437 /* Currently unused. */
439 hvkbd_read(keyboard_t *kbd, int wait)
441 DEBUG_HVKBD(kbd, "%s\n", __func__);
443 if (!KBD_IS_ACTIVE(kbd))
445 return hvkbd_read_char_locked(kbd, wait);
448 static keyboard_switch_t hvkbdsw = {
449 hvkbd_probe, /* not used */
451 hvkbd_term, /* not used */
452 hvkbd_intr, /* not used */
453 hvkbd_test_if, /* not used */
461 hvkbd_lock, /* not used */
463 hvkbd_get_state, /* not used */
464 hvkbd_set_state, /* not used */
470 KEYBOARD_DRIVER(hvkbd, hvkbdsw, hvkbd_configure);
473 hv_kbd_intr(hv_kbd_sc *sc)
476 if ((sc->sc_flags & HVKBD_FLAG_POLLING) != 0)
479 if (KBD_IS_ACTIVE(&sc->sc_kbd) &&
480 KBD_IS_BUSY(&sc->sc_kbd)) {
481 /* let the callback function process the input */
482 (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT,
483 sc->sc_kbd.kb_callback.kc_arg);
485 /* read and discard the input, no one is waiting for it */
487 c = hvkbd_read_char(&sc->sc_kbd, 0);
488 } while (c != NOKEY);
493 hvkbd_driver_load(module_t mod, int what, void *arg)
497 kbd_add_driver(&hvkbd_kbd_driver);
500 kbd_delete_driver(&hvkbd_kbd_driver);
507 hv_kbd_drv_attach(device_t dev)
509 hv_kbd_sc *sc = device_get_softc(dev);
510 int unit = device_get_unit(dev);
511 keyboard_t *kbd = &sc->sc_kbd;
512 keyboard_switch_t *sw;
513 sw = kbd_get_switch(HVKBD_DRIVER_NAME);
518 kbd_init_struct(kbd, HVKBD_DRIVER_NAME, KB_OTHER, unit, 0, 0, 0);
519 kbd->kb_data = (void *)sc;
520 kbd_set_maps(kbd, &key_map, &accent_map, fkey_tab, nitems(fkey_tab));
521 KBD_FOUND_DEVICE(kbd);
522 hvkbd_clear_state(kbd);
528 if (kbd_register(kbd) < 0) {
531 KBD_CONFIG_DONE(kbd);
532 #ifdef KBD_INSTALL_CDEV
533 if (kbd_attach(kbd)) {
538 genkbd_diag(kbd, bootverbose);
542 hv_kbd_drv_detach(dev);
547 hv_kbd_drv_detach(device_t dev)
550 hv_kbd_sc *sc = device_get_softc(dev);
551 hvkbd_disable(&sc->sc_kbd);
552 if (KBD_IS_CONFIGURED(&sc->sc_kbd)) {
553 error = kbd_unregister(&sc->sc_kbd);
555 device_printf(dev, "WARNING: kbd_unregister() "
556 "returned non-zero! (ignored)\n");
559 #ifdef KBD_INSTALL_CDEV
560 error = kbd_detach(&sc->sc_kbd);