1 /* 2 * Written for linux by Johan Myreen as a translation from 3 * the assembly version by Linus (with diacriticals added) 4 * 5 * Some additional features added by Christoph Niemann (ChN), March 1993 6 * 7 * Loadable keymaps by Risto Kankkunen, May 1993 8 * 9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993 10 * Added decr/incr_console, dynamic keymaps, Unicode support, 11 * dynamic function/string keys, led setting, Sept 1994 12 * `Sticky' modifier keys, 951006. 13 * 14 * 11-11-96: SAK should now work in the raw mode (Martin Mares) 15 * 16 * Modified to provide 'generic' keyboard support by Hamish Macdonald 17 * Merge with the m68k keyboard driver and split-off of the PC low-level 18 * parts by Geert Uytterhoeven, May 1997 19 * 20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares) 21 * 30-07-98: Dead keys redone, aeb@cwi.nl. 22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik) 23 */ 24 25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 26 27 #include <linux/consolemap.h> 28 #include <linux/module.h> 29 #include <linux/sched.h> 30 #include <linux/tty.h> 31 #include <linux/tty_flip.h> 32 #include <linux/mm.h> 33 #include <linux/string.h> 34 #include <linux/init.h> 35 #include <linux/slab.h> 36 37 #include <linux/kbd_kern.h> 38 #include <linux/kbd_diacr.h> 39 #include <linux/vt_kern.h> 40 #include <linux/input.h> 41 #include <linux/reboot.h> 42 #include <linux/notifier.h> 43 #include <linux/jiffies.h> 44 #include <linux/uaccess.h> 45 46 #include <asm/irq_regs.h> 47 48 extern void ctrl_alt_del(void); 49 50 /* 51 * Exported functions/variables 52 */ 53 54 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META)) 55 56 #if defined(CONFIG_X86) || defined(CONFIG_PARISC) 57 #include <asm/kbdleds.h> 58 #else 59 static inline int kbd_defleds(void) 60 { 61 return 0; 62 } 63 #endif 64 65 #define KBD_DEFLOCK 0 66 67 /* 68 * Handler Tables. 69 */ 70 71 #define K_HANDLERS\ 72 k_self, k_fn, k_spec, k_pad,\ 73 k_dead, k_cons, k_cur, k_shift,\ 74 k_meta, k_ascii, k_lock, k_lowercase,\ 75 k_slock, k_dead2, k_brl, k_ignore 76 77 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value, 78 char up_flag); 79 static k_handler_fn K_HANDLERS; 80 static k_handler_fn *k_handler[16] = { K_HANDLERS }; 81 82 #define FN_HANDLERS\ 83 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\ 84 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\ 85 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\ 86 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\ 87 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num 88 89 typedef void (fn_handler_fn)(struct vc_data *vc); 90 static fn_handler_fn FN_HANDLERS; 91 static fn_handler_fn *fn_handler[] = { FN_HANDLERS }; 92 93 /* 94 * Variables exported for vt_ioctl.c 95 */ 96 97 struct vt_spawn_console vt_spawn_con = { 98 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock), 99 .pid = NULL, 100 .sig = 0, 101 }; 102 103 104 /* 105 * Internal Data. 106 */ 107 108 static struct kbd_struct kbd_table[MAX_NR_CONSOLES]; 109 static struct kbd_struct *kbd = kbd_table; 110 111 /* maximum values each key_handler can handle */ 112 static const int max_vals[] = { 113 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1, 114 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1, 115 255, NR_LOCK - 1, 255, NR_BRL - 1 116 }; 117 118 static const int NR_TYPES = ARRAY_SIZE(max_vals); 119 120 static struct input_handler kbd_handler; 121 static DEFINE_SPINLOCK(kbd_event_lock); 122 static DEFINE_SPINLOCK(led_lock); 123 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */ 124 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */ 125 static bool dead_key_next; 126 static int npadch = -1; /* -1 or number assembled on pad */ 127 static unsigned int diacr; 128 static char rep; /* flag telling character repeat */ 129 130 static int shift_state = 0; 131 132 static unsigned char ledstate = 0xff; /* undefined */ 133 static unsigned char ledioctl; 134 135 /* 136 * Notifier list for console keyboard events 137 */ 138 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list); 139 140 int register_keyboard_notifier(struct notifier_block *nb) 141 { 142 return atomic_notifier_chain_register(&keyboard_notifier_list, nb); 143 } 144 EXPORT_SYMBOL_GPL(register_keyboard_notifier); 145 146 int unregister_keyboard_notifier(struct notifier_block *nb) 147 { 148 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb); 149 } 150 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier); 151 152 /* 153 * Translation of scancodes to keycodes. We set them on only the first 154 * keyboard in the list that accepts the scancode and keycode. 155 * Explanation for not choosing the first attached keyboard anymore: 156 * USB keyboards for example have two event devices: one for all "normal" 157 * keys and one for extra function keys (like "volume up", "make coffee", 158 * etc.). So this means that scancodes for the extra function keys won't 159 * be valid for the first event device, but will be for the second. 160 */ 161 162 struct getset_keycode_data { 163 struct input_keymap_entry ke; 164 int error; 165 }; 166 167 static int getkeycode_helper(struct input_handle *handle, void *data) 168 { 169 struct getset_keycode_data *d = data; 170 171 d->error = input_get_keycode(handle->dev, &d->ke); 172 173 return d->error == 0; /* stop as soon as we successfully get one */ 174 } 175 176 static int getkeycode(unsigned int scancode) 177 { 178 struct getset_keycode_data d = { 179 .ke = { 180 .flags = 0, 181 .len = sizeof(scancode), 182 .keycode = 0, 183 }, 184 .error = -ENODEV, 185 }; 186 187 memcpy(d.ke.scancode, &scancode, sizeof(scancode)); 188 189 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper); 190 191 return d.error ?: d.ke.keycode; 192 } 193 194 static int setkeycode_helper(struct input_handle *handle, void *data) 195 { 196 struct getset_keycode_data *d = data; 197 198 d->error = input_set_keycode(handle->dev, &d->ke); 199 200 return d->error == 0; /* stop as soon as we successfully set one */ 201 } 202 203 static int setkeycode(unsigned int scancode, unsigned int keycode) 204 { 205 struct getset_keycode_data d = { 206 .ke = { 207 .flags = 0, 208 .len = sizeof(scancode), 209 .keycode = keycode, 210 }, 211 .error = -ENODEV, 212 }; 213 214 memcpy(d.ke.scancode, &scancode, sizeof(scancode)); 215 216 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper); 217 218 return d.error; 219 } 220 221 /* 222 * Making beeps and bells. Note that we prefer beeps to bells, but when 223 * shutting the sound off we do both. 224 */ 225 226 static int kd_sound_helper(struct input_handle *handle, void *data) 227 { 228 unsigned int *hz = data; 229 struct input_dev *dev = handle->dev; 230 231 if (test_bit(EV_SND, dev->evbit)) { 232 if (test_bit(SND_TONE, dev->sndbit)) { 233 input_inject_event(handle, EV_SND, SND_TONE, *hz); 234 if (*hz) 235 return 0; 236 } 237 if (test_bit(SND_BELL, dev->sndbit)) 238 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0); 239 } 240 241 return 0; 242 } 243 244 static void kd_nosound(unsigned long ignored) 245 { 246 static unsigned int zero; 247 248 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper); 249 } 250 251 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0); 252 253 void kd_mksound(unsigned int hz, unsigned int ticks) 254 { 255 del_timer_sync(&kd_mksound_timer); 256 257 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper); 258 259 if (hz && ticks) 260 mod_timer(&kd_mksound_timer, jiffies + ticks); 261 } 262 EXPORT_SYMBOL(kd_mksound); 263 264 /* 265 * Setting the keyboard rate. 266 */ 267 268 static int kbd_rate_helper(struct input_handle *handle, void *data) 269 { 270 struct input_dev *dev = handle->dev; 271 struct kbd_repeat *rpt = data; 272 273 if (test_bit(EV_REP, dev->evbit)) { 274 275 if (rpt[0].delay > 0) 276 input_inject_event(handle, 277 EV_REP, REP_DELAY, rpt[0].delay); 278 if (rpt[0].period > 0) 279 input_inject_event(handle, 280 EV_REP, REP_PERIOD, rpt[0].period); 281 282 rpt[1].delay = dev->rep[REP_DELAY]; 283 rpt[1].period = dev->rep[REP_PERIOD]; 284 } 285 286 return 0; 287 } 288 289 int kbd_rate(struct kbd_repeat *rpt) 290 { 291 struct kbd_repeat data[2] = { *rpt }; 292 293 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper); 294 *rpt = data[1]; /* Copy currently used settings */ 295 296 return 0; 297 } 298 299 /* 300 * Helper Functions. 301 */ 302 static void put_queue(struct vc_data *vc, int ch) 303 { 304 tty_insert_flip_char(&vc->port, ch, 0); 305 tty_schedule_flip(&vc->port); 306 } 307 308 static void puts_queue(struct vc_data *vc, char *cp) 309 { 310 while (*cp) { 311 tty_insert_flip_char(&vc->port, *cp, 0); 312 cp++; 313 } 314 tty_schedule_flip(&vc->port); 315 } 316 317 static void applkey(struct vc_data *vc, int key, char mode) 318 { 319 static char buf[] = { 0x1b, 'O', 0x00, 0x00 }; 320 321 buf[1] = (mode ? 'O' : '['); 322 buf[2] = key; 323 puts_queue(vc, buf); 324 } 325 326 /* 327 * Many other routines do put_queue, but I think either 328 * they produce ASCII, or they produce some user-assigned 329 * string, and in both cases we might assume that it is 330 * in utf-8 already. 331 */ 332 static void to_utf8(struct vc_data *vc, uint c) 333 { 334 if (c < 0x80) 335 /* 0******* */ 336 put_queue(vc, c); 337 else if (c < 0x800) { 338 /* 110***** 10****** */ 339 put_queue(vc, 0xc0 | (c >> 6)); 340 put_queue(vc, 0x80 | (c & 0x3f)); 341 } else if (c < 0x10000) { 342 if (c >= 0xD800 && c < 0xE000) 343 return; 344 if (c == 0xFFFF) 345 return; 346 /* 1110**** 10****** 10****** */ 347 put_queue(vc, 0xe0 | (c >> 12)); 348 put_queue(vc, 0x80 | ((c >> 6) & 0x3f)); 349 put_queue(vc, 0x80 | (c & 0x3f)); 350 } else if (c < 0x110000) { 351 /* 11110*** 10****** 10****** 10****** */ 352 put_queue(vc, 0xf0 | (c >> 18)); 353 put_queue(vc, 0x80 | ((c >> 12) & 0x3f)); 354 put_queue(vc, 0x80 | ((c >> 6) & 0x3f)); 355 put_queue(vc, 0x80 | (c & 0x3f)); 356 } 357 } 358 359 /* 360 * Called after returning from RAW mode or when changing consoles - recompute 361 * shift_down[] and shift_state from key_down[] maybe called when keymap is 362 * undefined, so that shiftkey release is seen. The caller must hold the 363 * kbd_event_lock. 364 */ 365 366 static void do_compute_shiftstate(void) 367 { 368 unsigned int i, j, k, sym, val; 369 370 shift_state = 0; 371 memset(shift_down, 0, sizeof(shift_down)); 372 373 for (i = 0; i < ARRAY_SIZE(key_down); i++) { 374 375 if (!key_down[i]) 376 continue; 377 378 k = i * BITS_PER_LONG; 379 380 for (j = 0; j < BITS_PER_LONG; j++, k++) { 381 382 if (!test_bit(k, key_down)) 383 continue; 384 385 sym = U(key_maps[0][k]); 386 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK) 387 continue; 388 389 val = KVAL(sym); 390 if (val == KVAL(K_CAPSSHIFT)) 391 val = KVAL(K_SHIFT); 392 393 shift_down[val]++; 394 shift_state |= (1 << val); 395 } 396 } 397 } 398 399 /* We still have to export this method to vt.c */ 400 void compute_shiftstate(void) 401 { 402 unsigned long flags; 403 spin_lock_irqsave(&kbd_event_lock, flags); 404 do_compute_shiftstate(); 405 spin_unlock_irqrestore(&kbd_event_lock, flags); 406 } 407 408 /* 409 * We have a combining character DIACR here, followed by the character CH. 410 * If the combination occurs in the table, return the corresponding value. 411 * Otherwise, if CH is a space or equals DIACR, return DIACR. 412 * Otherwise, conclude that DIACR was not combining after all, 413 * queue it and return CH. 414 */ 415 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch) 416 { 417 unsigned int d = diacr; 418 unsigned int i; 419 420 diacr = 0; 421 422 if ((d & ~0xff) == BRL_UC_ROW) { 423 if ((ch & ~0xff) == BRL_UC_ROW) 424 return d | ch; 425 } else { 426 for (i = 0; i < accent_table_size; i++) 427 if (accent_table[i].diacr == d && accent_table[i].base == ch) 428 return accent_table[i].result; 429 } 430 431 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d) 432 return d; 433 434 if (kbd->kbdmode == VC_UNICODE) 435 to_utf8(vc, d); 436 else { 437 int c = conv_uni_to_8bit(d); 438 if (c != -1) 439 put_queue(vc, c); 440 } 441 442 return ch; 443 } 444 445 /* 446 * Special function handlers 447 */ 448 static void fn_enter(struct vc_data *vc) 449 { 450 if (diacr) { 451 if (kbd->kbdmode == VC_UNICODE) 452 to_utf8(vc, diacr); 453 else { 454 int c = conv_uni_to_8bit(diacr); 455 if (c != -1) 456 put_queue(vc, c); 457 } 458 diacr = 0; 459 } 460 461 put_queue(vc, 13); 462 if (vc_kbd_mode(kbd, VC_CRLF)) 463 put_queue(vc, 10); 464 } 465 466 static void fn_caps_toggle(struct vc_data *vc) 467 { 468 if (rep) 469 return; 470 471 chg_vc_kbd_led(kbd, VC_CAPSLOCK); 472 } 473 474 static void fn_caps_on(struct vc_data *vc) 475 { 476 if (rep) 477 return; 478 479 set_vc_kbd_led(kbd, VC_CAPSLOCK); 480 } 481 482 static void fn_show_ptregs(struct vc_data *vc) 483 { 484 struct pt_regs *regs = get_irq_regs(); 485 486 if (regs) 487 show_regs(regs); 488 } 489 490 static void fn_hold(struct vc_data *vc) 491 { 492 struct tty_struct *tty = vc->port.tty; 493 494 if (rep || !tty) 495 return; 496 497 /* 498 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty); 499 * these routines are also activated by ^S/^Q. 500 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.) 501 */ 502 if (tty->stopped) 503 start_tty(tty); 504 else 505 stop_tty(tty); 506 } 507 508 static void fn_num(struct vc_data *vc) 509 { 510 if (vc_kbd_mode(kbd, VC_APPLIC)) 511 applkey(vc, 'P', 1); 512 else 513 fn_bare_num(vc); 514 } 515 516 /* 517 * Bind this to Shift-NumLock if you work in application keypad mode 518 * but want to be able to change the NumLock flag. 519 * Bind this to NumLock if you prefer that the NumLock key always 520 * changes the NumLock flag. 521 */ 522 static void fn_bare_num(struct vc_data *vc) 523 { 524 if (!rep) 525 chg_vc_kbd_led(kbd, VC_NUMLOCK); 526 } 527 528 static void fn_lastcons(struct vc_data *vc) 529 { 530 /* switch to the last used console, ChN */ 531 set_console(last_console); 532 } 533 534 static void fn_dec_console(struct vc_data *vc) 535 { 536 int i, cur = fg_console; 537 538 /* Currently switching? Queue this next switch relative to that. */ 539 if (want_console != -1) 540 cur = want_console; 541 542 for (i = cur - 1; i != cur; i--) { 543 if (i == -1) 544 i = MAX_NR_CONSOLES - 1; 545 if (vc_cons_allocated(i)) 546 break; 547 } 548 set_console(i); 549 } 550 551 static void fn_inc_console(struct vc_data *vc) 552 { 553 int i, cur = fg_console; 554 555 /* Currently switching? Queue this next switch relative to that. */ 556 if (want_console != -1) 557 cur = want_console; 558 559 for (i = cur+1; i != cur; i++) { 560 if (i == MAX_NR_CONSOLES) 561 i = 0; 562 if (vc_cons_allocated(i)) 563 break; 564 } 565 set_console(i); 566 } 567 568 static void fn_send_intr(struct vc_data *vc) 569 { 570 tty_insert_flip_char(&vc->port, 0, TTY_BREAK); 571 tty_schedule_flip(&vc->port); 572 } 573 574 static void fn_scroll_forw(struct vc_data *vc) 575 { 576 scrollfront(vc, 0); 577 } 578 579 static void fn_scroll_back(struct vc_data *vc) 580 { 581 scrollback(vc, 0); 582 } 583 584 static void fn_show_mem(struct vc_data *vc) 585 { 586 show_mem(0); 587 } 588 589 static void fn_show_state(struct vc_data *vc) 590 { 591 show_state(); 592 } 593 594 static void fn_boot_it(struct vc_data *vc) 595 { 596 ctrl_alt_del(); 597 } 598 599 static void fn_compose(struct vc_data *vc) 600 { 601 dead_key_next = true; 602 } 603 604 static void fn_spawn_con(struct vc_data *vc) 605 { 606 spin_lock(&vt_spawn_con.lock); 607 if (vt_spawn_con.pid) 608 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) { 609 put_pid(vt_spawn_con.pid); 610 vt_spawn_con.pid = NULL; 611 } 612 spin_unlock(&vt_spawn_con.lock); 613 } 614 615 static void fn_SAK(struct vc_data *vc) 616 { 617 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work; 618 schedule_work(SAK_work); 619 } 620 621 static void fn_null(struct vc_data *vc) 622 { 623 do_compute_shiftstate(); 624 } 625 626 /* 627 * Special key handlers 628 */ 629 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag) 630 { 631 } 632 633 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag) 634 { 635 if (up_flag) 636 return; 637 if (value >= ARRAY_SIZE(fn_handler)) 638 return; 639 if ((kbd->kbdmode == VC_RAW || 640 kbd->kbdmode == VC_MEDIUMRAW || 641 kbd->kbdmode == VC_OFF) && 642 value != KVAL(K_SAK)) 643 return; /* SAK is allowed even in raw mode */ 644 fn_handler[value](vc); 645 } 646 647 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag) 648 { 649 pr_err("k_lowercase was called - impossible\n"); 650 } 651 652 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag) 653 { 654 if (up_flag) 655 return; /* no action, if this is a key release */ 656 657 if (diacr) 658 value = handle_diacr(vc, value); 659 660 if (dead_key_next) { 661 dead_key_next = false; 662 diacr = value; 663 return; 664 } 665 if (kbd->kbdmode == VC_UNICODE) 666 to_utf8(vc, value); 667 else { 668 int c = conv_uni_to_8bit(value); 669 if (c != -1) 670 put_queue(vc, c); 671 } 672 } 673 674 /* 675 * Handle dead key. Note that we now may have several 676 * dead keys modifying the same character. Very useful 677 * for Vietnamese. 678 */ 679 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag) 680 { 681 if (up_flag) 682 return; 683 684 diacr = (diacr ? handle_diacr(vc, value) : value); 685 } 686 687 static void k_self(struct vc_data *vc, unsigned char value, char up_flag) 688 { 689 k_unicode(vc, conv_8bit_to_uni(value), up_flag); 690 } 691 692 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag) 693 { 694 k_deadunicode(vc, value, up_flag); 695 } 696 697 /* 698 * Obsolete - for backwards compatibility only 699 */ 700 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag) 701 { 702 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' }; 703 704 k_deadunicode(vc, ret_diacr[value], up_flag); 705 } 706 707 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag) 708 { 709 if (up_flag) 710 return; 711 712 set_console(value); 713 } 714 715 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag) 716 { 717 if (up_flag) 718 return; 719 720 if ((unsigned)value < ARRAY_SIZE(func_table)) { 721 if (func_table[value]) 722 puts_queue(vc, func_table[value]); 723 } else 724 pr_err("k_fn called with value=%d\n", value); 725 } 726 727 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag) 728 { 729 static const char cur_chars[] = "BDCA"; 730 731 if (up_flag) 732 return; 733 734 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE)); 735 } 736 737 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag) 738 { 739 static const char pad_chars[] = "0123456789+-*/\015,.?()#"; 740 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS"; 741 742 if (up_flag) 743 return; /* no action, if this is a key release */ 744 745 /* kludge... shift forces cursor/number keys */ 746 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) { 747 applkey(vc, app_map[value], 1); 748 return; 749 } 750 751 if (!vc_kbd_led(kbd, VC_NUMLOCK)) { 752 753 switch (value) { 754 case KVAL(K_PCOMMA): 755 case KVAL(K_PDOT): 756 k_fn(vc, KVAL(K_REMOVE), 0); 757 return; 758 case KVAL(K_P0): 759 k_fn(vc, KVAL(K_INSERT), 0); 760 return; 761 case KVAL(K_P1): 762 k_fn(vc, KVAL(K_SELECT), 0); 763 return; 764 case KVAL(K_P2): 765 k_cur(vc, KVAL(K_DOWN), 0); 766 return; 767 case KVAL(K_P3): 768 k_fn(vc, KVAL(K_PGDN), 0); 769 return; 770 case KVAL(K_P4): 771 k_cur(vc, KVAL(K_LEFT), 0); 772 return; 773 case KVAL(K_P6): 774 k_cur(vc, KVAL(K_RIGHT), 0); 775 return; 776 case KVAL(K_P7): 777 k_fn(vc, KVAL(K_FIND), 0); 778 return; 779 case KVAL(K_P8): 780 k_cur(vc, KVAL(K_UP), 0); 781 return; 782 case KVAL(K_P9): 783 k_fn(vc, KVAL(K_PGUP), 0); 784 return; 785 case KVAL(K_P5): 786 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC)); 787 return; 788 } 789 } 790 791 put_queue(vc, pad_chars[value]); 792 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF)) 793 put_queue(vc, 10); 794 } 795 796 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag) 797 { 798 int old_state = shift_state; 799 800 if (rep) 801 return; 802 /* 803 * Mimic typewriter: 804 * a CapsShift key acts like Shift but undoes CapsLock 805 */ 806 if (value == KVAL(K_CAPSSHIFT)) { 807 value = KVAL(K_SHIFT); 808 if (!up_flag) 809 clr_vc_kbd_led(kbd, VC_CAPSLOCK); 810 } 811 812 if (up_flag) { 813 /* 814 * handle the case that two shift or control 815 * keys are depressed simultaneously 816 */ 817 if (shift_down[value]) 818 shift_down[value]--; 819 } else 820 shift_down[value]++; 821 822 if (shift_down[value]) 823 shift_state |= (1 << value); 824 else 825 shift_state &= ~(1 << value); 826 827 /* kludge */ 828 if (up_flag && shift_state != old_state && npadch != -1) { 829 if (kbd->kbdmode == VC_UNICODE) 830 to_utf8(vc, npadch); 831 else 832 put_queue(vc, npadch & 0xff); 833 npadch = -1; 834 } 835 } 836 837 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag) 838 { 839 if (up_flag) 840 return; 841 842 if (vc_kbd_mode(kbd, VC_META)) { 843 put_queue(vc, '\033'); 844 put_queue(vc, value); 845 } else 846 put_queue(vc, value | 0x80); 847 } 848 849 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag) 850 { 851 int base; 852 853 if (up_flag) 854 return; 855 856 if (value < 10) { 857 /* decimal input of code, while Alt depressed */ 858 base = 10; 859 } else { 860 /* hexadecimal input of code, while AltGr depressed */ 861 value -= 10; 862 base = 16; 863 } 864 865 if (npadch == -1) 866 npadch = value; 867 else 868 npadch = npadch * base + value; 869 } 870 871 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag) 872 { 873 if (up_flag || rep) 874 return; 875 876 chg_vc_kbd_lock(kbd, value); 877 } 878 879 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag) 880 { 881 k_shift(vc, value, up_flag); 882 if (up_flag || rep) 883 return; 884 885 chg_vc_kbd_slock(kbd, value); 886 /* try to make Alt, oops, AltGr and such work */ 887 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) { 888 kbd->slockstate = 0; 889 chg_vc_kbd_slock(kbd, value); 890 } 891 } 892 893 /* by default, 300ms interval for combination release */ 894 static unsigned brl_timeout = 300; 895 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)"); 896 module_param(brl_timeout, uint, 0644); 897 898 static unsigned brl_nbchords = 1; 899 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)"); 900 module_param(brl_nbchords, uint, 0644); 901 902 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag) 903 { 904 static unsigned long chords; 905 static unsigned committed; 906 907 if (!brl_nbchords) 908 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag); 909 else { 910 committed |= pattern; 911 chords++; 912 if (chords == brl_nbchords) { 913 k_unicode(vc, BRL_UC_ROW | committed, up_flag); 914 chords = 0; 915 committed = 0; 916 } 917 } 918 } 919 920 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag) 921 { 922 static unsigned pressed, committing; 923 static unsigned long releasestart; 924 925 if (kbd->kbdmode != VC_UNICODE) { 926 if (!up_flag) 927 pr_warn("keyboard mode must be unicode for braille patterns\n"); 928 return; 929 } 930 931 if (!value) { 932 k_unicode(vc, BRL_UC_ROW, up_flag); 933 return; 934 } 935 936 if (value > 8) 937 return; 938 939 if (!up_flag) { 940 pressed |= 1 << (value - 1); 941 if (!brl_timeout) 942 committing = pressed; 943 } else if (brl_timeout) { 944 if (!committing || 945 time_after(jiffies, 946 releasestart + msecs_to_jiffies(brl_timeout))) { 947 committing = pressed; 948 releasestart = jiffies; 949 } 950 pressed &= ~(1 << (value - 1)); 951 if (!pressed && committing) { 952 k_brlcommit(vc, committing, 0); 953 committing = 0; 954 } 955 } else { 956 if (committing) { 957 k_brlcommit(vc, committing, 0); 958 committing = 0; 959 } 960 pressed &= ~(1 << (value - 1)); 961 } 962 } 963 964 /* 965 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock, 966 * or (ii) whatever pattern of lights people want to show using KDSETLED, 967 * or (iii) specified bits of specified words in kernel memory. 968 */ 969 static unsigned char getledstate(void) 970 { 971 return ledstate; 972 } 973 974 void setledstate(struct kbd_struct *kb, unsigned int led) 975 { 976 unsigned long flags; 977 spin_lock_irqsave(&led_lock, flags); 978 if (!(led & ~7)) { 979 ledioctl = led; 980 kb->ledmode = LED_SHOW_IOCTL; 981 } else 982 kb->ledmode = LED_SHOW_FLAGS; 983 984 set_leds(); 985 spin_unlock_irqrestore(&led_lock, flags); 986 } 987 988 static inline unsigned char getleds(void) 989 { 990 struct kbd_struct *kb = kbd_table + fg_console; 991 992 if (kb->ledmode == LED_SHOW_IOCTL) 993 return ledioctl; 994 995 return kb->ledflagstate; 996 } 997 998 static int kbd_update_leds_helper(struct input_handle *handle, void *data) 999 { 1000 unsigned char leds = *(unsigned char *)data; 1001 1002 if (test_bit(EV_LED, handle->dev->evbit)) { 1003 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01)); 1004 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02)); 1005 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04)); 1006 input_inject_event(handle, EV_SYN, SYN_REPORT, 0); 1007 } 1008 1009 return 0; 1010 } 1011 1012 /** 1013 * vt_get_leds - helper for braille console 1014 * @console: console to read 1015 * @flag: flag we want to check 1016 * 1017 * Check the status of a keyboard led flag and report it back 1018 */ 1019 int vt_get_leds(int console, int flag) 1020 { 1021 struct kbd_struct *kb = kbd_table + console; 1022 int ret; 1023 unsigned long flags; 1024 1025 spin_lock_irqsave(&led_lock, flags); 1026 ret = vc_kbd_led(kb, flag); 1027 spin_unlock_irqrestore(&led_lock, flags); 1028 1029 return ret; 1030 } 1031 EXPORT_SYMBOL_GPL(vt_get_leds); 1032 1033 /** 1034 * vt_set_led_state - set LED state of a console 1035 * @console: console to set 1036 * @leds: LED bits 1037 * 1038 * Set the LEDs on a console. This is a wrapper for the VT layer 1039 * so that we can keep kbd knowledge internal 1040 */ 1041 void vt_set_led_state(int console, int leds) 1042 { 1043 struct kbd_struct *kb = kbd_table + console; 1044 setledstate(kb, leds); 1045 } 1046 1047 /** 1048 * vt_kbd_con_start - Keyboard side of console start 1049 * @console: console 1050 * 1051 * Handle console start. This is a wrapper for the VT layer 1052 * so that we can keep kbd knowledge internal 1053 * 1054 * FIXME: We eventually need to hold the kbd lock here to protect 1055 * the LED updating. We can't do it yet because fn_hold calls stop_tty 1056 * and start_tty under the kbd_event_lock, while normal tty paths 1057 * don't hold the lock. We probably need to split out an LED lock 1058 * but not during an -rc release! 1059 */ 1060 void vt_kbd_con_start(int console) 1061 { 1062 struct kbd_struct *kb = kbd_table + console; 1063 unsigned long flags; 1064 spin_lock_irqsave(&led_lock, flags); 1065 clr_vc_kbd_led(kb, VC_SCROLLOCK); 1066 set_leds(); 1067 spin_unlock_irqrestore(&led_lock, flags); 1068 } 1069 1070 /** 1071 * vt_kbd_con_stop - Keyboard side of console stop 1072 * @console: console 1073 * 1074 * Handle console stop. This is a wrapper for the VT layer 1075 * so that we can keep kbd knowledge internal 1076 */ 1077 void vt_kbd_con_stop(int console) 1078 { 1079 struct kbd_struct *kb = kbd_table + console; 1080 unsigned long flags; 1081 spin_lock_irqsave(&led_lock, flags); 1082 set_vc_kbd_led(kb, VC_SCROLLOCK); 1083 set_leds(); 1084 spin_unlock_irqrestore(&led_lock, flags); 1085 } 1086 1087 /* 1088 * This is the tasklet that updates LED state on all keyboards 1089 * attached to the box. The reason we use tasklet is that we 1090 * need to handle the scenario when keyboard handler is not 1091 * registered yet but we already getting updates from the VT to 1092 * update led state. 1093 */ 1094 static void kbd_bh(unsigned long dummy) 1095 { 1096 unsigned char leds; 1097 unsigned long flags; 1098 1099 spin_lock_irqsave(&led_lock, flags); 1100 leds = getleds(); 1101 spin_unlock_irqrestore(&led_lock, flags); 1102 1103 if (leds != ledstate) { 1104 input_handler_for_each_handle(&kbd_handler, &leds, 1105 kbd_update_leds_helper); 1106 ledstate = leds; 1107 } 1108 } 1109 1110 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0); 1111 1112 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\ 1113 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\ 1114 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\ 1115 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\ 1116 defined(CONFIG_AVR32) 1117 1118 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\ 1119 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001)) 1120 1121 static const unsigned short x86_keycodes[256] = 1122 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1123 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1124 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 1125 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 1126 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1127 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92, 1128 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339, 1129 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349, 1130 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355, 1131 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361, 1132 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114, 1133 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116, 1134 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307, 1135 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330, 1136 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 }; 1137 1138 #ifdef CONFIG_SPARC 1139 static int sparc_l1_a_state; 1140 extern void sun_do_break(void); 1141 #endif 1142 1143 static int emulate_raw(struct vc_data *vc, unsigned int keycode, 1144 unsigned char up_flag) 1145 { 1146 int code; 1147 1148 switch (keycode) { 1149 1150 case KEY_PAUSE: 1151 put_queue(vc, 0xe1); 1152 put_queue(vc, 0x1d | up_flag); 1153 put_queue(vc, 0x45 | up_flag); 1154 break; 1155 1156 case KEY_HANGEUL: 1157 if (!up_flag) 1158 put_queue(vc, 0xf2); 1159 break; 1160 1161 case KEY_HANJA: 1162 if (!up_flag) 1163 put_queue(vc, 0xf1); 1164 break; 1165 1166 case KEY_SYSRQ: 1167 /* 1168 * Real AT keyboards (that's what we're trying 1169 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when 1170 * pressing PrtSc/SysRq alone, but simply 0x54 1171 * when pressing Alt+PrtSc/SysRq. 1172 */ 1173 if (test_bit(KEY_LEFTALT, key_down) || 1174 test_bit(KEY_RIGHTALT, key_down)) { 1175 put_queue(vc, 0x54 | up_flag); 1176 } else { 1177 put_queue(vc, 0xe0); 1178 put_queue(vc, 0x2a | up_flag); 1179 put_queue(vc, 0xe0); 1180 put_queue(vc, 0x37 | up_flag); 1181 } 1182 break; 1183 1184 default: 1185 if (keycode > 255) 1186 return -1; 1187 1188 code = x86_keycodes[keycode]; 1189 if (!code) 1190 return -1; 1191 1192 if (code & 0x100) 1193 put_queue(vc, 0xe0); 1194 put_queue(vc, (code & 0x7f) | up_flag); 1195 1196 break; 1197 } 1198 1199 return 0; 1200 } 1201 1202 #else 1203 1204 #define HW_RAW(dev) 0 1205 1206 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag) 1207 { 1208 if (keycode > 127) 1209 return -1; 1210 1211 put_queue(vc, keycode | up_flag); 1212 return 0; 1213 } 1214 #endif 1215 1216 static void kbd_rawcode(unsigned char data) 1217 { 1218 struct vc_data *vc = vc_cons[fg_console].d; 1219 1220 kbd = kbd_table + vc->vc_num; 1221 if (kbd->kbdmode == VC_RAW) 1222 put_queue(vc, data); 1223 } 1224 1225 static void kbd_keycode(unsigned int keycode, int down, int hw_raw) 1226 { 1227 struct vc_data *vc = vc_cons[fg_console].d; 1228 unsigned short keysym, *key_map; 1229 unsigned char type; 1230 bool raw_mode; 1231 struct tty_struct *tty; 1232 int shift_final; 1233 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down }; 1234 int rc; 1235 1236 tty = vc->port.tty; 1237 1238 if (tty && (!tty->driver_data)) { 1239 /* No driver data? Strange. Okay we fix it then. */ 1240 tty->driver_data = vc; 1241 } 1242 1243 kbd = kbd_table + vc->vc_num; 1244 1245 #ifdef CONFIG_SPARC 1246 if (keycode == KEY_STOP) 1247 sparc_l1_a_state = down; 1248 #endif 1249 1250 rep = (down == 2); 1251 1252 raw_mode = (kbd->kbdmode == VC_RAW); 1253 if (raw_mode && !hw_raw) 1254 if (emulate_raw(vc, keycode, !down << 7)) 1255 if (keycode < BTN_MISC && printk_ratelimit()) 1256 pr_warn("can't emulate rawmode for keycode %d\n", 1257 keycode); 1258 1259 #ifdef CONFIG_SPARC 1260 if (keycode == KEY_A && sparc_l1_a_state) { 1261 sparc_l1_a_state = false; 1262 sun_do_break(); 1263 } 1264 #endif 1265 1266 if (kbd->kbdmode == VC_MEDIUMRAW) { 1267 /* 1268 * This is extended medium raw mode, with keys above 127 1269 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing 1270 * the 'up' flag if needed. 0 is reserved, so this shouldn't 1271 * interfere with anything else. The two bytes after 0 will 1272 * always have the up flag set not to interfere with older 1273 * applications. This allows for 16384 different keycodes, 1274 * which should be enough. 1275 */ 1276 if (keycode < 128) { 1277 put_queue(vc, keycode | (!down << 7)); 1278 } else { 1279 put_queue(vc, !down << 7); 1280 put_queue(vc, (keycode >> 7) | 0x80); 1281 put_queue(vc, keycode | 0x80); 1282 } 1283 raw_mode = true; 1284 } 1285 1286 if (down) 1287 set_bit(keycode, key_down); 1288 else 1289 clear_bit(keycode, key_down); 1290 1291 if (rep && 1292 (!vc_kbd_mode(kbd, VC_REPEAT) || 1293 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) { 1294 /* 1295 * Don't repeat a key if the input buffers are not empty and the 1296 * characters get aren't echoed locally. This makes key repeat 1297 * usable with slow applications and under heavy loads. 1298 */ 1299 return; 1300 } 1301 1302 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate; 1303 param.ledstate = kbd->ledflagstate; 1304 key_map = key_maps[shift_final]; 1305 1306 rc = atomic_notifier_call_chain(&keyboard_notifier_list, 1307 KBD_KEYCODE, ¶m); 1308 if (rc == NOTIFY_STOP || !key_map) { 1309 atomic_notifier_call_chain(&keyboard_notifier_list, 1310 KBD_UNBOUND_KEYCODE, ¶m); 1311 do_compute_shiftstate(); 1312 kbd->slockstate = 0; 1313 return; 1314 } 1315 1316 if (keycode < NR_KEYS) 1317 keysym = key_map[keycode]; 1318 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8) 1319 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1)); 1320 else 1321 return; 1322 1323 type = KTYP(keysym); 1324 1325 if (type < 0xf0) { 1326 param.value = keysym; 1327 rc = atomic_notifier_call_chain(&keyboard_notifier_list, 1328 KBD_UNICODE, ¶m); 1329 if (rc != NOTIFY_STOP) 1330 if (down && !raw_mode) 1331 to_utf8(vc, keysym); 1332 return; 1333 } 1334 1335 type -= 0xf0; 1336 1337 if (type == KT_LETTER) { 1338 type = KT_LATIN; 1339 if (vc_kbd_led(kbd, VC_CAPSLOCK)) { 1340 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)]; 1341 if (key_map) 1342 keysym = key_map[keycode]; 1343 } 1344 } 1345 1346 param.value = keysym; 1347 rc = atomic_notifier_call_chain(&keyboard_notifier_list, 1348 KBD_KEYSYM, ¶m); 1349 if (rc == NOTIFY_STOP) 1350 return; 1351 1352 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT) 1353 return; 1354 1355 (*k_handler[type])(vc, keysym & 0xff, !down); 1356 1357 param.ledstate = kbd->ledflagstate; 1358 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m); 1359 1360 if (type != KT_SLOCK) 1361 kbd->slockstate = 0; 1362 } 1363 1364 static void kbd_event(struct input_handle *handle, unsigned int event_type, 1365 unsigned int event_code, int value) 1366 { 1367 /* We are called with interrupts disabled, just take the lock */ 1368 spin_lock(&kbd_event_lock); 1369 1370 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev)) 1371 kbd_rawcode(value); 1372 if (event_type == EV_KEY) 1373 kbd_keycode(event_code, value, HW_RAW(handle->dev)); 1374 1375 spin_unlock(&kbd_event_lock); 1376 1377 tasklet_schedule(&keyboard_tasklet); 1378 do_poke_blanked_console = 1; 1379 schedule_console_callback(); 1380 } 1381 1382 static bool kbd_match(struct input_handler *handler, struct input_dev *dev) 1383 { 1384 int i; 1385 1386 if (test_bit(EV_SND, dev->evbit)) 1387 return true; 1388 1389 if (test_bit(EV_KEY, dev->evbit)) { 1390 for (i = KEY_RESERVED; i < BTN_MISC; i++) 1391 if (test_bit(i, dev->keybit)) 1392 return true; 1393 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++) 1394 if (test_bit(i, dev->keybit)) 1395 return true; 1396 } 1397 1398 return false; 1399 } 1400 1401 /* 1402 * When a keyboard (or other input device) is found, the kbd_connect 1403 * function is called. The function then looks at the device, and if it 1404 * likes it, it can open it and get events from it. In this (kbd_connect) 1405 * function, we should decide which VT to bind that keyboard to initially. 1406 */ 1407 static int kbd_connect(struct input_handler *handler, struct input_dev *dev, 1408 const struct input_device_id *id) 1409 { 1410 struct input_handle *handle; 1411 int error; 1412 1413 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL); 1414 if (!handle) 1415 return -ENOMEM; 1416 1417 handle->dev = dev; 1418 handle->handler = handler; 1419 handle->name = "kbd"; 1420 1421 error = input_register_handle(handle); 1422 if (error) 1423 goto err_free_handle; 1424 1425 error = input_open_device(handle); 1426 if (error) 1427 goto err_unregister_handle; 1428 1429 return 0; 1430 1431 err_unregister_handle: 1432 input_unregister_handle(handle); 1433 err_free_handle: 1434 kfree(handle); 1435 return error; 1436 } 1437 1438 static void kbd_disconnect(struct input_handle *handle) 1439 { 1440 input_close_device(handle); 1441 input_unregister_handle(handle); 1442 kfree(handle); 1443 } 1444 1445 /* 1446 * Start keyboard handler on the new keyboard by refreshing LED state to 1447 * match the rest of the system. 1448 */ 1449 static void kbd_start(struct input_handle *handle) 1450 { 1451 tasklet_disable(&keyboard_tasklet); 1452 1453 if (ledstate != 0xff) 1454 kbd_update_leds_helper(handle, &ledstate); 1455 1456 tasklet_enable(&keyboard_tasklet); 1457 } 1458 1459 static const struct input_device_id kbd_ids[] = { 1460 { 1461 .flags = INPUT_DEVICE_ID_MATCH_EVBIT, 1462 .evbit = { BIT_MASK(EV_KEY) }, 1463 }, 1464 1465 { 1466 .flags = INPUT_DEVICE_ID_MATCH_EVBIT, 1467 .evbit = { BIT_MASK(EV_SND) }, 1468 }, 1469 1470 { }, /* Terminating entry */ 1471 }; 1472 1473 MODULE_DEVICE_TABLE(input, kbd_ids); 1474 1475 static struct input_handler kbd_handler = { 1476 .event = kbd_event, 1477 .match = kbd_match, 1478 .connect = kbd_connect, 1479 .disconnect = kbd_disconnect, 1480 .start = kbd_start, 1481 .name = "kbd", 1482 .id_table = kbd_ids, 1483 }; 1484 1485 int __init kbd_init(void) 1486 { 1487 int i; 1488 int error; 1489 1490 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1491 kbd_table[i].ledflagstate = kbd_defleds(); 1492 kbd_table[i].default_ledflagstate = kbd_defleds(); 1493 kbd_table[i].ledmode = LED_SHOW_FLAGS; 1494 kbd_table[i].lockstate = KBD_DEFLOCK; 1495 kbd_table[i].slockstate = 0; 1496 kbd_table[i].modeflags = KBD_DEFMODE; 1497 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 1498 } 1499 1500 error = input_register_handler(&kbd_handler); 1501 if (error) 1502 return error; 1503 1504 tasklet_enable(&keyboard_tasklet); 1505 tasklet_schedule(&keyboard_tasklet); 1506 1507 return 0; 1508 } 1509 1510 /* Ioctl support code */ 1511 1512 /** 1513 * vt_do_diacrit - diacritical table updates 1514 * @cmd: ioctl request 1515 * @udp: pointer to user data for ioctl 1516 * @perm: permissions check computed by caller 1517 * 1518 * Update the diacritical tables atomically and safely. Lock them 1519 * against simultaneous keypresses 1520 */ 1521 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm) 1522 { 1523 unsigned long flags; 1524 int asize; 1525 int ret = 0; 1526 1527 switch (cmd) { 1528 case KDGKBDIACR: 1529 { 1530 struct kbdiacrs __user *a = udp; 1531 struct kbdiacr *dia; 1532 int i; 1533 1534 dia = kmalloc(MAX_DIACR * sizeof(struct kbdiacr), 1535 GFP_KERNEL); 1536 if (!dia) 1537 return -ENOMEM; 1538 1539 /* Lock the diacriticals table, make a copy and then 1540 copy it after we unlock */ 1541 spin_lock_irqsave(&kbd_event_lock, flags); 1542 1543 asize = accent_table_size; 1544 for (i = 0; i < asize; i++) { 1545 dia[i].diacr = conv_uni_to_8bit( 1546 accent_table[i].diacr); 1547 dia[i].base = conv_uni_to_8bit( 1548 accent_table[i].base); 1549 dia[i].result = conv_uni_to_8bit( 1550 accent_table[i].result); 1551 } 1552 spin_unlock_irqrestore(&kbd_event_lock, flags); 1553 1554 if (put_user(asize, &a->kb_cnt)) 1555 ret = -EFAULT; 1556 else if (copy_to_user(a->kbdiacr, dia, 1557 asize * sizeof(struct kbdiacr))) 1558 ret = -EFAULT; 1559 kfree(dia); 1560 return ret; 1561 } 1562 case KDGKBDIACRUC: 1563 { 1564 struct kbdiacrsuc __user *a = udp; 1565 void *buf; 1566 1567 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc), 1568 GFP_KERNEL); 1569 if (buf == NULL) 1570 return -ENOMEM; 1571 1572 /* Lock the diacriticals table, make a copy and then 1573 copy it after we unlock */ 1574 spin_lock_irqsave(&kbd_event_lock, flags); 1575 1576 asize = accent_table_size; 1577 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc)); 1578 1579 spin_unlock_irqrestore(&kbd_event_lock, flags); 1580 1581 if (put_user(asize, &a->kb_cnt)) 1582 ret = -EFAULT; 1583 else if (copy_to_user(a->kbdiacruc, buf, 1584 asize*sizeof(struct kbdiacruc))) 1585 ret = -EFAULT; 1586 kfree(buf); 1587 return ret; 1588 } 1589 1590 case KDSKBDIACR: 1591 { 1592 struct kbdiacrs __user *a = udp; 1593 struct kbdiacr *dia = NULL; 1594 unsigned int ct; 1595 int i; 1596 1597 if (!perm) 1598 return -EPERM; 1599 if (get_user(ct, &a->kb_cnt)) 1600 return -EFAULT; 1601 if (ct >= MAX_DIACR) 1602 return -EINVAL; 1603 1604 if (ct) { 1605 dia = kmalloc(sizeof(struct kbdiacr) * ct, 1606 GFP_KERNEL); 1607 if (!dia) 1608 return -ENOMEM; 1609 1610 if (copy_from_user(dia, a->kbdiacr, 1611 sizeof(struct kbdiacr) * ct)) { 1612 kfree(dia); 1613 return -EFAULT; 1614 } 1615 } 1616 1617 spin_lock_irqsave(&kbd_event_lock, flags); 1618 accent_table_size = ct; 1619 for (i = 0; i < ct; i++) { 1620 accent_table[i].diacr = 1621 conv_8bit_to_uni(dia[i].diacr); 1622 accent_table[i].base = 1623 conv_8bit_to_uni(dia[i].base); 1624 accent_table[i].result = 1625 conv_8bit_to_uni(dia[i].result); 1626 } 1627 spin_unlock_irqrestore(&kbd_event_lock, flags); 1628 kfree(dia); 1629 return 0; 1630 } 1631 1632 case KDSKBDIACRUC: 1633 { 1634 struct kbdiacrsuc __user *a = udp; 1635 unsigned int ct; 1636 void *buf = NULL; 1637 1638 if (!perm) 1639 return -EPERM; 1640 1641 if (get_user(ct, &a->kb_cnt)) 1642 return -EFAULT; 1643 1644 if (ct >= MAX_DIACR) 1645 return -EINVAL; 1646 1647 if (ct) { 1648 buf = kmalloc(ct * sizeof(struct kbdiacruc), 1649 GFP_KERNEL); 1650 if (buf == NULL) 1651 return -ENOMEM; 1652 1653 if (copy_from_user(buf, a->kbdiacruc, 1654 ct * sizeof(struct kbdiacruc))) { 1655 kfree(buf); 1656 return -EFAULT; 1657 } 1658 } 1659 spin_lock_irqsave(&kbd_event_lock, flags); 1660 if (ct) 1661 memcpy(accent_table, buf, 1662 ct * sizeof(struct kbdiacruc)); 1663 accent_table_size = ct; 1664 spin_unlock_irqrestore(&kbd_event_lock, flags); 1665 kfree(buf); 1666 return 0; 1667 } 1668 } 1669 return ret; 1670 } 1671 1672 /** 1673 * vt_do_kdskbmode - set keyboard mode ioctl 1674 * @console: the console to use 1675 * @arg: the requested mode 1676 * 1677 * Update the keyboard mode bits while holding the correct locks. 1678 * Return 0 for success or an error code. 1679 */ 1680 int vt_do_kdskbmode(int console, unsigned int arg) 1681 { 1682 struct kbd_struct *kb = kbd_table + console; 1683 int ret = 0; 1684 unsigned long flags; 1685 1686 spin_lock_irqsave(&kbd_event_lock, flags); 1687 switch(arg) { 1688 case K_RAW: 1689 kb->kbdmode = VC_RAW; 1690 break; 1691 case K_MEDIUMRAW: 1692 kb->kbdmode = VC_MEDIUMRAW; 1693 break; 1694 case K_XLATE: 1695 kb->kbdmode = VC_XLATE; 1696 do_compute_shiftstate(); 1697 break; 1698 case K_UNICODE: 1699 kb->kbdmode = VC_UNICODE; 1700 do_compute_shiftstate(); 1701 break; 1702 case K_OFF: 1703 kb->kbdmode = VC_OFF; 1704 break; 1705 default: 1706 ret = -EINVAL; 1707 } 1708 spin_unlock_irqrestore(&kbd_event_lock, flags); 1709 return ret; 1710 } 1711 1712 /** 1713 * vt_do_kdskbmeta - set keyboard meta state 1714 * @console: the console to use 1715 * @arg: the requested meta state 1716 * 1717 * Update the keyboard meta bits while holding the correct locks. 1718 * Return 0 for success or an error code. 1719 */ 1720 int vt_do_kdskbmeta(int console, unsigned int arg) 1721 { 1722 struct kbd_struct *kb = kbd_table + console; 1723 int ret = 0; 1724 unsigned long flags; 1725 1726 spin_lock_irqsave(&kbd_event_lock, flags); 1727 switch(arg) { 1728 case K_METABIT: 1729 clr_vc_kbd_mode(kb, VC_META); 1730 break; 1731 case K_ESCPREFIX: 1732 set_vc_kbd_mode(kb, VC_META); 1733 break; 1734 default: 1735 ret = -EINVAL; 1736 } 1737 spin_unlock_irqrestore(&kbd_event_lock, flags); 1738 return ret; 1739 } 1740 1741 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, 1742 int perm) 1743 { 1744 struct kbkeycode tmp; 1745 int kc = 0; 1746 1747 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode))) 1748 return -EFAULT; 1749 switch (cmd) { 1750 case KDGETKEYCODE: 1751 kc = getkeycode(tmp.scancode); 1752 if (kc >= 0) 1753 kc = put_user(kc, &user_kbkc->keycode); 1754 break; 1755 case KDSETKEYCODE: 1756 if (!perm) 1757 return -EPERM; 1758 kc = setkeycode(tmp.scancode, tmp.keycode); 1759 break; 1760 } 1761 return kc; 1762 } 1763 1764 #define i (tmp.kb_index) 1765 #define s (tmp.kb_table) 1766 #define v (tmp.kb_value) 1767 1768 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm, 1769 int console) 1770 { 1771 struct kbd_struct *kb = kbd_table + console; 1772 struct kbentry tmp; 1773 ushort *key_map, *new_map, val, ov; 1774 unsigned long flags; 1775 1776 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry))) 1777 return -EFAULT; 1778 1779 if (!capable(CAP_SYS_TTY_CONFIG)) 1780 perm = 0; 1781 1782 switch (cmd) { 1783 case KDGKBENT: 1784 /* Ensure another thread doesn't free it under us */ 1785 spin_lock_irqsave(&kbd_event_lock, flags); 1786 key_map = key_maps[s]; 1787 if (key_map) { 1788 val = U(key_map[i]); 1789 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES) 1790 val = K_HOLE; 1791 } else 1792 val = (i ? K_HOLE : K_NOSUCHMAP); 1793 spin_unlock_irqrestore(&kbd_event_lock, flags); 1794 return put_user(val, &user_kbe->kb_value); 1795 case KDSKBENT: 1796 if (!perm) 1797 return -EPERM; 1798 if (!i && v == K_NOSUCHMAP) { 1799 spin_lock_irqsave(&kbd_event_lock, flags); 1800 /* deallocate map */ 1801 key_map = key_maps[s]; 1802 if (s && key_map) { 1803 key_maps[s] = NULL; 1804 if (key_map[0] == U(K_ALLOCATED)) { 1805 kfree(key_map); 1806 keymap_count--; 1807 } 1808 } 1809 spin_unlock_irqrestore(&kbd_event_lock, flags); 1810 break; 1811 } 1812 1813 if (KTYP(v) < NR_TYPES) { 1814 if (KVAL(v) > max_vals[KTYP(v)]) 1815 return -EINVAL; 1816 } else 1817 if (kb->kbdmode != VC_UNICODE) 1818 return -EINVAL; 1819 1820 /* ++Geert: non-PC keyboards may generate keycode zero */ 1821 #if !defined(__mc68000__) && !defined(__powerpc__) 1822 /* assignment to entry 0 only tests validity of args */ 1823 if (!i) 1824 break; 1825 #endif 1826 1827 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL); 1828 if (!new_map) 1829 return -ENOMEM; 1830 spin_lock_irqsave(&kbd_event_lock, flags); 1831 key_map = key_maps[s]; 1832 if (key_map == NULL) { 1833 int j; 1834 1835 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && 1836 !capable(CAP_SYS_RESOURCE)) { 1837 spin_unlock_irqrestore(&kbd_event_lock, flags); 1838 kfree(new_map); 1839 return -EPERM; 1840 } 1841 key_maps[s] = new_map; 1842 key_map = new_map; 1843 key_map[0] = U(K_ALLOCATED); 1844 for (j = 1; j < NR_KEYS; j++) 1845 key_map[j] = U(K_HOLE); 1846 keymap_count++; 1847 } else 1848 kfree(new_map); 1849 1850 ov = U(key_map[i]); 1851 if (v == ov) 1852 goto out; 1853 /* 1854 * Attention Key. 1855 */ 1856 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) { 1857 spin_unlock_irqrestore(&kbd_event_lock, flags); 1858 return -EPERM; 1859 } 1860 key_map[i] = U(v); 1861 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT)) 1862 do_compute_shiftstate(); 1863 out: 1864 spin_unlock_irqrestore(&kbd_event_lock, flags); 1865 break; 1866 } 1867 return 0; 1868 } 1869 #undef i 1870 #undef s 1871 #undef v 1872 1873 /* FIXME: This one needs untangling and locking */ 1874 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm) 1875 { 1876 struct kbsentry *kbs; 1877 char *p; 1878 u_char *q; 1879 u_char __user *up; 1880 int sz; 1881 int delta; 1882 char *first_free, *fj, *fnw; 1883 int i, j, k; 1884 int ret; 1885 1886 if (!capable(CAP_SYS_TTY_CONFIG)) 1887 perm = 0; 1888 1889 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL); 1890 if (!kbs) { 1891 ret = -ENOMEM; 1892 goto reterr; 1893 } 1894 1895 /* we mostly copy too much here (512bytes), but who cares ;) */ 1896 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) { 1897 ret = -EFAULT; 1898 goto reterr; 1899 } 1900 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0'; 1901 i = kbs->kb_func; 1902 1903 switch (cmd) { 1904 case KDGKBSENT: 1905 sz = sizeof(kbs->kb_string) - 1; /* sz should have been 1906 a struct member */ 1907 up = user_kdgkb->kb_string; 1908 p = func_table[i]; 1909 if(p) 1910 for ( ; *p && sz; p++, sz--) 1911 if (put_user(*p, up++)) { 1912 ret = -EFAULT; 1913 goto reterr; 1914 } 1915 if (put_user('\0', up)) { 1916 ret = -EFAULT; 1917 goto reterr; 1918 } 1919 kfree(kbs); 1920 return ((p && *p) ? -EOVERFLOW : 0); 1921 case KDSKBSENT: 1922 if (!perm) { 1923 ret = -EPERM; 1924 goto reterr; 1925 } 1926 1927 q = func_table[i]; 1928 first_free = funcbufptr + (funcbufsize - funcbufleft); 1929 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++) 1930 ; 1931 if (j < MAX_NR_FUNC) 1932 fj = func_table[j]; 1933 else 1934 fj = first_free; 1935 1936 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string); 1937 if (delta <= funcbufleft) { /* it fits in current buf */ 1938 if (j < MAX_NR_FUNC) { 1939 memmove(fj + delta, fj, first_free - fj); 1940 for (k = j; k < MAX_NR_FUNC; k++) 1941 if (func_table[k]) 1942 func_table[k] += delta; 1943 } 1944 if (!q) 1945 func_table[i] = fj; 1946 funcbufleft -= delta; 1947 } else { /* allocate a larger buffer */ 1948 sz = 256; 1949 while (sz < funcbufsize - funcbufleft + delta) 1950 sz <<= 1; 1951 fnw = kmalloc(sz, GFP_KERNEL); 1952 if(!fnw) { 1953 ret = -ENOMEM; 1954 goto reterr; 1955 } 1956 1957 if (!q) 1958 func_table[i] = fj; 1959 if (fj > funcbufptr) 1960 memmove(fnw, funcbufptr, fj - funcbufptr); 1961 for (k = 0; k < j; k++) 1962 if (func_table[k]) 1963 func_table[k] = fnw + (func_table[k] - funcbufptr); 1964 1965 if (first_free > fj) { 1966 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj); 1967 for (k = j; k < MAX_NR_FUNC; k++) 1968 if (func_table[k]) 1969 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta; 1970 } 1971 if (funcbufptr != func_buf) 1972 kfree(funcbufptr); 1973 funcbufptr = fnw; 1974 funcbufleft = funcbufleft - delta + sz - funcbufsize; 1975 funcbufsize = sz; 1976 } 1977 strcpy(func_table[i], kbs->kb_string); 1978 break; 1979 } 1980 ret = 0; 1981 reterr: 1982 kfree(kbs); 1983 return ret; 1984 } 1985 1986 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm) 1987 { 1988 struct kbd_struct *kb = kbd_table + console; 1989 unsigned long flags; 1990 unsigned char ucval; 1991 1992 switch(cmd) { 1993 /* the ioctls below read/set the flags usually shown in the leds */ 1994 /* don't use them - they will go away without warning */ 1995 case KDGKBLED: 1996 spin_lock_irqsave(&kbd_event_lock, flags); 1997 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4); 1998 spin_unlock_irqrestore(&kbd_event_lock, flags); 1999 return put_user(ucval, (char __user *)arg); 2000 2001 case KDSKBLED: 2002 if (!perm) 2003 return -EPERM; 2004 if (arg & ~0x77) 2005 return -EINVAL; 2006 spin_lock_irqsave(&led_lock, flags); 2007 kb->ledflagstate = (arg & 7); 2008 kb->default_ledflagstate = ((arg >> 4) & 7); 2009 set_leds(); 2010 spin_unlock_irqrestore(&led_lock, flags); 2011 return 0; 2012 2013 /* the ioctls below only set the lights, not the functions */ 2014 /* for those, see KDGKBLED and KDSKBLED above */ 2015 case KDGETLED: 2016 ucval = getledstate(); 2017 return put_user(ucval, (char __user *)arg); 2018 2019 case KDSETLED: 2020 if (!perm) 2021 return -EPERM; 2022 setledstate(kb, arg); 2023 return 0; 2024 } 2025 return -ENOIOCTLCMD; 2026 } 2027 2028 int vt_do_kdgkbmode(int console) 2029 { 2030 struct kbd_struct *kb = kbd_table + console; 2031 /* This is a spot read so needs no locking */ 2032 switch (kb->kbdmode) { 2033 case VC_RAW: 2034 return K_RAW; 2035 case VC_MEDIUMRAW: 2036 return K_MEDIUMRAW; 2037 case VC_UNICODE: 2038 return K_UNICODE; 2039 case VC_OFF: 2040 return K_OFF; 2041 default: 2042 return K_XLATE; 2043 } 2044 } 2045 2046 /** 2047 * vt_do_kdgkbmeta - report meta status 2048 * @console: console to report 2049 * 2050 * Report the meta flag status of this console 2051 */ 2052 int vt_do_kdgkbmeta(int console) 2053 { 2054 struct kbd_struct *kb = kbd_table + console; 2055 /* Again a spot read so no locking */ 2056 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT; 2057 } 2058 2059 /** 2060 * vt_reset_unicode - reset the unicode status 2061 * @console: console being reset 2062 * 2063 * Restore the unicode console state to its default 2064 */ 2065 void vt_reset_unicode(int console) 2066 { 2067 unsigned long flags; 2068 2069 spin_lock_irqsave(&kbd_event_lock, flags); 2070 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 2071 spin_unlock_irqrestore(&kbd_event_lock, flags); 2072 } 2073 2074 /** 2075 * vt_get_shiftstate - shift bit state 2076 * 2077 * Report the shift bits from the keyboard state. We have to export 2078 * this to support some oddities in the vt layer. 2079 */ 2080 int vt_get_shift_state(void) 2081 { 2082 /* Don't lock as this is a transient report */ 2083 return shift_state; 2084 } 2085 2086 /** 2087 * vt_reset_keyboard - reset keyboard state 2088 * @console: console to reset 2089 * 2090 * Reset the keyboard bits for a console as part of a general console 2091 * reset event 2092 */ 2093 void vt_reset_keyboard(int console) 2094 { 2095 struct kbd_struct *kb = kbd_table + console; 2096 unsigned long flags; 2097 2098 spin_lock_irqsave(&kbd_event_lock, flags); 2099 set_vc_kbd_mode(kb, VC_REPEAT); 2100 clr_vc_kbd_mode(kb, VC_CKMODE); 2101 clr_vc_kbd_mode(kb, VC_APPLIC); 2102 clr_vc_kbd_mode(kb, VC_CRLF); 2103 kb->lockstate = 0; 2104 kb->slockstate = 0; 2105 spin_lock(&led_lock); 2106 kb->ledmode = LED_SHOW_FLAGS; 2107 kb->ledflagstate = kb->default_ledflagstate; 2108 spin_unlock(&led_lock); 2109 /* do not do set_leds here because this causes an endless tasklet loop 2110 when the keyboard hasn't been initialized yet */ 2111 spin_unlock_irqrestore(&kbd_event_lock, flags); 2112 } 2113 2114 /** 2115 * vt_get_kbd_mode_bit - read keyboard status bits 2116 * @console: console to read from 2117 * @bit: mode bit to read 2118 * 2119 * Report back a vt mode bit. We do this without locking so the 2120 * caller must be sure that there are no synchronization needs 2121 */ 2122 2123 int vt_get_kbd_mode_bit(int console, int bit) 2124 { 2125 struct kbd_struct *kb = kbd_table + console; 2126 return vc_kbd_mode(kb, bit); 2127 } 2128 2129 /** 2130 * vt_set_kbd_mode_bit - read keyboard status bits 2131 * @console: console to read from 2132 * @bit: mode bit to read 2133 * 2134 * Set a vt mode bit. We do this without locking so the 2135 * caller must be sure that there are no synchronization needs 2136 */ 2137 2138 void vt_set_kbd_mode_bit(int console, int bit) 2139 { 2140 struct kbd_struct *kb = kbd_table + console; 2141 unsigned long flags; 2142 2143 spin_lock_irqsave(&kbd_event_lock, flags); 2144 set_vc_kbd_mode(kb, bit); 2145 spin_unlock_irqrestore(&kbd_event_lock, flags); 2146 } 2147 2148 /** 2149 * vt_clr_kbd_mode_bit - read keyboard status bits 2150 * @console: console to read from 2151 * @bit: mode bit to read 2152 * 2153 * Report back a vt mode bit. We do this without locking so the 2154 * caller must be sure that there are no synchronization needs 2155 */ 2156 2157 void vt_clr_kbd_mode_bit(int console, int bit) 2158 { 2159 struct kbd_struct *kb = kbd_table + console; 2160 unsigned long flags; 2161 2162 spin_lock_irqsave(&kbd_event_lock, flags); 2163 clr_vc_kbd_mode(kb, bit); 2164 spin_unlock_irqrestore(&kbd_event_lock, flags); 2165 } 2166