drivers/char/keyboard.c

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