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