drivers/char/keyboard.c

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