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, [email protected], 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, [email protected].
  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                 '`',    /* dead_grave */
 695                 '\'',   /* dead_acute */
 696                 '^',    /* dead_circumflex */
 697                 '~',    /* dead_tilda */
 698                 '"',    /* dead_diaeresis */
 699                 ',',    /* dead_cedilla */
 700                 '_',    /* dead_macron */
 701                 'U',    /* dead_breve */
 702                 '.',    /* dead_abovedot */
 703                 '*',    /* dead_abovering */
 704                 '=',    /* dead_doubleacute */
 705                 'c',    /* dead_caron */
 706                 'k',    /* dead_ogonek */
 707                 'i',    /* dead_iota */
 708                 '#',    /* dead_voiced_sound */
 709                 'o',    /* dead_semivoiced_sound */
 710                 '!',    /* dead_belowdot */
 711                 '?',    /* dead_hook */
 712                 '+',    /* dead_horn */
 713                 '-',    /* dead_stroke */
 714                 ')',    /* dead_abovecomma */
 715                 '(',    /* dead_abovereversedcomma */
 716                 ':',    /* dead_doublegrave */
 717                 'n',    /* dead_invertedbreve */
 718                 ';',    /* dead_belowcomma */
 719                 '$',    /* dead_currency */
 720                 '@',    /* dead_greek */
 721         };
 722
 723         k_deadunicode(vc, ret_diacr[value], up_flag);
 724 }
 725
 726 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
 727 {
 728         if (up_flag)
 729                 return;
 730
 731         set_console(value);
 732 }
 733
 734 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
 735 {
 736         if (up_flag)
 737                 return;
 738
 739         if ((unsigned)value < ARRAY_SIZE(func_table)) {
 740                 if (func_table[value])
 741                         puts_queue(vc, func_table[value]);
 742         } else
 743                 pr_err("k_fn called with value=%d\n", value);
 744 }
 745
 746 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
 747 {
 748         static const char cur_chars[] = "BDCA";
 749
 750         if (up_flag)
 751                 return;
 752
 753         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 754 }
 755
 756 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
 757 {
 758         static const char pad_chars[] = "0123456789+-*/\015,.?()#";
 759         static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
 760
 761         if (up_flag)
 762                 return;         /* no action, if this is a key release */
 763
 764         /* kludge... shift forces cursor/number keys */
 765         if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
 766                 applkey(vc, app_map[value], 1);
 767                 return;
 768         }
 769
 770         if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
 771
 772                 switch (value) {
 773                 case KVAL(K_PCOMMA):
 774                 case KVAL(K_PDOT):
 775                         k_fn(vc, KVAL(K_REMOVE), 0);
 776                         return;
 777                 case KVAL(K_P0):
 778                         k_fn(vc, KVAL(K_INSERT), 0);
 779                         return;
 780                 case KVAL(K_P1):
 781                         k_fn(vc, KVAL(K_SELECT), 0);
 782                         return;
 783                 case KVAL(K_P2):
 784                         k_cur(vc, KVAL(K_DOWN), 0);
 785                         return;
 786                 case KVAL(K_P3):
 787                         k_fn(vc, KVAL(K_PGDN), 0);
 788                         return;
 789                 case KVAL(K_P4):
 790                         k_cur(vc, KVAL(K_LEFT), 0);
 791                         return;
 792                 case KVAL(K_P6):
 793                         k_cur(vc, KVAL(K_RIGHT), 0);
 794                         return;
 795                 case KVAL(K_P7):
 796                         k_fn(vc, KVAL(K_FIND), 0);
 797                         return;
 798                 case KVAL(K_P8):
 799                         k_cur(vc, KVAL(K_UP), 0);
 800                         return;
 801                 case KVAL(K_P9):
 802                         k_fn(vc, KVAL(K_PGUP), 0);
 803                         return;
 804                 case KVAL(K_P5):
 805                         applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
 806                         return;
 807                 }
 808         }
 809
 810         put_queue(vc, pad_chars[value]);
 811         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
 812                 put_queue(vc, 10);
 813 }
 814
 815 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
 816 {
 817         int old_state = shift_state;
 818
 819         if (rep)
 820                 return;
 821         /*
 822          * Mimic typewriter:
 823          * a CapsShift key acts like Shift but undoes CapsLock
 824          */
 825         if (value == KVAL(K_CAPSSHIFT)) {
 826                 value = KVAL(K_SHIFT);
 827                 if (!up_flag)
 828                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
 829         }
 830
 831         if (up_flag) {
 832                 /*
 833                  * handle the case that two shift or control
 834                  * keys are depressed simultaneously
 835                  */
 836                 if (shift_down[value])
 837                         shift_down[value]--;
 838         } else
 839                 shift_down[value]++;
 840
 841         if (shift_down[value])
 842                 shift_state |= (1 << value);
 843         else
 844                 shift_state &= ~(1 << value);
 845
 846         /* kludge */
 847         if (up_flag && shift_state != old_state && npadch != -1) {
 848                 if (kbd->kbdmode == VC_UNICODE)
 849                         to_utf8(vc, npadch);
 850                 else
 851                         put_queue(vc, npadch & 0xff);
 852                 npadch = -1;
 853         }
 854 }
 855
 856 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
 857 {
 858         if (up_flag)
 859                 return;
 860
 861         if (vc_kbd_mode(kbd, VC_META)) {
 862                 put_queue(vc, '\033');
 863                 put_queue(vc, value);
 864         } else
 865                 put_queue(vc, value | 0x80);
 866 }
 867
 868 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
 869 {
 870         int base;
 871
 872         if (up_flag)
 873                 return;
 874
 875         if (value < 10) {
 876                 /* decimal input of code, while Alt depressed */
 877                 base = 10;
 878         } else {
 879                 /* hexadecimal input of code, while AltGr depressed */
 880                 value -= 10;
 881                 base = 16;
 882         }
 883
 884         if (npadch == -1)
 885                 npadch = value;
 886         else
 887                 npadch = npadch * base + value;
 888 }
 889
 890 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
 891 {
 892         if (up_flag || rep)
 893                 return;
 894
 895         chg_vc_kbd_lock(kbd, value);
 896 }
 897
 898 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
 899 {
 900         k_shift(vc, value, up_flag);
 901         if (up_flag || rep)
 902                 return;
 903
 904         chg_vc_kbd_slock(kbd, value);
 905         /* try to make Alt, oops, AltGr and such work */
 906         if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
 907                 kbd->slockstate = 0;
 908                 chg_vc_kbd_slock(kbd, value);
 909         }
 910 }
 911
 912 /* by default, 300ms interval for combination release */
 913 static unsigned brl_timeout = 300;
 914 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
 915 module_param(brl_timeout, uint, 0644);
 916
 917 static unsigned brl_nbchords = 1;
 918 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
 919 module_param(brl_nbchords, uint, 0644);
 920
 921 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
 922 {
 923         static unsigned long chords;
 924         static unsigned committed;
 925
 926         if (!brl_nbchords)
 927                 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
 928         else {
 929                 committed |= pattern;
 930                 chords++;
 931                 if (chords == brl_nbchords) {
 932                         k_unicode(vc, BRL_UC_ROW | committed, up_flag);
 933                         chords = 0;
 934                         committed = 0;
 935                 }
 936         }
 937 }
 938
 939 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
 940 {
 941         static unsigned pressed, committing;
 942         static unsigned long releasestart;
 943
 944         if (kbd->kbdmode != VC_UNICODE) {
 945                 if (!up_flag)
 946                         pr_warn("keyboard mode must be unicode for braille patterns\n");
 947                 return;
 948         }
 949
 950         if (!value) {
 951                 k_unicode(vc, BRL_UC_ROW, up_flag);
 952                 return;
 953         }
 954
 955         if (value > 8)
 956                 return;
 957
 958         if (!up_flag) {
 959                 pressed |= 1 << (value - 1);
 960                 if (!brl_timeout)
 961                         committing = pressed;
 962         } else if (brl_timeout) {
 963                 if (!committing ||
 964                     time_after(jiffies,
 965                                releasestart + msecs_to_jiffies(brl_timeout))) {
 966                         committing = pressed;
 967                         releasestart = jiffies;
 968                 }
 969                 pressed &= ~(1 << (value - 1));
 970                 if (!pressed && committing) {
 971                         k_brlcommit(vc, committing, 0);
 972                         committing = 0;
 973                 }
 974         } else {
 975                 if (committing) {
 976                         k_brlcommit(vc, committing, 0);
 977                         committing = 0;
 978                 }
 979                 pressed &= ~(1 << (value - 1));
 980         }
 981 }
 982
 983 #if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
 984
 985 struct kbd_led_trigger {
 986         struct led_trigger trigger;
 987         unsigned int mask;
 988 };
 989
 990 static int kbd_led_trigger_activate(struct led_classdev *cdev)
 991 {
 992         struct kbd_led_trigger *trigger =
 993                 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
 994
 995         tasklet_disable(&keyboard_tasklet);
 996         if (ledstate != -1U)
 997                 led_trigger_event(&trigger->trigger,
 998                                   ledstate & trigger->mask ?
 999                                         LED_FULL : LED_OFF);
1000         tasklet_enable(&keyboard_tasklet);
1001
1002         return 0;
1003 }
1004
1005 #define KBD_LED_TRIGGER(_led_bit, _name) {                      \
1006                 .trigger = {                                    \
1007                         .name = _name,                          \
1008                         .activate = kbd_led_trigger_activate,   \
1009                 },                                              \
1010                 .mask   = BIT(_led_bit),                        \
1011         }
1012
1013 #define KBD_LOCKSTATE_TRIGGER(_led_bit, _name)          \
1014         KBD_LED_TRIGGER((_led_bit) + 8, _name)
1015
1016 static struct kbd_led_trigger kbd_led_triggers[] = {
1017         KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
1018         KBD_LED_TRIGGER(VC_NUMLOCK,   "kbd-numlock"),
1019         KBD_LED_TRIGGER(VC_CAPSLOCK,  "kbd-capslock"),
1020         KBD_LED_TRIGGER(VC_KANALOCK,  "kbd-kanalock"),
1021
1022         KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK,  "kbd-shiftlock"),
1023         KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK,  "kbd-altgrlock"),
1024         KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK,   "kbd-ctrllock"),
1025         KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK,    "kbd-altlock"),
1026         KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1027         KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1028         KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK,  "kbd-ctrlllock"),
1029         KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK,  "kbd-ctrlrlock"),
1030 };
1031
1032 static void kbd_propagate_led_state(unsigned int old_state,
1033                                     unsigned int new_state)
1034 {
1035         struct kbd_led_trigger *trigger;
1036         unsigned int changed = old_state ^ new_state;
1037         int i;
1038
1039         for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1040                 trigger = &kbd_led_triggers[i];
1041
1042                 if (changed & trigger->mask)
1043                         led_trigger_event(&trigger->trigger,
1044                                           new_state & trigger->mask ?
1045                                                 LED_FULL : LED_OFF);
1046         }
1047 }
1048
1049 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1050 {
1051         unsigned int led_state = *(unsigned int *)data;
1052
1053         if (test_bit(EV_LED, handle->dev->evbit))
1054                 kbd_propagate_led_state(~led_state, led_state);
1055
1056         return 0;
1057 }
1058
1059 static void kbd_init_leds(void)
1060 {
1061         int error;
1062         int i;
1063
1064         for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1065                 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1066                 if (error)
1067                         pr_err("error %d while registering trigger %s\n",
1068                                error, kbd_led_triggers[i].trigger.name);
1069         }
1070 }
1071
1072 #else
1073
1074 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1075 {
1076         unsigned int leds = *(unsigned int *)data;
1077
1078         if (test_bit(EV_LED, handle->dev->evbit)) {
1079                 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1080                 input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1081                 input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1082                 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1083         }
1084
1085         return 0;
1086 }
1087
1088 static void kbd_propagate_led_state(unsigned int old_state,
1089                                     unsigned int new_state)
1090 {
1091         input_handler_for_each_handle(&kbd_handler, &new_state,
1092                                       kbd_update_leds_helper);
1093 }
1094
1095 static void kbd_init_leds(void)
1096 {
1097 }
1098
1099 #endif
1100
1101 /*
1102  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1103  * or (ii) whatever pattern of lights people want to show using KDSETLED,
1104  * or (iii) specified bits of specified words in kernel memory.
1105  */
1106 static unsigned char getledstate(void)
1107 {
1108         return ledstate & 0xff;
1109 }
1110
1111 void setledstate(struct kbd_struct *kb, unsigned int led)
1112 {
1113         unsigned long flags;
1114         spin_lock_irqsave(&led_lock, flags);
1115         if (!(led & ~7)) {
1116                 ledioctl = led;
1117                 kb->ledmode = LED_SHOW_IOCTL;
1118         } else
1119                 kb->ledmode = LED_SHOW_FLAGS;
1120
1121         set_leds();
1122         spin_unlock_irqrestore(&led_lock, flags);
1123 }
1124
1125 static inline unsigned char getleds(void)
1126 {
1127         struct kbd_struct *kb = kbd_table + fg_console;
1128
1129         if (kb->ledmode == LED_SHOW_IOCTL)
1130                 return ledioctl;
1131
1132         return kb->ledflagstate;
1133 }
1134
1135 /**
1136  *      vt_get_leds     -       helper for braille console
1137  *      @console: console to read
1138  *      @flag: flag we want to check
1139  *
1140  *      Check the status of a keyboard led flag and report it back
1141  */
1142 int vt_get_leds(int console, int flag)
1143 {
1144         struct kbd_struct *kb = kbd_table + console;
1145         int ret;
1146         unsigned long flags;
1147
1148         spin_lock_irqsave(&led_lock, flags);
1149         ret = vc_kbd_led(kb, flag);
1150         spin_unlock_irqrestore(&led_lock, flags);
1151
1152         return ret;
1153 }
1154 EXPORT_SYMBOL_GPL(vt_get_leds);
1155
1156 /**
1157  *      vt_set_led_state        -       set LED state of a console
1158  *      @console: console to set
1159  *      @leds: LED bits
1160  *
1161  *      Set the LEDs on a console. This is a wrapper for the VT layer
1162  *      so that we can keep kbd knowledge internal
1163  */
1164 void vt_set_led_state(int console, int leds)
1165 {
1166         struct kbd_struct *kb = kbd_table + console;
1167         setledstate(kb, leds);
1168 }
1169
1170 /**
1171  *      vt_kbd_con_start        -       Keyboard side of console start
1172  *      @console: console
1173  *
1174  *      Handle console start. This is a wrapper for the VT layer
1175  *      so that we can keep kbd knowledge internal
1176  *
1177  *      FIXME: We eventually need to hold the kbd lock here to protect
1178  *      the LED updating. We can't do it yet because fn_hold calls stop_tty
1179  *      and start_tty under the kbd_event_lock, while normal tty paths
1180  *      don't hold the lock. We probably need to split out an LED lock
1181  *      but not during an -rc release!
1182  */
1183 void vt_kbd_con_start(int console)
1184 {
1185         struct kbd_struct *kb = kbd_table + console;
1186         unsigned long flags;
1187         spin_lock_irqsave(&led_lock, flags);
1188         clr_vc_kbd_led(kb, VC_SCROLLOCK);
1189         set_leds();
1190         spin_unlock_irqrestore(&led_lock, flags);
1191 }
1192
1193 /**
1194  *      vt_kbd_con_stop         -       Keyboard side of console stop
1195  *      @console: console
1196  *
1197  *      Handle console stop. This is a wrapper for the VT layer
1198  *      so that we can keep kbd knowledge internal
1199  */
1200 void vt_kbd_con_stop(int console)
1201 {
1202         struct kbd_struct *kb = kbd_table + console;
1203         unsigned long flags;
1204         spin_lock_irqsave(&led_lock, flags);
1205         set_vc_kbd_led(kb, VC_SCROLLOCK);
1206         set_leds();
1207         spin_unlock_irqrestore(&led_lock, flags);
1208 }
1209
1210 /*
1211  * This is the tasklet that updates LED state of LEDs using standard
1212  * keyboard triggers. The reason we use tasklet is that we need to
1213  * handle the scenario when keyboard handler is not registered yet
1214  * but we already getting updates from the VT to update led state.
1215  */
1216 static void kbd_bh(unsigned long dummy)
1217 {
1218         unsigned int leds;
1219         unsigned long flags;
1220
1221         spin_lock_irqsave(&led_lock, flags);
1222         leds = getleds();
1223         leds |= (unsigned int)kbd->lockstate << 8;
1224         spin_unlock_irqrestore(&led_lock, flags);
1225
1226         if (leds != ledstate) {
1227                 kbd_propagate_led_state(ledstate, leds);
1228                 ledstate = leds;
1229         }
1230 }
1231
1232 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1233
1234 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1235     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1236     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1237     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1238
1239 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1240                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1241
1242 static const unsigned short x86_keycodes[256] =
1243         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1244          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1245          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1246          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1247          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1248          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1249         284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1250         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1251         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1252         103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1253         291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1254         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1255         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1256         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1257         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1258
1259 #ifdef CONFIG_SPARC
1260 static int sparc_l1_a_state;
1261 extern void sun_do_break(void);
1262 #endif
1263
1264 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1265                        unsigned char up_flag)
1266 {
1267         int code;
1268
1269         switch (keycode) {
1270
1271         case KEY_PAUSE:
1272                 put_queue(vc, 0xe1);
1273                 put_queue(vc, 0x1d | up_flag);
1274                 put_queue(vc, 0x45 | up_flag);
1275                 break;
1276
1277         case KEY_HANGEUL:
1278                 if (!up_flag)
1279                         put_queue(vc, 0xf2);
1280                 break;
1281
1282         case KEY_HANJA:
1283                 if (!up_flag)
1284                         put_queue(vc, 0xf1);
1285                 break;
1286
1287         case KEY_SYSRQ:
1288                 /*
1289                  * Real AT keyboards (that's what we're trying
1290                  * to emulate here) emit 0xe0 0x2a 0xe0 0x37 when
1291                  * pressing PrtSc/SysRq alone, but simply 0x54
1292                  * when pressing Alt+PrtSc/SysRq.
1293                  */
1294                 if (test_bit(KEY_LEFTALT, key_down) ||
1295                     test_bit(KEY_RIGHTALT, key_down)) {
1296                         put_queue(vc, 0x54 | up_flag);
1297                 } else {
1298                         put_queue(vc, 0xe0);
1299                         put_queue(vc, 0x2a | up_flag);
1300                         put_queue(vc, 0xe0);
1301                         put_queue(vc, 0x37 | up_flag);
1302                 }
1303                 break;
1304
1305         default:
1306                 if (keycode > 255)
1307                         return -1;
1308
1309                 code = x86_keycodes[keycode];
1310                 if (!code)
1311                         return -1;
1312
1313                 if (code & 0x100)
1314                         put_queue(vc, 0xe0);
1315                 put_queue(vc, (code & 0x7f) | up_flag);
1316
1317                 break;
1318         }
1319
1320         return 0;
1321 }
1322
1323 #else
1324
1325 #define HW_RAW(dev)     0
1326
1327 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1328 {
1329         if (keycode > 127)
1330                 return -1;
1331
1332         put_queue(vc, keycode | up_flag);
1333         return 0;
1334 }
1335 #endif
1336
1337 static void kbd_rawcode(unsigned char data)
1338 {
1339         struct vc_data *vc = vc_cons[fg_console].d;
1340
1341         kbd = kbd_table + vc->vc_num;
1342         if (kbd->kbdmode == VC_RAW)
1343                 put_queue(vc, data);
1344 }
1345
1346 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1347 {
1348         struct vc_data *vc = vc_cons[fg_console].d;
1349         unsigned short keysym, *key_map;
1350         unsigned char type;
1351         bool raw_mode;
1352         struct tty_struct *tty;
1353         int shift_final;
1354         struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1355         int rc;
1356
1357         tty = vc->port.tty;
1358
1359         if (tty && (!tty->driver_data)) {
1360                 /* No driver data? Strange. Okay we fix it then. */
1361                 tty->driver_data = vc;
1362         }
1363
1364         kbd = kbd_table + vc->vc_num;
1365
1366 #ifdef CONFIG_SPARC
1367         if (keycode == KEY_STOP)
1368                 sparc_l1_a_state = down;
1369 #endif
1370
1371         rep = (down == 2);
1372
1373         raw_mode = (kbd->kbdmode == VC_RAW);
1374         if (raw_mode && !hw_raw)
1375                 if (emulate_raw(vc, keycode, !down << 7))
1376                         if (keycode < BTN_MISC && printk_ratelimit())
1377                                 pr_warn("can't emulate rawmode for keycode %d\n",
1378                                         keycode);
1379
1380 #ifdef CONFIG_SPARC
1381         if (keycode == KEY_A && sparc_l1_a_state) {
1382                 sparc_l1_a_state = false;
1383                 sun_do_break();
1384         }
1385 #endif
1386
1387         if (kbd->kbdmode == VC_MEDIUMRAW) {
1388                 /*
1389                  * This is extended medium raw mode, with keys above 127
1390                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1391                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1392                  * interfere with anything else. The two bytes after 0 will
1393                  * always have the up flag set not to interfere with older
1394                  * applications. This allows for 16384 different keycodes,
1395                  * which should be enough.
1396                  */
1397                 if (keycode < 128) {
1398                         put_queue(vc, keycode | (!down << 7));
1399                 } else {
1400                         put_queue(vc, !down << 7);
1401                         put_queue(vc, (keycode >> 7) | 0x80);
1402                         put_queue(vc, keycode | 0x80);
1403                 }
1404                 raw_mode = true;
1405         }
1406
1407         if (down)
1408                 set_bit(keycode, key_down);
1409         else
1410                 clear_bit(keycode, key_down);
1411
1412         if (rep &&
1413             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1414              (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1415                 /*
1416                  * Don't repeat a key if the input buffers are not empty and the
1417                  * characters get aren't echoed locally. This makes key repeat
1418                  * usable with slow applications and under heavy loads.
1419                  */
1420                 return;
1421         }
1422
1423         param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1424         param.ledstate = kbd->ledflagstate;
1425         key_map = key_maps[shift_final];
1426
1427         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1428                                         KBD_KEYCODE, &param);
1429         if (rc == NOTIFY_STOP || !key_map) {
1430                 atomic_notifier_call_chain(&keyboard_notifier_list,
1431                                            KBD_UNBOUND_KEYCODE, &param);
1432                 do_compute_shiftstate();
1433                 kbd->slockstate = 0;
1434                 return;
1435         }
1436
1437         if (keycode < NR_KEYS)
1438                 keysym = key_map[keycode];
1439         else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1440                 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1441         else
1442                 return;
1443
1444         type = KTYP(keysym);
1445
1446         if (type < 0xf0) {
1447                 param.value = keysym;
1448                 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1449                                                 KBD_UNICODE, &param);
1450                 if (rc != NOTIFY_STOP)
1451                         if (down && !raw_mode)
1452                                 to_utf8(vc, keysym);
1453                 return;
1454         }
1455
1456         type -= 0xf0;
1457
1458         if (type == KT_LETTER) {
1459                 type = KT_LATIN;
1460                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1461                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1462                         if (key_map)
1463                                 keysym = key_map[keycode];
1464                 }
1465         }
1466
1467         param.value = keysym;
1468         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1469                                         KBD_KEYSYM, &param);
1470         if (rc == NOTIFY_STOP)
1471                 return;
1472
1473         if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1474                 return;
1475
1476         (*k_handler[type])(vc, keysym & 0xff, !down);
1477
1478         param.ledstate = kbd->ledflagstate;
1479         atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1480
1481         if (type != KT_SLOCK)
1482                 kbd->slockstate = 0;
1483 }
1484
1485 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1486                       unsigned int event_code, int value)
1487 {
1488         /* We are called with interrupts disabled, just take the lock */
1489         spin_lock(&kbd_event_lock);
1490
1491         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1492                 kbd_rawcode(value);
1493         if (event_type == EV_KEY)
1494                 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1495
1496         spin_unlock(&kbd_event_lock);
1497
1498         tasklet_schedule(&keyboard_tasklet);
1499         do_poke_blanked_console = 1;
1500         schedule_console_callback();
1501 }
1502
1503 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1504 {
1505         int i;
1506
1507         if (test_bit(EV_SND, dev->evbit))
1508                 return true;
1509
1510         if (test_bit(EV_KEY, dev->evbit)) {
1511                 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1512                         if (test_bit(i, dev->keybit))
1513                                 return true;
1514                 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1515                         if (test_bit(i, dev->keybit))
1516                                 return true;
1517         }
1518
1519         return false;
1520 }
1521
1522 /*
1523  * When a keyboard (or other input device) is found, the kbd_connect
1524  * function is called. The function then looks at the device, and if it
1525  * likes it, it can open it and get events from it. In this (kbd_connect)
1526  * function, we should decide which VT to bind that keyboard to initially.
1527  */
1528 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1529                         const struct input_device_id *id)
1530 {
1531         struct input_handle *handle;
1532         int error;
1533
1534         handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1535         if (!handle)
1536                 return -ENOMEM;
1537
1538         handle->dev = dev;
1539         handle->handler = handler;
1540         handle->name = "kbd";
1541
1542         error = input_register_handle(handle);
1543         if (error)
1544                 goto err_free_handle;
1545
1546         error = input_open_device(handle);
1547         if (error)
1548                 goto err_unregister_handle;
1549
1550         return 0;
1551
1552  err_unregister_handle:
1553         input_unregister_handle(handle);
1554  err_free_handle:
1555         kfree(handle);
1556         return error;
1557 }
1558
1559 static void kbd_disconnect(struct input_handle *handle)
1560 {
1561         input_close_device(handle);
1562         input_unregister_handle(handle);
1563         kfree(handle);
1564 }
1565
1566 /*
1567  * Start keyboard handler on the new keyboard by refreshing LED state to
1568  * match the rest of the system.
1569  */
1570 static void kbd_start(struct input_handle *handle)
1571 {
1572         tasklet_disable(&keyboard_tasklet);
1573
1574         if (ledstate != -1U)
1575                 kbd_update_leds_helper(handle, &ledstate);
1576
1577         tasklet_enable(&keyboard_tasklet);
1578 }
1579
1580 static const struct input_device_id kbd_ids[] = {
1581         {
1582                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1583                 .evbit = { BIT_MASK(EV_KEY) },
1584         },
1585
1586         {
1587                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1588                 .evbit = { BIT_MASK(EV_SND) },
1589         },
1590
1591         { },    /* Terminating entry */
1592 };
1593
1594 MODULE_DEVICE_TABLE(input, kbd_ids);
1595
1596 static struct input_handler kbd_handler = {
1597         .event          = kbd_event,
1598         .match          = kbd_match,
1599         .connect        = kbd_connect,
1600         .disconnect     = kbd_disconnect,
1601         .start          = kbd_start,
1602         .name           = "kbd",
1603         .id_table       = kbd_ids,
1604 };
1605
1606 int __init kbd_init(void)
1607 {
1608         int i;
1609         int error;
1610
1611         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1612                 kbd_table[i].ledflagstate = kbd_defleds();
1613                 kbd_table[i].default_ledflagstate = kbd_defleds();
1614                 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1615                 kbd_table[i].lockstate = KBD_DEFLOCK;
1616                 kbd_table[i].slockstate = 0;
1617                 kbd_table[i].modeflags = KBD_DEFMODE;
1618                 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1619         }
1620
1621         kbd_init_leds();
1622
1623         error = input_register_handler(&kbd_handler);
1624         if (error)
1625                 return error;
1626
1627         tasklet_enable(&keyboard_tasklet);
1628         tasklet_schedule(&keyboard_tasklet);
1629
1630         return 0;
1631 }
1632
1633 /* Ioctl support code */
1634
1635 /**
1636  *      vt_do_diacrit           -       diacritical table updates
1637  *      @cmd: ioctl request
1638  *      @udp: pointer to user data for ioctl
1639  *      @perm: permissions check computed by caller
1640  *
1641  *      Update the diacritical tables atomically and safely. Lock them
1642  *      against simultaneous keypresses
1643  */
1644 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1645 {
1646         unsigned long flags;
1647         int asize;
1648         int ret = 0;
1649
1650         switch (cmd) {
1651         case KDGKBDIACR:
1652         {
1653                 struct kbdiacrs __user *a = udp;
1654                 struct kbdiacr *dia;
1655                 int i;
1656
1657                 dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr),
1658                                                                 GFP_KERNEL);
1659                 if (!dia)
1660                         return -ENOMEM;
1661
1662                 /* Lock the diacriticals table, make a copy and then
1663                    copy it after we unlock */
1664                 spin_lock_irqsave(&kbd_event_lock, flags);
1665
1666                 asize = accent_table_size;
1667                 for (i = 0; i < asize; i++) {
1668                         dia[i].diacr = conv_uni_to_8bit(
1669                                                 accent_table[i].diacr);
1670                         dia[i].base = conv_uni_to_8bit(
1671                                                 accent_table[i].base);
1672                         dia[i].result = conv_uni_to_8bit(
1673                                                 accent_table[i].result);
1674                 }
1675                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1676
1677                 if (put_user(asize, &a->kb_cnt))
1678                         ret = -EFAULT;
1679                 else  if (copy_to_user(a->kbdiacr, dia,
1680                                 asize * sizeof(struct kbdiacr)))
1681                         ret = -EFAULT;
1682                 kfree(dia);
1683                 return ret;
1684         }
1685         case KDGKBDIACRUC:
1686         {
1687                 struct kbdiacrsuc __user *a = udp;
1688                 void *buf;
1689
1690                 buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc),
1691                                                                 GFP_KERNEL);
1692                 if (buf == NULL)
1693                         return -ENOMEM;
1694
1695                 /* Lock the diacriticals table, make a copy and then
1696                    copy it after we unlock */
1697                 spin_lock_irqsave(&kbd_event_lock, flags);
1698
1699                 asize = accent_table_size;
1700                 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1701
1702                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1703
1704                 if (put_user(asize, &a->kb_cnt))
1705                         ret = -EFAULT;
1706                 else if (copy_to_user(a->kbdiacruc, buf,
1707                                 asize*sizeof(struct kbdiacruc)))
1708                         ret = -EFAULT;
1709                 kfree(buf);
1710                 return ret;
1711         }
1712
1713         case KDSKBDIACR:
1714         {
1715                 struct kbdiacrs __user *a = udp;
1716                 struct kbdiacr *dia = NULL;
1717                 unsigned int ct;
1718                 int i;
1719
1720                 if (!perm)
1721                         return -EPERM;
1722                 if (get_user(ct, &a->kb_cnt))
1723                         return -EFAULT;
1724                 if (ct >= MAX_DIACR)
1725                         return -EINVAL;
1726
1727                 if (ct) {
1728
1729                         dia = memdup_user(a->kbdiacr,
1730                                         sizeof(struct kbdiacr) * ct);
1731                         if (IS_ERR(dia))
1732                                 return PTR_ERR(dia);
1733
1734                 }
1735
1736                 spin_lock_irqsave(&kbd_event_lock, flags);
1737                 accent_table_size = ct;
1738                 for (i = 0; i < ct; i++) {
1739                         accent_table[i].diacr =
1740                                         conv_8bit_to_uni(dia[i].diacr);
1741                         accent_table[i].base =
1742                                         conv_8bit_to_uni(dia[i].base);
1743                         accent_table[i].result =
1744                                         conv_8bit_to_uni(dia[i].result);
1745                 }
1746                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1747                 kfree(dia);
1748                 return 0;
1749         }
1750
1751         case KDSKBDIACRUC:
1752         {
1753                 struct kbdiacrsuc __user *a = udp;
1754                 unsigned int ct;
1755                 void *buf = NULL;
1756
1757                 if (!perm)
1758                         return -EPERM;
1759
1760                 if (get_user(ct, &a->kb_cnt))
1761                         return -EFAULT;
1762
1763                 if (ct >= MAX_DIACR)
1764                         return -EINVAL;
1765
1766                 if (ct) {
1767                         buf = memdup_user(a->kbdiacruc,
1768                                           ct * sizeof(struct kbdiacruc));
1769                         if (IS_ERR(buf))
1770                                 return PTR_ERR(buf);
1771                 }
1772                 spin_lock_irqsave(&kbd_event_lock, flags);
1773                 if (ct)
1774                         memcpy(accent_table, buf,
1775                                         ct * sizeof(struct kbdiacruc));
1776                 accent_table_size = ct;
1777                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1778                 kfree(buf);
1779                 return 0;
1780         }
1781         }
1782         return ret;
1783 }
1784
1785 /**
1786  *      vt_do_kdskbmode         -       set keyboard mode ioctl
1787  *      @console: the console to use
1788  *      @arg: the requested mode
1789  *
1790  *      Update the keyboard mode bits while holding the correct locks.
1791  *      Return 0 for success or an error code.
1792  */
1793 int vt_do_kdskbmode(int console, unsigned int arg)
1794 {
1795         struct kbd_struct *kb = kbd_table + console;
1796         int ret = 0;
1797         unsigned long flags;
1798
1799         spin_lock_irqsave(&kbd_event_lock, flags);
1800         switch(arg) {
1801         case K_RAW:
1802                 kb->kbdmode = VC_RAW;
1803                 break;
1804         case K_MEDIUMRAW:
1805                 kb->kbdmode = VC_MEDIUMRAW;
1806                 break;
1807         case K_XLATE:
1808                 kb->kbdmode = VC_XLATE;
1809                 do_compute_shiftstate();
1810                 break;
1811         case K_UNICODE:
1812                 kb->kbdmode = VC_UNICODE;
1813                 do_compute_shiftstate();
1814                 break;
1815         case K_OFF:
1816                 kb->kbdmode = VC_OFF;
1817                 break;
1818         default:
1819                 ret = -EINVAL;
1820         }
1821         spin_unlock_irqrestore(&kbd_event_lock, flags);
1822         return ret;
1823 }
1824
1825 /**
1826  *      vt_do_kdskbmeta         -       set keyboard meta state
1827  *      @console: the console to use
1828  *      @arg: the requested meta state
1829  *
1830  *      Update the keyboard meta bits while holding the correct locks.
1831  *      Return 0 for success or an error code.
1832  */
1833 int vt_do_kdskbmeta(int console, unsigned int arg)
1834 {
1835         struct kbd_struct *kb = kbd_table + console;
1836         int ret = 0;
1837         unsigned long flags;
1838
1839         spin_lock_irqsave(&kbd_event_lock, flags);
1840         switch(arg) {
1841         case K_METABIT:
1842                 clr_vc_kbd_mode(kb, VC_META);
1843                 break;
1844         case K_ESCPREFIX:
1845                 set_vc_kbd_mode(kb, VC_META);
1846                 break;
1847         default:
1848                 ret = -EINVAL;
1849         }
1850         spin_unlock_irqrestore(&kbd_event_lock, flags);
1851         return ret;
1852 }
1853
1854 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1855                                                                 int perm)
1856 {
1857         struct kbkeycode tmp;
1858         int kc = 0;
1859
1860         if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1861                 return -EFAULT;
1862         switch (cmd) {
1863         case KDGETKEYCODE:
1864                 kc = getkeycode(tmp.scancode);
1865                 if (kc >= 0)
1866                         kc = put_user(kc, &user_kbkc->keycode);
1867                 break;
1868         case KDSETKEYCODE:
1869                 if (!perm)
1870                         return -EPERM;
1871                 kc = setkeycode(tmp.scancode, tmp.keycode);
1872                 break;
1873         }
1874         return kc;
1875 }
1876
1877 #define i (tmp.kb_index)
1878 #define s (tmp.kb_table)
1879 #define v (tmp.kb_value)
1880
1881 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1882                                                 int console)
1883 {
1884         struct kbd_struct *kb = kbd_table + console;
1885         struct kbentry tmp;
1886         ushort *key_map, *new_map, val, ov;
1887         unsigned long flags;
1888
1889         if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1890                 return -EFAULT;
1891
1892         if (!capable(CAP_SYS_TTY_CONFIG))
1893                 perm = 0;
1894
1895         switch (cmd) {
1896         case KDGKBENT:
1897                 /* Ensure another thread doesn't free it under us */
1898                 spin_lock_irqsave(&kbd_event_lock, flags);
1899                 key_map = key_maps[s];
1900                 if (key_map) {
1901                     val = U(key_map[i]);
1902                     if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1903                         val = K_HOLE;
1904                 } else
1905                     val = (i ? K_HOLE : K_NOSUCHMAP);
1906                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1907                 return put_user(val, &user_kbe->kb_value);
1908         case KDSKBENT:
1909                 if (!perm)
1910                         return -EPERM;
1911                 if (!i && v == K_NOSUCHMAP) {
1912                         spin_lock_irqsave(&kbd_event_lock, flags);
1913                         /* deallocate map */
1914                         key_map = key_maps[s];
1915                         if (s && key_map) {
1916                             key_maps[s] = NULL;
1917                             if (key_map[0] == U(K_ALLOCATED)) {
1918                                         kfree(key_map);
1919                                         keymap_count--;
1920                             }
1921                         }
1922                         spin_unlock_irqrestore(&kbd_event_lock, flags);
1923                         break;
1924                 }
1925
1926                 if (KTYP(v) < NR_TYPES) {
1927                     if (KVAL(v) > max_vals[KTYP(v)])
1928                                 return -EINVAL;
1929                 } else
1930                     if (kb->kbdmode != VC_UNICODE)
1931                                 return -EINVAL;
1932
1933                 /* ++Geert: non-PC keyboards may generate keycode zero */
1934 #if !defined(__mc68000__) && !defined(__powerpc__)
1935                 /* assignment to entry 0 only tests validity of args */
1936                 if (!i)
1937                         break;
1938 #endif
1939
1940                 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1941                 if (!new_map)
1942                         return -ENOMEM;
1943                 spin_lock_irqsave(&kbd_event_lock, flags);
1944                 key_map = key_maps[s];
1945                 if (key_map == NULL) {
1946                         int j;
1947
1948                         if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1949                             !capable(CAP_SYS_RESOURCE)) {
1950                                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1951                                 kfree(new_map);
1952                                 return -EPERM;
1953                         }
1954                         key_maps[s] = new_map;
1955                         key_map = new_map;
1956                         key_map[0] = U(K_ALLOCATED);
1957                         for (j = 1; j < NR_KEYS; j++)
1958                                 key_map[j] = U(K_HOLE);
1959                         keymap_count++;
1960                 } else
1961                         kfree(new_map);
1962
1963                 ov = U(key_map[i]);
1964                 if (v == ov)
1965                         goto out;
1966                 /*
1967                  * Attention Key.
1968                  */
1969                 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1970                         spin_unlock_irqrestore(&kbd_event_lock, flags);
1971                         return -EPERM;
1972                 }
1973                 key_map[i] = U(v);
1974                 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1975                         do_compute_shiftstate();
1976 out:
1977                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1978                 break;
1979         }
1980         return 0;
1981 }
1982 #undef i
1983 #undef s
1984 #undef v
1985
1986 /* FIXME: This one needs untangling and locking */
1987 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1988 {
1989         struct kbsentry *kbs;
1990         char *p;
1991         u_char *q;
1992         u_char __user *up;
1993         int sz;
1994         int delta;
1995         char *first_free, *fj, *fnw;
1996         int i, j, k;
1997         int ret;
1998
1999         if (!capable(CAP_SYS_TTY_CONFIG))
2000                 perm = 0;
2001
2002         kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
2003         if (!kbs) {
2004                 ret = -ENOMEM;
2005                 goto reterr;
2006         }
2007
2008         /* we mostly copy too much here (512bytes), but who cares ;) */
2009         if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
2010                 ret = -EFAULT;
2011                 goto reterr;
2012         }
2013         kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
2014         i = kbs->kb_func;
2015
2016         switch (cmd) {
2017         case KDGKBSENT:
2018                 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
2019                                                   a struct member */
2020                 up = user_kdgkb->kb_string;
2021                 p = func_table[i];
2022                 if(p)
2023                         for ( ; *p && sz; p++, sz--)
2024                                 if (put_user(*p, up++)) {
2025                                         ret = -EFAULT;
2026                                         goto reterr;
2027                                 }
2028                 if (put_user('\0', up)) {
2029                         ret = -EFAULT;
2030                         goto reterr;
2031                 }
2032                 kfree(kbs);
2033                 return ((p && *p) ? -EOVERFLOW : 0);
2034         case KDSKBSENT:
2035                 if (!perm) {
2036                         ret = -EPERM;
2037                         goto reterr;
2038                 }
2039
2040                 q = func_table[i];
2041                 first_free = funcbufptr + (funcbufsize - funcbufleft);
2042                 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2043                         ;
2044                 if (j < MAX_NR_FUNC)
2045                         fj = func_table[j];
2046                 else
2047                         fj = first_free;
2048
2049                 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2050                 if (delta <= funcbufleft) {     /* it fits in current buf */
2051                     if (j < MAX_NR_FUNC) {
2052                         memmove(fj + delta, fj, first_free - fj);
2053                         for (k = j; k < MAX_NR_FUNC; k++)
2054                             if (func_table[k])
2055                                 func_table[k] += delta;
2056                     }
2057                     if (!q)
2058                       func_table[i] = fj;
2059                     funcbufleft -= delta;
2060                 } else {                        /* allocate a larger buffer */
2061                     sz = 256;
2062                     while (sz < funcbufsize - funcbufleft + delta)
2063                       sz <<= 1;
2064                     fnw = kmalloc(sz, GFP_KERNEL);
2065                     if(!fnw) {
2066                       ret = -ENOMEM;
2067                       goto reterr;
2068                     }
2069
2070                     if (!q)
2071                       func_table[i] = fj;
2072                     if (fj > funcbufptr)
2073                         memmove(fnw, funcbufptr, fj - funcbufptr);
2074                     for (k = 0; k < j; k++)
2075                       if (func_table[k])
2076                         func_table[k] = fnw + (func_table[k] - funcbufptr);
2077
2078                     if (first_free > fj) {
2079                         memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2080                         for (k = j; k < MAX_NR_FUNC; k++)
2081                           if (func_table[k])
2082                             func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2083                     }
2084                     if (funcbufptr != func_buf)
2085                       kfree(funcbufptr);
2086                     funcbufptr = fnw;
2087                     funcbufleft = funcbufleft - delta + sz - funcbufsize;
2088                     funcbufsize = sz;
2089                 }
2090                 strcpy(func_table[i], kbs->kb_string);
2091                 break;
2092         }
2093         ret = 0;
2094 reterr:
2095         kfree(kbs);
2096         return ret;
2097 }
2098
2099 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2100 {
2101         struct kbd_struct *kb = kbd_table + console;
2102         unsigned long flags;
2103         unsigned char ucval;
2104
2105         switch(cmd) {
2106         /* the ioctls below read/set the flags usually shown in the leds */
2107         /* don't use them - they will go away without warning */
2108         case KDGKBLED:
2109                 spin_lock_irqsave(&kbd_event_lock, flags);
2110                 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2111                 spin_unlock_irqrestore(&kbd_event_lock, flags);
2112                 return put_user(ucval, (char __user *)arg);
2113
2114         case KDSKBLED:
2115                 if (!perm)
2116                         return -EPERM;
2117                 if (arg & ~0x77)
2118                         return -EINVAL;
2119                 spin_lock_irqsave(&led_lock, flags);
2120                 kb->ledflagstate = (arg & 7);
2121                 kb->default_ledflagstate = ((arg >> 4) & 7);
2122                 set_leds();
2123                 spin_unlock_irqrestore(&led_lock, flags);
2124                 return 0;
2125
2126         /* the ioctls below only set the lights, not the functions */
2127         /* for those, see KDGKBLED and KDSKBLED above */
2128         case KDGETLED:
2129                 ucval = getledstate();
2130                 return put_user(ucval, (char __user *)arg);
2131
2132         case KDSETLED:
2133                 if (!perm)
2134                         return -EPERM;
2135                 setledstate(kb, arg);
2136                 return 0;
2137         }
2138         return -ENOIOCTLCMD;
2139 }
2140
2141 int vt_do_kdgkbmode(int console)
2142 {
2143         struct kbd_struct *kb = kbd_table + console;
2144         /* This is a spot read so needs no locking */
2145         switch (kb->kbdmode) {
2146         case VC_RAW:
2147                 return K_RAW;
2148         case VC_MEDIUMRAW:
2149                 return K_MEDIUMRAW;
2150         case VC_UNICODE:
2151                 return K_UNICODE;
2152         case VC_OFF:
2153                 return K_OFF;
2154         default:
2155                 return K_XLATE;
2156         }
2157 }
2158
2159 /**
2160  *      vt_do_kdgkbmeta         -       report meta status
2161  *      @console: console to report
2162  *
2163  *      Report the meta flag status of this console
2164  */
2165 int vt_do_kdgkbmeta(int console)
2166 {
2167         struct kbd_struct *kb = kbd_table + console;
2168         /* Again a spot read so no locking */
2169         return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2170 }
2171
2172 /**
2173  *      vt_reset_unicode        -       reset the unicode status
2174  *      @console: console being reset
2175  *
2176  *      Restore the unicode console state to its default
2177  */
2178 void vt_reset_unicode(int console)
2179 {
2180         unsigned long flags;
2181
2182         spin_lock_irqsave(&kbd_event_lock, flags);
2183         kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2184         spin_unlock_irqrestore(&kbd_event_lock, flags);
2185 }
2186
2187 /**
2188  *      vt_get_shiftstate       -       shift bit state
2189  *
2190  *      Report the shift bits from the keyboard state. We have to export
2191  *      this to support some oddities in the vt layer.
2192  */
2193 int vt_get_shift_state(void)
2194 {
2195         /* Don't lock as this is a transient report */
2196         return shift_state;
2197 }
2198
2199 /**
2200  *      vt_reset_keyboard       -       reset keyboard state
2201  *      @console: console to reset
2202  *
2203  *      Reset the keyboard bits for a console as part of a general console
2204  *      reset event
2205  */
2206 void vt_reset_keyboard(int console)
2207 {
2208         struct kbd_struct *kb = kbd_table + console;
2209         unsigned long flags;
2210
2211         spin_lock_irqsave(&kbd_event_lock, flags);
2212         set_vc_kbd_mode(kb, VC_REPEAT);
2213         clr_vc_kbd_mode(kb, VC_CKMODE);
2214         clr_vc_kbd_mode(kb, VC_APPLIC);
2215         clr_vc_kbd_mode(kb, VC_CRLF);
2216         kb->lockstate = 0;
2217         kb->slockstate = 0;
2218         spin_lock(&led_lock);
2219         kb->ledmode = LED_SHOW_FLAGS;
2220         kb->ledflagstate = kb->default_ledflagstate;
2221         spin_unlock(&led_lock);
2222         /* do not do set_leds here because this causes an endless tasklet loop
2223            when the keyboard hasn't been initialized yet */
2224         spin_unlock_irqrestore(&kbd_event_lock, flags);
2225 }
2226
2227 /**
2228  *      vt_get_kbd_mode_bit     -       read keyboard status bits
2229  *      @console: console to read from
2230  *      @bit: mode bit to read
2231  *
2232  *      Report back a vt mode bit. We do this without locking so the
2233  *      caller must be sure that there are no synchronization needs
2234  */
2235
2236 int vt_get_kbd_mode_bit(int console, int bit)
2237 {
2238         struct kbd_struct *kb = kbd_table + console;
2239         return vc_kbd_mode(kb, bit);
2240 }
2241
2242 /**
2243  *      vt_set_kbd_mode_bit     -       read keyboard status bits
2244  *      @console: console to read from
2245  *      @bit: mode bit to read
2246  *
2247  *      Set a vt mode bit. We do this without locking so the
2248  *      caller must be sure that there are no synchronization needs
2249  */
2250
2251 void vt_set_kbd_mode_bit(int console, int bit)
2252 {
2253         struct kbd_struct *kb = kbd_table + console;
2254         unsigned long flags;
2255
2256         spin_lock_irqsave(&kbd_event_lock, flags);
2257         set_vc_kbd_mode(kb, bit);
2258         spin_unlock_irqrestore(&kbd_event_lock, flags);
2259 }
2260
2261 /**
2262  *      vt_clr_kbd_mode_bit     -       read keyboard status bits
2263  *      @console: console to read from
2264  *      @bit: mode bit to read
2265  *
2266  *      Report back a vt mode bit. We do this without locking so the
2267  *      caller must be sure that there are no synchronization needs
2268  */
2269
2270 void vt_clr_kbd_mode_bit(int console, int bit)
2271 {
2272         struct kbd_struct *kb = kbd_table + console;
2273         unsigned long flags;
2274
2275         spin_lock_irqsave(&kbd_event_lock, flags);
2276         clr_vc_kbd_mode(kb, bit);
2277         spin_unlock_irqrestore(&kbd_event_lock, flags);
2278 }