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