projects / deliverable / linux.git / blob
? search:


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