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