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