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