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