drivers/tty/vt/keyboard.c

   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_set_brightness(cdev, ledstate & trigger->mask ? LED_FULL : LED_OFF);
1037         tasklet_enable(&keyboard_tasklet);
1038
1039         return 0;
1040 }
1041
1042 #define KBD_LED_TRIGGER(_led_bit, _name) {                      \
1043                 .trigger = {                                    \
1044                         .name = _name,                          \
1045                         .activate = kbd_led_trigger_activate,   \
1046                 },                                              \
1047                 .mask   = BIT(_led_bit),                        \
1048         }
1049
1050 #define KBD_LOCKSTATE_TRIGGER(_led_bit, _name)          \
1051         KBD_LED_TRIGGER((_led_bit) + 8, _name)
1052
1053 static struct kbd_led_trigger kbd_led_triggers[] = {
1054         KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
1055         KBD_LED_TRIGGER(VC_NUMLOCK,   "kbd-numlock"),
1056         KBD_LED_TRIGGER(VC_CAPSLOCK,  "kbd-capslock"),
1057         KBD_LED_TRIGGER(VC_KANALOCK,  "kbd-kanalock"),
1058
1059         KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK,  "kbd-shiftlock"),
1060         KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK,  "kbd-altgrlock"),
1061         KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK,   "kbd-ctrllock"),
1062         KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK,    "kbd-altlock"),
1063         KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1064         KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1065         KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK,  "kbd-ctrlllock"),
1066         KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK,  "kbd-ctrlrlock"),
1067 };
1068
1069 static void kbd_propagate_led_state(unsigned int old_state,
1070                                     unsigned int new_state)
1071 {
1072         struct kbd_led_trigger *trigger;
1073         unsigned int changed = old_state ^ new_state;
1074         int i;
1075
1076         for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1077                 trigger = &kbd_led_triggers[i];
1078
1079                 if (changed & trigger->mask)
1080                         led_trigger_event(&trigger->trigger,
1081                                           new_state & trigger->mask ?
1082                                                 LED_FULL : LED_OFF);
1083         }
1084 }
1085
1086 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1087 {
1088         unsigned int led_state = *(unsigned int *)data;
1089
1090         if (test_bit(EV_LED, handle->dev->evbit))
1091                 kbd_propagate_led_state(~led_state, led_state);
1092
1093         return 0;
1094 }
1095
1096 static void kbd_init_leds(void)
1097 {
1098         int error;
1099         int i;
1100
1101         for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1102                 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1103                 if (error)
1104                         pr_err("error %d while registering trigger %s\n",
1105                                error, kbd_led_triggers[i].trigger.name);
1106         }
1107 }
1108
1109 #else
1110
1111 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1112 {
1113         unsigned int leds = *(unsigned int *)data;
1114
1115         if (test_bit(EV_LED, handle->dev->evbit)) {
1116                 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & BIT(0)));
1117                 input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & BIT(1)));
1118                 input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & BIT(2)));
1119                 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1120         }
1121
1122         return 0;
1123 }
1124
1125 static void kbd_propagate_led_state(unsigned int old_state,
1126                                     unsigned int new_state)
1127 {
1128         input_handler_for_each_handle(&kbd_handler, &new_state,
1129                                       kbd_update_leds_helper);
1130 }
1131
1132 static void kbd_init_leds(void)
1133 {
1134 }
1135
1136 #endif
1137
1138 /*
1139  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1140  * or (ii) whatever pattern of lights people want to show using KDSETLED,
1141  * or (iii) specified bits of specified words in kernel memory.
1142  */
1143 static unsigned char getledstate(void)
1144 {
1145         return ledstate & 0xff;
1146 }
1147
1148 void setledstate(struct kbd_struct *kb, unsigned int led)
1149 {
1150         unsigned long flags;
1151         spin_lock_irqsave(&led_lock, flags);
1152         if (!(led & ~7)) {
1153                 ledioctl = led;
1154                 kb->ledmode = LED_SHOW_IOCTL;
1155         } else
1156                 kb->ledmode = LED_SHOW_FLAGS;
1157
1158         set_leds();
1159         spin_unlock_irqrestore(&led_lock, flags);
1160 }
1161
1162 static inline unsigned char getleds(void)
1163 {
1164         struct kbd_struct *kb = kbd_table + fg_console;
1165
1166         if (kb->ledmode == LED_SHOW_IOCTL)
1167                 return ledioctl;
1168
1169         return kb->ledflagstate;
1170 }
1171
1172 /**
1173  *      vt_get_leds     -       helper for braille console
1174  *      @console: console to read
1175  *      @flag: flag we want to check
1176  *
1177  *      Check the status of a keyboard led flag and report it back
1178  */
1179 int vt_get_leds(unsigned int console, int flag)
1180 {
1181         struct kbd_struct *kb = &kbd_table[console];
1182         int ret;
1183         unsigned long flags;
1184
1185         spin_lock_irqsave(&led_lock, flags);
1186         ret = vc_kbd_led(kb, flag);
1187         spin_unlock_irqrestore(&led_lock, flags);
1188
1189         return ret;
1190 }
1191 EXPORT_SYMBOL_GPL(vt_get_leds);
1192
1193 /**
1194  *      vt_set_led_state        -       set LED state of a console
1195  *      @console: console to set
1196  *      @leds: LED bits
1197  *
1198  *      Set the LEDs on a console. This is a wrapper for the VT layer
1199  *      so that we can keep kbd knowledge internal
1200  */
1201 void vt_set_led_state(unsigned int console, int leds)
1202 {
1203         struct kbd_struct *kb = &kbd_table[console];
1204         setledstate(kb, leds);
1205 }
1206
1207 /**
1208  *      vt_kbd_con_start        -       Keyboard side of console start
1209  *      @console: console
1210  *
1211  *      Handle console start. This is a wrapper for the VT layer
1212  *      so that we can keep kbd knowledge internal
1213  *
1214  *      FIXME: We eventually need to hold the kbd lock here to protect
1215  *      the LED updating. We can't do it yet because fn_hold calls stop_tty
1216  *      and start_tty under the kbd_event_lock, while normal tty paths
1217  *      don't hold the lock. We probably need to split out an LED lock
1218  *      but not during an -rc release!
1219  */
1220 void vt_kbd_con_start(unsigned int console)
1221 {
1222         struct kbd_struct *kb = &kbd_table[console];
1223         unsigned long flags;
1224         spin_lock_irqsave(&led_lock, flags);
1225         clr_vc_kbd_led(kb, VC_SCROLLOCK);
1226         set_leds();
1227         spin_unlock_irqrestore(&led_lock, flags);
1228 }
1229
1230 /**
1231  *      vt_kbd_con_stop         -       Keyboard side of console stop
1232  *      @console: console
1233  *
1234  *      Handle console stop. This is a wrapper for the VT layer
1235  *      so that we can keep kbd knowledge internal
1236  */
1237 void vt_kbd_con_stop(unsigned int console)
1238 {
1239         struct kbd_struct *kb = &kbd_table[console];
1240         unsigned long flags;
1241         spin_lock_irqsave(&led_lock, flags);
1242         set_vc_kbd_led(kb, VC_SCROLLOCK);
1243         set_leds();
1244         spin_unlock_irqrestore(&led_lock, flags);
1245 }
1246
1247 /*
1248  * This is the tasklet that updates LED state of LEDs using standard
1249  * keyboard triggers. The reason we use tasklet is that we need to
1250  * handle the scenario when keyboard handler is not registered yet
1251  * but we already getting updates from the VT to update led state.
1252  */
1253 static void kbd_bh(struct tasklet_struct *unused)
1254 {
1255         unsigned int leds;
1256         unsigned long flags;
1257
1258         spin_lock_irqsave(&led_lock, flags);
1259         leds = getleds();
1260         leds |= (unsigned int)kbd->lockstate << 8;
1261         spin_unlock_irqrestore(&led_lock, flags);
1262
1263         if (vt_switch) {
1264                 ledstate = ~leds;
1265                 vt_switch = false;
1266         }
1267
1268         if (leds != ledstate) {
1269                 kbd_propagate_led_state(ledstate, leds);
1270                 ledstate = leds;
1271         }
1272 }
1273
1274 #if defined(CONFIG_X86) || defined(CONFIG_ALPHA) ||\
1275     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1276     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1277     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1278
1279 static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1280 {
1281         if (!test_bit(EV_MSC, dev->evbit) || !test_bit(MSC_RAW, dev->mscbit))
1282                 return false;
1283
1284         return dev->id.bustype == BUS_I8042 &&
1285                 dev->id.vendor == 0x0001 && dev->id.product == 0x0001;
1286 }
1287
1288 static const unsigned short x86_keycodes[256] =
1289         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1290          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1291          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1292          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1293          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1294          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1295         284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1296         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1297         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1298         103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1299         291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1300         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1301         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1302         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1303         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1304
1305 #ifdef CONFIG_SPARC
1306 static int sparc_l1_a_state;
1307 extern void sun_do_break(void);
1308 #endif
1309
1310 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1311                        unsigned char up_flag)
1312 {
1313         int code;
1314
1315         switch (keycode) {
1316
1317         case KEY_PAUSE:
1318                 put_queue(vc, 0xe1);
1319                 put_queue(vc, 0x1d | up_flag);
1320                 put_queue(vc, 0x45 | up_flag);
1321                 break;
1322
1323         case KEY_HANGEUL:
1324                 if (!up_flag)
1325                         put_queue(vc, 0xf2);
1326                 break;
1327
1328         case KEY_HANJA:
1329                 if (!up_flag)
1330                         put_queue(vc, 0xf1);
1331                 break;
1332
1333         case KEY_SYSRQ:
1334                 /*
1335                  * Real AT keyboards (that's what we're trying
1336                  * to emulate here) emit 0xe0 0x2a 0xe0 0x37 when
1337                  * pressing PrtSc/SysRq alone, but simply 0x54
1338                  * when pressing Alt+PrtSc/SysRq.
1339                  */
1340                 if (test_bit(KEY_LEFTALT, key_down) ||
1341                     test_bit(KEY_RIGHTALT, key_down)) {
1342                         put_queue(vc, 0x54 | up_flag);
1343                 } else {
1344                         put_queue(vc, 0xe0);
1345                         put_queue(vc, 0x2a | up_flag);
1346                         put_queue(vc, 0xe0);
1347                         put_queue(vc, 0x37 | up_flag);
1348                 }
1349                 break;
1350
1351         default:
1352                 if (keycode > 255)
1353                         return -1;
1354
1355                 code = x86_keycodes[keycode];
1356                 if (!code)
1357                         return -1;
1358
1359                 if (code & 0x100)
1360                         put_queue(vc, 0xe0);
1361                 put_queue(vc, (code & 0x7f) | up_flag);
1362
1363                 break;
1364         }
1365
1366         return 0;
1367 }
1368
1369 #else
1370
1371 static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1372 {
1373         return false;
1374 }
1375
1376 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1377 {
1378         if (keycode > 127)
1379                 return -1;
1380
1381         put_queue(vc, keycode | up_flag);
1382         return 0;
1383 }
1384 #endif
1385
1386 static void kbd_rawcode(unsigned char data)
1387 {
1388         struct vc_data *vc = vc_cons[fg_console].d;
1389
1390         kbd = &kbd_table[vc->vc_num];
1391         if (kbd->kbdmode == VC_RAW)
1392                 put_queue(vc, data);
1393 }
1394
1395 static void kbd_keycode(unsigned int keycode, int down, bool hw_raw)
1396 {
1397         struct vc_data *vc = vc_cons[fg_console].d;
1398         unsigned short keysym, *key_map;
1399         unsigned char type;
1400         bool raw_mode;
1401         struct tty_struct *tty;
1402         int shift_final;
1403         struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1404         int rc;
1405
1406         tty = vc->port.tty;
1407
1408         if (tty && (!tty->driver_data)) {
1409                 /* No driver data? Strange. Okay we fix it then. */
1410                 tty->driver_data = vc;
1411         }
1412
1413         kbd = &kbd_table[vc->vc_num];
1414
1415 #ifdef CONFIG_SPARC
1416         if (keycode == KEY_STOP)
1417                 sparc_l1_a_state = down;
1418 #endif
1419
1420         rep = (down == 2);
1421
1422         raw_mode = (kbd->kbdmode == VC_RAW);
1423         if (raw_mode && !hw_raw)
1424                 if (emulate_raw(vc, keycode, !down << 7))
1425                         if (keycode < BTN_MISC && printk_ratelimit())
1426                                 pr_warn("can't emulate rawmode for keycode %d\n",
1427                                         keycode);
1428
1429 #ifdef CONFIG_SPARC
1430         if (keycode == KEY_A && sparc_l1_a_state) {
1431                 sparc_l1_a_state = false;
1432                 sun_do_break();
1433         }
1434 #endif
1435
1436         if (kbd->kbdmode == VC_MEDIUMRAW) {
1437                 /*
1438                  * This is extended medium raw mode, with keys above 127
1439                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1440                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1441                  * interfere with anything else. The two bytes after 0 will
1442                  * always have the up flag set not to interfere with older
1443                  * applications. This allows for 16384 different keycodes,
1444                  * which should be enough.
1445                  */
1446                 if (keycode < 128) {
1447                         put_queue(vc, keycode | (!down << 7));
1448                 } else {
1449                         put_queue(vc, !down << 7);
1450                         put_queue(vc, (keycode >> 7) | BIT(7));
1451                         put_queue(vc, keycode | BIT(7));
1452                 }
1453                 raw_mode = true;
1454         }
1455
1456         assign_bit(keycode, key_down, down);
1457
1458         if (rep &&
1459             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1460              (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1461                 /*
1462                  * Don't repeat a key if the input buffers are not empty and the
1463                  * characters get aren't echoed locally. This makes key repeat
1464                  * usable with slow applications and under heavy loads.
1465                  */
1466                 return;
1467         }
1468
1469         param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1470         param.ledstate = kbd->ledflagstate;
1471         key_map = key_maps[shift_final];
1472
1473         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1474                                         KBD_KEYCODE, &param);
1475         if (rc == NOTIFY_STOP || !key_map) {
1476                 atomic_notifier_call_chain(&keyboard_notifier_list,
1477                                            KBD_UNBOUND_KEYCODE, &param);
1478                 do_compute_shiftstate();
1479                 kbd->slockstate = 0;
1480                 return;
1481         }
1482
1483         if (keycode < NR_KEYS)
1484                 keysym = key_map[keycode];
1485         else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1486                 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1487         else
1488                 return;
1489
1490         type = KTYP(keysym);
1491
1492         if (type < 0xf0) {
1493                 param.value = keysym;
1494                 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1495                                                 KBD_UNICODE, &param);
1496                 if (rc != NOTIFY_STOP)
1497                         if (down && !raw_mode)
1498                                 k_unicode(vc, keysym, !down);
1499                 return;
1500         }
1501
1502         type -= 0xf0;
1503
1504         if (type == KT_LETTER) {
1505                 type = KT_LATIN;
1506                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1507                         key_map = key_maps[shift_final ^ BIT(KG_SHIFT)];
1508                         if (key_map)
1509                                 keysym = key_map[keycode];
1510                 }
1511         }
1512
1513         param.value = keysym;
1514         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1515                                         KBD_KEYSYM, &param);
1516         if (rc == NOTIFY_STOP)
1517                 return;
1518
1519         if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1520                 return;
1521
1522         (*k_handler[type])(vc, keysym & 0xff, !down);
1523
1524         param.ledstate = kbd->ledflagstate;
1525         atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1526
1527         if (type != KT_SLOCK)
1528                 kbd->slockstate = 0;
1529 }
1530
1531 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1532                       unsigned int event_code, int value)
1533 {
1534         /* We are called with interrupts disabled, just take the lock */
1535         spin_lock(&kbd_event_lock);
1536
1537         if (event_type == EV_MSC && event_code == MSC_RAW &&
1538                         kbd_is_hw_raw(handle->dev))
1539                 kbd_rawcode(value);
1540         if (event_type == EV_KEY && event_code <= KEY_MAX)
1541                 kbd_keycode(event_code, value, kbd_is_hw_raw(handle->dev));
1542
1543         spin_unlock(&kbd_event_lock);
1544
1545         tasklet_schedule(&keyboard_tasklet);
1546         do_poke_blanked_console = 1;
1547         schedule_console_callback();
1548 }
1549
1550 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1551 {
1552         if (test_bit(EV_SND, dev->evbit))
1553                 return true;
1554
1555         if (test_bit(EV_KEY, dev->evbit)) {
1556                 if (find_next_bit(dev->keybit, BTN_MISC, KEY_RESERVED) <
1557                                 BTN_MISC)
1558                         return true;
1559                 if (find_next_bit(dev->keybit, KEY_BRL_DOT10 + 1,
1560                                         KEY_BRL_DOT1) <= KEY_BRL_DOT10)
1561                         return true;
1562         }
1563
1564         return false;
1565 }
1566
1567 /*
1568  * When a keyboard (or other input device) is found, the kbd_connect
1569  * function is called. The function then looks at the device, and if it
1570  * likes it, it can open it and get events from it. In this (kbd_connect)
1571  * function, we should decide which VT to bind that keyboard to initially.
1572  */
1573 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1574                         const struct input_device_id *id)
1575 {
1576         struct input_handle *handle;
1577         int error;
1578
1579         handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1580         if (!handle)
1581                 return -ENOMEM;
1582
1583         handle->dev = dev;
1584         handle->handler = handler;
1585         handle->name = "kbd";
1586
1587         error = input_register_handle(handle);
1588         if (error)
1589                 goto err_free_handle;
1590
1591         error = input_open_device(handle);
1592         if (error)
1593                 goto err_unregister_handle;
1594
1595         return 0;
1596
1597  err_unregister_handle:
1598         input_unregister_handle(handle);
1599  err_free_handle:
1600         kfree(handle);
1601         return error;
1602 }
1603
1604 static void kbd_disconnect(struct input_handle *handle)
1605 {
1606         input_close_device(handle);
1607         input_unregister_handle(handle);
1608         kfree(handle);
1609 }
1610
1611 /*
1612  * Start keyboard handler on the new keyboard by refreshing LED state to
1613  * match the rest of the system.
1614  */
1615 static void kbd_start(struct input_handle *handle)
1616 {
1617         tasklet_disable(&keyboard_tasklet);
1618
1619         if (ledstate != -1U)
1620                 kbd_update_leds_helper(handle, &ledstate);
1621
1622         tasklet_enable(&keyboard_tasklet);
1623 }
1624
1625 static const struct input_device_id kbd_ids[] = {
1626         {
1627                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1628                 .evbit = { BIT_MASK(EV_KEY) },
1629         },
1630
1631         {
1632                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1633                 .evbit = { BIT_MASK(EV_SND) },
1634         },
1635
1636         { },    /* Terminating entry */
1637 };
1638
1639 MODULE_DEVICE_TABLE(input, kbd_ids);
1640
1641 static struct input_handler kbd_handler = {
1642         .event          = kbd_event,
1643         .match          = kbd_match,
1644         .connect        = kbd_connect,
1645         .disconnect     = kbd_disconnect,
1646         .start          = kbd_start,
1647         .name           = "kbd",
1648         .id_table       = kbd_ids,
1649 };
1650
1651 int __init kbd_init(void)
1652 {
1653         int i;
1654         int error;
1655
1656         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1657                 kbd_table[i].ledflagstate = kbd_defleds();
1658                 kbd_table[i].default_ledflagstate = kbd_defleds();
1659                 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1660                 kbd_table[i].lockstate = KBD_DEFLOCK;
1661                 kbd_table[i].slockstate = 0;
1662                 kbd_table[i].modeflags = KBD_DEFMODE;
1663                 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1664         }
1665
1666         kbd_init_leds();
1667
1668         error = input_register_handler(&kbd_handler);
1669         if (error)
1670                 return error;
1671
1672         tasklet_enable(&keyboard_tasklet);
1673         tasklet_schedule(&keyboard_tasklet);
1674
1675         return 0;
1676 }
1677
1678 /* Ioctl support code */
1679
1680 /**
1681  *      vt_do_diacrit           -       diacritical table updates
1682  *      @cmd: ioctl request
1683  *      @udp: pointer to user data for ioctl
1684  *      @perm: permissions check computed by caller
1685  *
1686  *      Update the diacritical tables atomically and safely. Lock them
1687  *      against simultaneous keypresses
1688  */
1689 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1690 {
1691         unsigned long flags;
1692         int asize;
1693         int ret = 0;
1694
1695         switch (cmd) {
1696         case KDGKBDIACR:
1697         {
1698                 struct kbdiacrs __user *a = udp;
1699                 struct kbdiacr *dia;
1700                 int i;
1701
1702                 dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr),
1703                                                                 GFP_KERNEL);
1704                 if (!dia)
1705                         return -ENOMEM;
1706
1707                 /* Lock the diacriticals table, make a copy and then
1708                    copy it after we unlock */
1709                 spin_lock_irqsave(&kbd_event_lock, flags);
1710
1711                 asize = accent_table_size;
1712                 for (i = 0; i < asize; i++) {
1713                         dia[i].diacr = conv_uni_to_8bit(
1714                                                 accent_table[i].diacr);
1715                         dia[i].base = conv_uni_to_8bit(
1716                                                 accent_table[i].base);
1717                         dia[i].result = conv_uni_to_8bit(
1718                                                 accent_table[i].result);
1719                 }
1720                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1721
1722                 if (put_user(asize, &a->kb_cnt))
1723                         ret = -EFAULT;
1724                 else  if (copy_to_user(a->kbdiacr, dia,
1725                                 asize * sizeof(struct kbdiacr)))
1726                         ret = -EFAULT;
1727                 kfree(dia);
1728                 return ret;
1729         }
1730         case KDGKBDIACRUC:
1731         {
1732                 struct kbdiacrsuc __user *a = udp;
1733                 void *buf;
1734
1735                 buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc),
1736                                                                 GFP_KERNEL);
1737                 if (buf == NULL)
1738                         return -ENOMEM;
1739
1740                 /* Lock the diacriticals table, make a copy and then
1741                    copy it after we unlock */
1742                 spin_lock_irqsave(&kbd_event_lock, flags);
1743
1744                 asize = accent_table_size;
1745                 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1746
1747                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1748
1749                 if (put_user(asize, &a->kb_cnt))
1750                         ret = -EFAULT;
1751                 else if (copy_to_user(a->kbdiacruc, buf,
1752                                 asize*sizeof(struct kbdiacruc)))
1753                         ret = -EFAULT;
1754                 kfree(buf);
1755                 return ret;
1756         }
1757
1758         case KDSKBDIACR:
1759         {
1760                 struct kbdiacrs __user *a = udp;
1761                 struct kbdiacr *dia = NULL;
1762                 unsigned int ct;
1763                 int i;
1764
1765                 if (!perm)
1766                         return -EPERM;
1767                 if (get_user(ct, &a->kb_cnt))
1768                         return -EFAULT;
1769                 if (ct >= MAX_DIACR)
1770                         return -EINVAL;
1771
1772                 if (ct) {
1773                         dia = memdup_array_user(a->kbdiacr,
1774                                                 ct, sizeof(struct kbdiacr));
1775                         if (IS_ERR(dia))
1776                                 return PTR_ERR(dia);
1777                 }
1778
1779                 spin_lock_irqsave(&kbd_event_lock, flags);
1780                 accent_table_size = ct;
1781                 for (i = 0; i < ct; i++) {
1782                         accent_table[i].diacr =
1783                                         conv_8bit_to_uni(dia[i].diacr);
1784                         accent_table[i].base =
1785                                         conv_8bit_to_uni(dia[i].base);
1786                         accent_table[i].result =
1787                                         conv_8bit_to_uni(dia[i].result);
1788                 }
1789                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1790                 kfree(dia);
1791                 return 0;
1792         }
1793
1794         case KDSKBDIACRUC:
1795         {
1796                 struct kbdiacrsuc __user *a = udp;
1797                 unsigned int ct;
1798                 void *buf = NULL;
1799
1800                 if (!perm)
1801                         return -EPERM;
1802
1803                 if (get_user(ct, &a->kb_cnt))
1804                         return -EFAULT;
1805
1806                 if (ct >= MAX_DIACR)
1807                         return -EINVAL;
1808
1809                 if (ct) {
1810                         buf = memdup_array_user(a->kbdiacruc,
1811                                                 ct, sizeof(struct kbdiacruc));
1812                         if (IS_ERR(buf))
1813                                 return PTR_ERR(buf);
1814                 }
1815                 spin_lock_irqsave(&kbd_event_lock, flags);
1816                 if (ct)
1817                         memcpy(accent_table, buf,
1818                                         ct * sizeof(struct kbdiacruc));
1819                 accent_table_size = ct;
1820                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1821                 kfree(buf);
1822                 return 0;
1823         }
1824         }
1825         return ret;
1826 }
1827
1828 /**
1829  *      vt_do_kdskbmode         -       set keyboard mode ioctl
1830  *      @console: the console to use
1831  *      @arg: the requested mode
1832  *
1833  *      Update the keyboard mode bits while holding the correct locks.
1834  *      Return 0 for success or an error code.
1835  */
1836 int vt_do_kdskbmode(unsigned int console, unsigned int arg)
1837 {
1838         struct kbd_struct *kb = &kbd_table[console];
1839         int ret = 0;
1840         unsigned long flags;
1841
1842         spin_lock_irqsave(&kbd_event_lock, flags);
1843         switch(arg) {
1844         case K_RAW:
1845                 kb->kbdmode = VC_RAW;
1846                 break;
1847         case K_MEDIUMRAW:
1848                 kb->kbdmode = VC_MEDIUMRAW;
1849                 break;
1850         case K_XLATE:
1851                 kb->kbdmode = VC_XLATE;
1852                 do_compute_shiftstate();
1853                 break;
1854         case K_UNICODE:
1855                 kb->kbdmode = VC_UNICODE;
1856                 do_compute_shiftstate();
1857                 break;
1858         case K_OFF:
1859                 kb->kbdmode = VC_OFF;
1860                 break;
1861         default:
1862                 ret = -EINVAL;
1863         }
1864         spin_unlock_irqrestore(&kbd_event_lock, flags);
1865         return ret;
1866 }
1867
1868 /**
1869  *      vt_do_kdskbmeta         -       set keyboard meta state
1870  *      @console: the console to use
1871  *      @arg: the requested meta state
1872  *
1873  *      Update the keyboard meta bits while holding the correct locks.
1874  *      Return 0 for success or an error code.
1875  */
1876 int vt_do_kdskbmeta(unsigned int console, unsigned int arg)
1877 {
1878         struct kbd_struct *kb = &kbd_table[console];
1879         int ret = 0;
1880         unsigned long flags;
1881
1882         spin_lock_irqsave(&kbd_event_lock, flags);
1883         switch(arg) {
1884         case K_METABIT:
1885                 clr_vc_kbd_mode(kb, VC_META);
1886                 break;
1887         case K_ESCPREFIX:
1888                 set_vc_kbd_mode(kb, VC_META);
1889                 break;
1890         default:
1891                 ret = -EINVAL;
1892         }
1893         spin_unlock_irqrestore(&kbd_event_lock, flags);
1894         return ret;
1895 }
1896
1897 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1898                                                                 int perm)
1899 {
1900         struct kbkeycode tmp;
1901         int kc = 0;
1902
1903         if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1904                 return -EFAULT;
1905         switch (cmd) {
1906         case KDGETKEYCODE:
1907                 kc = getkeycode(tmp.scancode);
1908                 if (kc >= 0)
1909                         kc = put_user(kc, &user_kbkc->keycode);
1910                 break;
1911         case KDSETKEYCODE:
1912                 if (!perm)
1913                         return -EPERM;
1914                 kc = setkeycode(tmp.scancode, tmp.keycode);
1915                 break;
1916         }
1917         return kc;
1918 }
1919
1920 static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx,
1921                 unsigned char map)
1922 {
1923         unsigned short *key_map, val;
1924         unsigned long flags;
1925
1926         /* Ensure another thread doesn't free it under us */
1927         spin_lock_irqsave(&kbd_event_lock, flags);
1928         key_map = key_maps[map];
1929         if (key_map) {
1930                 val = U(key_map[idx]);
1931                 if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1932                         val = K_HOLE;
1933         } else
1934                 val = idx ? K_HOLE : K_NOSUCHMAP;
1935         spin_unlock_irqrestore(&kbd_event_lock, flags);
1936
1937         return val;
1938 }
1939
1940 static int vt_kdskbent(unsigned char kbdmode, unsigned char idx,
1941                 unsigned char map, unsigned short val)
1942 {
1943         unsigned long flags;
1944         unsigned short *key_map, *new_map, oldval;
1945
1946         if (!idx && val == K_NOSUCHMAP) {
1947                 spin_lock_irqsave(&kbd_event_lock, flags);
1948                 /* deallocate map */
1949                 key_map = key_maps[map];
1950                 if (map && key_map) {
1951                         key_maps[map] = NULL;
1952                         if (key_map[0] == U(K_ALLOCATED)) {
1953                                 kfree(key_map);
1954                                 keymap_count--;
1955                         }
1956                 }
1957                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1958
1959                 return 0;
1960         }
1961
1962         if (KTYP(val) < NR_TYPES) {
1963                 if (KVAL(val) > max_vals[KTYP(val)])
1964                         return -EINVAL;
1965         } else if (kbdmode != VC_UNICODE)
1966                 return -EINVAL;
1967
1968         /* ++Geert: non-PC keyboards may generate keycode zero */
1969 #if !defined(__mc68000__) && !defined(__powerpc__)
1970         /* assignment to entry 0 only tests validity of args */
1971         if (!idx)
1972                 return 0;
1973 #endif
1974
1975         new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1976         if (!new_map)
1977                 return -ENOMEM;
1978
1979         spin_lock_irqsave(&kbd_event_lock, flags);
1980         key_map = key_maps[map];
1981         if (key_map == NULL) {
1982                 int j;
1983
1984                 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1985                     !capable(CAP_SYS_RESOURCE)) {
1986                         spin_unlock_irqrestore(&kbd_event_lock, flags);
1987                         kfree(new_map);
1988                         return -EPERM;
1989                 }
1990                 key_maps[map] = new_map;
1991                 key_map = new_map;
1992                 key_map[0] = U(K_ALLOCATED);
1993                 for (j = 1; j < NR_KEYS; j++)
1994                         key_map[j] = U(K_HOLE);
1995                 keymap_count++;
1996         } else
1997                 kfree(new_map);
1998
1999         oldval = U(key_map[idx]);
2000         if (val == oldval)
2001                 goto out;
2002
2003         /* Attention Key */
2004         if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) {
2005                 spin_unlock_irqrestore(&kbd_event_lock, flags);
2006                 return -EPERM;
2007         }
2008
2009         key_map[idx] = U(val);
2010         if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT))
2011                 do_compute_shiftstate();
2012 out:
2013         spin_unlock_irqrestore(&kbd_event_lock, flags);
2014
2015         return 0;
2016 }
2017
2018 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
2019                                                 unsigned int console)
2020 {
2021         struct kbd_struct *kb = &kbd_table[console];
2022         struct kbentry kbe;
2023
2024         if (copy_from_user(&kbe, user_kbe, sizeof(struct kbentry)))
2025                 return -EFAULT;
2026
2027         switch (cmd) {
2028         case KDGKBENT:
2029                 return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index,
2030                                         kbe.kb_table),
2031                                 &user_kbe->kb_value);
2032         case KDSKBENT:
2033                 if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2034                         return -EPERM;
2035                 return vt_kdskbent(kb->kbdmode, kbe.kb_index, kbe.kb_table,
2036                                 kbe.kb_value);
2037         }
2038         return 0;
2039 }
2040
2041 static char *vt_kdskbsent(char *kbs, unsigned char cur)
2042 {
2043         static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC);
2044         char *cur_f = func_table[cur];
2045
2046         if (cur_f && strlen(cur_f) >= strlen(kbs)) {
2047                 strcpy(cur_f, kbs);
2048                 return kbs;
2049         }
2050
2051         func_table[cur] = kbs;
2052
2053         return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL;
2054 }
2055
2056 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2057 {
2058         unsigned char kb_func;
2059         unsigned long flags;
2060         char *kbs;
2061         int ret;
2062
2063         if (get_user(kb_func, &user_kdgkb->kb_func))
2064                 return -EFAULT;
2065
2066         kb_func = array_index_nospec(kb_func, MAX_NR_FUNC);
2067
2068         switch (cmd) {
2069         case KDGKBSENT: {
2070                 /* size should have been a struct member */
2071                 ssize_t len = sizeof(user_kdgkb->kb_string);
2072
2073                 kbs = kmalloc(len, GFP_KERNEL);
2074                 if (!kbs)
2075                         return -ENOMEM;
2076
2077                 spin_lock_irqsave(&func_buf_lock, flags);
2078                 len = strscpy(kbs, func_table[kb_func] ? : "", len);
2079                 spin_unlock_irqrestore(&func_buf_lock, flags);
2080
2081                 if (len < 0) {
2082                         ret = -ENOSPC;
2083                         break;
2084                 }
2085                 ret = copy_to_user(user_kdgkb->kb_string, kbs, len + 1) ?
2086                         -EFAULT : 0;
2087                 break;
2088         }
2089         case KDSKBSENT:
2090                 if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2091                         return -EPERM;
2092
2093                 kbs = strndup_user(user_kdgkb->kb_string,
2094                                 sizeof(user_kdgkb->kb_string));
2095                 if (IS_ERR(kbs))
2096                         return PTR_ERR(kbs);
2097
2098                 spin_lock_irqsave(&func_buf_lock, flags);
2099                 kbs = vt_kdskbsent(kbs, kb_func);
2100                 spin_unlock_irqrestore(&func_buf_lock, flags);
2101
2102                 ret = 0;
2103                 break;
2104         }
2105
2106         kfree(kbs);
2107
2108         return ret;
2109 }
2110
2111 int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm)
2112 {
2113         struct kbd_struct *kb = &kbd_table[console];
2114         unsigned long flags;
2115         unsigned char ucval;
2116
2117         switch(cmd) {
2118         /* the ioctls below read/set the flags usually shown in the leds */
2119         /* don't use them - they will go away without warning */
2120         case KDGKBLED:
2121                 spin_lock_irqsave(&kbd_event_lock, flags);
2122                 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2123                 spin_unlock_irqrestore(&kbd_event_lock, flags);
2124                 return put_user(ucval, (char __user *)arg);
2125
2126         case KDSKBLED:
2127                 if (!perm)
2128                         return -EPERM;
2129                 if (arg & ~0x77)
2130                         return -EINVAL;
2131                 spin_lock_irqsave(&led_lock, flags);
2132                 kb->ledflagstate = (arg & 7);
2133                 kb->default_ledflagstate = ((arg >> 4) & 7);
2134                 set_leds();
2135                 spin_unlock_irqrestore(&led_lock, flags);
2136                 return 0;
2137
2138         /* the ioctls below only set the lights, not the functions */
2139         /* for those, see KDGKBLED and KDSKBLED above */
2140         case KDGETLED:
2141                 ucval = getledstate();
2142                 return put_user(ucval, (char __user *)arg);
2143
2144         case KDSETLED:
2145                 if (!perm)
2146                         return -EPERM;
2147                 setledstate(kb, arg);
2148                 return 0;
2149         }
2150         return -ENOIOCTLCMD;
2151 }
2152
2153 int vt_do_kdgkbmode(unsigned int console)
2154 {
2155         struct kbd_struct *kb = &kbd_table[console];
2156         /* This is a spot read so needs no locking */
2157         switch (kb->kbdmode) {
2158         case VC_RAW:
2159                 return K_RAW;
2160         case VC_MEDIUMRAW:
2161                 return K_MEDIUMRAW;
2162         case VC_UNICODE:
2163                 return K_UNICODE;
2164         case VC_OFF:
2165                 return K_OFF;
2166         default:
2167                 return K_XLATE;
2168         }
2169 }
2170
2171 /**
2172  *      vt_do_kdgkbmeta         -       report meta status
2173  *      @console: console to report
2174  *
2175  *      Report the meta flag status of this console
2176  */
2177 int vt_do_kdgkbmeta(unsigned int console)
2178 {
2179         struct kbd_struct *kb = &kbd_table[console];
2180         /* Again a spot read so no locking */
2181         return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2182 }
2183
2184 /**
2185  *      vt_reset_unicode        -       reset the unicode status
2186  *      @console: console being reset
2187  *
2188  *      Restore the unicode console state to its default
2189  */
2190 void vt_reset_unicode(unsigned int console)
2191 {
2192         unsigned long flags;
2193
2194         spin_lock_irqsave(&kbd_event_lock, flags);
2195         kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2196         spin_unlock_irqrestore(&kbd_event_lock, flags);
2197 }
2198
2199 /**
2200  *      vt_get_shift_state      -       shift bit state
2201  *
2202  *      Report the shift bits from the keyboard state. We have to export
2203  *      this to support some oddities in the vt layer.
2204  */
2205 int vt_get_shift_state(void)
2206 {
2207         /* Don't lock as this is a transient report */
2208         return shift_state;
2209 }
2210
2211 /**
2212  *      vt_reset_keyboard       -       reset keyboard state
2213  *      @console: console to reset
2214  *
2215  *      Reset the keyboard bits for a console as part of a general console
2216  *      reset event
2217  */
2218 void vt_reset_keyboard(unsigned int console)
2219 {
2220         struct kbd_struct *kb = &kbd_table[console];
2221         unsigned long flags;
2222
2223         spin_lock_irqsave(&kbd_event_lock, flags);
2224         set_vc_kbd_mode(kb, VC_REPEAT);
2225         clr_vc_kbd_mode(kb, VC_CKMODE);
2226         clr_vc_kbd_mode(kb, VC_APPLIC);
2227         clr_vc_kbd_mode(kb, VC_CRLF);
2228         kb->lockstate = 0;
2229         kb->slockstate = 0;
2230         spin_lock(&led_lock);
2231         kb->ledmode = LED_SHOW_FLAGS;
2232         kb->ledflagstate = kb->default_ledflagstate;
2233         spin_unlock(&led_lock);
2234         /* do not do set_leds here because this causes an endless tasklet loop
2235            when the keyboard hasn't been initialized yet */
2236         spin_unlock_irqrestore(&kbd_event_lock, flags);
2237 }
2238
2239 /**
2240  *      vt_get_kbd_mode_bit     -       read keyboard status bits
2241  *      @console: console to read from
2242  *      @bit: mode bit to read
2243  *
2244  *      Report back a vt mode bit. We do this without locking so the
2245  *      caller must be sure that there are no synchronization needs
2246  */
2247
2248 int vt_get_kbd_mode_bit(unsigned int console, int bit)
2249 {
2250         struct kbd_struct *kb = &kbd_table[console];
2251         return vc_kbd_mode(kb, bit);
2252 }
2253
2254 /**
2255  *      vt_set_kbd_mode_bit     -       read keyboard status bits
2256  *      @console: console to read from
2257  *      @bit: mode bit to read
2258  *
2259  *      Set a vt mode bit. We do this without locking so the
2260  *      caller must be sure that there are no synchronization needs
2261  */
2262
2263 void vt_set_kbd_mode_bit(unsigned int console, int bit)
2264 {
2265         struct kbd_struct *kb = &kbd_table[console];
2266         unsigned long flags;
2267
2268         spin_lock_irqsave(&kbd_event_lock, flags);
2269         set_vc_kbd_mode(kb, bit);
2270         spin_unlock_irqrestore(&kbd_event_lock, flags);
2271 }
2272
2273 /**
2274  *      vt_clr_kbd_mode_bit     -       read keyboard status bits
2275  *      @console: console to read from
2276  *      @bit: mode bit to read
2277  *
2278  *      Report back a vt mode bit. We do this without locking so the
2279  *      caller must be sure that there are no synchronization needs
2280  */
2281
2282 void vt_clr_kbd_mode_bit(unsigned int console, int bit)
2283 {
2284         struct kbd_struct *kb = &kbd_table[console];
2285         unsigned long flags;
2286
2287         spin_lock_irqsave(&kbd_event_lock, flags);
2288         clr_vc_kbd_mode(kb, bit);
2289         spin_unlock_irqrestore(&kbd_event_lock, flags);
2290 }