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