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_set_brightness(cdev, ledstate & trigger->mask ? LED_FULL : LED_OFF);
1037	tasklet_enable(&keyboard_tasklet);
1038
1039	return 0;
1040}
1041
1042#define KBD_LED_TRIGGER(_led_bit, _name) {			\
1043		.trigger = {					\
1044			.name = _name,				\
1045			.activate = kbd_led_trigger_activate,	\
1046		},						\
1047		.mask	= BIT(_led_bit),			\
1048	}
1049
1050#define KBD_LOCKSTATE_TRIGGER(_led_bit, _name)		\
1051	KBD_LED_TRIGGER((_led_bit) + 8, _name)
1052
1053static struct kbd_led_trigger kbd_led_triggers[] = {
1054	KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
1055	KBD_LED_TRIGGER(VC_NUMLOCK,   "kbd-numlock"),
1056	KBD_LED_TRIGGER(VC_CAPSLOCK,  "kbd-capslock"),
1057	KBD_LED_TRIGGER(VC_KANALOCK,  "kbd-kanalock"),
1058
1059	KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK,  "kbd-shiftlock"),
1060	KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK,  "kbd-altgrlock"),
1061	KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK,   "kbd-ctrllock"),
1062	KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK,    "kbd-altlock"),
1063	KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1064	KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1065	KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK,  "kbd-ctrlllock"),
1066	KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK,  "kbd-ctrlrlock"),
1067};
1068
1069static void kbd_propagate_led_state(unsigned int old_state,
1070				    unsigned int new_state)
1071{
1072	struct kbd_led_trigger *trigger;
1073	unsigned int changed = old_state ^ new_state;
1074	int i;
1075
1076	for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1077		trigger = &kbd_led_triggers[i];
1078
1079		if (changed & trigger->mask)
1080			led_trigger_event(&trigger->trigger,
1081					  new_state & trigger->mask ?
1082						LED_FULL : LED_OFF);
1083	}
1084}
1085
1086static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1087{
1088	unsigned int led_state = *(unsigned int *)data;
1089
1090	if (test_bit(EV_LED, handle->dev->evbit))
1091		kbd_propagate_led_state(~led_state, led_state);
1092
1093	return 0;
1094}
1095
1096static void kbd_init_leds(void)
1097{
1098	int error;
1099	int i;
1100
1101	for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1102		error = led_trigger_register(&kbd_led_triggers[i].trigger);
1103		if (error)
1104			pr_err("error %d while registering trigger %s\n",
1105			       error, kbd_led_triggers[i].trigger.name);
1106	}
1107}
1108
1109#else
1110
1111static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1112{
1113	unsigned int leds = *(unsigned int *)data;
1114
1115	if (test_bit(EV_LED, handle->dev->evbit)) {
1116		input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & BIT(0)));
1117		input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & BIT(1)));
1118		input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & BIT(2)));
1119		input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1120	}
1121
1122	return 0;
1123}
1124
1125static void kbd_propagate_led_state(unsigned int old_state,
1126				    unsigned int new_state)
1127{
1128	input_handler_for_each_handle(&kbd_handler, &new_state,
1129				      kbd_update_leds_helper);
1130}
1131
1132static void kbd_init_leds(void)
1133{
1134}
1135
1136#endif
1137
1138/*
1139 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1140 * or (ii) whatever pattern of lights people want to show using KDSETLED,
1141 * or (iii) specified bits of specified words in kernel memory.
1142 */
1143static unsigned char getledstate(void)
1144{
1145	return ledstate & 0xff;
1146}
1147
1148void setledstate(struct kbd_struct *kb, unsigned int led)
1149{
1150        unsigned long flags;
1151        spin_lock_irqsave(&led_lock, flags);
1152	if (!(led & ~7)) {
1153		ledioctl = led;
1154		kb->ledmode = LED_SHOW_IOCTL;
1155	} else
1156		kb->ledmode = LED_SHOW_FLAGS;
1157
1158	set_leds();
1159	spin_unlock_irqrestore(&led_lock, flags);
1160}
1161
1162static inline unsigned char getleds(void)
1163{
1164	struct kbd_struct *kb = kbd_table + fg_console;
 
 
1165
1166	if (kb->ledmode == LED_SHOW_IOCTL)
1167		return ledioctl;
1168
1169	return kb->ledflagstate;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1170}
1171
1172/**
1173 *	vt_get_leds	-	helper for braille console
1174 *	@console: console to read
1175 *	@flag: flag we want to check
1176 *
1177 *	Check the status of a keyboard led flag and report it back
1178 */
1179int vt_get_leds(unsigned int console, int flag)
1180{
1181	struct kbd_struct *kb = &kbd_table[console];
1182	int ret;
1183	unsigned long flags;
1184
1185	spin_lock_irqsave(&led_lock, flags);
1186	ret = vc_kbd_led(kb, flag);
1187	spin_unlock_irqrestore(&led_lock, flags);
1188
1189	return ret;
1190}
1191EXPORT_SYMBOL_GPL(vt_get_leds);
1192
1193/**
1194 *	vt_set_led_state	-	set LED state of a console
1195 *	@console: console to set
1196 *	@leds: LED bits
1197 *
1198 *	Set the LEDs on a console. This is a wrapper for the VT layer
1199 *	so that we can keep kbd knowledge internal
1200 */
1201void vt_set_led_state(unsigned int console, int leds)
1202{
1203	struct kbd_struct *kb = &kbd_table[console];
1204	setledstate(kb, leds);
1205}
1206
1207/**
1208 *	vt_kbd_con_start	-	Keyboard side of console start
1209 *	@console: console
1210 *
1211 *	Handle console start. This is a wrapper for the VT layer
1212 *	so that we can keep kbd knowledge internal
1213 *
1214 *	FIXME: We eventually need to hold the kbd lock here to protect
1215 *	the LED updating. We can't do it yet because fn_hold calls stop_tty
1216 *	and start_tty under the kbd_event_lock, while normal tty paths
1217 *	don't hold the lock. We probably need to split out an LED lock
1218 *	but not during an -rc release!
1219 */
1220void vt_kbd_con_start(unsigned int console)
1221{
1222	struct kbd_struct *kb = &kbd_table[console];
1223	unsigned long flags;
1224	spin_lock_irqsave(&led_lock, flags);
1225	clr_vc_kbd_led(kb, VC_SCROLLOCK);
1226	set_leds();
1227	spin_unlock_irqrestore(&led_lock, flags);
1228}
1229
1230/**
1231 *	vt_kbd_con_stop		-	Keyboard side of console stop
1232 *	@console: console
1233 *
1234 *	Handle console stop. This is a wrapper for the VT layer
1235 *	so that we can keep kbd knowledge internal
 
 
 
 
 
 
1236 */
1237void vt_kbd_con_stop(unsigned int console)
1238{
1239	struct kbd_struct *kb = &kbd_table[console];
1240	unsigned long flags;
1241	spin_lock_irqsave(&led_lock, flags);
1242	set_vc_kbd_led(kb, VC_SCROLLOCK);
1243	set_leds();
1244	spin_unlock_irqrestore(&led_lock, flags);
1245}
1246
1247/*
1248 * This is the tasklet that updates LED state of LEDs using standard
1249 * keyboard triggers. The reason we use tasklet is that we need to
1250 * handle the scenario when keyboard handler is not registered yet
1251 * but we already getting updates from the VT to update led state.
 
1252 */
1253static void kbd_bh(struct tasklet_struct *unused)
1254{
1255	unsigned int leds;
1256	unsigned long flags;
1257
1258	spin_lock_irqsave(&led_lock, flags);
1259	leds = getleds();
1260	leds |= (unsigned int)kbd->lockstate << 8;
1261	spin_unlock_irqrestore(&led_lock, flags);
1262
1263	if (vt_switch) {
1264		ledstate = ~leds;
1265		vt_switch = false;
1266	}
1267
1268	if (leds != ledstate) {
1269		kbd_propagate_led_state(ledstate, leds);
 
1270		ledstate = leds;
1271	}
1272}
1273
1274#if defined(CONFIG_X86) || defined(CONFIG_ALPHA) ||\
 
 
1275    defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1276    defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1277    (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1278
1279static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1280{
1281	if (!test_bit(EV_MSC, dev->evbit) || !test_bit(MSC_RAW, dev->mscbit))
1282		return false;
1283
1284	return dev->id.bustype == BUS_I8042 &&
1285		dev->id.vendor == 0x0001 && dev->id.product == 0x0001;
1286}
1287
1288static const unsigned short x86_keycodes[256] =
1289	{ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1290	 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1291	 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1292	 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1293	 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1294	 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1295	284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1296	367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1297	360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1298	103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1299	291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1300	264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1301	377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1302	308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1303	332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1304
1305#ifdef CONFIG_SPARC
1306static int sparc_l1_a_state;
1307extern void sun_do_break(void);
1308#endif
1309
1310static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1311		       unsigned char up_flag)
1312{
1313	int code;
1314
1315	switch (keycode) {
1316
1317	case KEY_PAUSE:
1318		put_queue(vc, 0xe1);
1319		put_queue(vc, 0x1d | up_flag);
1320		put_queue(vc, 0x45 | up_flag);
1321		break;
1322
1323	case KEY_HANGEUL:
1324		if (!up_flag)
1325			put_queue(vc, 0xf2);
1326		break;
1327
1328	case KEY_HANJA:
1329		if (!up_flag)
1330			put_queue(vc, 0xf1);
1331		break;
1332
1333	case KEY_SYSRQ:
1334		/*
1335		 * Real AT keyboards (that's what we're trying
1336		 * to emulate here) emit 0xe0 0x2a 0xe0 0x37 when
1337		 * pressing PrtSc/SysRq alone, but simply 0x54
1338		 * when pressing Alt+PrtSc/SysRq.
1339		 */
1340		if (test_bit(KEY_LEFTALT, key_down) ||
1341		    test_bit(KEY_RIGHTALT, key_down)) {
1342			put_queue(vc, 0x54 | up_flag);
1343		} else {
1344			put_queue(vc, 0xe0);
1345			put_queue(vc, 0x2a | up_flag);
1346			put_queue(vc, 0xe0);
1347			put_queue(vc, 0x37 | up_flag);
1348		}
1349		break;
1350
1351	default:
1352		if (keycode > 255)
1353			return -1;
1354
1355		code = x86_keycodes[keycode];
1356		if (!code)
1357			return -1;
1358
1359		if (code & 0x100)
1360			put_queue(vc, 0xe0);
1361		put_queue(vc, (code & 0x7f) | up_flag);
1362
1363		break;
1364	}
1365
1366	return 0;
1367}
1368
1369#else
1370
1371static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1372{
1373	return false;
1374}
1375
1376static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1377{
1378	if (keycode > 127)
1379		return -1;
1380
1381	put_queue(vc, keycode | up_flag);
1382	return 0;
1383}
1384#endif
1385
1386static void kbd_rawcode(unsigned char data)
1387{
1388	struct vc_data *vc = vc_cons[fg_console].d;
1389
1390	kbd = &kbd_table[vc->vc_num];
1391	if (kbd->kbdmode == VC_RAW)
1392		put_queue(vc, data);
1393}
1394
1395static void kbd_keycode(unsigned int keycode, int down, bool hw_raw)
1396{
1397	struct vc_data *vc = vc_cons[fg_console].d;
1398	unsigned short keysym, *key_map;
1399	unsigned char type;
1400	bool raw_mode;
1401	struct tty_struct *tty;
1402	int shift_final;
1403	struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1404	int rc;
1405
1406	tty = vc->port.tty;
1407
1408	if (tty && (!tty->driver_data)) {
1409		/* No driver data? Strange. Okay we fix it then. */
1410		tty->driver_data = vc;
1411	}
1412
1413	kbd = &kbd_table[vc->vc_num];
1414
1415#ifdef CONFIG_SPARC
1416	if (keycode == KEY_STOP)
1417		sparc_l1_a_state = down;
1418#endif
1419
1420	rep = (down == 2);
1421
1422	raw_mode = (kbd->kbdmode == VC_RAW);
1423	if (raw_mode && !hw_raw)
1424		if (emulate_raw(vc, keycode, !down << 7))
1425			if (keycode < BTN_MISC && printk_ratelimit())
1426				pr_warn("can't emulate rawmode for keycode %d\n",
1427					keycode);
1428
1429#ifdef CONFIG_SPARC
1430	if (keycode == KEY_A && sparc_l1_a_state) {
1431		sparc_l1_a_state = false;
1432		sun_do_break();
1433	}
1434#endif
1435
1436	if (kbd->kbdmode == VC_MEDIUMRAW) {
1437		/*
1438		 * This is extended medium raw mode, with keys above 127
1439		 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1440		 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1441		 * interfere with anything else. The two bytes after 0 will
1442		 * always have the up flag set not to interfere with older
1443		 * applications. This allows for 16384 different keycodes,
1444		 * which should be enough.
1445		 */
1446		if (keycode < 128) {
1447			put_queue(vc, keycode | (!down << 7));
1448		} else {
1449			put_queue(vc, !down << 7);
1450			put_queue(vc, (keycode >> 7) | BIT(7));
1451			put_queue(vc, keycode | BIT(7));
1452		}
1453		raw_mode = true;
1454	}
1455
1456	assign_bit(keycode, key_down, down);
 
 
 
1457
1458	if (rep &&
1459	    (!vc_kbd_mode(kbd, VC_REPEAT) ||
1460	     (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1461		/*
1462		 * Don't repeat a key if the input buffers are not empty and the
1463		 * characters get aren't echoed locally. This makes key repeat
1464		 * usable with slow applications and under heavy loads.
1465		 */
1466		return;
1467	}
1468
1469	param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1470	param.ledstate = kbd->ledflagstate;
1471	key_map = key_maps[shift_final];
1472
1473	rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1474					KBD_KEYCODE, &param);
1475	if (rc == NOTIFY_STOP || !key_map) {
1476		atomic_notifier_call_chain(&keyboard_notifier_list,
1477					   KBD_UNBOUND_KEYCODE, &param);
1478		do_compute_shiftstate();
1479		kbd->slockstate = 0;
1480		return;
1481	}
1482
1483	if (keycode < NR_KEYS)
1484		keysym = key_map[keycode];
1485	else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1486		keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1487	else
1488		return;
1489
1490	type = KTYP(keysym);
1491
1492	if (type < 0xf0) {
1493		param.value = keysym;
1494		rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1495						KBD_UNICODE, &param);
1496		if (rc != NOTIFY_STOP)
1497			if (down && !raw_mode)
1498				k_unicode(vc, keysym, !down);
1499		return;
1500	}
1501
1502	type -= 0xf0;
1503
1504	if (type == KT_LETTER) {
1505		type = KT_LATIN;
1506		if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1507			key_map = key_maps[shift_final ^ BIT(KG_SHIFT)];
1508			if (key_map)
1509				keysym = key_map[keycode];
1510		}
1511	}
1512
1513	param.value = keysym;
1514	rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1515					KBD_KEYSYM, &param);
1516	if (rc == NOTIFY_STOP)
1517		return;
1518
1519	if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1520		return;
1521
1522	(*k_handler[type])(vc, keysym & 0xff, !down);
1523
1524	param.ledstate = kbd->ledflagstate;
1525	atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1526
1527	if (type != KT_SLOCK)
1528		kbd->slockstate = 0;
1529}
1530
1531static void kbd_event(struct input_handle *handle, unsigned int event_type,
1532		      unsigned int event_code, int value)
1533{
1534	/* We are called with interrupts disabled, just take the lock */
1535	spin_lock(&kbd_event_lock);
1536
1537	if (event_type == EV_MSC && event_code == MSC_RAW &&
1538			kbd_is_hw_raw(handle->dev))
1539		kbd_rawcode(value);
1540	if (event_type == EV_KEY && event_code <= KEY_MAX)
1541		kbd_keycode(event_code, value, kbd_is_hw_raw(handle->dev));
1542
1543	spin_unlock(&kbd_event_lock);
1544
1545	tasklet_schedule(&keyboard_tasklet);
1546	do_poke_blanked_console = 1;
1547	schedule_console_callback();
1548}
1549
1550static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1551{
 
 
1552	if (test_bit(EV_SND, dev->evbit))
1553		return true;
1554
1555	if (test_bit(EV_KEY, dev->evbit)) {
1556		if (find_next_bit(dev->keybit, BTN_MISC, KEY_RESERVED) <
1557				BTN_MISC)
1558			return true;
1559		if (find_next_bit(dev->keybit, KEY_BRL_DOT10 + 1,
1560					KEY_BRL_DOT1) <= KEY_BRL_DOT10)
1561			return true;
1562	}
1563
1564	return false;
1565}
1566
1567/*
1568 * When a keyboard (or other input device) is found, the kbd_connect
1569 * function is called. The function then looks at the device, and if it
1570 * likes it, it can open it and get events from it. In this (kbd_connect)
1571 * function, we should decide which VT to bind that keyboard to initially.
1572 */
1573static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1574			const struct input_device_id *id)
1575{
1576	struct input_handle *handle;
1577	int error;
1578
1579	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1580	if (!handle)
1581		return -ENOMEM;
1582
1583	handle->dev = dev;
1584	handle->handler = handler;
1585	handle->name = "kbd";
1586
1587	error = input_register_handle(handle);
1588	if (error)
1589		goto err_free_handle;
1590
1591	error = input_open_device(handle);
1592	if (error)
1593		goto err_unregister_handle;
1594
1595	return 0;
1596
1597 err_unregister_handle:
1598	input_unregister_handle(handle);
1599 err_free_handle:
1600	kfree(handle);
1601	return error;
1602}
1603
1604static void kbd_disconnect(struct input_handle *handle)
1605{
1606	input_close_device(handle);
1607	input_unregister_handle(handle);
1608	kfree(handle);
1609}
1610
1611/*
1612 * Start keyboard handler on the new keyboard by refreshing LED state to
1613 * match the rest of the system.
1614 */
1615static void kbd_start(struct input_handle *handle)
1616{
1617	tasklet_disable(&keyboard_tasklet);
1618
1619	if (ledstate != -1U)
1620		kbd_update_leds_helper(handle, &ledstate);
1621
1622	tasklet_enable(&keyboard_tasklet);
1623}
1624
1625static const struct input_device_id kbd_ids[] = {
1626	{
1627		.flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1628		.evbit = { BIT_MASK(EV_KEY) },
1629	},
1630
1631	{
1632		.flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1633		.evbit = { BIT_MASK(EV_SND) },
1634	},
1635
1636	{ },    /* Terminating entry */
1637};
1638
1639MODULE_DEVICE_TABLE(input, kbd_ids);
1640
1641static struct input_handler kbd_handler = {
1642	.event		= kbd_event,
1643	.match		= kbd_match,
1644	.connect	= kbd_connect,
1645	.disconnect	= kbd_disconnect,
1646	.start		= kbd_start,
1647	.name		= "kbd",
1648	.id_table	= kbd_ids,
1649};
1650
1651int __init kbd_init(void)
1652{
1653	int i;
1654	int error;
1655
1656	for (i = 0; i < MAX_NR_CONSOLES; i++) {
1657		kbd_table[i].ledflagstate = kbd_defleds();
1658		kbd_table[i].default_ledflagstate = kbd_defleds();
1659		kbd_table[i].ledmode = LED_SHOW_FLAGS;
1660		kbd_table[i].lockstate = KBD_DEFLOCK;
1661		kbd_table[i].slockstate = 0;
1662		kbd_table[i].modeflags = KBD_DEFMODE;
1663		kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1664	}
1665
1666	kbd_init_leds();
1667
1668	error = input_register_handler(&kbd_handler);
1669	if (error)
1670		return error;
1671
1672	tasklet_enable(&keyboard_tasklet);
1673	tasklet_schedule(&keyboard_tasklet);
1674
1675	return 0;
1676}
1677
1678/* Ioctl support code */
1679
1680/**
1681 *	vt_do_diacrit		-	diacritical table updates
1682 *	@cmd: ioctl request
1683 *	@udp: pointer to user data for ioctl
1684 *	@perm: permissions check computed by caller
1685 *
1686 *	Update the diacritical tables atomically and safely. Lock them
1687 *	against simultaneous keypresses
1688 */
1689int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1690{
 
1691	unsigned long flags;
1692	int asize;
1693	int ret = 0;
1694
1695	switch (cmd) {
1696	case KDGKBDIACR:
1697	{
1698		struct kbdiacrs __user *a = udp;
1699		struct kbdiacr *dia;
1700		int i;
1701
1702		dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr),
1703								GFP_KERNEL);
1704		if (!dia)
1705			return -ENOMEM;
1706
1707		/* Lock the diacriticals table, make a copy and then
1708		   copy it after we unlock */
1709		spin_lock_irqsave(&kbd_event_lock, flags);
1710
1711		asize = accent_table_size;
1712		for (i = 0; i < asize; i++) {
1713			dia[i].diacr = conv_uni_to_8bit(
1714						accent_table[i].diacr);
1715			dia[i].base = conv_uni_to_8bit(
1716						accent_table[i].base);
1717			dia[i].result = conv_uni_to_8bit(
1718						accent_table[i].result);
1719		}
1720		spin_unlock_irqrestore(&kbd_event_lock, flags);
1721
1722		if (put_user(asize, &a->kb_cnt))
1723			ret = -EFAULT;
1724		else  if (copy_to_user(a->kbdiacr, dia,
1725				asize * sizeof(struct kbdiacr)))
1726			ret = -EFAULT;
1727		kfree(dia);
1728		return ret;
1729	}
1730	case KDGKBDIACRUC:
1731	{
1732		struct kbdiacrsuc __user *a = udp;
1733		void *buf;
1734
1735		buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc),
1736								GFP_KERNEL);
1737		if (buf == NULL)
1738			return -ENOMEM;
1739
1740		/* Lock the diacriticals table, make a copy and then
1741		   copy it after we unlock */
1742		spin_lock_irqsave(&kbd_event_lock, flags);
1743
1744		asize = accent_table_size;
1745		memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1746
1747		spin_unlock_irqrestore(&kbd_event_lock, flags);
1748
1749		if (put_user(asize, &a->kb_cnt))
1750			ret = -EFAULT;
1751		else if (copy_to_user(a->kbdiacruc, buf,
1752				asize*sizeof(struct kbdiacruc)))
1753			ret = -EFAULT;
1754		kfree(buf);
1755		return ret;
1756	}
1757
1758	case KDSKBDIACR:
1759	{
1760		struct kbdiacrs __user *a = udp;
1761		struct kbdiacr *dia = NULL;
1762		unsigned int ct;
1763		int i;
1764
1765		if (!perm)
1766			return -EPERM;
1767		if (get_user(ct, &a->kb_cnt))
1768			return -EFAULT;
1769		if (ct >= MAX_DIACR)
1770			return -EINVAL;
1771
1772		if (ct) {
1773			dia = memdup_array_user(a->kbdiacr,
1774						ct, sizeof(struct kbdiacr));
1775			if (IS_ERR(dia))
1776				return PTR_ERR(dia);
 
 
 
 
 
 
1777		}
1778
1779		spin_lock_irqsave(&kbd_event_lock, flags);
1780		accent_table_size = ct;
1781		for (i = 0; i < ct; i++) {
1782			accent_table[i].diacr =
1783					conv_8bit_to_uni(dia[i].diacr);
1784			accent_table[i].base =
1785					conv_8bit_to_uni(dia[i].base);
1786			accent_table[i].result =
1787					conv_8bit_to_uni(dia[i].result);
1788		}
1789		spin_unlock_irqrestore(&kbd_event_lock, flags);
1790		kfree(dia);
1791		return 0;
1792	}
1793
1794	case KDSKBDIACRUC:
1795	{
1796		struct kbdiacrsuc __user *a = udp;
1797		unsigned int ct;
1798		void *buf = NULL;
1799
1800		if (!perm)
1801			return -EPERM;
1802
1803		if (get_user(ct, &a->kb_cnt))
1804			return -EFAULT;
1805
1806		if (ct >= MAX_DIACR)
1807			return -EINVAL;
1808
1809		if (ct) {
1810			buf = memdup_array_user(a->kbdiacruc,
1811						ct, sizeof(struct kbdiacruc));
1812			if (IS_ERR(buf))
1813				return PTR_ERR(buf);
 
 
 
 
 
 
1814		} 
1815		spin_lock_irqsave(&kbd_event_lock, flags);
1816		if (ct)
1817			memcpy(accent_table, buf,
1818					ct * sizeof(struct kbdiacruc));
1819		accent_table_size = ct;
1820		spin_unlock_irqrestore(&kbd_event_lock, flags);
1821		kfree(buf);
1822		return 0;
1823	}
1824	}
1825	return ret;
1826}
1827
1828/**
1829 *	vt_do_kdskbmode		-	set keyboard mode ioctl
1830 *	@console: the console to use
1831 *	@arg: the requested mode
1832 *
1833 *	Update the keyboard mode bits while holding the correct locks.
1834 *	Return 0 for success or an error code.
1835 */
1836int vt_do_kdskbmode(unsigned int console, unsigned int arg)
1837{
1838	struct kbd_struct *kb = &kbd_table[console];
1839	int ret = 0;
1840	unsigned long flags;
1841
1842	spin_lock_irqsave(&kbd_event_lock, flags);
1843	switch(arg) {
1844	case K_RAW:
1845		kb->kbdmode = VC_RAW;
1846		break;
1847	case K_MEDIUMRAW:
1848		kb->kbdmode = VC_MEDIUMRAW;
1849		break;
1850	case K_XLATE:
1851		kb->kbdmode = VC_XLATE;
1852		do_compute_shiftstate();
1853		break;
1854	case K_UNICODE:
1855		kb->kbdmode = VC_UNICODE;
1856		do_compute_shiftstate();
1857		break;
1858	case K_OFF:
1859		kb->kbdmode = VC_OFF;
1860		break;
1861	default:
1862		ret = -EINVAL;
1863	}
1864	spin_unlock_irqrestore(&kbd_event_lock, flags);
1865	return ret;
1866}
1867
1868/**
1869 *	vt_do_kdskbmeta		-	set keyboard meta state
1870 *	@console: the console to use
1871 *	@arg: the requested meta state
1872 *
1873 *	Update the keyboard meta bits while holding the correct locks.
1874 *	Return 0 for success or an error code.
1875 */
1876int vt_do_kdskbmeta(unsigned int console, unsigned int arg)
1877{
1878	struct kbd_struct *kb = &kbd_table[console];
1879	int ret = 0;
1880	unsigned long flags;
1881
1882	spin_lock_irqsave(&kbd_event_lock, flags);
1883	switch(arg) {
1884	case K_METABIT:
1885		clr_vc_kbd_mode(kb, VC_META);
1886		break;
1887	case K_ESCPREFIX:
1888		set_vc_kbd_mode(kb, VC_META);
1889		break;
1890	default:
1891		ret = -EINVAL;
1892	}
1893	spin_unlock_irqrestore(&kbd_event_lock, flags);
1894	return ret;
1895}
1896
1897int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1898								int perm)
1899{
1900	struct kbkeycode tmp;
1901	int kc = 0;
1902
1903	if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1904		return -EFAULT;
1905	switch (cmd) {
1906	case KDGETKEYCODE:
1907		kc = getkeycode(tmp.scancode);
1908		if (kc >= 0)
1909			kc = put_user(kc, &user_kbkc->keycode);
1910		break;
1911	case KDSETKEYCODE:
1912		if (!perm)
1913			return -EPERM;
1914		kc = setkeycode(tmp.scancode, tmp.keycode);
1915		break;
1916	}
1917	return kc;
1918}
1919
1920static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx,
1921		unsigned char map)
 
 
 
 
1922{
1923	unsigned short *key_map, val;
 
 
1924	unsigned long flags;
1925
1926	/* Ensure another thread doesn't free it under us */
1927	spin_lock_irqsave(&kbd_event_lock, flags);
1928	key_map = key_maps[map];
1929	if (key_map) {
1930		val = U(key_map[idx]);
1931		if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1932			val = K_HOLE;
1933	} else
1934		val = idx ? K_HOLE : K_NOSUCHMAP;
1935	spin_unlock_irqrestore(&kbd_event_lock, flags);
1936
1937	return val;
1938}
1939
1940static int vt_kdskbent(unsigned char kbdmode, unsigned char idx,
1941		unsigned char map, unsigned short val)
1942{
1943	unsigned long flags;
1944	unsigned short *key_map, *new_map, oldval;
1945
1946	if (!idx && val == K_NOSUCHMAP) {
1947		spin_lock_irqsave(&kbd_event_lock, flags);
1948		/* deallocate map */
1949		key_map = key_maps[map];
1950		if (map && key_map) {
1951			key_maps[map] = NULL;
1952			if (key_map[0] == U(K_ALLOCATED)) {
1953				kfree(key_map);
1954				keymap_count--;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1955			}
 
 
1956		}
1957		spin_unlock_irqrestore(&kbd_event_lock, flags);
1958
1959		return 0;
1960	}
1961
1962	if (KTYP(val) < NR_TYPES) {
1963		if (KVAL(val) > max_vals[KTYP(val)])
1964			return -EINVAL;
1965	} else if (kbdmode != VC_UNICODE)
1966		return -EINVAL;
1967
1968	/* ++Geert: non-PC keyboards may generate keycode zero */
1969#if !defined(__mc68000__) && !defined(__powerpc__)
1970	/* assignment to entry 0 only tests validity of args */
1971	if (!idx)
1972		return 0;
1973#endif
1974
1975	new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1976	if (!new_map)
1977		return -ENOMEM;
1978
1979	spin_lock_irqsave(&kbd_event_lock, flags);
1980	key_map = key_maps[map];
1981	if (key_map == NULL) {
1982		int j;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1983
1984		if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1985		    !capable(CAP_SYS_RESOURCE)) {
 
 
 
 
 
1986			spin_unlock_irqrestore(&kbd_event_lock, flags);
1987			kfree(new_map);
1988			return -EPERM;
1989		}
1990		key_maps[map] = new_map;
1991		key_map = new_map;
1992		key_map[0] = U(K_ALLOCATED);
1993		for (j = 1; j < NR_KEYS; j++)
1994			key_map[j] = U(K_HOLE);
1995		keymap_count++;
1996	} else
1997		kfree(new_map);
1998
1999	oldval = U(key_map[idx]);
2000	if (val == oldval)
2001		goto out;
2002
2003	/* Attention Key */
2004	if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) {
2005		spin_unlock_irqrestore(&kbd_event_lock, flags);
2006		return -EPERM;
2007	}
2008
2009	key_map[idx] = U(val);
2010	if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT))
2011		do_compute_shiftstate();
2012out:
2013	spin_unlock_irqrestore(&kbd_event_lock, flags);
2014
2015	return 0;
2016}
2017
2018int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
2019						unsigned int console)
2020{
2021	struct kbd_struct *kb = &kbd_table[console];
2022	struct kbentry kbe;
2023
2024	if (copy_from_user(&kbe, user_kbe, sizeof(struct kbentry)))
2025		return -EFAULT;
2026
2027	switch (cmd) {
2028	case KDGKBENT:
2029		return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index,
2030					kbe.kb_table),
2031				&user_kbe->kb_value);
2032	case KDSKBENT:
2033		if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2034			return -EPERM;
2035		return vt_kdskbent(kb->kbdmode, kbe.kb_index, kbe.kb_table,
2036				kbe.kb_value);
2037	}
2038	return 0;
2039}
 
 
 
2040
2041static char *vt_kdskbsent(char *kbs, unsigned char cur)
2042{
2043	static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC);
2044	char *cur_f = func_table[cur];
2045
2046	if (cur_f && strlen(cur_f) >= strlen(kbs)) {
2047		strcpy(cur_f, kbs);
2048		return kbs;
2049	}
2050
2051	func_table[cur] = kbs;
2052
2053	return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL;
2054}
2055
2056int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2057{
2058	unsigned char kb_func;
2059	unsigned long flags;
2060	char *kbs;
 
 
 
 
 
2061	int ret;
2062
2063	if (get_user(kb_func, &user_kdgkb->kb_func))
2064		return -EFAULT;
2065
2066	kb_func = array_index_nospec(kb_func, MAX_NR_FUNC);
 
 
 
 
 
 
 
 
 
 
 
 
2067
2068	switch (cmd) {
2069	case KDGKBSENT: {
2070		/* size should have been a struct member */
2071		ssize_t len = sizeof(user_kdgkb->kb_string);
2072
2073		kbs = kmalloc(len, GFP_KERNEL);
2074		if (!kbs)
2075			return -ENOMEM;
2076
2077		spin_lock_irqsave(&func_buf_lock, flags);
2078		len = strscpy(kbs, func_table[kb_func] ? : "", len);
2079		spin_unlock_irqrestore(&func_buf_lock, flags);
2080
2081		if (len < 0) {
2082			ret = -ENOSPC;
2083			break;
2084		}
2085		ret = copy_to_user(user_kdgkb->kb_string, kbs, len + 1) ?
2086			-EFAULT : 0;
2087		break;
2088	}
2089	case KDSKBSENT:
2090		if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2091			return -EPERM;
 
 
2092
2093		kbs = strndup_user(user_kdgkb->kb_string,
2094				sizeof(user_kdgkb->kb_string));
2095		if (IS_ERR(kbs))
2096			return PTR_ERR(kbs);
2097
2098		spin_lock_irqsave(&func_buf_lock, flags);
2099		kbs = vt_kdskbsent(kbs, kb_func);
2100		spin_unlock_irqrestore(&func_buf_lock, flags);
2101
2102		ret = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2103		break;
2104	}
2105
 
2106	kfree(kbs);
2107
2108	return ret;
2109}
2110
2111int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm)
2112{
2113	struct kbd_struct *kb = &kbd_table[console];
2114        unsigned long flags;
2115	unsigned char ucval;
2116
2117        switch(cmd) {
2118	/* the ioctls below read/set the flags usually shown in the leds */
2119	/* don't use them - they will go away without warning */
2120	case KDGKBLED:
2121                spin_lock_irqsave(&kbd_event_lock, flags);
2122		ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2123                spin_unlock_irqrestore(&kbd_event_lock, flags);
2124		return put_user(ucval, (char __user *)arg);
2125
2126	case KDSKBLED:
2127		if (!perm)
2128			return -EPERM;
2129		if (arg & ~0x77)
2130			return -EINVAL;
2131                spin_lock_irqsave(&led_lock, flags);
2132		kb->ledflagstate = (arg & 7);
2133		kb->default_ledflagstate = ((arg >> 4) & 7);
2134		set_leds();
2135                spin_unlock_irqrestore(&led_lock, flags);
2136		return 0;
2137
2138	/* the ioctls below only set the lights, not the functions */
2139	/* for those, see KDGKBLED and KDSKBLED above */
2140	case KDGETLED:
2141		ucval = getledstate();
2142		return put_user(ucval, (char __user *)arg);
2143
2144	case KDSETLED:
2145		if (!perm)
2146			return -EPERM;
2147		setledstate(kb, arg);
2148		return 0;
2149        }
2150        return -ENOIOCTLCMD;
2151}
2152
2153int vt_do_kdgkbmode(unsigned int console)
2154{
2155	struct kbd_struct *kb = &kbd_table[console];
2156	/* This is a spot read so needs no locking */
2157	switch (kb->kbdmode) {
2158	case VC_RAW:
2159		return K_RAW;
2160	case VC_MEDIUMRAW:
2161		return K_MEDIUMRAW;
2162	case VC_UNICODE:
2163		return K_UNICODE;
2164	case VC_OFF:
2165		return K_OFF;
2166	default:
2167		return K_XLATE;
2168	}
2169}
2170
2171/**
2172 *	vt_do_kdgkbmeta		-	report meta status
2173 *	@console: console to report
2174 *
2175 *	Report the meta flag status of this console
2176 */
2177int vt_do_kdgkbmeta(unsigned int console)
2178{
2179	struct kbd_struct *kb = &kbd_table[console];
2180        /* Again a spot read so no locking */
2181	return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2182}
2183
2184/**
2185 *	vt_reset_unicode	-	reset the unicode status
2186 *	@console: console being reset
2187 *
2188 *	Restore the unicode console state to its default
2189 */
2190void vt_reset_unicode(unsigned int console)
2191{
2192	unsigned long flags;
2193
2194	spin_lock_irqsave(&kbd_event_lock, flags);
2195	kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2196	spin_unlock_irqrestore(&kbd_event_lock, flags);
2197}
2198
2199/**
2200 *	vt_get_shift_state	-	shift bit state
2201 *
2202 *	Report the shift bits from the keyboard state. We have to export
2203 *	this to support some oddities in the vt layer.
2204 */
2205int vt_get_shift_state(void)
2206{
2207        /* Don't lock as this is a transient report */
2208        return shift_state;
2209}
2210
2211/**
2212 *	vt_reset_keyboard	-	reset keyboard state
2213 *	@console: console to reset
2214 *
2215 *	Reset the keyboard bits for a console as part of a general console
2216 *	reset event
2217 */
2218void vt_reset_keyboard(unsigned int console)
2219{
2220	struct kbd_struct *kb = &kbd_table[console];
2221	unsigned long flags;
2222
2223	spin_lock_irqsave(&kbd_event_lock, flags);
2224	set_vc_kbd_mode(kb, VC_REPEAT);
2225	clr_vc_kbd_mode(kb, VC_CKMODE);
2226	clr_vc_kbd_mode(kb, VC_APPLIC);
2227	clr_vc_kbd_mode(kb, VC_CRLF);
2228	kb->lockstate = 0;
2229	kb->slockstate = 0;
2230	spin_lock(&led_lock);
2231	kb->ledmode = LED_SHOW_FLAGS;
2232	kb->ledflagstate = kb->default_ledflagstate;
2233	spin_unlock(&led_lock);
2234	/* do not do set_leds here because this causes an endless tasklet loop
2235	   when the keyboard hasn't been initialized yet */
2236	spin_unlock_irqrestore(&kbd_event_lock, flags);
2237}
2238
2239/**
2240 *	vt_get_kbd_mode_bit	-	read keyboard status bits
2241 *	@console: console to read from
2242 *	@bit: mode bit to read
2243 *
2244 *	Report back a vt mode bit. We do this without locking so the
2245 *	caller must be sure that there are no synchronization needs
2246 */
2247
2248int vt_get_kbd_mode_bit(unsigned int console, int bit)
2249{
2250	struct kbd_struct *kb = &kbd_table[console];
2251	return vc_kbd_mode(kb, bit);
2252}
2253
2254/**
2255 *	vt_set_kbd_mode_bit	-	read keyboard status bits
2256 *	@console: console to read from
2257 *	@bit: mode bit to read
2258 *
2259 *	Set a vt mode bit. We do this without locking so the
2260 *	caller must be sure that there are no synchronization needs
2261 */
2262
2263void vt_set_kbd_mode_bit(unsigned int console, int bit)
2264{
2265	struct kbd_struct *kb = &kbd_table[console];
2266	unsigned long flags;
2267
2268	spin_lock_irqsave(&kbd_event_lock, flags);
2269	set_vc_kbd_mode(kb, bit);
2270	spin_unlock_irqrestore(&kbd_event_lock, flags);
2271}
2272
2273/**
2274 *	vt_clr_kbd_mode_bit	-	read keyboard status bits
2275 *	@console: console to read from
2276 *	@bit: mode bit to read
2277 *
2278 *	Report back a vt mode bit. We do this without locking so the
2279 *	caller must be sure that there are no synchronization needs
2280 */
2281
2282void vt_clr_kbd_mode_bit(unsigned int console, int bit)
2283{
2284	struct kbd_struct *kb = &kbd_table[console];
2285	unsigned long flags;
2286
2287	spin_lock_irqsave(&kbd_event_lock, flags);
2288	clr_vc_kbd_mode(kb, bit);
2289	spin_unlock_irqrestore(&kbd_event_lock, flags);
2290}