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