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 <sys/param.h> 35 #include <sys/bus.h> 36 #include <sys/conf.h> 37 #include <sys/consio.h> 38 #include <sys/fcntl.h> 39 #include <sys/kbio.h> 40 #include <sys/kernel.h> 41 #include <sys/limits.h> 42 #include <sys/lock.h> 43 #include <sys/malloc.h> 44 #include <sys/module.h> 45 #include <sys/mutex.h> 46 #include <sys/poll.h> 47 #include <sys/proc.h> 48 #include <sys/queue.h> 49 #include <sys/selinfo.h> 50 #include <sys/systm.h> 51 #include <sys/taskqueue.h> 52 #include <sys/uio.h> 53 #include <dev/misc/kbd/kbdreg.h> 54 #include <dev/misc/kbd/kbdtables.h> 55 56 #define KEYBOARD_NAME "kbdmux" 57 58 MALLOC_DECLARE(M_KBDMUX); 59 MALLOC_DEFINE(M_KBDMUX, KEYBOARD_NAME, "Keyboard multiplexor"); 60 61 /***************************************************************************** 62 ***************************************************************************** 63 ** Keyboard state 64 ***************************************************************************** 65 *****************************************************************************/ 66 67 #define KBDMUX_Q_SIZE 512 /* input queue size */ 68 69 /* 70 * XXX 71 * For now rely on Giant mutex to protect our data structures. 72 * Just like the rest of keyboard drivers and syscons(4) do. 73 * Note that callout is initialized as not MP-safe to make sure 74 * Giant is held. 75 * XXX: I don't think we are MP-Safing the callout, maybe we 76 * should, using get_mplock() around it? NFI 77 */ 78 79 #if 0 /* not yet */ 80 #error "This stuff still needs porting!" 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, &(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 | (84 + 1), (d), (t)) 114 #define KBDMUX_CALLOUT_INIT(s) \ 115 callout_init(&(s)->ks_timo) 116 #define KBDMUX_QUEUE_INTR(s) \ 117 taskqueue_enqueue(taskqueue_swi, &(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 kbd_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 (kbd_check_char(kbd)) { 270 c = kbd_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 kfree(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 = kmalloc(sizeof(*kbd), M_KBDMUX, M_NOWAIT | M_ZERO); 402 state = kmalloc(sizeof(*state), M_KBDMUX, M_NOWAIT | M_ZERO); 403 keymap = kmalloc(sizeof(key_map), M_KBDMUX, M_NOWAIT); 404 accmap = kmalloc(sizeof(accent_map), M_KBDMUX, M_NOWAIT); 405 fkeymap = kmalloc(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, 434 KB_PRI_MUX, 0, 0); 435 bcopy(&key_map, keymap, sizeof(key_map)); 436 bcopy(&accent_map, accmap, sizeof(accent_map)); 437 bcopy(fkey_tab, fkeymap, 438 imin(fkeymap_size*sizeof(fkeymap[0]), sizeof(fkey_tab))); 439 kbd_set_maps(kbd, keymap, accmap, fkeymap, fkeymap_size); 440 kbd->kb_data = (void *)state; 441 442 KBD_FOUND_DEVICE(kbd); 443 KBD_PROBE_DONE(kbd); 444 445 KBDMUX_LOCK(state); 446 kbdmux_clear_state_locked(state); 447 state->ks_mode = K_XLATE; 448 KBDMUX_UNLOCK(state); 449 } 450 451 if (!KBD_IS_INITIALIZED(kbd) && !(flags & KB_CONF_PROBE_ONLY)) { 452 kbd->kb_config = flags & ~KB_CONF_PROBE_ONLY; 453 454 kbdmux_ioctl(kbd, KDSETLED, (caddr_t)&state->ks_state); 455 456 delay[0] = kbd->kb_delay1; 457 delay[1] = kbd->kb_delay2; 458 kbdmux_ioctl(kbd, KDSETREPEAT, (caddr_t)delay); 459 460 KBD_INIT_DONE(kbd); 461 } 462 463 if (!KBD_IS_CONFIGURED(kbd)) { 464 if (kbd_register(kbd) < 0) { 465 error = ENXIO; 466 goto bad; 467 } 468 469 KBD_CONFIG_DONE(kbd); 470 471 KBDMUX_LOCK(state); 472 callout_reset(&state->ks_timo, TICKS, kbdmux_kbd_intr_timo, state); 473 KBDMUX_UNLOCK(state); 474 } 475 476 return (0); 477 bad: 478 if (needfree) { 479 if (state != NULL) 480 kfree(state, M_KBDMUX); 481 if (keymap != NULL) 482 kfree(keymap, M_KBDMUX); 483 if (accmap != NULL) 484 kfree(accmap, M_KBDMUX); 485 if (fkeymap != NULL) 486 kfree(fkeymap, M_KBDMUX); 487 if (kbd != NULL) { 488 kfree(kbd, M_KBDMUX); 489 *kbdp = NULL; /* insure ref doesn't leak to caller */ 490 } 491 } 492 493 return (error); 494 } 495 496 /* 497 * Finish using this keyboard 498 */ 499 static int 500 kbdmux_term(keyboard_t *kbd) 501 { 502 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 503 kbdmux_kbd_t *k; 504 505 KBDMUX_LOCK(state); 506 507 /* kill callout */ 508 callout_stop(&state->ks_timo); 509 510 /* wait for interrupt task */ 511 while (state->ks_flags & TASK) 512 KBDMUX_SLEEP(state, ks_task, "kbdmuxc", 0); 513 514 /* release all keyboards from the mux */ 515 while ((k = SLIST_FIRST(&state->ks_kbds)) != NULL) { 516 kbd_release(k->kbd, &k->kbd); 517 SLIST_REMOVE_HEAD(&state->ks_kbds, next); 518 519 k->kbd = NULL; 520 521 kfree(k, M_KBDMUX); 522 } 523 524 KBDMUX_UNLOCK(state); 525 526 kbd_unregister(kbd); 527 528 KBDMUX_LOCK_DESTROY(state); 529 bzero(state, sizeof(*state)); 530 kfree(state, M_KBDMUX); 531 532 kfree(kbd->kb_keymap, M_KBDMUX); 533 kfree(kbd->kb_accentmap, M_KBDMUX); 534 kfree(kbd->kb_fkeytab, M_KBDMUX); 535 kfree(kbd, M_KBDMUX); 536 537 return (0); 538 } 539 540 /* 541 * Keyboard interrupt routine 542 */ 543 static int 544 kbdmux_intr(keyboard_t *kbd, void *arg) 545 { 546 int c; 547 548 if (KBD_IS_ACTIVE(kbd) && KBD_IS_BUSY(kbd)) { 549 /* let the callback function to process the input */ 550 (*kbd->kb_callback.kc_func)(kbd, KBDIO_KEYINPUT, 551 kbd->kb_callback.kc_arg); 552 } else { 553 /* read and discard the input; no one is waiting for input */ 554 do { 555 c = kbdmux_read_char(kbd, FALSE); 556 } while (c != NOKEY); 557 } 558 559 return (0); 560 } 561 562 /* 563 * Test the interface to the device 564 */ 565 static int 566 kbdmux_test_if(keyboard_t *kbd) 567 { 568 return (0); 569 } 570 571 /* 572 * Enable the access to the device; until this function is called, 573 * the client cannot read from the keyboard. 574 */ 575 static int 576 kbdmux_enable(keyboard_t *kbd) 577 { 578 KBD_ACTIVATE(kbd); 579 return (0); 580 } 581 582 /* 583 * Disallow the access to the device 584 */ 585 static int 586 kbdmux_disable(keyboard_t *kbd) 587 { 588 KBD_DEACTIVATE(kbd); 589 return (0); 590 } 591 592 /* 593 * Read one byte from the keyboard if it's allowed 594 */ 595 static int 596 kbdmux_read(keyboard_t *kbd, int wait) 597 { 598 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 599 int c; 600 601 KBDMUX_LOCK(state); 602 c = kbdmux_kbd_getc(state); 603 KBDMUX_UNLOCK(state); 604 605 if (c != -1) 606 kbd->kb_count ++; 607 608 return (KBD_IS_ACTIVE(kbd)? c : -1); 609 } 610 611 /* 612 * Check if data is waiting 613 */ 614 static int 615 kbdmux_check(keyboard_t *kbd) 616 { 617 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 618 int ready; 619 620 if (!KBD_IS_ACTIVE(kbd)) 621 return (FALSE); 622 623 KBDMUX_LOCK(state); 624 ready = (state->ks_inq_length > 0) ? TRUE : FALSE; 625 KBDMUX_UNLOCK(state); 626 627 return (ready); 628 } 629 630 /* 631 * Read char from the keyboard (stolen from atkbd.c) 632 */ 633 static u_int 634 kbdmux_read_char(keyboard_t *kbd, int wait) 635 { 636 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 637 u_int action; 638 int scancode, keycode; 639 640 KBDMUX_LOCK(state); 641 642 next_code: 643 644 /* do we have a composed char to return? */ 645 if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0)) { 646 action = state->ks_composed_char; 647 state->ks_composed_char = 0; 648 if (action > UCHAR_MAX) { 649 KBDMUX_UNLOCK(state); 650 651 return (ERRKEY); 652 } 653 654 KBDMUX_UNLOCK(state); 655 656 return (action); 657 } 658 659 /* see if there is something in the keyboard queue */ 660 scancode = kbdmux_kbd_getc(state); 661 if (scancode == -1) { 662 if (state->ks_flags & POLLING) { 663 kbdmux_kbd_t *k; 664 665 SLIST_FOREACH(k, &state->ks_kbds, next) { 666 while (kbd_check_char(k->kbd)) { 667 scancode = kbd_read_char(k->kbd, 0); 668 if (scancode == NOKEY) 669 break; 670 if (scancode == ERRKEY) 671 continue; 672 if (!KBD_IS_BUSY(k->kbd)) 673 continue; 674 675 kbdmux_kbd_putc(state, scancode); 676 } 677 } 678 679 if (state->ks_inq_length > 0) 680 goto next_code; 681 } 682 683 KBDMUX_UNLOCK(state); 684 return (NOKEY); 685 } 686 /* XXX FIXME: check for -1 if wait == 1! */ 687 688 kbd->kb_count ++; 689 690 /* return the byte as is for the K_RAW mode */ 691 if (state->ks_mode == K_RAW) { 692 KBDMUX_UNLOCK(state); 693 return (scancode); 694 } 695 696 /* translate the scan code into a keycode */ 697 keycode = scancode & 0x7F; 698 switch (state->ks_prefix) { 699 case 0x00: /* normal scancode */ 700 switch(scancode) { 701 case 0xB8: /* left alt (compose key) released */ 702 if (state->ks_flags & COMPOSE) { 703 state->ks_flags &= ~COMPOSE; 704 if (state->ks_composed_char > UCHAR_MAX) 705 state->ks_composed_char = 0; 706 } 707 break; 708 case 0x38: /* left alt (compose key) pressed */ 709 if (!(state->ks_flags & COMPOSE)) { 710 state->ks_flags |= COMPOSE; 711 state->ks_composed_char = 0; 712 } 713 break; 714 case 0xE0: 715 case 0xE1: 716 state->ks_prefix = scancode; 717 goto next_code; 718 } 719 break; 720 case 0xE0: /* 0xE0 prefix */ 721 state->ks_prefix = 0; 722 switch (keycode) { 723 case 0x1C: /* right enter key */ 724 keycode = 0x59; 725 break; 726 case 0x1D: /* right ctrl key */ 727 keycode = 0x5A; 728 break; 729 case 0x35: /* keypad divide key */ 730 keycode = 0x5B; 731 break; 732 case 0x37: /* print scrn key */ 733 keycode = 0x5C; 734 break; 735 case 0x38: /* right alt key (alt gr) */ 736 keycode = 0x5D; 737 break; 738 case 0x46: /* ctrl-pause/break on AT 101 (see below) */ 739 keycode = 0x68; 740 break; 741 case 0x47: /* grey home key */ 742 keycode = 0x5E; 743 break; 744 case 0x48: /* grey up arrow key */ 745 keycode = 0x5F; 746 break; 747 case 0x49: /* grey page up key */ 748 keycode = 0x60; 749 break; 750 case 0x4B: /* grey left arrow key */ 751 keycode = 0x61; 752 break; 753 case 0x4D: /* grey right arrow key */ 754 keycode = 0x62; 755 break; 756 case 0x4F: /* grey end key */ 757 keycode = 0x63; 758 break; 759 case 0x50: /* grey down arrow key */ 760 keycode = 0x64; 761 break; 762 case 0x51: /* grey page down key */ 763 keycode = 0x65; 764 break; 765 case 0x52: /* grey insert key */ 766 keycode = 0x66; 767 break; 768 case 0x53: /* grey delete key */ 769 keycode = 0x67; 770 break; 771 /* the following 3 are only used on the MS "Natural" keyboard */ 772 case 0x5b: /* left Window key */ 773 keycode = 0x69; 774 break; 775 case 0x5c: /* right Window key */ 776 keycode = 0x6a; 777 break; 778 case 0x5d: /* menu key */ 779 keycode = 0x6b; 780 break; 781 case 0x5e: /* power key */ 782 keycode = 0x6d; 783 break; 784 case 0x5f: /* sleep key */ 785 keycode = 0x6e; 786 break; 787 case 0x63: /* wake key */ 788 keycode = 0x6f; 789 break; 790 case 0x64: /* [JP106USB] backslash, underscore */ 791 keycode = 0x73; 792 break; 793 default: /* ignore everything else */ 794 goto next_code; 795 } 796 break; 797 case 0xE1: /* 0xE1 prefix */ 798 /* 799 * The pause/break key on the 101 keyboard produces: 800 * E1-1D-45 E1-9D-C5 801 * Ctrl-pause/break produces: 802 * E0-46 E0-C6 (See above.) 803 */ 804 state->ks_prefix = 0; 805 if (keycode == 0x1D) 806 state->ks_prefix = 0x1D; 807 goto next_code; 808 /* NOT REACHED */ 809 case 0x1D: /* pause / break */ 810 state->ks_prefix = 0; 811 if (keycode != 0x45) 812 goto next_code; 813 keycode = 0x68; 814 break; 815 } 816 817 /* XXX assume 101/102 keys AT keyboard */ 818 switch (keycode) { 819 case 0x5c: /* print screen */ 820 if (state->ks_flags & ALTS) 821 keycode = 0x54; /* sysrq */ 822 break; 823 case 0x68: /* pause/break */ 824 if (state->ks_flags & CTLS) 825 keycode = 0x6c; /* break */ 826 break; 827 } 828 829 /* return the key code in the K_CODE mode */ 830 if (state->ks_mode == K_CODE) { 831 KBDMUX_UNLOCK(state); 832 return (keycode | (scancode & 0x80)); 833 } 834 835 /* compose a character code */ 836 if (state->ks_flags & COMPOSE) { 837 switch (keycode | (scancode & 0x80)) { 838 /* key pressed, process it */ 839 case 0x47: case 0x48: case 0x49: /* keypad 7,8,9 */ 840 state->ks_composed_char *= 10; 841 state->ks_composed_char += keycode - 0x40; 842 if (state->ks_composed_char > UCHAR_MAX) { 843 KBDMUX_UNLOCK(state); 844 return (ERRKEY); 845 } 846 goto next_code; 847 case 0x4B: case 0x4C: case 0x4D: /* keypad 4,5,6 */ 848 state->ks_composed_char *= 10; 849 state->ks_composed_char += keycode - 0x47; 850 if (state->ks_composed_char > UCHAR_MAX) { 851 KBDMUX_UNLOCK(state); 852 return (ERRKEY); 853 } 854 goto next_code; 855 case 0x4F: case 0x50: case 0x51: /* keypad 1,2,3 */ 856 state->ks_composed_char *= 10; 857 state->ks_composed_char += keycode - 0x4E; 858 if (state->ks_composed_char > UCHAR_MAX) { 859 KBDMUX_UNLOCK(state); 860 return (ERRKEY); 861 } 862 goto next_code; 863 case 0x52: /* keypad 0 */ 864 state->ks_composed_char *= 10; 865 if (state->ks_composed_char > UCHAR_MAX) { 866 KBDMUX_UNLOCK(state); 867 return (ERRKEY); 868 } 869 goto next_code; 870 871 /* key released, no interest here */ 872 case 0xC7: case 0xC8: case 0xC9: /* keypad 7,8,9 */ 873 case 0xCB: case 0xCC: case 0xCD: /* keypad 4,5,6 */ 874 case 0xCF: case 0xD0: case 0xD1: /* keypad 1,2,3 */ 875 case 0xD2: /* keypad 0 */ 876 goto next_code; 877 878 case 0x38: /* left alt key */ 879 break; 880 881 default: 882 if (state->ks_composed_char > 0) { 883 state->ks_flags &= ~COMPOSE; 884 state->ks_composed_char = 0; 885 KBDMUX_UNLOCK(state); 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 KBDMUX_UNLOCK(state); 899 900 return (action); 901 } 902 903 /* 904 * Check if char is waiting 905 */ 906 static int 907 kbdmux_check_char(keyboard_t *kbd) 908 { 909 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 910 int ready; 911 912 if (!KBD_IS_ACTIVE(kbd)) 913 return (FALSE); 914 915 KBDMUX_LOCK(state); 916 917 if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char != 0)) 918 ready = TRUE; 919 else 920 ready = (state->ks_inq_length > 0) ? TRUE : FALSE; 921 922 KBDMUX_UNLOCK(state); 923 924 return (ready); 925 } 926 927 /* 928 * Keyboard ioctl's 929 */ 930 static int 931 kbdmux_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg) 932 { 933 static int delays[] = { 934 250, 500, 750, 1000 935 }; 936 937 static int rates[] = { 938 34, 38, 42, 46, 50, 55, 59, 63, 939 68, 76, 84, 92, 100, 110, 118, 126, 940 136, 152, 168, 184, 200, 220, 236, 252, 941 272, 304, 336, 368, 400, 440, 472, 504 942 }; 943 944 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 945 kbdmux_kbd_t *k; 946 keyboard_info_t *ki; 947 int error = 0, mode; 948 949 if (state == NULL) 950 return (ENXIO); 951 952 switch (cmd) { 953 case KBADDKBD: /* add keyboard to the mux */ 954 ki = (keyboard_info_t *) arg; 955 956 if (ki == NULL || ki->kb_unit < 0 || ki->kb_name[0] == '\0' || 957 strcmp(ki->kb_name, "*") == 0) 958 return (EINVAL); /* bad input */ 959 960 KBDMUX_LOCK(state); 961 962 SLIST_FOREACH(k, &state->ks_kbds, next) 963 if (k->kbd->kb_unit == ki->kb_unit && 964 strcmp(k->kbd->kb_name, ki->kb_name) == 0) 965 break; 966 967 if (k != NULL) { 968 KBDMUX_UNLOCK(state); 969 970 return (0); /* keyboard already in the mux */ 971 } 972 973 k = kmalloc(sizeof(*k), M_KBDMUX, M_NOWAIT | M_ZERO); 974 if (k == NULL) { 975 KBDMUX_UNLOCK(state); 976 977 return (ENOMEM); /* out of memory */ 978 } 979 980 k->kbd = kbd_get_keyboard( 981 kbd_allocate( 982 ki->kb_name, 983 ki->kb_unit, 984 (void *) &k->kbd, 985 kbdmux_kbd_event, (void *) state)); 986 if (k->kbd == NULL) { 987 KBDMUX_UNLOCK(state); 988 kfree(k, M_KBDMUX); 989 990 return (EINVAL); /* bad keyboard */ 991 } 992 993 kbd_enable(k->kbd); 994 kbd_clear_state(k->kbd); 995 996 /* set K_RAW mode on slave keyboard */ 997 mode = K_RAW; 998 error = kbd_ioctl(k->kbd, KDSKBMODE, (caddr_t)&mode); 999 if (error == 0) { 1000 /* set lock keys state on slave keyboard */ 1001 mode = state->ks_state & LOCK_MASK; 1002 error = kbd_ioctl(k->kbd, KDSKBSTATE, (caddr_t)&mode); 1003 } 1004 1005 if (error != 0) { 1006 KBDMUX_UNLOCK(state); 1007 1008 kbd_release(k->kbd, &k->kbd); 1009 k->kbd = NULL; 1010 1011 kfree(k, M_KBDMUX); 1012 1013 return (error); /* could not set mode */ 1014 } 1015 1016 SLIST_INSERT_HEAD(&state->ks_kbds, k, next); 1017 1018 KBDMUX_UNLOCK(state); 1019 break; 1020 1021 case KBRELKBD: /* release keyboard from the mux */ 1022 ki = (keyboard_info_t *) arg; 1023 1024 if (ki == NULL || ki->kb_unit < 0 || ki->kb_name[0] == '\0' || 1025 strcmp(ki->kb_name, "*") == 0) 1026 return (EINVAL); /* bad input */ 1027 1028 KBDMUX_LOCK(state); 1029 1030 SLIST_FOREACH(k, &state->ks_kbds, next) 1031 if (k->kbd->kb_unit == ki->kb_unit && 1032 strcmp(k->kbd->kb_name, ki->kb_name) == 0) 1033 break; 1034 1035 if (k != NULL) { 1036 error = kbd_release(k->kbd, &k->kbd); 1037 if (error == 0) { 1038 SLIST_REMOVE(&state->ks_kbds, k, kbdmux_kbd, next); 1039 1040 k->kbd = NULL; 1041 1042 kfree(k, M_KBDMUX); 1043 } 1044 } else 1045 error = ENXIO; /* keyboard is not in the mux */ 1046 1047 KBDMUX_UNLOCK(state); 1048 break; 1049 1050 case KDGKBMODE: /* get kyboard mode */ 1051 KBDMUX_LOCK(state); 1052 *(int *)arg = state->ks_mode; 1053 KBDMUX_UNLOCK(state); 1054 break; 1055 1056 case KDSKBMODE: /* set keyboard mode */ 1057 KBDMUX_LOCK(state); 1058 1059 switch (*(int *)arg) { 1060 case K_XLATE: 1061 if (state->ks_mode != K_XLATE) { 1062 /* make lock key state and LED state match */ 1063 state->ks_state &= ~LOCK_MASK; 1064 state->ks_state |= KBD_LED_VAL(kbd); 1065 } 1066 /* FALLTHROUGH */ 1067 1068 case K_RAW: 1069 case K_CODE: 1070 if (state->ks_mode != *(int *)arg) { 1071 kbdmux_clear_state_locked(state); 1072 state->ks_mode = *(int *)arg; 1073 } 1074 break; 1075 1076 default: 1077 error = EINVAL; 1078 break; 1079 } 1080 1081 KBDMUX_UNLOCK(state); 1082 break; 1083 1084 case KDGETLED: /* get keyboard LED */ 1085 KBDMUX_LOCK(state); 1086 *(int *)arg = KBD_LED_VAL(kbd); 1087 KBDMUX_UNLOCK(state); 1088 break; 1089 1090 case KDSETLED: /* set keyboard LED */ 1091 KBDMUX_LOCK(state); 1092 1093 /* NOTE: lock key state in ks_state won't be changed */ 1094 if (*(int *)arg & ~LOCK_MASK) { 1095 KBDMUX_UNLOCK(state); 1096 1097 return (EINVAL); 1098 } 1099 1100 KBD_LED_VAL(kbd) = *(int *)arg; 1101 1102 /* KDSETLED on all slave keyboards */ 1103 SLIST_FOREACH(k, &state->ks_kbds, next) 1104 kbd_ioctl(k->kbd, KDSETLED, arg); 1105 1106 KBDMUX_UNLOCK(state); 1107 break; 1108 1109 case KDGKBSTATE: /* get lock key state */ 1110 KBDMUX_LOCK(state); 1111 *(int *)arg = state->ks_state & LOCK_MASK; 1112 KBDMUX_UNLOCK(state); 1113 break; 1114 1115 case KDSKBSTATE: /* set lock key state */ 1116 KBDMUX_LOCK(state); 1117 1118 if (*(int *)arg & ~LOCK_MASK) { 1119 KBDMUX_UNLOCK(state); 1120 1121 return (EINVAL); 1122 } 1123 1124 state->ks_state &= ~LOCK_MASK; 1125 state->ks_state |= *(int *)arg; 1126 1127 /* KDSKBSTATE on all slave keyboards */ 1128 SLIST_FOREACH(k, &state->ks_kbds, next) 1129 kbd_ioctl(k->kbd, KDSKBSTATE, arg); 1130 1131 KBDMUX_UNLOCK(state); 1132 1133 return (kbdmux_ioctl(kbd, KDSETLED, arg)); 1134 /* NOT REACHED */ 1135 1136 case KDSETREPEAT: /* set keyboard repeat rate (new interface) */ 1137 case KDSETRAD: /* set keyboard repeat rate (old interface) */ 1138 KBDMUX_LOCK(state); 1139 1140 if (cmd == KDSETREPEAT) { 1141 int i; 1142 1143 /* lookup delay */ 1144 for (i = sizeof(delays)/sizeof(delays[0]) - 1; i > 0; i --) 1145 if (((int *)arg)[0] >= delays[i]) 1146 break; 1147 mode = i << 5; 1148 1149 /* lookup rate */ 1150 for (i = sizeof(rates)/sizeof(rates[0]) - 1; i > 0; i --) 1151 if (((int *)arg)[1] >= rates[i]) 1152 break; 1153 mode |= i; 1154 } else 1155 mode = *(int *)arg; 1156 1157 if (mode & ~0x7f) { 1158 KBDMUX_UNLOCK(state); 1159 1160 return (EINVAL); 1161 } 1162 1163 kbd->kb_delay1 = delays[(mode >> 5) & 3]; 1164 kbd->kb_delay2 = rates[mode & 0x1f]; 1165 1166 /* perform command on all slave keyboards */ 1167 SLIST_FOREACH(k, &state->ks_kbds, next) 1168 kbd_ioctl(k->kbd, cmd, arg); 1169 1170 KBDMUX_UNLOCK(state); 1171 break; 1172 1173 case PIO_KEYMAP: /* set keyboard translation table */ 1174 case PIO_KEYMAPENT: /* set keyboard translation table entry */ 1175 case PIO_DEADKEYMAP: /* set accent key translation table */ 1176 KBDMUX_LOCK(state); 1177 state->ks_accents = 0; 1178 1179 /* perform command on all slave keyboards */ 1180 SLIST_FOREACH(k, &state->ks_kbds, next) 1181 kbd_ioctl(k->kbd, cmd, arg); 1182 1183 KBDMUX_UNLOCK(state); 1184 /* FALLTHROUGH */ 1185 1186 default: 1187 error = genkbd_commonioctl(kbd, cmd, arg); 1188 break; 1189 } 1190 1191 return (error); 1192 } 1193 1194 /* 1195 * Lock the access to the keyboard 1196 */ 1197 static int 1198 kbdmux_lock(keyboard_t *kbd, int lock) 1199 { 1200 return (1); /* XXX */ 1201 } 1202 1203 /* 1204 * Clear the internal state of the keyboard 1205 */ 1206 static void 1207 kbdmux_clear_state_locked(kbdmux_state_t *state) 1208 { 1209 KBDMUX_LOCK_ASSERT(state, MA_OWNED); 1210 1211 state->ks_flags &= ~(COMPOSE|POLLING); 1212 state->ks_state &= LOCK_MASK; /* preserve locking key state */ 1213 state->ks_accents = 0; 1214 state->ks_composed_char = 0; 1215 /* state->ks_prefix = 0; XXX */ 1216 state->ks_inq_length = 0; 1217 } 1218 1219 static void 1220 kbdmux_clear_state(keyboard_t *kbd) 1221 { 1222 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 1223 1224 KBDMUX_LOCK(state); 1225 kbdmux_clear_state_locked(state); 1226 KBDMUX_UNLOCK(state); 1227 } 1228 1229 /* 1230 * Save the internal state 1231 */ 1232 static int 1233 kbdmux_get_state(keyboard_t *kbd, void *buf, size_t len) 1234 { 1235 if (len == 0) 1236 return (sizeof(kbdmux_state_t)); 1237 if (len < sizeof(kbdmux_state_t)) 1238 return (-1); 1239 1240 bcopy(kbd->kb_data, buf, sizeof(kbdmux_state_t)); /* XXX locking? */ 1241 1242 return (0); 1243 } 1244 1245 /* 1246 * Set the internal state 1247 */ 1248 static int 1249 kbdmux_set_state(keyboard_t *kbd, void *buf, size_t len) 1250 { 1251 if (len < sizeof(kbdmux_state_t)) 1252 return (ENOMEM); 1253 1254 bcopy(buf, kbd->kb_data, sizeof(kbdmux_state_t)); /* XXX locking? */ 1255 1256 return (0); 1257 } 1258 1259 /* 1260 * Set polling 1261 */ 1262 static int 1263 kbdmux_poll(keyboard_t *kbd, int on) 1264 { 1265 kbdmux_state_t *state = (kbdmux_state_t *) kbd->kb_data; 1266 kbdmux_kbd_t *k; 1267 1268 KBDMUX_LOCK(state); 1269 1270 if (on) 1271 state->ks_flags |= POLLING; 1272 else 1273 state->ks_flags &= ~POLLING; 1274 1275 /* set poll on slave keyboards */ 1276 SLIST_FOREACH(k, &state->ks_kbds, next) 1277 kbd_poll(k->kbd, on); 1278 1279 KBDMUX_UNLOCK(state); 1280 1281 return (0); 1282 } 1283 1284 /***************************************************************************** 1285 ***************************************************************************** 1286 ** Module 1287 ***************************************************************************** 1288 *****************************************************************************/ 1289 1290 KEYBOARD_DRIVER(kbdmux, kbdmuxsw, kbdmux_configure); 1291 1292 static int 1293 kbdmux_modevent(module_t mod, int type, void *data) 1294 { 1295 keyboard_switch_t *sw; 1296 keyboard_t *kbd; 1297 int error; 1298 1299 switch (type) { 1300 case MOD_LOAD: 1301 if ((error = kbd_add_driver(&kbdmux_kbd_driver)) != 0) 1302 break; 1303 1304 if ((sw = kbd_get_switch(KEYBOARD_NAME)) == NULL) { 1305 kbd_delete_driver(&kbdmux_kbd_driver); 1306 error = ENXIO; 1307 break; 1308 } 1309 1310 kbd = NULL; 1311 1312 if ((error = (*sw->probe)(0, NULL, 0)) != 0 || 1313 (error = (*sw->init)(0, &kbd, NULL, 0)) != 0) { 1314 kbd_delete_driver(&kbdmux_kbd_driver); 1315 break; 1316 } 1317 1318 #ifdef KBD_INSTALL_CDEV 1319 if ((error = kbd_attach(kbd)) != 0) { 1320 (*sw->term)(kbd); 1321 kbd_delete_driver(&kbdmux_kbd_driver); 1322 break; 1323 } 1324 #endif 1325 1326 if ((error = (*sw->enable)(kbd)) != 0) { 1327 (*sw->disable)(kbd); 1328 #ifdef KBD_INSTALL_CDEV 1329 kbd_detach(kbd); 1330 #endif 1331 (*sw->term)(kbd); 1332 kbd_delete_driver(&kbdmux_kbd_driver); 1333 break; 1334 } 1335 break; 1336 1337 case MOD_UNLOAD: 1338 if ((sw = kbd_get_switch(KEYBOARD_NAME)) == NULL) 1339 panic("kbd_get_switch(" KEYBOARD_NAME ") == NULL"); 1340 1341 kbd = kbd_get_keyboard(kbd_find_keyboard(KEYBOARD_NAME, 0)); 1342 if (kbd != NULL) { 1343 (*sw->disable)(kbd); 1344 #ifdef KBD_INSTALL_CDEV 1345 kbd_detach(kbd); 1346 #endif 1347 (*sw->term)(kbd); 1348 kbd_delete_driver(&kbdmux_kbd_driver); 1349 } 1350 error = 0; 1351 break; 1352 1353 default: 1354 error = EOPNOTSUPP; 1355 break; 1356 } 1357 1358 return (error); 1359 } 1360 1361 DEV_MODULE(kbdmux, kbdmux_modevent, NULL); 1362