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         schedule_work(SAK_work);
 600 }
 601
 602 static void fn_null(struct vc_data *vc)
 603 {
 604         compute_shiftstate();
 605 }
 606
 607 /*
 608  * Special key handlers
 609  */
 610 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
 611 {
 612 }
 613
 614 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
 615 {
 616         if (up_flag)
 617                 return;
 618         if (value >= ARRAY_SIZE(fn_handler))
 619                 return;
 620         if ((kbd->kbdmode == VC_RAW ||
 621              kbd->kbdmode == VC_MEDIUMRAW) &&
 622              value != KVAL(K_SAK))
 623                 return;         /* SAK is allowed even in raw mode */
 624         fn_handler[value](vc);
 625 }
 626
 627 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
 628 {
 629         printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
 630 }
 631
 632 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
 633 {
 634         if (up_flag)
 635                 return;         /* no action, if this is a key release */
 636
 637         if (diacr)
 638                 value = handle_diacr(vc, value);
 639
 640         if (dead_key_next) {
 641                 dead_key_next = 0;
 642                 diacr = value;
 643                 return;
 644         }
 645         if (kbd->kbdmode == VC_UNICODE)
 646                 to_utf8(vc, value);
 647         else if (value < 0x100)
 648                 put_queue(vc, value);
 649 }
 650
 651 /*
 652  * Handle dead key. Note that we now may have several
 653  * dead keys modifying the same character. Very useful
 654  * for Vietnamese.
 655  */
 656 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
 657 {
 658         if (up_flag)
 659                 return;
 660         diacr = (diacr ? handle_diacr(vc, value) : value);
 661 }
 662
 663 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
 664 {
 665         k_unicode(vc, value, up_flag);
 666 }
 667
 668 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
 669 {
 670         k_deadunicode(vc, value, up_flag);
 671 }
 672
 673 /*
 674  * Obsolete - for backwards compatibility only
 675  */
 676 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
 677 {
 678         static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
 679         value = ret_diacr[value];
 680         k_deadunicode(vc, value, up_flag);
 681 }
 682
 683 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
 684 {
 685         if (up_flag)
 686                 return;
 687         set_console(value);
 688 }
 689
 690 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
 691 {
 692         unsigned v;
 693
 694         if (up_flag)
 695                 return;
 696         v = value;
 697         if (v < ARRAY_SIZE(func_table)) {
 698                 if (func_table[value])
 699                         puts_queue(vc, func_table[value]);
 700         } else
 701                 printk(KERN_ERR "k_fn called with value=%d\n", value);
 702 }
 703
 704 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
 705 {
 706         static const char cur_chars[] = "BDCA";
 707
 708         if (up_flag)
 709                 return;
 710         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 711 }
 712
 713 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
 714 {
 715         static const char pad_chars[] = "0123456789+-*/\015,.?()#";
 716         static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
 717
 718         if (up_flag)
 719                 return;         /* no action, if this is a key release */
 720
 721         /* kludge... shift forces cursor/number keys */
 722         if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
 723                 applkey(vc, app_map[value], 1);
 724                 return;
 725         }
 726
 727         if (!vc_kbd_led(kbd, VC_NUMLOCK))
 728                 switch (value) {
 729                         case KVAL(K_PCOMMA):
 730                         case KVAL(K_PDOT):
 731                                 k_fn(vc, KVAL(K_REMOVE), 0);
 732                                 return;
 733                         case KVAL(K_P0):
 734                                 k_fn(vc, KVAL(K_INSERT), 0);
 735                                 return;
 736                         case KVAL(K_P1):
 737                                 k_fn(vc, KVAL(K_SELECT), 0);
 738                                 return;
 739                         case KVAL(K_P2):
 740                                 k_cur(vc, KVAL(K_DOWN), 0);
 741                                 return;
 742                         case KVAL(K_P3):
 743                                 k_fn(vc, KVAL(K_PGDN), 0);
 744                                 return;
 745                         case KVAL(K_P4):
 746                                 k_cur(vc, KVAL(K_LEFT), 0);
 747                                 return;
 748                         case KVAL(K_P6):
 749                                 k_cur(vc, KVAL(K_RIGHT), 0);
 750                                 return;
 751                         case KVAL(K_P7):
 752                                 k_fn(vc, KVAL(K_FIND), 0);
 753                                 return;
 754                         case KVAL(K_P8):
 755                                 k_cur(vc, KVAL(K_UP), 0);
 756                                 return;
 757                         case KVAL(K_P9):
 758                                 k_fn(vc, KVAL(K_PGUP), 0);
 759                                 return;
 760                         case KVAL(K_P5):
 761                                 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
 762                                 return;
 763                 }
 764
 765         put_queue(vc, pad_chars[value]);
 766         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
 767                 put_queue(vc, 10);
 768 }
 769
 770 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
 771 {
 772         int old_state = shift_state;
 773
 774         if (rep)
 775                 return;
 776         /*
 777          * Mimic typewriter:
 778          * a CapsShift key acts like Shift but undoes CapsLock
 779          */
 780         if (value == KVAL(K_CAPSSHIFT)) {
 781                 value = KVAL(K_SHIFT);
 782                 if (!up_flag)
 783                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
 784         }
 785
 786         if (up_flag) {
 787                 /*
 788                  * handle the case that two shift or control
 789                  * keys are depressed simultaneously
 790                  */
 791                 if (shift_down[value])
 792                         shift_down[value]--;
 793         } else
 794                 shift_down[value]++;
 795
 796         if (shift_down[value])
 797                 shift_state |= (1 << value);
 798         else
 799                 shift_state &= ~(1 << value);
 800
 801         /* kludge */
 802         if (up_flag && shift_state != old_state && npadch != -1) {
 803                 if (kbd->kbdmode == VC_UNICODE)
 804                         to_utf8(vc, npadch & 0xffff);
 805                 else
 806                         put_queue(vc, npadch & 0xff);
 807                 npadch = -1;
 808         }
 809 }
 810
 811 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
 812 {
 813         if (up_flag)
 814                 return;
 815
 816         if (vc_kbd_mode(kbd, VC_META)) {
 817                 put_queue(vc, '\033');
 818                 put_queue(vc, value);
 819         } else
 820                 put_queue(vc, value | 0x80);
 821 }
 822
 823 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
 824 {
 825         int base;
 826
 827         if (up_flag)
 828                 return;
 829
 830         if (value < 10) {
 831                 /* decimal input of code, while Alt depressed */
 832                 base = 10;
 833         } else {
 834                 /* hexadecimal input of code, while AltGr depressed */
 835                 value -= 10;
 836                 base = 16;
 837         }
 838
 839         if (npadch == -1)
 840                 npadch = value;
 841         else
 842                 npadch = npadch * base + value;
 843 }
 844
 845 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
 846 {
 847         if (up_flag || rep)
 848                 return;
 849         chg_vc_kbd_lock(kbd, value);
 850 }
 851
 852 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
 853 {
 854         k_shift(vc, value, up_flag);
 855         if (up_flag || rep)
 856                 return;
 857         chg_vc_kbd_slock(kbd, value);
 858         /* try to make Alt, oops, AltGr and such work */
 859         if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
 860                 kbd->slockstate = 0;
 861                 chg_vc_kbd_slock(kbd, value);
 862         }
 863 }
 864
 865 /* by default, 300ms interval for combination release */
 866 static unsigned brl_timeout = 300;
 867 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
 868 module_param(brl_timeout, uint, 0644);
 869
 870 static unsigned brl_nbchords = 1;
 871 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
 872 module_param(brl_nbchords, uint, 0644);
 873
 874 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
 875 {
 876         static unsigned long chords;
 877         static unsigned committed;
 878
 879         if (!brl_nbchords)
 880                 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
 881         else {
 882                 committed |= pattern;
 883                 chords++;
 884                 if (chords == brl_nbchords) {
 885                         k_unicode(vc, BRL_UC_ROW | committed, up_flag);
 886                         chords = 0;
 887                         committed = 0;
 888                 }
 889         }
 890 }
 891
 892 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
 893 {
 894         static unsigned pressed,committing;
 895         static unsigned long releasestart;
 896
 897         if (kbd->kbdmode != VC_UNICODE) {
 898                 if (!up_flag)
 899                         printk("keyboard mode must be unicode for braille patterns\n");
 900                 return;
 901         }
 902
 903         if (!value) {
 904                 k_unicode(vc, BRL_UC_ROW, up_flag);
 905                 return;
 906         }
 907
 908         if (value > 8)
 909                 return;
 910
 911         if (up_flag) {
 912                 if (brl_timeout) {
 913                         if (!committing ||
 914                             jiffies - releasestart > (brl_timeout * HZ) / 1000) {
 915                                 committing = pressed;
 916                                 releasestart = jiffies;
 917                         }
 918                         pressed &= ~(1 << (value - 1));
 919                         if (!pressed) {
 920                                 if (committing) {
 921                                         k_brlcommit(vc, committing, 0);
 922                                         committing = 0;
 923                                 }
 924                         }
 925                 } else {
 926                         if (committing) {
 927                                 k_brlcommit(vc, committing, 0);
 928                                 committing = 0;
 929                         }
 930                         pressed &= ~(1 << (value - 1));
 931                 }
 932         } else {
 933                 pressed |= 1 << (value - 1);
 934                 if (!brl_timeout)
 935                         committing = pressed;
 936         }
 937 }
 938
 939 /*
 940  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
 941  * or (ii) whatever pattern of lights people want to show using KDSETLED,
 942  * or (iii) specified bits of specified words in kernel memory.
 943  */
 944 unsigned char getledstate(void)
 945 {
 946         return ledstate;
 947 }
 948
 949 void setledstate(struct kbd_struct *kbd, unsigned int led)
 950 {
 951         if (!(led & ~7)) {
 952                 ledioctl = led;
 953                 kbd->ledmode = LED_SHOW_IOCTL;
 954         } else
 955                 kbd->ledmode = LED_SHOW_FLAGS;
 956         set_leds();
 957 }
 958
 959 static inline unsigned char getleds(void)
 960 {
 961         struct kbd_struct *kbd = kbd_table + fg_console;
 962         unsigned char leds;
 963         int i;
 964
 965         if (kbd->ledmode == LED_SHOW_IOCTL)
 966                 return ledioctl;
 967
 968         leds = kbd->ledflagstate;
 969
 970         if (kbd->ledmode == LED_SHOW_MEM) {
 971                 for (i = 0; i < 3; i++)
 972                         if (ledptrs[i].valid) {
 973                                 if (*ledptrs[i].addr & ledptrs[i].mask)
 974                                         leds |= (1 << i);
 975                                 else
 976                                         leds &= ~(1 << i);
 977                         }
 978         }
 979         return leds;
 980 }
 981
 982 /*
 983  * This routine is the bottom half of the keyboard interrupt
 984  * routine, and runs with all interrupts enabled. It does
 985  * console changing, led setting and copy_to_cooked, which can
 986  * take a reasonably long time.
 987  *
 988  * Aside from timing (which isn't really that important for
 989  * keyboard interrupts as they happen often), using the software
 990  * interrupt routines for this thing allows us to easily mask
 991  * this when we don't want any of the above to happen.
 992  * This allows for easy and efficient race-condition prevention
 993  * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
 994  */
 995
 996 static void kbd_bh(unsigned long dummy)
 997 {
 998         struct list_head *node;
 999         unsigned char leds = getleds();
1000
1001         if (leds != ledstate) {
1002                 list_for_each(node, &kbd_handler.h_list) {
1003                         struct input_handle *handle = to_handle_h(node);
1004                         input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1005                         input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1006                         input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1007                         input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1008                 }
1009         }
1010
1011         ledstate = leds;
1012 }
1013
1014 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1015
1016 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1017     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1018     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1019     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1020
1021 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1022                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1023
1024 static const unsigned short x86_keycodes[256] =
1025         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1026          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1027          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1028          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1029          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1030          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1031         284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1032         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1033         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1034         103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1035         291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1036         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1037         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1038         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1039         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1040
1041 #ifdef CONFIG_MAC_EMUMOUSEBTN
1042 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1043 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1044
1045 #ifdef CONFIG_SPARC
1046 static int sparc_l1_a_state = 0;
1047 extern void sun_do_break(void);
1048 #endif
1049
1050 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1051                        unsigned char up_flag)
1052 {
1053         int code;
1054
1055         switch (keycode) {
1056                 case KEY_PAUSE:
1057                         put_queue(vc, 0xe1);
1058                         put_queue(vc, 0x1d | up_flag);
1059                         put_queue(vc, 0x45 | up_flag);
1060                         break;
1061
1062                 case KEY_HANGEUL:
1063                         if (!up_flag)
1064                                 put_queue(vc, 0xf2);
1065                         break;
1066
1067                 case KEY_HANJA:
1068                         if (!up_flag)
1069                                 put_queue(vc, 0xf1);
1070                         break;
1071
1072                 case KEY_SYSRQ:
1073                         /*
1074                          * Real AT keyboards (that's what we're trying
1075                          * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1076                          * pressing PrtSc/SysRq alone, but simply 0x54
1077                          * when pressing Alt+PrtSc/SysRq.
1078                          */
1079                         if (sysrq_alt) {
1080                                 put_queue(vc, 0x54 | up_flag);
1081                         } else {
1082                                 put_queue(vc, 0xe0);
1083                                 put_queue(vc, 0x2a | up_flag);
1084                                 put_queue(vc, 0xe0);
1085                                 put_queue(vc, 0x37 | up_flag);
1086                         }
1087                         break;
1088
1089                 default:
1090                         if (keycode > 255)
1091                                 return -1;
1092
1093                         code = x86_keycodes[keycode];
1094                         if (!code)
1095                                 return -1;
1096
1097                         if (code & 0x100)
1098                                 put_queue(vc, 0xe0);
1099                         put_queue(vc, (code & 0x7f) | up_flag);
1100
1101                         break;
1102         }
1103
1104         return 0;
1105 }
1106
1107 #else
1108
1109 #define HW_RAW(dev)     0
1110
1111 #warning "Cannot generate rawmode keyboard for your architecture yet."
1112
1113 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1114 {
1115         if (keycode > 127)
1116                 return -1;
1117
1118         put_queue(vc, keycode | up_flag);
1119         return 0;
1120 }
1121 #endif
1122
1123 static void kbd_rawcode(unsigned char data)
1124 {
1125         struct vc_data *vc = vc_cons[fg_console].d;
1126         kbd = kbd_table + fg_console;
1127         if (kbd->kbdmode == VC_RAW)
1128                 put_queue(vc, data);
1129 }
1130
1131 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1132 {
1133         struct vc_data *vc = vc_cons[fg_console].d;
1134         unsigned short keysym, *key_map;
1135         unsigned char type, raw_mode;
1136         struct tty_struct *tty;
1137         int shift_final;
1138
1139         tty = vc->vc_tty;
1140
1141         if (tty && (!tty->driver_data)) {
1142                 /* No driver data? Strange. Okay we fix it then. */
1143                 tty->driver_data = vc;
1144         }
1145
1146         kbd = kbd_table + fg_console;
1147
1148         if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1149                 sysrq_alt = down ? keycode : 0;
1150 #ifdef CONFIG_SPARC
1151         if (keycode == KEY_STOP)
1152                 sparc_l1_a_state = down;
1153 #endif
1154
1155         rep = (down == 2);
1156
1157 #ifdef CONFIG_MAC_EMUMOUSEBTN
1158         if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1159                 return;
1160 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1161
1162         if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1163                 if (emulate_raw(vc, keycode, !down << 7))
1164                         if (keycode < BTN_MISC)
1165                                 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1166
1167 #ifdef CONFIG_MAGIC_SYSRQ              /* Handle the SysRq Hack */
1168         if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1169                 if (!sysrq_down) {
1170                         sysrq_down = down;
1171                         sysrq_alt_use = sysrq_alt;
1172                 }
1173                 return;
1174         }
1175         if (sysrq_down && !down && keycode == sysrq_alt_use)
1176                 sysrq_down = 0;
1177         if (sysrq_down && down && !rep) {
1178                 handle_sysrq(kbd_sysrq_xlate[keycode], tty);
1179                 return;
1180         }
1181 #endif
1182 #ifdef CONFIG_SPARC
1183         if (keycode == KEY_A && sparc_l1_a_state) {
1184                 sparc_l1_a_state = 0;
1185                 sun_do_break();
1186         }
1187 #endif
1188
1189         if (kbd->kbdmode == VC_MEDIUMRAW) {
1190                 /*
1191                  * This is extended medium raw mode, with keys above 127
1192                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1193                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1194                  * interfere with anything else. The two bytes after 0 will
1195                  * always have the up flag set not to interfere with older
1196                  * applications. This allows for 16384 different keycodes,
1197                  * which should be enough.
1198                  */
1199                 if (keycode < 128) {
1200                         put_queue(vc, keycode | (!down << 7));
1201                 } else {
1202                         put_queue(vc, !down << 7);
1203                         put_queue(vc, (keycode >> 7) | 0x80);
1204                         put_queue(vc, keycode | 0x80);
1205                 }
1206                 raw_mode = 1;
1207         }
1208
1209         if (down)
1210                 set_bit(keycode, key_down);
1211         else
1212                 clear_bit(keycode, key_down);
1213
1214         if (rep &&
1215             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1216              (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1217                 /*
1218                  * Don't repeat a key if the input buffers are not empty and the
1219                  * characters get aren't echoed locally. This makes key repeat
1220                  * usable with slow applications and under heavy loads.
1221                  */
1222                 return;
1223         }
1224
1225         shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1226         key_map = key_maps[shift_final];
1227
1228         if (!key_map) {
1229                 compute_shiftstate();
1230                 kbd->slockstate = 0;
1231                 return;
1232         }
1233
1234         if (keycode > NR_KEYS)
1235                 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1236                         keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1237                 else
1238                         return;
1239         else
1240                 keysym = key_map[keycode];
1241
1242         type = KTYP(keysym);
1243
1244         if (type < 0xf0) {
1245                 if (down && !raw_mode)
1246                         to_utf8(vc, keysym);
1247                 return;
1248         }
1249
1250         type -= 0xf0;
1251
1252         if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1253                 return;
1254
1255         if (type == KT_LETTER) {
1256                 type = KT_LATIN;
1257                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1258                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1259                         if (key_map)
1260                                 keysym = key_map[keycode];
1261                 }
1262         }
1263
1264         (*k_handler[type])(vc, keysym & 0xff, !down);
1265
1266         if (type != KT_SLOCK)
1267                 kbd->slockstate = 0;
1268 }
1269
1270 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1271                       unsigned int event_code, int value)
1272 {
1273         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1274                 kbd_rawcode(value);
1275         if (event_type == EV_KEY)
1276                 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1277         tasklet_schedule(&keyboard_tasklet);
1278         do_poke_blanked_console = 1;
1279         schedule_console_callback();
1280 }
1281
1282 /*
1283  * When a keyboard (or other input device) is found, the kbd_connect
1284  * function is called. The function then looks at the device, and if it
1285  * likes it, it can open it and get events from it. In this (kbd_connect)
1286  * function, we should decide which VT to bind that keyboard to initially.
1287  */
1288 static struct input_handle *kbd_connect(struct input_handler *handler,
1289                                         struct input_dev *dev,
1290                                         const struct input_device_id *id)
1291 {
1292         struct input_handle *handle;
1293         int i;
1294
1295         for (i = KEY_RESERVED; i < BTN_MISC; i++)
1296                 if (test_bit(i, dev->keybit))
1297                         break;
1298
1299         if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1300                 return NULL;
1301
1302         handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1303         if (!handle)
1304                 return NULL;
1305
1306         handle->dev = dev;
1307         handle->handler = handler;
1308         handle->name = "kbd";
1309
1310         input_open_device(handle);
1311
1312         return handle;
1313 }
1314
1315 static void kbd_disconnect(struct input_handle *handle)
1316 {
1317         input_close_device(handle);
1318         kfree(handle);
1319 }
1320
1321 /*
1322  * Start keyboard handler on the new keyboard by refreshing LED state to
1323  * match the rest of the system.
1324  */
1325 static void kbd_start(struct input_handle *handle)
1326 {
1327         unsigned char leds = ledstate;
1328
1329         tasklet_disable(&keyboard_tasklet);
1330         if (leds != 0xff) {
1331                 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1332                 input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1333                 input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1334                 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1335         }
1336         tasklet_enable(&keyboard_tasklet);
1337 }
1338
1339 static const struct input_device_id kbd_ids[] = {
1340         {
1341                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1342                 .evbit = { BIT(EV_KEY) },
1343         },
1344
1345         {
1346                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1347                 .evbit = { BIT(EV_SND) },
1348         },
1349
1350         { },    /* Terminating entry */
1351 };
1352
1353 MODULE_DEVICE_TABLE(input, kbd_ids);
1354
1355 static struct input_handler kbd_handler = {
1356         .event          = kbd_event,
1357         .connect        = kbd_connect,
1358         .disconnect     = kbd_disconnect,
1359         .start          = kbd_start,
1360         .name           = "kbd",
1361         .id_table       = kbd_ids,
1362 };
1363
1364 int __init kbd_init(void)
1365 {
1366         int i;
1367         int error;
1368
1369         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1370                 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1371                 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1372                 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1373                 kbd_table[i].lockstate = KBD_DEFLOCK;
1374                 kbd_table[i].slockstate = 0;
1375                 kbd_table[i].modeflags = KBD_DEFMODE;
1376                 kbd_table[i].kbdmode = VC_XLATE;
1377         }
1378
1379         error = input_register_handler(&kbd_handler);
1380         if (error)
1381                 return error;
1382
1383         tasklet_enable(&keyboard_tasklet);
1384         tasklet_schedule(&keyboard_tasklet);
1385
1386         return 0;
1387 }