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