PageRenderTime 90ms CodeModel.GetById 8ms app.highlight 58ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/char/keyboard.c

https://bitbucket.org/evzijst/gittest
C | 1254 lines | 1030 code | 109 blank | 115 comment | 93 complexity | a0fc0a63673577bcd3b424582688612f MD5 | raw file
   1/*
   2 * linux/drivers/char/keyboard.c
   3 *
   4 * Written for linux by Johan Myreen as a translation from
   5 * the assembly version by Linus (with diacriticals added)
   6 *
   7 * Some additional features added by Christoph Niemann (ChN), March 1993
   8 *
   9 * Loadable keymaps by Risto Kankkunen, May 1993
  10 *
  11 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
  12 * Added decr/incr_console, dynamic keymaps, Unicode support,
  13 * dynamic function/string keys, led setting,  Sept 1994
  14 * `Sticky' modifier keys, 951006.
  15 *
  16 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
  17 * 
  18 * Modified to provide 'generic' keyboard support by Hamish Macdonald
  19 * Merge with the m68k keyboard driver and split-off of the PC low-level
  20 * parts by Geert Uytterhoeven, May 1997
  21 *
  22 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
  23 * 30-07-98: Dead keys redone, aeb@cwi.nl.
  24 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
  25 */
  26
  27#include <linux/config.h>
  28#include <linux/module.h>
  29#include <linux/sched.h>
  30#include <linux/tty.h>
  31#include <linux/tty_flip.h>
  32#include <linux/mm.h>
  33#include <linux/string.h>
  34#include <linux/init.h>
  35#include <linux/slab.h>
  36
  37#include <linux/kbd_kern.h>
  38#include <linux/kbd_diacr.h>
  39#include <linux/vt_kern.h>
  40#include <linux/sysrq.h>
  41#include <linux/input.h>
  42
  43static void kbd_disconnect(struct input_handle *handle);
  44extern void ctrl_alt_del(void);
  45
  46/*
  47 * Exported functions/variables
  48 */
  49
  50#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  51
  52/*
  53 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
  54 * This seems a good reason to start with NumLock off. On HIL keyboards
  55 * of PARISC machines however there is no NumLock key and everyone expects the keypad 
  56 * to be used for numbers.
  57 */
  58
  59#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
  60#define KBD_DEFLEDS (1 << VC_NUMLOCK)
  61#else
  62#define KBD_DEFLEDS 0
  63#endif
  64
  65#define KBD_DEFLOCK 0
  66
  67void compute_shiftstate(void);
  68
  69/*
  70 * Handler Tables.
  71 */
  72
  73#define K_HANDLERS\
  74	k_self,		k_fn,		k_spec,		k_pad,\
  75	k_dead,		k_cons,		k_cur,		k_shift,\
  76	k_meta,		k_ascii,	k_lock,		k_lowercase,\
  77	k_slock,	k_dead2,	k_ignore,	k_ignore
  78
  79typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value, 
  80			    char up_flag, struct pt_regs *regs);
  81static k_handler_fn K_HANDLERS;
  82static k_handler_fn *k_handler[16] = { K_HANDLERS };
  83
  84#define FN_HANDLERS\
  85	fn_null, 	fn_enter,	fn_show_ptregs,	fn_show_mem,\
  86	fn_show_state,	fn_send_intr, 	fn_lastcons, 	fn_caps_toggle,\
  87	fn_num,		fn_hold, 	fn_scroll_forw,	fn_scroll_back,\
  88	fn_boot_it, 	fn_caps_on, 	fn_compose,	fn_SAK,\
  89	fn_dec_console, fn_inc_console, fn_spawn_con, 	fn_bare_num
  90
  91typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
  92static fn_handler_fn FN_HANDLERS;
  93static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
  94
  95/*
  96 * Variables exported for vt_ioctl.c
  97 */
  98
  99/* maximum values each key_handler can handle */
 100const int max_vals[] = {
 101	255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
 102	NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
 103	255, NR_LOCK - 1, 255
 104};
 105
 106const int NR_TYPES = ARRAY_SIZE(max_vals);
 107
 108struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 109static struct kbd_struct *kbd = kbd_table;
 110static struct kbd_struct kbd0;
 111
 112int spawnpid, spawnsig;
 113
 114/*
 115 * Variables exported for vt.c
 116 */
 117
 118int shift_state = 0;
 119
 120/*
 121 * Internal Data.
 122 */
 123
 124static struct input_handler kbd_handler;
 125static unsigned long key_down[NBITS(KEY_MAX)];		/* keyboard key bitmap */
 126static unsigned char shift_down[NR_SHIFT];		/* shift state counters.. */
 127static int dead_key_next;
 128static int npadch = -1;					/* -1 or number assembled on pad */
 129static unsigned char diacr;
 130static char rep;					/* flag telling character repeat */
 131
 132static unsigned char ledstate = 0xff;			/* undefined */
 133static unsigned char ledioctl;
 134
 135static struct ledptr {
 136	unsigned int *addr;
 137	unsigned int mask;
 138	unsigned char valid:1;
 139} ledptrs[3];
 140
 141/* Simple translation table for the SysRq keys */
 142
 143#ifdef CONFIG_MAGIC_SYSRQ
 144unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
 145        "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
 146        "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
 147        "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
 148        "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
 149        "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
 150        "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
 151        "\r\000/";                                      /* 0x60 - 0x6f */
 152static int sysrq_down;
 153#endif
 154static int sysrq_alt;
 155
 156/*
 157 * Translation of scancodes to keycodes. We set them on only the first attached
 158 * keyboard - for per-keyboard setting, /dev/input/event is more useful.
 159 */
 160int getkeycode(unsigned int scancode)
 161{
 162	struct list_head * node;
 163	struct input_dev *dev = NULL;
 164
 165	list_for_each(node,&kbd_handler.h_list) {
 166		struct input_handle * handle = to_handle_h(node);
 167		if (handle->dev->keycodesize) { 
 168			dev = handle->dev; 
 169			break;
 170		}
 171	}
 172
 173	if (!dev)
 174		return -ENODEV;
 175
 176	if (scancode >= dev->keycodemax)
 177		return -EINVAL;
 178
 179	return INPUT_KEYCODE(dev, scancode);
 180}
 181
 182int setkeycode(unsigned int scancode, unsigned int keycode)
 183{
 184	struct list_head * node;
 185	struct input_dev *dev = NULL;
 186	unsigned int i, oldkey;
 187
 188	list_for_each(node,&kbd_handler.h_list) {
 189		struct input_handle *handle = to_handle_h(node);
 190		if (handle->dev->keycodesize) { 
 191			dev = handle->dev; 
 192			break; 
 193		}
 194	}
 195
 196	if (!dev)
 197		return -ENODEV;
 198
 199	if (scancode >= dev->keycodemax)
 200		return -EINVAL;
 201	if (keycode > KEY_MAX)
 202		return -EINVAL;
 203	if (keycode < 0 || keycode > KEY_MAX)
 204		return -EINVAL;
 205
 206	oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
 207
 208	clear_bit(oldkey, dev->keybit);
 209	set_bit(keycode, dev->keybit);
 210
 211	for (i = 0; i < dev->keycodemax; i++)
 212		if (INPUT_KEYCODE(dev,i) == oldkey)
 213			set_bit(oldkey, dev->keybit);
 214
 215	return 0;
 216}
 217
 218/*
 219 * Making beeps and bells. 
 220 */
 221static void kd_nosound(unsigned long ignored)
 222{
 223	struct list_head * node;
 224
 225	list_for_each(node,&kbd_handler.h_list) {
 226		struct input_handle *handle = to_handle_h(node);
 227		if (test_bit(EV_SND, handle->dev->evbit)) {
 228			if (test_bit(SND_TONE, handle->dev->sndbit))
 229				input_event(handle->dev, EV_SND, SND_TONE, 0);
 230			if (test_bit(SND_BELL, handle->dev->sndbit))
 231				input_event(handle->dev, EV_SND, SND_BELL, 0);
 232		}
 233	}
 234}
 235
 236static struct timer_list kd_mksound_timer =
 237		TIMER_INITIALIZER(kd_nosound, 0, 0);
 238
 239void kd_mksound(unsigned int hz, unsigned int ticks)
 240{
 241	struct list_head * node;
 242
 243	del_timer(&kd_mksound_timer);
 244
 245	if (hz) {
 246		list_for_each_prev(node,&kbd_handler.h_list) {
 247			struct input_handle *handle = to_handle_h(node);
 248			if (test_bit(EV_SND, handle->dev->evbit)) {
 249				if (test_bit(SND_TONE, handle->dev->sndbit)) {
 250					input_event(handle->dev, EV_SND, SND_TONE, hz);
 251					break;
 252				}
 253				if (test_bit(SND_BELL, handle->dev->sndbit)) {
 254					input_event(handle->dev, EV_SND, SND_BELL, 1);
 255					break;
 256				}
 257			}
 258		}
 259		if (ticks)
 260			mod_timer(&kd_mksound_timer, jiffies + ticks);
 261	} else
 262		kd_nosound(0);
 263}
 264
 265/*
 266 * Setting the keyboard rate.
 267 */
 268
 269int kbd_rate(struct kbd_repeat *rep)
 270{
 271	struct list_head *node;
 272	unsigned int d = 0;
 273	unsigned int p = 0;
 274
 275	list_for_each(node,&kbd_handler.h_list) {
 276		struct input_handle *handle = to_handle_h(node);
 277		struct input_dev *dev = handle->dev;
 278
 279		if (test_bit(EV_REP, dev->evbit)) {
 280			if (rep->delay > 0)
 281				input_event(dev, EV_REP, REP_DELAY, rep->delay);
 282			if (rep->period > 0)
 283				input_event(dev, EV_REP, REP_PERIOD, rep->period);
 284			d = dev->rep[REP_DELAY];
 285			p = dev->rep[REP_PERIOD];
 286		}
 287	}
 288	rep->delay  = d;
 289	rep->period = p;
 290	return 0;
 291}
 292
 293/*
 294 * Helper Functions.
 295 */
 296static void put_queue(struct vc_data *vc, int ch)
 297{
 298	struct tty_struct *tty = vc->vc_tty;
 299
 300	if (tty) {
 301		tty_insert_flip_char(tty, ch, 0);
 302		con_schedule_flip(tty);
 303	}
 304}
 305
 306static void puts_queue(struct vc_data *vc, char *cp)
 307{
 308	struct tty_struct *tty = vc->vc_tty;
 309
 310	if (!tty)
 311		return;
 312
 313	while (*cp) {
 314		tty_insert_flip_char(tty, *cp, 0);
 315		cp++;
 316	}
 317	con_schedule_flip(tty);
 318}
 319
 320static void applkey(struct vc_data *vc, int key, char mode)
 321{
 322	static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
 323
 324	buf[1] = (mode ? 'O' : '[');
 325	buf[2] = key;
 326	puts_queue(vc, buf);
 327}
 328
 329/*
 330 * Many other routines do put_queue, but I think either
 331 * they produce ASCII, or they produce some user-assigned
 332 * string, and in both cases we might assume that it is
 333 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
 334 * but we need only 16 bits here
 335 */
 336static void to_utf8(struct vc_data *vc, ushort 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 {
 346		/* 1110**** 10****** 10****** */
 347		put_queue(vc, 0xe0 | (c >> 12));
 348		put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
 349		put_queue(vc, 0x80 | (c & 0x3f));
 350    	}
 351}
 352
 353/* 
 354 * Called after returning from RAW mode or when changing consoles - recompute
 355 * shift_down[] and shift_state from key_down[] maybe called when keymap is
 356 * undefined, so that shiftkey release is seen
 357 */
 358void compute_shiftstate(void)
 359{
 360	unsigned int i, j, k, sym, val;
 361
 362	shift_state = 0;
 363	memset(shift_down, 0, sizeof(shift_down));
 364	
 365	for (i = 0; i < ARRAY_SIZE(key_down); i++) {
 366
 367		if (!key_down[i])
 368			continue;
 369
 370		k = i * BITS_PER_LONG;
 371
 372		for (j = 0; j < BITS_PER_LONG; j++, k++) {
 373
 374			if (!test_bit(k, key_down))
 375				continue;
 376
 377			sym = U(key_maps[0][k]);
 378			if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
 379				continue;
 380
 381			val = KVAL(sym);
 382			if (val == KVAL(K_CAPSSHIFT))
 383				val = KVAL(K_SHIFT);
 384
 385			shift_down[val]++;
 386			shift_state |= (1 << val);
 387		}
 388	}
 389}
 390
 391/*
 392 * We have a combining character DIACR here, followed by the character CH.
 393 * If the combination occurs in the table, return the corresponding value.
 394 * Otherwise, if CH is a space or equals DIACR, return DIACR.
 395 * Otherwise, conclude that DIACR was not combining after all,
 396 * queue it and return CH.
 397 */
 398static unsigned char handle_diacr(struct vc_data *vc, unsigned char ch)
 399{
 400	int d = diacr;
 401	unsigned int i;
 402
 403	diacr = 0;
 404
 405	for (i = 0; i < accent_table_size; i++) {
 406		if (accent_table[i].diacr == d && accent_table[i].base == ch)
 407			return accent_table[i].result;
 408	}
 409
 410	if (ch == ' ' || ch == d)
 411		return d;
 412
 413	put_queue(vc, d);
 414	return ch;
 415}
 416
 417/*
 418 * Special function handlers
 419 */
 420static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
 421{
 422	if (diacr) {
 423		put_queue(vc, diacr);
 424		diacr = 0;
 425	}
 426	put_queue(vc, 13);
 427	if (vc_kbd_mode(kbd, VC_CRLF))
 428		put_queue(vc, 10);
 429}
 430
 431static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
 432{
 433	if (rep)
 434		return;
 435	chg_vc_kbd_led(kbd, VC_CAPSLOCK);
 436}
 437
 438static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
 439{
 440	if (rep)
 441		return;
 442	set_vc_kbd_led(kbd, VC_CAPSLOCK);
 443}
 444
 445static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
 446{
 447	if (regs)
 448		show_regs(regs);
 449}
 450
 451static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
 452{
 453	struct tty_struct *tty = vc->vc_tty;
 454
 455	if (rep || !tty)
 456		return;
 457
 458	/*
 459	 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
 460	 * these routines are also activated by ^S/^Q.
 461	 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
 462	 */
 463	if (tty->stopped)
 464		start_tty(tty);
 465	else
 466		stop_tty(tty);
 467}
 468
 469static void fn_num(struct vc_data *vc, struct pt_regs *regs)
 470{
 471	if (vc_kbd_mode(kbd,VC_APPLIC))
 472		applkey(vc, 'P', 1);
 473	else
 474		fn_bare_num(vc, regs);
 475}
 476
 477/*
 478 * Bind this to Shift-NumLock if you work in application keypad mode
 479 * but want to be able to change the NumLock flag.
 480 * Bind this to NumLock if you prefer that the NumLock key always
 481 * changes the NumLock flag.
 482 */
 483static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
 484{
 485	if (!rep)
 486		chg_vc_kbd_led(kbd, VC_NUMLOCK);
 487}
 488
 489static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
 490{
 491	/* switch to the last used console, ChN */
 492	set_console(last_console);
 493}
 494
 495static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
 496{
 497	int i, cur = fg_console;
 498
 499	/* Currently switching?  Queue this next switch relative to that. */
 500	if (want_console != -1)
 501		cur = want_console;
 502
 503	for (i = cur-1; i != cur; i--) {
 504		if (i == -1)
 505			i = MAX_NR_CONSOLES-1;
 506		if (vc_cons_allocated(i))
 507			break;
 508	}
 509	set_console(i);
 510}
 511
 512static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
 513{
 514	int i, cur = fg_console;
 515
 516	/* Currently switching?  Queue this next switch relative to that. */
 517	if (want_console != -1)
 518		cur = want_console;
 519
 520	for (i = cur+1; i != cur; i++) {
 521		if (i == MAX_NR_CONSOLES)
 522			i = 0;
 523		if (vc_cons_allocated(i))
 524			break;
 525	}
 526	set_console(i);
 527}
 528
 529static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
 530{
 531	struct tty_struct *tty = vc->vc_tty;
 532
 533	if (!tty)
 534		return;
 535	tty_insert_flip_char(tty, 0, TTY_BREAK);
 536	con_schedule_flip(tty);
 537}
 538
 539static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
 540{
 541	scrollfront(vc, 0);
 542}
 543
 544static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
 545{
 546	scrollback(vc, 0);
 547}
 548
 549static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
 550{
 551	show_mem();
 552}
 553
 554static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
 555{
 556	show_state();
 557}
 558
 559static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
 560{
 561	ctrl_alt_del();
 562}
 563
 564static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
 565{
 566	dead_key_next = 1;
 567}
 568
 569static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
 570{
 571        if (spawnpid)
 572	   if(kill_proc(spawnpid, spawnsig, 1))
 573	     spawnpid = 0;
 574}
 575
 576static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
 577{
 578	struct tty_struct *tty = vc->vc_tty;
 579
 580	/*
 581	 * SAK should also work in all raw modes and reset
 582	 * them properly.
 583	 */
 584	if (tty)
 585		do_SAK(tty);
 586	reset_vc(vc);
 587}
 588
 589static void fn_null(struct vc_data *vc, struct pt_regs *regs)
 590{
 591	compute_shiftstate();
 592}
 593
 594/*
 595 * Special key handlers
 596 */
 597static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 598{
 599}
 600
 601static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 602{
 603	if (up_flag)
 604		return;
 605	if (value >= ARRAY_SIZE(fn_handler))
 606		return;
 607	if ((kbd->kbdmode == VC_RAW || 
 608	     kbd->kbdmode == VC_MEDIUMRAW) && 
 609	     value != KVAL(K_SAK))
 610		return;		/* SAK is allowed even in raw mode */
 611	fn_handler[value](vc, regs);
 612}
 613
 614static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 615{
 616	printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
 617}
 618
 619static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 620{
 621	if (up_flag)
 622		return;		/* no action, if this is a key release */
 623
 624	if (diacr)
 625		value = handle_diacr(vc, value);
 626
 627	if (dead_key_next) {
 628		dead_key_next = 0;
 629		diacr = value;
 630		return;
 631	}
 632	put_queue(vc, value);
 633}
 634
 635/*
 636 * Handle dead key. Note that we now may have several
 637 * dead keys modifying the same character. Very useful
 638 * for Vietnamese.
 639 */
 640static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 641{
 642	if (up_flag)
 643		return;
 644	diacr = (diacr ? handle_diacr(vc, value) : value);
 645}
 646
 647/*
 648 * Obsolete - for backwards compatibility only
 649 */
 650static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 651{
 652	static unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
 653	value = ret_diacr[value];
 654	k_dead2(vc, value, up_flag, regs);
 655}
 656
 657static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 658{
 659	if (up_flag)
 660		return;
 661	set_console(value);
 662}
 663
 664static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 665{
 666	unsigned v;
 667
 668	if (up_flag)
 669		return;
 670	v = value;
 671	if (v < ARRAY_SIZE(func_table)) {
 672		if (func_table[value])
 673			puts_queue(vc, func_table[value]);
 674	} else
 675		printk(KERN_ERR "k_fn called with value=%d\n", value);
 676}
 677
 678static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 679{
 680	static const char *cur_chars = "BDCA";
 681
 682	if (up_flag)
 683		return;
 684	applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 685}
 686
 687static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 688{
 689	static const char *pad_chars = "0123456789+-*/\015,.?()#";
 690	static const char *app_map = "pqrstuvwxylSRQMnnmPQS";
 691
 692	if (up_flag)
 693		return;		/* no action, if this is a key release */
 694
 695	/* kludge... shift forces cursor/number keys */
 696	if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
 697		applkey(vc, app_map[value], 1);
 698		return;
 699	}
 700
 701	if (!vc_kbd_led(kbd, VC_NUMLOCK))
 702		switch (value) {
 703			case KVAL(K_PCOMMA):
 704			case KVAL(K_PDOT):
 705				k_fn(vc, KVAL(K_REMOVE), 0, regs);
 706				return;
 707			case KVAL(K_P0):
 708				k_fn(vc, KVAL(K_INSERT), 0, regs);
 709				return;
 710			case KVAL(K_P1):
 711				k_fn(vc, KVAL(K_SELECT), 0, regs);
 712				return;
 713			case KVAL(K_P2):
 714				k_cur(vc, KVAL(K_DOWN), 0, regs);
 715				return;
 716			case KVAL(K_P3):
 717				k_fn(vc, KVAL(K_PGDN), 0, regs);
 718				return;
 719			case KVAL(K_P4):
 720				k_cur(vc, KVAL(K_LEFT), 0, regs);
 721				return;
 722			case KVAL(K_P6):
 723				k_cur(vc, KVAL(K_RIGHT), 0, regs);
 724				return;
 725			case KVAL(K_P7):
 726				k_fn(vc, KVAL(K_FIND), 0, regs);
 727				return;
 728			case KVAL(K_P8):
 729				k_cur(vc, KVAL(K_UP), 0, regs);
 730				return;
 731			case KVAL(K_P9):
 732				k_fn(vc, KVAL(K_PGUP), 0, regs);
 733				return;
 734			case KVAL(K_P5):
 735				applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
 736				return;
 737		}
 738
 739	put_queue(vc, pad_chars[value]);
 740	if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
 741		put_queue(vc, 10);
 742}
 743
 744static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 745{
 746	int old_state = shift_state;
 747
 748	if (rep)
 749		return;
 750	/*
 751	 * Mimic typewriter:
 752	 * a CapsShift key acts like Shift but undoes CapsLock
 753	 */
 754	if (value == KVAL(K_CAPSSHIFT)) {
 755		value = KVAL(K_SHIFT);
 756		if (!up_flag)
 757			clr_vc_kbd_led(kbd, VC_CAPSLOCK);
 758	}
 759
 760	if (up_flag) {
 761		/*
 762		 * handle the case that two shift or control
 763		 * keys are depressed simultaneously
 764		 */
 765		if (shift_down[value])
 766			shift_down[value]--;
 767	} else
 768		shift_down[value]++;
 769
 770	if (shift_down[value])
 771		shift_state |= (1 << value);
 772	else
 773		shift_state &= ~(1 << value);
 774
 775	/* kludge */
 776	if (up_flag && shift_state != old_state && npadch != -1) {
 777		if (kbd->kbdmode == VC_UNICODE)
 778			to_utf8(vc, npadch & 0xffff);
 779		else
 780			put_queue(vc, npadch & 0xff);
 781		npadch = -1;
 782	}
 783}
 784
 785static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 786{
 787	if (up_flag)
 788		return;
 789
 790	if (vc_kbd_mode(kbd, VC_META)) {
 791		put_queue(vc, '\033');
 792		put_queue(vc, value);
 793	} else
 794		put_queue(vc, value | 0x80);
 795}
 796
 797static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 798{
 799	int base;
 800
 801	if (up_flag)
 802		return;
 803
 804	if (value < 10) {
 805		/* decimal input of code, while Alt depressed */
 806		base = 10;
 807	} else {
 808		/* hexadecimal input of code, while AltGr depressed */
 809		value -= 10;
 810		base = 16;
 811	}
 812
 813	if (npadch == -1)
 814		npadch = value;
 815	else
 816		npadch = npadch * base + value;
 817}
 818
 819static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 820{
 821	if (up_flag || rep)
 822		return;
 823	chg_vc_kbd_lock(kbd, value);
 824}
 825
 826static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
 827{
 828	k_shift(vc, value, up_flag, regs);
 829	if (up_flag || rep)
 830		return;
 831	chg_vc_kbd_slock(kbd, value);
 832	/* try to make Alt, oops, AltGr and such work */
 833	if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
 834		kbd->slockstate = 0;
 835		chg_vc_kbd_slock(kbd, value);
 836	}
 837}
 838
 839/*
 840 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
 841 * or (ii) whatever pattern of lights people want to show using KDSETLED,
 842 * or (iii) specified bits of specified words in kernel memory.
 843 */
 844unsigned char getledstate(void)
 845{
 846	return ledstate;
 847}
 848
 849void setledstate(struct kbd_struct *kbd, unsigned int led)
 850{
 851	if (!(led & ~7)) {
 852		ledioctl = led;
 853		kbd->ledmode = LED_SHOW_IOCTL;
 854	} else
 855		kbd->ledmode = LED_SHOW_FLAGS;
 856	set_leds();
 857}
 858
 859static inline unsigned char getleds(void)
 860{
 861	struct kbd_struct *kbd = kbd_table + fg_console;
 862	unsigned char leds;
 863	int i;
 864
 865	if (kbd->ledmode == LED_SHOW_IOCTL)
 866		return ledioctl;
 867
 868	leds = kbd->ledflagstate;
 869
 870	if (kbd->ledmode == LED_SHOW_MEM) {
 871		for (i = 0; i < 3; i++)
 872			if (ledptrs[i].valid) {
 873				if (*ledptrs[i].addr & ledptrs[i].mask)
 874					leds |= (1 << i);
 875				else
 876					leds &= ~(1 << i);
 877			}
 878	}
 879	return leds;
 880}
 881
 882/*
 883 * This routine is the bottom half of the keyboard interrupt
 884 * routine, and runs with all interrupts enabled. It does
 885 * console changing, led setting and copy_to_cooked, which can
 886 * take a reasonably long time.
 887 *
 888 * Aside from timing (which isn't really that important for
 889 * keyboard interrupts as they happen often), using the software
 890 * interrupt routines for this thing allows us to easily mask
 891 * this when we don't want any of the above to happen.
 892 * This allows for easy and efficient race-condition prevention
 893 * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
 894 */
 895
 896static void kbd_bh(unsigned long dummy)
 897{
 898	struct list_head * node;
 899	unsigned char leds = getleds();
 900
 901	if (leds != ledstate) {
 902		list_for_each(node,&kbd_handler.h_list) {
 903			struct input_handle * handle = to_handle_h(node);
 904			input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
 905			input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
 906			input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
 907			input_sync(handle->dev);
 908		}
 909	}
 910
 911	ledstate = leds;
 912}
 913
 914DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
 915
 916/*
 917 * This allows a newly plugged keyboard to pick the LED state.
 918 */
 919static void kbd_refresh_leds(struct input_handle *handle)
 920{
 921	unsigned char leds = ledstate;
 922
 923	tasklet_disable(&keyboard_tasklet);
 924	if (leds != 0xff) {
 925		input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
 926		input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
 927		input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
 928		input_sync(handle->dev);
 929	}
 930	tasklet_enable(&keyboard_tasklet);
 931}
 932
 933#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
 934    defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC32) ||\
 935    defined(CONFIG_SPARC64) || defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
 936    (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
 937
 938#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
 939			((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
 940
 941static unsigned short x86_keycodes[256] =
 942	{ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 943	 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 944	 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 945	 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 946	 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 947	 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
 948	284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
 949	367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
 950	360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
 951	103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
 952	291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
 953	264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
 954	377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
 955	308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
 956	332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
 957
 958#ifdef CONFIG_MAC_EMUMOUSEBTN
 959extern int mac_hid_mouse_emulate_buttons(int, int, int);
 960#endif /* CONFIG_MAC_EMUMOUSEBTN */
 961
 962#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
 963static int sparc_l1_a_state = 0;
 964extern void sun_do_break(void);
 965#endif
 966
 967static int emulate_raw(struct vc_data *vc, unsigned int keycode, 
 968		       unsigned char up_flag)
 969{
 970	if (keycode > 255 || !x86_keycodes[keycode])
 971		return -1; 
 972
 973	switch (keycode) {
 974		case KEY_PAUSE:
 975			put_queue(vc, 0xe1);
 976			put_queue(vc, 0x1d | up_flag);
 977			put_queue(vc, 0x45 | up_flag);
 978			return 0;
 979		case KEY_HANGUEL:
 980			if (!up_flag) put_queue(vc, 0xf1);
 981			return 0;
 982		case KEY_HANJA:
 983			if (!up_flag) put_queue(vc, 0xf2);
 984			return 0;
 985	} 
 986
 987	if (keycode == KEY_SYSRQ && sysrq_alt) {
 988		put_queue(vc, 0x54 | up_flag);
 989		return 0;
 990	}
 991
 992	if (x86_keycodes[keycode] & 0x100)
 993		put_queue(vc, 0xe0);
 994
 995	put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
 996
 997	if (keycode == KEY_SYSRQ) {
 998		put_queue(vc, 0xe0);
 999		put_queue(vc, 0x37 | up_flag);
1000	}
1001
1002	return 0;
1003}
1004
1005#else
1006
1007#define HW_RAW(dev)	0
1008
1009#warning "Cannot generate rawmode keyboard for your architecture yet."
1010
1011static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1012{
1013	if (keycode > 127)
1014		return -1;
1015
1016	put_queue(vc, keycode | up_flag);
1017	return 0;
1018}
1019#endif
1020
1021static void kbd_rawcode(unsigned char data)
1022{
1023	struct vc_data *vc = vc_cons[fg_console].d;
1024	kbd = kbd_table + fg_console;
1025	if (kbd->kbdmode == VC_RAW)
1026		put_queue(vc, data);
1027}
1028
1029void kbd_keycode(unsigned int keycode, int down, int hw_raw, struct pt_regs *regs)
1030{
1031	struct vc_data *vc = vc_cons[fg_console].d;
1032	unsigned short keysym, *key_map;
1033	unsigned char type, raw_mode;
1034	struct tty_struct *tty;
1035	int shift_final;
1036
1037	tty = vc->vc_tty;
1038
1039	if (tty && (!tty->driver_data)) {
1040		/* No driver data? Strange. Okay we fix it then. */
1041		tty->driver_data = vc;
1042	}
1043
1044	kbd = kbd_table + fg_console;
1045
1046	if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1047		sysrq_alt = down;
1048#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1049	if (keycode == KEY_STOP)
1050		sparc_l1_a_state = down;
1051#endif
1052
1053	rep = (down == 2);
1054
1055#ifdef CONFIG_MAC_EMUMOUSEBTN
1056	if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1057		return;
1058#endif /* CONFIG_MAC_EMUMOUSEBTN */
1059
1060	if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1061		if (emulate_raw(vc, keycode, !down << 7))
1062			if (keycode < BTN_MISC)
1063				printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1064
1065#ifdef CONFIG_MAGIC_SYSRQ	       /* Handle the SysRq Hack */
1066	if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1067		sysrq_down = down;
1068		return;
1069	}
1070	if (sysrq_down && down && !rep) {
1071		handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1072		return;
1073	}
1074#endif
1075#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1076	if (keycode == KEY_A && sparc_l1_a_state) {
1077		sparc_l1_a_state = 0;
1078		sun_do_break();
1079	}
1080#endif
1081
1082	if (kbd->kbdmode == VC_MEDIUMRAW) {
1083		/*
1084		 * This is extended medium raw mode, with keys above 127
1085		 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1086		 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1087		 * interfere with anything else. The two bytes after 0 will
1088		 * always have the up flag set not to interfere with older
1089		 * applications. This allows for 16384 different keycodes,
1090		 * which should be enough.
1091		 */
1092		if (keycode < 128) {
1093			put_queue(vc, keycode | (!down << 7));
1094		} else {
1095			put_queue(vc, !down << 7);
1096			put_queue(vc, (keycode >> 7) | 0x80);
1097			put_queue(vc, keycode | 0x80);
1098		}
1099		raw_mode = 1;
1100	}
1101
1102	if (down)
1103		set_bit(keycode, key_down);
1104	else
1105		clear_bit(keycode, key_down);
1106
1107	if (rep && (!vc_kbd_mode(kbd, VC_REPEAT) || (tty && 
1108		(!L_ECHO(tty) && tty->driver->chars_in_buffer(tty))))) {
1109		/*
1110		 * Don't repeat a key if the input buffers are not empty and the
1111		 * characters get aren't echoed locally. This makes key repeat 
1112		 * usable with slow applications and under heavy loads.
1113		 */
1114		return;
1115	}
1116
1117	shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1118	key_map = key_maps[shift_final];
1119
1120	if (!key_map) {
1121		compute_shiftstate();
1122		kbd->slockstate = 0;
1123		return;
1124	}
1125
1126	if (keycode > NR_KEYS)
1127		return;
1128
1129	keysym = key_map[keycode];
1130	type = KTYP(keysym);
1131
1132	if (type < 0xf0) {
1133		if (down && !raw_mode) to_utf8(vc, keysym);
1134		return;
1135	}
1136
1137	type -= 0xf0;
1138
1139	if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1140		return;
1141
1142	if (type == KT_LETTER) {
1143		type = KT_LATIN;
1144		if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1145			key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1146			if (key_map)
1147				keysym = key_map[keycode];
1148		}
1149	}
1150
1151	(*k_handler[type])(vc, keysym & 0xff, !down, regs);
1152
1153	if (type != KT_SLOCK)
1154		kbd->slockstate = 0;
1155}
1156
1157static void kbd_event(struct input_handle *handle, unsigned int event_type, 
1158		      unsigned int event_code, int value)
1159{
1160	if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1161		kbd_rawcode(value);
1162	if (event_type == EV_KEY)
1163		kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1164	tasklet_schedule(&keyboard_tasklet);
1165	do_poke_blanked_console = 1;
1166	schedule_console_callback();
1167}
1168
1169static char kbd_name[] = "kbd";
1170
1171/*
1172 * When a keyboard (or other input device) is found, the kbd_connect
1173 * function is called. The function then looks at the device, and if it
1174 * likes it, it can open it and get events from it. In this (kbd_connect)
1175 * function, we should decide which VT to bind that keyboard to initially.
1176 */
1177static struct input_handle *kbd_connect(struct input_handler *handler, 
1178					struct input_dev *dev,
1179					struct input_device_id *id)
1180{
1181	struct input_handle *handle;
1182	int i;
1183
1184	for (i = KEY_RESERVED; i < BTN_MISC; i++)
1185		if (test_bit(i, dev->keybit)) break;
1186
1187	if ((i == BTN_MISC) && !test_bit(EV_SND, dev->evbit)) 
1188		return NULL;
1189
1190	if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL))) 
1191		return NULL;
1192	memset(handle, 0, sizeof(struct input_handle));
1193
1194	handle->dev = dev;
1195	handle->handler = handler;
1196	handle->name = kbd_name;
1197
1198	input_open_device(handle);
1199	kbd_refresh_leds(handle);
1200
1201	return handle;
1202}
1203
1204static void kbd_disconnect(struct input_handle *handle)
1205{
1206	input_close_device(handle);
1207	kfree(handle);
1208}
1209
1210static struct input_device_id kbd_ids[] = {
1211	{
1212                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1213                .evbit = { BIT(EV_KEY) },
1214        },
1215	
1216	{
1217                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1218                .evbit = { BIT(EV_SND) },
1219        },	
1220
1221	{ },    /* Terminating entry */
1222};
1223
1224MODULE_DEVICE_TABLE(input, kbd_ids);
1225
1226static struct input_handler kbd_handler = {
1227	.event		= kbd_event,
1228	.connect	= kbd_connect,
1229	.disconnect	= kbd_disconnect,
1230	.name		= "kbd",
1231	.id_table	= kbd_ids,
1232};
1233
1234int __init kbd_init(void)
1235{
1236	int i;
1237
1238        kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1239        kbd0.ledmode = LED_SHOW_FLAGS;
1240        kbd0.lockstate = KBD_DEFLOCK;
1241        kbd0.slockstate = 0;
1242        kbd0.modeflags = KBD_DEFMODE;
1243        kbd0.kbdmode = VC_XLATE;
1244
1245        for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1246                kbd_table[i] = kbd0;
1247
1248	input_register_handler(&kbd_handler);
1249
1250	tasklet_enable(&keyboard_tasklet);
1251	tasklet_schedule(&keyboard_tasklet);
1252
1253	return 0;
1254}