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