drivers/char/keyboard.c

   1 /*
   2  * linux/drivers/char/keyboard.c
   3  *
   4  * Written for linux by Johan Myreen as a translation from
   5  * the assembly version by Linus (with diacriticals added)
   6  *
   7  * Some additional features added by Christoph Niemann (ChN), March 1993
   8  *
   9  * Loadable keymaps by Risto Kankkunen, May 1993
  10  *
  11  * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
  12  * Added decr/incr_console, dynamic keymaps, Unicode support,
  13  * dynamic function/string keys, led setting,  Sept 1994
  14  * `Sticky' modifier keys, 951006.
  15  *
  16  * 11-11-96: SAK should now work in the raw mode (Martin Mares)
  17  *
  18  * Modified to provide 'generic' keyboard support by Hamish Macdonald
  19  * Merge with the m68k keyboard driver and split-off of the PC low-level
  20  * parts by Geert Uytterhoeven, May 1997
  21  *
  22  * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
  23  * 30-07-98: Dead keys redone, aeb@cwi.nl.
  24  * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/sched.h>
  29 #include <linux/tty.h>
  30 #include <linux/tty_flip.h>
  31 #include <linux/mm.h>
  32 #include <linux/string.h>
  33 #include <linux/init.h>
  34 #include <linux/slab.h>
  35
  36 #include <linux/kbd_kern.h>
  37 #include <linux/kbd_diacr.h>
  38 #include <linux/vt_kern.h>
  39 #include <linux/sysrq.h>
  40 #include <linux/input.h>
  41 #include <linux/reboot.h>
  42
  43 static void kbd_disconnect(struct input_handle *handle);
  44 extern void ctrl_alt_del(void);
  45
  46 /*
  47  * Exported functions/variables
  48  */
  49
  50 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  51
  52 /*
  53  * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
  54  * This seems a good reason to start with NumLock off. On HIL keyboards
  55  * of PARISC machines however there is no NumLock key and everyone expects the keypad
  56  * to be used for numbers.
  57  */
  58
  59 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
  60 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
  61 #else
  62 #define KBD_DEFLEDS 0
  63 #endif
  64
  65 #define KBD_DEFLOCK 0
  66
  67 void compute_shiftstate(void);
  68
  69 /*
  70  * Handler Tables.
  71  */
  72
  73 #define K_HANDLERS\
  74         k_self,         k_fn,           k_spec,         k_pad,\
  75         k_dead,         k_cons,         k_cur,          k_shift,\
  76         k_meta,         k_ascii,        k_lock,         k_lowercase,\
  77         k_slock,        k_dead2,        k_brl,          k_ignore
  78
  79 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
  80                             char up_flag, struct pt_regs *regs);
  81 static k_handler_fn K_HANDLERS;
  82 static k_handler_fn *k_handler[16] = { K_HANDLERS };
  83
  84 #define FN_HANDLERS\
  85         fn_null,        fn_enter,       fn_show_ptregs, fn_show_mem,\
  86         fn_show_state,  fn_send_intr,   fn_lastcons,    fn_caps_toggle,\
  87         fn_num,         fn_hold,        fn_scroll_forw, fn_scroll_back,\
  88         fn_boot_it,     fn_caps_on,     fn_compose,     fn_SAK,\
  89         fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
  90
  91 typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
  92 static fn_handler_fn FN_HANDLERS;
  93 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
  94
  95 /*
  96  * Variables exported for vt_ioctl.c
  97  */
  98
  99 /* maximum values each key_handler can handle */
 100 const int max_vals[] = {
 101         255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
 102         NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
 103         255, NR_LOCK - 1, 255, NR_BRL - 1
 104 };
 105
 106 const int NR_TYPES = ARRAY_SIZE(max_vals);
 107
 108 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 109 static struct kbd_struct *kbd = kbd_table;
 110 static struct kbd_struct kbd0;
 111
 112 int spawnpid, spawnsig;
 113
 114 /*
 115  * Variables exported for vt.c
 116  */
 117
 118 int shift_state = 0;
 119
 120 /*
 121  * Internal Data.
 122  */
 123
 124 static struct input_handler kbd_handler;
 125 static unsigned long key_down[NBITS(KEY_MAX)];          /* keyboard key bitmap */
 126 static unsigned char shift_down[NR_SHIFT];              /* shift state counters.. */
 127 static int dead_key_next;
 128 static int npadch = -1;                                 /* -1 or number assembled on pad */
 129 static unsigned int diacr;
 130 static char rep;                                        /* flag telling character repeat */
 131
 132 static unsigned char ledstate = 0xff;                   /* undefined */
 133 static unsigned char ledioctl;
 134
 135 static struct ledptr {
 136         unsigned int *addr;
 137         unsigned int mask;
 138         unsigned char valid:1;
 139 } ledptrs[3];
 140
 141 /* Simple translation table for the SysRq keys */
 142
 143 #ifdef CONFIG_MAGIC_SYSRQ
 144 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
 145         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
 146         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
 147         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
 148         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
 149         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
 150         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
 151         "\r\000/";                                      /* 0x60 - 0x6f */
 152 static int sysrq_down;
 153 static int sysrq_alt_use;
 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 const 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_start => 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 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1015     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1016     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1017     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1018
1019 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1020                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1021
1022 static const unsigned short x86_keycodes[256] =
1023         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1024          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1025          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1026          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1027          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1028          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1029         284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
1030         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1031         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1032         103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1033         291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1034         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1035         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1036         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1037         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1038
1039 #ifdef CONFIG_MAC_EMUMOUSEBTN
1040 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1041 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1042
1043 #ifdef CONFIG_SPARC
1044 static int sparc_l1_a_state = 0;
1045 extern void sun_do_break(void);
1046 #endif
1047
1048 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1049                        unsigned char up_flag)
1050 {
1051         if (keycode > 255 || !x86_keycodes[keycode])
1052                 return -1;
1053
1054         switch (keycode) {
1055                 case KEY_PAUSE:
1056                         put_queue(vc, 0xe1);
1057                         put_queue(vc, 0x1d | up_flag);
1058                         put_queue(vc, 0x45 | up_flag);
1059                         return 0;
1060                 case KEY_HANGEUL:
1061                         if (!up_flag)
1062                                 put_queue(vc, 0xf2);
1063                         return 0;
1064                 case KEY_HANJA:
1065                         if (!up_flag)
1066                                 put_queue(vc, 0xf1);
1067                         return 0;
1068         }
1069
1070         if (keycode == KEY_SYSRQ && sysrq_alt) {
1071                 put_queue(vc, 0x54 | up_flag);
1072                 return 0;
1073         }
1074
1075         if (x86_keycodes[keycode] & 0x100)
1076                 put_queue(vc, 0xe0);
1077
1078         put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1079
1080         if (keycode == KEY_SYSRQ) {
1081                 put_queue(vc, 0xe0);
1082                 put_queue(vc, 0x37 | up_flag);
1083         }
1084
1085         return 0;
1086 }
1087
1088 #else
1089
1090 #define HW_RAW(dev)     0
1091
1092 #warning "Cannot generate rawmode keyboard for your architecture yet."
1093
1094 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1095 {
1096         if (keycode > 127)
1097                 return -1;
1098
1099         put_queue(vc, keycode | up_flag);
1100         return 0;
1101 }
1102 #endif
1103
1104 static void kbd_rawcode(unsigned char data)
1105 {
1106         struct vc_data *vc = vc_cons[fg_console].d;
1107         kbd = kbd_table + fg_console;
1108         if (kbd->kbdmode == VC_RAW)
1109                 put_queue(vc, data);
1110 }
1111
1112 static void kbd_keycode(unsigned int keycode, int down,
1113                         int hw_raw, struct pt_regs *regs)
1114 {
1115         struct vc_data *vc = vc_cons[fg_console].d;
1116         unsigned short keysym, *key_map;
1117         unsigned char type, raw_mode;
1118         struct tty_struct *tty;
1119         int shift_final;
1120
1121         tty = vc->vc_tty;
1122
1123         if (tty && (!tty->driver_data)) {
1124                 /* No driver data? Strange. Okay we fix it then. */
1125                 tty->driver_data = vc;
1126         }
1127
1128         kbd = kbd_table + fg_console;
1129
1130         if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1131                 sysrq_alt = down ? keycode : 0;
1132 #ifdef CONFIG_SPARC
1133         if (keycode == KEY_STOP)
1134                 sparc_l1_a_state = down;
1135 #endif
1136
1137         rep = (down == 2);
1138
1139 #ifdef CONFIG_MAC_EMUMOUSEBTN
1140         if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1141                 return;
1142 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1143
1144         if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1145                 if (emulate_raw(vc, keycode, !down << 7))
1146                         if (keycode < BTN_MISC)
1147                                 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1148
1149 #ifdef CONFIG_MAGIC_SYSRQ              /* Handle the SysRq Hack */
1150         if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1151                 if (!sysrq_down) {
1152                         sysrq_down = down;
1153                         sysrq_alt_use = sysrq_alt;
1154                 }
1155                 return;
1156         }
1157         if (sysrq_down && !down && keycode == sysrq_alt_use)
1158                 sysrq_down = 0;
1159         if (sysrq_down && down && !rep) {
1160                 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1161                 return;
1162         }
1163 #endif
1164 #ifdef CONFIG_SPARC
1165         if (keycode == KEY_A && sparc_l1_a_state) {
1166                 sparc_l1_a_state = 0;
1167                 sun_do_break();
1168         }
1169 #endif
1170
1171         if (kbd->kbdmode == VC_MEDIUMRAW) {
1172                 /*
1173                  * This is extended medium raw mode, with keys above 127
1174                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1175                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1176                  * interfere with anything else. The two bytes after 0 will
1177                  * always have the up flag set not to interfere with older
1178                  * applications. This allows for 16384 different keycodes,
1179                  * which should be enough.
1180                  */
1181                 if (keycode < 128) {
1182                         put_queue(vc, keycode | (!down << 7));
1183                 } else {
1184                         put_queue(vc, !down << 7);
1185                         put_queue(vc, (keycode >> 7) | 0x80);
1186                         put_queue(vc, keycode | 0x80);
1187                 }
1188                 raw_mode = 1;
1189         }
1190
1191         if (down)
1192                 set_bit(keycode, key_down);
1193         else
1194                 clear_bit(keycode, key_down);
1195
1196         if (rep &&
1197             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1198              (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1199                 /*
1200                  * Don't repeat a key if the input buffers are not empty and the
1201                  * characters get aren't echoed locally. This makes key repeat
1202                  * usable with slow applications and under heavy loads.
1203                  */
1204                 return;
1205         }
1206
1207         shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1208         key_map = key_maps[shift_final];
1209
1210         if (!key_map) {
1211                 compute_shiftstate();
1212                 kbd->slockstate = 0;
1213                 return;
1214         }
1215
1216         if (keycode > NR_KEYS)
1217                 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1218                         keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1219                 else
1220                         return;
1221         else
1222                 keysym = key_map[keycode];
1223
1224         type = KTYP(keysym);
1225
1226         if (type < 0xf0) {
1227                 if (down && !raw_mode)
1228                         to_utf8(vc, keysym);
1229                 return;
1230         }
1231
1232         type -= 0xf0;
1233
1234         if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1235                 return;
1236
1237         if (type == KT_LETTER) {
1238                 type = KT_LATIN;
1239                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1240                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1241                         if (key_map)
1242                                 keysym = key_map[keycode];
1243                 }
1244         }
1245
1246         (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1247
1248         if (type != KT_SLOCK)
1249                 kbd->slockstate = 0;
1250 }
1251
1252 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1253                       unsigned int event_code, int value)
1254 {
1255         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1256                 kbd_rawcode(value);
1257         if (event_type == EV_KEY)
1258                 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1259         tasklet_schedule(&keyboard_tasklet);
1260         do_poke_blanked_console = 1;
1261         schedule_console_callback();
1262 }
1263
1264 /*
1265  * When a keyboard (or other input device) is found, the kbd_connect
1266  * function is called. The function then looks at the device, and if it
1267  * likes it, it can open it and get events from it. In this (kbd_connect)
1268  * function, we should decide which VT to bind that keyboard to initially.
1269  */
1270 static struct input_handle *kbd_connect(struct input_handler *handler,
1271                                         struct input_dev *dev,
1272                                         struct input_device_id *id)
1273 {
1274         struct input_handle *handle;
1275         int i;
1276
1277         for (i = KEY_RESERVED; i < BTN_MISC; i++)
1278                 if (test_bit(i, dev->keybit))
1279                         break;
1280
1281         if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1282                 return NULL;
1283
1284         if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1285                 return NULL;
1286         memset(handle, 0, sizeof(struct input_handle));
1287
1288         handle->dev = dev;
1289         handle->handler = handler;
1290         handle->name = "kbd";
1291
1292         input_open_device(handle);
1293
1294         return handle;
1295 }
1296
1297 static void kbd_disconnect(struct input_handle *handle)
1298 {
1299         input_close_device(handle);
1300         kfree(handle);
1301 }
1302
1303 /*
1304  * Start keyboard handler on the new keyboard by refreshing LED state to
1305  * match the rest of the system.
1306  */
1307 static void kbd_start(struct input_handle *handle)
1308 {
1309         unsigned char leds = ledstate;
1310
1311         tasklet_disable(&keyboard_tasklet);
1312         if (leds != 0xff) {
1313                 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1314                 input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
1315                 input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1316                 input_sync(handle->dev);
1317         }
1318         tasklet_enable(&keyboard_tasklet);
1319 }
1320
1321 static struct input_device_id kbd_ids[] = {
1322         {
1323                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1324                 .evbit = { BIT(EV_KEY) },
1325         },
1326
1327         {
1328                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1329                 .evbit = { BIT(EV_SND) },
1330         },
1331
1332         { },    /* Terminating entry */
1333 };
1334
1335 MODULE_DEVICE_TABLE(input, kbd_ids);
1336
1337 static struct input_handler kbd_handler = {
1338         .event          = kbd_event,
1339         .connect        = kbd_connect,
1340         .disconnect     = kbd_disconnect,
1341         .start          = kbd_start,
1342         .name           = "kbd",
1343         .id_table       = kbd_ids,
1344 };
1345
1346 int __init kbd_init(void)
1347 {
1348         int i;
1349
1350         kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1351         kbd0.ledmode = LED_SHOW_FLAGS;
1352         kbd0.lockstate = KBD_DEFLOCK;
1353         kbd0.slockstate = 0;
1354         kbd0.modeflags = KBD_DEFMODE;
1355         kbd0.kbdmode = VC_XLATE;
1356
1357         for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1358                 kbd_table[i] = kbd0;
1359
1360         input_register_handler(&kbd_handler);
1361
1362         tasklet_enable(&keyboard_tasklet);
1363         tasklet_schedule(&keyboard_tasklet);
1364
1365         return 0;
1366 }