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