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 #include <linux/reboot.h>
  43
  44 static void kbd_disconnect(struct input_handle *handle);
  45 extern void ctrl_alt_del(void);
  46
  47 /*
  48  * Exported functions/variables
  49  */
  50
  51 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  52
  53 /*
  54  * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
  55  * This seems a good reason to start with NumLock off. On HIL keyboards
  56  * of PARISC machines however there is no NumLock key and everyone expects the keypad
  57  * to be used for numbers.
  58  */
  59
  60 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
  61 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
  62 #else
  63 #define KBD_DEFLEDS 0
  64 #endif
  65
  66 #define KBD_DEFLOCK 0
  67
  68 void compute_shiftstate(void);
  69
  70 /*
  71  * Handler Tables.
  72  */
  73
  74 #define K_HANDLERS\
  75         k_self,         k_fn,           k_spec,         k_pad,\
  76         k_dead,         k_cons,         k_cur,          k_shift,\
  77         k_meta,         k_ascii,        k_lock,         k_lowercase,\
  78         k_slock,        k_dead2,        k_brl,          k_ignore
  79
  80 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
  81                             char up_flag, struct pt_regs *regs);
  82 static k_handler_fn K_HANDLERS;
  83 static k_handler_fn *k_handler[16] = { K_HANDLERS };
  84
  85 #define FN_HANDLERS\
  86         fn_null,        fn_enter,       fn_show_ptregs, fn_show_mem,\
  87         fn_show_state,  fn_send_intr,   fn_lastcons,    fn_caps_toggle,\
  88         fn_num,         fn_hold,        fn_scroll_forw, fn_scroll_back,\
  89         fn_boot_it,     fn_caps_on,     fn_compose,     fn_SAK,\
  90         fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
  91
  92 typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
  93 static fn_handler_fn FN_HANDLERS;
  94 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
  95
  96 /*
  97  * Variables exported for vt_ioctl.c
  98  */
  99
 100 /* maximum values each key_handler can handle */
 101 const int max_vals[] = {
 102         255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
 103         NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
 104         255, NR_LOCK - 1, 255, NR_BRL - 1
 105 };
 106
 107 const int NR_TYPES = ARRAY_SIZE(max_vals);
 108
 109 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 110 static struct kbd_struct *kbd = kbd_table;
 111 static struct kbd_struct kbd0;
 112
 113 int spawnpid, spawnsig;
 114
 115 /*
 116  * Variables exported for vt.c
 117  */
 118
 119 int shift_state = 0;
 120
 121 /*
 122  * Internal Data.
 123  */
 124
 125 static struct input_handler kbd_handler;
 126 static unsigned long key_down[NBITS(KEY_MAX)];          /* keyboard key bitmap */
 127 static unsigned char shift_down[NR_SHIFT];              /* shift state counters.. */
 128 static int dead_key_next;
 129 static int npadch = -1;                                 /* -1 or number assembled on pad */
 130 static unsigned int diacr;
 131 static char rep;                                        /* flag telling character repeat */
 132
 133 static unsigned char ledstate = 0xff;                   /* undefined */
 134 static unsigned char ledioctl;
 135
 136 static struct ledptr {
 137         unsigned int *addr;
 138         unsigned int mask;
 139         unsigned char valid:1;
 140 } ledptrs[3];
 141
 142 /* Simple translation table for the SysRq keys */
 143
 144 #ifdef CONFIG_MAGIC_SYSRQ
 145 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
 146         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
 147         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
 148         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
 149         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
 150         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
 151         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
 152         "\r\000/";                                      /* 0x60 - 0x6f */
 153 static int sysrq_down;
 154 static int sysrq_alt_use;
 155 #endif
 156 static int sysrq_alt;
 157
 158 /*
 159  * Translation of scancodes to keycodes. We set them on only the first attached
 160  * keyboard - for per-keyboard setting, /dev/input/event is more useful.
 161  */
 162 int getkeycode(unsigned int scancode)
 163 {
 164         struct list_head *node;
 165         struct input_dev *dev = NULL;
 166
 167         list_for_each(node, &kbd_handler.h_list) {
 168                 struct input_handle *handle = to_handle_h(node);
 169                 if (handle->dev->keycodesize) {
 170                         dev = handle->dev;
 171                         break;
 172                 }
 173         }
 174
 175         if (!dev)
 176                 return -ENODEV;
 177
 178         if (scancode >= dev->keycodemax)
 179                 return -EINVAL;
 180
 181         return INPUT_KEYCODE(dev, scancode);
 182 }
 183
 184 int setkeycode(unsigned int scancode, unsigned int keycode)
 185 {
 186         struct list_head *node;
 187         struct input_dev *dev = NULL;
 188         unsigned int i, oldkey;
 189
 190         list_for_each(node, &kbd_handler.h_list) {
 191                 struct input_handle *handle = to_handle_h(node);
 192                 if (handle->dev->keycodesize) {
 193                         dev = handle->dev;
 194                         break;
 195                 }
 196         }
 197
 198         if (!dev)
 199                 return -ENODEV;
 200
 201         if (scancode >= dev->keycodemax)
 202                 return -EINVAL;
 203         if (keycode < 0 || keycode > KEY_MAX)
 204                 return -EINVAL;
 205         if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
 206                 return -EINVAL;
 207
 208         oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
 209
 210         clear_bit(oldkey, dev->keybit);
 211         set_bit(keycode, dev->keybit);
 212
 213         for (i = 0; i < dev->keycodemax; i++)
 214                 if (INPUT_KEYCODE(dev,i) == oldkey)
 215                         set_bit(oldkey, dev->keybit);
 216
 217         return 0;
 218 }
 219
 220 /*
 221  * Making beeps and bells.
 222  */
 223 static void kd_nosound(unsigned long ignored)
 224 {
 225         struct list_head *node;
 226
 227         list_for_each(node,&kbd_handler.h_list) {
 228                 struct input_handle *handle = to_handle_h(node);
 229                 if (test_bit(EV_SND, handle->dev->evbit)) {
 230                         if (test_bit(SND_TONE, handle->dev->sndbit))
 231                                 input_event(handle->dev, EV_SND, SND_TONE, 0);
 232                         if (test_bit(SND_BELL, handle->dev->sndbit))
 233                                 input_event(handle->dev, EV_SND, SND_BELL, 0);
 234                 }
 235         }
 236 }
 237
 238 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
 239
 240 void kd_mksound(unsigned int hz, unsigned int ticks)
 241 {
 242         struct list_head *node;
 243
 244         del_timer(&kd_mksound_timer);
 245
 246         if (hz) {
 247                 list_for_each_prev(node, &kbd_handler.h_list) {
 248                         struct input_handle *handle = to_handle_h(node);
 249                         if (test_bit(EV_SND, handle->dev->evbit)) {
 250                                 if (test_bit(SND_TONE, handle->dev->sndbit)) {
 251                                         input_event(handle->dev, EV_SND, SND_TONE, hz);
 252                                         break;
 253                                 }
 254                                 if (test_bit(SND_BELL, handle->dev->sndbit)) {
 255                                         input_event(handle->dev, EV_SND, SND_BELL, 1);
 256                                         break;
 257                                 }
 258                         }
 259                 }
 260                 if (ticks)
 261                         mod_timer(&kd_mksound_timer, jiffies + ticks);
 262         } else
 263                 kd_nosound(0);
 264 }
 265
 266 /*
 267  * Setting the keyboard rate.
 268  */
 269
 270 int kbd_rate(struct kbd_repeat *rep)
 271 {
 272         struct list_head *node;
 273         unsigned int d = 0;
 274         unsigned int p = 0;
 275
 276         list_for_each(node,&kbd_handler.h_list) {
 277                 struct input_handle *handle = to_handle_h(node);
 278                 struct input_dev *dev = handle->dev;
 279
 280                 if (test_bit(EV_REP, dev->evbit)) {
 281                         if (rep->delay > 0)
 282                                 input_event(dev, EV_REP, REP_DELAY, rep->delay);
 283                         if (rep->period > 0)
 284                                 input_event(dev, EV_REP, REP_PERIOD, rep->period);
 285                         d = dev->rep[REP_DELAY];
 286                         p = dev->rep[REP_PERIOD];
 287                 }
 288         }
 289         rep->delay  = d;
 290         rep->period = p;
 291         return 0;
 292 }
 293
 294 /*
 295  * Helper Functions.
 296  */
 297 static void put_queue(struct vc_data *vc, int ch)
 298 {
 299         struct tty_struct *tty = vc->vc_tty;
 300
 301         if (tty) {
 302                 tty_insert_flip_char(tty, ch, 0);
 303                 con_schedule_flip(tty);
 304         }
 305 }
 306
 307 static void puts_queue(struct vc_data *vc, char *cp)
 308 {
 309         struct tty_struct *tty = vc->vc_tty;
 310
 311         if (!tty)
 312                 return;
 313
 314         while (*cp) {
 315                 tty_insert_flip_char(tty, *cp, 0);
 316                 cp++;
 317         }
 318         con_schedule_flip(tty);
 319 }
 320
 321 static void applkey(struct vc_data *vc, int key, char mode)
 322 {
 323         static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
 324
 325         buf[1] = (mode ? 'O' : '[');
 326         buf[2] = key;
 327         puts_queue(vc, buf);
 328 }
 329
 330 /*
 331  * Many other routines do put_queue, but I think either
 332  * they produce ASCII, or they produce some user-assigned
 333  * string, and in both cases we might assume that it is
 334  * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
 335  * but we need only 16 bits here
 336  */
 337 static void to_utf8(struct vc_data *vc, ushort c)
 338 {
 339         if (c < 0x80)
 340                 /*  0******* */
 341                 put_queue(vc, c);
 342         else if (c < 0x800) {
 343                 /* 110***** 10****** */
 344                 put_queue(vc, 0xc0 | (c >> 6));
 345                 put_queue(vc, 0x80 | (c & 0x3f));
 346         } else {
 347                 /* 1110**** 10****** 10****** */
 348                 put_queue(vc, 0xe0 | (c >> 12));
 349                 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
 350                 put_queue(vc, 0x80 | (c & 0x3f));
 351         }
 352 }
 353
 354 /*
 355  * Called after returning from RAW mode or when changing consoles - recompute
 356  * shift_down[] and shift_state from key_down[] maybe called when keymap is
 357  * undefined, so that shiftkey release is seen
 358  */
 359 void compute_shiftstate(void)
 360 {
 361         unsigned int i, j, k, sym, val;
 362
 363         shift_state = 0;
 364         memset(shift_down, 0, sizeof(shift_down));
 365
 366         for (i = 0; i < ARRAY_SIZE(key_down); i++) {
 367
 368                 if (!key_down[i])
 369                         continue;
 370
 371                 k = i * BITS_PER_LONG;
 372
 373                 for (j = 0; j < BITS_PER_LONG; j++, k++) {
 374
 375                         if (!test_bit(k, key_down))
 376                                 continue;
 377
 378                         sym = U(key_maps[0][k]);
 379                         if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
 380                                 continue;
 381
 382                         val = KVAL(sym);
 383                         if (val == KVAL(K_CAPSSHIFT))
 384                                 val = KVAL(K_SHIFT);
 385
 386                         shift_down[val]++;
 387                         shift_state |= (1 << val);
 388                 }
 389         }
 390 }
 391
 392 /*
 393  * We have a combining character DIACR here, followed by the character CH.
 394  * If the combination occurs in the table, return the corresponding value.
 395  * Otherwise, if CH is a space or equals DIACR, return DIACR.
 396  * Otherwise, conclude that DIACR was not combining after all,
 397  * queue it and return CH.
 398  */
 399 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
 400 {
 401         unsigned int d = diacr;
 402         unsigned int i;
 403
 404         diacr = 0;
 405
 406         if ((d & ~0xff) == BRL_UC_ROW) {
 407                 if ((ch & ~0xff) == BRL_UC_ROW)
 408                         return d | ch;
 409         } else {
 410                 for (i = 0; i < accent_table_size; i++)
 411                         if (accent_table[i].diacr == d && accent_table[i].base == ch)
 412                                 return accent_table[i].result;
 413         }
 414
 415         if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
 416                 return d;
 417
 418         if (kbd->kbdmode == VC_UNICODE)
 419                 to_utf8(vc, d);
 420         else if (d < 0x100)
 421                 put_queue(vc, d);
 422
 423         return ch;
 424 }
 425
 426 /*
 427  * Special function handlers
 428  */
 429 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
 430 {
 431         if (diacr) {
 432                 if (kbd->kbdmode == VC_UNICODE)
 433                         to_utf8(vc, diacr);
 434                 else if (diacr < 0x100)
 435                         put_queue(vc, diacr);
 436                 diacr = 0;
 437         }
 438         put_queue(vc, 13);
 439         if (vc_kbd_mode(kbd, VC_CRLF))
 440                 put_queue(vc, 10);
 441 }
 442
 443 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
 444 {
 445         if (rep)
 446                 return;
 447         chg_vc_kbd_led(kbd, VC_CAPSLOCK);
 448 }
 449
 450 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
 451 {
 452         if (rep)
 453                 return;
 454         set_vc_kbd_led(kbd, VC_CAPSLOCK);
 455 }
 456
 457 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
 458 {
 459         if (regs)
 460                 show_regs(regs);
 461 }
 462
 463 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
 464 {
 465         struct tty_struct *tty = vc->vc_tty;
 466
 467         if (rep || !tty)
 468                 return;
 469
 470         /*
 471          * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
 472          * these routines are also activated by ^S/^Q.
 473          * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
 474          */
 475         if (tty->stopped)
 476                 start_tty(tty);
 477         else
 478                 stop_tty(tty);
 479 }
 480
 481 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
 482 {
 483         if (vc_kbd_mode(kbd,VC_APPLIC))
 484                 applkey(vc, 'P', 1);
 485         else
 486                 fn_bare_num(vc, regs);
 487 }
 488
 489 /*
 490  * Bind this to Shift-NumLock if you work in application keypad mode
 491  * but want to be able to change the NumLock flag.
 492  * Bind this to NumLock if you prefer that the NumLock key always
 493  * changes the NumLock flag.
 494  */
 495 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
 496 {
 497         if (!rep)
 498                 chg_vc_kbd_led(kbd, VC_NUMLOCK);
 499 }
 500
 501 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
 502 {
 503         /* switch to the last used console, ChN */
 504         set_console(last_console);
 505 }
 506
 507 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
 508 {
 509         int i, cur = fg_console;
 510
 511         /* Currently switching?  Queue this next switch relative to that. */
 512         if (want_console != -1)
 513                 cur = want_console;
 514
 515         for (i = cur - 1; i != cur; i--) {
 516                 if (i == -1)
 517                         i = MAX_NR_CONSOLES - 1;
 518                 if (vc_cons_allocated(i))
 519                         break;
 520         }
 521         set_console(i);
 522 }
 523
 524 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
 525 {
 526         int i, cur = fg_console;
 527
 528         /* Currently switching?  Queue this next switch relative to that. */
 529         if (want_console != -1)
 530                 cur = want_console;
 531
 532         for (i = cur+1; i != cur; i++) {
 533                 if (i == MAX_NR_CONSOLES)
 534                         i = 0;
 535                 if (vc_cons_allocated(i))
 536                         break;
 537         }
 538         set_console(i);
 539 }
 540
 541 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
 542 {
 543         struct tty_struct *tty = vc->vc_tty;
 544
 545         if (!tty)
 546                 return;
 547         tty_insert_flip_char(tty, 0, TTY_BREAK);
 548         con_schedule_flip(tty);
 549 }
 550
 551 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
 552 {
 553         scrollfront(vc, 0);
 554 }
 555
 556 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
 557 {
 558         scrollback(vc, 0);
 559 }
 560
 561 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
 562 {
 563         show_mem();
 564 }
 565
 566 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
 567 {
 568         show_state();
 569 }
 570
 571 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
 572 {
 573         ctrl_alt_del();
 574 }
 575
 576 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
 577 {
 578         dead_key_next = 1;
 579 }
 580
 581 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
 582 {
 583         if (spawnpid)
 584                 if (kill_proc(spawnpid, spawnsig, 1))
 585                         spawnpid = 0;
 586 }
 587
 588 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
 589 {
 590         struct tty_struct *tty = vc->vc_tty;
 591
 592         /*
 593          * SAK should also work in all raw modes and reset
 594          * them properly.
 595          */
 596         if (tty)
 597                 do_SAK(tty);
 598         reset_vc(vc);
 599 }
 600
 601 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
 602 {
 603         compute_shiftstate();
 604 }
 605
 606 /*
 607  * Special key handlers
 608  */
 609 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 610 {
 611 }
 612
 613 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 614 {
 615         if (up_flag)
 616                 return;
 617         if (value >= ARRAY_SIZE(fn_handler))
 618                 return;
 619         if ((kbd->kbdmode == VC_RAW ||
 620              kbd->kbdmode == VC_MEDIUMRAW) &&
 621              value != KVAL(K_SAK))
 622                 return;         /* SAK is allowed even in raw mode */
 623         fn_handler[value](vc, regs);
 624 }
 625
 626 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 627 {
 628         printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
 629 }
 630
 631 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
 632 {
 633         if (up_flag)
 634                 return;         /* no action, if this is a key release */
 635
 636         if (diacr)
 637                 value = handle_diacr(vc, value);
 638
 639         if (dead_key_next) {
 640                 dead_key_next = 0;
 641                 diacr = value;
 642                 return;
 643         }
 644         if (kbd->kbdmode == VC_UNICODE)
 645                 to_utf8(vc, value);
 646         else if (value < 0x100)
 647                 put_queue(vc, value);
 648 }
 649
 650 /*
 651  * Handle dead key. Note that we now may have several
 652  * dead keys modifying the same character. Very useful
 653  * for Vietnamese.
 654  */
 655 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
 656 {
 657         if (up_flag)
 658                 return;
 659         diacr = (diacr ? handle_diacr(vc, value) : value);
 660 }
 661
 662 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 663 {
 664         k_unicode(vc, value, up_flag, regs);
 665 }
 666
 667 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 668 {
 669         k_deadunicode(vc, value, up_flag, regs);
 670 }
 671
 672 /*
 673  * Obsolete - for backwards compatibility only
 674  */
 675 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 676 {
 677         static unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
 678         value = ret_diacr[value];
 679         k_deadunicode(vc, value, up_flag, regs);
 680 }
 681
 682 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 683 {
 684         if (up_flag)
 685                 return;
 686         set_console(value);
 687 }
 688
 689 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 690 {
 691         unsigned v;
 692
 693         if (up_flag)
 694                 return;
 695         v = value;
 696         if (v < ARRAY_SIZE(func_table)) {
 697                 if (func_table[value])
 698                         puts_queue(vc, func_table[value]);
 699         } else
 700                 printk(KERN_ERR "k_fn called with value=%d\n", value);
 701 }
 702
 703 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 704 {
 705         static const char *cur_chars = "BDCA";
 706
 707         if (up_flag)
 708                 return;
 709         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 710 }
 711
 712 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 713 {
 714         static const char *pad_chars = "0123456789+-*/\015,.?()#";
 715         static const char *app_map = "pqrstuvwxylSRQMnnmPQS";
 716
 717         if (up_flag)
 718                 return;         /* no action, if this is a key release */
 719
 720         /* kludge... shift forces cursor/number keys */
 721         if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
 722                 applkey(vc, app_map[value], 1);
 723                 return;
 724         }
 725
 726         if (!vc_kbd_led(kbd, VC_NUMLOCK))
 727                 switch (value) {
 728                         case KVAL(K_PCOMMA):
 729                         case KVAL(K_PDOT):
 730                                 k_fn(vc, KVAL(K_REMOVE), 0, regs);
 731                                 return;
 732                         case KVAL(K_P0):
 733                                 k_fn(vc, KVAL(K_INSERT), 0, regs);
 734                                 return;
 735                         case KVAL(K_P1):
 736                                 k_fn(vc, KVAL(K_SELECT), 0, regs);
 737                                 return;
 738                         case KVAL(K_P2):
 739                                 k_cur(vc, KVAL(K_DOWN), 0, regs);
 740                                 return;
 741                         case KVAL(K_P3):
 742                                 k_fn(vc, KVAL(K_PGDN), 0, regs);
 743                                 return;
 744                         case KVAL(K_P4):
 745                                 k_cur(vc, KVAL(K_LEFT), 0, regs);
 746                                 return;
 747                         case KVAL(K_P6):
 748                                 k_cur(vc, KVAL(K_RIGHT), 0, regs);
 749                                 return;
 750                         case KVAL(K_P7):
 751                                 k_fn(vc, KVAL(K_FIND), 0, regs);
 752                                 return;
 753                         case KVAL(K_P8):
 754                                 k_cur(vc, KVAL(K_UP), 0, regs);
 755                                 return;
 756                         case KVAL(K_P9):
 757                                 k_fn(vc, KVAL(K_PGUP), 0, regs);
 758                                 return;
 759                         case KVAL(K_P5):
 760                                 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
 761                                 return;
 762                 }
 763
 764         put_queue(vc, pad_chars[value]);
 765         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
 766                 put_queue(vc, 10);
 767 }
 768
 769 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 770 {
 771         int old_state = shift_state;
 772
 773         if (rep)
 774                 return;
 775         /*
 776          * Mimic typewriter:
 777          * a CapsShift key acts like Shift but undoes CapsLock
 778          */
 779         if (value == KVAL(K_CAPSSHIFT)) {
 780                 value = KVAL(K_SHIFT);
 781                 if (!up_flag)
 782                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
 783         }
 784
 785         if (up_flag) {
 786                 /*
 787                  * handle the case that two shift or control
 788                  * keys are depressed simultaneously
 789                  */
 790                 if (shift_down[value])
 791                         shift_down[value]--;
 792         } else
 793                 shift_down[value]++;
 794
 795         if (shift_down[value])
 796                 shift_state |= (1 << value);
 797         else
 798                 shift_state &= ~(1 << value);
 799
 800         /* kludge */
 801         if (up_flag && shift_state != old_state && npadch != -1) {
 802                 if (kbd->kbdmode == VC_UNICODE)
 803                         to_utf8(vc, npadch & 0xffff);
 804                 else
 805                         put_queue(vc, npadch & 0xff);
 806                 npadch = -1;
 807         }
 808 }
 809
 810 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 811 {
 812         if (up_flag)
 813                 return;
 814
 815         if (vc_kbd_mode(kbd, VC_META)) {
 816                 put_queue(vc, '\033');
 817                 put_queue(vc, value);
 818         } else
 819                 put_queue(vc, value | 0x80);
 820 }
 821
 822 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 823 {
 824         int base;
 825
 826         if (up_flag)
 827                 return;
 828
 829         if (value < 10) {
 830                 /* decimal input of code, while Alt depressed */
 831                 base = 10;
 832         } else {
 833                 /* hexadecimal input of code, while AltGr depressed */
 834                 value -= 10;
 835                 base = 16;
 836         }
 837
 838         if (npadch == -1)
 839                 npadch = value;
 840         else
 841                 npadch = npadch * base + value;
 842 }
 843
 844 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 845 {
 846         if (up_flag || rep)
 847                 return;
 848         chg_vc_kbd_lock(kbd, value);
 849 }
 850
 851 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 852 {
 853         k_shift(vc, value, up_flag, regs);
 854         if (up_flag || rep)
 855                 return;
 856         chg_vc_kbd_slock(kbd, value);
 857         /* try to make Alt, oops, AltGr and such work */
 858         if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
 859                 kbd->slockstate = 0;
 860                 chg_vc_kbd_slock(kbd, value);
 861         }
 862 }
 863
 864 /* by default, 300ms interval for combination release */
 865 static unsigned brl_timeout = 300;
 866 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
 867 module_param(brl_timeout, uint, 0644);
 868
 869 static unsigned brl_nbchords = 1;
 870 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
 871 module_param(brl_nbchords, uint, 0644);
 872
 873 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag, struct pt_regs *regs)
 874 {
 875         static unsigned long chords;
 876         static unsigned committed;
 877
 878         if (!brl_nbchords)
 879                 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag, regs);
 880         else {
 881                 committed |= pattern;
 882                 chords++;
 883                 if (chords == brl_nbchords) {
 884                         k_unicode(vc, BRL_UC_ROW | committed, up_flag, regs);
 885                         chords = 0;
 886                         committed = 0;
 887                 }
 888         }
 889 }
 890
 891 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 892 {
 893         static unsigned pressed,committing;
 894         static unsigned long releasestart;
 895
 896         if (kbd->kbdmode != VC_UNICODE) {
 897                 if (!up_flag)
 898                         printk("keyboard mode must be unicode for braille patterns\n");
 899                 return;
 900         }
 901
 902         if (!value) {
 903                 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
 904                 return;
 905         }
 906
 907         if (value > 8)
 908                 return;
 909
 910         if (up_flag) {
 911                 if (brl_timeout) {
 912                         if (!committing ||
 913                             jiffies - releasestart > (brl_timeout * HZ) / 1000) {
 914                                 committing = pressed;
 915                                 releasestart = jiffies;
 916                         }
 917                         pressed &= ~(1 << (value - 1));
 918                         if (!pressed) {
 919                                 if (committing) {
 920                                         k_brlcommit(vc, committing, 0, regs);
 921                                         committing = 0;
 922                                 }
 923                         }
 924                 } else {
 925                         if (committing) {
 926                                 k_brlcommit(vc, committing, 0, regs);
 927                                 committing = 0;
 928                         }
 929                         pressed &= ~(1 << (value - 1));
 930                 }
 931         } else {
 932                 pressed |= 1 << (value - 1);
 933                 if (!brl_timeout)
 934                         committing = pressed;
 935         }
 936 }
 937
 938 /*
 939  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
 940  * or (ii) whatever pattern of lights people want to show using KDSETLED,
 941  * or (iii) specified bits of specified words in kernel memory.
 942  */
 943 unsigned char getledstate(void)
 944 {
 945         return ledstate;
 946 }
 947
 948 void setledstate(struct kbd_struct *kbd, unsigned int led)
 949 {
 950         if (!(led & ~7)) {
 951                 ledioctl = led;
 952                 kbd->ledmode = LED_SHOW_IOCTL;
 953         } else
 954                 kbd->ledmode = LED_SHOW_FLAGS;
 955         set_leds();
 956 }
 957
 958 static inline unsigned char getleds(void)
 959 {
 960         struct kbd_struct *kbd = kbd_table + fg_console;
 961         unsigned char leds;
 962         int i;
 963
 964         if (kbd->ledmode == LED_SHOW_IOCTL)
 965                 return ledioctl;
 966
 967         leds = kbd->ledflagstate;
 968
 969         if (kbd->ledmode == LED_SHOW_MEM) {
 970                 for (i = 0; i < 3; i++)
 971                         if (ledptrs[i].valid) {
 972                                 if (*ledptrs[i].addr & ledptrs[i].mask)
 973                                         leds |= (1 << i);
 974                                 else
 975                                         leds &= ~(1 << i);
 976                         }
 977         }
 978         return leds;
 979 }
 980
 981 /*
 982  * This routine is the bottom half of the keyboard interrupt
 983  * routine, and runs with all interrupts enabled. It does
 984  * console changing, led setting and copy_to_cooked, which can
 985  * take a reasonably long time.
 986  *
 987  * Aside from timing (which isn't really that important for
 988  * keyboard interrupts as they happen often), using the software
 989  * interrupt routines for this thing allows us to easily mask
 990  * this when we don't want any of the above to happen.
 991  * This allows for easy and efficient race-condition prevention
 992  * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
 993  */
 994
 995 static void kbd_bh(unsigned long dummy)
 996 {
 997         struct list_head *node;
 998         unsigned char leds = getleds();
 999
1000         if (leds != ledstate) {
1001                 list_for_each(node, &kbd_handler.h_list) {
1002                         struct input_handle * handle = to_handle_h(node);
1003                         input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1004                         input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
1005                         input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1006                         input_sync(handle->dev);
1007                 }
1008         }
1009
1010         ledstate = leds;
1011 }
1012
1013 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1014
1015 /*
1016  * This allows a newly plugged keyboard to pick the LED state.
1017  */
1018 static void kbd_refresh_leds(struct input_handle *handle)
1019 {
1020         unsigned char leds = ledstate;
1021
1022         tasklet_disable(&keyboard_tasklet);
1023         if (leds != 0xff) {
1024                 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1025                 input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
1026                 input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1027                 input_sync(handle->dev);
1028         }
1029         tasklet_enable(&keyboard_tasklet);
1030 }
1031
1032 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1033     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1034     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1035     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1036
1037 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1038                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1039
1040 static unsigned short x86_keycodes[256] =
1041         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1042          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1043          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1044          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1045          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1046          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1047         284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
1048         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1049         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1050         103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1051         291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1052         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1053         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1054         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1055         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1056
1057 #ifdef CONFIG_MAC_EMUMOUSEBTN
1058 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1059 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1060
1061 #ifdef CONFIG_SPARC
1062 static int sparc_l1_a_state = 0;
1063 extern void sun_do_break(void);
1064 #endif
1065
1066 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1067                        unsigned char up_flag)
1068 {
1069         if (keycode > 255 || !x86_keycodes[keycode])
1070                 return -1;
1071
1072         switch (keycode) {
1073                 case KEY_PAUSE:
1074                         put_queue(vc, 0xe1);
1075                         put_queue(vc, 0x1d | up_flag);
1076                         put_queue(vc, 0x45 | up_flag);
1077                         return 0;
1078                 case KEY_HANGUEL:
1079                         if (!up_flag) put_queue(vc, 0xf1);
1080                         return 0;
1081                 case KEY_HANJA:
1082                         if (!up_flag) put_queue(vc, 0xf2);
1083                         return 0;
1084         }
1085
1086         if (keycode == KEY_SYSRQ && sysrq_alt) {
1087                 put_queue(vc, 0x54 | up_flag);
1088                 return 0;
1089         }
1090
1091         if (x86_keycodes[keycode] & 0x100)
1092                 put_queue(vc, 0xe0);
1093
1094         put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1095
1096         if (keycode == KEY_SYSRQ) {
1097                 put_queue(vc, 0xe0);
1098                 put_queue(vc, 0x37 | up_flag);
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         if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1301                 return NULL;
1302         memset(handle, 0, sizeof(struct input_handle));
1303
1304         handle->dev = dev;
1305         handle->handler = handler;
1306         handle->name = "kbd";
1307
1308         input_open_device(handle);
1309         kbd_refresh_leds(handle);
1310
1311         return handle;
1312 }
1313
1314 static void kbd_disconnect(struct input_handle *handle)
1315 {
1316         input_close_device(handle);
1317         kfree(handle);
1318 }
1319
1320 static struct input_device_id kbd_ids[] = {
1321         {
1322                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1323                 .evbit = { BIT(EV_KEY) },
1324         },
1325
1326         {
1327                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1328                 .evbit = { BIT(EV_SND) },
1329         },
1330
1331         { },    /* Terminating entry */
1332 };
1333
1334 MODULE_DEVICE_TABLE(input, kbd_ids);
1335
1336 static struct input_handler kbd_handler = {
1337         .event          = kbd_event,
1338         .connect        = kbd_connect,
1339         .disconnect     = kbd_disconnect,
1340         .name           = "kbd",
1341         .id_table       = kbd_ids,
1342 };
1343
1344 int __init kbd_init(void)
1345 {
1346         int i;
1347
1348         kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1349         kbd0.ledmode = LED_SHOW_FLAGS;
1350         kbd0.lockstate = KBD_DEFLOCK;
1351         kbd0.slockstate = 0;
1352         kbd0.modeflags = KBD_DEFMODE;
1353         kbd0.kbdmode = VC_XLATE;
1354
1355         for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1356                 kbd_table[i] = kbd0;
1357
1358         input_register_handler(&kbd_handler);
1359
1360         tasklet_enable(&keyboard_tasklet);
1361         tasklet_schedule(&keyboard_tasklet);
1362
1363         return 0;
1364 }