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