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