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 long brl_timeout = 300;
 864 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for combination on first release, < 0 for dead characters)");
 865 module_param(brl_timeout, long, 0644);
 866 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 867 {
 868         static unsigned pressed,committing;
 869         static unsigned long releasestart;
 870
 871         if (kbd->kbdmode != VC_UNICODE) {
 872                 if (!up_flag)
 873                         printk("keyboard mode must be unicode for braille patterns\n");
 874                 return;
 875         }
 876
 877         if (!value) {
 878                 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
 879                 return;
 880         }
 881
 882         if (value > 8)
 883                 return;
 884
 885         if (brl_timeout < 0) {
 886                 k_deadunicode(vc, BRL_UC_ROW | (1 << (value - 1)), up_flag, regs);
 887                 return;
 888         }
 889
 890         if (up_flag) {
 891                 if (brl_timeout) {
 892                         if (!committing ||
 893                             jiffies - releasestart > (brl_timeout * HZ) / 1000) {
 894                                 committing = pressed;
 895                                 releasestart = jiffies;
 896                         }
 897                         pressed &= ~(1 << (value - 1));
 898                         if (!pressed) {
 899                                 if (committing) {
 900                                         k_unicode(vc, BRL_UC_ROW | committing, 0, regs);
 901                                         committing = 0;
 902                                 }
 903                         }
 904                 } else {
 905                         if (committing) {
 906                                 k_unicode(vc, BRL_UC_ROW | committing, 0, regs);
 907                                 committing = 0;
 908                         }
 909                         pressed &= ~(1 << (value - 1));
 910                 }
 911         } else {
 912                 pressed |= 1 << (value - 1);
 913                 if (!brl_timeout)
 914                         committing = pressed;
 915         }
 916 }
 917
 918 /*
 919  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
 920  * or (ii) whatever pattern of lights people want to show using KDSETLED,
 921  * or (iii) specified bits of specified words in kernel memory.
 922  */
 923 unsigned char getledstate(void)
 924 {
 925         return ledstate;
 926 }
 927
 928 void setledstate(struct kbd_struct *kbd, unsigned int led)
 929 {
 930         if (!(led & ~7)) {
 931                 ledioctl = led;
 932                 kbd->ledmode = LED_SHOW_IOCTL;
 933         } else
 934                 kbd->ledmode = LED_SHOW_FLAGS;
 935         set_leds();
 936 }
 937
 938 static inline unsigned char getleds(void)
 939 {
 940         struct kbd_struct *kbd = kbd_table + fg_console;
 941         unsigned char leds;
 942         int i;
 943
 944         if (kbd->ledmode == LED_SHOW_IOCTL)
 945                 return ledioctl;
 946
 947         leds = kbd->ledflagstate;
 948
 949         if (kbd->ledmode == LED_SHOW_MEM) {
 950                 for (i = 0; i < 3; i++)
 951                         if (ledptrs[i].valid) {
 952                                 if (*ledptrs[i].addr & ledptrs[i].mask)
 953                                         leds |= (1 << i);
 954                                 else
 955                                         leds &= ~(1 << i);
 956                         }
 957         }
 958         return leds;
 959 }
 960
 961 /*
 962  * This routine is the bottom half of the keyboard interrupt
 963  * routine, and runs with all interrupts enabled. It does
 964  * console changing, led setting and copy_to_cooked, which can
 965  * take a reasonably long time.
 966  *
 967  * Aside from timing (which isn't really that important for
 968  * keyboard interrupts as they happen often), using the software
 969  * interrupt routines for this thing allows us to easily mask
 970  * this when we don't want any of the above to happen.
 971  * This allows for easy and efficient race-condition prevention
 972  * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
 973  */
 974
 975 static void kbd_bh(unsigned long dummy)
 976 {
 977         struct list_head *node;
 978         unsigned char leds = getleds();
 979
 980         if (leds != ledstate) {
 981                 list_for_each(node, &kbd_handler.h_list) {
 982                         struct input_handle * handle = to_handle_h(node);
 983                         input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
 984                         input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
 985                         input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
 986                         input_sync(handle->dev);
 987                 }
 988         }
 989
 990         ledstate = leds;
 991 }
 992
 993 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
 994
 995 /*
 996  * This allows a newly plugged keyboard to pick the LED state.
 997  */
 998 static void kbd_refresh_leds(struct input_handle *handle)
 999 {
1000         unsigned char leds = ledstate;
1001
1002         tasklet_disable(&keyboard_tasklet);
1003         if (leds != 0xff) {
1004                 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1005                 input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
1006                 input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1007                 input_sync(handle->dev);
1008         }
1009         tasklet_enable(&keyboard_tasklet);
1010 }
1011
1012 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1013     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1014     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1015     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1016
1017 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1018                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1019
1020 static unsigned short x86_keycodes[256] =
1021         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1022          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1023          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1024          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1025          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1026          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1027         284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
1028         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1029         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1030         103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1031         291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1032         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1033         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1034         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1035         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1036
1037 #ifdef CONFIG_MAC_EMUMOUSEBTN
1038 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1039 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1040
1041 #ifdef CONFIG_SPARC
1042 static int sparc_l1_a_state = 0;
1043 extern void sun_do_break(void);
1044 #endif
1045
1046 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1047                        unsigned char up_flag)
1048 {
1049         if (keycode > 255 || !x86_keycodes[keycode])
1050                 return -1;
1051
1052         switch (keycode) {
1053                 case KEY_PAUSE:
1054                         put_queue(vc, 0xe1);
1055                         put_queue(vc, 0x1d | up_flag);
1056                         put_queue(vc, 0x45 | up_flag);
1057                         return 0;
1058                 case KEY_HANGUEL:
1059                         if (!up_flag) put_queue(vc, 0xf1);
1060                         return 0;
1061                 case KEY_HANJA:
1062                         if (!up_flag) put_queue(vc, 0xf2);
1063                         return 0;
1064         }
1065
1066         if (keycode == KEY_SYSRQ && sysrq_alt) {
1067                 put_queue(vc, 0x54 | up_flag);
1068                 return 0;
1069         }
1070
1071         if (x86_keycodes[keycode] & 0x100)
1072                 put_queue(vc, 0xe0);
1073
1074         put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1075
1076         if (keycode == KEY_SYSRQ) {
1077                 put_queue(vc, 0xe0);
1078                 put_queue(vc, 0x37 | up_flag);
1079         }
1080
1081         return 0;
1082 }
1083
1084 #else
1085
1086 #define HW_RAW(dev)     0
1087
1088 #warning "Cannot generate rawmode keyboard for your architecture yet."
1089
1090 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1091 {
1092         if (keycode > 127)
1093                 return -1;
1094
1095         put_queue(vc, keycode | up_flag);
1096         return 0;
1097 }
1098 #endif
1099
1100 static void kbd_rawcode(unsigned char data)
1101 {
1102         struct vc_data *vc = vc_cons[fg_console].d;
1103         kbd = kbd_table + fg_console;
1104         if (kbd->kbdmode == VC_RAW)
1105                 put_queue(vc, data);
1106 }
1107
1108 static void kbd_keycode(unsigned int keycode, int down,
1109                         int hw_raw, struct pt_regs *regs)
1110 {
1111         struct vc_data *vc = vc_cons[fg_console].d;
1112         unsigned short keysym, *key_map;
1113         unsigned char type, raw_mode;
1114         struct tty_struct *tty;
1115         int shift_final;
1116
1117         tty = vc->vc_tty;
1118
1119         if (tty && (!tty->driver_data)) {
1120                 /* No driver data? Strange. Okay we fix it then. */
1121                 tty->driver_data = vc;
1122         }
1123
1124         kbd = kbd_table + fg_console;
1125
1126         if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1127                 sysrq_alt = down;
1128 #ifdef CONFIG_SPARC
1129         if (keycode == KEY_STOP)
1130                 sparc_l1_a_state = down;
1131 #endif
1132
1133         rep = (down == 2);
1134
1135 #ifdef CONFIG_MAC_EMUMOUSEBTN
1136         if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1137                 return;
1138 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1139
1140         if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1141                 if (emulate_raw(vc, keycode, !down << 7))
1142                         if (keycode < BTN_MISC)
1143                                 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1144
1145 #ifdef CONFIG_MAGIC_SYSRQ              /* Handle the SysRq Hack */
1146         if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1147                 sysrq_down = down;
1148                 return;
1149         }
1150         if (sysrq_down && down && !rep) {
1151                 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1152                 return;
1153         }
1154 #endif
1155 #ifdef CONFIG_SPARC
1156         if (keycode == KEY_A && sparc_l1_a_state) {
1157                 sparc_l1_a_state = 0;
1158                 sun_do_break();
1159         }
1160 #endif
1161
1162         if (kbd->kbdmode == VC_MEDIUMRAW) {
1163                 /*
1164                  * This is extended medium raw mode, with keys above 127
1165                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1166                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1167                  * interfere with anything else. The two bytes after 0 will
1168                  * always have the up flag set not to interfere with older
1169                  * applications. This allows for 16384 different keycodes,
1170                  * which should be enough.
1171                  */
1172                 if (keycode < 128) {
1173                         put_queue(vc, keycode | (!down << 7));
1174                 } else {
1175                         put_queue(vc, !down << 7);
1176                         put_queue(vc, (keycode >> 7) | 0x80);
1177                         put_queue(vc, keycode | 0x80);
1178                 }
1179                 raw_mode = 1;
1180         }
1181
1182         if (down)
1183                 set_bit(keycode, key_down);
1184         else
1185                 clear_bit(keycode, key_down);
1186
1187         if (rep &&
1188             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1189              (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1190                 /*
1191                  * Don't repeat a key if the input buffers are not empty and the
1192                  * characters get aren't echoed locally. This makes key repeat
1193                  * usable with slow applications and under heavy loads.
1194                  */
1195                 return;
1196         }
1197
1198         shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1199         key_map = key_maps[shift_final];
1200
1201         if (!key_map) {
1202                 compute_shiftstate();
1203                 kbd->slockstate = 0;
1204                 return;
1205         }
1206
1207         if (keycode > NR_KEYS)
1208                 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1209                         keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1210                 else
1211                         return;
1212         else
1213                 keysym = key_map[keycode];
1214
1215         type = KTYP(keysym);
1216
1217         if (type < 0xf0) {
1218                 if (down && !raw_mode)
1219                         to_utf8(vc, keysym);
1220                 return;
1221         }
1222
1223         type -= 0xf0;
1224
1225         if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1226                 return;
1227
1228         if (type == KT_LETTER) {
1229                 type = KT_LATIN;
1230                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1231                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1232                         if (key_map)
1233                                 keysym = key_map[keycode];
1234                 }
1235         }
1236
1237         (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1238
1239         if (type != KT_SLOCK)
1240                 kbd->slockstate = 0;
1241 }
1242
1243 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1244                       unsigned int event_code, int value)
1245 {
1246         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1247                 kbd_rawcode(value);
1248         if (event_type == EV_KEY)
1249                 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1250         tasklet_schedule(&keyboard_tasklet);
1251         do_poke_blanked_console = 1;
1252         schedule_console_callback();
1253 }
1254
1255 /*
1256  * When a keyboard (or other input device) is found, the kbd_connect
1257  * function is called. The function then looks at the device, and if it
1258  * likes it, it can open it and get events from it. In this (kbd_connect)
1259  * function, we should decide which VT to bind that keyboard to initially.
1260  */
1261 static struct input_handle *kbd_connect(struct input_handler *handler,
1262                                         struct input_dev *dev,
1263                                         struct input_device_id *id)
1264 {
1265         struct input_handle *handle;
1266         int i;
1267
1268         for (i = KEY_RESERVED; i < BTN_MISC; i++)
1269                 if (test_bit(i, dev->keybit))
1270                         break;
1271
1272         if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1273                 return NULL;
1274
1275         if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1276                 return NULL;
1277         memset(handle, 0, sizeof(struct input_handle));
1278
1279         handle->dev = dev;
1280         handle->handler = handler;
1281         handle->name = "kbd";
1282
1283         input_open_device(handle);
1284         kbd_refresh_leds(handle);
1285
1286         return handle;
1287 }
1288
1289 static void kbd_disconnect(struct input_handle *handle)
1290 {
1291         input_close_device(handle);
1292         kfree(handle);
1293 }
1294
1295 static struct input_device_id kbd_ids[] = {
1296         {
1297                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1298                 .evbit = { BIT(EV_KEY) },
1299         },
1300
1301         {
1302                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1303                 .evbit = { BIT(EV_SND) },
1304         },
1305
1306         { },    /* Terminating entry */
1307 };
1308
1309 MODULE_DEVICE_TABLE(input, kbd_ids);
1310
1311 static struct input_handler kbd_handler = {
1312         .event          = kbd_event,
1313         .connect        = kbd_connect,
1314         .disconnect     = kbd_disconnect,
1315         .name           = "kbd",
1316         .id_table       = kbd_ids,
1317 };
1318
1319 int __init kbd_init(void)
1320 {
1321         int i;
1322
1323         kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1324         kbd0.ledmode = LED_SHOW_FLAGS;
1325         kbd0.lockstate = KBD_DEFLOCK;
1326         kbd0.slockstate = 0;
1327         kbd0.modeflags = KBD_DEFMODE;
1328         kbd0.kbdmode = VC_XLATE;
1329
1330         for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1331                 kbd_table[i] = kbd0;
1332
1333         input_register_handler(&kbd_handler);
1334
1335         tasklet_enable(&keyboard_tasklet);
1336         tasklet_schedule(&keyboard_tasklet);
1337
1338         return 0;
1339 }