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