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