projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
[GitHub/mt8127/android_kernel_alcatel_ttab.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
LT		 597{
598 struct tty_struct *tty = vc->vc_tty;
599
600 /*
601 * SAK should also work in all raw modes and reset
602 * them properly.
603 */
604 if (tty)
605 do_SAK(tty);
606 reset_vc(vc);
607}
608
7d12e780 609static void fn_null(struct vc_data *vc)
1da177e4
LT		 610{
611 compute_shiftstate();
612}
613
614/*
615 * Special key handlers
616 */
7d12e780 617static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 618{
619}
620
7d12e780 621static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 622{
623 if (up_flag)
624 return;
625 if (value >= ARRAY_SIZE(fn_handler))
626 return;
fe1e8604
DT		 627 if ((kbd->kbdmode == VC_RAW ||
628 kbd->kbdmode == VC_MEDIUMRAW) &&
1da177e4
LT		 629 value != KVAL(K_SAK))
630 return; /* SAK is allowed even in raw mode */
7d12e780 631 fn_handler[value](vc);
1da177e4
LT		 632}
633
7d12e780 634static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 635{
636 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
637}
638
7d12e780 639static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
1da177e4
LT		 640{
641 if (up_flag)
642 return; /* no action, if this is a key release */
643
644 if (diacr)
645 value = handle_diacr(vc, value);
646
647 if (dead_key_next) {
648 dead_key_next = 0;
649 diacr = value;
650 return;
651 }
b9ec4e10
ST		 652 if (kbd->kbdmode == VC_UNICODE)
653 to_utf8(vc, value);
654 else if (value < 0x100)
655 put_queue(vc, value);
1da177e4
LT		 656}
657
658/*
659 * Handle dead key. Note that we now may have several
660 * dead keys modifying the same character. Very useful
661 * for Vietnamese.
662 */
7d12e780 663static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
1da177e4
LT		 664{
665 if (up_flag)
666 return;
667 diacr = (diacr ? handle_diacr(vc, value) : value);
668}
669
7d12e780 670static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
b9ec4e10 671{
7d12e780 672 k_unicode(vc, value, up_flag);
b9ec4e10
ST		 673}
674
7d12e780 675static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
b9ec4e10 676{
7d12e780 677 k_deadunicode(vc, value, up_flag);
b9ec4e10
ST		 678}
679
1da177e4
LT		 680/*
681 * Obsolete - for backwards compatibility only
682 */
7d12e780 683static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4 684{
0f5e560e 685 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
1da177e4 686 value = ret_diacr[value];
7d12e780 687 k_deadunicode(vc, value, up_flag);
1da177e4
LT		 688}
689
7d12e780 690static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 691{
692 if (up_flag)
693 return;
694 set_console(value);
695}
696
7d12e780 697static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 698{
699 unsigned v;
700
701 if (up_flag)
702 return;
703 v = value;
704 if (v < ARRAY_SIZE(func_table)) {
705 if (func_table[value])
706 puts_queue(vc, func_table[value]);
707 } else
708 printk(KERN_ERR "k_fn called with value=%d\n", value);
709}
710
7d12e780 711static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 712{
713 static const char *cur_chars = "BDCA";
714
715 if (up_flag)
716 return;
717 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
718}
719
7d12e780 720static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4 721{
0f5e560e
AM		 722 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
723 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
1da177e4
LT		 724
725 if (up_flag)
726 return; /* no action, if this is a key release */
727
728 /* kludge... shift forces cursor/number keys */
729 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
730 applkey(vc, app_map[value], 1);
731 return;
732 }
733
734 if (!vc_kbd_led(kbd, VC_NUMLOCK))
735 switch (value) {
736 case KVAL(K_PCOMMA):
737 case KVAL(K_PDOT):
7d12e780 738 k_fn(vc, KVAL(K_REMOVE), 0);
1da177e4
LT		 739 return;
740 case KVAL(K_P0):
7d12e780 741 k_fn(vc, KVAL(K_INSERT), 0);
1da177e4
LT		 742 return;
743 case KVAL(K_P1):
7d12e780 744 k_fn(vc, KVAL(K_SELECT), 0);
1da177e4
LT		 745 return;
746 case KVAL(K_P2):
7d12e780 747 k_cur(vc, KVAL(K_DOWN), 0);
1da177e4
LT		 748 return;
749 case KVAL(K_P3):
7d12e780 750 k_fn(vc, KVAL(K_PGDN), 0);
1da177e4
LT		 751 return;
752 case KVAL(K_P4):
7d12e780 753 k_cur(vc, KVAL(K_LEFT), 0);
1da177e4
LT		 754 return;
755 case KVAL(K_P6):
7d12e780 756 k_cur(vc, KVAL(K_RIGHT), 0);
1da177e4
LT		 757 return;
758 case KVAL(K_P7):
7d12e780 759 k_fn(vc, KVAL(K_FIND), 0);
1da177e4
LT		 760 return;
761 case KVAL(K_P8):
7d12e780 762 k_cur(vc, KVAL(K_UP), 0);
1da177e4
LT		 763 return;
764 case KVAL(K_P9):
7d12e780 765 k_fn(vc, KVAL(K_PGUP), 0);
1da177e4
LT		 766 return;
767 case KVAL(K_P5):
768 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
769 return;
770 }
771
772 put_queue(vc, pad_chars[value]);
773 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
774 put_queue(vc, 10);
775}
776
7d12e780 777static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 778{
779 int old_state = shift_state;
780
781 if (rep)
782 return;
783 /*
784 * Mimic typewriter:
785 * a CapsShift key acts like Shift but undoes CapsLock
786 */
787 if (value == KVAL(K_CAPSSHIFT)) {
788 value = KVAL(K_SHIFT);
789 if (!up_flag)
790 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
791 }
792
793 if (up_flag) {
794 /*
795 * handle the case that two shift or control
796 * keys are depressed simultaneously
797 */
798 if (shift_down[value])
799 shift_down[value]--;
800 } else
801 shift_down[value]++;
802
803 if (shift_down[value])
804 shift_state |= (1 << value);
805 else
806 shift_state &= ~(1 << value);
807
808 /* kludge */
809 if (up_flag && shift_state != old_state && npadch != -1) {
810 if (kbd->kbdmode == VC_UNICODE)
811 to_utf8(vc, npadch & 0xffff);
812 else
813 put_queue(vc, npadch & 0xff);
814 npadch = -1;
815 }
816}
817
7d12e780 818static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 819{
820 if (up_flag)
821 return;
822
823 if (vc_kbd_mode(kbd, VC_META)) {
824 put_queue(vc, '\033');
825 put_queue(vc, value);
826 } else
827 put_queue(vc, value | 0x80);
828}
829
7d12e780 830static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 831{
832 int base;
833
834 if (up_flag)
835 return;
836
837 if (value < 10) {
838 /* decimal input of code, while Alt depressed */
839 base = 10;
840 } else {
841 /* hexadecimal input of code, while AltGr depressed */
842 value -= 10;
843 base = 16;
844 }
845
846 if (npadch == -1)
847 npadch = value;
848 else
849 npadch = npadch * base + value;
850}
851
7d12e780 852static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4
LT		 853{
854 if (up_flag || rep)
855 return;
856 chg_vc_kbd_lock(kbd, value);
857}
858
7d12e780 859static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
1da177e4 860{
7d12e780 861 k_shift(vc, value, up_flag);
1da177e4
LT		 862 if (up_flag || rep)
863 return;
864 chg_vc_kbd_slock(kbd, value);
865 /* try to make Alt, oops, AltGr and such work */
866 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
867 kbd->slockstate = 0;
868 chg_vc_kbd_slock(kbd, value);
869 }
870}
871
b9ec4e10 872/* by default, 300ms interval for combination release */
77426d72
ST		 873static unsigned brl_timeout = 300;
874MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
875module_param(brl_timeout, uint, 0644);
876
877static unsigned brl_nbchords = 1;
878MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
879module_param(brl_nbchords, uint, 0644);
880
7d12e780 881static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
77426d72
ST		 882{
883 static unsigned long chords;
884 static unsigned committed;
885
886 if (!brl_nbchords)
7d12e780 887 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
77426d72
ST		 888 else {
889 committed |= pattern;
890 chords++;
891 if (chords == brl_nbchords) {
7d12e780 892 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
77426d72
ST		 893 chords = 0;
894 committed = 0;
895 }
896 }
897}
898
7d12e780 899static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
b9ec4e10
ST		 900{
901 static unsigned pressed,committing;
902 static unsigned long releasestart;
903
904 if (kbd->kbdmode != VC_UNICODE) {
905 if (!up_flag)
906 printk("keyboard mode must be unicode for braille patterns\n");
907 return;
908 }
909
910 if (!value) {
7d12e780 911 k_unicode(vc, BRL_UC_ROW, up_flag);
b9ec4e10
ST		 912 return;
913 }
914
915 if (value > 8)
916 return;
917
b9ec4e10
ST		 918 if (up_flag) {
919 if (brl_timeout) {
920 if (!committing ||
921 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
922 committing = pressed;
923 releasestart = jiffies;
924 }
925 pressed &= ~(1 << (value - 1));
926 if (!pressed) {
927 if (committing) {
7d12e780 928 k_brlcommit(vc, committing, 0);
b9ec4e10
ST		 929 committing = 0;
930 }
931 }
932 } else {
933 if (committing) {
7d12e780 934 k_brlcommit(vc, committing, 0);
b9ec4e10
ST		 935 committing = 0;
936 }
937 pressed &= ~(1 << (value - 1));
938 }
939 } else {
940 pressed |= 1 << (value - 1);
941 if (!brl_timeout)
942 committing = pressed;
943 }
944}
945
1da177e4
LT		 946/*
947 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
948 * or (ii) whatever pattern of lights people want to show using KDSETLED,
949 * or (iii) specified bits of specified words in kernel memory.
950 */
951unsigned char getledstate(void)
952{
953 return ledstate;
954}
955
956void setledstate(struct kbd_struct *kbd, unsigned int led)
957{
958 if (!(led & ~7)) {
959 ledioctl = led;
960 kbd->ledmode = LED_SHOW_IOCTL;
961 } else
962 kbd->ledmode = LED_SHOW_FLAGS;
963 set_leds();
964}
965
966static inline unsigned char getleds(void)
967{
968 struct kbd_struct *kbd = kbd_table + fg_console;
969 unsigned char leds;
970 int i;
971
972 if (kbd->ledmode == LED_SHOW_IOCTL)
973 return ledioctl;
974
975 leds = kbd->ledflagstate;
976
977 if (kbd->ledmode == LED_SHOW_MEM) {
978 for (i = 0; i < 3; i++)
979 if (ledptrs[i].valid) {
980 if (*ledptrs[i].addr & ledptrs[i].mask)
981 leds |= (1 << i);
982 else
983 leds &= ~(1 << i);
984 }
985 }
986 return leds;
987}
988
989/*
990 * This routine is the bottom half of the keyboard interrupt
991 * routine, and runs with all interrupts enabled. It does
992 * console changing, led setting and copy_to_cooked, which can
993 * take a reasonably long time.
994 *
995 * Aside from timing (which isn't really that important for
996 * keyboard interrupts as they happen often), using the software
997 * interrupt routines for this thing allows us to easily mask
998 * this when we don't want any of the above to happen.
999 * This allows for easy and efficient race-condition prevention
0e739d28 1000 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
1da177e4
LT		 1001 */
1002
1003static void kbd_bh(unsigned long dummy)
1004{
fe1e8604 1005 struct list_head *node;
1da177e4
LT		 1006 unsigned char leds = getleds();
1007
1008 if (leds != ledstate) {
fe1e8604 1009 list_for_each(node, &kbd_handler.h_list) {
0e739d28
DT		 1010 struct input_handle *handle = to_handle_h(node);
1011 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1012 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1013 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1014 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1da177e4
LT		 1015 }
1016 }
1017
1018 ledstate = leds;
1019}
1020
1021DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1022
1da177e4 1023#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
0b57ee9e
AB		 1024 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1025 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1da177e4
LT		 1026 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1027
1028#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1029 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1030
0f5e560e 1031static const unsigned short x86_keycodes[256] =
1da177e4
LT		 1032 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1033 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1034 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1035 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1036 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1037 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
896cdc7b 1038 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1da177e4
LT		 1039 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1040 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1041 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1042 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1043 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1044 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1045 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1046 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1047
1048#ifdef CONFIG_MAC_EMUMOUSEBTN
1049extern int mac_hid_mouse_emulate_buttons(int, int, int);
1050#endif /* CONFIG_MAC_EMUMOUSEBTN */
1051
0b57ee9e 1052#ifdef CONFIG_SPARC
1da177e4
LT		 1053static int sparc_l1_a_state = 0;
1054extern void sun_do_break(void);
1055#endif
1056
fe1e8604 1057static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1da177e4
LT		 1058 unsigned char up_flag)
1059{
896cdc7b 1060 int code;
1da177e4
LT		 1061
1062 switch (keycode) {
1063 case KEY_PAUSE:
1064 put_queue(vc, 0xe1);
1065 put_queue(vc, 0x1d | up_flag);
1066 put_queue(vc, 0x45 | up_flag);
896cdc7b
DT		 1067 break;
1068
b9ab58dd 1069 case KEY_HANGEUL:
0ae051a1
DT		 1070 if (!up_flag)
1071 put_queue(vc, 0xf2);
896cdc7b
DT		 1072 break;
1073
1da177e4 1074 case KEY_HANJA:
0ae051a1
DT		 1075 if (!up_flag)
1076 put_queue(vc, 0xf1);
896cdc7b 1077 break;
1da177e4 1078
896cdc7b
DT		 1079 case KEY_SYSRQ:
1080 /*
1081 * Real AT keyboards (that's what we're trying
1082 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1083 * pressing PrtSc/SysRq alone, but simply 0x54
1084 * when pressing Alt+PrtSc/SysRq.
1085 */
1086 if (sysrq_alt) {
1087 put_queue(vc, 0x54 | up_flag);
1088 } else {
1089 put_queue(vc, 0xe0);
1090 put_queue(vc, 0x2a | up_flag);
1091 put_queue(vc, 0xe0);
1092 put_queue(vc, 0x37 | up_flag);
1093 }
1094 break;
1095
1096 default:
1097 if (keycode > 255)
1098 return -1;
1da177e4 1099
896cdc7b
DT		 1100 code = x86_keycodes[keycode];
1101 if (!code)
1102 return -1;
1da177e4 1103
896cdc7b
DT		 1104 if (code & 0x100)
1105 put_queue(vc, 0xe0);
1106 put_queue(vc, (code & 0x7f) | up_flag);
1da177e4 1107
896cdc7b 1108 break;
1da177e4
LT		 1109 }
1110
1111 return 0;
1112}
1113
1114#else
1115
1116#define HW_RAW(dev) 0
1117
1118#warning "Cannot generate rawmode keyboard for your architecture yet."
1119
1120static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1121{
1122 if (keycode > 127)
1123 return -1;
1124
1125 put_queue(vc, keycode | up_flag);
1126 return 0;
1127}
1128#endif
1129
1130static void kbd_rawcode(unsigned char data)
1131{
1132 struct vc_data *vc = vc_cons[fg_console].d;
1133 kbd = kbd_table + fg_console;
1134 if (kbd->kbdmode == VC_RAW)
1135 put_queue(vc, data);
1136}
1137
7d12e780 1138static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1da177e4
LT		 1139{
1140 struct vc_data *vc = vc_cons[fg_console].d;
1141 unsigned short keysym, *key_map;
1142 unsigned char type, raw_mode;
1143 struct tty_struct *tty;
1144 int shift_final;
1145
1146 tty = vc->vc_tty;
1147
1148 if (tty && (!tty->driver_data)) {
1149 /* No driver data? Strange. Okay we fix it then. */
1150 tty->driver_data = vc;
1151 }
1152
1153 kbd = kbd_table + fg_console;
1154
1155 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
d2be8ee5 1156 sysrq_alt = down ? keycode : 0;
0b57ee9e 1157#ifdef CONFIG_SPARC
1da177e4
LT		 1158 if (keycode == KEY_STOP)
1159 sparc_l1_a_state = down;
1160#endif
1161
1162 rep = (down == 2);
1163
1164#ifdef CONFIG_MAC_EMUMOUSEBTN
1165 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1166 return;
1167#endif /* CONFIG_MAC_EMUMOUSEBTN */
1168
1169 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1170 if (emulate_raw(vc, keycode, !down << 7))
1171 if (keycode < BTN_MISC)
1172 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1173
1174#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1175 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
d2be8ee5
FR		 1176 if (!sysrq_down) {
1177 sysrq_down = down;
1178 sysrq_alt_use = sysrq_alt;
1179 }
1da177e4
LT		 1180 return;
1181 }
d2be8ee5
FR		 1182 if (sysrq_down && !down && keycode == sysrq_alt_use)
1183 sysrq_down = 0;
1da177e4 1184 if (sysrq_down && down && !rep) {
7d12e780 1185 handle_sysrq(kbd_sysrq_xlate[keycode], tty);
1da177e4
LT		 1186 return;
1187 }
1188#endif
0b57ee9e 1189#ifdef CONFIG_SPARC
1da177e4
LT		 1190 if (keycode == KEY_A && sparc_l1_a_state) {
1191 sparc_l1_a_state = 0;
1192 sun_do_break();
1193 }
1194#endif
1195
1196 if (kbd->kbdmode == VC_MEDIUMRAW) {
1197 /*
1198 * This is extended medium raw mode, with keys above 127
1199 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1200 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1201 * interfere with anything else. The two bytes after 0 will
1202 * always have the up flag set not to interfere with older
1203 * applications. This allows for 16384 different keycodes,
1204 * which should be enough.
1205 */
1206 if (keycode < 128) {
1207 put_queue(vc, keycode | (!down << 7));
1208 } else {
1209 put_queue(vc, !down << 7);
1210 put_queue(vc, (keycode >> 7) | 0x80);
1211 put_queue(vc, keycode | 0x80);
1212 }
1213 raw_mode = 1;
1214 }
1215
1216 if (down)
1217 set_bit(keycode, key_down);
1218 else
1219 clear_bit(keycode, key_down);
1220
fe1e8604
DT		 1221 if (rep &&
1222 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1223 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1da177e4
LT		 1224 /*
1225 * Don't repeat a key if the input buffers are not empty and the
fe1e8604 1226 * characters get aren't echoed locally. This makes key repeat
1da177e4
LT		 1227 * usable with slow applications and under heavy loads.
1228 */
1229 return;
1230 }
1231
1232 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1233 key_map = key_maps[shift_final];
1234
1235 if (!key_map) {
1236 compute_shiftstate();
1237 kbd->slockstate = 0;
1238 return;
1239 }
1240
1241 if (keycode > NR_KEYS)
b9ec4e10
ST		 1242 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1243 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1244 else
1245 return;
1246 else
1247 keysym = key_map[keycode];
1da177e4 1248
1da177e4
LT		 1249 type = KTYP(keysym);
1250
1251 if (type < 0xf0) {
fe1e8604
DT		 1252 if (down && !raw_mode)
1253 to_utf8(vc, keysym);
1da177e4
LT		 1254 return;
1255 }
1256
1257 type -= 0xf0;
1258
1259 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1260 return;
1261
1262 if (type == KT_LETTER) {
1263 type = KT_LATIN;
1264 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1265 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1266 if (key_map)
1267 keysym = key_map[keycode];
1268 }
1269 }
1270
7d12e780 1271 (*k_handler[type])(vc, keysym & 0xff, !down);
1da177e4
LT		 1272
1273 if (type != KT_SLOCK)
1274 kbd->slockstate = 0;
1275}
1276
fe1e8604 1277static void kbd_event(struct input_handle *handle, unsigned int event_type,
1da177e4
LT		 1278 unsigned int event_code, int value)
1279{
1280 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1281 kbd_rawcode(value);
1282 if (event_type == EV_KEY)
7d12e780 1283 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1da177e4
LT		 1284 tasklet_schedule(&keyboard_tasklet);
1285 do_poke_blanked_console = 1;
1286 schedule_console_callback();
1287}
1288
1da177e4
LT		 1289/*
1290 * When a keyboard (or other input device) is found, the kbd_connect
1291 * function is called. The function then looks at the device, and if it
1292 * likes it, it can open it and get events from it. In this (kbd_connect)
1293 * function, we should decide which VT to bind that keyboard to initially.
1294 */
fe1e8604 1295static struct input_handle *kbd_connect(struct input_handler *handler,
1da177e4 1296 struct input_dev *dev,
66e66118 1297 const struct input_device_id *id)
1da177e4
LT		 1298{
1299 struct input_handle *handle;
1300 int i;
1301
1302 for (i = KEY_RESERVED; i < BTN_MISC; i++)
fe1e8604
DT		 1303 if (test_bit(i, dev->keybit))
1304 break;
1da177e4 1305
fe1e8604 1306 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1da177e4
LT		 1307 return NULL;
1308
22479e1c
DT		 1309 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1310 if (!handle)
1da177e4 1311 return NULL;
1da177e4
LT		 1312
1313 handle->dev = dev;
1314 handle->handler = handler;
fe1e8604 1315 handle->name = "kbd";
1da177e4
LT		 1316
1317 input_open_device(handle);
1da177e4
LT		 1318
1319 return handle;
1320}
1321
1322static void kbd_disconnect(struct input_handle *handle)
1323{
1324 input_close_device(handle);
1325 kfree(handle);
1326}
1327
c7e8dc6e
DT		 1328/*
1329 * Start keyboard handler on the new keyboard by refreshing LED state to
1330 * match the rest of the system.
1331 */
1332static void kbd_start(struct input_handle *handle)
1333{
1334 unsigned char leds = ledstate;
1335
1336 tasklet_disable(&keyboard_tasklet);
1337 if (leds != 0xff) {
0e739d28
DT		 1338 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1339 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1340 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1341 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
c7e8dc6e
DT		 1342 }
1343 tasklet_enable(&keyboard_tasklet);
1344}
1345
66e66118 1346static const struct input_device_id kbd_ids[] = {
1da177e4
LT		 1347 {
1348 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1349 .evbit = { BIT(EV_KEY) },
1350 },
fe1e8604 1351
1da177e4
LT		 1352 {
1353 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1354 .evbit = { BIT(EV_SND) },
fe1e8604 1355 },
1da177e4
LT		 1356
1357 { }, /* Terminating entry */
1358};
1359
1360MODULE_DEVICE_TABLE(input, kbd_ids);
1361
1362static struct input_handler kbd_handler = {
1363 .event = kbd_event,
1364 .connect = kbd_connect,
1365 .disconnect = kbd_disconnect,
c7e8dc6e 1366 .start = kbd_start,
1da177e4
LT		 1367 .name = "kbd",
1368 .id_table = kbd_ids,
1369};
1370
1371int __init kbd_init(void)
1372{
1373 int i;
4263cf0f 1374 int error;
1da177e4 1375
2b192908
DT		 1376 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1377 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1378 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1379 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1380 kbd_table[i].lockstate = KBD_DEFLOCK;
1381 kbd_table[i].slockstate = 0;
1382 kbd_table[i].modeflags = KBD_DEFMODE;
1383 kbd_table[i].kbdmode = VC_XLATE;
1384 }
1da177e4 1385
4263cf0f
DT		 1386 error = input_register_handler(&kbd_handler);
1387 if (error)
1388 return error;
1da177e4
LT		 1389
1390 tasklet_enable(&keyboard_tasklet);
1391 tasklet_schedule(&keyboard_tasklet);
1392
1393 return 0;
1394}
kernel source for telekom puls (alcatel/mediatek)