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