drivers/char/keyboard.c

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