keyboard.c

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