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