1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
28#include <linux/consolemap.h>
29#include <linux/init.h>
30#include <linux/input.h>
31#include <linux/jiffies.h>
32#include <linux/kbd_diacr.h>
33#include <linux/kbd_kern.h>
34#include <linux/leds.h>
35#include <linux/mm.h>
36#include <linux/module.h>
37#include <linux/nospec.h>
38#include <linux/notifier.h>
39#include <linux/reboot.h>
40#include <linux/sched/debug.h>
41#include <linux/sched/signal.h>
42#include <linux/slab.h>
43#include <linux/spinlock.h>
44#include <linux/string.h>
45#include <linux/tty_flip.h>
46#include <linux/tty.h>
47#include <linux/uaccess.h>
48#include <linux/vt_kern.h>
49
50#include <asm/irq_regs.h>
51
52
53
54
55
56#define KBD_DEFMODE (BIT(VC_REPEAT) | BIT(VC_META))
57
58#if defined(CONFIG_X86) || defined(CONFIG_PARISC)
59#include <asm/kbdleds.h>
60#else
61static inline int kbd_defleds(void)
62{
63 return 0;
64}
65#endif
66
67#define KBD_DEFLOCK 0
68
69
70
71
72
73#define K_HANDLERS\
74 k_self, k_fn, k_spec, k_pad,\
75 k_dead, k_cons, k_cur, k_shift,\
76 k_meta, k_ascii, k_lock, k_lowercase,\
77 k_slock, k_dead2, k_brl, k_ignore
78
79typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
80 char up_flag);
81static k_handler_fn K_HANDLERS;
82static k_handler_fn *k_handler[16] = { K_HANDLERS };
83
84#define FN_HANDLERS\
85 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
86 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
87 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
88 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
89 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
90
91typedef void (fn_handler_fn)(struct vc_data *vc);
92static fn_handler_fn FN_HANDLERS;
93static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
94
95
96
97
98
99struct vt_spawn_console vt_spawn_con = {
100 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
101 .pid = NULL,
102 .sig = 0,
103};
104
105
106
107
108
109
110static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
111static struct kbd_struct *kbd = kbd_table;
112
113
114static const unsigned char max_vals[] = {
115 [ KT_LATIN ] = 255,
116 [ KT_FN ] = ARRAY_SIZE(func_table) - 1,
117 [ KT_SPEC ] = ARRAY_SIZE(fn_handler) - 1,
118 [ KT_PAD ] = NR_PAD - 1,
119 [ KT_DEAD ] = NR_DEAD - 1,
120 [ KT_CONS ] = 255,
121 [ KT_CUR ] = 3,
122 [ KT_SHIFT ] = NR_SHIFT - 1,
123 [ KT_META ] = 255,
124 [ KT_ASCII ] = NR_ASCII - 1,
125 [ KT_LOCK ] = NR_LOCK - 1,
126 [ KT_LETTER ] = 255,
127 [ KT_SLOCK ] = NR_LOCK - 1,
128 [ KT_DEAD2 ] = 255,
129 [ KT_BRL ] = NR_BRL - 1,
130};
131
132static const int NR_TYPES = ARRAY_SIZE(max_vals);
133
134static void kbd_bh(struct tasklet_struct *unused);
135static DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh);
136
137static struct input_handler kbd_handler;
138static DEFINE_SPINLOCK(kbd_event_lock);
139static DEFINE_SPINLOCK(led_lock);
140static DEFINE_SPINLOCK(func_buf_lock);
141static DECLARE_BITMAP(key_down, KEY_CNT);
142static unsigned char shift_down[NR_SHIFT];
143static bool dead_key_next;
144
145
146static bool npadch_active;
147static unsigned int npadch_value;
148
149static unsigned int diacr;
150static bool rep;
151
152static int shift_state = 0;
153
154static unsigned int ledstate = -1U;
155static unsigned char ledioctl;
156
157
158
159
160static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
161
162int register_keyboard_notifier(struct notifier_block *nb)
163{
164 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
165}
166EXPORT_SYMBOL_GPL(register_keyboard_notifier);
167
168int unregister_keyboard_notifier(struct notifier_block *nb)
169{
170 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
171}
172EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
173
174
175
176
177
178
179
180
181
182
183
184struct getset_keycode_data {
185 struct input_keymap_entry ke;
186 int error;
187};
188
189static int getkeycode_helper(struct input_handle *handle, void *data)
190{
191 struct getset_keycode_data *d = data;
192
193 d->error = input_get_keycode(handle->dev, &d->ke);
194
195 return d->error == 0;
196}
197
198static int getkeycode(unsigned int scancode)
199{
200 struct getset_keycode_data d = {
201 .ke = {
202 .flags = 0,
203 .len = sizeof(scancode),
204 .keycode = 0,
205 },
206 .error = -ENODEV,
207 };
208
209 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
210
211 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
212
213 return d.error ?: d.ke.keycode;
214}
215
216static int setkeycode_helper(struct input_handle *handle, void *data)
217{
218 struct getset_keycode_data *d = data;
219
220 d->error = input_set_keycode(handle->dev, &d->ke);
221
222 return d->error == 0;
223}
224
225static int setkeycode(unsigned int scancode, unsigned int keycode)
226{
227 struct getset_keycode_data d = {
228 .ke = {
229 .flags = 0,
230 .len = sizeof(scancode),
231 .keycode = keycode,
232 },
233 .error = -ENODEV,
234 };
235
236 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
237
238 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
239
240 return d.error;
241}
242
243
244
245
246
247
248static int kd_sound_helper(struct input_handle *handle, void *data)
249{
250 unsigned int *hz = data;
251 struct input_dev *dev = handle->dev;
252
253 if (test_bit(EV_SND, dev->evbit)) {
254 if (test_bit(SND_TONE, dev->sndbit)) {
255 input_inject_event(handle, EV_SND, SND_TONE, *hz);
256 if (*hz)
257 return 0;
258 }
259 if (test_bit(SND_BELL, dev->sndbit))
260 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
261 }
262
263 return 0;
264}
265
266static void kd_nosound(struct timer_list *unused)
267{
268 static unsigned int zero;
269
270 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
271}
272
273static DEFINE_TIMER(kd_mksound_timer, kd_nosound);
274
275void kd_mksound(unsigned int hz, unsigned int ticks)
276{
277 del_timer_sync(&kd_mksound_timer);
278
279 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
280
281 if (hz && ticks)
282 mod_timer(&kd_mksound_timer, jiffies + ticks);
283}
284EXPORT_SYMBOL(kd_mksound);
285
286
287
288
289
290static int kbd_rate_helper(struct input_handle *handle, void *data)
291{
292 struct input_dev *dev = handle->dev;
293 struct kbd_repeat *rpt = data;
294
295 if (test_bit(EV_REP, dev->evbit)) {
296
297 if (rpt[0].delay > 0)
298 input_inject_event(handle,
299 EV_REP, REP_DELAY, rpt[0].delay);
300 if (rpt[0].period > 0)
301 input_inject_event(handle,
302 EV_REP, REP_PERIOD, rpt[0].period);
303
304 rpt[1].delay = dev->rep[REP_DELAY];
305 rpt[1].period = dev->rep[REP_PERIOD];
306 }
307
308 return 0;
309}
310
311int kbd_rate(struct kbd_repeat *rpt)
312{
313 struct kbd_repeat data[2] = { *rpt };
314
315 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
316 *rpt = data[1];
317
318 return 0;
319}
320
321
322
323
324static void put_queue(struct vc_data *vc, int ch)
325{
326 tty_insert_flip_char(&vc->port, ch, 0);
327 tty_schedule_flip(&vc->port);
328}
329
330static void puts_queue(struct vc_data *vc, const char *cp)
331{
332 tty_insert_flip_string(&vc->port, cp, strlen(cp));
333 tty_schedule_flip(&vc->port);
334}
335
336static void applkey(struct vc_data *vc, int key, char mode)
337{
338 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
339
340 buf[1] = (mode ? 'O' : '[');
341 buf[2] = key;
342 puts_queue(vc, buf);
343}
344
345
346
347
348
349
350
351static void to_utf8(struct vc_data *vc, uint c)
352{
353 if (c < 0x80)
354
355 put_queue(vc, c);
356 else if (c < 0x800) {
357
358 put_queue(vc, 0xc0 | (c >> 6));
359 put_queue(vc, 0x80 | (c & 0x3f));
360 } else if (c < 0x10000) {
361 if (c >= 0xD800 && c < 0xE000)
362 return;
363 if (c == 0xFFFF)
364 return;
365
366 put_queue(vc, 0xe0 | (c >> 12));
367 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
368 put_queue(vc, 0x80 | (c & 0x3f));
369 } else if (c < 0x110000) {
370
371 put_queue(vc, 0xf0 | (c >> 18));
372 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
373 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
374 put_queue(vc, 0x80 | (c & 0x3f));
375 }
376}
377
378
379static void set_leds(void)
380{
381 tasklet_schedule(&keyboard_tasklet);
382}
383
384
385
386
387
388
389
390
391static void do_compute_shiftstate(void)
392{
393 unsigned int k, sym, val;
394
395 shift_state = 0;
396 memset(shift_down, 0, sizeof(shift_down));
397
398 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
399 sym = U(key_maps[0][k]);
400 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
401 continue;
402
403 val = KVAL(sym);
404 if (val == KVAL(K_CAPSSHIFT))
405 val = KVAL(K_SHIFT);
406
407 shift_down[val]++;
408 shift_state |= BIT(val);
409 }
410}
411
412
413void vt_set_leds_compute_shiftstate(void)
414{
415 unsigned long flags;
416
417 set_leds();
418
419 spin_lock_irqsave(&kbd_event_lock, flags);
420 do_compute_shiftstate();
421 spin_unlock_irqrestore(&kbd_event_lock, flags);
422}
423
424
425
426
427
428
429
430
431static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
432{
433 unsigned int d = diacr;
434 unsigned int i;
435
436 diacr = 0;
437
438 if ((d & ~0xff) == BRL_UC_ROW) {
439 if ((ch & ~0xff) == BRL_UC_ROW)
440 return d | ch;
441 } else {
442 for (i = 0; i < accent_table_size; i++)
443 if (accent_table[i].diacr == d && accent_table[i].base == ch)
444 return accent_table[i].result;
445 }
446
447 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
448 return d;
449
450 if (kbd->kbdmode == VC_UNICODE)
451 to_utf8(vc, d);
452 else {
453 int c = conv_uni_to_8bit(d);
454 if (c != -1)
455 put_queue(vc, c);
456 }
457
458 return ch;
459}
460
461
462
463
464static void fn_enter(struct vc_data *vc)
465{
466 if (diacr) {
467 if (kbd->kbdmode == VC_UNICODE)
468 to_utf8(vc, diacr);
469 else {
470 int c = conv_uni_to_8bit(diacr);
471 if (c != -1)
472 put_queue(vc, c);
473 }
474 diacr = 0;
475 }
476
477 put_queue(vc, '\r');
478 if (vc_kbd_mode(kbd, VC_CRLF))
479 put_queue(vc, '\n');
480}
481
482static void fn_caps_toggle(struct vc_data *vc)
483{
484 if (rep)
485 return;
486
487 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
488}
489
490static void fn_caps_on(struct vc_data *vc)
491{
492 if (rep)
493 return;
494
495 set_vc_kbd_led(kbd, VC_CAPSLOCK);
496}
497
498static void fn_show_ptregs(struct vc_data *vc)
499{
500 struct pt_regs *regs = get_irq_regs();
501
502 if (regs)
503 show_regs(regs);
504}
505
506static void fn_hold(struct vc_data *vc)
507{
508 struct tty_struct *tty = vc->port.tty;
509
510 if (rep || !tty)
511 return;
512
513
514
515
516
517
518 if (tty->flow.stopped)
519 start_tty(tty);
520 else
521 stop_tty(tty);
522}
523
524static void fn_num(struct vc_data *vc)
525{
526 if (vc_kbd_mode(kbd, VC_APPLIC))
527 applkey(vc, 'P', 1);
528 else
529 fn_bare_num(vc);
530}
531
532
533
534
535
536
537
538static void fn_bare_num(struct vc_data *vc)
539{
540 if (!rep)
541 chg_vc_kbd_led(kbd, VC_NUMLOCK);
542}
543
544static void fn_lastcons(struct vc_data *vc)
545{
546
547 set_console(last_console);
548}
549
550static void fn_dec_console(struct vc_data *vc)
551{
552 int i, cur = fg_console;
553
554
555 if (want_console != -1)
556 cur = want_console;
557
558 for (i = cur - 1; i != cur; i--) {
559 if (i == -1)
560 i = MAX_NR_CONSOLES - 1;
561 if (vc_cons_allocated(i))
562 break;
563 }
564 set_console(i);
565}
566
567static void fn_inc_console(struct vc_data *vc)
568{
569 int i, cur = fg_console;
570
571
572 if (want_console != -1)
573 cur = want_console;
574
575 for (i = cur+1; i != cur; i++) {
576 if (i == MAX_NR_CONSOLES)
577 i = 0;
578 if (vc_cons_allocated(i))
579 break;
580 }
581 set_console(i);
582}
583
584static void fn_send_intr(struct vc_data *vc)
585{
586 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
587 tty_schedule_flip(&vc->port);
588}
589
590static void fn_scroll_forw(struct vc_data *vc)
591{
592 scrollfront(vc, 0);
593}
594
595static void fn_scroll_back(struct vc_data *vc)
596{
597 scrollback(vc);
598}
599
600static void fn_show_mem(struct vc_data *vc)
601{
602 show_mem(0, NULL);
603}
604
605static void fn_show_state(struct vc_data *vc)
606{
607 show_state();
608}
609
610static void fn_boot_it(struct vc_data *vc)
611{
612 ctrl_alt_del();
613}
614
615static void fn_compose(struct vc_data *vc)
616{
617 dead_key_next = true;
618}
619
620static void fn_spawn_con(struct vc_data *vc)
621{
622 spin_lock(&vt_spawn_con.lock);
623 if (vt_spawn_con.pid)
624 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
625 put_pid(vt_spawn_con.pid);
626 vt_spawn_con.pid = NULL;
627 }
628 spin_unlock(&vt_spawn_con.lock);
629}
630
631static void fn_SAK(struct vc_data *vc)
632{
633 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
634 schedule_work(SAK_work);
635}
636
637static void fn_null(struct vc_data *vc)
638{
639 do_compute_shiftstate();
640}
641
642
643
644
645static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
646{
647}
648
649static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
650{
651 if (up_flag)
652 return;
653 if (value >= ARRAY_SIZE(fn_handler))
654 return;
655 if ((kbd->kbdmode == VC_RAW ||
656 kbd->kbdmode == VC_MEDIUMRAW ||
657 kbd->kbdmode == VC_OFF) &&
658 value != KVAL(K_SAK))
659 return;
660 fn_handler[value](vc);
661}
662
663static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
664{
665 pr_err("k_lowercase was called - impossible\n");
666}
667
668static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
669{
670 if (up_flag)
671 return;
672
673 if (diacr)
674 value = handle_diacr(vc, value);
675
676 if (dead_key_next) {
677 dead_key_next = false;
678 diacr = value;
679 return;
680 }
681 if (kbd->kbdmode == VC_UNICODE)
682 to_utf8(vc, value);
683 else {
684 int c = conv_uni_to_8bit(value);
685 if (c != -1)
686 put_queue(vc, c);
687 }
688}
689
690
691
692
693
694
695static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
696{
697 if (up_flag)
698 return;
699
700 diacr = (diacr ? handle_diacr(vc, value) : value);
701}
702
703static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
704{
705 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
706}
707
708static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
709{
710 k_deadunicode(vc, value, up_flag);
711}
712
713
714
715
716static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
717{
718 static const unsigned char ret_diacr[NR_DEAD] = {
719 '`',
720 '\'',
721 '^',
722 '~',
723 '"',
724 ',',
725 '_',
726 'U',
727 '.',
728 '*',
729 '=',
730 'c',
731 'k',
732 'i',
733 '#',
734 'o',
735 '!',
736 '?',
737 '+',
738 '-',
739 ')',
740 '(',
741 ':',
742 'n',
743 ';',
744 '$',
745 '@',
746 };
747
748 k_deadunicode(vc, ret_diacr[value], up_flag);
749}
750
751static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
752{
753 if (up_flag)
754 return;
755
756 set_console(value);
757}
758
759static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
760{
761 if (up_flag)
762 return;
763
764 if ((unsigned)value < ARRAY_SIZE(func_table)) {
765 unsigned long flags;
766
767 spin_lock_irqsave(&func_buf_lock, flags);
768 if (func_table[value])
769 puts_queue(vc, func_table[value]);
770 spin_unlock_irqrestore(&func_buf_lock, flags);
771
772 } else
773 pr_err("k_fn called with value=%d\n", value);
774}
775
776static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
777{
778 static const char cur_chars[] = "BDCA";
779
780 if (up_flag)
781 return;
782
783 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
784}
785
786static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
787{
788 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
789 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
790
791 if (up_flag)
792 return;
793
794
795 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
796 applkey(vc, app_map[value], 1);
797 return;
798 }
799
800 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
801
802 switch (value) {
803 case KVAL(K_PCOMMA):
804 case KVAL(K_PDOT):
805 k_fn(vc, KVAL(K_REMOVE), 0);
806 return;
807 case KVAL(K_P0):
808 k_fn(vc, KVAL(K_INSERT), 0);
809 return;
810 case KVAL(K_P1):
811 k_fn(vc, KVAL(K_SELECT), 0);
812 return;
813 case KVAL(K_P2):
814 k_cur(vc, KVAL(K_DOWN), 0);
815 return;
816 case KVAL(K_P3):
817 k_fn(vc, KVAL(K_PGDN), 0);
818 return;
819 case KVAL(K_P4):
820 k_cur(vc, KVAL(K_LEFT), 0);
821 return;
822 case KVAL(K_P6):
823 k_cur(vc, KVAL(K_RIGHT), 0);
824 return;
825 case KVAL(K_P7):
826 k_fn(vc, KVAL(K_FIND), 0);
827 return;
828 case KVAL(K_P8):
829 k_cur(vc, KVAL(K_UP), 0);
830 return;
831 case KVAL(K_P9):
832 k_fn(vc, KVAL(K_PGUP), 0);
833 return;
834 case KVAL(K_P5):
835 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
836 return;
837 }
838 }
839
840 put_queue(vc, pad_chars[value]);
841 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
842 put_queue(vc, '\n');
843}
844
845static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
846{
847 int old_state = shift_state;
848
849 if (rep)
850 return;
851
852
853
854
855 if (value == KVAL(K_CAPSSHIFT)) {
856 value = KVAL(K_SHIFT);
857 if (!up_flag)
858 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
859 }
860
861 if (up_flag) {
862
863
864
865
866 if (shift_down[value])
867 shift_down[value]--;
868 } else
869 shift_down[value]++;
870
871 if (shift_down[value])
872 shift_state |= BIT(value);
873 else
874 shift_state &= ~BIT(value);
875
876
877 if (up_flag && shift_state != old_state && npadch_active) {
878 if (kbd->kbdmode == VC_UNICODE)
879 to_utf8(vc, npadch_value);
880 else
881 put_queue(vc, npadch_value & 0xff);
882 npadch_active = false;
883 }
884}
885
886static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
887{
888 if (up_flag)
889 return;
890
891 if (vc_kbd_mode(kbd, VC_META)) {
892 put_queue(vc, '\033');
893 put_queue(vc, value);
894 } else
895 put_queue(vc, value | BIT(7));
896}
897
898static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
899{
900 unsigned int base;
901
902 if (up_flag)
903 return;
904
905 if (value < 10) {
906
907 base = 10;
908 } else {
909
910 value -= 10;
911 base = 16;
912 }
913
914 if (!npadch_active) {
915 npadch_value = 0;
916 npadch_active = true;
917 }
918
919 npadch_value = npadch_value * base + value;
920}
921
922static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
923{
924 if (up_flag || rep)
925 return;
926
927 chg_vc_kbd_lock(kbd, value);
928}
929
930static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
931{
932 k_shift(vc, value, up_flag);
933 if (up_flag || rep)
934 return;
935
936 chg_vc_kbd_slock(kbd, value);
937
938 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
939 kbd->slockstate = 0;
940 chg_vc_kbd_slock(kbd, value);
941 }
942}
943
944
945static unsigned brl_timeout = 300;
946MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
947module_param(brl_timeout, uint, 0644);
948
949static unsigned brl_nbchords = 1;
950MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
951module_param(brl_nbchords, uint, 0644);
952
953static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
954{
955 static unsigned long chords;
956 static unsigned committed;
957
958 if (!brl_nbchords)
959 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
960 else {
961 committed |= pattern;
962 chords++;
963 if (chords == brl_nbchords) {
964 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
965 chords = 0;
966 committed = 0;
967 }
968 }
969}
970
971static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
972{
973 static unsigned pressed, committing;
974 static unsigned long releasestart;
975
976 if (kbd->kbdmode != VC_UNICODE) {
977 if (!up_flag)
978 pr_warn("keyboard mode must be unicode for braille patterns\n");
979 return;
980 }
981
982 if (!value) {
983 k_unicode(vc, BRL_UC_ROW, up_flag);
984 return;
985 }
986
987 if (value > 8)
988 return;
989
990 if (!up_flag) {
991 pressed |= BIT(value - 1);
992 if (!brl_timeout)
993 committing = pressed;
994 } else if (brl_timeout) {
995 if (!committing ||
996 time_after(jiffies,
997 releasestart + msecs_to_jiffies(brl_timeout))) {
998 committing = pressed;
999 releasestart = jiffies;
1000 }
1001 pressed &= ~BIT(value - 1);
1002 if (!pressed && committing) {
1003 k_brlcommit(vc, committing, 0);
1004 committing = 0;
1005 }
1006 } else {
1007 if (committing) {
1008 k_brlcommit(vc, committing, 0);
1009 committing = 0;
1010 }
1011 pressed &= ~BIT(value - 1);
1012 }
1013}
1014
1015#if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
1016
1017struct kbd_led_trigger {
1018 struct led_trigger trigger;
1019 unsigned int mask;
1020};
1021
1022static int kbd_led_trigger_activate(struct led_classdev *cdev)
1023{
1024 struct kbd_led_trigger *trigger =
1025 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
1026
1027 tasklet_disable(&keyboard_tasklet);
1028 if (ledstate != -1U)
1029 led_trigger_event(&trigger->trigger,
1030 ledstate & trigger->mask ?
1031 LED_FULL : LED_OFF);
1032 tasklet_enable(&keyboard_tasklet);
1033
1034 return 0;
1035}
1036
1037#define KBD_LED_TRIGGER(_led_bit, _name) { \
1038 .trigger = { \
1039 .name = _name, \
1040 .activate = kbd_led_trigger_activate, \
1041 }, \
1042 .mask = BIT(_led_bit), \
1043 }
1044
1045#define KBD_LOCKSTATE_TRIGGER(_led_bit, _name) \
1046 KBD_LED_TRIGGER((_led_bit) + 8, _name)
1047
1048static struct kbd_led_trigger kbd_led_triggers[] = {
1049 KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
1050 KBD_LED_TRIGGER(VC_NUMLOCK, "kbd-numlock"),
1051 KBD_LED_TRIGGER(VC_CAPSLOCK, "kbd-capslock"),
1052 KBD_LED_TRIGGER(VC_KANALOCK, "kbd-kanalock"),
1053
1054 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK, "kbd-shiftlock"),
1055 KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK, "kbd-altgrlock"),
1056 KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK, "kbd-ctrllock"),
1057 KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK, "kbd-altlock"),
1058 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1059 KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1060 KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK, "kbd-ctrlllock"),
1061 KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK, "kbd-ctrlrlock"),
1062};
1063
1064static void kbd_propagate_led_state(unsigned int old_state,
1065 unsigned int new_state)
1066{
1067 struct kbd_led_trigger *trigger;
1068 unsigned int changed = old_state ^ new_state;
1069 int i;
1070
1071 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1072 trigger = &kbd_led_triggers[i];
1073
1074 if (changed & trigger->mask)
1075 led_trigger_event(&trigger->trigger,
1076 new_state & trigger->mask ?
1077 LED_FULL : LED_OFF);
1078 }
1079}
1080
1081static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1082{
1083 unsigned int led_state = *(unsigned int *)data;
1084
1085 if (test_bit(EV_LED, handle->dev->evbit))
1086 kbd_propagate_led_state(~led_state, led_state);
1087
1088 return 0;
1089}
1090
1091static void kbd_init_leds(void)
1092{
1093 int error;
1094 int i;
1095
1096 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1097 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1098 if (error)
1099 pr_err("error %d while registering trigger %s\n",
1100 error, kbd_led_triggers[i].trigger.name);
1101 }
1102}
1103
1104#else
1105
1106static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1107{
1108 unsigned int leds = *(unsigned int *)data;
1109
1110 if (test_bit(EV_LED, handle->dev->evbit)) {
1111 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & BIT(0)));
1112 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & BIT(1)));
1113 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & BIT(2)));
1114 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1115 }
1116
1117 return 0;
1118}
1119
1120static void kbd_propagate_led_state(unsigned int old_state,
1121 unsigned int new_state)
1122{
1123 input_handler_for_each_handle(&kbd_handler, &new_state,
1124 kbd_update_leds_helper);
1125}
1126
1127static void kbd_init_leds(void)
1128{
1129}
1130
1131#endif
1132
1133
1134
1135
1136
1137
1138static unsigned char getledstate(void)
1139{
1140 return ledstate & 0xff;
1141}
1142
1143void setledstate(struct kbd_struct *kb, unsigned int led)
1144{
1145 unsigned long flags;
1146 spin_lock_irqsave(&led_lock, flags);
1147 if (!(led & ~7)) {
1148 ledioctl = led;
1149 kb->ledmode = LED_SHOW_IOCTL;
1150 } else
1151 kb->ledmode = LED_SHOW_FLAGS;
1152
1153 set_leds();
1154 spin_unlock_irqrestore(&led_lock, flags);
1155}
1156
1157static inline unsigned char getleds(void)
1158{
1159 struct kbd_struct *kb = kbd_table + fg_console;
1160
1161 if (kb->ledmode == LED_SHOW_IOCTL)
1162 return ledioctl;
1163
1164 return kb->ledflagstate;
1165}
1166
1167
1168
1169
1170
1171
1172
1173
1174int vt_get_leds(unsigned int console, int flag)
1175{
1176 struct kbd_struct *kb = &kbd_table[console];
1177 int ret;
1178 unsigned long flags;
1179
1180 spin_lock_irqsave(&led_lock, flags);
1181 ret = vc_kbd_led(kb, flag);
1182 spin_unlock_irqrestore(&led_lock, flags);
1183
1184 return ret;
1185}
1186EXPORT_SYMBOL_GPL(vt_get_leds);
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196void vt_set_led_state(unsigned int console, int leds)
1197{
1198 struct kbd_struct *kb = &kbd_table[console];
1199 setledstate(kb, leds);
1200}
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215void vt_kbd_con_start(unsigned int console)
1216{
1217 struct kbd_struct *kb = &kbd_table[console];
1218 unsigned long flags;
1219 spin_lock_irqsave(&led_lock, flags);
1220 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1221 set_leds();
1222 spin_unlock_irqrestore(&led_lock, flags);
1223}
1224
1225
1226
1227
1228
1229
1230
1231
1232void vt_kbd_con_stop(unsigned int console)
1233{
1234 struct kbd_struct *kb = &kbd_table[console];
1235 unsigned long flags;
1236 spin_lock_irqsave(&led_lock, flags);
1237 set_vc_kbd_led(kb, VC_SCROLLOCK);
1238 set_leds();
1239 spin_unlock_irqrestore(&led_lock, flags);
1240}
1241
1242
1243
1244
1245
1246
1247
1248static void kbd_bh(struct tasklet_struct *unused)
1249{
1250 unsigned int leds;
1251 unsigned long flags;
1252
1253 spin_lock_irqsave(&led_lock, flags);
1254 leds = getleds();
1255 leds |= (unsigned int)kbd->lockstate << 8;
1256 spin_unlock_irqrestore(&led_lock, flags);
1257
1258 if (leds != ledstate) {
1259 kbd_propagate_led_state(ledstate, leds);
1260 ledstate = leds;
1261 }
1262}
1263
1264#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1265 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1266 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1267 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1268
1269static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1270{
1271 if (!test_bit(EV_MSC, dev->evbit) || !test_bit(MSC_RAW, dev->mscbit))
1272 return false;
1273
1274 return dev->id.bustype == BUS_I8042 &&
1275 dev->id.vendor == 0x0001 && dev->id.product == 0x0001;
1276}
1277
1278static const unsigned short x86_keycodes[256] =
1279 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1280 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1281 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1282 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1283 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1284 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1285 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1286 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1287 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1288 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1289 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1290 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1291 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1292 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1293 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1294
1295#ifdef CONFIG_SPARC
1296static int sparc_l1_a_state;
1297extern void sun_do_break(void);
1298#endif
1299
1300static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1301 unsigned char up_flag)
1302{
1303 int code;
1304
1305 switch (keycode) {
1306
1307 case KEY_PAUSE:
1308 put_queue(vc, 0xe1);
1309 put_queue(vc, 0x1d | up_flag);
1310 put_queue(vc, 0x45 | up_flag);
1311 break;
1312
1313 case KEY_HANGEUL:
1314 if (!up_flag)
1315 put_queue(vc, 0xf2);
1316 break;
1317
1318 case KEY_HANJA:
1319 if (!up_flag)
1320 put_queue(vc, 0xf1);
1321 break;
1322
1323 case KEY_SYSRQ:
1324
1325
1326
1327
1328
1329
1330 if (test_bit(KEY_LEFTALT, key_down) ||
1331 test_bit(KEY_RIGHTALT, key_down)) {
1332 put_queue(vc, 0x54 | up_flag);
1333 } else {
1334 put_queue(vc, 0xe0);
1335 put_queue(vc, 0x2a | up_flag);
1336 put_queue(vc, 0xe0);
1337 put_queue(vc, 0x37 | up_flag);
1338 }
1339 break;
1340
1341 default:
1342 if (keycode > 255)
1343 return -1;
1344
1345 code = x86_keycodes[keycode];
1346 if (!code)
1347 return -1;
1348
1349 if (code & 0x100)
1350 put_queue(vc, 0xe0);
1351 put_queue(vc, (code & 0x7f) | up_flag);
1352
1353 break;
1354 }
1355
1356 return 0;
1357}
1358
1359#else
1360
1361static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1362{
1363 return false;
1364}
1365
1366static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1367{
1368 if (keycode > 127)
1369 return -1;
1370
1371 put_queue(vc, keycode | up_flag);
1372 return 0;
1373}
1374#endif
1375
1376static void kbd_rawcode(unsigned char data)
1377{
1378 struct vc_data *vc = vc_cons[fg_console].d;
1379
1380 kbd = &kbd_table[vc->vc_num];
1381 if (kbd->kbdmode == VC_RAW)
1382 put_queue(vc, data);
1383}
1384
1385static void kbd_keycode(unsigned int keycode, int down, bool hw_raw)
1386{
1387 struct vc_data *vc = vc_cons[fg_console].d;
1388 unsigned short keysym, *key_map;
1389 unsigned char type;
1390 bool raw_mode;
1391 struct tty_struct *tty;
1392 int shift_final;
1393 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1394 int rc;
1395
1396 tty = vc->port.tty;
1397
1398 if (tty && (!tty->driver_data)) {
1399
1400 tty->driver_data = vc;
1401 }
1402
1403 kbd = &kbd_table[vc->vc_num];
1404
1405#ifdef CONFIG_SPARC
1406 if (keycode == KEY_STOP)
1407 sparc_l1_a_state = down;
1408#endif
1409
1410 rep = (down == 2);
1411
1412 raw_mode = (kbd->kbdmode == VC_RAW);
1413 if (raw_mode && !hw_raw)
1414 if (emulate_raw(vc, keycode, !down << 7))
1415 if (keycode < BTN_MISC && printk_ratelimit())
1416 pr_warn("can't emulate rawmode for keycode %d\n",
1417 keycode);
1418
1419#ifdef CONFIG_SPARC
1420 if (keycode == KEY_A && sparc_l1_a_state) {
1421 sparc_l1_a_state = false;
1422 sun_do_break();
1423 }
1424#endif
1425
1426 if (kbd->kbdmode == VC_MEDIUMRAW) {
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436 if (keycode < 128) {
1437 put_queue(vc, keycode | (!down << 7));
1438 } else {
1439 put_queue(vc, !down << 7);
1440 put_queue(vc, (keycode >> 7) | BIT(7));
1441 put_queue(vc, keycode | BIT(7));
1442 }
1443 raw_mode = true;
1444 }
1445
1446 assign_bit(keycode, key_down, down);
1447
1448 if (rep &&
1449 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1450 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1451
1452
1453
1454
1455
1456 return;
1457 }
1458
1459 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1460 param.ledstate = kbd->ledflagstate;
1461 key_map = key_maps[shift_final];
1462
1463 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1464 KBD_KEYCODE, ¶m);
1465 if (rc == NOTIFY_STOP || !key_map) {
1466 atomic_notifier_call_chain(&keyboard_notifier_list,
1467 KBD_UNBOUND_KEYCODE, ¶m);
1468 do_compute_shiftstate();
1469 kbd->slockstate = 0;
1470 return;
1471 }
1472
1473 if (keycode < NR_KEYS)
1474 keysym = key_map[keycode];
1475 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1476 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1477 else
1478 return;
1479
1480 type = KTYP(keysym);
1481
1482 if (type < 0xf0) {
1483 param.value = keysym;
1484 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1485 KBD_UNICODE, ¶m);
1486 if (rc != NOTIFY_STOP)
1487 if (down && !raw_mode)
1488 k_unicode(vc, keysym, !down);
1489 return;
1490 }
1491
1492 type -= 0xf0;
1493
1494 if (type == KT_LETTER) {
1495 type = KT_LATIN;
1496 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1497 key_map = key_maps[shift_final ^ BIT(KG_SHIFT)];
1498 if (key_map)
1499 keysym = key_map[keycode];
1500 }
1501 }
1502
1503 param.value = keysym;
1504 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1505 KBD_KEYSYM, ¶m);
1506 if (rc == NOTIFY_STOP)
1507 return;
1508
1509 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1510 return;
1511
1512 (*k_handler[type])(vc, keysym & 0xff, !down);
1513
1514 param.ledstate = kbd->ledflagstate;
1515 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1516
1517 if (type != KT_SLOCK)
1518 kbd->slockstate = 0;
1519}
1520
1521static void kbd_event(struct input_handle *handle, unsigned int event_type,
1522 unsigned int event_code, int value)
1523{
1524
1525 spin_lock(&kbd_event_lock);
1526
1527 if (event_type == EV_MSC && event_code == MSC_RAW &&
1528 kbd_is_hw_raw(handle->dev))
1529 kbd_rawcode(value);
1530 if (event_type == EV_KEY && event_code <= KEY_MAX)
1531 kbd_keycode(event_code, value, kbd_is_hw_raw(handle->dev));
1532
1533 spin_unlock(&kbd_event_lock);
1534
1535 tasklet_schedule(&keyboard_tasklet);
1536 do_poke_blanked_console = 1;
1537 schedule_console_callback();
1538}
1539
1540static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1541{
1542 if (test_bit(EV_SND, dev->evbit))
1543 return true;
1544
1545 if (test_bit(EV_KEY, dev->evbit)) {
1546 if (find_next_bit(dev->keybit, BTN_MISC, KEY_RESERVED) <
1547 BTN_MISC)
1548 return true;
1549 if (find_next_bit(dev->keybit, KEY_BRL_DOT10 + 1,
1550 KEY_BRL_DOT1) <= KEY_BRL_DOT10)
1551 return true;
1552 }
1553
1554 return false;
1555}
1556
1557
1558
1559
1560
1561
1562
1563static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1564 const struct input_device_id *id)
1565{
1566 struct input_handle *handle;
1567 int error;
1568
1569 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1570 if (!handle)
1571 return -ENOMEM;
1572
1573 handle->dev = dev;
1574 handle->handler = handler;
1575 handle->name = "kbd";
1576
1577 error = input_register_handle(handle);
1578 if (error)
1579 goto err_free_handle;
1580
1581 error = input_open_device(handle);
1582 if (error)
1583 goto err_unregister_handle;
1584
1585 return 0;
1586
1587 err_unregister_handle:
1588 input_unregister_handle(handle);
1589 err_free_handle:
1590 kfree(handle);
1591 return error;
1592}
1593
1594static void kbd_disconnect(struct input_handle *handle)
1595{
1596 input_close_device(handle);
1597 input_unregister_handle(handle);
1598 kfree(handle);
1599}
1600
1601
1602
1603
1604
1605static void kbd_start(struct input_handle *handle)
1606{
1607 tasklet_disable(&keyboard_tasklet);
1608
1609 if (ledstate != -1U)
1610 kbd_update_leds_helper(handle, &ledstate);
1611
1612 tasklet_enable(&keyboard_tasklet);
1613}
1614
1615static const struct input_device_id kbd_ids[] = {
1616 {
1617 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1618 .evbit = { BIT_MASK(EV_KEY) },
1619 },
1620
1621 {
1622 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1623 .evbit = { BIT_MASK(EV_SND) },
1624 },
1625
1626 { },
1627};
1628
1629MODULE_DEVICE_TABLE(input, kbd_ids);
1630
1631static struct input_handler kbd_handler = {
1632 .event = kbd_event,
1633 .match = kbd_match,
1634 .connect = kbd_connect,
1635 .disconnect = kbd_disconnect,
1636 .start = kbd_start,
1637 .name = "kbd",
1638 .id_table = kbd_ids,
1639};
1640
1641int __init kbd_init(void)
1642{
1643 int i;
1644 int error;
1645
1646 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1647 kbd_table[i].ledflagstate = kbd_defleds();
1648 kbd_table[i].default_ledflagstate = kbd_defleds();
1649 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1650 kbd_table[i].lockstate = KBD_DEFLOCK;
1651 kbd_table[i].slockstate = 0;
1652 kbd_table[i].modeflags = KBD_DEFMODE;
1653 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1654 }
1655
1656 kbd_init_leds();
1657
1658 error = input_register_handler(&kbd_handler);
1659 if (error)
1660 return error;
1661
1662 tasklet_enable(&keyboard_tasklet);
1663 tasklet_schedule(&keyboard_tasklet);
1664
1665 return 0;
1666}
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1680{
1681 unsigned long flags;
1682 int asize;
1683 int ret = 0;
1684
1685 switch (cmd) {
1686 case KDGKBDIACR:
1687 {
1688 struct kbdiacrs __user *a = udp;
1689 struct kbdiacr *dia;
1690 int i;
1691
1692 dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr),
1693 GFP_KERNEL);
1694 if (!dia)
1695 return -ENOMEM;
1696
1697
1698
1699 spin_lock_irqsave(&kbd_event_lock, flags);
1700
1701 asize = accent_table_size;
1702 for (i = 0; i < asize; i++) {
1703 dia[i].diacr = conv_uni_to_8bit(
1704 accent_table[i].diacr);
1705 dia[i].base = conv_uni_to_8bit(
1706 accent_table[i].base);
1707 dia[i].result = conv_uni_to_8bit(
1708 accent_table[i].result);
1709 }
1710 spin_unlock_irqrestore(&kbd_event_lock, flags);
1711
1712 if (put_user(asize, &a->kb_cnt))
1713 ret = -EFAULT;
1714 else if (copy_to_user(a->kbdiacr, dia,
1715 asize * sizeof(struct kbdiacr)))
1716 ret = -EFAULT;
1717 kfree(dia);
1718 return ret;
1719 }
1720 case KDGKBDIACRUC:
1721 {
1722 struct kbdiacrsuc __user *a = udp;
1723 void *buf;
1724
1725 buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc),
1726 GFP_KERNEL);
1727 if (buf == NULL)
1728 return -ENOMEM;
1729
1730
1731
1732 spin_lock_irqsave(&kbd_event_lock, flags);
1733
1734 asize = accent_table_size;
1735 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1736
1737 spin_unlock_irqrestore(&kbd_event_lock, flags);
1738
1739 if (put_user(asize, &a->kb_cnt))
1740 ret = -EFAULT;
1741 else if (copy_to_user(a->kbdiacruc, buf,
1742 asize*sizeof(struct kbdiacruc)))
1743 ret = -EFAULT;
1744 kfree(buf);
1745 return ret;
1746 }
1747
1748 case KDSKBDIACR:
1749 {
1750 struct kbdiacrs __user *a = udp;
1751 struct kbdiacr *dia = NULL;
1752 unsigned int ct;
1753 int i;
1754
1755 if (!perm)
1756 return -EPERM;
1757 if (get_user(ct, &a->kb_cnt))
1758 return -EFAULT;
1759 if (ct >= MAX_DIACR)
1760 return -EINVAL;
1761
1762 if (ct) {
1763
1764 dia = memdup_user(a->kbdiacr,
1765 sizeof(struct kbdiacr) * ct);
1766 if (IS_ERR(dia))
1767 return PTR_ERR(dia);
1768
1769 }
1770
1771 spin_lock_irqsave(&kbd_event_lock, flags);
1772 accent_table_size = ct;
1773 for (i = 0; i < ct; i++) {
1774 accent_table[i].diacr =
1775 conv_8bit_to_uni(dia[i].diacr);
1776 accent_table[i].base =
1777 conv_8bit_to_uni(dia[i].base);
1778 accent_table[i].result =
1779 conv_8bit_to_uni(dia[i].result);
1780 }
1781 spin_unlock_irqrestore(&kbd_event_lock, flags);
1782 kfree(dia);
1783 return 0;
1784 }
1785
1786 case KDSKBDIACRUC:
1787 {
1788 struct kbdiacrsuc __user *a = udp;
1789 unsigned int ct;
1790 void *buf = NULL;
1791
1792 if (!perm)
1793 return -EPERM;
1794
1795 if (get_user(ct, &a->kb_cnt))
1796 return -EFAULT;
1797
1798 if (ct >= MAX_DIACR)
1799 return -EINVAL;
1800
1801 if (ct) {
1802 buf = memdup_user(a->kbdiacruc,
1803 ct * sizeof(struct kbdiacruc));
1804 if (IS_ERR(buf))
1805 return PTR_ERR(buf);
1806 }
1807 spin_lock_irqsave(&kbd_event_lock, flags);
1808 if (ct)
1809 memcpy(accent_table, buf,
1810 ct * sizeof(struct kbdiacruc));
1811 accent_table_size = ct;
1812 spin_unlock_irqrestore(&kbd_event_lock, flags);
1813 kfree(buf);
1814 return 0;
1815 }
1816 }
1817 return ret;
1818}
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828int vt_do_kdskbmode(unsigned int console, unsigned int arg)
1829{
1830 struct kbd_struct *kb = &kbd_table[console];
1831 int ret = 0;
1832 unsigned long flags;
1833
1834 spin_lock_irqsave(&kbd_event_lock, flags);
1835 switch(arg) {
1836 case K_RAW:
1837 kb->kbdmode = VC_RAW;
1838 break;
1839 case K_MEDIUMRAW:
1840 kb->kbdmode = VC_MEDIUMRAW;
1841 break;
1842 case K_XLATE:
1843 kb->kbdmode = VC_XLATE;
1844 do_compute_shiftstate();
1845 break;
1846 case K_UNICODE:
1847 kb->kbdmode = VC_UNICODE;
1848 do_compute_shiftstate();
1849 break;
1850 case K_OFF:
1851 kb->kbdmode = VC_OFF;
1852 break;
1853 default:
1854 ret = -EINVAL;
1855 }
1856 spin_unlock_irqrestore(&kbd_event_lock, flags);
1857 return ret;
1858}
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868int vt_do_kdskbmeta(unsigned int console, unsigned int arg)
1869{
1870 struct kbd_struct *kb = &kbd_table[console];
1871 int ret = 0;
1872 unsigned long flags;
1873
1874 spin_lock_irqsave(&kbd_event_lock, flags);
1875 switch(arg) {
1876 case K_METABIT:
1877 clr_vc_kbd_mode(kb, VC_META);
1878 break;
1879 case K_ESCPREFIX:
1880 set_vc_kbd_mode(kb, VC_META);
1881 break;
1882 default:
1883 ret = -EINVAL;
1884 }
1885 spin_unlock_irqrestore(&kbd_event_lock, flags);
1886 return ret;
1887}
1888
1889int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1890 int perm)
1891{
1892 struct kbkeycode tmp;
1893 int kc = 0;
1894
1895 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1896 return -EFAULT;
1897 switch (cmd) {
1898 case KDGETKEYCODE:
1899 kc = getkeycode(tmp.scancode);
1900 if (kc >= 0)
1901 kc = put_user(kc, &user_kbkc->keycode);
1902 break;
1903 case KDSETKEYCODE:
1904 if (!perm)
1905 return -EPERM;
1906 kc = setkeycode(tmp.scancode, tmp.keycode);
1907 break;
1908 }
1909 return kc;
1910}
1911
1912static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx,
1913 unsigned char map)
1914{
1915 unsigned short *key_map, val;
1916 unsigned long flags;
1917
1918
1919 spin_lock_irqsave(&kbd_event_lock, flags);
1920 key_map = key_maps[map];
1921 if (key_map) {
1922 val = U(key_map[idx]);
1923 if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1924 val = K_HOLE;
1925 } else
1926 val = idx ? K_HOLE : K_NOSUCHMAP;
1927 spin_unlock_irqrestore(&kbd_event_lock, flags);
1928
1929 return val;
1930}
1931
1932static int vt_kdskbent(unsigned char kbdmode, unsigned char idx,
1933 unsigned char map, unsigned short val)
1934{
1935 unsigned long flags;
1936 unsigned short *key_map, *new_map, oldval;
1937
1938 if (!idx && val == K_NOSUCHMAP) {
1939 spin_lock_irqsave(&kbd_event_lock, flags);
1940
1941 key_map = key_maps[map];
1942 if (map && key_map) {
1943 key_maps[map] = NULL;
1944 if (key_map[0] == U(K_ALLOCATED)) {
1945 kfree(key_map);
1946 keymap_count--;
1947 }
1948 }
1949 spin_unlock_irqrestore(&kbd_event_lock, flags);
1950
1951 return 0;
1952 }
1953
1954 if (KTYP(val) < NR_TYPES) {
1955 if (KVAL(val) > max_vals[KTYP(val)])
1956 return -EINVAL;
1957 } else if (kbdmode != VC_UNICODE)
1958 return -EINVAL;
1959
1960
1961#if !defined(__mc68000__) && !defined(__powerpc__)
1962
1963 if (!idx)
1964 return 0;
1965#endif
1966
1967 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1968 if (!new_map)
1969 return -ENOMEM;
1970
1971 spin_lock_irqsave(&kbd_event_lock, flags);
1972 key_map = key_maps[map];
1973 if (key_map == NULL) {
1974 int j;
1975
1976 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1977 !capable(CAP_SYS_RESOURCE)) {
1978 spin_unlock_irqrestore(&kbd_event_lock, flags);
1979 kfree(new_map);
1980 return -EPERM;
1981 }
1982 key_maps[map] = new_map;
1983 key_map = new_map;
1984 key_map[0] = U(K_ALLOCATED);
1985 for (j = 1; j < NR_KEYS; j++)
1986 key_map[j] = U(K_HOLE);
1987 keymap_count++;
1988 } else
1989 kfree(new_map);
1990
1991 oldval = U(key_map[idx]);
1992 if (val == oldval)
1993 goto out;
1994
1995
1996 if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) {
1997 spin_unlock_irqrestore(&kbd_event_lock, flags);
1998 return -EPERM;
1999 }
2000
2001 key_map[idx] = U(val);
2002 if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT))
2003 do_compute_shiftstate();
2004out:
2005 spin_unlock_irqrestore(&kbd_event_lock, flags);
2006
2007 return 0;
2008}
2009
2010int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
2011 unsigned int console)
2012{
2013 struct kbd_struct *kb = &kbd_table[console];
2014 struct kbentry kbe;
2015
2016 if (copy_from_user(&kbe, user_kbe, sizeof(struct kbentry)))
2017 return -EFAULT;
2018
2019 switch (cmd) {
2020 case KDGKBENT:
2021 return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index,
2022 kbe.kb_table),
2023 &user_kbe->kb_value);
2024 case KDSKBENT:
2025 if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2026 return -EPERM;
2027 return vt_kdskbent(kb->kbdmode, kbe.kb_index, kbe.kb_table,
2028 kbe.kb_value);
2029 }
2030 return 0;
2031}
2032
2033static char *vt_kdskbsent(char *kbs, unsigned char cur)
2034{
2035 static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC);
2036 char *cur_f = func_table[cur];
2037
2038 if (cur_f && strlen(cur_f) >= strlen(kbs)) {
2039 strcpy(cur_f, kbs);
2040 return kbs;
2041 }
2042
2043 func_table[cur] = kbs;
2044
2045 return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL;
2046}
2047
2048int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2049{
2050 unsigned char kb_func;
2051 unsigned long flags;
2052 char *kbs;
2053 int ret;
2054
2055 if (get_user(kb_func, &user_kdgkb->kb_func))
2056 return -EFAULT;
2057
2058 kb_func = array_index_nospec(kb_func, MAX_NR_FUNC);
2059
2060 switch (cmd) {
2061 case KDGKBSENT: {
2062
2063 ssize_t len = sizeof(user_kdgkb->kb_string);
2064
2065 kbs = kmalloc(len, GFP_KERNEL);
2066 if (!kbs)
2067 return -ENOMEM;
2068
2069 spin_lock_irqsave(&func_buf_lock, flags);
2070 len = strlcpy(kbs, func_table[kb_func] ? : "", len);
2071 spin_unlock_irqrestore(&func_buf_lock, flags);
2072
2073 ret = copy_to_user(user_kdgkb->kb_string, kbs, len + 1) ?
2074 -EFAULT : 0;
2075
2076 break;
2077 }
2078 case KDSKBSENT:
2079 if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2080 return -EPERM;
2081
2082 kbs = strndup_user(user_kdgkb->kb_string,
2083 sizeof(user_kdgkb->kb_string));
2084 if (IS_ERR(kbs))
2085 return PTR_ERR(kbs);
2086
2087 spin_lock_irqsave(&func_buf_lock, flags);
2088 kbs = vt_kdskbsent(kbs, kb_func);
2089 spin_unlock_irqrestore(&func_buf_lock, flags);
2090
2091 ret = 0;
2092 break;
2093 }
2094
2095 kfree(kbs);
2096
2097 return ret;
2098}
2099
2100int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm)
2101{
2102 struct kbd_struct *kb = &kbd_table[console];
2103 unsigned long flags;
2104 unsigned char ucval;
2105
2106 switch(cmd) {
2107
2108
2109 case KDGKBLED:
2110 spin_lock_irqsave(&kbd_event_lock, flags);
2111 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2112 spin_unlock_irqrestore(&kbd_event_lock, flags);
2113 return put_user(ucval, (char __user *)arg);
2114
2115 case KDSKBLED:
2116 if (!perm)
2117 return -EPERM;
2118 if (arg & ~0x77)
2119 return -EINVAL;
2120 spin_lock_irqsave(&led_lock, flags);
2121 kb->ledflagstate = (arg & 7);
2122 kb->default_ledflagstate = ((arg >> 4) & 7);
2123 set_leds();
2124 spin_unlock_irqrestore(&led_lock, flags);
2125 return 0;
2126
2127
2128
2129 case KDGETLED:
2130 ucval = getledstate();
2131 return put_user(ucval, (char __user *)arg);
2132
2133 case KDSETLED:
2134 if (!perm)
2135 return -EPERM;
2136 setledstate(kb, arg);
2137 return 0;
2138 }
2139 return -ENOIOCTLCMD;
2140}
2141
2142int vt_do_kdgkbmode(unsigned int console)
2143{
2144 struct kbd_struct *kb = &kbd_table[console];
2145
2146 switch (kb->kbdmode) {
2147 case VC_RAW:
2148 return K_RAW;
2149 case VC_MEDIUMRAW:
2150 return K_MEDIUMRAW;
2151 case VC_UNICODE:
2152 return K_UNICODE;
2153 case VC_OFF:
2154 return K_OFF;
2155 default:
2156 return K_XLATE;
2157 }
2158}
2159
2160
2161
2162
2163
2164
2165
2166int vt_do_kdgkbmeta(unsigned int console)
2167{
2168 struct kbd_struct *kb = &kbd_table[console];
2169
2170 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2171}
2172
2173
2174
2175
2176
2177
2178
2179void vt_reset_unicode(unsigned int console)
2180{
2181 unsigned long flags;
2182
2183 spin_lock_irqsave(&kbd_event_lock, flags);
2184 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2185 spin_unlock_irqrestore(&kbd_event_lock, flags);
2186}
2187
2188
2189
2190
2191
2192
2193
2194int vt_get_shift_state(void)
2195{
2196
2197 return shift_state;
2198}
2199
2200
2201
2202
2203
2204
2205
2206
2207void vt_reset_keyboard(unsigned int console)
2208{
2209 struct kbd_struct *kb = &kbd_table[console];
2210 unsigned long flags;
2211
2212 spin_lock_irqsave(&kbd_event_lock, flags);
2213 set_vc_kbd_mode(kb, VC_REPEAT);
2214 clr_vc_kbd_mode(kb, VC_CKMODE);
2215 clr_vc_kbd_mode(kb, VC_APPLIC);
2216 clr_vc_kbd_mode(kb, VC_CRLF);
2217 kb->lockstate = 0;
2218 kb->slockstate = 0;
2219 spin_lock(&led_lock);
2220 kb->ledmode = LED_SHOW_FLAGS;
2221 kb->ledflagstate = kb->default_ledflagstate;
2222 spin_unlock(&led_lock);
2223
2224
2225 spin_unlock_irqrestore(&kbd_event_lock, flags);
2226}
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237int vt_get_kbd_mode_bit(unsigned int console, int bit)
2238{
2239 struct kbd_struct *kb = &kbd_table[console];
2240 return vc_kbd_mode(kb, bit);
2241}
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252void vt_set_kbd_mode_bit(unsigned int console, int bit)
2253{
2254 struct kbd_struct *kb = &kbd_table[console];
2255 unsigned long flags;
2256
2257 spin_lock_irqsave(&kbd_event_lock, flags);
2258 set_vc_kbd_mode(kb, bit);
2259 spin_unlock_irqrestore(&kbd_event_lock, flags);
2260}
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271void vt_clr_kbd_mode_bit(unsigned int console, int bit)
2272{
2273 struct kbd_struct *kb = &kbd_table[console];
2274 unsigned long flags;
2275
2276 spin_lock_irqsave(&kbd_event_lock, flags);
2277 clr_vc_kbd_mode(kb, bit);
2278 spin_unlock_irqrestore(&kbd_event_lock, flags);
2279}
2280