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