git.oblomov.eu Git - linux-2.6/blob - drivers/char/keyboard.c

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