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