1 /* 2 * Written for linux by Johan Myreen as a translation from 3 * the assembly version by Linus (with diacriticals added) 4 * 5 * Some additional features added by Christoph Niemann (ChN), March 1993 6 * 7 * Loadable keymaps by Risto Kankkunen, May 1993 8 * 9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993 10 * Added decr/incr_console, dynamic keymaps, Unicode support, 11 * dynamic function/string keys, led setting, Sept 1994 12 * `Sticky' modifier keys, 951006. 13 * 14 * 11-11-96: SAK should now work in the raw mode (Martin Mares) 15 * 16 * Modified to provide 'generic' keyboard support by Hamish Macdonald 17 * Merge with the m68k keyboard driver and split-off of the PC low-level 18 * parts by Geert Uytterhoeven, May 1997 19 * 20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares) 21 * 30-07-98: Dead keys redone, aeb@cwi.nl. 22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik) 23 */ 24 25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 26 27 #include <linux/consolemap.h> 28 #include <linux/module.h> 29 #include <linux/sched.h> 30 #include <linux/tty.h> 31 #include <linux/tty_flip.h> 32 #include <linux/mm.h> 33 #include <linux/string.h> 34 #include <linux/init.h> 35 #include <linux/slab.h> 36 37 #include <linux/kbd_kern.h> 38 #include <linux/kbd_diacr.h> 39 #include <linux/vt_kern.h> 40 #include <linux/input.h> 41 #include <linux/reboot.h> 42 #include <linux/notifier.h> 43 #include <linux/jiffies.h> 44 #include <linux/uaccess.h> 45 46 #include <asm/irq_regs.h> 47 48 extern void ctrl_alt_del(void); 49 50 /* 51 * Exported functions/variables 52 */ 53 54 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META)) 55 56 #if defined(CONFIG_X86) || defined(CONFIG_PARISC) 57 #include <asm/kbdleds.h> 58 #else 59 static inline int kbd_defleds(void) 60 { 61 return 0; 62 } 63 #endif 64 65 #define KBD_DEFLOCK 0 66 67 /* 68 * Handler Tables. 69 */ 70 71 #define K_HANDLERS\ 72 k_self, k_fn, k_spec, k_pad,\ 73 k_dead, k_cons, k_cur, k_shift,\ 74 k_meta, k_ascii, k_lock, k_lowercase,\ 75 k_slock, k_dead2, k_brl, k_ignore 76 77 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value, 78 char up_flag); 79 static k_handler_fn K_HANDLERS; 80 static k_handler_fn *k_handler[16] = { K_HANDLERS }; 81 82 #define FN_HANDLERS\ 83 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\ 84 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\ 85 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\ 86 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\ 87 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num 88 89 typedef void (fn_handler_fn)(struct vc_data *vc); 90 static fn_handler_fn FN_HANDLERS; 91 static fn_handler_fn *fn_handler[] = { FN_HANDLERS }; 92 93 /* 94 * Variables exported for vt_ioctl.c 95 */ 96 97 struct vt_spawn_console vt_spawn_con = { 98 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock), 99 .pid = NULL, 100 .sig = 0, 101 }; 102 103 104 /* 105 * Internal Data. 106 */ 107 108 static struct kbd_struct kbd_table[MAX_NR_CONSOLES]; 109 static struct kbd_struct *kbd = kbd_table; 110 111 /* maximum values each key_handler can handle */ 112 static const int max_vals[] = { 113 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1, 114 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1, 115 255, NR_LOCK - 1, 255, NR_BRL - 1 116 }; 117 118 static const int NR_TYPES = ARRAY_SIZE(max_vals); 119 120 static struct input_handler kbd_handler; 121 static DEFINE_SPINLOCK(kbd_event_lock); 122 static DEFINE_SPINLOCK(led_lock); 123 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */ 124 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */ 125 static bool dead_key_next; 126 static int npadch = -1; /* -1 or number assembled on pad */ 127 static unsigned int diacr; 128 static char rep; /* flag telling character repeat */ 129 130 static int shift_state = 0; 131 132 static unsigned char ledstate = 0xff; /* undefined */ 133 static unsigned char ledioctl; 134 135 static struct ledptr { 136 unsigned int *addr; 137 unsigned int mask; 138 unsigned char valid:1; 139 } ledptrs[3]; 140 141 /* 142 * Notifier list for console keyboard events 143 */ 144 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list); 145 146 int register_keyboard_notifier(struct notifier_block *nb) 147 { 148 return atomic_notifier_chain_register(&keyboard_notifier_list, nb); 149 } 150 EXPORT_SYMBOL_GPL(register_keyboard_notifier); 151 152 int unregister_keyboard_notifier(struct notifier_block *nb) 153 { 154 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb); 155 } 156 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier); 157 158 /* 159 * Translation of scancodes to keycodes. We set them on only the first 160 * keyboard in the list that accepts the scancode and keycode. 161 * Explanation for not choosing the first attached keyboard anymore: 162 * USB keyboards for example have two event devices: one for all "normal" 163 * keys and one for extra function keys (like "volume up", "make coffee", 164 * etc.). So this means that scancodes for the extra function keys won't 165 * be valid for the first event device, but will be for the second. 166 */ 167 168 struct getset_keycode_data { 169 struct input_keymap_entry ke; 170 int error; 171 }; 172 173 static int getkeycode_helper(struct input_handle *handle, void *data) 174 { 175 struct getset_keycode_data *d = data; 176 177 d->error = input_get_keycode(handle->dev, &d->ke); 178 179 return d->error == 0; /* stop as soon as we successfully get one */ 180 } 181 182 static int getkeycode(unsigned int scancode) 183 { 184 struct getset_keycode_data d = { 185 .ke = { 186 .flags = 0, 187 .len = sizeof(scancode), 188 .keycode = 0, 189 }, 190 .error = -ENODEV, 191 }; 192 193 memcpy(d.ke.scancode, &scancode, sizeof(scancode)); 194 195 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper); 196 197 return d.error ?: d.ke.keycode; 198 } 199 200 static int setkeycode_helper(struct input_handle *handle, void *data) 201 { 202 struct getset_keycode_data *d = data; 203 204 d->error = input_set_keycode(handle->dev, &d->ke); 205 206 return d->error == 0; /* stop as soon as we successfully set one */ 207 } 208 209 static int setkeycode(unsigned int scancode, unsigned int keycode) 210 { 211 struct getset_keycode_data d = { 212 .ke = { 213 .flags = 0, 214 .len = sizeof(scancode), 215 .keycode = keycode, 216 }, 217 .error = -ENODEV, 218 }; 219 220 memcpy(d.ke.scancode, &scancode, sizeof(scancode)); 221 222 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper); 223 224 return d.error; 225 } 226 227 /* 228 * Making beeps and bells. Note that we prefer beeps to bells, but when 229 * shutting the sound off we do both. 230 */ 231 232 static int kd_sound_helper(struct input_handle *handle, void *data) 233 { 234 unsigned int *hz = data; 235 struct input_dev *dev = handle->dev; 236 237 if (test_bit(EV_SND, dev->evbit)) { 238 if (test_bit(SND_TONE, dev->sndbit)) { 239 input_inject_event(handle, EV_SND, SND_TONE, *hz); 240 if (*hz) 241 return 0; 242 } 243 if (test_bit(SND_BELL, dev->sndbit)) 244 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0); 245 } 246 247 return 0; 248 } 249 250 static void kd_nosound(unsigned long ignored) 251 { 252 static unsigned int zero; 253 254 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper); 255 } 256 257 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0); 258 259 void kd_mksound(unsigned int hz, unsigned int ticks) 260 { 261 del_timer_sync(&kd_mksound_timer); 262 263 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper); 264 265 if (hz && ticks) 266 mod_timer(&kd_mksound_timer, jiffies + ticks); 267 } 268 EXPORT_SYMBOL(kd_mksound); 269 270 /* 271 * Setting the keyboard rate. 272 */ 273 274 static int kbd_rate_helper(struct input_handle *handle, void *data) 275 { 276 struct input_dev *dev = handle->dev; 277 struct kbd_repeat *rep = data; 278 279 if (test_bit(EV_REP, dev->evbit)) { 280 281 if (rep[0].delay > 0) 282 input_inject_event(handle, 283 EV_REP, REP_DELAY, rep[0].delay); 284 if (rep[0].period > 0) 285 input_inject_event(handle, 286 EV_REP, REP_PERIOD, rep[0].period); 287 288 rep[1].delay = dev->rep[REP_DELAY]; 289 rep[1].period = dev->rep[REP_PERIOD]; 290 } 291 292 return 0; 293 } 294 295 int kbd_rate(struct kbd_repeat *rep) 296 { 297 struct kbd_repeat data[2] = { *rep }; 298 299 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper); 300 *rep = data[1]; /* Copy currently used settings */ 301 302 return 0; 303 } 304 305 /* 306 * Helper Functions. 307 */ 308 static void put_queue(struct vc_data *vc, int ch) 309 { 310 struct tty_struct *tty = vc->port.tty; 311 312 if (tty) { 313 tty_insert_flip_char(tty, ch, 0); 314 tty_schedule_flip(tty); 315 } 316 } 317 318 static void puts_queue(struct vc_data *vc, char *cp) 319 { 320 struct tty_struct *tty = vc->port.tty; 321 322 if (!tty) 323 return; 324 325 while (*cp) { 326 tty_insert_flip_char(tty, *cp, 0); 327 cp++; 328 } 329 tty_schedule_flip(tty); 330 } 331 332 static void applkey(struct vc_data *vc, int key, char mode) 333 { 334 static char buf[] = { 0x1b, 'O', 0x00, 0x00 }; 335 336 buf[1] = (mode ? 'O' : '['); 337 buf[2] = key; 338 puts_queue(vc, buf); 339 } 340 341 /* 342 * Many other routines do put_queue, but I think either 343 * they produce ASCII, or they produce some user-assigned 344 * string, and in both cases we might assume that it is 345 * in utf-8 already. 346 */ 347 static void to_utf8(struct vc_data *vc, uint c) 348 { 349 if (c < 0x80) 350 /* 0******* */ 351 put_queue(vc, c); 352 else if (c < 0x800) { 353 /* 110***** 10****** */ 354 put_queue(vc, 0xc0 | (c >> 6)); 355 put_queue(vc, 0x80 | (c & 0x3f)); 356 } else if (c < 0x10000) { 357 if (c >= 0xD800 && c < 0xE000) 358 return; 359 if (c == 0xFFFF) 360 return; 361 /* 1110**** 10****** 10****** */ 362 put_queue(vc, 0xe0 | (c >> 12)); 363 put_queue(vc, 0x80 | ((c >> 6) & 0x3f)); 364 put_queue(vc, 0x80 | (c & 0x3f)); 365 } else if (c < 0x110000) { 366 /* 11110*** 10****** 10****** 10****** */ 367 put_queue(vc, 0xf0 | (c >> 18)); 368 put_queue(vc, 0x80 | ((c >> 12) & 0x3f)); 369 put_queue(vc, 0x80 | ((c >> 6) & 0x3f)); 370 put_queue(vc, 0x80 | (c & 0x3f)); 371 } 372 } 373 374 /* 375 * Called after returning from RAW mode or when changing consoles - recompute 376 * shift_down[] and shift_state from key_down[] maybe called when keymap is 377 * undefined, so that shiftkey release is seen. The caller must hold the 378 * kbd_event_lock. 379 */ 380 381 static void do_compute_shiftstate(void) 382 { 383 unsigned int i, j, k, sym, val; 384 385 shift_state = 0; 386 memset(shift_down, 0, sizeof(shift_down)); 387 388 for (i = 0; i < ARRAY_SIZE(key_down); i++) { 389 390 if (!key_down[i]) 391 continue; 392 393 k = i * BITS_PER_LONG; 394 395 for (j = 0; j < BITS_PER_LONG; j++, k++) { 396 397 if (!test_bit(k, key_down)) 398 continue; 399 400 sym = U(key_maps[0][k]); 401 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK) 402 continue; 403 404 val = KVAL(sym); 405 if (val == KVAL(K_CAPSSHIFT)) 406 val = KVAL(K_SHIFT); 407 408 shift_down[val]++; 409 shift_state |= (1 << val); 410 } 411 } 412 } 413 414 /* We still have to export this method to vt.c */ 415 void compute_shiftstate(void) 416 { 417 unsigned long flags; 418 spin_lock_irqsave(&kbd_event_lock, flags); 419 do_compute_shiftstate(); 420 spin_unlock_irqrestore(&kbd_event_lock, flags); 421 } 422 423 /* 424 * We have a combining character DIACR here, followed by the character CH. 425 * If the combination occurs in the table, return the corresponding value. 426 * Otherwise, if CH is a space or equals DIACR, return DIACR. 427 * Otherwise, conclude that DIACR was not combining after all, 428 * queue it and return CH. 429 */ 430 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch) 431 { 432 unsigned int d = diacr; 433 unsigned int i; 434 435 diacr = 0; 436 437 if ((d & ~0xff) == BRL_UC_ROW) { 438 if ((ch & ~0xff) == BRL_UC_ROW) 439 return d | ch; 440 } else { 441 for (i = 0; i < accent_table_size; i++) 442 if (accent_table[i].diacr == d && accent_table[i].base == ch) 443 return accent_table[i].result; 444 } 445 446 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d) 447 return d; 448 449 if (kbd->kbdmode == VC_UNICODE) 450 to_utf8(vc, d); 451 else { 452 int c = conv_uni_to_8bit(d); 453 if (c != -1) 454 put_queue(vc, c); 455 } 456 457 return ch; 458 } 459 460 /* 461 * Special function handlers 462 */ 463 static void fn_enter(struct vc_data *vc) 464 { 465 if (diacr) { 466 if (kbd->kbdmode == VC_UNICODE) 467 to_utf8(vc, diacr); 468 else { 469 int c = conv_uni_to_8bit(diacr); 470 if (c != -1) 471 put_queue(vc, c); 472 } 473 diacr = 0; 474 } 475 476 put_queue(vc, 13); 477 if (vc_kbd_mode(kbd, VC_CRLF)) 478 put_queue(vc, 10); 479 } 480 481 static void fn_caps_toggle(struct vc_data *vc) 482 { 483 if (rep) 484 return; 485 486 chg_vc_kbd_led(kbd, VC_CAPSLOCK); 487 } 488 489 static void fn_caps_on(struct vc_data *vc) 490 { 491 if (rep) 492 return; 493 494 set_vc_kbd_led(kbd, VC_CAPSLOCK); 495 } 496 497 static void fn_show_ptregs(struct vc_data *vc) 498 { 499 struct pt_regs *regs = get_irq_regs(); 500 501 if (regs) 502 show_regs(regs); 503 } 504 505 static void fn_hold(struct vc_data *vc) 506 { 507 struct tty_struct *tty = vc->port.tty; 508 509 if (rep || !tty) 510 return; 511 512 /* 513 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty); 514 * these routines are also activated by ^S/^Q. 515 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.) 516 */ 517 if (tty->stopped) 518 start_tty(tty); 519 else 520 stop_tty(tty); 521 } 522 523 static void fn_num(struct vc_data *vc) 524 { 525 if (vc_kbd_mode(kbd, VC_APPLIC)) 526 applkey(vc, 'P', 1); 527 else 528 fn_bare_num(vc); 529 } 530 531 /* 532 * Bind this to Shift-NumLock if you work in application keypad mode 533 * but want to be able to change the NumLock flag. 534 * Bind this to NumLock if you prefer that the NumLock key always 535 * changes the NumLock flag. 536 */ 537 static void fn_bare_num(struct vc_data *vc) 538 { 539 if (!rep) 540 chg_vc_kbd_led(kbd, VC_NUMLOCK); 541 } 542 543 static void fn_lastcons(struct vc_data *vc) 544 { 545 /* switch to the last used console, ChN */ 546 set_console(last_console); 547 } 548 549 static void fn_dec_console(struct vc_data *vc) 550 { 551 int i, cur = fg_console; 552 553 /* Currently switching? Queue this next switch relative to that. */ 554 if (want_console != -1) 555 cur = want_console; 556 557 for (i = cur - 1; i != cur; i--) { 558 if (i == -1) 559 i = MAX_NR_CONSOLES - 1; 560 if (vc_cons_allocated(i)) 561 break; 562 } 563 set_console(i); 564 } 565 566 static void fn_inc_console(struct vc_data *vc) 567 { 568 int i, cur = fg_console; 569 570 /* Currently switching? Queue this next switch relative to that. */ 571 if (want_console != -1) 572 cur = want_console; 573 574 for (i = cur+1; i != cur; i++) { 575 if (i == MAX_NR_CONSOLES) 576 i = 0; 577 if (vc_cons_allocated(i)) 578 break; 579 } 580 set_console(i); 581 } 582 583 static void fn_send_intr(struct vc_data *vc) 584 { 585 struct tty_struct *tty = vc->port.tty; 586 587 if (!tty) 588 return; 589 tty_insert_flip_char(tty, 0, TTY_BREAK); 590 tty_schedule_flip(tty); 591 } 592 593 static void fn_scroll_forw(struct vc_data *vc) 594 { 595 scrollfront(vc, 0); 596 } 597 598 static void fn_scroll_back(struct vc_data *vc) 599 { 600 scrollback(vc, 0); 601 } 602 603 static void fn_show_mem(struct vc_data *vc) 604 { 605 show_mem(0); 606 } 607 608 static void fn_show_state(struct vc_data *vc) 609 { 610 show_state(); 611 } 612 613 static void fn_boot_it(struct vc_data *vc) 614 { 615 ctrl_alt_del(); 616 } 617 618 static void fn_compose(struct vc_data *vc) 619 { 620 dead_key_next = true; 621 } 622 623 static void fn_spawn_con(struct vc_data *vc) 624 { 625 spin_lock(&vt_spawn_con.lock); 626 if (vt_spawn_con.pid) 627 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) { 628 put_pid(vt_spawn_con.pid); 629 vt_spawn_con.pid = NULL; 630 } 631 spin_unlock(&vt_spawn_con.lock); 632 } 633 634 static void fn_SAK(struct vc_data *vc) 635 { 636 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work; 637 schedule_work(SAK_work); 638 } 639 640 static void fn_null(struct vc_data *vc) 641 { 642 do_compute_shiftstate(); 643 } 644 645 /* 646 * Special key handlers 647 */ 648 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag) 649 { 650 } 651 652 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag) 653 { 654 if (up_flag) 655 return; 656 if (value >= ARRAY_SIZE(fn_handler)) 657 return; 658 if ((kbd->kbdmode == VC_RAW || 659 kbd->kbdmode == VC_MEDIUMRAW || 660 kbd->kbdmode == VC_OFF) && 661 value != KVAL(K_SAK)) 662 return; /* SAK is allowed even in raw mode */ 663 fn_handler[value](vc); 664 } 665 666 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag) 667 { 668 pr_err("k_lowercase was called - impossible\n"); 669 } 670 671 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag) 672 { 673 if (up_flag) 674 return; /* no action, if this is a key release */ 675 676 if (diacr) 677 value = handle_diacr(vc, value); 678 679 if (dead_key_next) { 680 dead_key_next = false; 681 diacr = value; 682 return; 683 } 684 if (kbd->kbdmode == VC_UNICODE) 685 to_utf8(vc, value); 686 else { 687 int c = conv_uni_to_8bit(value); 688 if (c != -1) 689 put_queue(vc, c); 690 } 691 } 692 693 /* 694 * Handle dead key. Note that we now may have several 695 * dead keys modifying the same character. Very useful 696 * for Vietnamese. 697 */ 698 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag) 699 { 700 if (up_flag) 701 return; 702 703 diacr = (diacr ? handle_diacr(vc, value) : value); 704 } 705 706 static void k_self(struct vc_data *vc, unsigned char value, char up_flag) 707 { 708 k_unicode(vc, conv_8bit_to_uni(value), up_flag); 709 } 710 711 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag) 712 { 713 k_deadunicode(vc, value, up_flag); 714 } 715 716 /* 717 * Obsolete - for backwards compatibility only 718 */ 719 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag) 720 { 721 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' }; 722 723 k_deadunicode(vc, ret_diacr[value], up_flag); 724 } 725 726 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag) 727 { 728 if (up_flag) 729 return; 730 731 set_console(value); 732 } 733 734 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag) 735 { 736 if (up_flag) 737 return; 738 739 if ((unsigned)value < ARRAY_SIZE(func_table)) { 740 if (func_table[value]) 741 puts_queue(vc, func_table[value]); 742 } else 743 pr_err("k_fn called with value=%d\n", value); 744 } 745 746 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag) 747 { 748 static const char cur_chars[] = "BDCA"; 749 750 if (up_flag) 751 return; 752 753 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE)); 754 } 755 756 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag) 757 { 758 static const char pad_chars[] = "0123456789+-*/\015,.?()#"; 759 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS"; 760 761 if (up_flag) 762 return; /* no action, if this is a key release */ 763 764 /* kludge... shift forces cursor/number keys */ 765 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) { 766 applkey(vc, app_map[value], 1); 767 return; 768 } 769 770 if (!vc_kbd_led(kbd, VC_NUMLOCK)) { 771 772 switch (value) { 773 case KVAL(K_PCOMMA): 774 case KVAL(K_PDOT): 775 k_fn(vc, KVAL(K_REMOVE), 0); 776 return; 777 case KVAL(K_P0): 778 k_fn(vc, KVAL(K_INSERT), 0); 779 return; 780 case KVAL(K_P1): 781 k_fn(vc, KVAL(K_SELECT), 0); 782 return; 783 case KVAL(K_P2): 784 k_cur(vc, KVAL(K_DOWN), 0); 785 return; 786 case KVAL(K_P3): 787 k_fn(vc, KVAL(K_PGDN), 0); 788 return; 789 case KVAL(K_P4): 790 k_cur(vc, KVAL(K_LEFT), 0); 791 return; 792 case KVAL(K_P6): 793 k_cur(vc, KVAL(K_RIGHT), 0); 794 return; 795 case KVAL(K_P7): 796 k_fn(vc, KVAL(K_FIND), 0); 797 return; 798 case KVAL(K_P8): 799 k_cur(vc, KVAL(K_UP), 0); 800 return; 801 case KVAL(K_P9): 802 k_fn(vc, KVAL(K_PGUP), 0); 803 return; 804 case KVAL(K_P5): 805 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC)); 806 return; 807 } 808 } 809 810 put_queue(vc, pad_chars[value]); 811 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF)) 812 put_queue(vc, 10); 813 } 814 815 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag) 816 { 817 int old_state = shift_state; 818 819 if (rep) 820 return; 821 /* 822 * Mimic typewriter: 823 * a CapsShift key acts like Shift but undoes CapsLock 824 */ 825 if (value == KVAL(K_CAPSSHIFT)) { 826 value = KVAL(K_SHIFT); 827 if (!up_flag) 828 clr_vc_kbd_led(kbd, VC_CAPSLOCK); 829 } 830 831 if (up_flag) { 832 /* 833 * handle the case that two shift or control 834 * keys are depressed simultaneously 835 */ 836 if (shift_down[value]) 837 shift_down[value]--; 838 } else 839 shift_down[value]++; 840 841 if (shift_down[value]) 842 shift_state |= (1 << value); 843 else 844 shift_state &= ~(1 << value); 845 846 /* kludge */ 847 if (up_flag && shift_state != old_state && npadch != -1) { 848 if (kbd->kbdmode == VC_UNICODE) 849 to_utf8(vc, npadch); 850 else 851 put_queue(vc, npadch & 0xff); 852 npadch = -1; 853 } 854 } 855 856 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag) 857 { 858 if (up_flag) 859 return; 860 861 if (vc_kbd_mode(kbd, VC_META)) { 862 put_queue(vc, '\033'); 863 put_queue(vc, value); 864 } else 865 put_queue(vc, value | 0x80); 866 } 867 868 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag) 869 { 870 int base; 871 872 if (up_flag) 873 return; 874 875 if (value < 10) { 876 /* decimal input of code, while Alt depressed */ 877 base = 10; 878 } else { 879 /* hexadecimal input of code, while AltGr depressed */ 880 value -= 10; 881 base = 16; 882 } 883 884 if (npadch == -1) 885 npadch = value; 886 else 887 npadch = npadch * base + value; 888 } 889 890 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag) 891 { 892 if (up_flag || rep) 893 return; 894 895 chg_vc_kbd_lock(kbd, value); 896 } 897 898 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag) 899 { 900 k_shift(vc, value, up_flag); 901 if (up_flag || rep) 902 return; 903 904 chg_vc_kbd_slock(kbd, value); 905 /* try to make Alt, oops, AltGr and such work */ 906 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) { 907 kbd->slockstate = 0; 908 chg_vc_kbd_slock(kbd, value); 909 } 910 } 911 912 /* by default, 300ms interval for combination release */ 913 static unsigned brl_timeout = 300; 914 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)"); 915 module_param(brl_timeout, uint, 0644); 916 917 static unsigned brl_nbchords = 1; 918 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)"); 919 module_param(brl_nbchords, uint, 0644); 920 921 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag) 922 { 923 static unsigned long chords; 924 static unsigned committed; 925 926 if (!brl_nbchords) 927 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag); 928 else { 929 committed |= pattern; 930 chords++; 931 if (chords == brl_nbchords) { 932 k_unicode(vc, BRL_UC_ROW | committed, up_flag); 933 chords = 0; 934 committed = 0; 935 } 936 } 937 } 938 939 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag) 940 { 941 static unsigned pressed, committing; 942 static unsigned long releasestart; 943 944 if (kbd->kbdmode != VC_UNICODE) { 945 if (!up_flag) 946 pr_warning("keyboard mode must be unicode for braille patterns\n"); 947 return; 948 } 949 950 if (!value) { 951 k_unicode(vc, BRL_UC_ROW, up_flag); 952 return; 953 } 954 955 if (value > 8) 956 return; 957 958 if (!up_flag) { 959 pressed |= 1 << (value - 1); 960 if (!brl_timeout) 961 committing = pressed; 962 } else if (brl_timeout) { 963 if (!committing || 964 time_after(jiffies, 965 releasestart + msecs_to_jiffies(brl_timeout))) { 966 committing = pressed; 967 releasestart = jiffies; 968 } 969 pressed &= ~(1 << (value - 1)); 970 if (!pressed && committing) { 971 k_brlcommit(vc, committing, 0); 972 committing = 0; 973 } 974 } else { 975 if (committing) { 976 k_brlcommit(vc, committing, 0); 977 committing = 0; 978 } 979 pressed &= ~(1 << (value - 1)); 980 } 981 } 982 983 /* 984 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock, 985 * or (ii) whatever pattern of lights people want to show using KDSETLED, 986 * or (iii) specified bits of specified words in kernel memory. 987 */ 988 static unsigned char getledstate(void) 989 { 990 return ledstate; 991 } 992 993 void setledstate(struct kbd_struct *kbd, unsigned int led) 994 { 995 unsigned long flags; 996 spin_lock_irqsave(&led_lock, flags); 997 if (!(led & ~7)) { 998 ledioctl = led; 999 kbd->ledmode = LED_SHOW_IOCTL; 1000 } else 1001 kbd->ledmode = LED_SHOW_FLAGS; 1002 1003 set_leds(); 1004 spin_unlock_irqrestore(&led_lock, flags); 1005 } 1006 1007 static inline unsigned char getleds(void) 1008 { 1009 struct kbd_struct *kbd = kbd_table + fg_console; 1010 unsigned char leds; 1011 int i; 1012 1013 if (kbd->ledmode == LED_SHOW_IOCTL) 1014 return ledioctl; 1015 1016 leds = kbd->ledflagstate; 1017 1018 if (kbd->ledmode == LED_SHOW_MEM) { 1019 for (i = 0; i < 3; i++) 1020 if (ledptrs[i].valid) { 1021 if (*ledptrs[i].addr & ledptrs[i].mask) 1022 leds |= (1 << i); 1023 else 1024 leds &= ~(1 << i); 1025 } 1026 } 1027 return leds; 1028 } 1029 1030 static int kbd_update_leds_helper(struct input_handle *handle, void *data) 1031 { 1032 unsigned char leds = *(unsigned char *)data; 1033 1034 if (test_bit(EV_LED, handle->dev->evbit)) { 1035 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01)); 1036 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02)); 1037 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04)); 1038 input_inject_event(handle, EV_SYN, SYN_REPORT, 0); 1039 } 1040 1041 return 0; 1042 } 1043 1044 /** 1045 * vt_get_leds - helper for braille console 1046 * @console: console to read 1047 * @flag: flag we want to check 1048 * 1049 * Check the status of a keyboard led flag and report it back 1050 */ 1051 int vt_get_leds(int console, int flag) 1052 { 1053 struct kbd_struct * kbd = kbd_table + console; 1054 int ret; 1055 unsigned long flags; 1056 1057 spin_lock_irqsave(&led_lock, flags); 1058 ret = vc_kbd_led(kbd, flag); 1059 spin_unlock_irqrestore(&led_lock, flags); 1060 1061 return ret; 1062 } 1063 EXPORT_SYMBOL_GPL(vt_get_leds); 1064 1065 /** 1066 * vt_set_led_state - set LED state of a console 1067 * @console: console to set 1068 * @leds: LED bits 1069 * 1070 * Set the LEDs on a console. This is a wrapper for the VT layer 1071 * so that we can keep kbd knowledge internal 1072 */ 1073 void vt_set_led_state(int console, int leds) 1074 { 1075 struct kbd_struct * kbd = kbd_table + console; 1076 setledstate(kbd, leds); 1077 } 1078 1079 /** 1080 * vt_kbd_con_start - Keyboard side of console start 1081 * @console: console 1082 * 1083 * Handle console start. This is a wrapper for the VT layer 1084 * so that we can keep kbd knowledge internal 1085 * 1086 * FIXME: We eventually need to hold the kbd lock here to protect 1087 * the LED updating. We can't do it yet because fn_hold calls stop_tty 1088 * and start_tty under the kbd_event_lock, while normal tty paths 1089 * don't hold the lock. We probably need to split out an LED lock 1090 * but not during an -rc release! 1091 */ 1092 void vt_kbd_con_start(int console) 1093 { 1094 struct kbd_struct * kbd = kbd_table + console; 1095 unsigned long flags; 1096 spin_lock_irqsave(&led_lock, flags); 1097 clr_vc_kbd_led(kbd, VC_SCROLLOCK); 1098 set_leds(); 1099 spin_unlock_irqrestore(&led_lock, flags); 1100 } 1101 1102 /** 1103 * vt_kbd_con_stop - Keyboard side of console stop 1104 * @console: console 1105 * 1106 * Handle console stop. This is a wrapper for the VT layer 1107 * so that we can keep kbd knowledge internal 1108 */ 1109 void vt_kbd_con_stop(int console) 1110 { 1111 struct kbd_struct * kbd = kbd_table + console; 1112 unsigned long flags; 1113 spin_lock_irqsave(&led_lock, flags); 1114 set_vc_kbd_led(kbd, VC_SCROLLOCK); 1115 set_leds(); 1116 spin_unlock_irqrestore(&led_lock, flags); 1117 } 1118 1119 /* 1120 * This is the tasklet that updates LED state on all keyboards 1121 * attached to the box. The reason we use tasklet is that we 1122 * need to handle the scenario when keyboard handler is not 1123 * registered yet but we already getting updates from the VT to 1124 * update led state. 1125 */ 1126 static void kbd_bh(unsigned long dummy) 1127 { 1128 unsigned char leds; 1129 unsigned long flags; 1130 1131 spin_lock_irqsave(&led_lock, flags); 1132 leds = getleds(); 1133 spin_unlock_irqrestore(&led_lock, flags); 1134 1135 if (leds != ledstate) { 1136 input_handler_for_each_handle(&kbd_handler, &leds, 1137 kbd_update_leds_helper); 1138 ledstate = leds; 1139 } 1140 } 1141 1142 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0); 1143 1144 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\ 1145 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\ 1146 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\ 1147 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\ 1148 defined(CONFIG_AVR32) 1149 1150 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\ 1151 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001)) 1152 1153 static const unsigned short x86_keycodes[256] = 1154 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1155 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1156 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 1157 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 1158 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1159 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92, 1160 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339, 1161 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349, 1162 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355, 1163 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361, 1164 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114, 1165 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116, 1166 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307, 1167 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330, 1168 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 }; 1169 1170 #ifdef CONFIG_SPARC 1171 static int sparc_l1_a_state; 1172 extern void sun_do_break(void); 1173 #endif 1174 1175 static int emulate_raw(struct vc_data *vc, unsigned int keycode, 1176 unsigned char up_flag) 1177 { 1178 int code; 1179 1180 switch (keycode) { 1181 1182 case KEY_PAUSE: 1183 put_queue(vc, 0xe1); 1184 put_queue(vc, 0x1d | up_flag); 1185 put_queue(vc, 0x45 | up_flag); 1186 break; 1187 1188 case KEY_HANGEUL: 1189 if (!up_flag) 1190 put_queue(vc, 0xf2); 1191 break; 1192 1193 case KEY_HANJA: 1194 if (!up_flag) 1195 put_queue(vc, 0xf1); 1196 break; 1197 1198 case KEY_SYSRQ: 1199 /* 1200 * Real AT keyboards (that's what we're trying 1201 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when 1202 * pressing PrtSc/SysRq alone, but simply 0x54 1203 * when pressing Alt+PrtSc/SysRq. 1204 */ 1205 if (test_bit(KEY_LEFTALT, key_down) || 1206 test_bit(KEY_RIGHTALT, key_down)) { 1207 put_queue(vc, 0x54 | up_flag); 1208 } else { 1209 put_queue(vc, 0xe0); 1210 put_queue(vc, 0x2a | up_flag); 1211 put_queue(vc, 0xe0); 1212 put_queue(vc, 0x37 | up_flag); 1213 } 1214 break; 1215 1216 default: 1217 if (keycode > 255) 1218 return -1; 1219 1220 code = x86_keycodes[keycode]; 1221 if (!code) 1222 return -1; 1223 1224 if (code & 0x100) 1225 put_queue(vc, 0xe0); 1226 put_queue(vc, (code & 0x7f) | up_flag); 1227 1228 break; 1229 } 1230 1231 return 0; 1232 } 1233 1234 #else 1235 1236 #define HW_RAW(dev) 0 1237 1238 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag) 1239 { 1240 if (keycode > 127) 1241 return -1; 1242 1243 put_queue(vc, keycode | up_flag); 1244 return 0; 1245 } 1246 #endif 1247 1248 static void kbd_rawcode(unsigned char data) 1249 { 1250 struct vc_data *vc = vc_cons[fg_console].d; 1251 1252 kbd = kbd_table + vc->vc_num; 1253 if (kbd->kbdmode == VC_RAW) 1254 put_queue(vc, data); 1255 } 1256 1257 static void kbd_keycode(unsigned int keycode, int down, int hw_raw) 1258 { 1259 struct vc_data *vc = vc_cons[fg_console].d; 1260 unsigned short keysym, *key_map; 1261 unsigned char type; 1262 bool raw_mode; 1263 struct tty_struct *tty; 1264 int shift_final; 1265 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down }; 1266 int rc; 1267 1268 tty = vc->port.tty; 1269 1270 if (tty && (!tty->driver_data)) { 1271 /* No driver data? Strange. Okay we fix it then. */ 1272 tty->driver_data = vc; 1273 } 1274 1275 kbd = kbd_table + vc->vc_num; 1276 1277 #ifdef CONFIG_SPARC 1278 if (keycode == KEY_STOP) 1279 sparc_l1_a_state = down; 1280 #endif 1281 1282 rep = (down == 2); 1283 1284 raw_mode = (kbd->kbdmode == VC_RAW); 1285 if (raw_mode && !hw_raw) 1286 if (emulate_raw(vc, keycode, !down << 7)) 1287 if (keycode < BTN_MISC && printk_ratelimit()) 1288 pr_warning("can't emulate rawmode for keycode %d\n", 1289 keycode); 1290 1291 #ifdef CONFIG_SPARC 1292 if (keycode == KEY_A && sparc_l1_a_state) { 1293 sparc_l1_a_state = false; 1294 sun_do_break(); 1295 } 1296 #endif 1297 1298 if (kbd->kbdmode == VC_MEDIUMRAW) { 1299 /* 1300 * This is extended medium raw mode, with keys above 127 1301 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing 1302 * the 'up' flag if needed. 0 is reserved, so this shouldn't 1303 * interfere with anything else. The two bytes after 0 will 1304 * always have the up flag set not to interfere with older 1305 * applications. This allows for 16384 different keycodes, 1306 * which should be enough. 1307 */ 1308 if (keycode < 128) { 1309 put_queue(vc, keycode | (!down << 7)); 1310 } else { 1311 put_queue(vc, !down << 7); 1312 put_queue(vc, (keycode >> 7) | 0x80); 1313 put_queue(vc, keycode | 0x80); 1314 } 1315 raw_mode = true; 1316 } 1317 1318 if (down) 1319 set_bit(keycode, key_down); 1320 else 1321 clear_bit(keycode, key_down); 1322 1323 if (rep && 1324 (!vc_kbd_mode(kbd, VC_REPEAT) || 1325 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) { 1326 /* 1327 * Don't repeat a key if the input buffers are not empty and the 1328 * characters get aren't echoed locally. This makes key repeat 1329 * usable with slow applications and under heavy loads. 1330 */ 1331 return; 1332 } 1333 1334 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate; 1335 param.ledstate = kbd->ledflagstate; 1336 key_map = key_maps[shift_final]; 1337 1338 rc = atomic_notifier_call_chain(&keyboard_notifier_list, 1339 KBD_KEYCODE, ¶m); 1340 if (rc == NOTIFY_STOP || !key_map) { 1341 atomic_notifier_call_chain(&keyboard_notifier_list, 1342 KBD_UNBOUND_KEYCODE, ¶m); 1343 do_compute_shiftstate(); 1344 kbd->slockstate = 0; 1345 return; 1346 } 1347 1348 if (keycode < NR_KEYS) 1349 keysym = key_map[keycode]; 1350 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8) 1351 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1)); 1352 else 1353 return; 1354 1355 type = KTYP(keysym); 1356 1357 if (type < 0xf0) { 1358 param.value = keysym; 1359 rc = atomic_notifier_call_chain(&keyboard_notifier_list, 1360 KBD_UNICODE, ¶m); 1361 if (rc != NOTIFY_STOP) 1362 if (down && !raw_mode) 1363 to_utf8(vc, keysym); 1364 return; 1365 } 1366 1367 type -= 0xf0; 1368 1369 if (type == KT_LETTER) { 1370 type = KT_LATIN; 1371 if (vc_kbd_led(kbd, VC_CAPSLOCK)) { 1372 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)]; 1373 if (key_map) 1374 keysym = key_map[keycode]; 1375 } 1376 } 1377 1378 param.value = keysym; 1379 rc = atomic_notifier_call_chain(&keyboard_notifier_list, 1380 KBD_KEYSYM, ¶m); 1381 if (rc == NOTIFY_STOP) 1382 return; 1383 1384 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT) 1385 return; 1386 1387 (*k_handler[type])(vc, keysym & 0xff, !down); 1388 1389 param.ledstate = kbd->ledflagstate; 1390 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m); 1391 1392 if (type != KT_SLOCK) 1393 kbd->slockstate = 0; 1394 } 1395 1396 static void kbd_event(struct input_handle *handle, unsigned int event_type, 1397 unsigned int event_code, int value) 1398 { 1399 /* We are called with interrupts disabled, just take the lock */ 1400 spin_lock(&kbd_event_lock); 1401 1402 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev)) 1403 kbd_rawcode(value); 1404 if (event_type == EV_KEY) 1405 kbd_keycode(event_code, value, HW_RAW(handle->dev)); 1406 1407 spin_unlock(&kbd_event_lock); 1408 1409 tasklet_schedule(&keyboard_tasklet); 1410 do_poke_blanked_console = 1; 1411 schedule_console_callback(); 1412 } 1413 1414 static bool kbd_match(struct input_handler *handler, struct input_dev *dev) 1415 { 1416 int i; 1417 1418 if (test_bit(EV_SND, dev->evbit)) 1419 return true; 1420 1421 if (test_bit(EV_KEY, dev->evbit)) { 1422 for (i = KEY_RESERVED; i < BTN_MISC; i++) 1423 if (test_bit(i, dev->keybit)) 1424 return true; 1425 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++) 1426 if (test_bit(i, dev->keybit)) 1427 return true; 1428 } 1429 1430 return false; 1431 } 1432 1433 /* 1434 * When a keyboard (or other input device) is found, the kbd_connect 1435 * function is called. The function then looks at the device, and if it 1436 * likes it, it can open it and get events from it. In this (kbd_connect) 1437 * function, we should decide which VT to bind that keyboard to initially. 1438 */ 1439 static int kbd_connect(struct input_handler *handler, struct input_dev *dev, 1440 const struct input_device_id *id) 1441 { 1442 struct input_handle *handle; 1443 int error; 1444 1445 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL); 1446 if (!handle) 1447 return -ENOMEM; 1448 1449 handle->dev = dev; 1450 handle->handler = handler; 1451 handle->name = "kbd"; 1452 1453 error = input_register_handle(handle); 1454 if (error) 1455 goto err_free_handle; 1456 1457 error = input_open_device(handle); 1458 if (error) 1459 goto err_unregister_handle; 1460 1461 return 0; 1462 1463 err_unregister_handle: 1464 input_unregister_handle(handle); 1465 err_free_handle: 1466 kfree(handle); 1467 return error; 1468 } 1469 1470 static void kbd_disconnect(struct input_handle *handle) 1471 { 1472 input_close_device(handle); 1473 input_unregister_handle(handle); 1474 kfree(handle); 1475 } 1476 1477 /* 1478 * Start keyboard handler on the new keyboard by refreshing LED state to 1479 * match the rest of the system. 1480 */ 1481 static void kbd_start(struct input_handle *handle) 1482 { 1483 tasklet_disable(&keyboard_tasklet); 1484 1485 if (ledstate != 0xff) 1486 kbd_update_leds_helper(handle, &ledstate); 1487 1488 tasklet_enable(&keyboard_tasklet); 1489 } 1490 1491 static const struct input_device_id kbd_ids[] = { 1492 { 1493 .flags = INPUT_DEVICE_ID_MATCH_EVBIT, 1494 .evbit = { BIT_MASK(EV_KEY) }, 1495 }, 1496 1497 { 1498 .flags = INPUT_DEVICE_ID_MATCH_EVBIT, 1499 .evbit = { BIT_MASK(EV_SND) }, 1500 }, 1501 1502 { }, /* Terminating entry */ 1503 }; 1504 1505 MODULE_DEVICE_TABLE(input, kbd_ids); 1506 1507 static struct input_handler kbd_handler = { 1508 .event = kbd_event, 1509 .match = kbd_match, 1510 .connect = kbd_connect, 1511 .disconnect = kbd_disconnect, 1512 .start = kbd_start, 1513 .name = "kbd", 1514 .id_table = kbd_ids, 1515 }; 1516 1517 int __init kbd_init(void) 1518 { 1519 int i; 1520 int error; 1521 1522 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1523 kbd_table[i].ledflagstate = kbd_defleds(); 1524 kbd_table[i].default_ledflagstate = kbd_defleds(); 1525 kbd_table[i].ledmode = LED_SHOW_FLAGS; 1526 kbd_table[i].lockstate = KBD_DEFLOCK; 1527 kbd_table[i].slockstate = 0; 1528 kbd_table[i].modeflags = KBD_DEFMODE; 1529 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 1530 } 1531 1532 error = input_register_handler(&kbd_handler); 1533 if (error) 1534 return error; 1535 1536 tasklet_enable(&keyboard_tasklet); 1537 tasklet_schedule(&keyboard_tasklet); 1538 1539 return 0; 1540 } 1541 1542 /* Ioctl support code */ 1543 1544 /** 1545 * vt_do_diacrit - diacritical table updates 1546 * @cmd: ioctl request 1547 * @up: pointer to user data for ioctl 1548 * @perm: permissions check computed by caller 1549 * 1550 * Update the diacritical tables atomically and safely. Lock them 1551 * against simultaneous keypresses 1552 */ 1553 int vt_do_diacrit(unsigned int cmd, void __user *up, int perm) 1554 { 1555 struct kbdiacrs __user *a = up; 1556 unsigned long flags; 1557 int asize; 1558 int ret = 0; 1559 1560 switch (cmd) { 1561 case KDGKBDIACR: 1562 { 1563 struct kbdiacr *diacr; 1564 int i; 1565 1566 diacr = kmalloc(MAX_DIACR * sizeof(struct kbdiacr), 1567 GFP_KERNEL); 1568 if (diacr == NULL) 1569 return -ENOMEM; 1570 1571 /* Lock the diacriticals table, make a copy and then 1572 copy it after we unlock */ 1573 spin_lock_irqsave(&kbd_event_lock, flags); 1574 1575 asize = accent_table_size; 1576 for (i = 0; i < asize; i++) { 1577 diacr[i].diacr = conv_uni_to_8bit( 1578 accent_table[i].diacr); 1579 diacr[i].base = conv_uni_to_8bit( 1580 accent_table[i].base); 1581 diacr[i].result = conv_uni_to_8bit( 1582 accent_table[i].result); 1583 } 1584 spin_unlock_irqrestore(&kbd_event_lock, flags); 1585 1586 if (put_user(asize, &a->kb_cnt)) 1587 ret = -EFAULT; 1588 else if (copy_to_user(a->kbdiacr, diacr, 1589 asize * sizeof(struct kbdiacr))) 1590 ret = -EFAULT; 1591 kfree(diacr); 1592 return ret; 1593 } 1594 case KDGKBDIACRUC: 1595 { 1596 struct kbdiacrsuc __user *a = up; 1597 void *buf; 1598 1599 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc), 1600 GFP_KERNEL); 1601 if (buf == NULL) 1602 return -ENOMEM; 1603 1604 /* Lock the diacriticals table, make a copy and then 1605 copy it after we unlock */ 1606 spin_lock_irqsave(&kbd_event_lock, flags); 1607 1608 asize = accent_table_size; 1609 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc)); 1610 1611 spin_unlock_irqrestore(&kbd_event_lock, flags); 1612 1613 if (put_user(asize, &a->kb_cnt)) 1614 ret = -EFAULT; 1615 else if (copy_to_user(a->kbdiacruc, buf, 1616 asize*sizeof(struct kbdiacruc))) 1617 ret = -EFAULT; 1618 kfree(buf); 1619 return ret; 1620 } 1621 1622 case KDSKBDIACR: 1623 { 1624 struct kbdiacrs __user *a = up; 1625 struct kbdiacr *diacr = NULL; 1626 unsigned int ct; 1627 int i; 1628 1629 if (!perm) 1630 return -EPERM; 1631 if (get_user(ct, &a->kb_cnt)) 1632 return -EFAULT; 1633 if (ct >= MAX_DIACR) 1634 return -EINVAL; 1635 1636 if (ct) { 1637 diacr = kmalloc(sizeof(struct kbdiacr) * ct, 1638 GFP_KERNEL); 1639 if (diacr == NULL) 1640 return -ENOMEM; 1641 1642 if (copy_from_user(diacr, a->kbdiacr, 1643 sizeof(struct kbdiacr) * ct)) { 1644 kfree(diacr); 1645 return -EFAULT; 1646 } 1647 } 1648 1649 spin_lock_irqsave(&kbd_event_lock, flags); 1650 accent_table_size = ct; 1651 for (i = 0; i < ct; i++) { 1652 accent_table[i].diacr = 1653 conv_8bit_to_uni(diacr[i].diacr); 1654 accent_table[i].base = 1655 conv_8bit_to_uni(diacr[i].base); 1656 accent_table[i].result = 1657 conv_8bit_to_uni(diacr[i].result); 1658 } 1659 spin_unlock_irqrestore(&kbd_event_lock, flags); 1660 kfree(diacr); 1661 return 0; 1662 } 1663 1664 case KDSKBDIACRUC: 1665 { 1666 struct kbdiacrsuc __user *a = up; 1667 unsigned int ct; 1668 void *buf = NULL; 1669 1670 if (!perm) 1671 return -EPERM; 1672 1673 if (get_user(ct, &a->kb_cnt)) 1674 return -EFAULT; 1675 1676 if (ct >= MAX_DIACR) 1677 return -EINVAL; 1678 1679 if (ct) { 1680 buf = kmalloc(ct * sizeof(struct kbdiacruc), 1681 GFP_KERNEL); 1682 if (buf == NULL) 1683 return -ENOMEM; 1684 1685 if (copy_from_user(buf, a->kbdiacruc, 1686 ct * sizeof(struct kbdiacruc))) { 1687 kfree(buf); 1688 return -EFAULT; 1689 } 1690 } 1691 spin_lock_irqsave(&kbd_event_lock, flags); 1692 if (ct) 1693 memcpy(accent_table, buf, 1694 ct * sizeof(struct kbdiacruc)); 1695 accent_table_size = ct; 1696 spin_unlock_irqrestore(&kbd_event_lock, flags); 1697 kfree(buf); 1698 return 0; 1699 } 1700 } 1701 return ret; 1702 } 1703 1704 /** 1705 * vt_do_kdskbmode - set keyboard mode ioctl 1706 * @console: the console to use 1707 * @arg: the requested mode 1708 * 1709 * Update the keyboard mode bits while holding the correct locks. 1710 * Return 0 for success or an error code. 1711 */ 1712 int vt_do_kdskbmode(int console, unsigned int arg) 1713 { 1714 struct kbd_struct * kbd = kbd_table + console; 1715 int ret = 0; 1716 unsigned long flags; 1717 1718 spin_lock_irqsave(&kbd_event_lock, flags); 1719 switch(arg) { 1720 case K_RAW: 1721 kbd->kbdmode = VC_RAW; 1722 break; 1723 case K_MEDIUMRAW: 1724 kbd->kbdmode = VC_MEDIUMRAW; 1725 break; 1726 case K_XLATE: 1727 kbd->kbdmode = VC_XLATE; 1728 do_compute_shiftstate(); 1729 break; 1730 case K_UNICODE: 1731 kbd->kbdmode = VC_UNICODE; 1732 do_compute_shiftstate(); 1733 break; 1734 case K_OFF: 1735 kbd->kbdmode = VC_OFF; 1736 break; 1737 default: 1738 ret = -EINVAL; 1739 } 1740 spin_unlock_irqrestore(&kbd_event_lock, flags); 1741 return ret; 1742 } 1743 1744 /** 1745 * vt_do_kdskbmeta - set keyboard meta state 1746 * @console: the console to use 1747 * @arg: the requested meta state 1748 * 1749 * Update the keyboard meta bits while holding the correct locks. 1750 * Return 0 for success or an error code. 1751 */ 1752 int vt_do_kdskbmeta(int console, unsigned int arg) 1753 { 1754 struct kbd_struct * kbd = kbd_table + console; 1755 int ret = 0; 1756 unsigned long flags; 1757 1758 spin_lock_irqsave(&kbd_event_lock, flags); 1759 switch(arg) { 1760 case K_METABIT: 1761 clr_vc_kbd_mode(kbd, VC_META); 1762 break; 1763 case K_ESCPREFIX: 1764 set_vc_kbd_mode(kbd, VC_META); 1765 break; 1766 default: 1767 ret = -EINVAL; 1768 } 1769 spin_unlock_irqrestore(&kbd_event_lock, flags); 1770 return ret; 1771 } 1772 1773 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, 1774 int perm) 1775 { 1776 struct kbkeycode tmp; 1777 int kc = 0; 1778 1779 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode))) 1780 return -EFAULT; 1781 switch (cmd) { 1782 case KDGETKEYCODE: 1783 kc = getkeycode(tmp.scancode); 1784 if (kc >= 0) 1785 kc = put_user(kc, &user_kbkc->keycode); 1786 break; 1787 case KDSETKEYCODE: 1788 if (!perm) 1789 return -EPERM; 1790 kc = setkeycode(tmp.scancode, tmp.keycode); 1791 break; 1792 } 1793 return kc; 1794 } 1795 1796 #define i (tmp.kb_index) 1797 #define s (tmp.kb_table) 1798 #define v (tmp.kb_value) 1799 1800 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm, 1801 int console) 1802 { 1803 struct kbd_struct * kbd = kbd_table + console; 1804 struct kbentry tmp; 1805 ushort *key_map, *new_map, val, ov; 1806 unsigned long flags; 1807 1808 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry))) 1809 return -EFAULT; 1810 1811 if (!capable(CAP_SYS_TTY_CONFIG)) 1812 perm = 0; 1813 1814 switch (cmd) { 1815 case KDGKBENT: 1816 /* Ensure another thread doesn't free it under us */ 1817 spin_lock_irqsave(&kbd_event_lock, flags); 1818 key_map = key_maps[s]; 1819 if (key_map) { 1820 val = U(key_map[i]); 1821 if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES) 1822 val = K_HOLE; 1823 } else 1824 val = (i ? K_HOLE : K_NOSUCHMAP); 1825 spin_unlock_irqrestore(&kbd_event_lock, flags); 1826 return put_user(val, &user_kbe->kb_value); 1827 case KDSKBENT: 1828 if (!perm) 1829 return -EPERM; 1830 if (!i && v == K_NOSUCHMAP) { 1831 spin_lock_irqsave(&kbd_event_lock, flags); 1832 /* deallocate map */ 1833 key_map = key_maps[s]; 1834 if (s && key_map) { 1835 key_maps[s] = NULL; 1836 if (key_map[0] == U(K_ALLOCATED)) { 1837 kfree(key_map); 1838 keymap_count--; 1839 } 1840 } 1841 spin_unlock_irqrestore(&kbd_event_lock, flags); 1842 break; 1843 } 1844 1845 if (KTYP(v) < NR_TYPES) { 1846 if (KVAL(v) > max_vals[KTYP(v)]) 1847 return -EINVAL; 1848 } else 1849 if (kbd->kbdmode != VC_UNICODE) 1850 return -EINVAL; 1851 1852 /* ++Geert: non-PC keyboards may generate keycode zero */ 1853 #if !defined(__mc68000__) && !defined(__powerpc__) 1854 /* assignment to entry 0 only tests validity of args */ 1855 if (!i) 1856 break; 1857 #endif 1858 1859 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL); 1860 if (!new_map) 1861 return -ENOMEM; 1862 spin_lock_irqsave(&kbd_event_lock, flags); 1863 key_map = key_maps[s]; 1864 if (key_map == NULL) { 1865 int j; 1866 1867 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && 1868 !capable(CAP_SYS_RESOURCE)) { 1869 spin_unlock_irqrestore(&kbd_event_lock, flags); 1870 kfree(new_map); 1871 return -EPERM; 1872 } 1873 key_maps[s] = new_map; 1874 key_map = new_map; 1875 key_map[0] = U(K_ALLOCATED); 1876 for (j = 1; j < NR_KEYS; j++) 1877 key_map[j] = U(K_HOLE); 1878 keymap_count++; 1879 } else 1880 kfree(new_map); 1881 1882 ov = U(key_map[i]); 1883 if (v == ov) 1884 goto out; 1885 /* 1886 * Attention Key. 1887 */ 1888 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) { 1889 spin_unlock_irqrestore(&kbd_event_lock, flags); 1890 return -EPERM; 1891 } 1892 key_map[i] = U(v); 1893 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT)) 1894 do_compute_shiftstate(); 1895 out: 1896 spin_unlock_irqrestore(&kbd_event_lock, flags); 1897 break; 1898 } 1899 return 0; 1900 } 1901 #undef i 1902 #undef s 1903 #undef v 1904 1905 /* FIXME: This one needs untangling and locking */ 1906 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm) 1907 { 1908 struct kbsentry *kbs; 1909 char *p; 1910 u_char *q; 1911 u_char __user *up; 1912 int sz; 1913 int delta; 1914 char *first_free, *fj, *fnw; 1915 int i, j, k; 1916 int ret; 1917 1918 if (!capable(CAP_SYS_TTY_CONFIG)) 1919 perm = 0; 1920 1921 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL); 1922 if (!kbs) { 1923 ret = -ENOMEM; 1924 goto reterr; 1925 } 1926 1927 /* we mostly copy too much here (512bytes), but who cares ;) */ 1928 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) { 1929 ret = -EFAULT; 1930 goto reterr; 1931 } 1932 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0'; 1933 i = kbs->kb_func; 1934 1935 switch (cmd) { 1936 case KDGKBSENT: 1937 sz = sizeof(kbs->kb_string) - 1; /* sz should have been 1938 a struct member */ 1939 up = user_kdgkb->kb_string; 1940 p = func_table[i]; 1941 if(p) 1942 for ( ; *p && sz; p++, sz--) 1943 if (put_user(*p, up++)) { 1944 ret = -EFAULT; 1945 goto reterr; 1946 } 1947 if (put_user('\0', up)) { 1948 ret = -EFAULT; 1949 goto reterr; 1950 } 1951 kfree(kbs); 1952 return ((p && *p) ? -EOVERFLOW : 0); 1953 case KDSKBSENT: 1954 if (!perm) { 1955 ret = -EPERM; 1956 goto reterr; 1957 } 1958 1959 q = func_table[i]; 1960 first_free = funcbufptr + (funcbufsize - funcbufleft); 1961 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++) 1962 ; 1963 if (j < MAX_NR_FUNC) 1964 fj = func_table[j]; 1965 else 1966 fj = first_free; 1967 1968 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string); 1969 if (delta <= funcbufleft) { /* it fits in current buf */ 1970 if (j < MAX_NR_FUNC) { 1971 memmove(fj + delta, fj, first_free - fj); 1972 for (k = j; k < MAX_NR_FUNC; k++) 1973 if (func_table[k]) 1974 func_table[k] += delta; 1975 } 1976 if (!q) 1977 func_table[i] = fj; 1978 funcbufleft -= delta; 1979 } else { /* allocate a larger buffer */ 1980 sz = 256; 1981 while (sz < funcbufsize - funcbufleft + delta) 1982 sz <<= 1; 1983 fnw = kmalloc(sz, GFP_KERNEL); 1984 if(!fnw) { 1985 ret = -ENOMEM; 1986 goto reterr; 1987 } 1988 1989 if (!q) 1990 func_table[i] = fj; 1991 if (fj > funcbufptr) 1992 memmove(fnw, funcbufptr, fj - funcbufptr); 1993 for (k = 0; k < j; k++) 1994 if (func_table[k]) 1995 func_table[k] = fnw + (func_table[k] - funcbufptr); 1996 1997 if (first_free > fj) { 1998 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj); 1999 for (k = j; k < MAX_NR_FUNC; k++) 2000 if (func_table[k]) 2001 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta; 2002 } 2003 if (funcbufptr != func_buf) 2004 kfree(funcbufptr); 2005 funcbufptr = fnw; 2006 funcbufleft = funcbufleft - delta + sz - funcbufsize; 2007 funcbufsize = sz; 2008 } 2009 strcpy(func_table[i], kbs->kb_string); 2010 break; 2011 } 2012 ret = 0; 2013 reterr: 2014 kfree(kbs); 2015 return ret; 2016 } 2017 2018 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm) 2019 { 2020 struct kbd_struct * kbd = kbd_table + console; 2021 unsigned long flags; 2022 unsigned char ucval; 2023 2024 switch(cmd) { 2025 /* the ioctls below read/set the flags usually shown in the leds */ 2026 /* don't use them - they will go away without warning */ 2027 case KDGKBLED: 2028 spin_lock_irqsave(&kbd_event_lock, flags); 2029 ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4); 2030 spin_unlock_irqrestore(&kbd_event_lock, flags); 2031 return put_user(ucval, (char __user *)arg); 2032 2033 case KDSKBLED: 2034 if (!perm) 2035 return -EPERM; 2036 if (arg & ~0x77) 2037 return -EINVAL; 2038 spin_lock_irqsave(&led_lock, flags); 2039 kbd->ledflagstate = (arg & 7); 2040 kbd->default_ledflagstate = ((arg >> 4) & 7); 2041 set_leds(); 2042 spin_unlock_irqrestore(&led_lock, flags); 2043 return 0; 2044 2045 /* the ioctls below only set the lights, not the functions */ 2046 /* for those, see KDGKBLED and KDSKBLED above */ 2047 case KDGETLED: 2048 ucval = getledstate(); 2049 return put_user(ucval, (char __user *)arg); 2050 2051 case KDSETLED: 2052 if (!perm) 2053 return -EPERM; 2054 setledstate(kbd, arg); 2055 return 0; 2056 } 2057 return -ENOIOCTLCMD; 2058 } 2059 2060 int vt_do_kdgkbmode(int console) 2061 { 2062 struct kbd_struct * kbd = kbd_table + console; 2063 /* This is a spot read so needs no locking */ 2064 switch (kbd->kbdmode) { 2065 case VC_RAW: 2066 return K_RAW; 2067 case VC_MEDIUMRAW: 2068 return K_MEDIUMRAW; 2069 case VC_UNICODE: 2070 return K_UNICODE; 2071 case VC_OFF: 2072 return K_OFF; 2073 default: 2074 return K_XLATE; 2075 } 2076 } 2077 2078 /** 2079 * vt_do_kdgkbmeta - report meta status 2080 * @console: console to report 2081 * 2082 * Report the meta flag status of this console 2083 */ 2084 int vt_do_kdgkbmeta(int console) 2085 { 2086 struct kbd_struct * kbd = kbd_table + console; 2087 /* Again a spot read so no locking */ 2088 return vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT; 2089 } 2090 2091 /** 2092 * vt_reset_unicode - reset the unicode status 2093 * @console: console being reset 2094 * 2095 * Restore the unicode console state to its default 2096 */ 2097 void vt_reset_unicode(int console) 2098 { 2099 unsigned long flags; 2100 2101 spin_lock_irqsave(&kbd_event_lock, flags); 2102 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 2103 spin_unlock_irqrestore(&kbd_event_lock, flags); 2104 } 2105 2106 /** 2107 * vt_get_shiftstate - shift bit state 2108 * 2109 * Report the shift bits from the keyboard state. We have to export 2110 * this to support some oddities in the vt layer. 2111 */ 2112 int vt_get_shift_state(void) 2113 { 2114 /* Don't lock as this is a transient report */ 2115 return shift_state; 2116 } 2117 2118 /** 2119 * vt_reset_keyboard - reset keyboard state 2120 * @console: console to reset 2121 * 2122 * Reset the keyboard bits for a console as part of a general console 2123 * reset event 2124 */ 2125 void vt_reset_keyboard(int console) 2126 { 2127 struct kbd_struct * kbd = kbd_table + console; 2128 unsigned long flags; 2129 2130 spin_lock_irqsave(&kbd_event_lock, flags); 2131 set_vc_kbd_mode(kbd, VC_REPEAT); 2132 clr_vc_kbd_mode(kbd, VC_CKMODE); 2133 clr_vc_kbd_mode(kbd, VC_APPLIC); 2134 clr_vc_kbd_mode(kbd, VC_CRLF); 2135 kbd->lockstate = 0; 2136 kbd->slockstate = 0; 2137 spin_lock(&led_lock); 2138 kbd->ledmode = LED_SHOW_FLAGS; 2139 kbd->ledflagstate = kbd->default_ledflagstate; 2140 spin_unlock(&led_lock); 2141 /* do not do set_leds here because this causes an endless tasklet loop 2142 when the keyboard hasn't been initialized yet */ 2143 spin_unlock_irqrestore(&kbd_event_lock, flags); 2144 } 2145 2146 /** 2147 * vt_get_kbd_mode_bit - read keyboard status bits 2148 * @console: console to read from 2149 * @bit: mode bit to read 2150 * 2151 * Report back a vt mode bit. We do this without locking so the 2152 * caller must be sure that there are no synchronization needs 2153 */ 2154 2155 int vt_get_kbd_mode_bit(int console, int bit) 2156 { 2157 struct kbd_struct * kbd = kbd_table + console; 2158 return vc_kbd_mode(kbd, bit); 2159 } 2160 2161 /** 2162 * vt_set_kbd_mode_bit - read keyboard status bits 2163 * @console: console to read from 2164 * @bit: mode bit to read 2165 * 2166 * Set a vt mode bit. We do this without locking so the 2167 * caller must be sure that there are no synchronization needs 2168 */ 2169 2170 void vt_set_kbd_mode_bit(int console, int bit) 2171 { 2172 struct kbd_struct * kbd = kbd_table + console; 2173 unsigned long flags; 2174 2175 spin_lock_irqsave(&kbd_event_lock, flags); 2176 set_vc_kbd_mode(kbd, bit); 2177 spin_unlock_irqrestore(&kbd_event_lock, flags); 2178 } 2179 2180 /** 2181 * vt_clr_kbd_mode_bit - read keyboard status bits 2182 * @console: console to read from 2183 * @bit: mode bit to read 2184 * 2185 * Report back a vt mode bit. We do this without locking so the 2186 * caller must be sure that there are no synchronization needs 2187 */ 2188 2189 void vt_clr_kbd_mode_bit(int console, int bit) 2190 { 2191 struct kbd_struct * kbd = kbd_table + console; 2192 unsigned long flags; 2193 2194 spin_lock_irqsave(&kbd_event_lock, flags); 2195 clr_vc_kbd_mode(kbd, bit); 2196 spin_unlock_irqrestore(&kbd_event_lock, flags); 2197 } 2198