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