projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid
[deliverable/linux.git] / drivers / tty / vt / keyboard.c
1 /*
2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
4 *
5 * Some additional features added by Christoph Niemann (ChN), March 1993
6 *
7 * Loadable keymaps by Risto Kankkunen, May 1993
8 *
9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
10 * Added decr/incr_console, dynamic keymaps, Unicode support,
11 * dynamic function/string keys, led setting, Sept 1994
12 * `Sticky' modifier keys, 951006.
13 *
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
15 *
16 * Modified to provide 'generic' keyboard support by Hamish Macdonald
17 * Merge with the m68k keyboard driver and split-off of the PC low-level
18 * parts by Geert Uytterhoeven, May 1997
19 *
20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
21 * 30-07-98: Dead keys redone, aeb@cwi.nl.
22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
23 */
24
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27 #include <linux/consolemap.h>
28 #include <linux/module.h>
29 #include <linux/sched.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
32 #include <linux/mm.h>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36
37 #include <linux/kbd_kern.h>
38 #include <linux/kbd_diacr.h>
39 #include <linux/vt_kern.h>
40 #include <linux/input.h>
41 #include <linux/reboot.h>
42 #include <linux/notifier.h>
43 #include <linux/jiffies.h>
44 #include <linux/uaccess.h>
45
46 #include <asm/irq_regs.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 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
57 #include <asm/kbdleds.h>
58 #else
59 static inline int kbd_defleds(void)
60 {
61 return 0;
62 }
63 #endif
64
65 #define KBD_DEFLOCK 0
66
67 /*
68 * Handler Tables.
69 */
70
71 #define K_HANDLERS\
72 k_self, k_fn, k_spec, k_pad,\
73 k_dead, k_cons, k_cur, k_shift,\
74 k_meta, k_ascii, k_lock, k_lowercase,\
75 k_slock, k_dead2, k_brl, k_ignore
76
77 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
78 char up_flag);
79 static k_handler_fn K_HANDLERS;
80 static k_handler_fn *k_handler[16] = { K_HANDLERS };
81
82 #define FN_HANDLERS\
83 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
84 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
85 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
86 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
87 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
88
89 typedef void (fn_handler_fn)(struct vc_data *vc);
90 static fn_handler_fn FN_HANDLERS;
91 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
92
93 /*
94 * Variables exported for vt_ioctl.c
95 */
96
97 struct vt_spawn_console vt_spawn_con = {
98 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
99 .pid = NULL,
100 .sig = 0,
101 };
102
103
104 /*
105 * Internal Data.
106 */
107
108 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
110
111 /* maximum values each key_handler can handle */
112 static const int max_vals[] = {
113 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
114 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
115 255, NR_LOCK - 1, 255, NR_BRL - 1
116 };
117
118 static const int NR_TYPES = ARRAY_SIZE(max_vals);
119
120 static struct input_handler kbd_handler;
121 static DEFINE_SPINLOCK(kbd_event_lock);
122 static DEFINE_SPINLOCK(led_lock);
123 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
124 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
125 static bool dead_key_next;
126 static int npadch = -1; /* -1 or number assembled on pad */
127 static unsigned int diacr;
128 static char rep; /* flag telling character repeat */
129
130 static int shift_state = 0;
131
132 static unsigned char ledstate = 0xff; /* undefined */
133 static unsigned char ledioctl;
134
135 /*
136 * Notifier list for console keyboard events
137 */
138 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
139
140 int register_keyboard_notifier(struct notifier_block *nb)
141 {
142 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
143 }
144 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
145
146 int unregister_keyboard_notifier(struct notifier_block *nb)
147 {
148 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
149 }
150 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
151
152 /*
153 * Translation of scancodes to keycodes. We set them on only the first
154 * keyboard in the list that accepts the scancode and keycode.
155 * Explanation for not choosing the first attached keyboard anymore:
156 * USB keyboards for example have two event devices: one for all "normal"
157 * keys and one for extra function keys (like "volume up", "make coffee",
158 * etc.). So this means that scancodes for the extra function keys won't
159 * be valid for the first event device, but will be for the second.
160 */
161
162 struct getset_keycode_data {
163 struct input_keymap_entry ke;
164 int error;
165 };
166
167 static int getkeycode_helper(struct input_handle *handle, void *data)
168 {
169 struct getset_keycode_data *d = data;
170
171 d->error = input_get_keycode(handle->dev, &d->ke);
172
173 return d->error == 0; /* stop as soon as we successfully get one */
174 }
175
176 static int getkeycode(unsigned int scancode)
177 {
178 struct getset_keycode_data d = {
179 .ke = {
180 .flags = 0,
181 .len = sizeof(scancode),
182 .keycode = 0,
183 },
184 .error = -ENODEV,
185 };
186
187 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
188
189 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
190
191 return d.error ?: d.ke.keycode;
192 }
193
194 static int setkeycode_helper(struct input_handle *handle, void *data)
195 {
196 struct getset_keycode_data *d = data;
197
198 d->error = input_set_keycode(handle->dev, &d->ke);
199
200 return d->error == 0; /* stop as soon as we successfully set one */
201 }
202
203 static int setkeycode(unsigned int scancode, unsigned int keycode)
204 {
205 struct getset_keycode_data d = {
206 .ke = {
207 .flags = 0,
208 .len = sizeof(scancode),
209 .keycode = keycode,
210 },
211 .error = -ENODEV,
212 };
213
214 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
215
216 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
217
218 return d.error;
219 }
220
221 /*
222 * Making beeps and bells. Note that we prefer beeps to bells, but when
223 * shutting the sound off we do both.
224 */
225
226 static int kd_sound_helper(struct input_handle *handle, void *data)
227 {
228 unsigned int *hz = data;
229 struct input_dev *dev = handle->dev;
230
231 if (test_bit(EV_SND, dev->evbit)) {
232 if (test_bit(SND_TONE, dev->sndbit)) {
233 input_inject_event(handle, EV_SND, SND_TONE, *hz);
234 if (*hz)
235 return 0;
236 }
237 if (test_bit(SND_BELL, dev->sndbit))
238 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
239 }
240
241 return 0;
242 }
243
244 static void kd_nosound(unsigned long ignored)
245 {
246 static unsigned int zero;
247
248 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
249 }
250
251 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
252
253 void kd_mksound(unsigned int hz, unsigned int ticks)
254 {
255 del_timer_sync(&kd_mksound_timer);
256
257 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
258
259 if (hz && ticks)
260 mod_timer(&kd_mksound_timer, jiffies + ticks);
261 }
262 EXPORT_SYMBOL(kd_mksound);
263
264 /*
265 * Setting the keyboard rate.
266 */
267
268 static int kbd_rate_helper(struct input_handle *handle, void *data)
269 {
270 struct input_dev *dev = handle->dev;
271 struct kbd_repeat *rpt = data;
272
273 if (test_bit(EV_REP, dev->evbit)) {
274
275 if (rpt[0].delay > 0)
276 input_inject_event(handle,
277 EV_REP, REP_DELAY, rpt[0].delay);
278 if (rpt[0].period > 0)
279 input_inject_event(handle,
280 EV_REP, REP_PERIOD, rpt[0].period);
281
282 rpt[1].delay = dev->rep[REP_DELAY];
283 rpt[1].period = dev->rep[REP_PERIOD];
284 }
285
286 return 0;
287 }
288
289 int kbd_rate(struct kbd_repeat *rpt)
290 {
291 struct kbd_repeat data[2] = { *rpt };
292
293 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
294 *rpt = data[1]; /* Copy currently used settings */
295
296 return 0;
297 }
298
299 /*
300 * Helper Functions.
301 */
302 static void put_queue(struct vc_data *vc, int ch)
303 {
304 tty_insert_flip_char(&vc->port, ch, 0);
305 tty_schedule_flip(&vc->port);
306 }
307
308 static void puts_queue(struct vc_data *vc, char *cp)
309 {
310 while (*cp) {
311 tty_insert_flip_char(&vc->port, *cp, 0);
312 cp++;
313 }
314 tty_schedule_flip(&vc->port);
315 }
316
317 static void applkey(struct vc_data *vc, int key, char mode)
318 {
319 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
320
321 buf[1] = (mode ? 'O' : '[');
322 buf[2] = key;
323 puts_queue(vc, buf);
324 }
325
326 /*
327 * Many other routines do put_queue, but I think either
328 * they produce ASCII, or they produce some user-assigned
329 * string, and in both cases we might assume that it is
330 * in utf-8 already.
331 */
332 static void to_utf8(struct vc_data *vc, uint c)
333 {
334 if (c < 0x80)
335 /* 0******* */
336 put_queue(vc, c);
337 else if (c < 0x800) {
338 /* 110***** 10****** */
339 put_queue(vc, 0xc0 | (c >> 6));
340 put_queue(vc, 0x80 | (c & 0x3f));
341 } else if (c < 0x10000) {
342 if (c >= 0xD800 && c < 0xE000)
343 return;
344 if (c == 0xFFFF)
345 return;
346 /* 1110**** 10****** 10****** */
347 put_queue(vc, 0xe0 | (c >> 12));
348 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
349 put_queue(vc, 0x80 | (c & 0x3f));
350 } else if (c < 0x110000) {
351 /* 11110*** 10****** 10****** 10****** */
352 put_queue(vc, 0xf0 | (c >> 18));
353 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
354 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
355 put_queue(vc, 0x80 | (c & 0x3f));
356 }
357 }
358
359 /*
360 * Called after returning from RAW mode or when changing consoles - recompute
361 * shift_down[] and shift_state from key_down[] maybe called when keymap is
362 * undefined, so that shiftkey release is seen. The caller must hold the
363 * kbd_event_lock.
364 */
365
366 static void do_compute_shiftstate(void)
367 {
368 unsigned int i, j, k, sym, val;
369
370 shift_state = 0;
371 memset(shift_down, 0, sizeof(shift_down));
372
373 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
374
375 if (!key_down[i])
376 continue;
377
378 k = i * BITS_PER_LONG;
379
380 for (j = 0; j < BITS_PER_LONG; j++, k++) {
381
382 if (!test_bit(k, key_down))
383 continue;
384
385 sym = U(key_maps[0][k]);
386 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
387 continue;
388
389 val = KVAL(sym);
390 if (val == KVAL(K_CAPSSHIFT))
391 val = KVAL(K_SHIFT);
392
393 shift_down[val]++;
394 shift_state |= (1 << val);
395 }
396 }
397 }
398
399 /* We still have to export this method to vt.c */
400 void compute_shiftstate(void)
401 {
402 unsigned long flags;
403 spin_lock_irqsave(&kbd_event_lock, flags);
404 do_compute_shiftstate();
405 spin_unlock_irqrestore(&kbd_event_lock, flags);
406 }
407
408 /*
409 * We have a combining character DIACR here, followed by the character CH.
410 * If the combination occurs in the table, return the corresponding value.
411 * Otherwise, if CH is a space or equals DIACR, return DIACR.
412 * Otherwise, conclude that DIACR was not combining after all,
413 * queue it and return CH.
414 */
415 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
416 {
417 unsigned int d = diacr;
418 unsigned int i;
419
420 diacr = 0;
421
422 if ((d & ~0xff) == BRL_UC_ROW) {
423 if ((ch & ~0xff) == BRL_UC_ROW)
424 return d | ch;
425 } else {
426 for (i = 0; i < accent_table_size; i++)
427 if (accent_table[i].diacr == d && accent_table[i].base == ch)
428 return accent_table[i].result;
429 }
430
431 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
432 return d;
433
434 if (kbd->kbdmode == VC_UNICODE)
435 to_utf8(vc, d);
436 else {
437 int c = conv_uni_to_8bit(d);
438 if (c != -1)
439 put_queue(vc, c);
440 }
441
442 return ch;
443 }
444
445 /*
446 * Special function handlers
447 */
448 static void fn_enter(struct vc_data *vc)
449 {
450 if (diacr) {
451 if (kbd->kbdmode == VC_UNICODE)
452 to_utf8(vc, diacr);
453 else {
454 int c = conv_uni_to_8bit(diacr);
455 if (c != -1)
456 put_queue(vc, c);
457 }
458 diacr = 0;
459 }
460
461 put_queue(vc, 13);
462 if (vc_kbd_mode(kbd, VC_CRLF))
463 put_queue(vc, 10);
464 }
465
466 static void fn_caps_toggle(struct vc_data *vc)
467 {
468 if (rep)
469 return;
470
471 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
472 }
473
474 static void fn_caps_on(struct vc_data *vc)
475 {
476 if (rep)
477 return;
478
479 set_vc_kbd_led(kbd, VC_CAPSLOCK);
480 }
481
482 static void fn_show_ptregs(struct vc_data *vc)
483 {
484 struct pt_regs *regs = get_irq_regs();
485
486 if (regs)
487 show_regs(regs);
488 }
489
490 static void fn_hold(struct vc_data *vc)
491 {
492 struct tty_struct *tty = vc->port.tty;
493
494 if (rep || !tty)
495 return;
496
497 /*
498 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
499 * these routines are also activated by ^S/^Q.
500 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
501 */
502 if (tty->stopped)
503 start_tty(tty);
504 else
505 stop_tty(tty);
506 }
507
508 static void fn_num(struct vc_data *vc)
509 {
510 if (vc_kbd_mode(kbd, VC_APPLIC))
511 applkey(vc, 'P', 1);
512 else
513 fn_bare_num(vc);
514 }
515
516 /*
517 * Bind this to Shift-NumLock if you work in application keypad mode
518 * but want to be able to change the NumLock flag.
519 * Bind this to NumLock if you prefer that the NumLock key always
520 * changes the NumLock flag.
521 */
522 static void fn_bare_num(struct vc_data *vc)
523 {
524 if (!rep)
525 chg_vc_kbd_led(kbd, VC_NUMLOCK);
526 }
527
528 static void fn_lastcons(struct vc_data *vc)
529 {
530 /* switch to the last used console, ChN */
531 set_console(last_console);
532 }
533
534 static void fn_dec_console(struct vc_data *vc)
535 {
536 int i, cur = fg_console;
537
538 /* Currently switching? Queue this next switch relative to that. */
539 if (want_console != -1)
540 cur = want_console;
541
542 for (i = cur - 1; i != cur; i--) {
543 if (i == -1)
544 i = MAX_NR_CONSOLES - 1;
545 if (vc_cons_allocated(i))
546 break;
547 }
548 set_console(i);
549 }
550
551 static void fn_inc_console(struct vc_data *vc)
552 {
553 int i, cur = fg_console;
554
555 /* Currently switching? Queue this next switch relative to that. */
556 if (want_console != -1)
557 cur = want_console;
558
559 for (i = cur+1; i != cur; i++) {
560 if (i == MAX_NR_CONSOLES)
561 i = 0;
562 if (vc_cons_allocated(i))
563 break;
564 }
565 set_console(i);
566 }
567
568 static void fn_send_intr(struct vc_data *vc)
569 {
570 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
571 tty_schedule_flip(&vc->port);
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(0);
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 do_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 kbd->kbdmode == VC_OFF) &&
642 value != KVAL(K_SAK))
643 return; /* SAK is allowed even in raw mode */
644 fn_handler[value](vc);
645 }
646
647 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
648 {
649 pr_err("k_lowercase was called - impossible\n");
650 }
651
652 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
653 {
654 if (up_flag)
655 return; /* no action, if this is a key release */
656
657 if (diacr)
658 value = handle_diacr(vc, value);
659
660 if (dead_key_next) {
661 dead_key_next = false;
662 diacr = value;
663 return;
664 }
665 if (kbd->kbdmode == VC_UNICODE)
666 to_utf8(vc, value);
667 else {
668 int c = conv_uni_to_8bit(value);
669 if (c != -1)
670 put_queue(vc, c);
671 }
672 }
673
674 /*
675 * Handle dead key. Note that we now may have several
676 * dead keys modifying the same character. Very useful
677 * for Vietnamese.
678 */
679 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
680 {
681 if (up_flag)
682 return;
683
684 diacr = (diacr ? handle_diacr(vc, value) : value);
685 }
686
687 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
688 {
689 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
690 }
691
692 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
693 {
694 k_deadunicode(vc, value, up_flag);
695 }
696
697 /*
698 * Obsolete - for backwards compatibility only
699 */
700 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
701 {
702 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
703
704 k_deadunicode(vc, ret_diacr[value], up_flag);
705 }
706
707 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
708 {
709 if (up_flag)
710 return;
711
712 set_console(value);
713 }
714
715 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
716 {
717 if (up_flag)
718 return;
719
720 if ((unsigned)value < ARRAY_SIZE(func_table)) {
721 if (func_table[value])
722 puts_queue(vc, func_table[value]);
723 } else
724 pr_err("k_fn called with value=%d\n", value);
725 }
726
727 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
728 {
729 static const char cur_chars[] = "BDCA";
730
731 if (up_flag)
732 return;
733
734 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
735 }
736
737 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
738 {
739 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
740 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
741
742 if (up_flag)
743 return; /* no action, if this is a key release */
744
745 /* kludge... shift forces cursor/number keys */
746 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
747 applkey(vc, app_map[value], 1);
748 return;
749 }
750
751 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
752
753 switch (value) {
754 case KVAL(K_PCOMMA):
755 case KVAL(K_PDOT):
756 k_fn(vc, KVAL(K_REMOVE), 0);
757 return;
758 case KVAL(K_P0):
759 k_fn(vc, KVAL(K_INSERT), 0);
760 return;
761 case KVAL(K_P1):
762 k_fn(vc, KVAL(K_SELECT), 0);
763 return;
764 case KVAL(K_P2):
765 k_cur(vc, KVAL(K_DOWN), 0);
766 return;
767 case KVAL(K_P3):
768 k_fn(vc, KVAL(K_PGDN), 0);
769 return;
770 case KVAL(K_P4):
771 k_cur(vc, KVAL(K_LEFT), 0);
772 return;
773 case KVAL(K_P6):
774 k_cur(vc, KVAL(K_RIGHT), 0);
775 return;
776 case KVAL(K_P7):
777 k_fn(vc, KVAL(K_FIND), 0);
778 return;
779 case KVAL(K_P8):
780 k_cur(vc, KVAL(K_UP), 0);
781 return;
782 case KVAL(K_P9):
783 k_fn(vc, KVAL(K_PGUP), 0);
784 return;
785 case KVAL(K_P5):
786 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
787 return;
788 }
789 }
790
791 put_queue(vc, pad_chars[value]);
792 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
793 put_queue(vc, 10);
794 }
795
796 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
797 {
798 int old_state = shift_state;
799
800 if (rep)
801 return;
802 /*
803 * Mimic typewriter:
804 * a CapsShift key acts like Shift but undoes CapsLock
805 */
806 if (value == KVAL(K_CAPSSHIFT)) {
807 value = KVAL(K_SHIFT);
808 if (!up_flag)
809 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
810 }
811
812 if (up_flag) {
813 /*
814 * handle the case that two shift or control
815 * keys are depressed simultaneously
816 */
817 if (shift_down[value])
818 shift_down[value]--;
819 } else
820 shift_down[value]++;
821
822 if (shift_down[value])
823 shift_state |= (1 << value);
824 else
825 shift_state &= ~(1 << value);
826
827 /* kludge */
828 if (up_flag && shift_state != old_state && npadch != -1) {
829 if (kbd->kbdmode == VC_UNICODE)
830 to_utf8(vc, npadch);
831 else
832 put_queue(vc, npadch & 0xff);
833 npadch = -1;
834 }
835 }
836
837 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
838 {
839 if (up_flag)
840 return;
841
842 if (vc_kbd_mode(kbd, VC_META)) {
843 put_queue(vc, '\033');
844 put_queue(vc, value);
845 } else
846 put_queue(vc, value | 0x80);
847 }
848
849 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
850 {
851 int base;
852
853 if (up_flag)
854 return;
855
856 if (value < 10) {
857 /* decimal input of code, while Alt depressed */
858 base = 10;
859 } else {
860 /* hexadecimal input of code, while AltGr depressed */
861 value -= 10;
862 base = 16;
863 }
864
865 if (npadch == -1)
866 npadch = value;
867 else
868 npadch = npadch * base + value;
869 }
870
871 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
872 {
873 if (up_flag || rep)
874 return;
875
876 chg_vc_kbd_lock(kbd, value);
877 }
878
879 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
880 {
881 k_shift(vc, value, up_flag);
882 if (up_flag || rep)
883 return;
884
885 chg_vc_kbd_slock(kbd, value);
886 /* try to make Alt, oops, AltGr and such work */
887 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
888 kbd->slockstate = 0;
889 chg_vc_kbd_slock(kbd, value);
890 }
891 }
892
893 /* by default, 300ms interval for combination release */
894 static unsigned brl_timeout = 300;
895 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
896 module_param(brl_timeout, uint, 0644);
897
898 static unsigned brl_nbchords = 1;
899 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
900 module_param(brl_nbchords, uint, 0644);
901
902 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
903 {
904 static unsigned long chords;
905 static unsigned committed;
906
907 if (!brl_nbchords)
908 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
909 else {
910 committed |= pattern;
911 chords++;
912 if (chords == brl_nbchords) {
913 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
914 chords = 0;
915 committed = 0;
916 }
917 }
918 }
919
920 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
921 {
922 static unsigned pressed, committing;
923 static unsigned long releasestart;
924
925 if (kbd->kbdmode != VC_UNICODE) {
926 if (!up_flag)
927 pr_warn("keyboard mode must be unicode for braille patterns\n");
928 return;
929 }
930
931 if (!value) {
932 k_unicode(vc, BRL_UC_ROW, up_flag);
933 return;
934 }
935
936 if (value > 8)
937 return;
938
939 if (!up_flag) {
940 pressed |= 1 << (value - 1);
941 if (!brl_timeout)
942 committing = pressed;
943 } else if (brl_timeout) {
944 if (!committing ||
945 time_after(jiffies,
946 releasestart + msecs_to_jiffies(brl_timeout))) {
947 committing = pressed;
948 releasestart = jiffies;
949 }
950 pressed &= ~(1 << (value - 1));
951 if (!pressed && committing) {
952 k_brlcommit(vc, committing, 0);
953 committing = 0;
954 }
955 } else {
956 if (committing) {
957 k_brlcommit(vc, committing, 0);
958 committing = 0;
959 }
960 pressed &= ~(1 << (value - 1));
961 }
962 }
963
964 /*
965 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
966 * or (ii) whatever pattern of lights people want to show using KDSETLED,
967 * or (iii) specified bits of specified words in kernel memory.
968 */
969 static unsigned char getledstate(void)
970 {
971 return ledstate;
972 }
973
974 void setledstate(struct kbd_struct *kb, unsigned int led)
975 {
976 unsigned long flags;
977 spin_lock_irqsave(&led_lock, flags);
978 if (!(led & ~7)) {
979 ledioctl = led;
980 kb->ledmode = LED_SHOW_IOCTL;
981 } else
982 kb->ledmode = LED_SHOW_FLAGS;
983
984 set_leds();
985 spin_unlock_irqrestore(&led_lock, flags);
986 }
987
988 static inline unsigned char getleds(void)
989 {
990 struct kbd_struct *kb = kbd_table + fg_console;
991
992 if (kb->ledmode == LED_SHOW_IOCTL)
993 return ledioctl;
994
995 return kb->ledflagstate;
996 }
997
998 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
999 {
1000 unsigned char leds = *(unsigned char *)data;
1001
1002 if (test_bit(EV_LED, handle->dev->evbit)) {
1003 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1004 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1005 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1006 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1007 }
1008
1009 return 0;
1010 }
1011
1012 /**
1013 * vt_get_leds - helper for braille console
1014 * @console: console to read
1015 * @flag: flag we want to check
1016 *
1017 * Check the status of a keyboard led flag and report it back
1018 */
1019 int vt_get_leds(int console, int flag)
1020 {
1021 struct kbd_struct *kb = kbd_table + console;
1022 int ret;
1023 unsigned long flags;
1024
1025 spin_lock_irqsave(&led_lock, flags);
1026 ret = vc_kbd_led(kb, flag);
1027 spin_unlock_irqrestore(&led_lock, flags);
1028
1029 return ret;
1030 }
1031 EXPORT_SYMBOL_GPL(vt_get_leds);
1032
1033 /**
1034 * vt_set_led_state - set LED state of a console
1035 * @console: console to set
1036 * @leds: LED bits
1037 *
1038 * Set the LEDs on a console. This is a wrapper for the VT layer
1039 * so that we can keep kbd knowledge internal
1040 */
1041 void vt_set_led_state(int console, int leds)
1042 {
1043 struct kbd_struct *kb = kbd_table + console;
1044 setledstate(kb, leds);
1045 }
1046
1047 /**
1048 * vt_kbd_con_start - Keyboard side of console start
1049 * @console: console
1050 *
1051 * Handle console start. This is a wrapper for the VT layer
1052 * so that we can keep kbd knowledge internal
1053 *
1054 * FIXME: We eventually need to hold the kbd lock here to protect
1055 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1056 * and start_tty under the kbd_event_lock, while normal tty paths
1057 * don't hold the lock. We probably need to split out an LED lock
1058 * but not during an -rc release!
1059 */
1060 void vt_kbd_con_start(int console)
1061 {
1062 struct kbd_struct *kb = kbd_table + console;
1063 unsigned long flags;
1064 spin_lock_irqsave(&led_lock, flags);
1065 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1066 set_leds();
1067 spin_unlock_irqrestore(&led_lock, flags);
1068 }
1069
1070 /**
1071 * vt_kbd_con_stop - Keyboard side of console stop
1072 * @console: console
1073 *
1074 * Handle console stop. This is a wrapper for the VT layer
1075 * so that we can keep kbd knowledge internal
1076 */
1077 void vt_kbd_con_stop(int console)
1078 {
1079 struct kbd_struct *kb = kbd_table + console;
1080 unsigned long flags;
1081 spin_lock_irqsave(&led_lock, flags);
1082 set_vc_kbd_led(kb, VC_SCROLLOCK);
1083 set_leds();
1084 spin_unlock_irqrestore(&led_lock, flags);
1085 }
1086
1087 /*
1088 * This is the tasklet that updates LED state on all keyboards
1089 * attached to the box. The reason we use tasklet is that we
1090 * need to handle the scenario when keyboard handler is not
1091 * registered yet but we already getting updates from the VT to
1092 * update led state.
1093 */
1094 static void kbd_bh(unsigned long dummy)
1095 {
1096 unsigned char leds;
1097 unsigned long flags;
1098
1099 spin_lock_irqsave(&led_lock, flags);
1100 leds = getleds();
1101 spin_unlock_irqrestore(&led_lock, flags);
1102
1103 if (leds != ledstate) {
1104 input_handler_for_each_handle(&kbd_handler, &leds,
1105 kbd_update_leds_helper);
1106 ledstate = leds;
1107 }
1108 }
1109
1110 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1111
1112 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1113 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1114 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1115 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1116 defined(CONFIG_AVR32)
1117
1118 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1119 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1120
1121 static const unsigned short x86_keycodes[256] =
1122 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1123 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1124 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1125 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1126 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1127 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1128 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1129 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1130 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1131 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1132 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1133 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1134 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1135 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1136 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1137
1138 #ifdef CONFIG_SPARC
1139 static int sparc_l1_a_state;
1140 extern void sun_do_break(void);
1141 #endif
1142
1143 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1144 unsigned char up_flag)
1145 {
1146 int code;
1147
1148 switch (keycode) {
1149
1150 case KEY_PAUSE:
1151 put_queue(vc, 0xe1);
1152 put_queue(vc, 0x1d | up_flag);
1153 put_queue(vc, 0x45 | up_flag);
1154 break;
1155
1156 case KEY_HANGEUL:
1157 if (!up_flag)
1158 put_queue(vc, 0xf2);
1159 break;
1160
1161 case KEY_HANJA:
1162 if (!up_flag)
1163 put_queue(vc, 0xf1);
1164 break;
1165
1166 case KEY_SYSRQ:
1167 /*
1168 * Real AT keyboards (that's what we're trying
1169 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1170 * pressing PrtSc/SysRq alone, but simply 0x54
1171 * when pressing Alt+PrtSc/SysRq.
1172 */
1173 if (test_bit(KEY_LEFTALT, key_down) ||
1174 test_bit(KEY_RIGHTALT, key_down)) {
1175 put_queue(vc, 0x54 | up_flag);
1176 } else {
1177 put_queue(vc, 0xe0);
1178 put_queue(vc, 0x2a | up_flag);
1179 put_queue(vc, 0xe0);
1180 put_queue(vc, 0x37 | up_flag);
1181 }
1182 break;
1183
1184 default:
1185 if (keycode > 255)
1186 return -1;
1187
1188 code = x86_keycodes[keycode];
1189 if (!code)
1190 return -1;
1191
1192 if (code & 0x100)
1193 put_queue(vc, 0xe0);
1194 put_queue(vc, (code & 0x7f) | up_flag);
1195
1196 break;
1197 }
1198
1199 return 0;
1200 }
1201
1202 #else
1203
1204 #define HW_RAW(dev) 0
1205
1206 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1207 {
1208 if (keycode > 127)
1209 return -1;
1210
1211 put_queue(vc, keycode | up_flag);
1212 return 0;
1213 }
1214 #endif
1215
1216 static void kbd_rawcode(unsigned char data)
1217 {
1218 struct vc_data *vc = vc_cons[fg_console].d;
1219
1220 kbd = kbd_table + vc->vc_num;
1221 if (kbd->kbdmode == VC_RAW)
1222 put_queue(vc, data);
1223 }
1224
1225 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1226 {
1227 struct vc_data *vc = vc_cons[fg_console].d;
1228 unsigned short keysym, *key_map;
1229 unsigned char type;
1230 bool raw_mode;
1231 struct tty_struct *tty;
1232 int shift_final;
1233 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1234 int rc;
1235
1236 tty = vc->port.tty;
1237
1238 if (tty && (!tty->driver_data)) {
1239 /* No driver data? Strange. Okay we fix it then. */
1240 tty->driver_data = vc;
1241 }
1242
1243 kbd = kbd_table + vc->vc_num;
1244
1245 #ifdef CONFIG_SPARC
1246 if (keycode == KEY_STOP)
1247 sparc_l1_a_state = down;
1248 #endif
1249
1250 rep = (down == 2);
1251
1252 raw_mode = (kbd->kbdmode == VC_RAW);
1253 if (raw_mode && !hw_raw)
1254 if (emulate_raw(vc, keycode, !down << 7))
1255 if (keycode < BTN_MISC && printk_ratelimit())
1256 pr_warn("can't emulate rawmode for keycode %d\n",
1257 keycode);
1258
1259 #ifdef CONFIG_SPARC
1260 if (keycode == KEY_A && sparc_l1_a_state) {
1261 sparc_l1_a_state = false;
1262 sun_do_break();
1263 }
1264 #endif
1265
1266 if (kbd->kbdmode == VC_MEDIUMRAW) {
1267 /*
1268 * This is extended medium raw mode, with keys above 127
1269 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1270 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1271 * interfere with anything else. The two bytes after 0 will
1272 * always have the up flag set not to interfere with older
1273 * applications. This allows for 16384 different keycodes,
1274 * which should be enough.
1275 */
1276 if (keycode < 128) {
1277 put_queue(vc, keycode | (!down << 7));
1278 } else {
1279 put_queue(vc, !down << 7);
1280 put_queue(vc, (keycode >> 7) | 0x80);
1281 put_queue(vc, keycode | 0x80);
1282 }
1283 raw_mode = true;
1284 }
1285
1286 if (down)
1287 set_bit(keycode, key_down);
1288 else
1289 clear_bit(keycode, key_down);
1290
1291 if (rep &&
1292 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1293 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1294 /*
1295 * Don't repeat a key if the input buffers are not empty and the
1296 * characters get aren't echoed locally. This makes key repeat
1297 * usable with slow applications and under heavy loads.
1298 */
1299 return;
1300 }
1301
1302 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1303 param.ledstate = kbd->ledflagstate;
1304 key_map = key_maps[shift_final];
1305
1306 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1307 KBD_KEYCODE, &param);
1308 if (rc == NOTIFY_STOP || !key_map) {
1309 atomic_notifier_call_chain(&keyboard_notifier_list,
1310 KBD_UNBOUND_KEYCODE, &param);
1311 do_compute_shiftstate();
1312 kbd->slockstate = 0;
1313 return;
1314 }
1315
1316 if (keycode < NR_KEYS)
1317 keysym = key_map[keycode];
1318 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1319 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1320 else
1321 return;
1322
1323 type = KTYP(keysym);
1324
1325 if (type < 0xf0) {
1326 param.value = keysym;
1327 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1328 KBD_UNICODE, &param);
1329 if (rc != NOTIFY_STOP)
1330 if (down && !raw_mode)
1331 to_utf8(vc, keysym);
1332 return;
1333 }
1334
1335 type -= 0xf0;
1336
1337 if (type == KT_LETTER) {
1338 type = KT_LATIN;
1339 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1340 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1341 if (key_map)
1342 keysym = key_map[keycode];
1343 }
1344 }
1345
1346 param.value = keysym;
1347 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1348 KBD_KEYSYM, &param);
1349 if (rc == NOTIFY_STOP)
1350 return;
1351
1352 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1353 return;
1354
1355 (*k_handler[type])(vc, keysym & 0xff, !down);
1356
1357 param.ledstate = kbd->ledflagstate;
1358 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1359
1360 if (type != KT_SLOCK)
1361 kbd->slockstate = 0;
1362 }
1363
1364 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1365 unsigned int event_code, int value)
1366 {
1367 /* We are called with interrupts disabled, just take the lock */
1368 spin_lock(&kbd_event_lock);
1369
1370 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1371 kbd_rawcode(value);
1372 if (event_type == EV_KEY)
1373 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1374
1375 spin_unlock(&kbd_event_lock);
1376
1377 tasklet_schedule(&keyboard_tasklet);
1378 do_poke_blanked_console = 1;
1379 schedule_console_callback();
1380 }
1381
1382 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1383 {
1384 int i;
1385
1386 if (test_bit(EV_SND, dev->evbit))
1387 return true;
1388
1389 if (test_bit(EV_KEY, dev->evbit)) {
1390 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1391 if (test_bit(i, dev->keybit))
1392 return true;
1393 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1394 if (test_bit(i, dev->keybit))
1395 return true;
1396 }
1397
1398 return false;
1399 }
1400
1401 /*
1402 * When a keyboard (or other input device) is found, the kbd_connect
1403 * function is called. The function then looks at the device, and if it
1404 * likes it, it can open it and get events from it. In this (kbd_connect)
1405 * function, we should decide which VT to bind that keyboard to initially.
1406 */
1407 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1408 const struct input_device_id *id)
1409 {
1410 struct input_handle *handle;
1411 int error;
1412
1413 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1414 if (!handle)
1415 return -ENOMEM;
1416
1417 handle->dev = dev;
1418 handle->handler = handler;
1419 handle->name = "kbd";
1420
1421 error = input_register_handle(handle);
1422 if (error)
1423 goto err_free_handle;
1424
1425 error = input_open_device(handle);
1426 if (error)
1427 goto err_unregister_handle;
1428
1429 return 0;
1430
1431 err_unregister_handle:
1432 input_unregister_handle(handle);
1433 err_free_handle:
1434 kfree(handle);
1435 return error;
1436 }
1437
1438 static void kbd_disconnect(struct input_handle *handle)
1439 {
1440 input_close_device(handle);
1441 input_unregister_handle(handle);
1442 kfree(handle);
1443 }
1444
1445 /*
1446 * Start keyboard handler on the new keyboard by refreshing LED state to
1447 * match the rest of the system.
1448 */
1449 static void kbd_start(struct input_handle *handle)
1450 {
1451 tasklet_disable(&keyboard_tasklet);
1452
1453 if (ledstate != 0xff)
1454 kbd_update_leds_helper(handle, &ledstate);
1455
1456 tasklet_enable(&keyboard_tasklet);
1457 }
1458
1459 static const struct input_device_id kbd_ids[] = {
1460 {
1461 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1462 .evbit = { BIT_MASK(EV_KEY) },
1463 },
1464
1465 {
1466 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1467 .evbit = { BIT_MASK(EV_SND) },
1468 },
1469
1470 { }, /* Terminating entry */
1471 };
1472
1473 MODULE_DEVICE_TABLE(input, kbd_ids);
1474
1475 static struct input_handler kbd_handler = {
1476 .event = kbd_event,
1477 .match = kbd_match,
1478 .connect = kbd_connect,
1479 .disconnect = kbd_disconnect,
1480 .start = kbd_start,
1481 .name = "kbd",
1482 .id_table = kbd_ids,
1483 };
1484
1485 int __init kbd_init(void)
1486 {
1487 int i;
1488 int error;
1489
1490 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1491 kbd_table[i].ledflagstate = kbd_defleds();
1492 kbd_table[i].default_ledflagstate = kbd_defleds();
1493 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1494 kbd_table[i].lockstate = KBD_DEFLOCK;
1495 kbd_table[i].slockstate = 0;
1496 kbd_table[i].modeflags = KBD_DEFMODE;
1497 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1498 }
1499
1500 error = input_register_handler(&kbd_handler);
1501 if (error)
1502 return error;
1503
1504 tasklet_enable(&keyboard_tasklet);
1505 tasklet_schedule(&keyboard_tasklet);
1506
1507 return 0;
1508 }
1509
1510 /* Ioctl support code */
1511
1512 /**
1513 * vt_do_diacrit - diacritical table updates
1514 * @cmd: ioctl request
1515 * @udp: pointer to user data for ioctl
1516 * @perm: permissions check computed by caller
1517 *
1518 * Update the diacritical tables atomically and safely. Lock them
1519 * against simultaneous keypresses
1520 */
1521 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1522 {
1523 unsigned long flags;
1524 int asize;
1525 int ret = 0;
1526
1527 switch (cmd) {
1528 case KDGKBDIACR:
1529 {
1530 struct kbdiacrs __user *a = udp;
1531 struct kbdiacr *dia;
1532 int i;
1533
1534 dia = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1535 GFP_KERNEL);
1536 if (!dia)
1537 return -ENOMEM;
1538
1539 /* Lock the diacriticals table, make a copy and then
1540 copy it after we unlock */
1541 spin_lock_irqsave(&kbd_event_lock, flags);
1542
1543 asize = accent_table_size;
1544 for (i = 0; i < asize; i++) {
1545 dia[i].diacr = conv_uni_to_8bit(
1546 accent_table[i].diacr);
1547 dia[i].base = conv_uni_to_8bit(
1548 accent_table[i].base);
1549 dia[i].result = conv_uni_to_8bit(
1550 accent_table[i].result);
1551 }
1552 spin_unlock_irqrestore(&kbd_event_lock, flags);
1553
1554 if (put_user(asize, &a->kb_cnt))
1555 ret = -EFAULT;
1556 else if (copy_to_user(a->kbdiacr, dia,
1557 asize * sizeof(struct kbdiacr)))
1558 ret = -EFAULT;
1559 kfree(dia);
1560 return ret;
1561 }
1562 case KDGKBDIACRUC:
1563 {
1564 struct kbdiacrsuc __user *a = udp;
1565 void *buf;
1566
1567 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1568 GFP_KERNEL);
1569 if (buf == NULL)
1570 return -ENOMEM;
1571
1572 /* Lock the diacriticals table, make a copy and then
1573 copy it after we unlock */
1574 spin_lock_irqsave(&kbd_event_lock, flags);
1575
1576 asize = accent_table_size;
1577 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1578
1579 spin_unlock_irqrestore(&kbd_event_lock, flags);
1580
1581 if (put_user(asize, &a->kb_cnt))
1582 ret = -EFAULT;
1583 else if (copy_to_user(a->kbdiacruc, buf,
1584 asize*sizeof(struct kbdiacruc)))
1585 ret = -EFAULT;
1586 kfree(buf);
1587 return ret;
1588 }
1589
1590 case KDSKBDIACR:
1591 {
1592 struct kbdiacrs __user *a = udp;
1593 struct kbdiacr *dia = NULL;
1594 unsigned int ct;
1595 int i;
1596
1597 if (!perm)
1598 return -EPERM;
1599 if (get_user(ct, &a->kb_cnt))
1600 return -EFAULT;
1601 if (ct >= MAX_DIACR)
1602 return -EINVAL;
1603
1604 if (ct) {
1605 dia = kmalloc(sizeof(struct kbdiacr) * ct,
1606 GFP_KERNEL);
1607 if (!dia)
1608 return -ENOMEM;
1609
1610 if (copy_from_user(dia, a->kbdiacr,
1611 sizeof(struct kbdiacr) * ct)) {
1612 kfree(dia);
1613 return -EFAULT;
1614 }
1615 }
1616
1617 spin_lock_irqsave(&kbd_event_lock, flags);
1618 accent_table_size = ct;
1619 for (i = 0; i < ct; i++) {
1620 accent_table[i].diacr =
1621 conv_8bit_to_uni(dia[i].diacr);
1622 accent_table[i].base =
1623 conv_8bit_to_uni(dia[i].base);
1624 accent_table[i].result =
1625 conv_8bit_to_uni(dia[i].result);
1626 }
1627 spin_unlock_irqrestore(&kbd_event_lock, flags);
1628 kfree(dia);
1629 return 0;
1630 }
1631
1632 case KDSKBDIACRUC:
1633 {
1634 struct kbdiacrsuc __user *a = udp;
1635 unsigned int ct;
1636 void *buf = NULL;
1637
1638 if (!perm)
1639 return -EPERM;
1640
1641 if (get_user(ct, &a->kb_cnt))
1642 return -EFAULT;
1643
1644 if (ct >= MAX_DIACR)
1645 return -EINVAL;
1646
1647 if (ct) {
1648 buf = kmalloc(ct * sizeof(struct kbdiacruc),
1649 GFP_KERNEL);
1650 if (buf == NULL)
1651 return -ENOMEM;
1652
1653 if (copy_from_user(buf, a->kbdiacruc,
1654 ct * sizeof(struct kbdiacruc))) {
1655 kfree(buf);
1656 return -EFAULT;
1657 }
1658 }
1659 spin_lock_irqsave(&kbd_event_lock, flags);
1660 if (ct)
1661 memcpy(accent_table, buf,
1662 ct * sizeof(struct kbdiacruc));
1663 accent_table_size = ct;
1664 spin_unlock_irqrestore(&kbd_event_lock, flags);
1665 kfree(buf);
1666 return 0;
1667 }
1668 }
1669 return ret;
1670 }
1671
1672 /**
1673 * vt_do_kdskbmode - set keyboard mode ioctl
1674 * @console: the console to use
1675 * @arg: the requested mode
1676 *
1677 * Update the keyboard mode bits while holding the correct locks.
1678 * Return 0 for success or an error code.
1679 */
1680 int vt_do_kdskbmode(int console, unsigned int arg)
1681 {
1682 struct kbd_struct *kb = kbd_table + console;
1683 int ret = 0;
1684 unsigned long flags;
1685
1686 spin_lock_irqsave(&kbd_event_lock, flags);
1687 switch(arg) {
1688 case K_RAW:
1689 kb->kbdmode = VC_RAW;
1690 break;
1691 case K_MEDIUMRAW:
1692 kb->kbdmode = VC_MEDIUMRAW;
1693 break;
1694 case K_XLATE:
1695 kb->kbdmode = VC_XLATE;
1696 do_compute_shiftstate();
1697 break;
1698 case K_UNICODE:
1699 kb->kbdmode = VC_UNICODE;
1700 do_compute_shiftstate();
1701 break;
1702 case K_OFF:
1703 kb->kbdmode = VC_OFF;
1704 break;
1705 default:
1706 ret = -EINVAL;
1707 }
1708 spin_unlock_irqrestore(&kbd_event_lock, flags);
1709 return ret;
1710 }
1711
1712 /**
1713 * vt_do_kdskbmeta - set keyboard meta state
1714 * @console: the console to use
1715 * @arg: the requested meta state
1716 *
1717 * Update the keyboard meta bits while holding the correct locks.
1718 * Return 0 for success or an error code.
1719 */
1720 int vt_do_kdskbmeta(int console, unsigned int arg)
1721 {
1722 struct kbd_struct *kb = kbd_table + console;
1723 int ret = 0;
1724 unsigned long flags;
1725
1726 spin_lock_irqsave(&kbd_event_lock, flags);
1727 switch(arg) {
1728 case K_METABIT:
1729 clr_vc_kbd_mode(kb, VC_META);
1730 break;
1731 case K_ESCPREFIX:
1732 set_vc_kbd_mode(kb, VC_META);
1733 break;
1734 default:
1735 ret = -EINVAL;
1736 }
1737 spin_unlock_irqrestore(&kbd_event_lock, flags);
1738 return ret;
1739 }
1740
1741 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1742 int perm)
1743 {
1744 struct kbkeycode tmp;
1745 int kc = 0;
1746
1747 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1748 return -EFAULT;
1749 switch (cmd) {
1750 case KDGETKEYCODE:
1751 kc = getkeycode(tmp.scancode);
1752 if (kc >= 0)
1753 kc = put_user(kc, &user_kbkc->keycode);
1754 break;
1755 case KDSETKEYCODE:
1756 if (!perm)
1757 return -EPERM;
1758 kc = setkeycode(tmp.scancode, tmp.keycode);
1759 break;
1760 }
1761 return kc;
1762 }
1763
1764 #define i (tmp.kb_index)
1765 #define s (tmp.kb_table)
1766 #define v (tmp.kb_value)
1767
1768 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1769 int console)
1770 {
1771 struct kbd_struct *kb = kbd_table + console;
1772 struct kbentry tmp;
1773 ushort *key_map, *new_map, val, ov;
1774 unsigned long flags;
1775
1776 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1777 return -EFAULT;
1778
1779 if (!capable(CAP_SYS_TTY_CONFIG))
1780 perm = 0;
1781
1782 switch (cmd) {
1783 case KDGKBENT:
1784 /* Ensure another thread doesn't free it under us */
1785 spin_lock_irqsave(&kbd_event_lock, flags);
1786 key_map = key_maps[s];
1787 if (key_map) {
1788 val = U(key_map[i]);
1789 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1790 val = K_HOLE;
1791 } else
1792 val = (i ? K_HOLE : K_NOSUCHMAP);
1793 spin_unlock_irqrestore(&kbd_event_lock, flags);
1794 return put_user(val, &user_kbe->kb_value);
1795 case KDSKBENT:
1796 if (!perm)
1797 return -EPERM;
1798 if (!i && v == K_NOSUCHMAP) {
1799 spin_lock_irqsave(&kbd_event_lock, flags);
1800 /* deallocate map */
1801 key_map = key_maps[s];
1802 if (s && key_map) {
1803 key_maps[s] = NULL;
1804 if (key_map[0] == U(K_ALLOCATED)) {
1805 kfree(key_map);
1806 keymap_count--;
1807 }
1808 }
1809 spin_unlock_irqrestore(&kbd_event_lock, flags);
1810 break;
1811 }
1812
1813 if (KTYP(v) < NR_TYPES) {
1814 if (KVAL(v) > max_vals[KTYP(v)])
1815 return -EINVAL;
1816 } else
1817 if (kb->kbdmode != VC_UNICODE)
1818 return -EINVAL;
1819
1820 /* ++Geert: non-PC keyboards may generate keycode zero */
1821 #if !defined(__mc68000__) && !defined(__powerpc__)
1822 /* assignment to entry 0 only tests validity of args */
1823 if (!i)
1824 break;
1825 #endif
1826
1827 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1828 if (!new_map)
1829 return -ENOMEM;
1830 spin_lock_irqsave(&kbd_event_lock, flags);
1831 key_map = key_maps[s];
1832 if (key_map == NULL) {
1833 int j;
1834
1835 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1836 !capable(CAP_SYS_RESOURCE)) {
1837 spin_unlock_irqrestore(&kbd_event_lock, flags);
1838 kfree(new_map);
1839 return -EPERM;
1840 }
1841 key_maps[s] = new_map;
1842 key_map = new_map;
1843 key_map[0] = U(K_ALLOCATED);
1844 for (j = 1; j < NR_KEYS; j++)
1845 key_map[j] = U(K_HOLE);
1846 keymap_count++;
1847 } else
1848 kfree(new_map);
1849
1850 ov = U(key_map[i]);
1851 if (v == ov)
1852 goto out;
1853 /*
1854 * Attention Key.
1855 */
1856 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1857 spin_unlock_irqrestore(&kbd_event_lock, flags);
1858 return -EPERM;
1859 }
1860 key_map[i] = U(v);
1861 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1862 do_compute_shiftstate();
1863 out:
1864 spin_unlock_irqrestore(&kbd_event_lock, flags);
1865 break;
1866 }
1867 return 0;
1868 }
1869 #undef i
1870 #undef s
1871 #undef v
1872
1873 /* FIXME: This one needs untangling and locking */
1874 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1875 {
1876 struct kbsentry *kbs;
1877 char *p;
1878 u_char *q;
1879 u_char __user *up;
1880 int sz;
1881 int delta;
1882 char *first_free, *fj, *fnw;
1883 int i, j, k;
1884 int ret;
1885
1886 if (!capable(CAP_SYS_TTY_CONFIG))
1887 perm = 0;
1888
1889 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1890 if (!kbs) {
1891 ret = -ENOMEM;
1892 goto reterr;
1893 }
1894
1895 /* we mostly copy too much here (512bytes), but who cares ;) */
1896 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1897 ret = -EFAULT;
1898 goto reterr;
1899 }
1900 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1901 i = kbs->kb_func;
1902
1903 switch (cmd) {
1904 case KDGKBSENT:
1905 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1906 a struct member */
1907 up = user_kdgkb->kb_string;
1908 p = func_table[i];
1909 if(p)
1910 for ( ; *p && sz; p++, sz--)
1911 if (put_user(*p, up++)) {
1912 ret = -EFAULT;
1913 goto reterr;
1914 }
1915 if (put_user('\0', up)) {
1916 ret = -EFAULT;
1917 goto reterr;
1918 }
1919 kfree(kbs);
1920 return ((p && *p) ? -EOVERFLOW : 0);
1921 case KDSKBSENT:
1922 if (!perm) {
1923 ret = -EPERM;
1924 goto reterr;
1925 }
1926
1927 q = func_table[i];
1928 first_free = funcbufptr + (funcbufsize - funcbufleft);
1929 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
1930 ;
1931 if (j < MAX_NR_FUNC)
1932 fj = func_table[j];
1933 else
1934 fj = first_free;
1935
1936 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
1937 if (delta <= funcbufleft) { /* it fits in current buf */
1938 if (j < MAX_NR_FUNC) {
1939 memmove(fj + delta, fj, first_free - fj);
1940 for (k = j; k < MAX_NR_FUNC; k++)
1941 if (func_table[k])
1942 func_table[k] += delta;
1943 }
1944 if (!q)
1945 func_table[i] = fj;
1946 funcbufleft -= delta;
1947 } else { /* allocate a larger buffer */
1948 sz = 256;
1949 while (sz < funcbufsize - funcbufleft + delta)
1950 sz <<= 1;
1951 fnw = kmalloc(sz, GFP_KERNEL);
1952 if(!fnw) {
1953 ret = -ENOMEM;
1954 goto reterr;
1955 }
1956
1957 if (!q)
1958 func_table[i] = fj;
1959 if (fj > funcbufptr)
1960 memmove(fnw, funcbufptr, fj - funcbufptr);
1961 for (k = 0; k < j; k++)
1962 if (func_table[k])
1963 func_table[k] = fnw + (func_table[k] - funcbufptr);
1964
1965 if (first_free > fj) {
1966 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
1967 for (k = j; k < MAX_NR_FUNC; k++)
1968 if (func_table[k])
1969 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
1970 }
1971 if (funcbufptr != func_buf)
1972 kfree(funcbufptr);
1973 funcbufptr = fnw;
1974 funcbufleft = funcbufleft - delta + sz - funcbufsize;
1975 funcbufsize = sz;
1976 }
1977 strcpy(func_table[i], kbs->kb_string);
1978 break;
1979 }
1980 ret = 0;
1981 reterr:
1982 kfree(kbs);
1983 return ret;
1984 }
1985
1986 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
1987 {
1988 struct kbd_struct *kb = kbd_table + console;
1989 unsigned long flags;
1990 unsigned char ucval;
1991
1992 switch(cmd) {
1993 /* the ioctls below read/set the flags usually shown in the leds */
1994 /* don't use them - they will go away without warning */
1995 case KDGKBLED:
1996 spin_lock_irqsave(&kbd_event_lock, flags);
1997 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
1998 spin_unlock_irqrestore(&kbd_event_lock, flags);
1999 return put_user(ucval, (char __user *)arg);
2000
2001 case KDSKBLED:
2002 if (!perm)
2003 return -EPERM;
2004 if (arg & ~0x77)
2005 return -EINVAL;
2006 spin_lock_irqsave(&led_lock, flags);
2007 kb->ledflagstate = (arg & 7);
2008 kb->default_ledflagstate = ((arg >> 4) & 7);
2009 set_leds();
2010 spin_unlock_irqrestore(&led_lock, flags);
2011 return 0;
2012
2013 /* the ioctls below only set the lights, not the functions */
2014 /* for those, see KDGKBLED and KDSKBLED above */
2015 case KDGETLED:
2016 ucval = getledstate();
2017 return put_user(ucval, (char __user *)arg);
2018
2019 case KDSETLED:
2020 if (!perm)
2021 return -EPERM;
2022 setledstate(kb, arg);
2023 return 0;
2024 }
2025 return -ENOIOCTLCMD;
2026 }
2027
2028 int vt_do_kdgkbmode(int console)
2029 {
2030 struct kbd_struct *kb = kbd_table + console;
2031 /* This is a spot read so needs no locking */
2032 switch (kb->kbdmode) {
2033 case VC_RAW:
2034 return K_RAW;
2035 case VC_MEDIUMRAW:
2036 return K_MEDIUMRAW;
2037 case VC_UNICODE:
2038 return K_UNICODE;
2039 case VC_OFF:
2040 return K_OFF;
2041 default:
2042 return K_XLATE;
2043 }
2044 }
2045
2046 /**
2047 * vt_do_kdgkbmeta - report meta status
2048 * @console: console to report
2049 *
2050 * Report the meta flag status of this console
2051 */
2052 int vt_do_kdgkbmeta(int console)
2053 {
2054 struct kbd_struct *kb = kbd_table + console;
2055 /* Again a spot read so no locking */
2056 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2057 }
2058
2059 /**
2060 * vt_reset_unicode - reset the unicode status
2061 * @console: console being reset
2062 *
2063 * Restore the unicode console state to its default
2064 */
2065 void vt_reset_unicode(int console)
2066 {
2067 unsigned long flags;
2068
2069 spin_lock_irqsave(&kbd_event_lock, flags);
2070 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2071 spin_unlock_irqrestore(&kbd_event_lock, flags);
2072 }
2073
2074 /**
2075 * vt_get_shiftstate - shift bit state
2076 *
2077 * Report the shift bits from the keyboard state. We have to export
2078 * this to support some oddities in the vt layer.
2079 */
2080 int vt_get_shift_state(void)
2081 {
2082 /* Don't lock as this is a transient report */
2083 return shift_state;
2084 }
2085
2086 /**
2087 * vt_reset_keyboard - reset keyboard state
2088 * @console: console to reset
2089 *
2090 * Reset the keyboard bits for a console as part of a general console
2091 * reset event
2092 */
2093 void vt_reset_keyboard(int console)
2094 {
2095 struct kbd_struct *kb = kbd_table + console;
2096 unsigned long flags;
2097
2098 spin_lock_irqsave(&kbd_event_lock, flags);
2099 set_vc_kbd_mode(kb, VC_REPEAT);
2100 clr_vc_kbd_mode(kb, VC_CKMODE);
2101 clr_vc_kbd_mode(kb, VC_APPLIC);
2102 clr_vc_kbd_mode(kb, VC_CRLF);
2103 kb->lockstate = 0;
2104 kb->slockstate = 0;
2105 spin_lock(&led_lock);
2106 kb->ledmode = LED_SHOW_FLAGS;
2107 kb->ledflagstate = kb->default_ledflagstate;
2108 spin_unlock(&led_lock);
2109 /* do not do set_leds here because this causes an endless tasklet loop
2110 when the keyboard hasn't been initialized yet */
2111 spin_unlock_irqrestore(&kbd_event_lock, flags);
2112 }
2113
2114 /**
2115 * vt_get_kbd_mode_bit - read keyboard status bits
2116 * @console: console to read from
2117 * @bit: mode bit to read
2118 *
2119 * Report back a vt mode bit. We do this without locking so the
2120 * caller must be sure that there are no synchronization needs
2121 */
2122
2123 int vt_get_kbd_mode_bit(int console, int bit)
2124 {
2125 struct kbd_struct *kb = kbd_table + console;
2126 return vc_kbd_mode(kb, bit);
2127 }
2128
2129 /**
2130 * vt_set_kbd_mode_bit - read keyboard status bits
2131 * @console: console to read from
2132 * @bit: mode bit to read
2133 *
2134 * Set a vt mode bit. We do this without locking so the
2135 * caller must be sure that there are no synchronization needs
2136 */
2137
2138 void vt_set_kbd_mode_bit(int console, int bit)
2139 {
2140 struct kbd_struct *kb = kbd_table + console;
2141 unsigned long flags;
2142
2143 spin_lock_irqsave(&kbd_event_lock, flags);
2144 set_vc_kbd_mode(kb, bit);
2145 spin_unlock_irqrestore(&kbd_event_lock, flags);
2146 }
2147
2148 /**
2149 * vt_clr_kbd_mode_bit - read keyboard status bits
2150 * @console: console to read from
2151 * @bit: mode bit to read
2152 *
2153 * Report back a vt mode bit. We do this without locking so the
2154 * caller must be sure that there are no synchronization needs
2155 */
2156
2157 void vt_clr_kbd_mode_bit(int console, int bit)
2158 {
2159 struct kbd_struct *kb = kbd_table + console;
2160 unsigned long flags;
2161
2162 spin_lock_irqsave(&kbd_event_lock, flags);
2163 clr_vc_kbd_mode(kb, bit);
2164 spin_unlock_irqrestore(&kbd_event_lock, flags);
2165 }
Linux kernel - Deliverables
This page took 0.074217 seconds and 6 git commands to generate.