drivers/char/keyboard.c

   1 /*
   2  * linux/drivers/char/keyboard.c
   3  *
   4  * Written for linux by Johan Myreen as a translation from
   5  * the assembly version by Linus (with diacriticals added)
   6  *
   7  * Some additional features added by Christoph Niemann (ChN), March 1993
   8  *
   9  * Loadable keymaps by Risto Kankkunen, May 1993
  10  *
  11  * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
  12  * Added decr/incr_console, dynamic keymaps, Unicode support,
  13  * dynamic function/string keys, led setting,  Sept 1994
  14  * `Sticky' modifier keys, 951006.
  15  *
  16  * 11-11-96: SAK should now work in the raw mode (Martin Mares)
  17  *
  18  * Modified to provide 'generic' keyboard support by Hamish Macdonald
  19  * Merge with the m68k keyboard driver and split-off of the PC low-level
  20  * parts by Geert Uytterhoeven, May 1997
  21  *
  22  * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
  23  * 30-07-98: Dead keys redone, aeb@cwi.nl.
  24  * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/sched.h>
  29 #include <linux/tty.h>
  30 #include <linux/tty_flip.h>
  31 #include <linux/mm.h>
  32 #include <linux/string.h>
  33 #include <linux/init.h>
  34 #include <linux/slab.h>
  35
  36 #include <linux/kbd_kern.h>
  37 #include <linux/kbd_diacr.h>
  38 #include <linux/vt_kern.h>
  39 #include <linux/sysrq.h>
  40 #include <linux/input.h>
  41 #include <linux/reboot.h>
  42
  43 static void kbd_disconnect(struct input_handle *handle);
  44 extern void ctrl_alt_del(void);
  45
  46 /*
  47  * Exported functions/variables
  48  */
  49
  50 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  51
  52 /*
  53  * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
  54  * This seems a good reason to start with NumLock off. On HIL keyboards
  55  * of PARISC machines however there is no NumLock key and everyone expects the keypad
  56  * to be used for numbers.
  57  */
  58
  59 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
  60 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
  61 #else
  62 #define KBD_DEFLEDS 0
  63 #endif
  64
  65 #define KBD_DEFLOCK 0
  66
  67 void compute_shiftstate(void);
  68
  69 /*
  70  * Handler Tables.
  71  */
  72
  73 #define K_HANDLERS\
  74         k_self,         k_fn,           k_spec,         k_pad,\
  75         k_dead,         k_cons,         k_cur,          k_shift,\
  76         k_meta,         k_ascii,        k_lock,         k_lowercase,\
  77         k_slock,        k_dead2,        k_brl,          k_ignore
  78
  79 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
  80                             char up_flag, struct pt_regs *regs);
  81 static k_handler_fn K_HANDLERS;
  82 static k_handler_fn *k_handler[16] = { K_HANDLERS };
  83
  84 #define FN_HANDLERS\
  85         fn_null,        fn_enter,       fn_show_ptregs, fn_show_mem,\
  86         fn_show_state,  fn_send_intr,   fn_lastcons,    fn_caps_toggle,\
  87         fn_num,         fn_hold,        fn_scroll_forw, fn_scroll_back,\
  88         fn_boot_it,     fn_caps_on,     fn_compose,     fn_SAK,\
  89         fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
  90
  91 typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
  92 static fn_handler_fn FN_HANDLERS;
  93 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
  94
  95 /*
  96  * Variables exported for vt_ioctl.c
  97  */
  98
  99 /* maximum values each key_handler can handle */
 100 const int max_vals[] = {
 101         255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
 102         NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
 103         255, NR_LOCK - 1, 255, NR_BRL - 1
 104 };
 105
 106 const int NR_TYPES = ARRAY_SIZE(max_vals);
 107
 108 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 109 static struct kbd_struct *kbd = kbd_table;
 110
 111 int spawnpid, spawnsig;
 112
 113 /*
 114  * Variables exported for vt.c
 115  */
 116
 117 int shift_state = 0;
 118
 119 /*
 120  * Internal Data.
 121  */
 122
 123 static struct input_handler kbd_handler;
 124 static unsigned long key_down[NBITS(KEY_MAX)];          /* keyboard key bitmap */
 125 static unsigned char shift_down[NR_SHIFT];              /* shift state counters.. */
 126 static int dead_key_next;
 127 static int npadch = -1;                                 /* -1 or number assembled on pad */
 128 static unsigned int diacr;
 129 static char rep;                                        /* flag telling character repeat */
 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 /* Simple translation table for the SysRq keys */
 141
 142 #ifdef CONFIG_MAGIC_SYSRQ
 143 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
 144         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
 145         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
 146         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
 147         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
 148         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
 149         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
 150         "\r\000/";                                      /* 0x60 - 0x6f */
 151 static int sysrq_down;
 152 static int sysrq_alt_use;
 153 #endif
 154 static int sysrq_alt;
 155
 156 /*
 157  * Translation of scancodes to keycodes. We set them on only the first attached
 158  * keyboard - for per-keyboard setting, /dev/input/event is more useful.
 159  */
 160 int getkeycode(unsigned int scancode)
 161 {
 162         struct list_head *node;
 163         struct input_dev *dev = NULL;
 164
 165         list_for_each(node, &kbd_handler.h_list) {
 166                 struct input_handle *handle = to_handle_h(node);
 167                 if (handle->dev->keycodesize) {
 168                         dev = handle->dev;
 169                         break;
 170                 }
 171         }
 172
 173         if (!dev)
 174                 return -ENODEV;
 175
 176         if (scancode >= dev->keycodemax)
 177                 return -EINVAL;
 178
 179         return INPUT_KEYCODE(dev, scancode);
 180 }
 181
 182 int setkeycode(unsigned int scancode, unsigned int keycode)
 183 {
 184         struct list_head *node;
 185         struct input_dev *dev = NULL;
 186         unsigned int i, oldkey;
 187
 188         list_for_each(node, &kbd_handler.h_list) {
 189                 struct input_handle *handle = to_handle_h(node);
 190                 if (handle->dev->keycodesize) {
 191                         dev = handle->dev;
 192                         break;
 193                 }
 194         }
 195
 196         if (!dev)
 197                 return -ENODEV;
 198
 199         if (scancode >= dev->keycodemax)
 200                 return -EINVAL;
 201         if (keycode < 0 || keycode > KEY_MAX)
 202                 return -EINVAL;
 203         if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
 204                 return -EINVAL;
 205
 206         oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
 207
 208         clear_bit(oldkey, dev->keybit);
 209         set_bit(keycode, dev->keybit);
 210
 211         for (i = 0; i < dev->keycodemax; i++)
 212                 if (INPUT_KEYCODE(dev,i) == oldkey)
 213                         set_bit(oldkey, dev->keybit);
 214
 215         return 0;
 216 }
 217
 218 /*
 219  * Making beeps and bells.
 220  */
 221 static void kd_nosound(unsigned long ignored)
 222 {
 223         struct list_head *node;
 224
 225         list_for_each(node, &kbd_handler.h_list) {
 226                 struct input_handle *handle = to_handle_h(node);
 227                 if (test_bit(EV_SND, handle->dev->evbit)) {
 228                         if (test_bit(SND_TONE, handle->dev->sndbit))
 229                                 input_inject_event(handle, EV_SND, SND_TONE, 0);
 230                         if (test_bit(SND_BELL, handle->dev->sndbit))
 231                                 input_inject_event(handle, EV_SND, SND_BELL, 0);
 232                 }
 233         }
 234 }
 235
 236 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
 237
 238 void kd_mksound(unsigned int hz, unsigned int ticks)
 239 {
 240         struct list_head *node;
 241
 242         del_timer(&kd_mksound_timer);
 243
 244         if (hz) {
 245                 list_for_each_prev(node, &kbd_handler.h_list) {
 246                         struct input_handle *handle = to_handle_h(node);
 247                         if (test_bit(EV_SND, handle->dev->evbit)) {
 248                                 if (test_bit(SND_TONE, handle->dev->sndbit)) {
 249                                         input_inject_event(handle, EV_SND, SND_TONE, hz);
 250                                         break;
 251                                 }
 252                                 if (test_bit(SND_BELL, handle->dev->sndbit)) {
 253                                         input_inject_event(handle, EV_SND, SND_BELL, 1);
 254                                         break;
 255                                 }
 256                         }
 257                 }
 258                 if (ticks)
 259                         mod_timer(&kd_mksound_timer, jiffies + ticks);
 260         } else
 261                 kd_nosound(0);
 262 }
 263
 264 /*
 265  * Setting the keyboard rate.
 266  */
 267
 268 int kbd_rate(struct kbd_repeat *rep)
 269 {
 270         struct list_head *node;
 271         unsigned int d = 0;
 272         unsigned int p = 0;
 273
 274         list_for_each(node, &kbd_handler.h_list) {
 275                 struct input_handle *handle = to_handle_h(node);
 276                 struct input_dev *dev = handle->dev;
 277
 278                 if (test_bit(EV_REP, dev->evbit)) {
 279                         if (rep->delay > 0)
 280                                 input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
 281                         if (rep->period > 0)
 282                                 input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
 283                         d = dev->rep[REP_DELAY];
 284                         p = dev->rep[REP_PERIOD];
 285                 }
 286         }
 287         rep->delay  = d;
 288         rep->period = p;
 289         return 0;
 290 }
 291
 292 /*
 293  * Helper Functions.
 294  */
 295 static void put_queue(struct vc_data *vc, int ch)
 296 {
 297         struct tty_struct *tty = vc->vc_tty;
 298
 299         if (tty) {
 300                 tty_insert_flip_char(tty, ch, 0);
 301                 con_schedule_flip(tty);
 302         }
 303 }
 304
 305 static void puts_queue(struct vc_data *vc, char *cp)
 306 {
 307         struct tty_struct *tty = vc->vc_tty;
 308
 309         if (!tty)
 310                 return;
 311
 312         while (*cp) {
 313                 tty_insert_flip_char(tty, *cp, 0);
 314                 cp++;
 315         }
 316         con_schedule_flip(tty);
 317 }
 318
 319 static void applkey(struct vc_data *vc, int key, char mode)
 320 {
 321         static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
 322
 323         buf[1] = (mode ? 'O' : '[');
 324         buf[2] = key;
 325         puts_queue(vc, buf);
 326 }
 327
 328 /*
 329  * Many other routines do put_queue, but I think either
 330  * they produce ASCII, or they produce some user-assigned
 331  * string, and in both cases we might assume that it is
 332  * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
 333  * but we need only 16 bits here
 334  */
 335 static void to_utf8(struct vc_data *vc, ushort c)
 336 {
 337         if (c < 0x80)
 338                 /*  0******* */
 339                 put_queue(vc, c);
 340         else if (c < 0x800) {
 341                 /* 110***** 10****** */
 342                 put_queue(vc, 0xc0 | (c >> 6));
 343                 put_queue(vc, 0x80 | (c & 0x3f));
 344         } else {
 345                 /* 1110**** 10****** 10****** */
 346                 put_queue(vc, 0xe0 | (c >> 12));
 347                 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
 348                 put_queue(vc, 0x80 | (c & 0x3f));
 349         }
 350 }
 351
 352 /*
 353  * Called after returning from RAW mode or when changing consoles - recompute
 354  * shift_down[] and shift_state from key_down[] maybe called when keymap is
 355  * undefined, so that shiftkey release is seen
 356  */
 357 void compute_shiftstate(void)
 358 {
 359         unsigned int i, j, k, sym, val;
 360
 361         shift_state = 0;
 362         memset(shift_down, 0, sizeof(shift_down));
 363
 364         for (i = 0; i < ARRAY_SIZE(key_down); i++) {
 365
 366                 if (!key_down[i])
 367                         continue;
 368
 369                 k = i * BITS_PER_LONG;
 370
 371                 for (j = 0; j < BITS_PER_LONG; j++, k++) {
 372
 373                         if (!test_bit(k, key_down))
 374                                 continue;
 375
 376                         sym = U(key_maps[0][k]);
 377                         if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
 378                                 continue;
 379
 380                         val = KVAL(sym);
 381                         if (val == KVAL(K_CAPSSHIFT))
 382                                 val = KVAL(K_SHIFT);
 383
 384                         shift_down[val]++;
 385                         shift_state |= (1 << val);
 386                 }
 387         }
 388 }
 389
 390 /*
 391  * We have a combining character DIACR here, followed by the character CH.
 392  * If the combination occurs in the table, return the corresponding value.
 393  * Otherwise, if CH is a space or equals DIACR, return DIACR.
 394  * Otherwise, conclude that DIACR was not combining after all,
 395  * queue it and return CH.
 396  */
 397 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
 398 {
 399         unsigned int d = diacr;
 400         unsigned int i;
 401
 402         diacr = 0;
 403
 404         if ((d & ~0xff) == BRL_UC_ROW) {
 405                 if ((ch & ~0xff) == BRL_UC_ROW)
 406                         return d | ch;
 407         } else {
 408                 for (i = 0; i < accent_table_size; i++)
 409                         if (accent_table[i].diacr == d && accent_table[i].base == ch)
 410                                 return accent_table[i].result;
 411         }
 412
 413         if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
 414                 return d;
 415
 416         if (kbd->kbdmode == VC_UNICODE)
 417                 to_utf8(vc, d);
 418         else if (d < 0x100)
 419                 put_queue(vc, d);
 420
 421         return ch;
 422 }
 423
 424 /*
 425  * Special function handlers
 426  */
 427 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
 428 {
 429         if (diacr) {
 430                 if (kbd->kbdmode == VC_UNICODE)
 431                         to_utf8(vc, diacr);
 432                 else if (diacr < 0x100)
 433                         put_queue(vc, diacr);
 434                 diacr = 0;
 435         }
 436         put_queue(vc, 13);
 437         if (vc_kbd_mode(kbd, VC_CRLF))
 438                 put_queue(vc, 10);
 439 }
 440
 441 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
 442 {
 443         if (rep)
 444                 return;
 445         chg_vc_kbd_led(kbd, VC_CAPSLOCK);
 446 }
 447
 448 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
 449 {
 450         if (rep)
 451                 return;
 452         set_vc_kbd_led(kbd, VC_CAPSLOCK);
 453 }
 454
 455 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
 456 {
 457         if (regs)
 458                 show_regs(regs);
 459 }
 460
 461 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
 462 {
 463         struct tty_struct *tty = vc->vc_tty;
 464
 465         if (rep || !tty)
 466                 return;
 467
 468         /*
 469          * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
 470          * these routines are also activated by ^S/^Q.
 471          * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
 472          */
 473         if (tty->stopped)
 474                 start_tty(tty);
 475         else
 476                 stop_tty(tty);
 477 }
 478
 479 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
 480 {
 481         if (vc_kbd_mode(kbd,VC_APPLIC))
 482                 applkey(vc, 'P', 1);
 483         else
 484                 fn_bare_num(vc, regs);
 485 }
 486
 487 /*
 488  * Bind this to Shift-NumLock if you work in application keypad mode
 489  * but want to be able to change the NumLock flag.
 490  * Bind this to NumLock if you prefer that the NumLock key always
 491  * changes the NumLock flag.
 492  */
 493 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
 494 {
 495         if (!rep)
 496                 chg_vc_kbd_led(kbd, VC_NUMLOCK);
 497 }
 498
 499 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
 500 {
 501         /* switch to the last used console, ChN */
 502         set_console(last_console);
 503 }
 504
 505 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
 506 {
 507         int i, cur = fg_console;
 508
 509         /* Currently switching?  Queue this next switch relative to that. */
 510         if (want_console != -1)
 511                 cur = want_console;
 512
 513         for (i = cur - 1; i != cur; i--) {
 514                 if (i == -1)
 515                         i = MAX_NR_CONSOLES - 1;
 516                 if (vc_cons_allocated(i))
 517                         break;
 518         }
 519         set_console(i);
 520 }
 521
 522 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
 523 {
 524         int i, cur = fg_console;
 525
 526         /* Currently switching?  Queue this next switch relative to that. */
 527         if (want_console != -1)
 528                 cur = want_console;
 529
 530         for (i = cur+1; i != cur; i++) {
 531                 if (i == MAX_NR_CONSOLES)
 532                         i = 0;
 533                 if (vc_cons_allocated(i))
 534                         break;
 535         }
 536         set_console(i);
 537 }
 538
 539 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
 540 {
 541         struct tty_struct *tty = vc->vc_tty;
 542
 543         if (!tty)
 544                 return;
 545         tty_insert_flip_char(tty, 0, TTY_BREAK);
 546         con_schedule_flip(tty);
 547 }
 548
 549 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
 550 {
 551         scrollfront(vc, 0);
 552 }
 553
 554 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
 555 {
 556         scrollback(vc, 0);
 557 }
 558
 559 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
 560 {
 561         show_mem();
 562 }
 563
 564 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
 565 {
 566         show_state();
 567 }
 568
 569 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
 570 {
 571         ctrl_alt_del();
 572 }
 573
 574 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
 575 {
 576         dead_key_next = 1;
 577 }
 578
 579 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
 580 {
 581         if (spawnpid)
 582                 if (kill_proc(spawnpid, spawnsig, 1))
 583                         spawnpid = 0;
 584 }
 585
 586 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
 587 {
 588         struct tty_struct *tty = vc->vc_tty;
 589
 590         /*
 591          * SAK should also work in all raw modes and reset
 592          * them properly.
 593          */
 594         if (tty)
 595                 do_SAK(tty);
 596         reset_vc(vc);
 597 }
 598
 599 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
 600 {
 601         compute_shiftstate();
 602 }
 603
 604 /*
 605  * Special key handlers
 606  */
 607 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 608 {
 609 }
 610
 611 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 612 {
 613         if (up_flag)
 614                 return;
 615         if (value >= ARRAY_SIZE(fn_handler))
 616                 return;
 617         if ((kbd->kbdmode == VC_RAW ||
 618              kbd->kbdmode == VC_MEDIUMRAW) &&
 619              value != KVAL(K_SAK))
 620                 return;         /* SAK is allowed even in raw mode */
 621         fn_handler[value](vc, regs);
 622 }
 623
 624 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 625 {
 626         printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
 627 }
 628
 629 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
 630 {
 631         if (up_flag)
 632                 return;         /* no action, if this is a key release */
 633
 634         if (diacr)
 635                 value = handle_diacr(vc, value);
 636
 637         if (dead_key_next) {
 638                 dead_key_next = 0;
 639                 diacr = value;
 640                 return;
 641         }
 642         if (kbd->kbdmode == VC_UNICODE)
 643                 to_utf8(vc, value);
 644         else if (value < 0x100)
 645                 put_queue(vc, value);
 646 }
 647
 648 /*
 649  * Handle dead key. Note that we now may have several
 650  * dead keys modifying the same character. Very useful
 651  * for Vietnamese.
 652  */
 653 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
 654 {
 655         if (up_flag)
 656                 return;
 657         diacr = (diacr ? handle_diacr(vc, value) : value);
 658 }
 659
 660 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 661 {
 662         k_unicode(vc, value, up_flag, regs);
 663 }
 664
 665 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 666 {
 667         k_deadunicode(vc, value, up_flag, regs);
 668 }
 669
 670 /*
 671  * Obsolete - for backwards compatibility only
 672  */
 673 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 674 {
 675         static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
 676         value = ret_diacr[value];
 677         k_deadunicode(vc, value, up_flag, regs);
 678 }
 679
 680 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 681 {
 682         if (up_flag)
 683                 return;
 684         set_console(value);
 685 }
 686
 687 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 688 {
 689         unsigned v;
 690
 691         if (up_flag)
 692                 return;
 693         v = value;
 694         if (v < ARRAY_SIZE(func_table)) {
 695                 if (func_table[value])
 696                         puts_queue(vc, func_table[value]);
 697         } else
 698                 printk(KERN_ERR "k_fn called with value=%d\n", value);
 699 }
 700
 701 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 702 {
 703         static const char *cur_chars = "BDCA";
 704
 705         if (up_flag)
 706                 return;
 707         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 708 }
 709
 710 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 711 {
 712         static const char pad_chars[] = "0123456789+-*/\015,.?()#";
 713         static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
 714
 715         if (up_flag)
 716                 return;         /* no action, if this is a key release */
 717
 718         /* kludge... shift forces cursor/number keys */
 719         if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
 720                 applkey(vc, app_map[value], 1);
 721                 return;
 722         }
 723
 724         if (!vc_kbd_led(kbd, VC_NUMLOCK))
 725                 switch (value) {
 726                         case KVAL(K_PCOMMA):
 727                         case KVAL(K_PDOT):
 728                                 k_fn(vc, KVAL(K_REMOVE), 0, regs);
 729                                 return;
 730                         case KVAL(K_P0):
 731                                 k_fn(vc, KVAL(K_INSERT), 0, regs);
 732                                 return;
 733                         case KVAL(K_P1):
 734                                 k_fn(vc, KVAL(K_SELECT), 0, regs);
 735                                 return;
 736                         case KVAL(K_P2):
 737                                 k_cur(vc, KVAL(K_DOWN), 0, regs);
 738                                 return;
 739                         case KVAL(K_P3):
 740                                 k_fn(vc, KVAL(K_PGDN), 0, regs);
 741                                 return;
 742                         case KVAL(K_P4):
 743                                 k_cur(vc, KVAL(K_LEFT), 0, regs);
 744                                 return;
 745                         case KVAL(K_P6):
 746                                 k_cur(vc, KVAL(K_RIGHT), 0, regs);
 747                                 return;
 748                         case KVAL(K_P7):
 749                                 k_fn(vc, KVAL(K_FIND), 0, regs);
 750                                 return;
 751                         case KVAL(K_P8):
 752                                 k_cur(vc, KVAL(K_UP), 0, regs);
 753                                 return;
 754                         case KVAL(K_P9):
 755                                 k_fn(vc, KVAL(K_PGUP), 0, regs);
 756                                 return;
 757                         case KVAL(K_P5):
 758                                 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
 759                                 return;
 760                 }
 761
 762         put_queue(vc, pad_chars[value]);
 763         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
 764                 put_queue(vc, 10);
 765 }
 766
 767 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 768 {
 769         int old_state = shift_state;
 770
 771         if (rep)
 772                 return;
 773         /*
 774          * Mimic typewriter:
 775          * a CapsShift key acts like Shift but undoes CapsLock
 776          */
 777         if (value == KVAL(K_CAPSSHIFT)) {
 778                 value = KVAL(K_SHIFT);
 779                 if (!up_flag)
 780                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
 781         }
 782
 783         if (up_flag) {
 784                 /*
 785                  * handle the case that two shift or control
 786                  * keys are depressed simultaneously
 787                  */
 788                 if (shift_down[value])
 789                         shift_down[value]--;
 790         } else
 791                 shift_down[value]++;
 792
 793         if (shift_down[value])
 794                 shift_state |= (1 << value);
 795         else
 796                 shift_state &= ~(1 << value);
 797
 798         /* kludge */
 799         if (up_flag && shift_state != old_state && npadch != -1) {
 800                 if (kbd->kbdmode == VC_UNICODE)
 801                         to_utf8(vc, npadch & 0xffff);
 802                 else
 803                         put_queue(vc, npadch & 0xff);
 804                 npadch = -1;
 805         }
 806 }
 807
 808 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 809 {
 810         if (up_flag)
 811                 return;
 812
 813         if (vc_kbd_mode(kbd, VC_META)) {
 814                 put_queue(vc, '\033');
 815                 put_queue(vc, value);
 816         } else
 817                 put_queue(vc, value | 0x80);
 818 }
 819
 820 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 821 {
 822         int base;
 823
 824         if (up_flag)
 825                 return;
 826
 827         if (value < 10) {
 828                 /* decimal input of code, while Alt depressed */
 829                 base = 10;
 830         } else {
 831                 /* hexadecimal input of code, while AltGr depressed */
 832                 value -= 10;
 833                 base = 16;
 834         }
 835
 836         if (npadch == -1)
 837                 npadch = value;
 838         else
 839                 npadch = npadch * base + value;
 840 }
 841
 842 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 843 {
 844         if (up_flag || rep)
 845                 return;
 846         chg_vc_kbd_lock(kbd, value);
 847 }
 848
 849 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 850 {
 851         k_shift(vc, value, up_flag, regs);
 852         if (up_flag || rep)
 853                 return;
 854         chg_vc_kbd_slock(kbd, value);
 855         /* try to make Alt, oops, AltGr and such work */
 856         if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
 857                 kbd->slockstate = 0;
 858                 chg_vc_kbd_slock(kbd, value);
 859         }
 860 }
 861
 862 /* by default, 300ms interval for combination release */
 863 static unsigned brl_timeout = 300;
 864 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
 865 module_param(brl_timeout, uint, 0644);
 866
 867 static unsigned brl_nbchords = 1;
 868 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
 869 module_param(brl_nbchords, uint, 0644);
 870
 871 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag, struct pt_regs *regs)
 872 {
 873         static unsigned long chords;
 874         static unsigned committed;
 875
 876         if (!brl_nbchords)
 877                 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag, regs);
 878         else {
 879                 committed |= pattern;
 880                 chords++;
 881                 if (chords == brl_nbchords) {
 882                         k_unicode(vc, BRL_UC_ROW | committed, up_flag, regs);
 883                         chords = 0;
 884                         committed = 0;
 885                 }
 886         }
 887 }
 888
 889 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 890 {
 891         static unsigned pressed,committing;
 892         static unsigned long releasestart;
 893
 894         if (kbd->kbdmode != VC_UNICODE) {
 895                 if (!up_flag)
 896                         printk("keyboard mode must be unicode for braille patterns\n");
 897                 return;
 898         }
 899
 900         if (!value) {
 901                 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
 902                 return;
 903         }
 904
 905         if (value > 8)
 906                 return;
 907
 908         if (up_flag) {
 909                 if (brl_timeout) {
 910                         if (!committing ||
 911                             jiffies - releasestart > (brl_timeout * HZ) / 1000) {
 912                                 committing = pressed;
 913                                 releasestart = jiffies;
 914                         }
 915                         pressed &= ~(1 << (value - 1));
 916                         if (!pressed) {
 917                                 if (committing) {
 918                                         k_brlcommit(vc, committing, 0, regs);
 919                                         committing = 0;
 920                                 }
 921                         }
 922                 } else {
 923                         if (committing) {
 924                                 k_brlcommit(vc, committing, 0, regs);
 925                                 committing = 0;
 926                         }
 927                         pressed &= ~(1 << (value - 1));
 928                 }
 929         } else {
 930                 pressed |= 1 << (value - 1);
 931                 if (!brl_timeout)
 932                         committing = pressed;
 933         }
 934 }
 935
 936 /*
 937  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
 938  * or (ii) whatever pattern of lights people want to show using KDSETLED,
 939  * or (iii) specified bits of specified words in kernel memory.
 940  */
 941 unsigned char getledstate(void)
 942 {
 943         return ledstate;
 944 }
 945
 946 void setledstate(struct kbd_struct *kbd, unsigned int led)
 947 {
 948         if (!(led & ~7)) {
 949                 ledioctl = led;
 950                 kbd->ledmode = LED_SHOW_IOCTL;
 951         } else
 952                 kbd->ledmode = LED_SHOW_FLAGS;
 953         set_leds();
 954 }
 955
 956 static inline unsigned char getleds(void)
 957 {
 958         struct kbd_struct *kbd = kbd_table + fg_console;
 959         unsigned char leds;
 960         int i;
 961
 962         if (kbd->ledmode == LED_SHOW_IOCTL)
 963                 return ledioctl;
 964
 965         leds = kbd->ledflagstate;
 966
 967         if (kbd->ledmode == LED_SHOW_MEM) {
 968                 for (i = 0; i < 3; i++)
 969                         if (ledptrs[i].valid) {
 970                                 if (*ledptrs[i].addr & ledptrs[i].mask)
 971                                         leds |= (1 << i);
 972                                 else
 973                                         leds &= ~(1 << i);
 974                         }
 975         }
 976         return leds;
 977 }
 978
 979 /*
 980  * This routine is the bottom half of the keyboard interrupt
 981  * routine, and runs with all interrupts enabled. It does
 982  * console changing, led setting and copy_to_cooked, which can
 983  * take a reasonably long time.
 984  *
 985  * Aside from timing (which isn't really that important for
 986  * keyboard interrupts as they happen often), using the software
 987  * interrupt routines for this thing allows us to easily mask
 988  * this when we don't want any of the above to happen.
 989  * This allows for easy and efficient race-condition prevention
 990  * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
 991  */
 992
 993 static void kbd_bh(unsigned long dummy)
 994 {
 995         struct list_head *node;
 996         unsigned char leds = getleds();
 997
 998         if (leds != ledstate) {
 999                 list_for_each(node, &kbd_handler.h_list) {
1000                         struct input_handle *handle = to_handle_h(node);
1001                         input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1002                         input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1003                         input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1004                         input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1005                 }
1006         }
1007
1008         ledstate = leds;
1009 }
1010
1011 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1012
1013 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1014     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1015     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1016     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1017
1018 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1019                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1020
1021 static const unsigned short x86_keycodes[256] =
1022         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1023          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1024          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1025          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1026          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1027          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1028         284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
1029         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1030         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1031         103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1032         291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1033         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1034         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1035         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1036         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1037
1038 #ifdef CONFIG_MAC_EMUMOUSEBTN
1039 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1040 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1041
1042 #ifdef CONFIG_SPARC
1043 static int sparc_l1_a_state = 0;
1044 extern void sun_do_break(void);
1045 #endif
1046
1047 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1048                        unsigned char up_flag)
1049 {
1050         if (keycode > 255 || !x86_keycodes[keycode])
1051                 return -1;
1052
1053         switch (keycode) {
1054                 case KEY_PAUSE:
1055                         put_queue(vc, 0xe1);
1056                         put_queue(vc, 0x1d | up_flag);
1057                         put_queue(vc, 0x45 | up_flag);
1058                         return 0;
1059                 case KEY_HANGEUL:
1060                         if (!up_flag)
1061                                 put_queue(vc, 0xf2);
1062                         return 0;
1063                 case KEY_HANJA:
1064                         if (!up_flag)
1065                                 put_queue(vc, 0xf1);
1066                         return 0;
1067         }
1068
1069         if (keycode == KEY_SYSRQ && sysrq_alt) {
1070                 put_queue(vc, 0x54 | up_flag);
1071                 return 0;
1072         }
1073
1074         if (x86_keycodes[keycode] & 0x100)
1075                 put_queue(vc, 0xe0);
1076
1077         put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1078
1079         if (keycode == KEY_SYSRQ) {
1080                 put_queue(vc, 0xe0);
1081                 put_queue(vc, 0x37 | up_flag);
1082         }
1083
1084         return 0;
1085 }
1086
1087 #else
1088
1089 #define HW_RAW(dev)     0
1090
1091 #warning "Cannot generate rawmode keyboard for your architecture yet."
1092
1093 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1094 {
1095         if (keycode > 127)
1096                 return -1;
1097
1098         put_queue(vc, keycode | up_flag);
1099         return 0;
1100 }
1101 #endif
1102
1103 static void kbd_rawcode(unsigned char data)
1104 {
1105         struct vc_data *vc = vc_cons[fg_console].d;
1106         kbd = kbd_table + fg_console;
1107         if (kbd->kbdmode == VC_RAW)
1108                 put_queue(vc, data);
1109 }
1110
1111 static void kbd_keycode(unsigned int keycode, int down,
1112                         int hw_raw, struct pt_regs *regs)
1113 {
1114         struct vc_data *vc = vc_cons[fg_console].d;
1115         unsigned short keysym, *key_map;
1116         unsigned char type, raw_mode;
1117         struct tty_struct *tty;
1118         int shift_final;
1119
1120         tty = vc->vc_tty;
1121
1122         if (tty && (!tty->driver_data)) {
1123                 /* No driver data? Strange. Okay we fix it then. */
1124                 tty->driver_data = vc;
1125         }
1126
1127         kbd = kbd_table + fg_console;
1128
1129         if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1130                 sysrq_alt = down ? keycode : 0;
1131 #ifdef CONFIG_SPARC
1132         if (keycode == KEY_STOP)
1133                 sparc_l1_a_state = down;
1134 #endif
1135
1136         rep = (down == 2);
1137
1138 #ifdef CONFIG_MAC_EMUMOUSEBTN
1139         if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1140                 return;
1141 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1142
1143         if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1144                 if (emulate_raw(vc, keycode, !down << 7))
1145                         if (keycode < BTN_MISC)
1146                                 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1147
1148 #ifdef CONFIG_MAGIC_SYSRQ              /* Handle the SysRq Hack */
1149         if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1150                 if (!sysrq_down) {
1151                         sysrq_down = down;
1152                         sysrq_alt_use = sysrq_alt;
1153                 }
1154                 return;
1155         }
1156         if (sysrq_down && !down && keycode == sysrq_alt_use)
1157                 sysrq_down = 0;
1158         if (sysrq_down && down && !rep) {
1159                 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1160                 return;
1161         }
1162 #endif
1163 #ifdef CONFIG_SPARC
1164         if (keycode == KEY_A && sparc_l1_a_state) {
1165                 sparc_l1_a_state = 0;
1166                 sun_do_break();
1167         }
1168 #endif
1169
1170         if (kbd->kbdmode == VC_MEDIUMRAW) {
1171                 /*
1172                  * This is extended medium raw mode, with keys above 127
1173                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1174                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1175                  * interfere with anything else. The two bytes after 0 will
1176                  * always have the up flag set not to interfere with older
1177                  * applications. This allows for 16384 different keycodes,
1178                  * which should be enough.
1179                  */
1180                 if (keycode < 128) {
1181                         put_queue(vc, keycode | (!down << 7));
1182                 } else {
1183                         put_queue(vc, !down << 7);
1184                         put_queue(vc, (keycode >> 7) | 0x80);
1185                         put_queue(vc, keycode | 0x80);
1186                 }
1187                 raw_mode = 1;
1188         }
1189
1190         if (down)
1191                 set_bit(keycode, key_down);
1192         else
1193                 clear_bit(keycode, key_down);
1194
1195         if (rep &&
1196             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1197              (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1198                 /*
1199                  * Don't repeat a key if the input buffers are not empty and the
1200                  * characters get aren't echoed locally. This makes key repeat
1201                  * usable with slow applications and under heavy loads.
1202                  */
1203                 return;
1204         }
1205
1206         shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1207         key_map = key_maps[shift_final];
1208
1209         if (!key_map) {
1210                 compute_shiftstate();
1211                 kbd->slockstate = 0;
1212                 return;
1213         }
1214
1215         if (keycode > NR_KEYS)
1216                 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1217                         keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1218                 else
1219                         return;
1220         else
1221                 keysym = key_map[keycode];
1222
1223         type = KTYP(keysym);
1224
1225         if (type < 0xf0) {
1226                 if (down && !raw_mode)
1227                         to_utf8(vc, keysym);
1228                 return;
1229         }
1230
1231         type -= 0xf0;
1232
1233         if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1234                 return;
1235
1236         if (type == KT_LETTER) {
1237                 type = KT_LATIN;
1238                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1239                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1240                         if (key_map)
1241                                 keysym = key_map[keycode];
1242                 }
1243         }
1244
1245         (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1246
1247         if (type != KT_SLOCK)
1248                 kbd->slockstate = 0;
1249 }
1250
1251 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1252                       unsigned int event_code, int value)
1253 {
1254         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1255                 kbd_rawcode(value);
1256         if (event_type == EV_KEY)
1257                 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1258         tasklet_schedule(&keyboard_tasklet);
1259         do_poke_blanked_console = 1;
1260         schedule_console_callback();
1261 }
1262
1263 /*
1264  * When a keyboard (or other input device) is found, the kbd_connect
1265  * function is called. The function then looks at the device, and if it
1266  * likes it, it can open it and get events from it. In this (kbd_connect)
1267  * function, we should decide which VT to bind that keyboard to initially.
1268  */
1269 static struct input_handle *kbd_connect(struct input_handler *handler,
1270                                         struct input_dev *dev,
1271                                         struct input_device_id *id)
1272 {
1273         struct input_handle *handle;
1274         int i;
1275
1276         for (i = KEY_RESERVED; i < BTN_MISC; i++)
1277                 if (test_bit(i, dev->keybit))
1278                         break;
1279
1280         if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1281                 return NULL;
1282
1283         if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1284                 return NULL;
1285         memset(handle, 0, sizeof(struct input_handle));
1286
1287         handle->dev = dev;
1288         handle->handler = handler;
1289         handle->name = "kbd";
1290
1291         input_open_device(handle);
1292
1293         return handle;
1294 }
1295
1296 static void kbd_disconnect(struct input_handle *handle)
1297 {
1298         input_close_device(handle);
1299         kfree(handle);
1300 }
1301
1302 /*
1303  * Start keyboard handler on the new keyboard by refreshing LED state to
1304  * match the rest of the system.
1305  */
1306 static void kbd_start(struct input_handle *handle)
1307 {
1308         unsigned char leds = ledstate;
1309
1310         tasklet_disable(&keyboard_tasklet);
1311         if (leds != 0xff) {
1312                 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1313                 input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1314                 input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1315                 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1316         }
1317         tasklet_enable(&keyboard_tasklet);
1318 }
1319
1320 static struct input_device_id kbd_ids[] = {
1321         {
1322                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1323                 .evbit = { BIT(EV_KEY) },
1324         },
1325
1326         {
1327                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1328                 .evbit = { BIT(EV_SND) },
1329         },
1330
1331         { },    /* Terminating entry */
1332 };
1333
1334 MODULE_DEVICE_TABLE(input, kbd_ids);
1335
1336 static struct input_handler kbd_handler = {
1337         .event          = kbd_event,
1338         .connect        = kbd_connect,
1339         .disconnect     = kbd_disconnect,
1340         .start          = kbd_start,
1341         .name           = "kbd",
1342         .id_table       = kbd_ids,
1343 };
1344
1345 int __init kbd_init(void)
1346 {
1347         int i;
1348
1349         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1350                 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1351                 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1352                 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1353                 kbd_table[i].lockstate = KBD_DEFLOCK;
1354                 kbd_table[i].slockstate = 0;
1355                 kbd_table[i].modeflags = KBD_DEFMODE;
1356                 kbd_table[i].kbdmode = VC_XLATE;
1357         }
1358
1359         input_register_handler(&kbd_handler);
1360
1361         tasklet_enable(&keyboard_tasklet);
1362         tasklet_schedule(&keyboard_tasklet);
1363
1364         return 0;
1365 }