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
1776	dia = memdup_user(a->kbdiacr,
1777	sizeof(struct kbdiacr) * ct);
1778	if (IS_ERR(ptr: dia))
1779	return PTR_ERR(ptr: dia);
1780
1781	}
1782
1783	spin_lock_irqsave(&kbd_event_lock, flags);
1784	accent_table_size = ct;
1785	for (i = 0; i < ct; i++) {
1786	accent_table[i].diacr =
1787	conv_8bit_to_uni(c: dia[i].diacr);
1788	accent_table[i].base =
1789	conv_8bit_to_uni(c: dia[i].base);
1790	accent_table[i].result =
1791	conv_8bit_to_uni(c: dia[i].result);
1792	}
1793	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
1794	kfree(objp: dia);
1795	return 0;
1796	}
1797
1798	case KDSKBDIACRUC:
1799	{
1800	struct kbdiacrsuc __user *a = udp;
1801	unsigned int ct;
1802	void *buf = NULL;
1803
1804	if (!perm)
1805	return -EPERM;
1806
1807	if (get_user(ct, &a->kb_cnt))
1808	return -EFAULT;
1809
1810	if (ct >= MAX_DIACR)
1811	return -EINVAL;
1812
1813	if (ct) {
1814	buf = memdup_user(a->kbdiacruc,
1815	ct * sizeof(struct kbdiacruc));
1816	if (IS_ERR(ptr: buf))
1817	return PTR_ERR(ptr: buf);
1818	}
1819	spin_lock_irqsave(&kbd_event_lock, flags);
1820	if (ct)
1821	memcpy(accent_table, buf,
1822	ct * sizeof(struct kbdiacruc));
1823	accent_table_size = ct;
1824	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
1825	kfree(objp: buf);
1826	return 0;
1827	}
1828	}
1829	return ret;
1830	}
1831
1832	/**
1833	* vt_do_kdskbmode - set keyboard mode ioctl
1834	* @console: the console to use
1835	* @arg: the requested mode
1836	*
1837	* Update the keyboard mode bits while holding the correct locks.
1838	* Return 0 for success or an error code.
1839	*/
1840	int vt_do_kdskbmode(unsigned int console, unsigned int arg)
1841	{
1842	struct kbd_struct *kb = &kbd_table[console];
1843	int ret = 0;
1844	unsigned long flags;
1845
1846	spin_lock_irqsave(&kbd_event_lock, flags);
1847	switch(arg) {
1848	case K_RAW:
1849	kb->kbdmode = VC_RAW;
1850	break;
1851	case K_MEDIUMRAW:
1852	kb->kbdmode = VC_MEDIUMRAW;
1853	break;
1854	case K_XLATE:
1855	kb->kbdmode = VC_XLATE;
1856	do_compute_shiftstate();
1857	break;
1858	case K_UNICODE:
1859	kb->kbdmode = VC_UNICODE;
1860	do_compute_shiftstate();
1861	break;
1862	case K_OFF:
1863	kb->kbdmode = VC_OFF;
1864	break;
1865	default:
1866	ret = -EINVAL;
1867	}
1868	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
1869	return ret;
1870	}
1871
1872	/**
1873	* vt_do_kdskbmeta - set keyboard meta state
1874	* @console: the console to use
1875	* @arg: the requested meta state
1876	*
1877	* Update the keyboard meta bits while holding the correct locks.
1878	* Return 0 for success or an error code.
1879	*/
1880	int vt_do_kdskbmeta(unsigned int console, unsigned int arg)
1881	{
1882	struct kbd_struct *kb = &kbd_table[console];
1883	int ret = 0;
1884	unsigned long flags;
1885
1886	spin_lock_irqsave(&kbd_event_lock, flags);
1887	switch(arg) {
1888	case K_METABIT:
1889	clr_vc_kbd_mode(kbd: kb, VC_META);
1890	break;
1891	case K_ESCPREFIX:
1892	set_vc_kbd_mode(kbd: kb, VC_META);
1893	break;
1894	default:
1895	ret = -EINVAL;
1896	}
1897	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
1898	return ret;
1899	}
1900
1901	int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1902	int perm)
1903	{
1904	struct kbkeycode tmp;
1905	int kc = 0;
1906
1907	if (copy_from_user(to: &tmp, from: user_kbkc, n: sizeof(struct kbkeycode)))
1908	return -EFAULT;
1909	switch (cmd) {
1910	case KDGETKEYCODE:
1911	kc = getkeycode(scancode: tmp.scancode);
1912	if (kc >= 0)
1913	kc = put_user(kc, &user_kbkc->keycode);
1914	break;
1915	case KDSETKEYCODE:
1916	if (!perm)
1917	return -EPERM;
1918	kc = setkeycode(scancode: tmp.scancode, keycode: tmp.keycode);
1919	break;
1920	}
1921	return kc;
1922	}
1923
1924	static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx,
1925	unsigned char map)
1926	{
1927	unsigned short *key_map, val;
1928	unsigned long flags;
1929
1930	/* Ensure another thread doesn't free it under us */
1931	spin_lock_irqsave(&kbd_event_lock, flags);
1932	key_map = key_maps[map];
1933	if (key_map) {
1934	val = U(key_map[idx]);
1935	if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1936	val = K_HOLE;
1937	} else
1938	val = idx ? K_HOLE : K_NOSUCHMAP;
1939	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
1940
1941	return val;
1942	}
1943
1944	static int vt_kdskbent(unsigned char kbdmode, unsigned char idx,
1945	unsigned char map, unsigned short val)
1946	{
1947	unsigned long flags;
1948	unsigned short *key_map, *new_map, oldval;
1949
1950	if (!idx && val == K_NOSUCHMAP) {
1951	spin_lock_irqsave(&kbd_event_lock, flags);
1952	/* deallocate map */
1953	key_map = key_maps[map];
1954	if (map && key_map) {
1955	key_maps[map] = NULL;
1956	if (key_map[0] == U(K_ALLOCATED)) {
1957	kfree(objp: key_map);
1958	keymap_count--;
1959	}
1960	}
1961	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
1962
1963	return 0;
1964	}
1965
1966	if (KTYP(val) < NR_TYPES) {
1967	if (KVAL(val) > max_vals[KTYP(val)])
1968	return -EINVAL;
1969	} else if (kbdmode != VC_UNICODE)
1970	return -EINVAL;
1971
1972	/* ++Geert: non-PC keyboards may generate keycode zero */
1973	#if !defined(__mc68000__) && !defined(__powerpc__)
1974	/* assignment to entry 0 only tests validity of args */
1975	if (!idx)
1976	return 0;
1977	#endif
1978
1979	new_map = kmalloc(size: sizeof(plain_map), GFP_KERNEL);
1980	if (!new_map)
1981	return -ENOMEM;
1982
1983	spin_lock_irqsave(&kbd_event_lock, flags);
1984	key_map = key_maps[map];
1985	if (key_map == NULL) {
1986	int j;
1987
1988	if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1989	!capable(CAP_SYS_RESOURCE)) {
1990	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
1991	kfree(objp: new_map);
1992	return -EPERM;
1993	}
1994	key_maps[map] = new_map;
1995	key_map = new_map;
1996	key_map[0] = U(K_ALLOCATED);
1997	for (j = 1; j < NR_KEYS; j++)
1998	key_map[j] = U(K_HOLE);
1999	keymap_count++;
2000	} else
2001	kfree(objp: new_map);
2002
2003	oldval = U(key_map[idx]);
2004	if (val == oldval)
2005	goto out;
2006
2007	/* Attention Key */
2008	if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) {
2009	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
2010	return -EPERM;
2011	}
2012
2013	key_map[idx] = U(val);
2014	if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT))
2015	do_compute_shiftstate();
2016	out:
2017	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
2018
2019	return 0;
2020	}
2021
2022	int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
2023	unsigned int console)
2024	{
2025	struct kbd_struct *kb = &kbd_table[console];
2026	struct kbentry kbe;
2027
2028	if (copy_from_user(to: &kbe, from: user_kbe, n: sizeof(struct kbentry)))
2029	return -EFAULT;
2030
2031	switch (cmd) {
2032	case KDGKBENT:
2033	return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index,
2034	kbe.kb_table),
2035	&user_kbe->kb_value);
2036	case KDSKBENT:
2037	if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2038	return -EPERM;
2039	return vt_kdskbent(kbdmode: kb->kbdmode, idx: kbe.kb_index, map: kbe.kb_table,
2040	val: kbe.kb_value);
2041	}
2042	return 0;
2043	}
2044
2045	static char *vt_kdskbsent(char *kbs, unsigned char cur)
2046	{
2047	static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC);
2048	char *cur_f = func_table[cur];
2049
2050	if (cur_f && strlen(cur_f) >= strlen(kbs)) {
2051	strcpy(p: cur_f, q: kbs);
2052	return kbs;
2053	}
2054
2055	func_table[cur] = kbs;
2056
2057	return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL;
2058	}
2059
2060	int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2061	{
2062	unsigned char kb_func;
2063	unsigned long flags;
2064	char *kbs;
2065	int ret;
2066
2067	if (get_user(kb_func, &user_kdgkb->kb_func))
2068	return -EFAULT;
2069
2070	kb_func = array_index_nospec(kb_func, MAX_NR_FUNC);
2071
2072	switch (cmd) {
2073	case KDGKBSENT: {
2074	/* size should have been a struct member */
2075	ssize_t len = sizeof(user_kdgkb->kb_string);
2076
2077	kbs = kmalloc(size: len, GFP_KERNEL);
2078	if (!kbs)
2079	return -ENOMEM;
2080
2081	spin_lock_irqsave(&func_buf_lock, flags);
2082	len = strscpy(p: kbs, q: func_table[kb_func] ? : "", size: len);
2083	spin_unlock_irqrestore(lock: &func_buf_lock, flags);
2084
2085	if (len < 0) {
2086	ret = -ENOSPC;
2087	break;
2088	}
2089	ret = copy_to_user(to: user_kdgkb->kb_string, from: kbs, n: len + 1) ?
2090	-EFAULT : 0;
2091	break;
2092	}
2093	case KDSKBSENT:
2094	if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2095	return -EPERM;
2096
2097	kbs = strndup_user(user_kdgkb->kb_string,
2098	sizeof(user_kdgkb->kb_string));
2099	if (IS_ERR(ptr: kbs))
2100	return PTR_ERR(ptr: kbs);
2101
2102	spin_lock_irqsave(&func_buf_lock, flags);
2103	kbs = vt_kdskbsent(kbs, cur: kb_func);
2104	spin_unlock_irqrestore(lock: &func_buf_lock, flags);
2105
2106	ret = 0;
2107	break;
2108	}
2109
2110	kfree(objp: kbs);
2111
2112	return ret;
2113	}
2114
2115	int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm)
2116	{
2117	struct kbd_struct *kb = &kbd_table[console];
2118	unsigned long flags;
2119	unsigned char ucval;
2120
2121	switch(cmd) {
2122	/* the ioctls below read/set the flags usually shown in the leds */
2123	/* don't use them - they will go away without warning */
2124	case KDGKBLED:
2125	spin_lock_irqsave(&kbd_event_lock, flags);
2126	ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2127	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
2128	return put_user(ucval, (char __user *)arg);
2129
2130	case KDSKBLED:
2131	if (!perm)
2132	return -EPERM;
2133	if (arg & ~0x77)
2134	return -EINVAL;
2135	spin_lock_irqsave(&led_lock, flags);
2136	kb->ledflagstate = (arg & 7);
2137	kb->default_ledflagstate = ((arg >> 4) & 7);
2138	set_leds();
2139	spin_unlock_irqrestore(lock: &led_lock, flags);
2140	return 0;
2141
2142	/* the ioctls below only set the lights, not the functions */
2143	/* for those, see KDGKBLED and KDSKBLED above */
2144	case KDGETLED:
2145	ucval = getledstate();
2146	return put_user(ucval, (char __user *)arg);
2147
2148	case KDSETLED:
2149	if (!perm)
2150	return -EPERM;
2151	setledstate(kb, led: arg);
2152	return 0;
2153	}
2154	return -ENOIOCTLCMD;
2155	}
2156
2157	int vt_do_kdgkbmode(unsigned int console)
2158	{
2159	struct kbd_struct *kb = &kbd_table[console];
2160	/* This is a spot read so needs no locking */
2161	switch (kb->kbdmode) {
2162	case VC_RAW:
2163	return K_RAW;
2164	case VC_MEDIUMRAW:
2165	return K_MEDIUMRAW;
2166	case VC_UNICODE:
2167	return K_UNICODE;
2168	case VC_OFF:
2169	return K_OFF;
2170	default:
2171	return K_XLATE;
2172	}
2173	}
2174
2175	/**
2176	* vt_do_kdgkbmeta - report meta status
2177	* @console: console to report
2178	*
2179	* Report the meta flag status of this console
2180	*/
2181	int vt_do_kdgkbmeta(unsigned int console)
2182	{
2183	struct kbd_struct *kb = &kbd_table[console];
2184	/* Again a spot read so no locking */
2185	return vc_kbd_mode(kbd: kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2186	}
2187
2188	/**
2189	* vt_reset_unicode - reset the unicode status
2190	* @console: console being reset
2191	*
2192	* Restore the unicode console state to its default
2193	*/
2194	void vt_reset_unicode(unsigned int console)
2195	{
2196	unsigned long flags;
2197
2198	spin_lock_irqsave(&kbd_event_lock, flags);
2199	kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2200	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
2201	}
2202
2203	/**
2204	* vt_get_shift_state - shift bit state
2205	*
2206	* Report the shift bits from the keyboard state. We have to export
2207	* this to support some oddities in the vt layer.
2208	*/
2209	int vt_get_shift_state(void)
2210	{
2211	/* Don't lock as this is a transient report */
2212	return shift_state;
2213	}
2214
2215	/**
2216	* vt_reset_keyboard - reset keyboard state
2217	* @console: console to reset
2218	*
2219	* Reset the keyboard bits for a console as part of a general console
2220	* reset event
2221	*/
2222	void vt_reset_keyboard(unsigned int console)
2223	{
2224	struct kbd_struct *kb = &kbd_table[console];
2225	unsigned long flags;
2226
2227	spin_lock_irqsave(&kbd_event_lock, flags);
2228	set_vc_kbd_mode(kbd: kb, VC_REPEAT);
2229	clr_vc_kbd_mode(kbd: kb, VC_CKMODE);
2230	clr_vc_kbd_mode(kbd: kb, VC_APPLIC);
2231	clr_vc_kbd_mode(kbd: kb, VC_CRLF);
2232	kb->lockstate = 0;
2233	kb->slockstate = 0;
2234	spin_lock(lock: &led_lock);
2235	kb->ledmode = LED_SHOW_FLAGS;
2236	kb->ledflagstate = kb->default_ledflagstate;
2237	spin_unlock(lock: &led_lock);
2238	/* do not do set_leds here because this causes an endless tasklet loop
2239	when the keyboard hasn't been initialized yet */
2240	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
2241	}
2242
2243	/**
2244	* vt_get_kbd_mode_bit - read keyboard status bits
2245	* @console: console to read from
2246	* @bit: mode bit to read
2247	*
2248	* Report back a vt mode bit. We do this without locking so the
2249	* caller must be sure that there are no synchronization needs
2250	*/
2251
2252	int vt_get_kbd_mode_bit(unsigned int console, int bit)
2253	{
2254	struct kbd_struct *kb = &kbd_table[console];
2255	return vc_kbd_mode(kbd: kb, flag: bit);
2256	}
2257
2258	/**
2259	* vt_set_kbd_mode_bit - read keyboard status bits
2260	* @console: console to read from
2261	* @bit: mode bit to read
2262	*
2263	* Set a vt mode bit. We do this without locking so the
2264	* caller must be sure that there are no synchronization needs
2265	*/
2266
2267	void vt_set_kbd_mode_bit(unsigned int console, int bit)
2268	{
2269	struct kbd_struct *kb = &kbd_table[console];
2270	unsigned long flags;
2271
2272	spin_lock_irqsave(&kbd_event_lock, flags);
2273	set_vc_kbd_mode(kbd: kb, flag: bit);
2274	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
2275	}
2276
2277	/**
2278	* vt_clr_kbd_mode_bit - read keyboard status bits
2279	* @console: console to read from
2280	* @bit: mode bit to read
2281	*
2282	* Report back a vt mode bit. We do this without locking so the
2283	* caller must be sure that there are no synchronization needs
2284	*/
2285
2286	void vt_clr_kbd_mode_bit(unsigned int console, int bit)
2287	{
2288	struct kbd_struct *kb = &kbd_table[console];
2289	unsigned long flags;
2290
2291	spin_lock_irqsave(&kbd_event_lock, flags);
2292	clr_vc_kbd_mode(kbd: kb, flag: bit);
2293	spin_unlock_irqrestore(lock: &kbd_event_lock, flags);
2294	}
2295