keyboard.c 33.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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
 *
Linus Torvalds's avatar
Linus Torvalds committed
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)
 */

Jan Engelhardt's avatar
Jan Engelhardt committed
27
#include <linux/consolemap.h>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
37
38
39
40
41
42

#include <linux/kbd_kern.h>
#include <linux/kbd_diacr.h>
#include <linux/vt_kern.h>
#include <linux/sysrq.h>
#include <linux/input.h>
Adrian Bunk's avatar
Adrian Bunk committed
43
#include <linux/reboot.h>
44
#include <linux/notifier.h>
45
#include <linux/jiffies.h>
Linus Torvalds's avatar
Linus Torvalds committed
46
47
48

extern void ctrl_alt_del(void);

Joe Perches's avatar
Joe Perches committed
49
50
#define to_handle_h(n) container_of(n, struct input_handle, h_node)

Linus Torvalds's avatar
Linus Torvalds committed
51
52
53
54
55
56
57
58
59
/*
 * 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
60
 * of PARISC machines however there is no NumLock key and everyone expects the keypad
Linus Torvalds's avatar
Linus Torvalds committed
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 * 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,\
82
	k_slock,	k_dead2,	k_brl,		k_ignore
Linus Torvalds's avatar
Linus Torvalds committed
83

84
typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
85
			    char up_flag);
Linus Torvalds's avatar
Linus Torvalds committed
86
static k_handler_fn K_HANDLERS;
87
88
k_handler_fn *k_handler[16] = { K_HANDLERS };
EXPORT_SYMBOL_GPL(k_handler);
Linus Torvalds's avatar
Linus Torvalds committed
89
90

#define FN_HANDLERS\
91
92
93
94
95
	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
Linus Torvalds's avatar
Linus Torvalds committed
96

97
typedef void (fn_handler_fn)(struct vc_data *vc);
Linus Torvalds's avatar
Linus Torvalds committed
98
99
100
101
102
103
104
105
106
107
108
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,
109
	255, NR_LOCK - 1, 255, NR_BRL - 1
Linus Torvalds's avatar
Linus Torvalds committed
110
111
112
113
114
};

const int NR_TYPES = ARRAY_SIZE(max_vals);

struct kbd_struct kbd_table[MAX_NR_CONSOLES];
115
EXPORT_SYMBOL_GPL(kbd_table);
Linus Torvalds's avatar
Linus Torvalds committed
116
117
static struct kbd_struct *kbd = kbd_table;

118
struct vt_spawn_console vt_spawn_con = {
119
	.lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
120
121
122
	.pid  = NULL,
	.sig  = 0,
};
Linus Torvalds's avatar
Linus Torvalds committed
123
124
125
126
127
128
129
130
131
132
133
134

/*
 * Variables exported for vt.c
 */

int shift_state = 0;

/*
 * Internal Data.
 */

static struct input_handler kbd_handler;
135
static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)];	/* keyboard key bitmap */
Linus Torvalds's avatar
Linus Torvalds committed
136
137
138
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 */
139
static unsigned int diacr;
Linus Torvalds's avatar
Linus Torvalds committed
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
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;
163
static int sysrq_alt_use;
Linus Torvalds's avatar
Linus Torvalds committed
164
165
166
#endif
static int sysrq_alt;

167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/*
 * Notifier list for console keyboard events
 */
static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);

int register_keyboard_notifier(struct notifier_block *nb)
{
	return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(register_keyboard_notifier);

int unregister_keyboard_notifier(struct notifier_block *nb)
{
	return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
}
EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);

Linus Torvalds's avatar
Linus Torvalds committed
184
/*
185
186
187
188
189
190
191
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
192
193
194
 */
int getkeycode(unsigned int scancode)
{
195
196
197
198
199
	struct input_handle *handle;
	int keycode;
	int error = -ENODEV;

	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
200
		error = input_get_keycode(handle->dev, scancode, &keycode);
201
202
		if (!error)
			return keycode;
Linus Torvalds's avatar
Linus Torvalds committed
203
204
	}

205
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
206
207
208
209
}

int setkeycode(unsigned int scancode, unsigned int keycode)
{
210
211
212
213
	struct input_handle *handle;
	int error = -ENODEV;

	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
214
		error = input_set_keycode(handle->dev, scancode, keycode);
215
		if (!error)
216
			break;
Linus Torvalds's avatar
Linus Torvalds committed
217
218
	}

219
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
220
221
222
}

/*
223
 * Making beeps and bells.
Linus Torvalds's avatar
Linus Torvalds committed
224
225
226
 */
static void kd_nosound(unsigned long ignored)
{
227
	struct input_handle *handle;
Linus Torvalds's avatar
Linus Torvalds committed
228

229
	list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
Linus Torvalds's avatar
Linus Torvalds committed
230
231
		if (test_bit(EV_SND, handle->dev->evbit)) {
			if (test_bit(SND_TONE, handle->dev->sndbit))
232
				input_inject_event(handle, EV_SND, SND_TONE, 0);
Linus Torvalds's avatar
Linus Torvalds committed
233
			if (test_bit(SND_BELL, handle->dev->sndbit))
234
				input_inject_event(handle, EV_SND, SND_BELL, 0);
Linus Torvalds's avatar
Linus Torvalds committed
235
236
237
238
		}
	}
}

239
static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
240
241
242

void kd_mksound(unsigned int hz, unsigned int ticks)
{
243
	struct list_head *node;
Linus Torvalds's avatar
Linus Torvalds committed
244
245
246
247

	del_timer(&kd_mksound_timer);

	if (hz) {
248
		list_for_each_prev(node, &kbd_handler.h_list) {
Linus Torvalds's avatar
Linus Torvalds committed
249
250
251
			struct input_handle *handle = to_handle_h(node);
			if (test_bit(EV_SND, handle->dev->evbit)) {
				if (test_bit(SND_TONE, handle->dev->sndbit)) {
252
					input_inject_event(handle, EV_SND, SND_TONE, hz);
Linus Torvalds's avatar
Linus Torvalds committed
253
254
255
					break;
				}
				if (test_bit(SND_BELL, handle->dev->sndbit)) {
256
					input_inject_event(handle, EV_SND, SND_BELL, 1);
Linus Torvalds's avatar
Linus Torvalds committed
257
258
259
260
261
262
263
264
265
					break;
				}
			}
		}
		if (ticks)
			mod_timer(&kd_mksound_timer, jiffies + ticks);
	} else
		kd_nosound(0);
}
266
EXPORT_SYMBOL(kd_mksound);
Linus Torvalds's avatar
Linus Torvalds committed
267
268
269
270
271
272
273
274
275
276
277

/*
 * Setting the keyboard rate.
 */

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

278
	list_for_each(node, &kbd_handler.h_list) {
Linus Torvalds's avatar
Linus Torvalds committed
279
280
281
282
283
		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)
284
				input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
Linus Torvalds's avatar
Linus Torvalds committed
285
			if (rep->period > 0)
286
				input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
Linus Torvalds's avatar
Linus Torvalds committed
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
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
			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
Jan Engelhardt's avatar
Jan Engelhardt committed
336
 * in utf-8 already.
Linus Torvalds's avatar
Linus Torvalds committed
337
 */
Jan Engelhardt's avatar
Jan Engelhardt committed
338
static void to_utf8(struct vc_data *vc, uint c)
Linus Torvalds's avatar
Linus Torvalds committed
339
340
341
342
{
	if (c < 0x80)
		/*  0******* */
		put_queue(vc, c);
343
	else if (c < 0x800) {
Linus Torvalds's avatar
Linus Torvalds committed
344
		/* 110***** 10****** */
345
		put_queue(vc, 0xc0 | (c >> 6));
Linus Torvalds's avatar
Linus Torvalds committed
346
		put_queue(vc, 0x80 | (c & 0x3f));
Jan Engelhardt's avatar
Jan Engelhardt committed
347
348
349
350
351
    	} else if (c < 0x10000) {
	       	if (c >= 0xD800 && c < 0xE000)
			return;
		if (c == 0xFFFF)
			return;
Linus Torvalds's avatar
Linus Torvalds committed
352
353
354
355
		/* 1110**** 10****** 10****** */
		put_queue(vc, 0xe0 | (c >> 12));
		put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
		put_queue(vc, 0x80 | (c & 0x3f));
Jan Engelhardt's avatar
Jan Engelhardt committed
356
357
358
359
360
361
    	} 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));
362
	}
Linus Torvalds's avatar
Linus Torvalds committed
363
364
}

365
/*
Linus Torvalds's avatar
Linus Torvalds committed
366
367
368
369
370
371
372
373
374
375
 * 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));
376

Linus Torvalds's avatar
Linus Torvalds committed
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
	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.
 */
410
static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
Linus Torvalds's avatar
Linus Torvalds committed
411
{
412
	unsigned int d = diacr;
Linus Torvalds's avatar
Linus Torvalds committed
413
414
415
416
	unsigned int i;

	diacr = 0;

417
418
419
420
421
422
423
	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;
Linus Torvalds's avatar
Linus Torvalds committed
424
425
	}

426
	if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
Linus Torvalds's avatar
Linus Torvalds committed
427
428
		return d;

429
	if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault's avatar
Samuel Thibault committed
430
431
432
433
434
435
		to_utf8(vc, d);
	else {
		int c = conv_uni_to_8bit(d);
		if (c != -1)
			put_queue(vc, c);
	}
436

Linus Torvalds's avatar
Linus Torvalds committed
437
438
439
440
441
442
	return ch;
}

/*
 * Special function handlers
 */
443
static void fn_enter(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
444
445
{
	if (diacr) {
446
		if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault's avatar
Samuel Thibault committed
447
448
449
450
451
452
			to_utf8(vc, diacr);
		else {
			int c = conv_uni_to_8bit(diacr);
			if (c != -1)
				put_queue(vc, c);
		}
Linus Torvalds's avatar
Linus Torvalds committed
453
454
455
456
457
458
459
		diacr = 0;
	}
	put_queue(vc, 13);
	if (vc_kbd_mode(kbd, VC_CRLF))
		put_queue(vc, 10);
}

460
static void fn_caps_toggle(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
461
462
463
464
465
466
{
	if (rep)
		return;
	chg_vc_kbd_led(kbd, VC_CAPSLOCK);
}

467
static void fn_caps_on(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
468
469
470
471
472
473
{
	if (rep)
		return;
	set_vc_kbd_led(kbd, VC_CAPSLOCK);
}

474
static void fn_show_ptregs(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
475
{
476
	struct pt_regs *regs = get_irq_regs();
Linus Torvalds's avatar
Linus Torvalds committed
477
478
479
480
	if (regs)
		show_regs(regs);
}

481
static void fn_hold(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
{
	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);
}

499
static void fn_num(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
500
501
502
503
{
	if (vc_kbd_mode(kbd,VC_APPLIC))
		applkey(vc, 'P', 1);
	else
504
		fn_bare_num(vc);
Linus Torvalds's avatar
Linus Torvalds committed
505
506
507
508
509
510
511
512
}

/*
 * 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.
 */
513
static void fn_bare_num(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
514
515
516
517
518
{
	if (!rep)
		chg_vc_kbd_led(kbd, VC_NUMLOCK);
}

519
static void fn_lastcons(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
520
521
522
523
524
{
	/* switch to the last used console, ChN */
	set_console(last_console);
}

525
static void fn_dec_console(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
526
527
528
529
530
531
532
{
	int i, cur = fg_console;

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

533
	for (i = cur - 1; i != cur; i--) {
Linus Torvalds's avatar
Linus Torvalds committed
534
		if (i == -1)
535
			i = MAX_NR_CONSOLES - 1;
Linus Torvalds's avatar
Linus Torvalds committed
536
537
538
539
540
541
		if (vc_cons_allocated(i))
			break;
	}
	set_console(i);
}

542
static void fn_inc_console(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
{
	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);
}

559
static void fn_send_intr(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
560
561
562
563
564
565
566
567
568
{
	struct tty_struct *tty = vc->vc_tty;

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

569
static void fn_scroll_forw(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
570
571
572
573
{
	scrollfront(vc, 0);
}

574
static void fn_scroll_back(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
575
576
577
578
{
	scrollback(vc, 0);
}

579
static void fn_show_mem(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
580
581
582
583
{
	show_mem();
}

584
static void fn_show_state(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
585
586
587
588
{
	show_state();
}

589
static void fn_boot_it(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
590
591
592
593
{
	ctrl_alt_del();
}

594
static void fn_compose(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
595
596
597
598
{
	dead_key_next = 1;
}

599
static void fn_spawn_con(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
600
{
601
602
603
604
605
606
607
	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);
Linus Torvalds's avatar
Linus Torvalds committed
608
609
}

610
static void fn_SAK(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
611
{
612
613
	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
	schedule_work(SAK_work);
Linus Torvalds's avatar
Linus Torvalds committed
614
615
}

616
static void fn_null(struct vc_data *vc)
Linus Torvalds's avatar
Linus Torvalds committed
617
618
619
620
621
622
623
{
	compute_shiftstate();
}

/*
 * Special key handlers
 */
624
static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
625
626
627
{
}

628
static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
629
630
631
632
633
{
	if (up_flag)
		return;
	if (value >= ARRAY_SIZE(fn_handler))
		return;
634
635
	if ((kbd->kbdmode == VC_RAW ||
	     kbd->kbdmode == VC_MEDIUMRAW) &&
Linus Torvalds's avatar
Linus Torvalds committed
636
637
	     value != KVAL(K_SAK))
		return;		/* SAK is allowed even in raw mode */
638
	fn_handler[value](vc);
Linus Torvalds's avatar
Linus Torvalds committed
639
640
}

641
static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
642
643
644
645
{
	printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
}

646
static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
647
648
649
650
651
652
653
654
655
656
657
658
{
	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;
	}
659
	if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault's avatar
Samuel Thibault committed
660
661
662
663
664
665
		to_utf8(vc, value);
	else {
		int c = conv_uni_to_8bit(value);
		if (c != -1)
			put_queue(vc, c);
	}
Linus Torvalds's avatar
Linus Torvalds committed
666
667
668
669
670
671
672
}

/*
 * Handle dead key. Note that we now may have several
 * dead keys modifying the same character. Very useful
 * for Vietnamese.
 */
673
static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
674
675
676
677
678
679
{
	if (up_flag)
		return;
	diacr = (diacr ? handle_diacr(vc, value) : value);
}

680
static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
681
{
682
	k_unicode(vc, conv_8bit_to_uni(value), up_flag);
683
684
}

685
static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
686
{
687
	k_deadunicode(vc, value, up_flag);
688
689
}

Linus Torvalds's avatar
Linus Torvalds committed
690
691
692
/*
 * Obsolete - for backwards compatibility only
 */
693
static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
694
{
695
	static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
Linus Torvalds's avatar
Linus Torvalds committed
696
	value = ret_diacr[value];
697
	k_deadunicode(vc, value, up_flag);
Linus Torvalds's avatar
Linus Torvalds committed
698
699
}

700
static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
701
702
703
704
705
706
{
	if (up_flag)
		return;
	set_console(value);
}

707
static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
708
709
710
711
712
713
714
715
716
717
718
719
720
{
	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);
}

721
static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
722
{
723
	static const char cur_chars[] = "BDCA";
Linus Torvalds's avatar
Linus Torvalds committed
724
725
726
727
728
729

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

730
static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
731
{
732
733
	static const char pad_chars[] = "0123456789+-*/\015,.?()#";
	static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
Linus Torvalds's avatar
Linus Torvalds committed
734
735
736
737
738
739
740
741
742
743
744
745
746
747

	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):
748
				k_fn(vc, KVAL(K_REMOVE), 0);
Linus Torvalds's avatar
Linus Torvalds committed
749
750
				return;
			case KVAL(K_P0):
751
				k_fn(vc, KVAL(K_INSERT), 0);
Linus Torvalds's avatar
Linus Torvalds committed
752
753
				return;
			case KVAL(K_P1):
754
				k_fn(vc, KVAL(K_SELECT), 0);
Linus Torvalds's avatar
Linus Torvalds committed
755
756
				return;
			case KVAL(K_P2):
757
				k_cur(vc, KVAL(K_DOWN), 0);
Linus Torvalds's avatar
Linus Torvalds committed
758
759
				return;
			case KVAL(K_P3):
760
				k_fn(vc, KVAL(K_PGDN), 0);
Linus Torvalds's avatar
Linus Torvalds committed
761
762
				return;
			case KVAL(K_P4):
763
				k_cur(vc, KVAL(K_LEFT), 0);
Linus Torvalds's avatar
Linus Torvalds committed
764
765
				return;
			case KVAL(K_P6):
766
				k_cur(vc, KVAL(K_RIGHT), 0);
Linus Torvalds's avatar
Linus Torvalds committed
767
768
				return;
			case KVAL(K_P7):
769
				k_fn(vc, KVAL(K_FIND), 0);
Linus Torvalds's avatar
Linus Torvalds committed
770
771
				return;
			case KVAL(K_P8):
772
				k_cur(vc, KVAL(K_UP), 0);
Linus Torvalds's avatar
Linus Torvalds committed
773
774
				return;
			case KVAL(K_P9):
775
				k_fn(vc, KVAL(K_PGUP), 0);
Linus Torvalds's avatar
Linus Torvalds committed
776
777
778
779
780
781
782
783
784
785
786
				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);
}

787
static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
{
	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)
Jan Engelhardt's avatar
Jan Engelhardt committed
821
			to_utf8(vc, npadch);
Linus Torvalds's avatar
Linus Torvalds committed
822
823
824
825
826
827
		else
			put_queue(vc, npadch & 0xff);
		npadch = -1;
	}
}

828
static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
829
830
831
832
833
834
835
836
837
838
839
{
	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);
}

840
static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
{
	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;
}

862
static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
863
864
865
866
867
868
{
	if (up_flag || rep)
		return;
	chg_vc_kbd_lock(kbd, value);
}

869
static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds's avatar
Linus Torvalds committed
870
{
871
	k_shift(vc, value, up_flag);
Linus Torvalds's avatar
Linus Torvalds committed
872
873
874
875
876
877
878
879
880
881
	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);
	}
}

882
/* by default, 300ms interval for combination release */
883
884
885
886
887
888
889
890
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);

891
static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
892
893
894
895
896
{
	static unsigned long chords;
	static unsigned committed;

	if (!brl_nbchords)
897
		k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
898
899
900
901
	else {
		committed |= pattern;
		chords++;
		if (chords == brl_nbchords) {
902
			k_unicode(vc, BRL_UC_ROW | committed, up_flag);
903
904
905
906
907
908
			chords = 0;
			committed = 0;
		}
	}
}

909
static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
910
911
912
913
914
915
916
917
918
919
920
{
	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) {
921
		k_unicode(vc, BRL_UC_ROW, up_flag);
922
923
924
925
926
927
928
929
930
		return;
	}

	if (value > 8)
		return;

	if (up_flag) {
		if (brl_timeout) {
			if (!committing ||
931
932
			    time_after(jiffies,
				       releasestart + msecs_to_jiffies(brl_timeout))) {
933
934
935
936
937
938
				committing = pressed;
				releasestart = jiffies;
			}
			pressed &= ~(1 << (value - 1));
			if (!pressed) {
				if (committing) {
939
					k_brlcommit(vc, committing, 0);
940
941
942
943
944
					committing = 0;
				}
			}
		} else {
			if (committing) {
945
				k_brlcommit(vc, committing, 0);
946
947
948
949
950
951
952
953
954
955
956
				committing = 0;
			}
			pressed &= ~(1 << (value - 1));
		}
	} else {
		pressed |= 1 << (value - 1);
		if (!brl_timeout)
			committing = pressed;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
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
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
/*
 * 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
1011
 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
Linus Torvalds's avatar
Linus Torvalds committed
1012
1013
1014
1015
 */

static void kbd_bh(unsigned long dummy)
{
1016
	struct list_head *node;
Linus Torvalds's avatar
Linus Torvalds committed
1017
1018
1019
	unsigned char leds = getleds();

	if (leds != ledstate) {
1020
		list_for_each(node, &kbd_handler.h_list) {
1021
1022
1023
1024
1025
			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);
Linus Torvalds's avatar
Linus Torvalds committed
1026
1027
1028
1029
1030
1031
1032
1033
1034
		}
	}

	ledstate = leds;
}

DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);

#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1035
1036
    defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
    defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1037
1038
    (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
    defined(CONFIG_AVR32)
Linus Torvalds's avatar
Linus Torvalds committed
1039
1040
1041
1042

#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))

1043
static const unsigned short x86_keycodes[256] =
Linus Torvalds's avatar
Linus Torvalds committed
1044
1045
1046
1047
1048
1049
	{ 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,
1050
	284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
Linus Torvalds's avatar
Linus Torvalds committed
1051
1052
	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,
1053
1054
	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,
Linus Torvalds's avatar
Linus Torvalds committed
1055
1056
1057
1058
1059
	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 };

1060
#ifdef CONFIG_SPARC
Linus Torvalds's avatar
Linus Torvalds committed
1061
1062
1063
1064
static int sparc_l1_a_state = 0;
extern void sun_do_break(void);
#endif

1065
static int emulate_raw(struct vc_data *vc, unsigned int keycode,
Linus Torvalds's avatar
Linus Torvalds committed
1066
1067
		       unsigned char up_flag)
{
1068
	int code;
Linus Torvalds's avatar
Linus Torvalds committed
1069
1070
1071
1072
1073
1074

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

1077
		case KEY_HANGEUL:
1078
1079
			if (!up_flag)
				put_queue(vc, 0xf2);
1080
1081
			break;

Linus Torvalds's avatar
Linus Torvalds committed
1082
		case KEY_HANJA:
1083
1084
			if (!up_flag)
				put_queue(vc, 0xf1);
1085
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1086

1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
		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;
Linus Torvalds's avatar
Linus Torvalds committed
1107

1108
1109
1110
			code = x86_keycodes[keycode];
			if (!code)
				return -1;
Linus Torvalds's avatar
Linus Torvalds committed
1111

1112
1113
1114
			if (code & 0x100)
				put_queue(vc, 0xe0);
			put_queue(vc, (code & 0x7f) | up_flag);
Linus Torvalds's avatar
Linus Torvalds committed
1115

1116
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
	}

	return 0;
}

#else

#define HW_RAW(dev)	0

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);
}

1144
static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
Linus Torvalds's avatar
Linus Torvalds committed
1145
1146
1147
1148
1149
1150
{
	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;
1151
	struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
Linus Torvalds's avatar
Linus Torvalds committed
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162

	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)
1163
		sysrq_alt = down ? keycode : 0;
1164
#ifdef CONFIG_SPARC
Linus Torvalds's avatar
Linus Torvalds committed
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
	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))
1178
			if (keycode < BTN_MISC && printk_ratelimit())
Linus Torvalds's avatar
Linus Torvalds committed
1179
1180
1181
1182
				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))) {
1183
1184
1185
1186
		if (!sysrq_down) {
			sysrq_down = down;
			sysrq_alt_use = sysrq_alt;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1187
1188
		return;
	}
1189
1190
	if (sysrq_down && !down && keycode == sysrq_alt_use)
		sysrq_down = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1191
	if (sysrq_down && down && !rep) {
1192
		handle_sysrq(kbd_sysrq_xlate[keycode], tty);
Linus Torvalds's avatar
Linus Torvalds committed
1193
1194
1195
		return;
	}
#endif
1196
#ifdef CONFIG_SPARC
Linus Torvalds's avatar
Linus Torvalds committed
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
	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);

1228
1229
	if (rep &&
	    (!vc_kbd_mode(kbd, VC_REPEAT) ||
Alan Cox Cox's avatar
Alan Cox Cox committed
1230
	     (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
Linus Torvalds's avatar
Linus Torvalds committed
1231
1232
		/*
		 * Don't repeat a key if the input buffers are not empty and the
1233
		 * characters get aren't echoed locally. This makes key repeat
Linus Torvalds's avatar
Linus Torvalds committed
1234
1235
1236
1237
1238
		 * usable with slow applications and under heavy loads.
		 */
		return;
	}

1239
	param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1240
	param.ledstate = kbd->ledflagstate;
Linus Torvalds's avatar
Linus Torvalds committed
1241
1242
	key_map = key_maps[shift_final];

1243
1244
	if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYCODE, &param) == NOTIFY_STOP || !key_map) {
		atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNBOUND_KEYCODE, &param);
Linus Torvalds's avatar
Linus Torvalds committed
1245
1246
1247
1248
1249
		compute_shiftstate();
		kbd->slockstate = 0;
		return;
	}

1250
	if (keycode >= NR_KEYS)
1251
		if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1252
			keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1253
1254
1255
1256
		else
			return;
	else
		keysym = key_map[keycode];
Linus Torvalds's avatar
Linus Torvalds committed
1257
1258
1259
1260

	type = KTYP(keysym);

	if (type < 0xf0) {
1261
1262
1263
		param.value = keysym;
		if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNICODE, &param) == NOTIFY_STOP)
			return;
1264
1265
		if (down && !raw_mode)
			to_utf8(vc, keysym);
Linus Torvalds's avatar
Linus Torvalds committed
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
		return;
	}

	type -= 0xf0;

	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];
		}
	}
1279
1280
1281
1282
1283
1284
1285
	param.value = keysym;

	if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYSYM, &param) == NOTIFY_STOP)
		return;

	if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
1286

1287
	(*k_handler[type])(vc, keysym & 0xff, !down);
Linus Torvalds's avatar
Linus Torvalds committed
1288

1289
	param.ledstate = kbd->ledflagstate;
1290
1291
	atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);

Linus Torvalds's avatar
Linus Torvalds committed
1292
1293
1294
1295
	if (type != KT_SLOCK)
		kbd->slockstate = 0;
}

1296
static void kbd_event(struct input_handle *handle, unsigned int event_type,
Linus Torvalds's avatar
Linus Torvalds committed
1297
1298
1299
1300
1301
		      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)
1302
		kbd_keycode(event_code, value, HW_RAW(handle->dev));
Linus Torvalds's avatar
Linus Torvalds committed
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
	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.
 */
1314
1315
static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
			const struct input_device_id *id)
Linus Torvalds's avatar
Linus Torvalds committed
1316
1317
{
	struct input_handle *handle;
1318
	int error;
Linus Torvalds's avatar
Linus Torvalds committed
1319
1320
1321
	int i;

	for (i = KEY_RESERVED; i < BTN_MISC; i++)
1322
1323
		if (test_bit(i, dev->keybit))
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1324

1325
	if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1326
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
1327

1328
1329
	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
	if (!handle)
1330
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
1331
1332
1333

	handle->dev = dev;
	handle->handler = handler;
1334
	handle->name = "kbd";
Linus Torvalds's avatar
Linus Torvalds committed
1335

1336
1337
1338
	error = input_register_handle(handle);
	if (error)
		goto err_free_handle;
Linus Torvalds's avatar
Linus Torvalds committed
1339

1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
	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;
Linus Torvalds's avatar
Linus Torvalds committed
1351
1352
1353
1354
1355
}

static void kbd_disconnect(struct input_handle *handle)
{
	input_close_device(handle);
1356
	input_unregister_handle(handle);
Linus Torvalds's avatar
Linus Torvalds committed
1357
1358
1359
	kfree(handle);
}

1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
/*
 * 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) {
1370
1371
1372
1373
		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);
1374
1375
1376
1377
	}
	tasklet_enable(&keyboard_tasklet);
}

Dmitry Torokhov's avatar
Dmitry Torokhov committed
1378
static const struct input_device_id kbd_ids[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1379
1380
	{
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1381
                .evbit = { BIT_MASK(EV_KEY) },
Linus Torvalds's avatar
Linus Torvalds committed
1382
        },
1383

Linus Torvalds's avatar
Linus Torvalds committed
1384
1385
	{
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1386
                .evbit = { BIT_MASK(EV_SND) },