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	del_timer_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
 379/* FIXME: review locking for vt.c callers */
 380static void set_leds(void)
 381{
 382	tasklet_schedule(&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
 392static 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 */
 414void 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(&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 */
 438static 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, d);
 459	else {
 460		int c = conv_uni_to_8bit(d);
 461		if (c != -1)
 462			put_queue(vc, c);
 463	}
 464
 465	return ch;
 466}
 467
 468/*
 469 * Special function handlers
 470 */
 471static void fn_enter(struct vc_data *vc)
 472{
 473	if (diacr) {
 474		if (kbd->kbdmode == VC_UNICODE)
 475			to_utf8(vc, diacr);
 476		else {
 477			int c = conv_uni_to_8bit(diacr);
 478			if (c != -1)
 479				put_queue(vc, c);
 480		}
 481		diacr = 0;
 482	}
 483
 484	put_queue(vc, '\r');
 485	if (vc_kbd_mode(kbd, VC_CRLF))
 486		put_queue(vc, '\n');
 487}
 488
 489static 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
 497static 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
 505static 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
 513static 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
 531static void fn_num(struct vc_data *vc)
 532{
 533	if (vc_kbd_mode(kbd, VC_APPLIC))
 534		applkey(vc, 'P', 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 */
 545static void fn_bare_num(struct vc_data *vc)
 546{
 547	if (!rep)
 548		chg_vc_kbd_led(kbd, VC_NUMLOCK);
 549}
 550
 551static void fn_lastcons(struct vc_data *vc)
 552{
 553	/* switch to the last used console, ChN */
 554	set_console(last_console);
 555}
 556
 557static 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(i))
 569			break;
 570	}
 571	set_console(i);
 572}
 573
 574static 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(i))
 586			break;
 587	}
 588	set_console(i);
 589}
 590
 591static void fn_send_intr(struct vc_data *vc)
 592{
 593	tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
 594	tty_flip_buffer_push(&vc->port);
 595}
 596
 597static void fn_scroll_forw(struct vc_data *vc)
 598{
 599	scrollfront(vc, 0);
 600}
 601
 602static void fn_scroll_back(struct vc_data *vc)
 603{
 604	scrollback(vc);
 605}
 606
 607static void fn_show_mem(struct vc_data *vc)
 608{
 609	show_mem();
 610}
 611
 612static void fn_show_state(struct vc_data *vc)
 613{
 614	show_state();
 615}
 616
 617static void fn_boot_it(struct vc_data *vc)
 618{
 619	ctrl_alt_del();
 620}
 621
 622static void fn_compose(struct vc_data *vc)
 623{
 624	dead_key_next = true;
 625}
 626
 627static void fn_spawn_con(struct vc_data *vc)
 628{
 629	spin_lock(&vt_spawn_con.lock);
 630	if (vt_spawn_con.pid)
 631		if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
 632			put_pid(vt_spawn_con.pid);
 633			vt_spawn_con.pid = NULL;
 634		}
 635	spin_unlock(&vt_spawn_con.lock);
 636}
 637
 638static void fn_SAK(struct vc_data *vc)
 639{
 640	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
 641	schedule_work(SAK_work);
 642}
 643
 644static void fn_null(struct vc_data *vc)
 645{
 646	do_compute_shiftstate();
 647}
 648
 649/*
 650 * Special key handlers
 651 */
 652static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
 653{
 654}
 655
 656static 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
 670static 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
 675static 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, 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, value);
 690	else {
 691		int c = conv_uni_to_8bit(value);
 692		if (c != -1)
 693			put_queue(vc, 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 */
 702static 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, value) : value);
 708}
 709
 710static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
 711{
 712	k_unicode(vc, conv_8bit_to_uni(value), up_flag);
 713}
 714
 715static 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 */
 723static 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, ret_diacr[value], up_flag);
 756}
 757
 758static 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
 766static 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, func_table[value]);
 777		spin_unlock_irqrestore(&func_buf_lock, flags);
 778
 779	} else
 780		pr_err("k_fn called with value=%d\n", value);
 781}
 782
 783static 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, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 791}
 792
 793static 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, app_map[value], 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), 0);
 813			return;
 814		case KVAL(K_P0):
 815			k_fn(vc, KVAL(K_INSERT), 0);
 816			return;
 817		case KVAL(K_P1):
 818			k_fn(vc, KVAL(K_SELECT), 0);
 819			return;
 820		case KVAL(K_P2):
 821			k_cur(vc, KVAL(K_DOWN), 0);
 822			return;
 823		case KVAL(K_P3):
 824			k_fn(vc, KVAL(K_PGDN), 0);
 825			return;
 826		case KVAL(K_P4):
 827			k_cur(vc, KVAL(K_LEFT), 0);
 828			return;
 829		case KVAL(K_P6):
 830			k_cur(vc, KVAL(K_RIGHT), 0);
 831			return;
 832		case KVAL(K_P7):
 833			k_fn(vc, KVAL(K_FIND), 0);
 834			return;
 835		case KVAL(K_P8):
 836			k_cur(vc, KVAL(K_UP), 0);
 837			return;
 838		case KVAL(K_P9):
 839			k_fn(vc, KVAL(K_PGUP), 0);
 840			return;
 841		case KVAL(K_P5):
 842			applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
 843			return;
 844		}
 845	}
 846
 847	put_queue(vc, pad_chars[value]);
 848	if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
 849		put_queue(vc, '\n');
 850}
 851
 852static 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, npadch_value);
 887		else
 888			put_queue(vc, npadch_value & 0xff);
 889		npadch_active = false;
 890	}
 891}
 892
 893static 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, '\033');
 900		put_queue(vc, value);
 901	} else
 902		put_queue(vc, value | BIT(7));
 903}
 904
 905static 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
 929static 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, value);
 935}
 936
 937static 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, 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, value);
 948	}
 949}
 950
 951/* by default, 300ms interval for combination release */
 952static unsigned brl_timeout = 300;
 953MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
 954module_param(brl_timeout, uint, 0644);
 955
 956static unsigned brl_nbchords = 1;
 957MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
 958module_param(brl_nbchords, uint, 0644);
 959
 960static 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
 978static 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, committing, 0);
1011			committing = 0;
1012		}
1013	} else {
1014		if (committing) {
1015			k_brlcommit(vc, committing, 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
1024struct kbd_led_trigger {
1025	struct led_trigger trigger;
1026	unsigned int mask;
1027};
1028
1029static 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(&keyboard_tasklet);
1035	if (ledstate != -1U)
1036		led_trigger_event(&trigger->trigger,
1037				  ledstate & trigger->mask ?
1038					LED_FULL : LED_OFF);
1039	tasklet_enable(&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
1055static 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
1071static 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,
1083					  new_state & trigger->mask ?
1084						LED_FULL : LED_OFF);
1085	}
1086}
1087
1088static 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(~led_state, led_state);
1094
1095	return 0;
1096}
1097
1098static 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(&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
1113static 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
1127static 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
1134static 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 */
1145static unsigned char getledstate(void)
1146{
1147	return ledstate & 0xff;
1148}
1149
1150void 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(&led_lock, flags);
1162}
1163
1164static 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 */
1181int 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(kb, flag);
1189	spin_unlock_irqrestore(&led_lock, flags);
1190
1191	return ret;
1192}
1193EXPORT_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 */
1203void vt_set_led_state(unsigned int console, int leds)
1204{
1205	struct kbd_struct *kb = &kbd_table[console];
1206	setledstate(kb, 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 */
1222void 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(kb, VC_SCROLLOCK);
1228	set_leds();
1229	spin_unlock_irqrestore(&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 */
1239void 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(kb, VC_SCROLLOCK);
1245	set_leds();
1246	spin_unlock_irqrestore(&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 */
1255static 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(&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(ledstate, 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
1281static 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
1290static 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
1308static int sparc_l1_a_state;
1309extern void sun_do_break(void);
1310#endif
1311
1312static 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, 0xe1);
1321		put_queue(vc, 0x1d | up_flag);
1322		put_queue(vc, 0x45 | up_flag);
1323		break;
1324
1325	case KEY_HANGEUL:
1326		if (!up_flag)
1327			put_queue(vc, 0xf2);
1328		break;
1329
1330	case KEY_HANJA:
1331		if (!up_flag)
1332			put_queue(vc, 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, 0x54 | up_flag);
1345		} else {
1346			put_queue(vc, 0xe0);
1347			put_queue(vc, 0x2a | up_flag);
1348			put_queue(vc, 0xe0);
1349			put_queue(vc, 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, 0xe0);
1363		put_queue(vc, (code & 0x7f) | up_flag);
1364
1365		break;
1366	}
1367
1368	return 0;
1369}
1370
1371#else
1372
1373static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1374{
1375	return false;
1376}
1377
1378static 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
1388static 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, data);
1395}
1396
1397static 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, !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, keycode | (!down << 7));
1450		} else {
1451			put_queue(vc, !down << 7);
1452			put_queue(vc, (keycode >> 7) | BIT(7));
1453			put_queue(vc, keycode | BIT(7));
1454		}
1455		raw_mode = true;
1456	}
1457
1458	assign_bit(keycode, key_down, 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(&keyboard_notifier_list,
1476					KBD_KEYCODE, &param);
1477	if (rc == NOTIFY_STOP || !key_map) {
1478		atomic_notifier_call_chain(&keyboard_notifier_list,
1479					   KBD_UNBOUND_KEYCODE, &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(&keyboard_notifier_list,
1497						KBD_UNICODE, &param);
1498		if (rc != NOTIFY_STOP)
1499			if (down && !raw_mode)
1500				k_unicode(vc, keysym, !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(&keyboard_notifier_list,
1517					KBD_KEYSYM, &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(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1528
1529	if (type != KT_SLOCK)
1530		kbd->slockstate = 0;
1531}
1532
1533static 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(&kbd_event_lock);
1538
1539	if (event_type == EV_MSC && event_code == MSC_RAW &&
1540			kbd_is_hw_raw(handle->dev))
1541		kbd_rawcode(value);
1542	if (event_type == EV_KEY && event_code <= KEY_MAX)
1543		kbd_keycode(event_code, value, kbd_is_hw_raw(handle->dev));
1544
1545	spin_unlock(&kbd_event_lock);
1546
1547	tasklet_schedule(&keyboard_tasklet);
1548	do_poke_blanked_console = 1;
1549	schedule_console_callback();
1550}
1551
1552static 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(dev->keybit, BTN_MISC, KEY_RESERVED) <
1559				BTN_MISC)
1560			return true;
1561		if (find_next_bit(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 */
1575static 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(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(handle);
1603	return error;
1604}
1605
1606static void kbd_disconnect(struct input_handle *handle)
1607{
1608	input_close_device(handle);
1609	input_unregister_handle(handle);
1610	kfree(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 */
1617static void kbd_start(struct input_handle *handle)
1618{
1619	tasklet_disable(&keyboard_tasklet);
1620
1621	if (ledstate != -1U)
1622		kbd_update_leds_helper(handle, &ledstate);
1623
1624	tasklet_enable(&keyboard_tasklet);
1625}
1626
1627static 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
1641MODULE_DEVICE_TABLE(input, kbd_ids);
1642
1643static 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
1653int __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(&keyboard_tasklet);
1675	tasklet_schedule(&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 */
1691int 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, 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						accent_table[i].diacr);
1717			dia[i].base = conv_uni_to_8bit(
1718						accent_table[i].base);
1719			dia[i].result = conv_uni_to_8bit(
1720						accent_table[i].result);
1721		}
1722		spin_unlock_irqrestore(&kbd_event_lock, flags);
1723
1724		if (put_user(asize, &a->kb_cnt))
1725			ret = -EFAULT;
1726		else  if (copy_to_user(a->kbdiacr, dia,
1727				asize * sizeof(struct kbdiacr)))
1728			ret = -EFAULT;
1729		kfree(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, 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(&kbd_event_lock, flags);
1750
1751		if (put_user(asize, &a->kb_cnt))
1752			ret = -EFAULT;
1753		else if (copy_to_user(a->kbdiacruc, buf,
1754				asize*sizeof(struct kbdiacruc)))
1755			ret = -EFAULT;
1756		kfree(buf);
1757		return ret;
1758	}
1759
1760	case KDSKBDIACR:
1761	{
1762		struct kbdiacrs __user *a = udp;
1763		struct kbdiacr *dia = NULL;
1764		unsigned int ct;
1765		int i;
1766
1767		if (!perm)
1768			return -EPERM;
1769		if (get_user(ct, &a->kb_cnt))
1770			return -EFAULT;
1771		if (ct >= MAX_DIACR)
1772			return -EINVAL;
1773
1774		if (ct) {
1775			dia = memdup_array_user(a->kbdiacr,
1776						ct, sizeof(struct kbdiacr));
 
1777			if (IS_ERR(dia))
1778				return PTR_ERR(dia);
 
1779		}
1780
1781		spin_lock_irqsave(&kbd_event_lock, flags);
1782		accent_table_size = ct;
1783		for (i = 0; i < ct; i++) {
1784			accent_table[i].diacr =
1785					conv_8bit_to_uni(dia[i].diacr);
1786			accent_table[i].base =
1787					conv_8bit_to_uni(dia[i].base);
1788			accent_table[i].result =
1789					conv_8bit_to_uni(dia[i].result);
1790		}
1791		spin_unlock_irqrestore(&kbd_event_lock, flags);
1792		kfree(dia);
1793		return 0;
1794	}
1795
1796	case KDSKBDIACRUC:
1797	{
1798		struct kbdiacrsuc __user *a = udp;
1799		unsigned int ct;
1800		void *buf = NULL;
1801
1802		if (!perm)
1803			return -EPERM;
1804
1805		if (get_user(ct, &a->kb_cnt))
1806			return -EFAULT;
1807
1808		if (ct >= MAX_DIACR)
1809			return -EINVAL;
1810
1811		if (ct) {
1812			buf = memdup_array_user(a->kbdiacruc,
1813						ct, sizeof(struct kbdiacruc));
1814			if (IS_ERR(buf))
1815				return PTR_ERR(buf);
 
 
 
 
 
 
1816		} 
1817		spin_lock_irqsave(&kbd_event_lock, flags);
1818		if (ct)
1819			memcpy(accent_table, buf,
1820					ct * sizeof(struct kbdiacruc));
1821		accent_table_size = ct;
1822		spin_unlock_irqrestore(&kbd_event_lock, flags);
1823		kfree(buf);
1824		return 0;
1825	}
1826	}
1827	return ret;
1828}
1829
1830/**
1831 *	vt_do_kdskbmode		-	set keyboard mode ioctl
1832 *	@console: the console to use
1833 *	@arg: the requested mode
1834 *
1835 *	Update the keyboard mode bits while holding the correct locks.
1836 *	Return 0 for success or an error code.
1837 */
1838int vt_do_kdskbmode(unsigned int console, unsigned int arg)
1839{
1840	struct kbd_struct *kb = &kbd_table[console];
1841	int ret = 0;
1842	unsigned long flags;
1843
1844	spin_lock_irqsave(&kbd_event_lock, flags);
1845	switch(arg) {
1846	case K_RAW:
1847		kb->kbdmode = VC_RAW;
1848		break;
1849	case K_MEDIUMRAW:
1850		kb->kbdmode = VC_MEDIUMRAW;
1851		break;
1852	case K_XLATE:
1853		kb->kbdmode = VC_XLATE;
1854		do_compute_shiftstate();
1855		break;
1856	case K_UNICODE:
1857		kb->kbdmode = VC_UNICODE;
1858		do_compute_shiftstate();
1859		break;
1860	case K_OFF:
1861		kb->kbdmode = VC_OFF;
1862		break;
1863	default:
1864		ret = -EINVAL;
1865	}
1866	spin_unlock_irqrestore(&kbd_event_lock, flags);
1867	return ret;
1868}
1869
1870/**
1871 *	vt_do_kdskbmeta		-	set keyboard meta state
1872 *	@console: the console to use
1873 *	@arg: the requested meta state
1874 *
1875 *	Update the keyboard meta bits while holding the correct locks.
1876 *	Return 0 for success or an error code.
1877 */
1878int vt_do_kdskbmeta(unsigned int console, unsigned int arg)
1879{
1880	struct kbd_struct *kb = &kbd_table[console];
1881	int ret = 0;
1882	unsigned long flags;
1883
1884	spin_lock_irqsave(&kbd_event_lock, flags);
1885	switch(arg) {
1886	case K_METABIT:
1887		clr_vc_kbd_mode(kb, VC_META);
1888		break;
1889	case K_ESCPREFIX:
1890		set_vc_kbd_mode(kb, VC_META);
1891		break;
1892	default:
1893		ret = -EINVAL;
1894	}
1895	spin_unlock_irqrestore(&kbd_event_lock, flags);
1896	return ret;
1897}
1898
1899int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1900								int perm)
1901{
1902	struct kbkeycode tmp;
1903	int kc = 0;
1904
1905	if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1906		return -EFAULT;
1907	switch (cmd) {
1908	case KDGETKEYCODE:
1909		kc = getkeycode(tmp.scancode);
1910		if (kc >= 0)
1911			kc = put_user(kc, &user_kbkc->keycode);
1912		break;
1913	case KDSETKEYCODE:
1914		if (!perm)
1915			return -EPERM;
1916		kc = setkeycode(tmp.scancode, tmp.keycode);
1917		break;
1918	}
1919	return kc;
1920}
1921
1922static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx,
1923		unsigned char map)
 
 
 
 
1924{
1925	unsigned short *key_map, val;
 
 
1926	unsigned long flags;
1927
1928	/* Ensure another thread doesn't free it under us */
1929	spin_lock_irqsave(&kbd_event_lock, flags);
1930	key_map = key_maps[map];
1931	if (key_map) {
1932		val = U(key_map[idx]);
1933		if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1934			val = K_HOLE;
1935	} else
1936		val = idx ? K_HOLE : K_NOSUCHMAP;
1937	spin_unlock_irqrestore(&kbd_event_lock, flags);
1938
1939	return val;
1940}
1941
1942static int vt_kdskbent(unsigned char kbdmode, unsigned char idx,
1943		unsigned char map, unsigned short val)
1944{
1945	unsigned long flags;
1946	unsigned short *key_map, *new_map, oldval;
1947
1948	if (!idx && val == K_NOSUCHMAP) {
 
 
1949		spin_lock_irqsave(&kbd_event_lock, flags);
1950		/* deallocate map */
1951		key_map = key_maps[map];
1952		if (map && key_map) {
1953			key_maps[map] = NULL;
1954			if (key_map[0] == U(K_ALLOCATED)) {
1955				kfree(key_map);
1956				keymap_count--;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1957			}
 
 
1958		}
1959		spin_unlock_irqrestore(&kbd_event_lock, flags);
1960
1961		return 0;
1962	}
1963
1964	if (KTYP(val) < NR_TYPES) {
1965		if (KVAL(val) > max_vals[KTYP(val)])
1966			return -EINVAL;
1967	} else if (kbdmode != VC_UNICODE)
1968		return -EINVAL;
 
1969
1970	/* ++Geert: non-PC keyboards may generate keycode zero */
1971#if !defined(__mc68000__) && !defined(__powerpc__)
1972	/* assignment to entry 0 only tests validity of args */
1973	if (!idx)
1974		return 0;
1975#endif
1976
1977	new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1978	if (!new_map)
1979		return -ENOMEM;
1980
1981	spin_lock_irqsave(&kbd_event_lock, flags);
1982	key_map = key_maps[map];
1983	if (key_map == NULL) {
1984		int j;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1985
1986		if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1987		    !capable(CAP_SYS_RESOURCE)) {
 
 
 
 
 
1988			spin_unlock_irqrestore(&kbd_event_lock, flags);
1989			kfree(new_map);
1990			return -EPERM;
1991		}
1992		key_maps[map] = new_map;
1993		key_map = new_map;
1994		key_map[0] = U(K_ALLOCATED);
1995		for (j = 1; j < NR_KEYS; j++)
1996			key_map[j] = U(K_HOLE);
1997		keymap_count++;
1998	} else
1999		kfree(new_map);
2000
2001	oldval = U(key_map[idx]);
2002	if (val == oldval)
2003		goto out;
2004
2005	/* Attention Key */
2006	if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) {
2007		spin_unlock_irqrestore(&kbd_event_lock, flags);
2008		return -EPERM;
2009	}
2010
2011	key_map[idx] = U(val);
2012	if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT))
2013		do_compute_shiftstate();
2014out:
2015	spin_unlock_irqrestore(&kbd_event_lock, flags);
2016
2017	return 0;
2018}
2019
2020int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
2021						unsigned int console)
2022{
2023	struct kbd_struct *kb = &kbd_table[console];
2024	struct kbentry kbe;
2025
2026	if (copy_from_user(&kbe, user_kbe, sizeof(struct kbentry)))
2027		return -EFAULT;
2028
2029	switch (cmd) {
2030	case KDGKBENT:
2031		return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index,
2032					kbe.kb_table),
2033				&user_kbe->kb_value);
2034	case KDSKBENT:
2035		if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2036			return -EPERM;
2037		return vt_kdskbent(kb->kbdmode, kbe.kb_index, kbe.kb_table,
2038				kbe.kb_value);
2039	}
2040	return 0;
2041}
 
 
 
2042
2043static char *vt_kdskbsent(char *kbs, unsigned char cur)
2044{
2045	static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC);
2046	char *cur_f = func_table[cur];
2047
2048	if (cur_f && strlen(cur_f) >= strlen(kbs)) {
2049		strcpy(cur_f, kbs);
2050		return kbs;
2051	}
2052
2053	func_table[cur] = kbs;
2054
2055	return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL;
2056}
2057
2058int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2059{
2060	unsigned char kb_func;
2061	unsigned long flags;
2062	char *kbs;
 
 
 
 
 
2063	int ret;
2064
2065	if (get_user(kb_func, &user_kdgkb->kb_func))
2066		return -EFAULT;
2067
2068	kb_func = array_index_nospec(kb_func, MAX_NR_FUNC);
 
 
 
 
 
 
 
 
 
 
 
 
2069
2070	switch (cmd) {
2071	case KDGKBSENT: {
2072		/* size should have been a struct member */
2073		ssize_t len = sizeof(user_kdgkb->kb_string);
2074
2075		kbs = kmalloc(len, GFP_KERNEL);
2076		if (!kbs)
2077			return -ENOMEM;
2078
2079		spin_lock_irqsave(&func_buf_lock, flags);
2080		len = strscpy(kbs, func_table[kb_func] ? : "", len);
2081		spin_unlock_irqrestore(&func_buf_lock, flags);
2082
2083		if (len < 0) {
2084			ret = -ENOSPC;
2085			break;
2086		}
2087		ret = copy_to_user(user_kdgkb->kb_string, kbs, len + 1) ?
2088			-EFAULT : 0;
2089		break;
2090	}
2091	case KDSKBSENT:
2092		if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2093			return -EPERM;
 
 
2094
2095		kbs = strndup_user(user_kdgkb->kb_string,
2096				sizeof(user_kdgkb->kb_string));
2097		if (IS_ERR(kbs))
2098			return PTR_ERR(kbs);
2099
2100		spin_lock_irqsave(&func_buf_lock, flags);
2101		kbs = vt_kdskbsent(kbs, kb_func);
2102		spin_unlock_irqrestore(&func_buf_lock, flags);
2103
2104		ret = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2105		break;
2106	}
2107
 
2108	kfree(kbs);
2109
2110	return ret;
2111}
2112
2113int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm)
2114{
2115	struct kbd_struct *kb = &kbd_table[console];
2116        unsigned long flags;
2117	unsigned char ucval;
2118
2119        switch(cmd) {
2120	/* the ioctls below read/set the flags usually shown in the leds */
2121	/* don't use them - they will go away without warning */
2122	case KDGKBLED:
2123                spin_lock_irqsave(&kbd_event_lock, flags);
2124		ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2125                spin_unlock_irqrestore(&kbd_event_lock, flags);
2126		return put_user(ucval, (char __user *)arg);
2127
2128	case KDSKBLED:
2129		if (!perm)
2130			return -EPERM;
2131		if (arg & ~0x77)
2132			return -EINVAL;
2133                spin_lock_irqsave(&led_lock, flags);
2134		kb->ledflagstate = (arg & 7);
2135		kb->default_ledflagstate = ((arg >> 4) & 7);
2136		set_leds();
2137                spin_unlock_irqrestore(&led_lock, flags);
2138		return 0;
2139
2140	/* the ioctls below only set the lights, not the functions */
2141	/* for those, see KDGKBLED and KDSKBLED above */
2142	case KDGETLED:
2143		ucval = getledstate();
2144		return put_user(ucval, (char __user *)arg);
2145
2146	case KDSETLED:
2147		if (!perm)
2148			return -EPERM;
2149		setledstate(kb, arg);
2150		return 0;
2151        }
2152        return -ENOIOCTLCMD;
2153}
2154
2155int vt_do_kdgkbmode(unsigned int console)
2156{
2157	struct kbd_struct *kb = &kbd_table[console];
2158	/* This is a spot read so needs no locking */
2159	switch (kb->kbdmode) {
2160	case VC_RAW:
2161		return K_RAW;
2162	case VC_MEDIUMRAW:
2163		return K_MEDIUMRAW;
2164	case VC_UNICODE:
2165		return K_UNICODE;
2166	case VC_OFF:
2167		return K_OFF;
2168	default:
2169		return K_XLATE;
2170	}
2171}
2172
2173/**
2174 *	vt_do_kdgkbmeta		-	report meta status
2175 *	@console: console to report
2176 *
2177 *	Report the meta flag status of this console
2178 */
2179int vt_do_kdgkbmeta(unsigned int console)
2180{
2181	struct kbd_struct *kb = &kbd_table[console];
2182        /* Again a spot read so no locking */
2183	return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2184}
2185
2186/**
2187 *	vt_reset_unicode	-	reset the unicode status
2188 *	@console: console being reset
2189 *
2190 *	Restore the unicode console state to its default
2191 */
2192void vt_reset_unicode(unsigned int console)
2193{
2194	unsigned long flags;
2195
2196	spin_lock_irqsave(&kbd_event_lock, flags);
2197	kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2198	spin_unlock_irqrestore(&kbd_event_lock, flags);
2199}
2200
2201/**
2202 *	vt_get_shift_state	-	shift bit state
2203 *
2204 *	Report the shift bits from the keyboard state. We have to export
2205 *	this to support some oddities in the vt layer.
2206 */
2207int vt_get_shift_state(void)
2208{
2209        /* Don't lock as this is a transient report */
2210        return shift_state;
2211}
2212
2213/**
2214 *	vt_reset_keyboard	-	reset keyboard state
2215 *	@console: console to reset
2216 *
2217 *	Reset the keyboard bits for a console as part of a general console
2218 *	reset event
2219 */
2220void vt_reset_keyboard(unsigned int console)
2221{
2222	struct kbd_struct *kb = &kbd_table[console];
2223	unsigned long flags;
2224
2225	spin_lock_irqsave(&kbd_event_lock, flags);
2226	set_vc_kbd_mode(kb, VC_REPEAT);
2227	clr_vc_kbd_mode(kb, VC_CKMODE);
2228	clr_vc_kbd_mode(kb, VC_APPLIC);
2229	clr_vc_kbd_mode(kb, VC_CRLF);
2230	kb->lockstate = 0;
2231	kb->slockstate = 0;
2232	spin_lock(&led_lock);
2233	kb->ledmode = LED_SHOW_FLAGS;
2234	kb->ledflagstate = kb->default_ledflagstate;
2235	spin_unlock(&led_lock);
2236	/* do not do set_leds here because this causes an endless tasklet loop
2237	   when the keyboard hasn't been initialized yet */
2238	spin_unlock_irqrestore(&kbd_event_lock, flags);
2239}
2240
2241/**
2242 *	vt_get_kbd_mode_bit	-	read keyboard status bits
2243 *	@console: console to read from
2244 *	@bit: mode bit to read
2245 *
2246 *	Report back a vt mode bit. We do this without locking so the
2247 *	caller must be sure that there are no synchronization needs
2248 */
2249
2250int vt_get_kbd_mode_bit(unsigned int console, int bit)
2251{
2252	struct kbd_struct *kb = &kbd_table[console];
2253	return vc_kbd_mode(kb, bit);
2254}
2255
2256/**
2257 *	vt_set_kbd_mode_bit	-	read keyboard status bits
2258 *	@console: console to read from
2259 *	@bit: mode bit to read
2260 *
2261 *	Set a vt mode bit. We do this without locking so the
2262 *	caller must be sure that there are no synchronization needs
2263 */
2264
2265void vt_set_kbd_mode_bit(unsigned int console, int bit)
2266{
2267	struct kbd_struct *kb = &kbd_table[console];
2268	unsigned long flags;
2269
2270	spin_lock_irqsave(&kbd_event_lock, flags);
2271	set_vc_kbd_mode(kb, bit);
2272	spin_unlock_irqrestore(&kbd_event_lock, flags);
2273}
2274
2275/**
2276 *	vt_clr_kbd_mode_bit	-	read keyboard status bits
2277 *	@console: console to read from
2278 *	@bit: mode bit to read
2279 *
2280 *	Report back a vt mode bit. We do this without locking so the
2281 *	caller must be sure that there are no synchronization needs
2282 */
2283
2284void vt_clr_kbd_mode_bit(unsigned int console, int bit)
2285{
2286	struct kbd_struct *kb = &kbd_table[console];
2287	unsigned long flags;
2288
2289	spin_lock_irqsave(&kbd_event_lock, flags);
2290	clr_vc_kbd_mode(kb, bit);
2291	spin_unlock_irqrestore(&kbd_event_lock, flags);
2292}