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