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 __FBSDID("$FreeBSD$"); 29 30 #include "opt_evdev.h" 31 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/conf.h> 35 #include <sys/uio.h> 36 #include <sys/bus.h> 37 #include <sys/malloc.h> 38 #include <sys/mbuf.h> 39 #include <sys/module.h> 40 #include <sys/limits.h> 41 #include <sys/lock.h> 42 #include <sys/taskqueue.h> 43 #include <sys/selinfo.h> 44 #include <sys/sysctl.h> 45 #include <sys/poll.h> 46 #include <sys/proc.h> 47 #include <sys/queue.h> 48 #include <sys/kthread.h> 49 #include <sys/syscallsubr.h> 50 #include <sys/sysproto.h> 51 #include <sys/sema.h> 52 #include <sys/signal.h> 53 #include <sys/syslog.h> 54 #include <sys/systm.h> 55 #include <sys/mutex.h> 56 #include <sys/callout.h> 57 58 #include <sys/kbio.h> 59 #include <dev/kbd/kbdreg.h> 60 #include <dev/kbd/kbdtables.h> 61 62 #ifdef EVDEV_SUPPORT 63 #include <dev/evdev/evdev.h> 64 #include <dev/evdev/input.h> 65 #endif 66 67 #include "dev/hyperv/input/hv_kbdc.h" 68 69 #define HVKBD_MTX_LOCK(_m) do { \ 70 mtx_lock(_m); \ 71 } while (0) 72 73 #define HVKBD_MTX_UNLOCK(_m) do { \ 74 mtx_unlock(_m); \ 75 } while (0) 76 77 #define HVKBD_MTX_ASSERT(_m, _t) do { \ 78 mtx_assert(_m, _t); \ 79 } while (0) 80 81 #define HVKBD_LOCK() HVKBD_MTX_LOCK(&Giant) 82 #define HVKBD_UNLOCK() HVKBD_MTX_UNLOCK(&Giant) 83 #define HVKBD_LOCK_ASSERT() HVKBD_MTX_ASSERT(&Giant, MA_OWNED) 84 85 #define HVKBD_FLAG_COMPOSE 0x00000001 /* compose char flag */ 86 #define HVKBD_FLAG_POLLING 0x00000002 87 88 #ifdef EVDEV_SUPPORT 89 static evdev_event_t hvkbd_ev_event; 90 91 static const struct evdev_methods hvkbd_evdev_methods = { 92 .ev_event = hvkbd_ev_event, 93 }; 94 #endif 95 96 /* early keyboard probe, not supported */ 97 static int 98 hvkbd_configure(int flags) 99 { 100 return (0); 101 } 102 103 /* detect a keyboard, not used */ 104 static int 105 hvkbd_probe(int unit, void *arg, int flags) 106 { 107 return (ENXIO); 108 } 109 110 /* reset and initialize the device, not used */ 111 static int 112 hvkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags) 113 { 114 DEBUG_HVKBD(*kbdp, "%s\n", __func__); 115 return (ENXIO); 116 } 117 118 /* test the interface to the device, not used */ 119 static int 120 hvkbd_test_if(keyboard_t *kbd) 121 { 122 DEBUG_HVKBD(kbd, "%s\n", __func__); 123 return (0); 124 } 125 126 /* finish using this keyboard, not used */ 127 static int 128 hvkbd_term(keyboard_t *kbd) 129 { 130 DEBUG_HVKBD(kbd, "%s\n", __func__); 131 return (ENXIO); 132 } 133 134 /* keyboard interrupt routine, not used */ 135 static int 136 hvkbd_intr(keyboard_t *kbd, void *arg) 137 { 138 DEBUG_HVKBD(kbd, "%s\n", __func__); 139 return (0); 140 } 141 142 /* lock the access to the keyboard, not used */ 143 static int 144 hvkbd_lock(keyboard_t *kbd, int lock) 145 { 146 DEBUG_HVKBD(kbd, "%s\n", __func__); 147 return (1); 148 } 149 150 /* save the internal state, not used */ 151 static int 152 hvkbd_get_state(keyboard_t *kbd, void *buf, size_t len) 153 { 154 DEBUG_HVKBD(kbd,"%s\n", __func__); 155 return (len == 0) ? 1 : -1; 156 } 157 158 /* set the internal state, not used */ 159 static int 160 hvkbd_set_state(keyboard_t *kbd, void *buf, size_t len) 161 { 162 DEBUG_HVKBD(kbd, "%s\n", __func__); 163 return (EINVAL); 164 } 165 166 static int 167 hvkbd_poll(keyboard_t *kbd, int on) 168 { 169 hv_kbd_sc *sc = kbd->kb_data; 170 171 HVKBD_LOCK(); 172 /* 173 * Keep a reference count on polling to allow recursive 174 * cngrab() during a panic for example. 175 */ 176 if (on) 177 sc->sc_polling++; 178 else if (sc->sc_polling > 0) 179 sc->sc_polling--; 180 181 if (sc->sc_polling != 0) { 182 sc->sc_flags |= HVKBD_FLAG_POLLING; 183 } else { 184 sc->sc_flags &= ~HVKBD_FLAG_POLLING; 185 } 186 HVKBD_UNLOCK(); 187 return (0); 188 } 189 190 /* 191 * Enable the access to the device; until this function is called, 192 * the client cannot read from the keyboard. 193 */ 194 static int 195 hvkbd_enable(keyboard_t *kbd) 196 { 197 HVKBD_LOCK(); 198 KBD_ACTIVATE(kbd); 199 HVKBD_UNLOCK(); 200 return (0); 201 } 202 203 /* disallow the access to the device */ 204 static int 205 hvkbd_disable(keyboard_t *kbd) 206 { 207 DEBUG_HVKBD(kbd, "%s\n", __func__); 208 HVKBD_LOCK(); 209 KBD_DEACTIVATE(kbd); 210 HVKBD_UNLOCK(); 211 return (0); 212 } 213 214 static void 215 hvkbd_do_poll(hv_kbd_sc *sc, uint8_t wait) 216 { 217 while (!hv_kbd_prod_is_ready(sc)) { 218 hv_kbd_read_channel(sc->hs_chan, sc); 219 if (!wait) 220 break; 221 } 222 } 223 224 /* check if data is waiting */ 225 /* Currently unused. */ 226 static int 227 hvkbd_check(keyboard_t *kbd) 228 { 229 DEBUG_HVKBD(kbd, "%s\n", __func__); 230 return (0); 231 } 232 233 /* check if char is waiting */ 234 static int 235 hvkbd_check_char_locked(keyboard_t *kbd) 236 { 237 HVKBD_LOCK_ASSERT(); 238 if (!KBD_IS_ACTIVE(kbd)) 239 return (FALSE); 240 241 hv_kbd_sc *sc = kbd->kb_data; 242 if (!(sc->sc_flags & HVKBD_FLAG_COMPOSE) && sc->sc_composed_char != 0) 243 return (TRUE); 244 if (sc->sc_flags & HVKBD_FLAG_POLLING) 245 hvkbd_do_poll(sc, 0); 246 if (hv_kbd_prod_is_ready(sc)) { 247 return (TRUE); 248 } 249 return (FALSE); 250 } 251 252 static int 253 hvkbd_check_char(keyboard_t *kbd) 254 { 255 int result; 256 257 HVKBD_LOCK(); 258 result = hvkbd_check_char_locked(kbd); 259 HVKBD_UNLOCK(); 260 261 return (result); 262 } 263 264 /* read char from the keyboard */ 265 static uint32_t 266 hvkbd_read_char_locked(keyboard_t *kbd, int wait) 267 { 268 uint32_t scancode = NOKEY; 269 uint32_t action; 270 keystroke ks; 271 hv_kbd_sc *sc = kbd->kb_data; 272 int keycode; 273 274 HVKBD_LOCK_ASSERT(); 275 276 if (!KBD_IS_ACTIVE(kbd) || !hv_kbd_prod_is_ready(sc)) 277 return (NOKEY); 278 279 next_code: 280 281 /* do we have a composed char to return? */ 282 if (!(sc->sc_flags & HVKBD_FLAG_COMPOSE) && sc->sc_composed_char > 0) { 283 action = sc->sc_composed_char; 284 sc->sc_composed_char = 0; 285 if (action > UCHAR_MAX) { 286 return (ERRKEY); 287 } 288 return (action); 289 } 290 291 if (hv_kbd_fetch_top(sc, &ks)) { 292 return (NOKEY); 293 } 294 if ((ks.info & IS_E0) || (ks.info & IS_E1)) { 295 /** 296 * Emulate the generation of E0 or E1 scancode, 297 * the real scancode will be consumed next time. 298 */ 299 if (ks.info & IS_E0) { 300 scancode = XTKBD_EMUL0; 301 ks.info &= ~IS_E0; 302 } else if (ks.info & IS_E1) { 303 scancode = XTKBD_EMUL1; 304 ks.info &= ~IS_E1; 305 } 306 /** 307 * Change the top item to avoid encountering 308 * E0 or E1 twice. 309 */ 310 hv_kbd_modify_top(sc, &ks); 311 } else if (ks.info & IS_UNICODE) { 312 /** 313 * XXX: Hyperv host send unicode to VM through 314 * 'Type clipboard text', the mapping from 315 * unicode to scancode depends on the keymap. 316 * It is so complicated that we do not plan to 317 * support it yet. 318 */ 319 if (bootverbose) 320 device_printf(sc->dev, "Unsupported unicode\n"); 321 hv_kbd_remove_top(sc); 322 return (NOKEY); 323 } else { 324 scancode = ks.makecode; 325 if (ks.info & IS_BREAK) { 326 scancode |= XTKBD_RELEASE; 327 } 328 hv_kbd_remove_top(sc); 329 } 330 #ifdef EVDEV_SUPPORT 331 /* push evdev event */ 332 if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD && 333 sc->ks_evdev != NULL) { 334 keycode = evdev_scancode2key(&sc->ks_evdev_state, 335 scancode); 336 337 if (keycode != KEY_RESERVED) { 338 evdev_push_event(sc->ks_evdev, EV_KEY, 339 (uint16_t)keycode, scancode & 0x80 ? 0 : 1); 340 evdev_sync(sc->ks_evdev); 341 } 342 } 343 if (sc->ks_evdev != NULL && evdev_is_grabbed(sc->ks_evdev)) 344 return (NOKEY); 345 #endif 346 ++kbd->kb_count; 347 DEBUG_HVKBD(kbd, "read scan: 0x%x\n", scancode); 348 349 /* return the byte as is for the K_RAW mode */ 350 if (sc->sc_mode == K_RAW) 351 return scancode; 352 353 /* translate the scan code into a keycode */ 354 keycode = scancode & 0x7F; 355 switch (sc->sc_prefix) { 356 case 0x00: /* normal scancode */ 357 switch(scancode) { 358 case 0xB8: /* left alt (compose key) released */ 359 if (sc->sc_flags & HVKBD_FLAG_COMPOSE) { 360 sc->sc_flags &= ~HVKBD_FLAG_COMPOSE; 361 if (sc->sc_composed_char > UCHAR_MAX) 362 sc->sc_composed_char = 0; 363 } 364 break; 365 case 0x38: /* left alt (compose key) pressed */ 366 if (!(sc->sc_flags & HVKBD_FLAG_COMPOSE)) { 367 sc->sc_flags |= HVKBD_FLAG_COMPOSE; 368 sc->sc_composed_char = 0; 369 } 370 break; 371 case 0xE0: 372 case 0xE1: 373 sc->sc_prefix = scancode; 374 goto next_code; 375 } 376 break; 377 case 0xE0: /* 0xE0 prefix */ 378 sc->sc_prefix = 0; 379 switch (keycode) { 380 case 0x1C: /* right enter key */ 381 keycode = 0x59; 382 break; 383 case 0x1D: /* right ctrl key */ 384 keycode = 0x5A; 385 break; 386 case 0x35: /* keypad divide key */ 387 keycode = 0x5B; 388 break; 389 case 0x37: /* print scrn key */ 390 keycode = 0x5C; 391 break; 392 case 0x38: /* right alt key (alt gr) */ 393 keycode = 0x5D; 394 break; 395 case 0x46: /* ctrl-pause/break on AT 101 (see below) */ 396 keycode = 0x68; 397 break; 398 case 0x47: /* grey home key */ 399 keycode = 0x5E; 400 break; 401 case 0x48: /* grey up arrow key */ 402 keycode = 0x5F; 403 break; 404 case 0x49: /* grey page up key */ 405 keycode = 0x60; 406 break; 407 case 0x4B: /* grey left arrow key */ 408 keycode = 0x61; 409 break; 410 case 0x4D: /* grey right arrow key */ 411 keycode = 0x62; 412 break; 413 case 0x4F: /* grey end key */ 414 keycode = 0x63; 415 break; 416 case 0x50: /* grey down arrow key */ 417 keycode = 0x64; 418 break; 419 case 0x51: /* grey page down key */ 420 keycode = 0x65; 421 break; 422 case 0x52: /* grey insert key */ 423 keycode = 0x66; 424 break; 425 case 0x53: /* grey delete key */ 426 keycode = 0x67; 427 break; 428 /* the following 3 are only used on the MS "Natural" keyboard */ 429 case 0x5b: /* left Window key */ 430 keycode = 0x69; 431 break; 432 case 0x5c: /* right Window key */ 433 keycode = 0x6a; 434 break; 435 case 0x5d: /* menu key */ 436 keycode = 0x6b; 437 break; 438 case 0x5e: /* power key */ 439 keycode = 0x6d; 440 break; 441 case 0x5f: /* sleep key */ 442 keycode = 0x6e; 443 break; 444 case 0x63: /* wake key */ 445 keycode = 0x6f; 446 break; 447 default: /* ignore everything else */ 448 goto next_code; 449 } 450 break; 451 case 0xE1: /* 0xE1 prefix */ 452 /* 453 * The pause/break key on the 101 keyboard produces: 454 * E1-1D-45 E1-9D-C5 455 * Ctrl-pause/break produces: 456 * E0-46 E0-C6 (See above.) 457 */ 458 sc->sc_prefix = 0; 459 if (keycode == 0x1D) 460 sc->sc_prefix = 0x1D; 461 goto next_code; 462 /* NOT REACHED */ 463 case 0x1D: /* pause / break */ 464 sc->sc_prefix = 0; 465 if (keycode != 0x45) 466 goto next_code; 467 keycode = 0x68; 468 break; 469 } 470 471 /* XXX assume 101/102 keys AT keyboard */ 472 switch (keycode) { 473 case 0x5c: /* print screen */ 474 if (sc->sc_flags & ALTS) 475 keycode = 0x54; /* sysrq */ 476 break; 477 case 0x68: /* pause/break */ 478 if (sc->sc_flags & CTLS) 479 keycode = 0x6c; /* break */ 480 break; 481 } 482 483 /* return the key code in the K_CODE mode */ 484 if (sc->sc_mode == K_CODE) 485 return (keycode | (scancode & 0x80)); 486 487 /* compose a character code */ 488 if (sc->sc_flags & HVKBD_FLAG_COMPOSE) { 489 switch (keycode | (scancode & 0x80)) { 490 /* key pressed, process it */ 491 case 0x47: case 0x48: case 0x49: /* keypad 7,8,9 */ 492 sc->sc_composed_char *= 10; 493 sc->sc_composed_char += keycode - 0x40; 494 if (sc->sc_composed_char > UCHAR_MAX) 495 return ERRKEY; 496 goto next_code; 497 case 0x4B: case 0x4C: case 0x4D: /* keypad 4,5,6 */ 498 sc->sc_composed_char *= 10; 499 sc->sc_composed_char += keycode - 0x47; 500 if (sc->sc_composed_char > UCHAR_MAX) 501 return ERRKEY; 502 goto next_code; 503 case 0x4F: case 0x50: case 0x51: /* keypad 1,2,3 */ 504 sc->sc_composed_char *= 10; 505 sc->sc_composed_char += keycode - 0x4E; 506 if (sc->sc_composed_char > UCHAR_MAX) 507 return ERRKEY; 508 goto next_code; 509 case 0x52: /* keypad 0 */ 510 sc->sc_composed_char *= 10; 511 if (sc->sc_composed_char > UCHAR_MAX) 512 return ERRKEY; 513 goto next_code; 514 515 /* key released, no interest here */ 516 case 0xC7: case 0xC8: case 0xC9: /* keypad 7,8,9 */ 517 case 0xCB: case 0xCC: case 0xCD: /* keypad 4,5,6 */ 518 case 0xCF: case 0xD0: case 0xD1: /* keypad 1,2,3 */ 519 case 0xD2: /* keypad 0 */ 520 goto next_code; 521 522 case 0x38: /* left alt key */ 523 break; 524 525 default: 526 if (sc->sc_composed_char > 0) { 527 sc->sc_flags &= ~HVKBD_FLAG_COMPOSE; 528 sc->sc_composed_char = 0; 529 return (ERRKEY); 530 } 531 break; 532 } 533 } 534 535 /* keycode to key action */ 536 action = genkbd_keyaction(kbd, keycode, scancode & 0x80, 537 &sc->sc_state, &sc->sc_accents); 538 if (action == NOKEY) 539 goto next_code; 540 else 541 return (action); 542 } 543 544 /* Currently wait is always false. */ 545 static uint32_t 546 hvkbd_read_char(keyboard_t *kbd, int wait) 547 { 548 uint32_t keycode; 549 550 HVKBD_LOCK(); 551 keycode = hvkbd_read_char_locked(kbd, wait); 552 HVKBD_UNLOCK(); 553 554 return (keycode); 555 } 556 557 /* clear the internal state of the keyboard */ 558 static void 559 hvkbd_clear_state(keyboard_t *kbd) 560 { 561 hv_kbd_sc *sc = kbd->kb_data; 562 sc->sc_state &= LOCK_MASK; /* preserve locking key state */ 563 sc->sc_flags &= ~(HVKBD_FLAG_POLLING | HVKBD_FLAG_COMPOSE); 564 sc->sc_accents = 0; 565 sc->sc_composed_char = 0; 566 } 567 568 static int 569 hvkbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg) 570 { 571 int i; 572 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 573 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 574 int ival; 575 #endif 576 hv_kbd_sc *sc = kbd->kb_data; 577 switch (cmd) { 578 case KDGKBMODE: 579 *(int *)arg = sc->sc_mode; 580 break; 581 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 582 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 583 case _IO('K', 7): 584 ival = IOCPARM_IVAL(arg); 585 arg = (caddr_t)&ival; 586 /* FALLTHROUGH */ 587 #endif 588 case KDSKBMODE: /* set keyboard mode */ 589 DEBUG_HVKBD(kbd, "expected mode: %x\n", *(int *)arg); 590 switch (*(int *)arg) { 591 case K_XLATE: 592 if (sc->sc_mode != K_XLATE) { 593 /* make lock key state and LED state match */ 594 sc->sc_state &= ~LOCK_MASK; 595 sc->sc_state |= KBD_LED_VAL(kbd); 596 } 597 /* FALLTHROUGH */ 598 case K_RAW: 599 case K_CODE: 600 if (sc->sc_mode != *(int *)arg) { 601 DEBUG_HVKBD(kbd, "mod changed to %x\n", *(int *)arg); 602 if ((sc->sc_flags & HVKBD_FLAG_POLLING) == 0) 603 hvkbd_clear_state(kbd); 604 sc->sc_mode = *(int *)arg; 605 } 606 break; 607 default: 608 return (EINVAL); 609 } 610 break; 611 case KDGKBSTATE: /* get lock key state */ 612 *(int *)arg = sc->sc_state & LOCK_MASK; 613 break; 614 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 615 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 616 case _IO('K', 20): 617 ival = IOCPARM_IVAL(arg); 618 arg = (caddr_t)&ival; 619 /* FALLTHROUGH */ 620 #endif 621 case KDSKBSTATE: /* set lock key state */ 622 if (*(int *)arg & ~LOCK_MASK) { 623 return (EINVAL); 624 } 625 sc->sc_state &= ~LOCK_MASK; 626 sc->sc_state |= *(int *)arg; 627 return hvkbd_ioctl_locked(kbd, KDSETLED, arg); 628 case KDGETLED: /* get keyboard LED */ 629 *(int *)arg = KBD_LED_VAL(kbd); 630 break; 631 #if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 632 defined(COMPAT_FREEBSD4) || defined(COMPAT_43) 633 case _IO('K', 66): 634 ival = IOCPARM_IVAL(arg); 635 arg = (caddr_t)&ival; 636 /* FALLTHROUGH */ 637 #endif 638 case KDSETLED: /* set keyboard LED */ 639 /* NOTE: lock key state in "sc_state" won't be changed */ 640 if (*(int *)arg & ~LOCK_MASK) 641 return (EINVAL); 642 643 i = *(int *)arg; 644 645 /* replace CAPS LED with ALTGR LED for ALTGR keyboards */ 646 if (sc->sc_mode == K_XLATE && 647 kbd->kb_keymap->n_keys > ALTGR_OFFSET) { 648 if (i & ALKED) 649 i |= CLKED; 650 else 651 i &= ~CLKED; 652 } 653 if (KBD_HAS_DEVICE(kbd)) { 654 DEBUG_HVSC(sc, "setled 0x%x\n", *(int *)arg); 655 } 656 657 #ifdef EVDEV_SUPPORT 658 /* push LED states to evdev */ 659 if (sc->ks_evdev != NULL && 660 evdev_rcpt_mask & EVDEV_RCPT_HW_KBD) 661 evdev_push_leds(sc->ks_evdev, *(int *)arg); 662 #endif 663 KBD_LED_VAL(kbd) = *(int *)arg; 664 break; 665 case PIO_KEYMAP: /* set keyboard translation table */ 666 case OPIO_KEYMAP: /* set keyboard translation table (compat) */ 667 case PIO_KEYMAPENT: /* set keyboard translation table entry */ 668 case PIO_DEADKEYMAP: /* set accent key translation table */ 669 case OPIO_DEADKEYMAP: /* set accent key translation table (compat) */ 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 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 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 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 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 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 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 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