drivers/tty/vt/keyboard.c

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