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