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