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