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