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