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_obj(*handle, 1552 GFP_KERNEL); 1553 if (!handle) 1554 return -ENOMEM; 1555 1556 handle->dev = dev; 1557 handle->handler = handler; 1558 handle->name = "kbd"; 1559 1560 error = input_register_handle(handle); 1561 if (error) 1562 return error; 1563 1564 error = input_open_device(handle); 1565 if (error) 1566 goto err_unregister_handle; 1567 1568 retain_and_null_ptr(handle); 1569 1570 return 0; 1571 1572 err_unregister_handle: 1573 input_unregister_handle(handle); 1574 return error; 1575 } 1576 1577 static void kbd_disconnect(struct input_handle *handle) 1578 { 1579 input_close_device(handle); 1580 input_unregister_handle(handle); 1581 kfree(handle); 1582 } 1583 1584 /* 1585 * Start keyboard handler on the new keyboard by refreshing LED state to 1586 * match the rest of the system. 1587 */ 1588 static void kbd_start(struct input_handle *handle) 1589 { 1590 tasklet_disable(&keyboard_tasklet); 1591 1592 if (ledstate != -1U) 1593 kbd_update_leds_helper(handle, &ledstate); 1594 1595 tasklet_enable(&keyboard_tasklet); 1596 } 1597 1598 static const struct input_device_id kbd_ids[] = { 1599 { 1600 .flags = INPUT_DEVICE_ID_MATCH_EVBIT, 1601 .evbit = { BIT_MASK(EV_KEY) }, 1602 }, 1603 1604 { 1605 .flags = INPUT_DEVICE_ID_MATCH_EVBIT, 1606 .evbit = { BIT_MASK(EV_SND) }, 1607 }, 1608 1609 { }, /* Terminating entry */ 1610 }; 1611 1612 MODULE_DEVICE_TABLE(input, kbd_ids); 1613 1614 static struct input_handler kbd_handler = { 1615 .event = kbd_event, 1616 .match = kbd_match, 1617 .connect = kbd_connect, 1618 .disconnect = kbd_disconnect, 1619 .start = kbd_start, 1620 .name = "kbd", 1621 .id_table = kbd_ids, 1622 }; 1623 1624 int __init kbd_init(void) 1625 { 1626 int i; 1627 int error; 1628 1629 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1630 kbd_table[i].ledflagstate = kbd_defleds(); 1631 kbd_table[i].default_ledflagstate = kbd_defleds(); 1632 kbd_table[i].ledmode = LED_SHOW_FLAGS; 1633 kbd_table[i].lockstate = KBD_DEFLOCK; 1634 kbd_table[i].slockstate = 0; 1635 kbd_table[i].modeflags = KBD_DEFMODE; 1636 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 1637 } 1638 1639 kbd_init_leds(); 1640 1641 error = input_register_handler(&kbd_handler); 1642 if (error) 1643 return error; 1644 1645 tasklet_enable(&keyboard_tasklet); 1646 tasklet_schedule(&keyboard_tasklet); 1647 1648 return 0; 1649 } 1650 1651 /* Ioctl support code */ 1652 1653 static int vt_do_kdgkbdiacr(void __user *udp) 1654 { 1655 struct kbdiacrs __user *a = udp; 1656 int i, asize; 1657 1658 struct kbdiacr __free(kfree) *dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr), 1659 GFP_KERNEL); 1660 if (!dia) 1661 return -ENOMEM; 1662 1663 /* Lock the diacriticals table, make a copy and then 1664 copy it after we unlock */ 1665 scoped_guard(spinlock_irqsave, &kbd_event_lock) { 1666 asize = accent_table_size; 1667 for (i = 0; i < asize; i++) { 1668 dia[i].diacr = conv_uni_to_8bit(accent_table[i].diacr); 1669 dia[i].base = conv_uni_to_8bit(accent_table[i].base); 1670 dia[i].result = conv_uni_to_8bit(accent_table[i].result); 1671 } 1672 } 1673 1674 if (put_user(asize, &a->kb_cnt)) 1675 return -EFAULT; 1676 if (copy_to_user(a->kbdiacr, dia, asize * sizeof(struct kbdiacr))) 1677 return -EFAULT; 1678 return 0; 1679 } 1680 1681 static int vt_do_kdgkbdiacruc(void __user *udp) 1682 { 1683 struct kbdiacrsuc __user *a = udp; 1684 int asize; 1685 1686 void __free(kfree) *buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc), 1687 GFP_KERNEL); 1688 if (buf == NULL) 1689 return -ENOMEM; 1690 1691 /* Lock the diacriticals table, make a copy and then 1692 copy it after we unlock */ 1693 scoped_guard(spinlock_irqsave, &kbd_event_lock) { 1694 asize = accent_table_size; 1695 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc)); 1696 } 1697 1698 if (put_user(asize, &a->kb_cnt)) 1699 return -EFAULT; 1700 if (copy_to_user(a->kbdiacruc, buf, asize * sizeof(struct kbdiacruc))) 1701 return -EFAULT; 1702 1703 return 0; 1704 } 1705 1706 static int vt_do_kdskbdiacr(void __user *udp, int perm) 1707 { 1708 struct kbdiacrs __user *a = udp; 1709 struct kbdiacr __free(kfree) *dia = NULL; 1710 unsigned int ct; 1711 int i; 1712 1713 if (!perm) 1714 return -EPERM; 1715 if (get_user(ct, &a->kb_cnt)) 1716 return -EFAULT; 1717 if (ct >= MAX_DIACR) 1718 return -EINVAL; 1719 1720 if (ct) { 1721 dia = memdup_array_user(a->kbdiacr, 1722 ct, sizeof(struct kbdiacr)); 1723 if (IS_ERR(dia)) 1724 return PTR_ERR(dia); 1725 } 1726 1727 guard(spinlock_irqsave)(&kbd_event_lock); 1728 accent_table_size = ct; 1729 for (i = 0; i < ct; i++) { 1730 accent_table[i].diacr = 1731 conv_8bit_to_uni(dia[i].diacr); 1732 accent_table[i].base = 1733 conv_8bit_to_uni(dia[i].base); 1734 accent_table[i].result = 1735 conv_8bit_to_uni(dia[i].result); 1736 } 1737 1738 return 0; 1739 } 1740 1741 static int vt_do_kdskbdiacruc(void __user *udp, int perm) 1742 { 1743 struct kbdiacrsuc __user *a = udp; 1744 unsigned int ct; 1745 void __free(kfree) *buf = NULL; 1746 1747 if (!perm) 1748 return -EPERM; 1749 1750 if (get_user(ct, &a->kb_cnt)) 1751 return -EFAULT; 1752 1753 if (ct >= MAX_DIACR) 1754 return -EINVAL; 1755 1756 if (ct) { 1757 buf = memdup_array_user(a->kbdiacruc, 1758 ct, sizeof(struct kbdiacruc)); 1759 if (IS_ERR(buf)) 1760 return PTR_ERR(buf); 1761 } 1762 guard(spinlock_irqsave)(&kbd_event_lock); 1763 if (ct) 1764 memcpy(accent_table, buf, 1765 ct * sizeof(struct kbdiacruc)); 1766 accent_table_size = ct; 1767 return 0; 1768 } 1769 1770 /** 1771 * vt_do_diacrit - diacritical table updates 1772 * @cmd: ioctl request 1773 * @udp: pointer to user data for ioctl 1774 * @perm: permissions check computed by caller 1775 * 1776 * Update the diacritical tables atomically and safely. Lock them 1777 * against simultaneous keypresses 1778 */ 1779 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm) 1780 { 1781 switch (cmd) { 1782 case KDGKBDIACR: 1783 return vt_do_kdgkbdiacr(udp); 1784 case KDGKBDIACRUC: 1785 return vt_do_kdgkbdiacruc(udp); 1786 case KDSKBDIACR: 1787 return vt_do_kdskbdiacr(udp, perm); 1788 case KDSKBDIACRUC: 1789 return vt_do_kdskbdiacruc(udp, perm); 1790 } 1791 return 0; 1792 } 1793 1794 /** 1795 * vt_do_kdskbmode - set keyboard mode ioctl 1796 * @console: the console to use 1797 * @arg: the requested mode 1798 * 1799 * Update the keyboard mode bits while holding the correct locks. 1800 * Return 0 for success or an error code. 1801 */ 1802 int vt_do_kdskbmode(unsigned int console, unsigned int arg) 1803 { 1804 struct kbd_struct *kb = &kbd_table[console]; 1805 1806 guard(spinlock_irqsave)(&kbd_event_lock); 1807 switch(arg) { 1808 case K_RAW: 1809 kb->kbdmode = VC_RAW; 1810 return 0; 1811 case K_MEDIUMRAW: 1812 kb->kbdmode = VC_MEDIUMRAW; 1813 return 0; 1814 case K_XLATE: 1815 kb->kbdmode = VC_XLATE; 1816 do_compute_shiftstate(); 1817 return 0; 1818 case K_UNICODE: 1819 kb->kbdmode = VC_UNICODE; 1820 do_compute_shiftstate(); 1821 return 0; 1822 case K_OFF: 1823 kb->kbdmode = VC_OFF; 1824 return 0; 1825 default: 1826 return -EINVAL; 1827 } 1828 } 1829 1830 /** 1831 * vt_do_kdskbmeta - set keyboard meta state 1832 * @console: the console to use 1833 * @arg: the requested meta state 1834 * 1835 * Update the keyboard meta bits while holding the correct locks. 1836 * Return 0 for success or an error code. 1837 */ 1838 int vt_do_kdskbmeta(unsigned int console, unsigned int arg) 1839 { 1840 struct kbd_struct *kb = &kbd_table[console]; 1841 1842 guard(spinlock_irqsave)(&kbd_event_lock); 1843 switch(arg) { 1844 case K_METABIT: 1845 clr_vc_kbd_mode(kb, VC_META); 1846 return 0; 1847 case K_ESCPREFIX: 1848 set_vc_kbd_mode(kb, VC_META); 1849 return 0; 1850 default: 1851 return -EINVAL; 1852 } 1853 } 1854 1855 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, int perm) 1856 { 1857 struct kbkeycode tmp; 1858 int kc; 1859 1860 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode))) 1861 return -EFAULT; 1862 1863 switch (cmd) { 1864 case KDGETKEYCODE: 1865 kc = getkeycode(tmp.scancode); 1866 if (kc < 0) 1867 return kc; 1868 return put_user(kc, &user_kbkc->keycode); 1869 case KDSETKEYCODE: 1870 if (!perm) 1871 return -EPERM; 1872 return setkeycode(tmp.scancode, tmp.keycode); 1873 } 1874 1875 return 0; 1876 } 1877 1878 static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx, 1879 unsigned char map) 1880 { 1881 unsigned short *key_map; 1882 1883 /* Ensure another thread doesn't free it under us */ 1884 guard(spinlock_irqsave)(&kbd_event_lock); 1885 key_map = key_maps[map]; 1886 if (key_map) { 1887 unsigned short val = U(key_map[idx]); 1888 if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES) 1889 return K_HOLE; 1890 return val; 1891 } 1892 1893 return idx ? K_HOLE : K_NOSUCHMAP; 1894 } 1895 1896 static int vt_kdskbent(unsigned char kbdmode, unsigned char idx, 1897 unsigned char map, unsigned short val) 1898 { 1899 unsigned short *key_map, oldval; 1900 1901 if (!idx && val == K_NOSUCHMAP) { 1902 guard(spinlock_irqsave)(&kbd_event_lock); 1903 /* deallocate map */ 1904 key_map = key_maps[map]; 1905 if (map && key_map) { 1906 key_maps[map] = NULL; 1907 if (key_map[0] == U(K_ALLOCATED)) { 1908 kfree(key_map); 1909 keymap_count--; 1910 } 1911 } 1912 1913 return 0; 1914 } 1915 1916 if (KTYP(val) < NR_TYPES) { 1917 if (KVAL(val) > max_vals[KTYP(val)]) 1918 return -EINVAL; 1919 } else if (kbdmode != VC_UNICODE) 1920 return -EINVAL; 1921 1922 /* ++Geert: non-PC keyboards may generate keycode zero */ 1923 #if !defined(__mc68000__) && !defined(__powerpc__) 1924 /* assignment to entry 0 only tests validity of args */ 1925 if (!idx) 1926 return 0; 1927 #endif 1928 1929 unsigned short __free(kfree) *new_map = kmalloc(sizeof(plain_map), GFP_KERNEL); 1930 if (!new_map) 1931 return -ENOMEM; 1932 1933 guard(spinlock_irqsave)(&kbd_event_lock); 1934 key_map = key_maps[map]; 1935 if (key_map == NULL) { 1936 int j; 1937 1938 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && !capable(CAP_SYS_RESOURCE)) 1939 return -EPERM; 1940 1941 key_map = key_maps[map] = no_free_ptr(new_map); 1942 key_map[0] = U(K_ALLOCATED); 1943 for (j = 1; j < NR_KEYS; j++) 1944 key_map[j] = U(K_HOLE); 1945 keymap_count++; 1946 } 1947 1948 oldval = U(key_map[idx]); 1949 if (val == oldval) 1950 return 0; 1951 1952 /* Attention Key */ 1953 if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) 1954 return -EPERM; 1955 1956 key_map[idx] = U(val); 1957 if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT)) 1958 do_compute_shiftstate(); 1959 1960 return 0; 1961 } 1962 1963 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm, 1964 unsigned int console) 1965 { 1966 struct kbd_struct *kb = &kbd_table[console]; 1967 struct kbentry kbe; 1968 1969 if (copy_from_user(&kbe, user_kbe, sizeof(struct kbentry))) 1970 return -EFAULT; 1971 1972 switch (cmd) { 1973 case KDGKBENT: 1974 return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index, 1975 kbe.kb_table), 1976 &user_kbe->kb_value); 1977 case KDSKBENT: 1978 if (!perm || !capable(CAP_SYS_TTY_CONFIG)) 1979 return -EPERM; 1980 return vt_kdskbent(kb->kbdmode, kbe.kb_index, kbe.kb_table, 1981 kbe.kb_value); 1982 } 1983 return 0; 1984 } 1985 1986 static char *vt_kdskbsent(char *kbs, unsigned char cur) 1987 { 1988 static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC); 1989 char *cur_f = func_table[cur]; 1990 1991 if (cur_f && strlen(cur_f) >= strlen(kbs)) { 1992 strcpy(cur_f, kbs); 1993 return kbs; 1994 } 1995 1996 func_table[cur] = kbs; 1997 1998 return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL; 1999 } 2000 2001 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm) 2002 { 2003 unsigned char kb_func; 2004 2005 if (get_user(kb_func, &user_kdgkb->kb_func)) 2006 return -EFAULT; 2007 2008 kb_func = array_index_nospec(kb_func, MAX_NR_FUNC); 2009 2010 switch (cmd) { 2011 case KDGKBSENT: { 2012 /* size should have been a struct member */ 2013 ssize_t len = sizeof(user_kdgkb->kb_string); 2014 2015 char __free(kfree) *kbs = kmalloc(len, GFP_KERNEL); 2016 if (!kbs) 2017 return -ENOMEM; 2018 2019 scoped_guard(spinlock_irqsave, &func_buf_lock) 2020 len = strscpy(kbs, func_table[kb_func] ? : "", len); 2021 2022 if (len < 0) 2023 return -ENOSPC; 2024 2025 if (copy_to_user(user_kdgkb->kb_string, kbs, len + 1)) 2026 return -EFAULT; 2027 2028 return 0; 2029 } 2030 case KDSKBSENT: 2031 if (!perm || !capable(CAP_SYS_TTY_CONFIG)) 2032 return -EPERM; 2033 2034 char __free(kfree) *kbs = strndup_user(user_kdgkb->kb_string, 2035 sizeof(user_kdgkb->kb_string)); 2036 if (IS_ERR(kbs)) 2037 return PTR_ERR(kbs); 2038 2039 guard(spinlock_irqsave)(&func_buf_lock); 2040 kbs = vt_kdskbsent(kbs, kb_func); 2041 2042 return 0; 2043 } 2044 2045 return 0; 2046 } 2047 2048 int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm) 2049 { 2050 struct kbd_struct *kb = &kbd_table[console]; 2051 unsigned char ucval; 2052 2053 switch(cmd) { 2054 /* the ioctls below read/set the flags usually shown in the leds */ 2055 /* don't use them - they will go away without warning */ 2056 case KDGKBLED: 2057 scoped_guard(spinlock_irqsave, &kbd_event_lock) 2058 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4); 2059 return put_user(ucval, (char __user *)arg); 2060 2061 case KDSKBLED: 2062 if (!perm) 2063 return -EPERM; 2064 if (arg & ~0x77) 2065 return -EINVAL; 2066 scoped_guard(spinlock_irqsave, &led_lock) { 2067 kb->ledflagstate = (arg & 7); 2068 kb->default_ledflagstate = ((arg >> 4) & 7); 2069 set_leds(); 2070 } 2071 return 0; 2072 2073 /* the ioctls below only set the lights, not the functions */ 2074 /* for those, see KDGKBLED and KDSKBLED above */ 2075 case KDGETLED: 2076 ucval = getledstate(); 2077 return put_user(ucval, (char __user *)arg); 2078 2079 case KDSETLED: 2080 if (!perm) 2081 return -EPERM; 2082 setledstate(kb, arg); 2083 return 0; 2084 } 2085 return -ENOIOCTLCMD; 2086 } 2087 2088 int vt_do_kdgkbmode(unsigned int console) 2089 { 2090 struct kbd_struct *kb = &kbd_table[console]; 2091 /* This is a spot read so needs no locking */ 2092 switch (kb->kbdmode) { 2093 case VC_RAW: 2094 return K_RAW; 2095 case VC_MEDIUMRAW: 2096 return K_MEDIUMRAW; 2097 case VC_UNICODE: 2098 return K_UNICODE; 2099 case VC_OFF: 2100 return K_OFF; 2101 default: 2102 return K_XLATE; 2103 } 2104 } 2105 2106 /** 2107 * vt_do_kdgkbmeta - report meta status 2108 * @console: console to report 2109 * 2110 * Report the meta flag status of this console 2111 */ 2112 int vt_do_kdgkbmeta(unsigned int console) 2113 { 2114 struct kbd_struct *kb = &kbd_table[console]; 2115 /* Again a spot read so no locking */ 2116 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT; 2117 } 2118 2119 /** 2120 * vt_reset_unicode - reset the unicode status 2121 * @console: console being reset 2122 * 2123 * Restore the unicode console state to its default 2124 */ 2125 void vt_reset_unicode(unsigned int console) 2126 { 2127 guard(spinlock_irqsave)(&kbd_event_lock); 2128 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 2129 } 2130 2131 /** 2132 * vt_get_shift_state - shift bit state 2133 * 2134 * Report the shift bits from the keyboard state. We have to export 2135 * this to support some oddities in the vt layer. 2136 */ 2137 int vt_get_shift_state(void) 2138 { 2139 /* Don't lock as this is a transient report */ 2140 return shift_state; 2141 } 2142 2143 /** 2144 * vt_reset_keyboard - reset keyboard state 2145 * @console: console to reset 2146 * 2147 * Reset the keyboard bits for a console as part of a general console 2148 * reset event 2149 */ 2150 void vt_reset_keyboard(unsigned int console) 2151 { 2152 struct kbd_struct *kb = &kbd_table[console]; 2153 2154 guard(spinlock_irqsave)(&kbd_event_lock); 2155 set_vc_kbd_mode(kb, VC_REPEAT); 2156 clr_vc_kbd_mode(kb, VC_CKMODE); 2157 clr_vc_kbd_mode(kb, VC_APPLIC); 2158 clr_vc_kbd_mode(kb, VC_CRLF); 2159 kb->lockstate = 0; 2160 kb->slockstate = 0; 2161 guard(spinlock)(&led_lock); 2162 kb->ledmode = LED_SHOW_FLAGS; 2163 kb->ledflagstate = kb->default_ledflagstate; 2164 /* do not do set_leds here because this causes an endless tasklet loop 2165 when the keyboard hasn't been initialized yet */ 2166 } 2167 2168 /** 2169 * vt_get_kbd_mode_bit - read keyboard status bits 2170 * @console: console to read from 2171 * @bit: mode bit to read 2172 * 2173 * Report back a vt mode bit. We do this without locking so the 2174 * caller must be sure that there are no synchronization needs 2175 */ 2176 2177 int vt_get_kbd_mode_bit(unsigned int console, int bit) 2178 { 2179 struct kbd_struct *kb = &kbd_table[console]; 2180 return vc_kbd_mode(kb, bit); 2181 } 2182 2183 /** 2184 * vt_set_kbd_mode_bit - read keyboard status bits 2185 * @console: console to read from 2186 * @bit: mode bit to read 2187 * 2188 * Set a vt mode bit. We do this without locking so the 2189 * caller must be sure that there are no synchronization needs 2190 */ 2191 2192 void vt_set_kbd_mode_bit(unsigned int console, int bit) 2193 { 2194 struct kbd_struct *kb = &kbd_table[console]; 2195 2196 guard(spinlock_irqsave)(&kbd_event_lock); 2197 set_vc_kbd_mode(kb, bit); 2198 } 2199 2200 /** 2201 * vt_clr_kbd_mode_bit - read keyboard status bits 2202 * @console: console to read from 2203 * @bit: mode bit to read 2204 * 2205 * Report back a vt mode bit. We do this without locking so the 2206 * caller must be sure that there are no synchronization needs 2207 */ 2208 2209 void vt_clr_kbd_mode_bit(unsigned int console, int bit) 2210 { 2211 struct kbd_struct *kb = &kbd_table[console]; 2212 2213 guard(spinlock_irqsave)(&kbd_event_lock); 2214 clr_vc_kbd_mode(kb, bit); 2215 } 2216