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