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