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