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