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