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