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