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