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