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