?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / char / keyboard.c
blob80cbf0d4031997484034441ae83500a84ecba9d1
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29 #include <linux/consolemap.h>
30 #include <linux/module.h>
31 #include <linux/sched.h>
32 #include <linux/tty.h>
33 #include <linux/tty_flip.h>
34 #include <linux/mm.h>
35 #include <linux/string.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/irq.h>
39
40 #include <linux/kbd_kern.h>
41 #include <linux/kbd_diacr.h>
42 #include <linux/vt_kern.h>
43 #include <linux/input.h>
44 #include <linux/reboot.h>
45 #include <linux/notifier.h>
46 #include <linux/jiffies.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 /*
57 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
58 * This seems a good reason to start with NumLock off. On HIL keyboards
59 * of PARISC machines however there is no NumLock key and everyone expects the keypad
60 * to be used for numbers.
61 */
62
63 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || \
64 defined(CONFIG_KEYBOARD_HIL_OLD))
65 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
66 #else
67 #define KBD_DEFLEDS 0
68 #endif
69
70 #define KBD_DEFLOCK 0
71
72 void compute_shiftstate(void);
73
74 /*
75 * Handler Tables.
76 */
77
78 #define K_HANDLERS\
79 k_self, k_fn, k_spec, k_pad,\
80 k_dead, k_cons, k_cur, k_shift,\
81 k_meta, k_ascii, k_lock, k_lowercase,\
82 k_slock, k_dead2, k_brl, k_ignore
83
84 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
85 char up_flag);
86 static k_handler_fn K_HANDLERS;
87 static k_handler_fn *k_handler[16] = { K_HANDLERS };
88
89 #define FN_HANDLERS\
90 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
91 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
92 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
93 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
94 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
95
96 typedef void (fn_handler_fn)(struct vc_data *vc);
97 static fn_handler_fn FN_HANDLERS;
98 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
99
100 /*
101 * Variables exported for vt_ioctl.c
102 */
103
104 /* maximum values each key_handler can handle */
105 const int max_vals[] = {
106 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
107 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
108 255, NR_LOCK - 1, 255, NR_BRL - 1
109 };
110
111 const int NR_TYPES = ARRAY_SIZE(max_vals);
112
113 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
114 EXPORT_SYMBOL_GPL(kbd_table);
115 static struct kbd_struct *kbd = kbd_table;
116
117 struct vt_spawn_console vt_spawn_con = {
118 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
119 .pid = NULL,
120 .sig = 0,
121 };
122
123 /*
124 * Variables exported for vt.c
125 */
126
127 int shift_state = 0;
128
129 /*
130 * Internal Data.
131 */
132
133 static struct input_handler kbd_handler;
134 static DEFINE_SPINLOCK(kbd_event_lock);
135 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
136 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
137 static bool dead_key_next;
138 static int npadch = -1; /* -1 or number assembled on pad */
139 static unsigned int diacr;
140 static char rep; /* flag telling character repeat */
141
142 static unsigned char ledstate = 0xff; /* undefined */
143 static unsigned char ledioctl;
144
145 static struct ledptr {
146 unsigned int *addr;
147 unsigned int mask;
148 unsigned char valid:1;
149 } ledptrs[3];
150
151 /*
152 * Notifier list for console keyboard events
153 */
154 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
155
156 int register_keyboard_notifier(struct notifier_block *nb)
157 {
158 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
159 }
160 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
161
162 int unregister_keyboard_notifier(struct notifier_block *nb)
163 {
164 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
165 }
166 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
167
168 /*
169 * Translation of scancodes to keycodes. We set them on only the first
170 * keyboard in the list that accepts the scancode and keycode.
171 * Explanation for not choosing the first attached keyboard anymore:
172 * USB keyboards for example have two event devices: one for all "normal"
173 * keys and one for extra function keys (like "volume up", "make coffee",
174 * etc.). So this means that scancodes for the extra function keys won't
175 * be valid for the first event device, but will be for the second.
176 */
177
178 struct getset_keycode_data {
179 unsigned int scancode;
180 unsigned int keycode;
181 int error;
182 };
183
184 static int getkeycode_helper(struct input_handle *handle, void *data)
185 {
186 struct getset_keycode_data *d = data;
187
188 d->error = input_get_keycode(handle->dev, d->scancode, &d->keycode);
189
190 return d->error == 0; /* stop as soon as we successfully get one */
191 }
192
193 int getkeycode(unsigned int scancode)
194 {
195 struct getset_keycode_data d = { scancode, 0, -ENODEV };
196
197 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
198
199 return d.error ?: d.keycode;
200 }
201
202 static int setkeycode_helper(struct input_handle *handle, void *data)
203 {
204 struct getset_keycode_data *d = data;
205
206 d->error = input_set_keycode(handle->dev, d->scancode, d->keycode);
207
208 return d->error == 0; /* stop as soon as we successfully set one */
209 }
210
211 int setkeycode(unsigned int scancode, unsigned int keycode)
212 {
213 struct getset_keycode_data d = { scancode, keycode, -ENODEV };
214
215 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
216
217 return d.error;
218 }
219
220 /*
221 * Making beeps and bells. Note that we prefer beeps to bells, but when
222 * shutting the sound off we do both.
223 */
224
225 static int kd_sound_helper(struct input_handle *handle, void *data)
226 {
227 unsigned int *hz = data;
228 struct input_dev *dev = handle->dev;
229
230 if (test_bit(EV_SND, dev->evbit)) {
231 if (test_bit(SND_TONE, dev->sndbit)) {
232 input_inject_event(handle, EV_SND, SND_TONE, *hz);
233 if (*hz)
234 return 0;
235 }
236 if (test_bit(SND_BELL, dev->sndbit))
237 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
238 }
239
240 return 0;
241 }
242
243 static void kd_nosound(unsigned long ignored)
244 {
245 static unsigned int zero;
246
247 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
248 }
249
250 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
251
252 void kd_mksound(unsigned int hz, unsigned int ticks)
253 {
254 del_timer_sync(&kd_mksound_timer);
255
256 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
257
258 if (hz && ticks)
259 mod_timer(&kd_mksound_timer, jiffies + ticks);
260 }
261 EXPORT_SYMBOL(kd_mksound);
262
263 /*
264 * Setting the keyboard rate.
265 */
266
267 static int kbd_rate_helper(struct input_handle *handle, void *data)
268 {
269 struct input_dev *dev = handle->dev;
270 struct kbd_repeat *rep = data;
271
272 if (test_bit(EV_REP, dev->evbit)) {
273
274 if (rep[0].delay > 0)
275 input_inject_event(handle,
276 EV_REP, REP_DELAY, rep[0].delay);
277 if (rep[0].period > 0)
278 input_inject_event(handle,
279 EV_REP, REP_PERIOD, rep[0].period);
280
281 rep[1].delay = dev->rep[REP_DELAY];
282 rep[1].period = dev->rep[REP_PERIOD];
283 }
284
285 return 0;
286 }
287
288 int kbd_rate(struct kbd_repeat *rep)
289 {
290 struct kbd_repeat data[2] = { *rep };
291
292 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
293 *rep = data[1]; /* Copy currently used settings */
294
295 return 0;
296 }
297
298 /*
299 * Helper Functions.
300 */
301 static void put_queue(struct vc_data *vc, int ch)
302 {
303 struct tty_struct *tty = vc->port.tty;
304
305 if (tty) {
306 tty_insert_flip_char(tty, ch, 0);
307 con_schedule_flip(tty);
308 }
309 }
310
311 static void puts_queue(struct vc_data *vc, char *cp)
312 {
313 struct tty_struct *tty = vc->port.tty;
314
315 if (!tty)
316 return;
317
318 while (*cp) {
319 tty_insert_flip_char(tty, *cp, 0);
320 cp++;
321 }
322 con_schedule_flip(tty);
323 }
324
325 static void applkey(struct vc_data *vc, int key, char mode)
326 {
327 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
328
329 buf[1] = (mode ? 'O' : '[');
330 buf[2] = key;
331 puts_queue(vc, buf);
332 }
333
334 /*
335 * Many other routines do put_queue, but I think either
336 * they produce ASCII, or they produce some user-assigned
337 * string, and in both cases we might assume that it is
338 * in utf-8 already.
339 */
340 static void to_utf8(struct vc_data *vc, uint c)
341 {
342 if (c < 0x80)
343 /* 0******* */
344 put_queue(vc, c);
345 else if (c < 0x800) {
346 /* 110***** 10****** */
347 put_queue(vc, 0xc0 | (c >> 6));
348 put_queue(vc, 0x80 | (c & 0x3f));
349 } else if (c < 0x10000) {
350 if (c >= 0xD800 && c < 0xE000)
351 return;
352 if (c == 0xFFFF)
353 return;
354 /* 1110**** 10****** 10****** */
355 put_queue(vc, 0xe0 | (c >> 12));
356 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
357 put_queue(vc, 0x80 | (c & 0x3f));
358 } else if (c < 0x110000) {
359 /* 11110*** 10****** 10****** 10****** */
360 put_queue(vc, 0xf0 | (c >> 18));
361 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
362 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
363 put_queue(vc, 0x80 | (c & 0x3f));
364 }
365 }
366
367 /*
368 * Called after returning from RAW mode or when changing consoles - recompute
369 * shift_down[] and shift_state from key_down[] maybe called when keymap is
370 * undefined, so that shiftkey release is seen
371 */
372 void compute_shiftstate(void)
373 {
374 unsigned int i, j, k, sym, val;
375
376 shift_state = 0;
377 memset(shift_down, 0, sizeof(shift_down));
378
379 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
380
381 if (!key_down[i])
382 continue;
383
384 k = i * BITS_PER_LONG;
385
386 for (j = 0; j < BITS_PER_LONG; j++, k++) {
387
388 if (!test_bit(k, key_down))
389 continue;
390
391 sym = U(key_maps[0][k]);
392 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
393 continue;
394
395 val = KVAL(sym);
396 if (val == KVAL(K_CAPSSHIFT))
397 val = KVAL(K_SHIFT);
398
399 shift_down[val]++;
400 shift_state |= (1 << val);
401 }
402 }
403 }
404
405 /*
406 * We have a combining character DIACR here, followed by the character CH.
407 * If the combination occurs in the table, return the corresponding value.
408 * Otherwise, if CH is a space or equals DIACR, return DIACR.
409 * Otherwise, conclude that DIACR was not combining after all,
410 * queue it and return CH.
411 */
412 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
413 {
414 unsigned int d = diacr;
415 unsigned int i;
416
417 diacr = 0;
418
419 if ((d & ~0xff) == BRL_UC_ROW) {
420 if ((ch & ~0xff) == BRL_UC_ROW)
421 return d | ch;
422 } else {
423 for (i = 0; i < accent_table_size; i++)
424 if (accent_table[i].diacr == d && accent_table[i].base == ch)
425 return accent_table[i].result;
426 }
427
428 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
429 return d;
430
431 if (kbd->kbdmode == VC_UNICODE)
432 to_utf8(vc, d);
433 else {
434 int c = conv_uni_to_8bit(d);
435 if (c != -1)
436 put_queue(vc, c);
437 }
438
439 return ch;
440 }
441
442 /*
443 * Special function handlers
444 */
445 static void fn_enter(struct vc_data *vc)
446 {
447 if (diacr) {
448 if (kbd->kbdmode == VC_UNICODE)
449 to_utf8(vc, diacr);
450 else {
451 int c = conv_uni_to_8bit(diacr);
452 if (c != -1)
453 put_queue(vc, c);
454 }
455 diacr = 0;
456 }
457
458 put_queue(vc, 13);
459 if (vc_kbd_mode(kbd, VC_CRLF))
460 put_queue(vc, 10);
461 }
462
463 static void fn_caps_toggle(struct vc_data *vc)
464 {
465 if (rep)
466 return;
467
468 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
469 }
470
471 static void fn_caps_on(struct vc_data *vc)
472 {
473 if (rep)
474 return;
475
476 set_vc_kbd_led(kbd, VC_CAPSLOCK);
477 }
478
479 static void fn_show_ptregs(struct vc_data *vc)
480 {
481 struct pt_regs *regs = get_irq_regs();
482
483 if (regs)
484 show_regs(regs);
485 }
486
487 static void fn_hold(struct vc_data *vc)
488 {
489 struct tty_struct *tty = vc->port.tty;
490
491 if (rep || !tty)
492 return;
493
494 /*
495 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
496 * these routines are also activated by ^S/^Q.
497 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
498 */
499 if (tty->stopped)
500 start_tty(tty);
501 else
502 stop_tty(tty);
503 }
504
505 static void fn_num(struct vc_data *vc)
506 {
507 if (vc_kbd_mode(kbd, VC_APPLIC))
508 applkey(vc, 'P', 1);
509 else
510 fn_bare_num(vc);
511 }
512
513 /*
514 * Bind this to Shift-NumLock if you work in application keypad mode
515 * but want to be able to change the NumLock flag.
516 * Bind this to NumLock if you prefer that the NumLock key always
517 * changes the NumLock flag.
518 */
519 static void fn_bare_num(struct vc_data *vc)
520 {
521 if (!rep)
522 chg_vc_kbd_led(kbd, VC_NUMLOCK);
523 }
524
525 static void fn_lastcons(struct vc_data *vc)
526 {
527 /* switch to the last used console, ChN */
528 set_console(last_console);
529 }
530
531 static void fn_dec_console(struct vc_data *vc)
532 {
533 int i, cur = fg_console;
534
535 /* Currently switching? Queue this next switch relative to that. */
536 if (want_console != -1)
537 cur = want_console;
538
539 for (i = cur - 1; i != cur; i--) {
540 if (i == -1)
541 i = MAX_NR_CONSOLES - 1;
542 if (vc_cons_allocated(i))
543 break;
544 }
545 set_console(i);
546 }
547
548 static void fn_inc_console(struct vc_data *vc)
549 {
550 int i, cur = fg_console;
551
552 /* Currently switching? Queue this next switch relative to that. */
553 if (want_console != -1)
554 cur = want_console;
555
556 for (i = cur+1; i != cur; i++) {
557 if (i == MAX_NR_CONSOLES)
558 i = 0;
559 if (vc_cons_allocated(i))
560 break;
561 }
562 set_console(i);
563 }
564
565 static void fn_send_intr(struct vc_data *vc)
566 {
567 struct tty_struct *tty = vc->port.tty;
568
569 if (!tty)
570 return;
571 tty_insert_flip_char(tty, 0, TTY_BREAK);
572 con_schedule_flip(tty);
573 }
574
575 static void fn_scroll_forw(struct vc_data *vc)
576 {
577 scrollfront(vc, 0);
578 }
579
580 static void fn_scroll_back(struct vc_data *vc)
581 {
582 scrollback(vc, 0);
583 }
584
585 static void fn_show_mem(struct vc_data *vc)
586 {
587 show_mem();
588 }
589
590 static void fn_show_state(struct vc_data *vc)
591 {
592 show_state();
593 }
594
595 static void fn_boot_it(struct vc_data *vc)
596 {
597 ctrl_alt_del();
598 }
599
600 static void fn_compose(struct vc_data *vc)
601 {
602 dead_key_next = true;
603 }
604
605 static void fn_spawn_con(struct vc_data *vc)
606 {
607 spin_lock(&vt_spawn_con.lock);
608 if (vt_spawn_con.pid)
609 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
610 put_pid(vt_spawn_con.pid);
611 vt_spawn_con.pid = NULL;
612 }
613 spin_unlock(&vt_spawn_con.lock);
614 }
615
616 static void fn_SAK(struct vc_data *vc)
617 {
618 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
619 schedule_work(SAK_work);
620 }
621
622 static void fn_null(struct vc_data *vc)
623 {
624 compute_shiftstate();
625 }
626
627 /*
628 * Special key handlers
629 */
630 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
631 {
632 }
633
634 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
635 {
636 if (up_flag)
637 return;
638 if (value >= ARRAY_SIZE(fn_handler))
639 return;
640 if ((kbd->kbdmode == VC_RAW ||
641 kbd->kbdmode == VC_MEDIUMRAW) &&
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_warning("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 unsigned char getledstate(void)
970 {
971 return ledstate;
972 }
973
974 void setledstate(struct kbd_struct *kbd, unsigned int led)
975 {
976 if (!(led & ~7)) {
977 ledioctl = led;
978 kbd->ledmode = LED_SHOW_IOCTL;
979 } else
980 kbd->ledmode = LED_SHOW_FLAGS;
981
982 set_leds();
983 }
984
985 static inline unsigned char getleds(void)
986 {
987 struct kbd_struct *kbd = kbd_table + fg_console;
988 unsigned char leds;
989 int i;
990
991 if (kbd->ledmode == LED_SHOW_IOCTL)
992 return ledioctl;
993
994 leds = kbd->ledflagstate;
995
996 if (kbd->ledmode == LED_SHOW_MEM) {
997 for (i = 0; i < 3; i++)
998 if (ledptrs[i].valid) {
999 if (*ledptrs[i].addr & ledptrs[i].mask)
1000 leds |= (1 << i);
1001 else
1002 leds &= ~(1 << i);
1003 }
1004 }
1005 return leds;
1006 }
1007
1008 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1009 {
1010 unsigned char leds = *(unsigned char *)data;
1011
1012 if (test_bit(EV_LED, handle->dev->evbit)) {
1013 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1014 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1015 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1016 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1017 }
1018
1019 return 0;
1020 }
1021
1022 /*
1023 * This is the tasklet that updates LED state on all keyboards
1024 * attached to the box. The reason we use tasklet is that we
1025 * need to handle the scenario when keyboard handler is not
1026 * registered yet but we already getting updates form VT to
1027 * update led state.
1028 */
1029 static void kbd_bh(unsigned long dummy)
1030 {
1031 unsigned char leds = getleds();
1032
1033 if (leds != ledstate) {
1034 input_handler_for_each_handle(&kbd_handler, &leds,
1035 kbd_update_leds_helper);
1036 ledstate = leds;
1037 }
1038 }
1039
1040 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1041
1042 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) || \
1043 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) || \
1044 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) || (defined(CONFIG_ARM) && \
1045 defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) || defined(CONFIG_AVR32)
1046
1047 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1048 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1049
1050 static const unsigned short x86_keycodes[256] =
1051 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1052 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1053 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1054 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1055 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1056 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1057 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1058 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1059 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1060 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1061 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1062 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1063 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1064 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1065 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1066
1067 #ifdef CONFIG_SPARC
1068 static int sparc_l1_a_state;
1069 extern void sun_do_break(void);
1070 #endif
1071
1072 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1073 unsigned char up_flag)
1074 {
1075 int code;
1076
1077 switch (keycode) {
1078
1079 case KEY_PAUSE:
1080 put_queue(vc, 0xe1);
1081 put_queue(vc, 0x1d | up_flag);
1082 put_queue(vc, 0x45 | up_flag);
1083 break;
1084
1085 case KEY_HANGEUL:
1086 if (!up_flag)
1087 put_queue(vc, 0xf2);
1088 break;
1089
1090 case KEY_HANJA:
1091 if (!up_flag)
1092 put_queue(vc, 0xf1);
1093 break;
1094
1095 case KEY_SYSRQ:
1096 /*
1097 * Real AT keyboards (that's what we're trying
1098 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1099 * pressing PrtSc/SysRq alone, but simply 0x54
1100 * when pressing Alt+PrtSc/SysRq.
1101 */
1102 if (test_bit(KEY_LEFTALT, key_down) ||
1103 test_bit(KEY_RIGHTALT, key_down)) {
1104 put_queue(vc, 0x54 | up_flag);
1105 } else {
1106 put_queue(vc, 0xe0);
1107 put_queue(vc, 0x2a | up_flag);
1108 put_queue(vc, 0xe0);
1109 put_queue(vc, 0x37 | up_flag);
1110 }
1111 break;
1112
1113 default:
1114 if (keycode > 255)
1115 return -1;
1116
1117 code = x86_keycodes[keycode];
1118 if (!code)
1119 return -1;
1120
1121 if (code & 0x100)
1122 put_queue(vc, 0xe0);
1123 put_queue(vc, (code & 0x7f) | up_flag);
1124
1125 break;
1126 }
1127
1128 return 0;
1129 }
1130
1131 #else
1132
1133 #define HW_RAW(dev) 0
1134
1135 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1136 {
1137 if (keycode > 127)
1138 return -1;
1139
1140 put_queue(vc, keycode | up_flag);
1141 return 0;
1142 }
1143 #endif
1144
1145 static void kbd_rawcode(unsigned char data)
1146 {
1147 struct vc_data *vc = vc_cons[fg_console].d;
1148
1149 kbd = kbd_table + vc->vc_num;
1150 if (kbd->kbdmode == VC_RAW)
1151 put_queue(vc, data);
1152 }
1153
1154 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1155 {
1156 struct vc_data *vc = vc_cons[fg_console].d;
1157 unsigned short keysym, *key_map;
1158 unsigned char type;
1159 bool raw_mode;
1160 struct tty_struct *tty;
1161 int shift_final;
1162 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1163 int rc;
1164
1165 tty = vc->port.tty;
1166
1167 if (tty && (!tty->driver_data)) {
1168 /* No driver data? Strange. Okay we fix it then. */
1169 tty->driver_data = vc;
1170 }
1171
1172 kbd = kbd_table + vc->vc_num;
1173
1174 #ifdef CONFIG_SPARC
1175 if (keycode == KEY_STOP)
1176 sparc_l1_a_state = down;
1177 #endif
1178
1179 rep = (down == 2);
1180
1181 raw_mode = (kbd->kbdmode == VC_RAW);
1182 if (raw_mode && !hw_raw)
1183 if (emulate_raw(vc, keycode, !down << 7))
1184 if (keycode < BTN_MISC && printk_ratelimit())
1185 pr_warning("can't emulate rawmode for keycode %d\n",
1186 keycode);
1187
1188 #ifdef CONFIG_SPARC
1189 if (keycode == KEY_A && sparc_l1_a_state) {
1190 sparc_l1_a_state = false;
1191 sun_do_break();
1192 }
1193 #endif
1194
1195 if (kbd->kbdmode == VC_MEDIUMRAW) {
1196 /*
1197 * This is extended medium raw mode, with keys above 127
1198 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1199 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1200 * interfere with anything else. The two bytes after 0 will
1201 * always have the up flag set not to interfere with older
1202 * applications. This allows for 16384 different keycodes,
1203 * which should be enough.
1204 */
1205 if (keycode < 128) {
1206 put_queue(vc, keycode | (!down << 7));
1207 } else {
1208 put_queue(vc, !down << 7);
1209 put_queue(vc, (keycode >> 7) | 0x80);
1210 put_queue(vc, keycode | 0x80);
1211 }
1212 raw_mode = true;
1213 }
1214
1215 if (down)
1216 set_bit(keycode, key_down);
1217 else
1218 clear_bit(keycode, key_down);
1219
1220 if (rep &&
1221 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1222 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1223 /*
1224 * Don't repeat a key if the input buffers are not empty and the
1225 * characters get aren't echoed locally. This makes key repeat
1226 * usable with slow applications and under heavy loads.
1227 */
1228 return;
1229 }
1230
1231 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1232 param.ledstate = kbd->ledflagstate;
1233 key_map = key_maps[shift_final];
1234
1235 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1236 KBD_KEYCODE, &param);
1237 if (rc == NOTIFY_STOP || !key_map) {
1238 atomic_notifier_call_chain(&keyboard_notifier_list,
1239 KBD_UNBOUND_KEYCODE, &param);
1240 compute_shiftstate();
1241 kbd->slockstate = 0;
1242 return;
1243 }
1244
1245 if (keycode < NR_KEYS)
1246 keysym = key_map[keycode];
1247 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1248 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1249 else
1250 return;
1251
1252 type = KTYP(keysym);
1253
1254 if (type < 0xf0) {
1255 param.value = keysym;
1256 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1257 KBD_UNICODE, &param);
1258 if (rc != NOTIFY_STOP)
1259 if (down && !raw_mode)
1260 to_utf8(vc, keysym);
1261 return;
1262 }
1263
1264 type -= 0xf0;
1265
1266 if (type == KT_LETTER) {
1267 type = KT_LATIN;
1268 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1269 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1270 if (key_map)
1271 keysym = key_map[keycode];
1272 }
1273 }
1274
1275 param.value = keysym;
1276 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1277 KBD_KEYSYM, &param);
1278 if (rc == NOTIFY_STOP)
1279 return;
1280
1281 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1282 return;
1283
1284 (*k_handler[type])(vc, keysym & 0xff, !down);
1285
1286 param.ledstate = kbd->ledflagstate;
1287 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1288
1289 if (type != KT_SLOCK)
1290 kbd->slockstate = 0;
1291 }
1292
1293 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1294 unsigned int event_code, int value)
1295 {
1296 /* We are called with interrupts disabled, just take the lock */
1297 spin_lock(&kbd_event_lock);
1298
1299 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1300 kbd_rawcode(value);
1301 if (event_type == EV_KEY)
1302 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1303
1304 spin_unlock(&kbd_event_lock);
1305
1306 tasklet_schedule(&keyboard_tasklet);
1307 do_poke_blanked_console = 1;
1308 schedule_console_callback();
1309 }
1310
1311 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1312 {
1313 int i;
1314
1315 if (test_bit(EV_SND, dev->evbit))
1316 return true;
1317
1318 if (test_bit(EV_KEY, dev->evbit)) {
1319 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1320 if (test_bit(i, dev->keybit))
1321 return true;
1322 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1323 if (test_bit(i, dev->keybit))
1324 return true;
1325 }
1326
1327 return false;
1328 }
1329
1330 /*
1331 * When a keyboard (or other input device) is found, the kbd_connect
1332 * function is called. The function then looks at the device, and if it
1333 * likes it, it can open it and get events from it. In this (kbd_connect)
1334 * function, we should decide which VT to bind that keyboard to initially.
1335 */
1336 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1337 const struct input_device_id *id)
1338 {
1339 struct input_handle *handle;
1340 int error;
1341
1342 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1343 if (!handle)
1344 return -ENOMEM;
1345
1346 handle->dev = dev;
1347 handle->handler = handler;
1348 handle->name = "kbd";
1349
1350 error = input_register_handle(handle);
1351 if (error)
1352 goto err_free_handle;
1353
1354 error = input_open_device(handle);
1355 if (error)
1356 goto err_unregister_handle;
1357
1358 return 0;
1359
1360 err_unregister_handle:
1361 input_unregister_handle(handle);
1362 err_free_handle:
1363 kfree(handle);
1364 return error;
1365 }
1366
1367 static void kbd_disconnect(struct input_handle *handle)
1368 {
1369 input_close_device(handle);
1370 input_unregister_handle(handle);
1371 kfree(handle);
1372 }
1373
1374 /*
1375 * Start keyboard handler on the new keyboard by refreshing LED state to
1376 * match the rest of the system.
1377 */
1378 static void kbd_start(struct input_handle *handle)
1379 {
1380 tasklet_disable(&keyboard_tasklet);
1381
1382 if (ledstate != 0xff)
1383 kbd_update_leds_helper(handle, &ledstate);
1384
1385 tasklet_enable(&keyboard_tasklet);
1386 }
1387
1388 static const struct input_device_id kbd_ids[] = {
1389 {
1390 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1391 .evbit = { BIT_MASK(EV_KEY) },
1392 },
1393
1394 {
1395 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1396 .evbit = { BIT_MASK(EV_SND) },
1397 },
1398
1399 { }, /* Terminating entry */
1400 };
1401
1402 MODULE_DEVICE_TABLE(input, kbd_ids);
1403
1404 static struct input_handler kbd_handler = {
1405 .event = kbd_event,
1406 .match = kbd_match,
1407 .connect = kbd_connect,
1408 .disconnect = kbd_disconnect,
1409 .start = kbd_start,
1410 .name = "kbd",
1411 .id_table = kbd_ids,
1412 };
1413
1414 int __init kbd_init(void)
1415 {
1416 int i;
1417 int error;
1418
1419 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1420 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1421 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1422 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1423 kbd_table[i].lockstate = KBD_DEFLOCK;
1424 kbd_table[i].slockstate = 0;
1425 kbd_table[i].modeflags = KBD_DEFMODE;
1426 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1427 }
1428
1429 error = input_register_handler(&kbd_handler);
1430 if (error)
1431 return error;
1432
1433 tasklet_enable(&keyboard_tasklet);
1434 tasklet_schedule(&keyboard_tasklet);
1435
1436 return 0;
1437 }
Tomato firmware and modifications.