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