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