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(0, NULL); 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_IA64) || 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 1776 dia = memdup_user(a->kbdiacr, 1777 sizeof(struct kbdiacr) * ct); 1778 if (IS_ERR(dia)) 1779 return PTR_ERR(dia); 1780 1781 } 1782 1783 spin_lock_irqsave(&kbd_event_lock, flags); 1784 accent_table_size = ct; 1785 for (i = 0; i < ct; i++) { 1786 accent_table[i].diacr = 1787 conv_8bit_to_uni(dia[i].diacr); 1788 accent_table[i].base = 1789 conv_8bit_to_uni(dia[i].base); 1790 accent_table[i].result = 1791 conv_8bit_to_uni(dia[i].result); 1792 } 1793 spin_unlock_irqrestore(&kbd_event_lock, flags); 1794 kfree(dia); 1795 return 0; 1796 } 1797 1798 case KDSKBDIACRUC: 1799 { 1800 struct kbdiacrsuc __user *a = udp; 1801 unsigned int ct; 1802 void *buf = NULL; 1803 1804 if (!perm) 1805 return -EPERM; 1806 1807 if (get_user(ct, &a->kb_cnt)) 1808 return -EFAULT; 1809 1810 if (ct >= MAX_DIACR) 1811 return -EINVAL; 1812 1813 if (ct) { 1814 buf = memdup_user(a->kbdiacruc, 1815 ct * sizeof(struct kbdiacruc)); 1816 if (IS_ERR(buf)) 1817 return PTR_ERR(buf); 1818 } 1819 spin_lock_irqsave(&kbd_event_lock, flags); 1820 if (ct) 1821 memcpy(accent_table, buf, 1822 ct * sizeof(struct kbdiacruc)); 1823 accent_table_size = ct; 1824 spin_unlock_irqrestore(&kbd_event_lock, flags); 1825 kfree(buf); 1826 return 0; 1827 } 1828 } 1829 return ret; 1830 } 1831 1832 /** 1833 * vt_do_kdskbmode - set keyboard mode ioctl 1834 * @console: the console to use 1835 * @arg: the requested mode 1836 * 1837 * Update the keyboard mode bits while holding the correct locks. 1838 * Return 0 for success or an error code. 1839 */ 1840 int vt_do_kdskbmode(unsigned int console, unsigned int arg) 1841 { 1842 struct kbd_struct *kb = &kbd_table[console]; 1843 int ret = 0; 1844 unsigned long flags; 1845 1846 spin_lock_irqsave(&kbd_event_lock, flags); 1847 switch(arg) { 1848 case K_RAW: 1849 kb->kbdmode = VC_RAW; 1850 break; 1851 case K_MEDIUMRAW: 1852 kb->kbdmode = VC_MEDIUMRAW; 1853 break; 1854 case K_XLATE: 1855 kb->kbdmode = VC_XLATE; 1856 do_compute_shiftstate(); 1857 break; 1858 case K_UNICODE: 1859 kb->kbdmode = VC_UNICODE; 1860 do_compute_shiftstate(); 1861 break; 1862 case K_OFF: 1863 kb->kbdmode = VC_OFF; 1864 break; 1865 default: 1866 ret = -EINVAL; 1867 } 1868 spin_unlock_irqrestore(&kbd_event_lock, flags); 1869 return ret; 1870 } 1871 1872 /** 1873 * vt_do_kdskbmeta - set keyboard meta state 1874 * @console: the console to use 1875 * @arg: the requested meta state 1876 * 1877 * Update the keyboard meta bits while holding the correct locks. 1878 * Return 0 for success or an error code. 1879 */ 1880 int vt_do_kdskbmeta(unsigned int console, unsigned int arg) 1881 { 1882 struct kbd_struct *kb = &kbd_table[console]; 1883 int ret = 0; 1884 unsigned long flags; 1885 1886 spin_lock_irqsave(&kbd_event_lock, flags); 1887 switch(arg) { 1888 case K_METABIT: 1889 clr_vc_kbd_mode(kb, VC_META); 1890 break; 1891 case K_ESCPREFIX: 1892 set_vc_kbd_mode(kb, VC_META); 1893 break; 1894 default: 1895 ret = -EINVAL; 1896 } 1897 spin_unlock_irqrestore(&kbd_event_lock, flags); 1898 return ret; 1899 } 1900 1901 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, 1902 int perm) 1903 { 1904 struct kbkeycode tmp; 1905 int kc = 0; 1906 1907 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode))) 1908 return -EFAULT; 1909 switch (cmd) { 1910 case KDGETKEYCODE: 1911 kc = getkeycode(tmp.scancode); 1912 if (kc >= 0) 1913 kc = put_user(kc, &user_kbkc->keycode); 1914 break; 1915 case KDSETKEYCODE: 1916 if (!perm) 1917 return -EPERM; 1918 kc = setkeycode(tmp.scancode, tmp.keycode); 1919 break; 1920 } 1921 return kc; 1922 } 1923 1924 static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx, 1925 unsigned char map) 1926 { 1927 unsigned short *key_map, val; 1928 unsigned long flags; 1929 1930 /* Ensure another thread doesn't free it under us */ 1931 spin_lock_irqsave(&kbd_event_lock, flags); 1932 key_map = key_maps[map]; 1933 if (key_map) { 1934 val = U(key_map[idx]); 1935 if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES) 1936 val = K_HOLE; 1937 } else 1938 val = idx ? K_HOLE : K_NOSUCHMAP; 1939 spin_unlock_irqrestore(&kbd_event_lock, flags); 1940 1941 return val; 1942 } 1943 1944 static int vt_kdskbent(unsigned char kbdmode, unsigned char idx, 1945 unsigned char map, unsigned short val) 1946 { 1947 unsigned long flags; 1948 unsigned short *key_map, *new_map, oldval; 1949 1950 if (!idx && val == K_NOSUCHMAP) { 1951 spin_lock_irqsave(&kbd_event_lock, flags); 1952 /* deallocate map */ 1953 key_map = key_maps[map]; 1954 if (map && key_map) { 1955 key_maps[map] = NULL; 1956 if (key_map[0] == U(K_ALLOCATED)) { 1957 kfree(key_map); 1958 keymap_count--; 1959 } 1960 } 1961 spin_unlock_irqrestore(&kbd_event_lock, flags); 1962 1963 return 0; 1964 } 1965 1966 if (KTYP(val) < NR_TYPES) { 1967 if (KVAL(val) > max_vals[KTYP(val)]) 1968 return -EINVAL; 1969 } else if (kbdmode != VC_UNICODE) 1970 return -EINVAL; 1971 1972 /* ++Geert: non-PC keyboards may generate keycode zero */ 1973 #if !defined(__mc68000__) && !defined(__powerpc__) 1974 /* assignment to entry 0 only tests validity of args */ 1975 if (!idx) 1976 return 0; 1977 #endif 1978 1979 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL); 1980 if (!new_map) 1981 return -ENOMEM; 1982 1983 spin_lock_irqsave(&kbd_event_lock, flags); 1984 key_map = key_maps[map]; 1985 if (key_map == NULL) { 1986 int j; 1987 1988 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && 1989 !capable(CAP_SYS_RESOURCE)) { 1990 spin_unlock_irqrestore(&kbd_event_lock, flags); 1991 kfree(new_map); 1992 return -EPERM; 1993 } 1994 key_maps[map] = new_map; 1995 key_map = new_map; 1996 key_map[0] = U(K_ALLOCATED); 1997 for (j = 1; j < NR_KEYS; j++) 1998 key_map[j] = U(K_HOLE); 1999 keymap_count++; 2000 } else 2001 kfree(new_map); 2002 2003 oldval = U(key_map[idx]); 2004 if (val == oldval) 2005 goto out; 2006 2007 /* Attention Key */ 2008 if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) { 2009 spin_unlock_irqrestore(&kbd_event_lock, flags); 2010 return -EPERM; 2011 } 2012 2013 key_map[idx] = U(val); 2014 if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT)) 2015 do_compute_shiftstate(); 2016 out: 2017 spin_unlock_irqrestore(&kbd_event_lock, flags); 2018 2019 return 0; 2020 } 2021 2022 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm, 2023 unsigned int console) 2024 { 2025 struct kbd_struct *kb = &kbd_table[console]; 2026 struct kbentry kbe; 2027 2028 if (copy_from_user(&kbe, user_kbe, sizeof(struct kbentry))) 2029 return -EFAULT; 2030 2031 switch (cmd) { 2032 case KDGKBENT: 2033 return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index, 2034 kbe.kb_table), 2035 &user_kbe->kb_value); 2036 case KDSKBENT: 2037 if (!perm || !capable(CAP_SYS_TTY_CONFIG)) 2038 return -EPERM; 2039 return vt_kdskbent(kb->kbdmode, kbe.kb_index, kbe.kb_table, 2040 kbe.kb_value); 2041 } 2042 return 0; 2043 } 2044 2045 static char *vt_kdskbsent(char *kbs, unsigned char cur) 2046 { 2047 static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC); 2048 char *cur_f = func_table[cur]; 2049 2050 if (cur_f && strlen(cur_f) >= strlen(kbs)) { 2051 strcpy(cur_f, kbs); 2052 return kbs; 2053 } 2054 2055 func_table[cur] = kbs; 2056 2057 return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL; 2058 } 2059 2060 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm) 2061 { 2062 unsigned char kb_func; 2063 unsigned long flags; 2064 char *kbs; 2065 int ret; 2066 2067 if (get_user(kb_func, &user_kdgkb->kb_func)) 2068 return -EFAULT; 2069 2070 kb_func = array_index_nospec(kb_func, MAX_NR_FUNC); 2071 2072 switch (cmd) { 2073 case KDGKBSENT: { 2074 /* size should have been a struct member */ 2075 ssize_t len = sizeof(user_kdgkb->kb_string); 2076 2077 kbs = kmalloc(len, GFP_KERNEL); 2078 if (!kbs) 2079 return -ENOMEM; 2080 2081 spin_lock_irqsave(&func_buf_lock, flags); 2082 len = strlcpy(kbs, func_table[kb_func] ? : "", len); 2083 spin_unlock_irqrestore(&func_buf_lock, flags); 2084 2085 ret = copy_to_user(user_kdgkb->kb_string, kbs, len + 1) ? 2086 -EFAULT : 0; 2087 2088 break; 2089 } 2090 case KDSKBSENT: 2091 if (!perm || !capable(CAP_SYS_TTY_CONFIG)) 2092 return -EPERM; 2093 2094 kbs = strndup_user(user_kdgkb->kb_string, 2095 sizeof(user_kdgkb->kb_string)); 2096 if (IS_ERR(kbs)) 2097 return PTR_ERR(kbs); 2098 2099 spin_lock_irqsave(&func_buf_lock, flags); 2100 kbs = vt_kdskbsent(kbs, kb_func); 2101 spin_unlock_irqrestore(&func_buf_lock, flags); 2102 2103 ret = 0; 2104 break; 2105 } 2106 2107 kfree(kbs); 2108 2109 return ret; 2110 } 2111 2112 int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm) 2113 { 2114 struct kbd_struct *kb = &kbd_table[console]; 2115 unsigned long flags; 2116 unsigned char ucval; 2117 2118 switch(cmd) { 2119 /* the ioctls below read/set the flags usually shown in the leds */ 2120 /* don't use them - they will go away without warning */ 2121 case KDGKBLED: 2122 spin_lock_irqsave(&kbd_event_lock, flags); 2123 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4); 2124 spin_unlock_irqrestore(&kbd_event_lock, flags); 2125 return put_user(ucval, (char __user *)arg); 2126 2127 case KDSKBLED: 2128 if (!perm) 2129 return -EPERM; 2130 if (arg & ~0x77) 2131 return -EINVAL; 2132 spin_lock_irqsave(&led_lock, flags); 2133 kb->ledflagstate = (arg & 7); 2134 kb->default_ledflagstate = ((arg >> 4) & 7); 2135 set_leds(); 2136 spin_unlock_irqrestore(&led_lock, flags); 2137 return 0; 2138 2139 /* the ioctls below only set the lights, not the functions */ 2140 /* for those, see KDGKBLED and KDSKBLED above */ 2141 case KDGETLED: 2142 ucval = getledstate(); 2143 return put_user(ucval, (char __user *)arg); 2144 2145 case KDSETLED: 2146 if (!perm) 2147 return -EPERM; 2148 setledstate(kb, arg); 2149 return 0; 2150 } 2151 return -ENOIOCTLCMD; 2152 } 2153 2154 int vt_do_kdgkbmode(unsigned int console) 2155 { 2156 struct kbd_struct *kb = &kbd_table[console]; 2157 /* This is a spot read so needs no locking */ 2158 switch (kb->kbdmode) { 2159 case VC_RAW: 2160 return K_RAW; 2161 case VC_MEDIUMRAW: 2162 return K_MEDIUMRAW; 2163 case VC_UNICODE: 2164 return K_UNICODE; 2165 case VC_OFF: 2166 return K_OFF; 2167 default: 2168 return K_XLATE; 2169 } 2170 } 2171 2172 /** 2173 * vt_do_kdgkbmeta - report meta status 2174 * @console: console to report 2175 * 2176 * Report the meta flag status of this console 2177 */ 2178 int vt_do_kdgkbmeta(unsigned int console) 2179 { 2180 struct kbd_struct *kb = &kbd_table[console]; 2181 /* Again a spot read so no locking */ 2182 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT; 2183 } 2184 2185 /** 2186 * vt_reset_unicode - reset the unicode status 2187 * @console: console being reset 2188 * 2189 * Restore the unicode console state to its default 2190 */ 2191 void vt_reset_unicode(unsigned int console) 2192 { 2193 unsigned long flags; 2194 2195 spin_lock_irqsave(&kbd_event_lock, flags); 2196 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 2197 spin_unlock_irqrestore(&kbd_event_lock, flags); 2198 } 2199 2200 /** 2201 * vt_get_shift_state - shift bit state 2202 * 2203 * Report the shift bits from the keyboard state. We have to export 2204 * this to support some oddities in the vt layer. 2205 */ 2206 int vt_get_shift_state(void) 2207 { 2208 /* Don't lock as this is a transient report */ 2209 return shift_state; 2210 } 2211 2212 /** 2213 * vt_reset_keyboard - reset keyboard state 2214 * @console: console to reset 2215 * 2216 * Reset the keyboard bits for a console as part of a general console 2217 * reset event 2218 */ 2219 void vt_reset_keyboard(unsigned int console) 2220 { 2221 struct kbd_struct *kb = &kbd_table[console]; 2222 unsigned long flags; 2223 2224 spin_lock_irqsave(&kbd_event_lock, flags); 2225 set_vc_kbd_mode(kb, VC_REPEAT); 2226 clr_vc_kbd_mode(kb, VC_CKMODE); 2227 clr_vc_kbd_mode(kb, VC_APPLIC); 2228 clr_vc_kbd_mode(kb, VC_CRLF); 2229 kb->lockstate = 0; 2230 kb->slockstate = 0; 2231 spin_lock(&led_lock); 2232 kb->ledmode = LED_SHOW_FLAGS; 2233 kb->ledflagstate = kb->default_ledflagstate; 2234 spin_unlock(&led_lock); 2235 /* do not do set_leds here because this causes an endless tasklet loop 2236 when the keyboard hasn't been initialized yet */ 2237 spin_unlock_irqrestore(&kbd_event_lock, flags); 2238 } 2239 2240 /** 2241 * vt_get_kbd_mode_bit - read keyboard status bits 2242 * @console: console to read from 2243 * @bit: mode bit to read 2244 * 2245 * Report back a vt mode bit. We do this without locking so the 2246 * caller must be sure that there are no synchronization needs 2247 */ 2248 2249 int vt_get_kbd_mode_bit(unsigned int console, int bit) 2250 { 2251 struct kbd_struct *kb = &kbd_table[console]; 2252 return vc_kbd_mode(kb, bit); 2253 } 2254 2255 /** 2256 * vt_set_kbd_mode_bit - read keyboard status bits 2257 * @console: console to read from 2258 * @bit: mode bit to read 2259 * 2260 * Set a vt mode bit. We do this without locking so the 2261 * caller must be sure that there are no synchronization needs 2262 */ 2263 2264 void vt_set_kbd_mode_bit(unsigned int console, int bit) 2265 { 2266 struct kbd_struct *kb = &kbd_table[console]; 2267 unsigned long flags; 2268 2269 spin_lock_irqsave(&kbd_event_lock, flags); 2270 set_vc_kbd_mode(kb, bit); 2271 spin_unlock_irqrestore(&kbd_event_lock, flags); 2272 } 2273 2274 /** 2275 * vt_clr_kbd_mode_bit - read keyboard status bits 2276 * @console: console to read from 2277 * @bit: mode bit to read 2278 * 2279 * Report back a vt mode bit. We do this without locking so the 2280 * caller must be sure that there are no synchronization needs 2281 */ 2282 2283 void vt_clr_kbd_mode_bit(unsigned int console, int bit) 2284 { 2285 struct kbd_struct *kb = &kbd_table[console]; 2286 unsigned long flags; 2287 2288 spin_lock_irqsave(&kbd_event_lock, flags); 2289 clr_vc_kbd_mode(kb, bit); 2290 spin_unlock_irqrestore(&kbd_event_lock, flags); 2291 } 2292