1 /*- 2 * (MPSAFE) 3 * 4 * Copyright (c) 2005 Maksim Yevmenkin <m_evmenkin@yahoo.com> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $Id: kbdmux.c,v 1.4 2005/07/14 17:38:35 max Exp $ 29 * $FreeBSD$ 30 */ 31 32 #include "opt_evdev.h" 33 #include "opt_kbd.h" 34 35 #include <sys/param.h> 36 #include <sys/bus.h> 37 #include <sys/conf.h> 38 #include <sys/consio.h> 39 #include <sys/fcntl.h> 40 #include <sys/kbio.h> 41 #include <sys/kernel.h> 42 #include <sys/limits.h> 43 #include <sys/lock.h> 44 #include <sys/malloc.h> 45 #include <sys/module.h> 46 #include <sys/mutex.h> 47 #include <sys/poll.h> 48 #include <sys/proc.h> 49 #include <sys/queue.h> 50 #include <sys/event.h> 51 #include <sys/systm.h> 52 #include <sys/taskqueue.h> 53 #include <sys/uio.h> 54 #include <dev/misc/kbd/kbdreg.h> 55 #include <dev/misc/kbd/kbdtables.h> 56 57 #ifdef EVDEV_SUPPORT 58 #include <dev/misc/evdev/evdev.h> 59 #include <dev/misc/evdev/input.h> 60 #endif 61 62 #define KEYBOARD_NAME "kbdmux" 63 64 MALLOC_DECLARE(M_KBDMUX); 65 MALLOC_DEFINE(M_KBDMUX, KEYBOARD_NAME, "Keyboard multiplexor"); 66 67 /***************************************************************************** 68 ***************************************************************************** 69 ** Keyboard state 70 ***************************************************************************** 71 *****************************************************************************/ 72 73 #define KBDMUX_Q_SIZE 512 /* input queue size */ 74 75 /* 76 * kbdmux keyboard 77 */ 78 struct kbdmux_kbd 79 { 80 keyboard_t *kbd; /* keyboard */ 81 SLIST_ENTRY(kbdmux_kbd) next; /* link to next */ 82 }; 83 84 typedef struct kbdmux_kbd kbdmux_kbd_t; 85 86 /* 87 * kbdmux state 88 */ 89 struct kbdmux_state 90 { 91 char ks_inq[KBDMUX_Q_SIZE]; /* input chars queue */ 92 unsigned int ks_inq_start; 93 unsigned int ks_inq_length; 94 struct task ks_task; /* interrupt task */ 95 96 int ks_flags; /* flags */ 97 #define COMPOSE (1 << 0) /* compose char flag */ 98 #define POLLING (1 << 1) /* polling */ 99 100 int ks_mode; /* K_XLATE, K_RAW, K_CODE */ 101 int ks_state; /* state */ 102 int ks_accents; /* accent key index (> 0) */ 103 u_int ks_composed_char; /* composed char code */ 104 u_char ks_prefix; /* AT scan code prefix */ 105 106 #ifdef EVDEV_SUPPORT 107 struct evdev_dev * ks_evdev; 108 int ks_evdev_state; 109 #endif 110 111 SLIST_HEAD(, kbdmux_kbd) ks_kbds; /* keyboards */ 112 }; 113 114 typedef struct kbdmux_state kbdmux_state_t; 115 116 /***************************************************************************** 117 ***************************************************************************** 118 ** Helper functions 119 ***************************************************************************** 120 *****************************************************************************/ 121 122 static task_fn_t kbdmux_kbd_intr; 123 static kbd_callback_func_t kbdmux_kbd_event; 124 125 static void 126 kbdmux_kbd_putc(kbdmux_state_t *state, char c) 127 { 128 unsigned int p; 129 130 if (state->ks_inq_length == KBDMUX_Q_SIZE) 131 return; 132 133 p = (state->ks_inq_start + state->ks_inq_length) % KBDMUX_Q_SIZE; 134 state->ks_inq[p] = c; 135 state->ks_inq_length++; 136 } 137 138 static int 139 kbdmux_kbd_getc(kbdmux_state_t *state) 140 { 141 unsigned char c; 142 143 if (state->ks_inq_length == 0) 144 return (-1); 145 146 c = state->ks_inq[state->ks_inq_start]; 147 state->ks_inq_start = (state->ks_inq_start + 1) % KBDMUX_Q_SIZE; 148 state->ks_inq_length--; 149 150 return (c); 151 } 152 153 /* 154 * Interrupt handler task 155 */ 156 static void 157 kbdmux_kbd_intr(void *xkbd, int pending) 158 { 159 keyboard_t *kbd = (keyboard_t *) xkbd; 160 KBD_LOCK_DECLARE; 161 162 KBD_LOCK(kbd); /* recursive so ok */ 163 kbd_intr(kbd, NULL); 164 KBD_UNLOCK(kbd); 165 } 166 167 /* 168 * Process event from one of our keyboards 169 */ 170 static int 171 kbdmux_kbd_event(keyboard_t *kbd, int event, void *arg) 172 { 173 kbdmux_state_t *state = (kbdmux_state_t *) arg; 174 175 switch (event) { 176 case KBDIO_KEYINPUT: { 177 int c; 178 179 /* 180 * Read all chars from the keyboard 181 * 182 * Turns out that atkbd(4) check_char() method may return 183 * "true" while read_char() method returns NOKEY. If this 184 * happens we could stuck in the loop below. Avoid this 185 * by breaking out of the loop if read_char() method returns 186 * NOKEY. 187 */ 188 189 while (kbd_check_char(kbd)) { 190 c = kbd_read_char(kbd, 0); 191 if (c == NOKEY) 192 break; 193 if (c == ERRKEY) 194 continue; /* XXX ring bell */ 195 if (!KBD_IS_BUSY(kbd)) 196 continue; /* not open - discard the input */ 197 198 kbdmux_kbd_putc(state, c); 199 } 200 201 /* queue interrupt task if needed */ 202 if (state->ks_inq_length > 0) 203 taskqueue_enqueue(taskqueue_swi, &state->ks_task); 204 205 } break; 206 207 case KBDIO_UNLOADING: { 208 kbdmux_kbd_t *k; 209 210 SLIST_FOREACH(k, &state->ks_kbds, next) 211 if (k->kbd == kbd) 212 break; 213 214 if (k != NULL) { 215 kbd_release(k->kbd, &k->kbd); 216 SLIST_REMOVE(&state->ks_kbds, k, kbdmux_kbd, next); 217 218 k->kbd = NULL; 219 220 kfree(k, M_KBDMUX); 221 } 222 223 } break; 224 225 default: 226 return (EINVAL); 227 /* NOT REACHED */ 228 } 229 return (0); 230 } 231 232 /**************************************************************************** 233 **************************************************************************** 234 ** Keyboard driver 235 **************************************************************************** 236 ****************************************************************************/ 237 238 static int kbdmux_configure(int flags); 239 static kbd_probe_t kbdmux_probe; 240 static kbd_init_t kbdmux_init; 241 static kbd_term_t kbdmux_term; 242 static kbd_intr_t kbdmux_intr; 243 static kbd_test_if_t kbdmux_test_if; 244 static kbd_enable_t kbdmux_enable; 245 static kbd_disable_t kbdmux_disable; 246 static kbd_read_t kbdmux_read; 247 static kbd_check_t kbdmux_check; 248 static kbd_read_char_t kbdmux_read_char; 249 static kbd_check_char_t kbdmux_check_char; 250 static kbd_ioctl_t kbdmux_ioctl; 251 static kbd_lock_t kbdmux_lock; 252 static kbd_clear_state_t kbdmux_clear_state; 253 static kbd_get_state_t kbdmux_get_state; 254 static kbd_set_state_t kbdmux_set_state; 255 static kbd_poll_mode_t kbdmux_poll; 256 257 static keyboard_switch_t kbdmuxsw = { 258 .probe = kbdmux_probe, 259 .init = kbdmux_init, 260 .term = kbdmux_term, 261 .intr = kbdmux_intr, 262 .test_if = kbdmux_test_if, 263 .enable = kbdmux_enable, 264 .disable = kbdmux_disable, 265 .read = kbdmux_read, 266 .check = kbdmux_check, 267 .read_char = kbdmux_read_char, 268 .check_char = kbdmux_check_char, 269 .ioctl = kbdmux_ioctl, 270 .lock = kbdmux_lock, 271 .clear_state = kbdmux_clear_state, 272 .get_state = kbdmux_get_state, 273 .set_state = kbdmux_set_state, 274 .get_fkeystr = genkbd_get_fkeystr, 275 .poll = kbdmux_poll, 276 .diag = genkbd_diag, 277 }; 278 279 #ifdef EVDEV_SUPPORT 280 static const struct evdev_methods kbdmux_evdev_methods = { 281 .ev_event = evdev_ev_kbd_event, 282 }; 283 #endif 284 285 /* 286 * Return the number of found keyboards 287 */ 288 static int 289 kbdmux_configure(int flags) 290 { 291 return (1); 292 } 293 294 /* 295 * Detect a keyboard 296 */ 297 static int 298 kbdmux_probe(int unit, void *arg, int flags) 299 { 300 if (resource_disabled(KEYBOARD_NAME, unit)) 301 return (ENXIO); 302 303 return (0); 304 } 305 306 /* 307 * Reset and initialize the keyboard (stolen from atkbd.c) 308 * 309 * Called without kbd lock held. 310 */ 311 static int 312 kbdmux_init(int unit, keyboard_t **kbdp, void *arg, int flags) 313 { 314 kbdmux_state_t *state = NULL; 315 keymap_t *keymap = NULL; 316 accentmap_t *accmap = NULL; 317 fkeytab_t *fkeymap = NULL; 318 keyboard_t *kbd = NULL; 319 int error, needfree, fkeymap_size, delay[2]; 320 #ifdef EVDEV_SUPPORT 321 struct evdev_dev *evdev; 322 char phys_loc[NAMELEN]; 323 #endif 324 325 if (*kbdp == NULL) { 326 *kbdp = kbd = kmalloc(sizeof(*kbd), M_KBDMUX, M_NOWAIT | M_ZERO); 327 state = kmalloc(sizeof(*state), M_KBDMUX, M_NOWAIT | M_ZERO); 328 keymap = kmalloc(sizeof(key_map), M_KBDMUX, M_NOWAIT); 329 accmap = kmalloc(sizeof(accent_map), M_KBDMUX, M_NOWAIT); 330 fkeymap = kmalloc(sizeof(fkey_tab), M_KBDMUX, M_NOWAIT); 331 fkeymap_size = NELEM(fkey_tab); 332 needfree = 1; 333 334 if ((kbd == NULL) || (state == NULL) || (keymap == NULL) || 335 (accmap == NULL) || (fkeymap == NULL)) { 336 error = ENOMEM; 337 goto bad; 338 } 339 340 TASK_INIT(&state->ks_task, 0, kbdmux_kbd_intr, (void *) kbd); 341 SLIST_INIT(&state->ks_kbds); 342 } else if (KBD_IS_INITIALIZED(*kbdp) && KBD_IS_CONFIGURED(*kbdp)) { 343 return (0); 344 } else { 345 kbd = *kbdp; 346 state = (kbdmux_state_t *) kbd->kb_data; 347 keymap = kbd->kb_keymap; 348 accmap = kbd->kb_accentmap; 349 fkeymap = kbd->kb_fkeytab; 350 fkeymap_size = kbd->kb_fkeytab_size; 351 needfree = 0; 352 } 353 354 if (!KBD_IS_PROBED(kbd)) { 355 /* XXX assume 101/102 keys keyboard */ 356 kbd_init_struct(kbd, KEYBOARD_NAME, KB_101, unit, flags, 357 KB_PRI_MUX, 0, 0); 358 bcopy(&key_map, keymap, sizeof(key_map)); 359 bcopy(&accent_map, accmap, sizeof(accent_map)); 360 bcopy(fkey_tab, fkeymap, 361 imin(fkeymap_size*sizeof(fkeymap[0]), sizeof(fkey_tab))); 362 kbd_set_maps(kbd, keymap, accmap, fkeymap, fkeymap_size); 363 kbd->kb_data = (void *)state; 364 365 KBD_FOUND_DEVICE(kbd); 366 KBD_PROBE_DONE(kbd); 367 368 kbdmux_clear_state(kbd); 369 state->ks_mode = K_XLATE; 370 } 371 372 if (!KBD_IS_INITIALIZED(kbd) && !(flags & KB_CONF_PROBE_ONLY)) { 373 kbd->kb_config = flags & ~KB_CONF_PROBE_ONLY; 374 375 kbdmux_ioctl(kbd, KDSETLED, (caddr_t)&state->ks_state); 376 377 delay[0] = kbd->kb_delay1; 378 delay[1] = kbd->kb_delay2; 379 kbdmux_ioctl(kbd, KDSETREPEAT, (caddr_t)delay); 380 381 #ifdef EVDEV_SUPPORT 382 /* register as evdev provider */ 383 evdev = evdev_alloc(); 384 evdev_set_name(evdev, "System keyboard multiplexer"); 385 ksnprintf(phys_loc, NAMELEN, KEYBOARD_NAME"%d", unit); 386 evdev_set_phys(evdev, phys_loc); 387 evdev_set_id(evdev, BUS_VIRTUAL, 0, 0, 0); 388 evdev_set_methods(evdev, kbd, &kbdmux_evdev_methods); 389 evdev_support_event(evdev, EV_SYN); 390 evdev_support_event(evdev, EV_KEY); 391 evdev_support_event(evdev, EV_LED); 392 evdev_support_event(evdev, EV_REP); 393 evdev_support_all_known_keys(evdev); 394 evdev_support_led(evdev, LED_NUML); 395 evdev_support_led(evdev, LED_CAPSL); 396 evdev_support_led(evdev, LED_SCROLLL); 397 398 if (evdev_register(evdev)) 399 evdev_free(evdev); 400 else 401 state->ks_evdev = evdev; 402 state->ks_evdev_state = 0; 403 #endif 404 405 KBD_INIT_DONE(kbd); 406 } 407 408 if (!KBD_IS_CONFIGURED(kbd)) { 409 if (kbd_register(kbd) < 0) { 410 error = ENXIO; 411 goto bad; 412 } 413 414 KBD_CONFIG_DONE(kbd); 415 } 416 417 return (0); 418 bad: 419 if (needfree) { 420 if (state != NULL) 421 kfree(state, M_KBDMUX); 422 if (keymap != NULL) 423 kfree(keymap, M_KBDMUX); 424 if (accmap != NULL) 425 kfree(accmap, M_KBDMUX); 426 if (fkeymap != NULL) 427 kfree(fkeymap, M_KBDMUX); 428 if (kbd != NULL) { 429 kfree(kbd, M_KBDMUX); 430 *kbdp = NULL; /* insure ref doesn't leak to caller */ 431 } 432 } 433 434 return (error); 435 } 436 437 /* 438 * Finish using this keyboard 439 * 440 * NOTE: deregistration automatically unlocks lock. 441 */ 442 static int 443 kbdmux_term(keyboard_t *kbd) 444 { 445 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 446 kbdmux_kbd_t *k; 447 448 /* wait for interrupt task */ 449 while (taskqueue_cancel(taskqueue_swi, &state->ks_task, NULL) != 0) 450 taskqueue_drain(taskqueue_swi, &state->ks_task); 451 452 /* release all keyboards from the mux */ 453 while ((k = SLIST_FIRST(&state->ks_kbds)) != NULL) { 454 kbd_release(k->kbd, &k->kbd); 455 SLIST_REMOVE_HEAD(&state->ks_kbds, next); 456 457 k->kbd = NULL; 458 459 kfree(k, M_KBDMUX); 460 } 461 462 kbd_unregister(kbd); 463 464 #ifdef EVDEV_SUPPORT 465 evdev_free(state->ks_evdev); 466 #endif 467 468 bzero(state, sizeof(*state)); 469 kfree(state, M_KBDMUX); 470 471 kfree(kbd->kb_keymap, M_KBDMUX); 472 kfree(kbd->kb_accentmap, M_KBDMUX); 473 kfree(kbd->kb_fkeytab, M_KBDMUX); 474 kfree(kbd, M_KBDMUX); 475 476 return (0); 477 } 478 479 /* 480 * Keyboard interrupt routine 481 */ 482 static int 483 kbdmux_intr(keyboard_t *kbd, void *arg) 484 { 485 int c; 486 487 if (KBD_IS_ACTIVE(kbd) && KBD_IS_BUSY(kbd)) { 488 /* let the callback function to process the input */ 489 (*kbd->kb_callback.kc_func)(kbd, KBDIO_KEYINPUT, 490 kbd->kb_callback.kc_arg); 491 } else { 492 /* read and discard the input; no one is waiting for input */ 493 do { 494 c = kbdmux_read_char(kbd, FALSE); 495 } while (c != NOKEY); 496 } 497 498 return (0); 499 } 500 501 /* 502 * Test the interface to the device 503 */ 504 static int 505 kbdmux_test_if(keyboard_t *kbd) 506 { 507 return (0); 508 } 509 510 /* 511 * Enable the access to the device; until this function is called, 512 * the client cannot read from the keyboard. 513 */ 514 static int 515 kbdmux_enable(keyboard_t *kbd) 516 { 517 KBD_ACTIVATE(kbd); 518 return (0); 519 } 520 521 /* 522 * Disallow the access to the device 523 */ 524 static int 525 kbdmux_disable(keyboard_t *kbd) 526 { 527 KBD_DEACTIVATE(kbd); 528 return (0); 529 } 530 531 /* 532 * Read one byte from the keyboard if it's allowed 533 */ 534 static int 535 kbdmux_read(keyboard_t *kbd, int wait) 536 { 537 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 538 int c, ret; 539 540 do { 541 c = kbdmux_kbd_getc(state); 542 } while (c == -1 && wait); 543 544 if (c != -1) 545 kbd->kb_count++; 546 547 ret = (KBD_IS_ACTIVE(kbd)? c : -1); 548 549 return ret; 550 } 551 552 /* 553 * Check if data is waiting 554 */ 555 static int 556 kbdmux_check(keyboard_t *kbd) 557 { 558 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 559 int ready; 560 561 if (!KBD_IS_ACTIVE(kbd)) 562 return (FALSE); 563 564 ready = (state->ks_inq_length > 0) ? TRUE : FALSE; 565 566 return (ready); 567 } 568 569 /* 570 * Read char from the keyboard (stolen from atkbd.c) 571 * 572 * Note: We do not attempt to detect the case where no keyboards are 573 * present in the wait case. If the kernel is sitting at the 574 * debugger prompt we want someone to be able to plug in a keyboard 575 * and have it work, and not just panic or fall through or do 576 * something equally nasty. 577 */ 578 static u_int 579 kbdmux_read_char(keyboard_t *kbd, int wait) 580 { 581 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 582 u_int action; 583 int scancode, keycode; 584 585 next_code: 586 587 /* do we have a composed char to return? */ 588 if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0)) { 589 action = state->ks_composed_char; 590 state->ks_composed_char = 0; 591 if (action > UCHAR_MAX) { 592 return (ERRKEY); 593 } 594 return (action); 595 } 596 597 /* 598 * See if there is something in the keyboard queue 599 */ 600 scancode = kbdmux_kbd_getc(state); 601 602 if (scancode == -1) { 603 if (state->ks_flags & POLLING) { 604 kbdmux_kbd_t *k; 605 606 SLIST_FOREACH(k, &state->ks_kbds, next) { 607 while (kbd_check_char(k->kbd)) { 608 scancode = kbd_read_char(k->kbd, 0); 609 if (scancode == ERRKEY) 610 continue; 611 if (scancode == NOKEY) 612 break; 613 if (!KBD_IS_BUSY(k->kbd)) 614 continue; 615 kbdmux_kbd_putc(state, scancode); 616 } 617 } 618 619 if (state->ks_inq_length > 0) 620 goto next_code; 621 if (wait) 622 goto next_code; 623 } else { 624 if (wait) { 625 lksleep(&state->ks_task, &kbd->kb_lock, PCATCH, 626 "kbdwai", hz/10); 627 goto next_code; 628 } 629 } 630 return (NOKEY); 631 } 632 633 kbd->kb_count++; 634 635 #ifdef EVDEV_SUPPORT 636 /* push evdev event */ 637 if (evdev_rcpt_mask & EVDEV_RCPT_KBDMUX && state->ks_evdev != NULL) { 638 uint16_t key = evdev_scancode2key(&state->ks_evdev_state, 639 scancode); 640 641 if (key != KEY_RESERVED) { 642 evdev_push_event(state->ks_evdev, EV_KEY, 643 key, scancode & 0x80 ? 0 : 1); 644 evdev_sync(state->ks_evdev); 645 } 646 } 647 #endif 648 649 /* return the byte as is for the K_RAW mode */ 650 if (state->ks_mode == K_RAW) 651 return (scancode); 652 653 /* translate the scan code into a keycode */ 654 keycode = scancode & 0x7F; 655 switch (state->ks_prefix) { 656 case 0x00: /* normal scancode */ 657 switch(scancode) { 658 case 0xB8: /* left alt (compose key) released */ 659 if (state->ks_flags & COMPOSE) { 660 state->ks_flags &= ~COMPOSE; 661 if (state->ks_composed_char > UCHAR_MAX) 662 state->ks_composed_char = 0; 663 } 664 break; 665 case 0x38: /* left alt (compose key) pressed */ 666 if (!(state->ks_flags & COMPOSE)) { 667 state->ks_flags |= COMPOSE; 668 state->ks_composed_char = 0; 669 } 670 break; 671 case 0xE0: 672 case 0xE1: 673 state->ks_prefix = scancode; 674 goto next_code; 675 } 676 break; 677 case 0xE0: /* 0xE0 prefix */ 678 state->ks_prefix = 0; 679 switch (keycode) { 680 case 0x1C: /* right enter key */ 681 keycode = 0x59; 682 break; 683 case 0x1D: /* right ctrl key */ 684 keycode = 0x5A; 685 break; 686 case 0x35: /* keypad divide key */ 687 keycode = 0x5B; 688 break; 689 case 0x37: /* print scrn key */ 690 keycode = 0x5C; 691 break; 692 case 0x38: /* right alt key (alt gr) */ 693 keycode = 0x5D; 694 break; 695 case 0x46: /* ctrl-pause/break on AT 101 (see below) */ 696 keycode = 0x68; 697 break; 698 case 0x47: /* grey home key */ 699 keycode = 0x5E; 700 break; 701 case 0x48: /* grey up arrow key */ 702 keycode = 0x5F; 703 break; 704 case 0x49: /* grey page up key */ 705 keycode = 0x60; 706 break; 707 case 0x4B: /* grey left arrow key */ 708 keycode = 0x61; 709 break; 710 case 0x4D: /* grey right arrow key */ 711 keycode = 0x62; 712 break; 713 case 0x4F: /* grey end key */ 714 keycode = 0x63; 715 break; 716 case 0x50: /* grey down arrow key */ 717 keycode = 0x64; 718 break; 719 case 0x51: /* grey page down key */ 720 keycode = 0x65; 721 break; 722 case 0x52: /* grey insert key */ 723 keycode = 0x66; 724 break; 725 case 0x53: /* grey delete key */ 726 keycode = 0x67; 727 break; 728 /* the following 3 are only used on the MS "Natural" keyboard */ 729 case 0x5b: /* left Window key */ 730 keycode = 0x69; 731 break; 732 case 0x5c: /* right Window key */ 733 keycode = 0x6a; 734 break; 735 case 0x5d: /* menu key */ 736 keycode = 0x6b; 737 break; 738 case 0x5e: /* power key */ 739 keycode = 0x6d; 740 break; 741 case 0x5f: /* sleep key */ 742 keycode = 0x6e; 743 break; 744 case 0x63: /* wake key */ 745 keycode = 0x6f; 746 break; 747 case 0x64: /* [JP106USB] backslash, underscore */ 748 keycode = 0x73; 749 break; 750 default: /* ignore everything else */ 751 goto next_code; 752 } 753 break; 754 case 0xE1: /* 0xE1 prefix */ 755 /* 756 * The pause/break key on the 101 keyboard produces: 757 * E1-1D-45 E1-9D-C5 758 * Ctrl-pause/break produces: 759 * E0-46 E0-C6 (See above.) 760 */ 761 state->ks_prefix = 0; 762 if (keycode == 0x1D) 763 state->ks_prefix = 0x1D; 764 goto next_code; 765 /* NOT REACHED */ 766 case 0x1D: /* pause / break */ 767 state->ks_prefix = 0; 768 if (keycode != 0x45) 769 goto next_code; 770 keycode = 0x68; 771 break; 772 } 773 774 /* XXX assume 101/102 keys AT keyboard */ 775 switch (keycode) { 776 case 0x5c: /* print screen */ 777 if (state->ks_flags & ALTS) 778 keycode = 0x54; /* sysrq */ 779 break; 780 case 0x68: /* pause/break */ 781 if (state->ks_flags & CTLS) 782 keycode = 0x6c; /* break */ 783 break; 784 } 785 786 /* return the key code in the K_CODE mode */ 787 if (state->ks_mode == K_CODE) 788 return (keycode | (scancode & 0x80)); 789 790 /* compose a character code */ 791 if (state->ks_flags & COMPOSE) { 792 switch (keycode | (scancode & 0x80)) { 793 /* key pressed, process it */ 794 case 0x47: case 0x48: case 0x49: /* keypad 7,8,9 */ 795 state->ks_composed_char *= 10; 796 state->ks_composed_char += keycode - 0x40; 797 if (state->ks_composed_char > UCHAR_MAX) 798 return (ERRKEY); 799 goto next_code; 800 case 0x4B: case 0x4C: case 0x4D: /* keypad 4,5,6 */ 801 state->ks_composed_char *= 10; 802 state->ks_composed_char += keycode - 0x47; 803 if (state->ks_composed_char > UCHAR_MAX) 804 return (ERRKEY); 805 goto next_code; 806 case 0x4F: case 0x50: case 0x51: /* keypad 1,2,3 */ 807 state->ks_composed_char *= 10; 808 state->ks_composed_char += keycode - 0x4E; 809 if (state->ks_composed_char > UCHAR_MAX) 810 return (ERRKEY); 811 goto next_code; 812 case 0x52: /* keypad 0 */ 813 state->ks_composed_char *= 10; 814 if (state->ks_composed_char > UCHAR_MAX) 815 return (ERRKEY); 816 goto next_code; 817 818 /* key released, no interest here */ 819 case 0xC7: case 0xC8: case 0xC9: /* keypad 7,8,9 */ 820 case 0xCB: case 0xCC: case 0xCD: /* keypad 4,5,6 */ 821 case 0xCF: case 0xD0: case 0xD1: /* keypad 1,2,3 */ 822 case 0xD2: /* keypad 0 */ 823 goto next_code; 824 825 case 0x38: /* left alt key */ 826 break; 827 828 default: 829 if (state->ks_composed_char > 0) { 830 state->ks_flags &= ~COMPOSE; 831 state->ks_composed_char = 0; 832 return (ERRKEY); 833 } 834 break; 835 } 836 } 837 838 /* keycode to key action */ 839 action = genkbd_keyaction(kbd, keycode, scancode & 0x80, 840 &state->ks_state, &state->ks_accents); 841 if (action == NOKEY) 842 goto next_code; 843 844 return (action); 845 } 846 847 /* 848 * Check if char is waiting 849 */ 850 static int 851 kbdmux_check_char(keyboard_t *kbd) 852 { 853 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 854 int ready; 855 856 if (!KBD_IS_ACTIVE(kbd)) 857 return (FALSE); 858 859 if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char != 0)) 860 ready = TRUE; 861 else 862 ready = (state->ks_inq_length > 0) ? TRUE : FALSE; 863 864 return (ready); 865 } 866 867 /* 868 * Keyboard ioctl's 869 */ 870 static int 871 kbdmux_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg) 872 { 873 static int delays[] = { 874 250, 500, 750, 1000 875 }; 876 877 static int rates[] = { 878 34, 38, 42, 46, 50, 55, 59, 63, 879 68, 76, 84, 92, 100, 110, 118, 126, 880 136, 152, 168, 184, 200, 220, 236, 252, 881 272, 304, 336, 368, 400, 440, 472, 504 882 }; 883 884 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 885 kbdmux_kbd_t *k; 886 keyboard_info_t *ki; 887 int error = 0, mode, i; 888 889 if (state == NULL) 890 return (ENXIO); 891 892 switch (cmd) { 893 case KBADDKBD: /* add keyboard to the mux */ 894 ki = (keyboard_info_t *) arg; 895 896 if (ki == NULL || ki->kb_unit < 0 || ki->kb_name[0] == '\0' || 897 strcmp(ki->kb_name, "*") == 0) { 898 return (EINVAL); /* bad input */ 899 } 900 901 SLIST_FOREACH(k, &state->ks_kbds, next) 902 if (k->kbd->kb_unit == ki->kb_unit && 903 strcmp(k->kbd->kb_name, ki->kb_name) == 0) 904 break; 905 906 if (k != NULL) 907 return (0); /* keyboard already in the mux */ 908 909 k = kmalloc(sizeof(*k), M_KBDMUX, M_NOWAIT | M_ZERO); 910 if (k == NULL) 911 return (ENOMEM); /* out of memory */ 912 913 k->kbd = kbd_get_keyboard( 914 kbd_allocate( 915 ki->kb_name, 916 ki->kb_unit, 917 (void *) &k->kbd, 918 kbdmux_kbd_event, (void *) state)); 919 if (k->kbd == NULL) { 920 kfree(k, M_KBDMUX); 921 return (EINVAL); /* bad keyboard */ 922 } 923 924 kbd_enable(k->kbd); 925 kbd_clear_state(k->kbd); 926 927 /* set K_RAW mode on slave keyboard */ 928 mode = K_RAW; 929 error = kbd_ioctl(k->kbd, KDSKBMODE, (caddr_t)&mode); 930 if (error == 0) { 931 /* set lock keys state on slave keyboard */ 932 mode = state->ks_state & LOCK_MASK; 933 error = kbd_ioctl(k->kbd, KDSKBSTATE, (caddr_t)&mode); 934 } 935 936 if (error != 0) { 937 kbd_release(k->kbd, &k->kbd); 938 k->kbd = NULL; 939 kfree(k, M_KBDMUX); 940 return (error); /* could not set mode */ 941 } 942 943 SLIST_INSERT_HEAD(&state->ks_kbds, k, next); 944 break; 945 946 case KBRELKBD: /* release keyboard from the mux */ 947 ki = (keyboard_info_t *) arg; 948 949 if (ki == NULL || ki->kb_unit < 0 || ki->kb_name[0] == '\0' || 950 strcmp(ki->kb_name, "*") == 0) { 951 return (EINVAL); /* bad input */ 952 } 953 954 SLIST_FOREACH(k, &state->ks_kbds, next) 955 if (k->kbd->kb_unit == ki->kb_unit && 956 strcmp(k->kbd->kb_name, ki->kb_name) == 0) 957 break; 958 959 if (k != NULL) { 960 error = kbd_release(k->kbd, &k->kbd); 961 if (error == 0) { 962 SLIST_REMOVE(&state->ks_kbds, k, kbdmux_kbd, next); 963 964 k->kbd = NULL; 965 966 kfree(k, M_KBDMUX); 967 } 968 } else 969 error = ENXIO; /* keyboard is not in the mux */ 970 971 break; 972 973 case KDGKBMODE: /* get kyboard mode */ 974 *(int *)arg = state->ks_mode; 975 break; 976 977 case KDSKBMODE: /* set keyboard mode */ 978 switch (*(int *)arg) { 979 case K_XLATE: 980 if (state->ks_mode != K_XLATE) { 981 /* make lock key state and LED state match */ 982 state->ks_state &= ~LOCK_MASK; 983 state->ks_state |= KBD_LED_VAL(kbd); 984 } 985 /* FALLTHROUGH */ 986 987 case K_RAW: 988 case K_CODE: 989 if (state->ks_mode != *(int *)arg) { 990 kbdmux_clear_state(kbd); 991 state->ks_mode = *(int *)arg; 992 } 993 break; 994 995 default: 996 error = EINVAL; 997 break; 998 } 999 break; 1000 1001 case KDGETLED: /* get keyboard LED */ 1002 *(int *)arg = KBD_LED_VAL(kbd); 1003 break; 1004 1005 case KDSETLED: /* set keyboard LED */ 1006 /* NOTE: lock key state in ks_state won't be changed */ 1007 if (*(int *)arg & ~LOCK_MASK) 1008 return (EINVAL); 1009 1010 KBD_LED_VAL(kbd) = *(int *)arg; 1011 #ifdef EVDEV_SUPPORT 1012 if (state->ks_evdev != NULL && 1013 evdev_rcpt_mask & EVDEV_RCPT_KBDMUX) 1014 evdev_push_leds(state->ks_evdev, *(int *)arg); 1015 #endif 1016 /* KDSETLED on all slave keyboards */ 1017 SLIST_FOREACH(k, &state->ks_kbds, next) 1018 kbd_ioctl(k->kbd, KDSETLED, arg); 1019 break; 1020 1021 case KDGKBSTATE: /* get lock key state */ 1022 *(int *)arg = state->ks_state & LOCK_MASK; 1023 break; 1024 1025 case KDSKBSTATE: /* set lock key state */ 1026 if (*(int *)arg & ~LOCK_MASK) 1027 return (EINVAL); 1028 1029 state->ks_state &= ~LOCK_MASK; 1030 state->ks_state |= *(int *)arg; 1031 1032 /* KDSKBSTATE on all slave keyboards */ 1033 SLIST_FOREACH(k, &state->ks_kbds, next) 1034 kbd_ioctl(k->kbd, KDSKBSTATE, arg); 1035 1036 return (kbdmux_ioctl(kbd, KDSETLED, arg)); 1037 /* NOT REACHED */ 1038 1039 case KDSETREPEAT: /* set keyboard repeat rate (new interface) */ 1040 /* lookup delay */ 1041 for (i = NELEM(delays) - 1; i > 0; i --) 1042 if (((int *)arg)[0] >= delays[i]) 1043 break; 1044 mode = i << 5; 1045 1046 /* lookup rate */ 1047 for (i = NELEM(rates) - 1; i > 0; i --) 1048 if (((int *)arg)[1] >= rates[i]) 1049 break; 1050 mode |= i; 1051 1052 if (mode & ~0x7f) 1053 return (EINVAL); 1054 1055 kbd->kb_delay1 = delays[(mode >> 5) & 3]; 1056 kbd->kb_delay2 = rates[mode & 0x1f]; 1057 #ifdef EVDEV_SUPPORT 1058 if (state->ks_evdev != NULL && 1059 evdev_rcpt_mask & EVDEV_RCPT_KBDMUX) 1060 evdev_push_repeats(state->ks_evdev, kbd); 1061 #endif 1062 /* perform command on all slave keyboards */ 1063 SLIST_FOREACH(k, &state->ks_kbds, next) 1064 kbd_ioctl(k->kbd, cmd, arg); 1065 break; 1066 1067 case PIO_KEYMAP: /* set keyboard translation table */ 1068 case PIO_KEYMAPENT: /* set keyboard translation table entry */ 1069 case PIO_DEADKEYMAP: /* set accent key translation table */ 1070 state->ks_accents = 0; 1071 1072 /* perform command on all slave keyboards */ 1073 SLIST_FOREACH(k, &state->ks_kbds, next) 1074 kbd_ioctl(k->kbd, cmd, arg); 1075 /* FALLTHROUGH */ 1076 1077 default: 1078 error = genkbd_commonioctl(kbd, cmd, arg); 1079 break; 1080 } 1081 return (error); 1082 } 1083 1084 /* 1085 * Lock the access to the keyboard 1086 */ 1087 static int 1088 kbdmux_lock(keyboard_t *kbd, int lock) 1089 { 1090 return (1); /* XXX */ 1091 } 1092 1093 /* 1094 * Clear the internal state of the keyboard 1095 * 1096 * NOTE: May be called unlocked from init 1097 */ 1098 static void 1099 kbdmux_clear_state(keyboard_t *kbd) 1100 { 1101 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 1102 1103 state->ks_flags &= ~(COMPOSE|POLLING); 1104 state->ks_state &= LOCK_MASK; /* preserve locking key state */ 1105 state->ks_accents = 0; 1106 state->ks_composed_char = 0; 1107 /* state->ks_prefix = 0; XXX */ 1108 state->ks_inq_length = 0; 1109 } 1110 1111 /* 1112 * Save the internal state 1113 */ 1114 static int 1115 kbdmux_get_state(keyboard_t *kbd, void *buf, size_t len) 1116 { 1117 if (len == 0) 1118 return (sizeof(kbdmux_state_t)); 1119 if (len < sizeof(kbdmux_state_t)) 1120 return (-1); 1121 1122 bcopy(kbd->kb_data, buf, sizeof(kbdmux_state_t)); /* XXX locking? */ 1123 1124 return (0); 1125 } 1126 1127 /* 1128 * Set the internal state 1129 */ 1130 static int 1131 kbdmux_set_state(keyboard_t *kbd, void *buf, size_t len) 1132 { 1133 if (len < sizeof(kbdmux_state_t)) 1134 return (ENOMEM); 1135 1136 bcopy(buf, kbd->kb_data, sizeof(kbdmux_state_t)); /* XXX locking? */ 1137 1138 return (0); 1139 } 1140 1141 /* 1142 * Set polling 1143 * 1144 * Caller interlocks all keyboard calls. We must not lock here. 1145 */ 1146 static int 1147 kbdmux_poll(keyboard_t *kbd, int on) 1148 { 1149 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 1150 kbdmux_kbd_t *k; 1151 1152 if (on) 1153 state->ks_flags |= POLLING; 1154 else 1155 state->ks_flags &= ~POLLING; 1156 1157 /* set poll on slave keyboards */ 1158 SLIST_FOREACH(k, &state->ks_kbds, next) 1159 kbd_poll(k->kbd, on); 1160 1161 return (0); 1162 } 1163 1164 /***************************************************************************** 1165 ***************************************************************************** 1166 ** Module 1167 ***************************************************************************** 1168 *****************************************************************************/ 1169 1170 KEYBOARD_DRIVER(kbdmux, kbdmuxsw, kbdmux_configure); 1171 1172 static int 1173 kbdmux_modevent(module_t mod, int type, void *data) 1174 { 1175 keyboard_switch_t *sw; 1176 keyboard_t *kbd; 1177 int error; 1178 1179 switch (type) { 1180 case MOD_LOAD: 1181 if ((error = kbd_add_driver(&kbdmux_kbd_driver)) != 0) 1182 break; 1183 1184 if ((sw = kbd_get_switch(KEYBOARD_NAME)) == NULL) { 1185 kbd_delete_driver(&kbdmux_kbd_driver); 1186 error = ENXIO; 1187 break; 1188 } 1189 1190 kbd = NULL; 1191 1192 if ((error = (*sw->probe)(0, NULL, 0)) != 0 || 1193 (error = (*sw->init)(0, &kbd, NULL, 0)) != 0) { 1194 kbd_delete_driver(&kbdmux_kbd_driver); 1195 break; 1196 } 1197 1198 #ifdef KBD_INSTALL_CDEV 1199 if ((error = kbd_attach(kbd)) != 0) { 1200 (*sw->term)(kbd); 1201 kbd_delete_driver(&kbdmux_kbd_driver); 1202 break; 1203 } 1204 #endif 1205 1206 if ((error = (*sw->enable)(kbd)) != 0) { 1207 (*sw->disable)(kbd); 1208 #ifdef KBD_INSTALL_CDEV 1209 kbd_detach(kbd); 1210 #endif 1211 (*sw->term)(kbd); 1212 kbd_delete_driver(&kbdmux_kbd_driver); 1213 break; 1214 } 1215 break; 1216 1217 case MOD_UNLOAD: 1218 if ((sw = kbd_get_switch(KEYBOARD_NAME)) == NULL) 1219 panic("kbd_get_switch(" KEYBOARD_NAME ") == NULL"); 1220 1221 kbd = kbd_get_keyboard(kbd_find_keyboard(KEYBOARD_NAME, 0)); 1222 if (kbd != NULL) { 1223 (*sw->disable)(kbd); 1224 #ifdef KBD_INSTALL_CDEV 1225 kbd_detach(kbd); 1226 #endif 1227 (*sw->term)(kbd); 1228 kbd_delete_driver(&kbdmux_kbd_driver); 1229 } 1230 error = 0; 1231 break; 1232 1233 default: 1234 error = EOPNOTSUPP; 1235 break; 1236 } 1237 return (error); 1238 } 1239 1240 DEV_MODULE(kbdmux, kbdmux_modevent, NULL); 1241 #ifdef EVDEV_SUPPORT 1242 MODULE_DEPEND(kbdmux, evdev, 1, 1, 1); 1243 #endif 1244