keyboard.c 32.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * linux/drivers/char/keyboard.c
 *
 * Written for linux by Johan Myreen as a translation from
 * the assembly version by Linus (with diacriticals added)
 *
 * Some additional features added by Christoph Niemann (ChN), March 1993
 *
 * Loadable keymaps by Risto Kankkunen, May 1993
 *
 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
 * Added decr/incr_console, dynamic keymaps, Unicode support,
 * dynamic function/string keys, led setting,  Sept 1994
 * `Sticky' modifier keys, 951006.
 *
 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
17
 *
L
Linus Torvalds 已提交
18 19 20 21 22 23 24 25 26
 * Modified to provide 'generic' keyboard support by Hamish Macdonald
 * Merge with the m68k keyboard driver and split-off of the PC low-level
 * parts by Geert Uytterhoeven, May 1997
 *
 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
 * 30-07-98: Dead keys redone, aeb@cwi.nl.
 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
 */

J
Jan Engelhardt 已提交
27
#include <linux/consolemap.h>
L
Linus Torvalds 已提交
28 29 30 31 32 33 34 35
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/slab.h>
36
#include <linux/irq.h>
L
Linus Torvalds 已提交
37 38 39 40

#include <linux/kbd_kern.h>
#include <linux/kbd_diacr.h>
#include <linux/vt_kern.h>
S
Samuel Thibault 已提交
41
#include <linux/consolemap.h>
L
Linus Torvalds 已提交
42 43
#include <linux/sysrq.h>
#include <linux/input.h>
A
Adrian Bunk 已提交
44
#include <linux/reboot.h>
L
Linus Torvalds 已提交
45 46 47 48 49 50 51 52 53 54 55 56

extern void ctrl_alt_del(void);

/*
 * Exported functions/variables
 */

#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))

/*
 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
 * This seems a good reason to start with NumLock off. On HIL keyboards
57
 * of PARISC machines however there is no NumLock key and everyone expects the keypad
L
Linus Torvalds 已提交
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
 * to be used for numbers.
 */

#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
#define KBD_DEFLEDS (1 << VC_NUMLOCK)
#else
#define KBD_DEFLEDS 0
#endif

#define KBD_DEFLOCK 0

void compute_shiftstate(void);

/*
 * Handler Tables.
 */

#define K_HANDLERS\
	k_self,		k_fn,		k_spec,		k_pad,\
	k_dead,		k_cons,		k_cur,		k_shift,\
	k_meta,		k_ascii,	k_lock,		k_lowercase,\
79
	k_slock,	k_dead2,	k_brl,		k_ignore
L
Linus Torvalds 已提交
80

81
typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
82
			    char up_flag);
L
Linus Torvalds 已提交
83 84 85 86
static k_handler_fn K_HANDLERS;
static k_handler_fn *k_handler[16] = { K_HANDLERS };

#define FN_HANDLERS\
87 88 89 90 91
	fn_null,	fn_enter,	fn_show_ptregs,	fn_show_mem,\
	fn_show_state,	fn_send_intr,	fn_lastcons,	fn_caps_toggle,\
	fn_num,		fn_hold,	fn_scroll_forw,	fn_scroll_back,\
	fn_boot_it,	fn_caps_on,	fn_compose,	fn_SAK,\
	fn_dec_console, fn_inc_console, fn_spawn_con,	fn_bare_num
L
Linus Torvalds 已提交
92

93
typedef void (fn_handler_fn)(struct vc_data *vc);
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102 103 104
static fn_handler_fn FN_HANDLERS;
static fn_handler_fn *fn_handler[] = { FN_HANDLERS };

/*
 * Variables exported for vt_ioctl.c
 */

/* maximum values each key_handler can handle */
const int max_vals[] = {
	255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
	NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
105
	255, NR_LOCK - 1, 255, NR_BRL - 1
L
Linus Torvalds 已提交
106 107 108 109 110 111 112
};

const int NR_TYPES = ARRAY_SIZE(max_vals);

struct kbd_struct kbd_table[MAX_NR_CONSOLES];
static struct kbd_struct *kbd = kbd_table;

113
struct vt_spawn_console vt_spawn_con = {
114
	.lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
115 116 117
	.pid  = NULL,
	.sig  = 0,
};
L
Linus Torvalds 已提交
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133

/*
 * Variables exported for vt.c
 */

int shift_state = 0;

/*
 * Internal Data.
 */

static struct input_handler kbd_handler;
static unsigned long key_down[NBITS(KEY_MAX)];		/* keyboard key bitmap */
static unsigned char shift_down[NR_SHIFT];		/* shift state counters.. */
static int dead_key_next;
static int npadch = -1;					/* -1 or number assembled on pad */
134
static unsigned int diacr;
L
Linus Torvalds 已提交
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
static char rep;					/* flag telling character repeat */

static unsigned char ledstate = 0xff;			/* undefined */
static unsigned char ledioctl;

static struct ledptr {
	unsigned int *addr;
	unsigned int mask;
	unsigned char valid:1;
} ledptrs[3];

/* Simple translation table for the SysRq keys */

#ifdef CONFIG_MAGIC_SYSRQ
unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
        "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
        "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
        "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
        "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
        "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
        "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
        "\r\000/";                                      /* 0x60 - 0x6f */
static int sysrq_down;
158
static int sysrq_alt_use;
L
Linus Torvalds 已提交
159 160 161 162
#endif
static int sysrq_alt;

/*
163 164 165 166 167 168 169
 * Translation of scancodes to keycodes. We set them on only the first
 * keyboard in the list that accepts the scancode and keycode.
 * Explanation for not choosing the first attached keyboard anymore:
 *  USB keyboards for example have two event devices: one for all "normal"
 *  keys and one for extra function keys (like "volume up", "make coffee",
 *  etc.). So this means that scancodes for the extra function keys won't
 *  be valid for the first event device, but will be for the second.
L
Linus Torvalds 已提交
170 171 172
 */
int getkeycode(unsigned int scancode)
{
173 174 175 176 177 178 179 180
	struct input_handle *handle;
	int keycode;
	int error = -ENODEV;

	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
		error = handle->dev->getkeycode(handle->dev, scancode, &keycode);
		if (!error)
			return keycode;
L
Linus Torvalds 已提交
181 182
	}

183
	return error;
L
Linus Torvalds 已提交
184 185 186 187
}

int setkeycode(unsigned int scancode, unsigned int keycode)
{
188 189 190 191 192 193
	struct input_handle *handle;
	int error = -ENODEV;

	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
		error = handle->dev->setkeycode(handle->dev, scancode, keycode);
		if (!error)
194
			break;
L
Linus Torvalds 已提交
195 196
	}

197
	return error;
L
Linus Torvalds 已提交
198 199 200
}

/*
201
 * Making beeps and bells.
L
Linus Torvalds 已提交
202 203 204
 */
static void kd_nosound(unsigned long ignored)
{
205
	struct input_handle *handle;
L
Linus Torvalds 已提交
206

207
	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
L
Linus Torvalds 已提交
208 209
		if (test_bit(EV_SND, handle->dev->evbit)) {
			if (test_bit(SND_TONE, handle->dev->sndbit))
210
				input_inject_event(handle, EV_SND, SND_TONE, 0);
L
Linus Torvalds 已提交
211
			if (test_bit(SND_BELL, handle->dev->sndbit))
212
				input_inject_event(handle, EV_SND, SND_BELL, 0);
L
Linus Torvalds 已提交
213 214 215 216
		}
	}
}

217
static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
L
Linus Torvalds 已提交
218 219 220

void kd_mksound(unsigned int hz, unsigned int ticks)
{
221
	struct list_head *node;
L
Linus Torvalds 已提交
222 223 224 225

	del_timer(&kd_mksound_timer);

	if (hz) {
226
		list_for_each_prev(node, &kbd_handler.h_list) {
L
Linus Torvalds 已提交
227 228 229
			struct input_handle *handle = to_handle_h(node);
			if (test_bit(EV_SND, handle->dev->evbit)) {
				if (test_bit(SND_TONE, handle->dev->sndbit)) {
230
					input_inject_event(handle, EV_SND, SND_TONE, hz);
L
Linus Torvalds 已提交
231 232 233
					break;
				}
				if (test_bit(SND_BELL, handle->dev->sndbit)) {
234
					input_inject_event(handle, EV_SND, SND_BELL, 1);
L
Linus Torvalds 已提交
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
					break;
				}
			}
		}
		if (ticks)
			mod_timer(&kd_mksound_timer, jiffies + ticks);
	} else
		kd_nosound(0);
}

/*
 * Setting the keyboard rate.
 */

int kbd_rate(struct kbd_repeat *rep)
{
	struct list_head *node;
	unsigned int d = 0;
	unsigned int p = 0;

255
	list_for_each(node, &kbd_handler.h_list) {
L
Linus Torvalds 已提交
256 257 258 259 260
		struct input_handle *handle = to_handle_h(node);
		struct input_dev *dev = handle->dev;

		if (test_bit(EV_REP, dev->evbit)) {
			if (rep->delay > 0)
261
				input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
L
Linus Torvalds 已提交
262
			if (rep->period > 0)
263
				input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
L
Linus Torvalds 已提交
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
			d = dev->rep[REP_DELAY];
			p = dev->rep[REP_PERIOD];
		}
	}
	rep->delay  = d;
	rep->period = p;
	return 0;
}

/*
 * Helper Functions.
 */
static void put_queue(struct vc_data *vc, int ch)
{
	struct tty_struct *tty = vc->vc_tty;

	if (tty) {
		tty_insert_flip_char(tty, ch, 0);
		con_schedule_flip(tty);
	}
}

static void puts_queue(struct vc_data *vc, char *cp)
{
	struct tty_struct *tty = vc->vc_tty;

	if (!tty)
		return;

	while (*cp) {
		tty_insert_flip_char(tty, *cp, 0);
		cp++;
	}
	con_schedule_flip(tty);
}

static void applkey(struct vc_data *vc, int key, char mode)
{
	static char buf[] = { 0x1b, 'O', 0x00, 0x00 };

	buf[1] = (mode ? 'O' : '[');
	buf[2] = key;
	puts_queue(vc, buf);
}

/*
 * Many other routines do put_queue, but I think either
 * they produce ASCII, or they produce some user-assigned
 * string, and in both cases we might assume that it is
J
Jan Engelhardt 已提交
313
 * in utf-8 already.
L
Linus Torvalds 已提交
314
 */
J
Jan Engelhardt 已提交
315
static void to_utf8(struct vc_data *vc, uint c)
L
Linus Torvalds 已提交
316 317 318 319
{
	if (c < 0x80)
		/*  0******* */
		put_queue(vc, c);
320
	else if (c < 0x800) {
L
Linus Torvalds 已提交
321
		/* 110***** 10****** */
322
		put_queue(vc, 0xc0 | (c >> 6));
L
Linus Torvalds 已提交
323
		put_queue(vc, 0x80 | (c & 0x3f));
J
Jan Engelhardt 已提交
324 325 326 327 328
    	} else if (c < 0x10000) {
	       	if (c >= 0xD800 && c < 0xE000)
			return;
		if (c == 0xFFFF)
			return;
L
Linus Torvalds 已提交
329 330 331 332
		/* 1110**** 10****** 10****** */
		put_queue(vc, 0xe0 | (c >> 12));
		put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
		put_queue(vc, 0x80 | (c & 0x3f));
J
Jan Engelhardt 已提交
333 334 335 336 337 338
    	} else if (c < 0x110000) {
		/* 11110*** 10****** 10****** 10****** */
		put_queue(vc, 0xf0 | (c >> 18));
		put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
		put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
		put_queue(vc, 0x80 | (c & 0x3f));
339
	}
L
Linus Torvalds 已提交
340 341
}

342
/*
L
Linus Torvalds 已提交
343 344 345 346 347 348 349 350 351 352
 * Called after returning from RAW mode or when changing consoles - recompute
 * shift_down[] and shift_state from key_down[] maybe called when keymap is
 * undefined, so that shiftkey release is seen
 */
void compute_shiftstate(void)
{
	unsigned int i, j, k, sym, val;

	shift_state = 0;
	memset(shift_down, 0, sizeof(shift_down));
353

L
Linus Torvalds 已提交
354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
	for (i = 0; i < ARRAY_SIZE(key_down); i++) {

		if (!key_down[i])
			continue;

		k = i * BITS_PER_LONG;

		for (j = 0; j < BITS_PER_LONG; j++, k++) {

			if (!test_bit(k, key_down))
				continue;

			sym = U(key_maps[0][k]);
			if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
				continue;

			val = KVAL(sym);
			if (val == KVAL(K_CAPSSHIFT))
				val = KVAL(K_SHIFT);

			shift_down[val]++;
			shift_state |= (1 << val);
		}
	}
}

/*
 * We have a combining character DIACR here, followed by the character CH.
 * If the combination occurs in the table, return the corresponding value.
 * Otherwise, if CH is a space or equals DIACR, return DIACR.
 * Otherwise, conclude that DIACR was not combining after all,
 * queue it and return CH.
 */
387
static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
L
Linus Torvalds 已提交
388
{
389
	unsigned int d = diacr;
L
Linus Torvalds 已提交
390 391 392 393
	unsigned int i;

	diacr = 0;

394 395 396 397 398 399 400
	if ((d & ~0xff) == BRL_UC_ROW) {
		if ((ch & ~0xff) == BRL_UC_ROW)
			return d | ch;
	} else {
		for (i = 0; i < accent_table_size; i++)
			if (accent_table[i].diacr == d && accent_table[i].base == ch)
				return accent_table[i].result;
L
Linus Torvalds 已提交
401 402
	}

403
	if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
L
Linus Torvalds 已提交
404 405
		return d;

406
	if (kbd->kbdmode == VC_UNICODE)
S
Samuel Thibault 已提交
407 408 409 410 411 412
		to_utf8(vc, d);
	else {
		int c = conv_uni_to_8bit(d);
		if (c != -1)
			put_queue(vc, c);
	}
413

L
Linus Torvalds 已提交
414 415 416 417 418 419
	return ch;
}

/*
 * Special function handlers
 */
420
static void fn_enter(struct vc_data *vc)
L
Linus Torvalds 已提交
421 422
{
	if (diacr) {
423
		if (kbd->kbdmode == VC_UNICODE)
S
Samuel Thibault 已提交
424 425 426 427 428 429
			to_utf8(vc, diacr);
		else {
			int c = conv_uni_to_8bit(diacr);
			if (c != -1)
				put_queue(vc, c);
		}
L
Linus Torvalds 已提交
430 431 432 433 434 435 436
		diacr = 0;
	}
	put_queue(vc, 13);
	if (vc_kbd_mode(kbd, VC_CRLF))
		put_queue(vc, 10);
}

437
static void fn_caps_toggle(struct vc_data *vc)
L
Linus Torvalds 已提交
438 439 440 441 442 443
{
	if (rep)
		return;
	chg_vc_kbd_led(kbd, VC_CAPSLOCK);
}

444
static void fn_caps_on(struct vc_data *vc)
L
Linus Torvalds 已提交
445 446 447 448 449 450
{
	if (rep)
		return;
	set_vc_kbd_led(kbd, VC_CAPSLOCK);
}

451
static void fn_show_ptregs(struct vc_data *vc)
L
Linus Torvalds 已提交
452
{
453
	struct pt_regs *regs = get_irq_regs();
L
Linus Torvalds 已提交
454 455 456 457
	if (regs)
		show_regs(regs);
}

458
static void fn_hold(struct vc_data *vc)
L
Linus Torvalds 已提交
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
{
	struct tty_struct *tty = vc->vc_tty;

	if (rep || !tty)
		return;

	/*
	 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
	 * these routines are also activated by ^S/^Q.
	 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
	 */
	if (tty->stopped)
		start_tty(tty);
	else
		stop_tty(tty);
}

476
static void fn_num(struct vc_data *vc)
L
Linus Torvalds 已提交
477 478 479 480
{
	if (vc_kbd_mode(kbd,VC_APPLIC))
		applkey(vc, 'P', 1);
	else
481
		fn_bare_num(vc);
L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489
}

/*
 * Bind this to Shift-NumLock if you work in application keypad mode
 * but want to be able to change the NumLock flag.
 * Bind this to NumLock if you prefer that the NumLock key always
 * changes the NumLock flag.
 */
490
static void fn_bare_num(struct vc_data *vc)
L
Linus Torvalds 已提交
491 492 493 494 495
{
	if (!rep)
		chg_vc_kbd_led(kbd, VC_NUMLOCK);
}

496
static void fn_lastcons(struct vc_data *vc)
L
Linus Torvalds 已提交
497 498 499 500 501
{
	/* switch to the last used console, ChN */
	set_console(last_console);
}

502
static void fn_dec_console(struct vc_data *vc)
L
Linus Torvalds 已提交
503 504 505 506 507 508 509
{
	int i, cur = fg_console;

	/* Currently switching?  Queue this next switch relative to that. */
	if (want_console != -1)
		cur = want_console;

510
	for (i = cur - 1; i != cur; i--) {
L
Linus Torvalds 已提交
511
		if (i == -1)
512
			i = MAX_NR_CONSOLES - 1;
L
Linus Torvalds 已提交
513 514 515 516 517 518
		if (vc_cons_allocated(i))
			break;
	}
	set_console(i);
}

519
static void fn_inc_console(struct vc_data *vc)
L
Linus Torvalds 已提交
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
{
	int i, cur = fg_console;

	/* Currently switching?  Queue this next switch relative to that. */
	if (want_console != -1)
		cur = want_console;

	for (i = cur+1; i != cur; i++) {
		if (i == MAX_NR_CONSOLES)
			i = 0;
		if (vc_cons_allocated(i))
			break;
	}
	set_console(i);
}

536
static void fn_send_intr(struct vc_data *vc)
L
Linus Torvalds 已提交
537 538 539 540 541 542 543 544 545
{
	struct tty_struct *tty = vc->vc_tty;

	if (!tty)
		return;
	tty_insert_flip_char(tty, 0, TTY_BREAK);
	con_schedule_flip(tty);
}

546
static void fn_scroll_forw(struct vc_data *vc)
L
Linus Torvalds 已提交
547 548 549 550
{
	scrollfront(vc, 0);
}

551
static void fn_scroll_back(struct vc_data *vc)
L
Linus Torvalds 已提交
552 553 554 555
{
	scrollback(vc, 0);
}

556
static void fn_show_mem(struct vc_data *vc)
L
Linus Torvalds 已提交
557 558 559 560
{
	show_mem();
}

561
static void fn_show_state(struct vc_data *vc)
L
Linus Torvalds 已提交
562 563 564 565
{
	show_state();
}

566
static void fn_boot_it(struct vc_data *vc)
L
Linus Torvalds 已提交
567 568 569 570
{
	ctrl_alt_del();
}

571
static void fn_compose(struct vc_data *vc)
L
Linus Torvalds 已提交
572 573 574 575
{
	dead_key_next = 1;
}

576
static void fn_spawn_con(struct vc_data *vc)
L
Linus Torvalds 已提交
577
{
578 579 580 581 582 583 584
	spin_lock(&vt_spawn_con.lock);
	if (vt_spawn_con.pid)
		if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
			put_pid(vt_spawn_con.pid);
			vt_spawn_con.pid = NULL;
		}
	spin_unlock(&vt_spawn_con.lock);
L
Linus Torvalds 已提交
585 586
}

587
static void fn_SAK(struct vc_data *vc)
L
Linus Torvalds 已提交
588
{
589 590
	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
	schedule_work(SAK_work);
L
Linus Torvalds 已提交
591 592
}

593
static void fn_null(struct vc_data *vc)
L
Linus Torvalds 已提交
594 595 596 597 598 599 600
{
	compute_shiftstate();
}

/*
 * Special key handlers
 */
601
static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
602 603 604
{
}

605
static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
606 607 608 609 610
{
	if (up_flag)
		return;
	if (value >= ARRAY_SIZE(fn_handler))
		return;
611 612
	if ((kbd->kbdmode == VC_RAW ||
	     kbd->kbdmode == VC_MEDIUMRAW) &&
L
Linus Torvalds 已提交
613 614
	     value != KVAL(K_SAK))
		return;		/* SAK is allowed even in raw mode */
615
	fn_handler[value](vc);
L
Linus Torvalds 已提交
616 617
}

618
static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
619 620 621 622
{
	printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
}

623
static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
L
Linus Torvalds 已提交
624 625 626 627 628 629 630 631 632 633 634 635
{
	if (up_flag)
		return;		/* no action, if this is a key release */

	if (diacr)
		value = handle_diacr(vc, value);

	if (dead_key_next) {
		dead_key_next = 0;
		diacr = value;
		return;
	}
636
	if (kbd->kbdmode == VC_UNICODE)
S
Samuel Thibault 已提交
637 638 639 640 641 642
		to_utf8(vc, value);
	else {
		int c = conv_uni_to_8bit(value);
		if (c != -1)
			put_queue(vc, c);
	}
L
Linus Torvalds 已提交
643 644 645 646 647 648 649
}

/*
 * Handle dead key. Note that we now may have several
 * dead keys modifying the same character. Very useful
 * for Vietnamese.
 */
650
static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
L
Linus Torvalds 已提交
651 652 653 654 655 656
{
	if (up_flag)
		return;
	diacr = (diacr ? handle_diacr(vc, value) : value);
}

657
static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
658
{
S
Samuel Thibault 已提交
659 660 661 662 663 664
	unsigned int uni;
	if (kbd->kbdmode == VC_UNICODE)
		uni = value;
	else
		uni = conv_8bit_to_uni(value);
	k_unicode(vc, uni, up_flag);
665 666
}

667
static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
668
{
669
	k_deadunicode(vc, value, up_flag);
670 671
}

L
Linus Torvalds 已提交
672 673 674
/*
 * Obsolete - for backwards compatibility only
 */
675
static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
676
{
677
	static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
L
Linus Torvalds 已提交
678
	value = ret_diacr[value];
679
	k_deadunicode(vc, value, up_flag);
L
Linus Torvalds 已提交
680 681
}

682
static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
683 684 685 686 687 688
{
	if (up_flag)
		return;
	set_console(value);
}

689
static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
690 691 692 693 694 695 696 697 698 699 700 701 702
{
	unsigned v;

	if (up_flag)
		return;
	v = value;
	if (v < ARRAY_SIZE(func_table)) {
		if (func_table[value])
			puts_queue(vc, func_table[value]);
	} else
		printk(KERN_ERR "k_fn called with value=%d\n", value);
}

703
static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
704
{
705
	static const char cur_chars[] = "BDCA";
L
Linus Torvalds 已提交
706 707 708 709 710 711

	if (up_flag)
		return;
	applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
}

712
static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
713
{
714 715
	static const char pad_chars[] = "0123456789+-*/\015,.?()#";
	static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
L
Linus Torvalds 已提交
716 717 718 719 720 721 722 723 724 725 726 727 728 729

	if (up_flag)
		return;		/* no action, if this is a key release */

	/* kludge... shift forces cursor/number keys */
	if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
		applkey(vc, app_map[value], 1);
		return;
	}

	if (!vc_kbd_led(kbd, VC_NUMLOCK))
		switch (value) {
			case KVAL(K_PCOMMA):
			case KVAL(K_PDOT):
730
				k_fn(vc, KVAL(K_REMOVE), 0);
L
Linus Torvalds 已提交
731 732
				return;
			case KVAL(K_P0):
733
				k_fn(vc, KVAL(K_INSERT), 0);
L
Linus Torvalds 已提交
734 735
				return;
			case KVAL(K_P1):
736
				k_fn(vc, KVAL(K_SELECT), 0);
L
Linus Torvalds 已提交
737 738
				return;
			case KVAL(K_P2):
739
				k_cur(vc, KVAL(K_DOWN), 0);
L
Linus Torvalds 已提交
740 741
				return;
			case KVAL(K_P3):
742
				k_fn(vc, KVAL(K_PGDN), 0);
L
Linus Torvalds 已提交
743 744
				return;
			case KVAL(K_P4):
745
				k_cur(vc, KVAL(K_LEFT), 0);
L
Linus Torvalds 已提交
746 747
				return;
			case KVAL(K_P6):
748
				k_cur(vc, KVAL(K_RIGHT), 0);
L
Linus Torvalds 已提交
749 750
				return;
			case KVAL(K_P7):
751
				k_fn(vc, KVAL(K_FIND), 0);
L
Linus Torvalds 已提交
752 753
				return;
			case KVAL(K_P8):
754
				k_cur(vc, KVAL(K_UP), 0);
L
Linus Torvalds 已提交
755 756
				return;
			case KVAL(K_P9):
757
				k_fn(vc, KVAL(K_PGUP), 0);
L
Linus Torvalds 已提交
758 759 760 761 762 763 764 765 766 767 768
				return;
			case KVAL(K_P5):
				applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
				return;
		}

	put_queue(vc, pad_chars[value]);
	if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
		put_queue(vc, 10);
}

769
static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
{
	int old_state = shift_state;

	if (rep)
		return;
	/*
	 * Mimic typewriter:
	 * a CapsShift key acts like Shift but undoes CapsLock
	 */
	if (value == KVAL(K_CAPSSHIFT)) {
		value = KVAL(K_SHIFT);
		if (!up_flag)
			clr_vc_kbd_led(kbd, VC_CAPSLOCK);
	}

	if (up_flag) {
		/*
		 * handle the case that two shift or control
		 * keys are depressed simultaneously
		 */
		if (shift_down[value])
			shift_down[value]--;
	} else
		shift_down[value]++;

	if (shift_down[value])
		shift_state |= (1 << value);
	else
		shift_state &= ~(1 << value);

	/* kludge */
	if (up_flag && shift_state != old_state && npadch != -1) {
		if (kbd->kbdmode == VC_UNICODE)
J
Jan Engelhardt 已提交
803
			to_utf8(vc, npadch);
L
Linus Torvalds 已提交
804 805 806 807 808 809
		else
			put_queue(vc, npadch & 0xff);
		npadch = -1;
	}
}

810
static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
811 812 813 814 815 816 817 818 819 820 821
{
	if (up_flag)
		return;

	if (vc_kbd_mode(kbd, VC_META)) {
		put_queue(vc, '\033');
		put_queue(vc, value);
	} else
		put_queue(vc, value | 0x80);
}

822
static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
{
	int base;

	if (up_flag)
		return;

	if (value < 10) {
		/* decimal input of code, while Alt depressed */
		base = 10;
	} else {
		/* hexadecimal input of code, while AltGr depressed */
		value -= 10;
		base = 16;
	}

	if (npadch == -1)
		npadch = value;
	else
		npadch = npadch * base + value;
}

844
static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
845 846 847 848 849 850
{
	if (up_flag || rep)
		return;
	chg_vc_kbd_lock(kbd, value);
}

851
static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
L
Linus Torvalds 已提交
852
{
853
	k_shift(vc, value, up_flag);
L
Linus Torvalds 已提交
854 855 856 857 858 859 860 861 862 863
	if (up_flag || rep)
		return;
	chg_vc_kbd_slock(kbd, value);
	/* try to make Alt, oops, AltGr and such work */
	if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
		kbd->slockstate = 0;
		chg_vc_kbd_slock(kbd, value);
	}
}

864
/* by default, 300ms interval for combination release */
865 866 867 868 869 870 871 872
static unsigned brl_timeout = 300;
MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
module_param(brl_timeout, uint, 0644);

static unsigned brl_nbchords = 1;
MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
module_param(brl_nbchords, uint, 0644);

873
static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
874 875 876 877 878
{
	static unsigned long chords;
	static unsigned committed;

	if (!brl_nbchords)
879
		k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
880 881 882 883
	else {
		committed |= pattern;
		chords++;
		if (chords == brl_nbchords) {
884
			k_unicode(vc, BRL_UC_ROW | committed, up_flag);
885 886 887 888 889 890
			chords = 0;
			committed = 0;
		}
	}
}

891
static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
892 893 894 895 896 897 898 899 900 901 902
{
	static unsigned pressed,committing;
	static unsigned long releasestart;

	if (kbd->kbdmode != VC_UNICODE) {
		if (!up_flag)
			printk("keyboard mode must be unicode for braille patterns\n");
		return;
	}

	if (!value) {
903
		k_unicode(vc, BRL_UC_ROW, up_flag);
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
		return;
	}

	if (value > 8)
		return;

	if (up_flag) {
		if (brl_timeout) {
			if (!committing ||
			    jiffies - releasestart > (brl_timeout * HZ) / 1000) {
				committing = pressed;
				releasestart = jiffies;
			}
			pressed &= ~(1 << (value - 1));
			if (!pressed) {
				if (committing) {
920
					k_brlcommit(vc, committing, 0);
921 922 923 924 925
					committing = 0;
				}
			}
		} else {
			if (committing) {
926
				k_brlcommit(vc, committing, 0);
927 928 929 930 931 932 933 934 935 936 937
				committing = 0;
			}
			pressed &= ~(1 << (value - 1));
		}
	} else {
		pressed |= 1 << (value - 1);
		if (!brl_timeout)
			committing = pressed;
	}
}

L
Linus Torvalds 已提交
938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
/*
 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
 * or (ii) whatever pattern of lights people want to show using KDSETLED,
 * or (iii) specified bits of specified words in kernel memory.
 */
unsigned char getledstate(void)
{
	return ledstate;
}

void setledstate(struct kbd_struct *kbd, unsigned int led)
{
	if (!(led & ~7)) {
		ledioctl = led;
		kbd->ledmode = LED_SHOW_IOCTL;
	} else
		kbd->ledmode = LED_SHOW_FLAGS;
	set_leds();
}

static inline unsigned char getleds(void)
{
	struct kbd_struct *kbd = kbd_table + fg_console;
	unsigned char leds;
	int i;

	if (kbd->ledmode == LED_SHOW_IOCTL)
		return ledioctl;

	leds = kbd->ledflagstate;

	if (kbd->ledmode == LED_SHOW_MEM) {
		for (i = 0; i < 3; i++)
			if (ledptrs[i].valid) {
				if (*ledptrs[i].addr & ledptrs[i].mask)
					leds |= (1 << i);
				else
					leds &= ~(1 << i);
			}
	}
	return leds;
}

/*
 * This routine is the bottom half of the keyboard interrupt
 * routine, and runs with all interrupts enabled. It does
 * console changing, led setting and copy_to_cooked, which can
 * take a reasonably long time.
 *
 * Aside from timing (which isn't really that important for
 * keyboard interrupts as they happen often), using the software
 * interrupt routines for this thing allows us to easily mask
 * this when we don't want any of the above to happen.
 * This allows for easy and efficient race-condition prevention
992
 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
L
Linus Torvalds 已提交
993 994 995 996
 */

static void kbd_bh(unsigned long dummy)
{
997
	struct list_head *node;
L
Linus Torvalds 已提交
998 999 1000
	unsigned char leds = getleds();

	if (leds != ledstate) {
1001
		list_for_each(node, &kbd_handler.h_list) {
1002 1003 1004 1005 1006
			struct input_handle *handle = to_handle_h(node);
			input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
			input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
			input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
			input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
L
Linus Torvalds 已提交
1007 1008 1009 1010 1011 1012 1013 1014 1015
		}
	}

	ledstate = leds;
}

DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);

#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1016 1017
    defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
    defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
L
Linus Torvalds 已提交
1018 1019 1020 1021 1022
    (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))

#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
			((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))

1023
static const unsigned short x86_keycodes[256] =
L
Linus Torvalds 已提交
1024 1025 1026 1027 1028 1029
	{ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
	 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
	 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
	 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
	 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
	 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1030
	284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
L
Linus Torvalds 已提交
1031 1032
	367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
	360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1033 1034
	103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
	291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039
	264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
	377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
	308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
	332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };

1040
#ifdef CONFIG_SPARC
L
Linus Torvalds 已提交
1041 1042 1043 1044
static int sparc_l1_a_state = 0;
extern void sun_do_break(void);
#endif

1045
static int emulate_raw(struct vc_data *vc, unsigned int keycode,
L
Linus Torvalds 已提交
1046 1047
		       unsigned char up_flag)
{
1048
	int code;
L
Linus Torvalds 已提交
1049 1050 1051 1052 1053 1054

	switch (keycode) {
		case KEY_PAUSE:
			put_queue(vc, 0xe1);
			put_queue(vc, 0x1d | up_flag);
			put_queue(vc, 0x45 | up_flag);
1055 1056
			break;

1057
		case KEY_HANGEUL:
1058 1059
			if (!up_flag)
				put_queue(vc, 0xf2);
1060 1061
			break;

L
Linus Torvalds 已提交
1062
		case KEY_HANJA:
1063 1064
			if (!up_flag)
				put_queue(vc, 0xf1);
1065
			break;
L
Linus Torvalds 已提交
1066

1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
		case KEY_SYSRQ:
			/*
			 * Real AT keyboards (that's what we're trying
			 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
			 * pressing PrtSc/SysRq alone, but simply 0x54
			 * when pressing Alt+PrtSc/SysRq.
			 */
			if (sysrq_alt) {
				put_queue(vc, 0x54 | up_flag);
			} else {
				put_queue(vc, 0xe0);
				put_queue(vc, 0x2a | up_flag);
				put_queue(vc, 0xe0);
				put_queue(vc, 0x37 | up_flag);
			}
			break;

		default:
			if (keycode > 255)
				return -1;
L
Linus Torvalds 已提交
1087

1088 1089 1090
			code = x86_keycodes[keycode];
			if (!code)
				return -1;
L
Linus Torvalds 已提交
1091

1092 1093 1094
			if (code & 0x100)
				put_queue(vc, 0xe0);
			put_queue(vc, (code & 0x7f) | up_flag);
L
Linus Torvalds 已提交
1095

1096
			break;
L
Linus Torvalds 已提交
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
	}

	return 0;
}

#else

#define HW_RAW(dev)	0

#warning "Cannot generate rawmode keyboard for your architecture yet."

static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
{
	if (keycode > 127)
		return -1;

	put_queue(vc, keycode | up_flag);
	return 0;
}
#endif

static void kbd_rawcode(unsigned char data)
{
	struct vc_data *vc = vc_cons[fg_console].d;
	kbd = kbd_table + fg_console;
	if (kbd->kbdmode == VC_RAW)
		put_queue(vc, data);
}

1126
static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
L
Linus Torvalds 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
{
	struct vc_data *vc = vc_cons[fg_console].d;
	unsigned short keysym, *key_map;
	unsigned char type, raw_mode;
	struct tty_struct *tty;
	int shift_final;

	tty = vc->vc_tty;

	if (tty && (!tty->driver_data)) {
		/* No driver data? Strange. Okay we fix it then. */
		tty->driver_data = vc;
	}

	kbd = kbd_table + fg_console;

	if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1144
		sysrq_alt = down ? keycode : 0;
1145
#ifdef CONFIG_SPARC
L
Linus Torvalds 已提交
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
	if (keycode == KEY_STOP)
		sparc_l1_a_state = down;
#endif

	rep = (down == 2);

#ifdef CONFIG_MAC_EMUMOUSEBTN
	if (mac_hid_mouse_emulate_buttons(1, keycode, down))
		return;
#endif /* CONFIG_MAC_EMUMOUSEBTN */

	if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
		if (emulate_raw(vc, keycode, !down << 7))
1159
			if (keycode < BTN_MISC && printk_ratelimit())
L
Linus Torvalds 已提交
1160 1161 1162 1163
				printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);

#ifdef CONFIG_MAGIC_SYSRQ	       /* Handle the SysRq Hack */
	if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1164 1165 1166 1167
		if (!sysrq_down) {
			sysrq_down = down;
			sysrq_alt_use = sysrq_alt;
		}
L
Linus Torvalds 已提交
1168 1169
		return;
	}
1170 1171
	if (sysrq_down && !down && keycode == sysrq_alt_use)
		sysrq_down = 0;
L
Linus Torvalds 已提交
1172
	if (sysrq_down && down && !rep) {
1173
		handle_sysrq(kbd_sysrq_xlate[keycode], tty);
L
Linus Torvalds 已提交
1174 1175 1176
		return;
	}
#endif
1177
#ifdef CONFIG_SPARC
L
Linus Torvalds 已提交
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
	if (keycode == KEY_A && sparc_l1_a_state) {
		sparc_l1_a_state = 0;
		sun_do_break();
	}
#endif

	if (kbd->kbdmode == VC_MEDIUMRAW) {
		/*
		 * This is extended medium raw mode, with keys above 127
		 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
		 * the 'up' flag if needed. 0 is reserved, so this shouldn't
		 * interfere with anything else. The two bytes after 0 will
		 * always have the up flag set not to interfere with older
		 * applications. This allows for 16384 different keycodes,
		 * which should be enough.
		 */
		if (keycode < 128) {
			put_queue(vc, keycode | (!down << 7));
		} else {
			put_queue(vc, !down << 7);
			put_queue(vc, (keycode >> 7) | 0x80);
			put_queue(vc, keycode | 0x80);
		}
		raw_mode = 1;
	}

	if (down)
		set_bit(keycode, key_down);
	else
		clear_bit(keycode, key_down);

1209 1210 1211
	if (rep &&
	    (!vc_kbd_mode(kbd, VC_REPEAT) ||
	     (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
L
Linus Torvalds 已提交
1212 1213
		/*
		 * Don't repeat a key if the input buffers are not empty and the
1214
		 * characters get aren't echoed locally. This makes key repeat
L
Linus Torvalds 已提交
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
		 * usable with slow applications and under heavy loads.
		 */
		return;
	}

	shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
	key_map = key_maps[shift_final];

	if (!key_map) {
		compute_shiftstate();
		kbd->slockstate = 0;
		return;
	}

	if (keycode > NR_KEYS)
1230 1231 1232 1233 1234 1235
		if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
			keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
		else
			return;
	else
		keysym = key_map[keycode];
L
Linus Torvalds 已提交
1236 1237 1238 1239

	type = KTYP(keysym);

	if (type < 0xf0) {
1240 1241
		if (down && !raw_mode)
			to_utf8(vc, keysym);
L
Linus Torvalds 已提交
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
		return;
	}

	type -= 0xf0;

	if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
		return;

	if (type == KT_LETTER) {
		type = KT_LATIN;
		if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
			key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
			if (key_map)
				keysym = key_map[keycode];
		}
	}

1259
	(*k_handler[type])(vc, keysym & 0xff, !down);
L
Linus Torvalds 已提交
1260 1261 1262 1263 1264

	if (type != KT_SLOCK)
		kbd->slockstate = 0;
}

1265
static void kbd_event(struct input_handle *handle, unsigned int event_type,
L
Linus Torvalds 已提交
1266 1267 1268 1269 1270
		      unsigned int event_code, int value)
{
	if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
		kbd_rawcode(value);
	if (event_type == EV_KEY)
1271
		kbd_keycode(event_code, value, HW_RAW(handle->dev));
L
Linus Torvalds 已提交
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
	tasklet_schedule(&keyboard_tasklet);
	do_poke_blanked_console = 1;
	schedule_console_callback();
}

/*
 * When a keyboard (or other input device) is found, the kbd_connect
 * function is called. The function then looks at the device, and if it
 * likes it, it can open it and get events from it. In this (kbd_connect)
 * function, we should decide which VT to bind that keyboard to initially.
 */
1283 1284
static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
			const struct input_device_id *id)
L
Linus Torvalds 已提交
1285 1286
{
	struct input_handle *handle;
1287
	int error;
L
Linus Torvalds 已提交
1288 1289 1290
	int i;

	for (i = KEY_RESERVED; i < BTN_MISC; i++)
1291 1292
		if (test_bit(i, dev->keybit))
			break;
L
Linus Torvalds 已提交
1293

1294
	if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1295
		return -ENODEV;
L
Linus Torvalds 已提交
1296

1297 1298
	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
	if (!handle)
1299
		return -ENOMEM;
L
Linus Torvalds 已提交
1300 1301 1302

	handle->dev = dev;
	handle->handler = handler;
1303
	handle->name = "kbd";
L
Linus Torvalds 已提交
1304

1305 1306 1307
	error = input_register_handle(handle);
	if (error)
		goto err_free_handle;
L
Linus Torvalds 已提交
1308

1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
	error = input_open_device(handle);
	if (error)
		goto err_unregister_handle;

	return 0;

 err_unregister_handle:
	input_unregister_handle(handle);
 err_free_handle:
	kfree(handle);
	return error;
L
Linus Torvalds 已提交
1320 1321 1322 1323 1324
}

static void kbd_disconnect(struct input_handle *handle)
{
	input_close_device(handle);
1325
	input_unregister_handle(handle);
L
Linus Torvalds 已提交
1326 1327 1328
	kfree(handle);
}

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
/*
 * Start keyboard handler on the new keyboard by refreshing LED state to
 * match the rest of the system.
 */
static void kbd_start(struct input_handle *handle)
{
	unsigned char leds = ledstate;

	tasklet_disable(&keyboard_tasklet);
	if (leds != 0xff) {
1339 1340 1341 1342
		input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
		input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
		input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
		input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1343 1344 1345 1346
	}
	tasklet_enable(&keyboard_tasklet);
}

D
Dmitry Torokhov 已提交
1347
static const struct input_device_id kbd_ids[] = {
L
Linus Torvalds 已提交
1348 1349 1350 1351
	{
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
                .evbit = { BIT(EV_KEY) },
        },
1352

L
Linus Torvalds 已提交
1353 1354 1355
	{
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
                .evbit = { BIT(EV_SND) },
1356
        },
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366

	{ },    /* Terminating entry */
};

MODULE_DEVICE_TABLE(input, kbd_ids);

static struct input_handler kbd_handler = {
	.event		= kbd_event,
	.connect	= kbd_connect,
	.disconnect	= kbd_disconnect,
1367
	.start		= kbd_start,
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373 1374
	.name		= "kbd",
	.id_table	= kbd_ids,
};

int __init kbd_init(void)
{
	int i;
1375
	int error;
L
Linus Torvalds 已提交
1376

1377 1378 1379 1380 1381 1382 1383 1384 1385
        for (i = 0; i < MAX_NR_CONSOLES; i++) {
		kbd_table[i].ledflagstate = KBD_DEFLEDS;
		kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
		kbd_table[i].ledmode = LED_SHOW_FLAGS;
		kbd_table[i].lockstate = KBD_DEFLOCK;
		kbd_table[i].slockstate = 0;
		kbd_table[i].modeflags = KBD_DEFMODE;
		kbd_table[i].kbdmode = VC_XLATE;
	}
L
Linus Torvalds 已提交
1386

1387 1388 1389
	error = input_register_handler(&kbd_handler);
	if (error)
		return error;
L
Linus Torvalds 已提交
1390 1391 1392 1393 1394 1395

	tasklet_enable(&keyboard_tasklet);
	tasklet_schedule(&keyboard_tasklet);

	return 0;
}