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