projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Input: synaptics - limit rate to 40pps on Toshiba Protege M300
[linux-2.6-block.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
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
fe1e8604 55 * of PARISC machines however there is no NumLock key and everyone expects the keypad
1da177e4
LT		 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
fe1e8604 79typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
1da177e4
LT		 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\
fe1e8604
DT		 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
1da177e4
LT		 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{
fe1e8604 162 struct list_head *node;
1da177e4
LT		 163 struct input_dev *dev = NULL;
164
fe1e8604
DT		 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;
1da177e4
LT		 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{
fe1e8604 184 struct list_head *node;
1da177e4
LT		 185 struct input_dev *dev = NULL;
186 unsigned int i, oldkey;
187
fe1e8604 188 list_for_each(node, &kbd_handler.h_list) {
1da177e4 189 struct input_handle *handle = to_handle_h(node);
fe1e8604
DT		 190 if (handle->dev->keycodesize) {
191 dev = handle->dev;
192 break;
1da177e4
LT		 193 }
194 }
195
196 if (!dev)
197 return -ENODEV;
198
199 if (scancode >= dev->keycodemax)
200 return -EINVAL;
1da177e4
LT		 201 if (keycode < 0 || keycode > KEY_MAX)
202 return -EINVAL;
4cee9956 203 if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
5ac7ba3f 204 return -EINVAL;
1da177e4
LT		 205
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/*
fe1e8604 219 * Making beeps and bells.
1da177e4
LT		 220 */
221static void kd_nosound(unsigned long ignored)
222{
fe1e8604 223 struct list_head *node;
1da177e4
LT		 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
8d06afab 236static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
1da177e4
LT		 237
238void kd_mksound(unsigned int hz, unsigned int ticks)
239{
fe1e8604 240 struct list_head *node;
1da177e4
LT		 241
242 del_timer(&kd_mksound_timer);
243
244 if (hz) {
fe1e8604 245 list_for_each_prev(node, &kbd_handler.h_list) {
1da177e4
LT		 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);
fe1e8604 340 else if (c < 0x800) {
1da177e4 341 /* 110***** 10****** */
fe1e8604 342 put_queue(vc, 0xc0 | (c >> 6));
1da177e4 343 put_queue(vc, 0x80 | (c & 0x3f));
fe1e8604 344 } else {
1da177e4
LT		 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));
fe1e8604 349 }
1da177e4
LT		 350}
351
fe1e8604 352/*
1da177e4
LT		 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));
fe1e8604 363
1da177e4
LT		 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
fe1e8604 502 for (i = cur - 1; i != cur; i--) {
1da177e4 503 if (i == -1)
fe1e8604 504 i = MAX_NR_CONSOLES - 1;
1da177e4
LT		 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{
fe1e8604
DT		 570 if (spawnpid)
571 if (kill_proc(spawnpid, spawnsig, 1))
572 spawnpid = 0;
1da177e4
LT		 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;
fe1e8604
DT		 606 if ((kbd->kbdmode == VC_RAW ||
607 kbd->kbdmode == VC_MEDIUMRAW) &&
1da177e4
LT		 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{
fe1e8604 897 struct list_head *node;
1da177e4
LT		 898 unsigned char leds = getleds();
899
900 if (leds != ledstate) {
fe1e8604 901 list_for_each(node, &kbd_handler.h_list) {
1da177e4
LT		 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) ||\
0b57ee9e
AB		 933 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
934 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1da177e4
LT		 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
0b57ee9e 961#ifdef CONFIG_SPARC
1da177e4
LT		 962static int sparc_l1_a_state = 0;
963extern void sun_do_break(void);
964#endif
965
fe1e8604 966static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1da177e4
LT		 967 unsigned char up_flag)
968{
969 if (keycode > 255 || !x86_keycodes[keycode])
fe1e8604 970 return -1;
1da177e4
LT		 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;
fe1e8604 984 }
1da177e4
LT		 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
75c96f85
AB		 1028static void kbd_keycode(unsigned int keycode, int down,
1029 int hw_raw, struct pt_regs *regs)
1da177e4
LT		 1030{
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;
0b57ee9e 1048#ifdef CONFIG_SPARC
1da177e4
LT		 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
0b57ee9e 1075#ifdef CONFIG_SPARC
1da177e4
LT		 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
fe1e8604
DT		 1107 if (rep &&
1108 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1109 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1da177e4
LT		 1110 /*
1111 * Don't repeat a key if the input buffers are not empty and the
fe1e8604 1112 * characters get aren't echoed locally. This makes key repeat
1da177e4
LT		 1113 * usable with slow applications and under heavy loads.
1114 */
1115 return;
1116 }
1117
1118 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1119 key_map = key_maps[shift_final];
1120
1121 if (!key_map) {
1122 compute_shiftstate();
1123 kbd->slockstate = 0;
1124 return;
1125 }
1126
1127 if (keycode > NR_KEYS)
1128 return;
1129
1130 keysym = key_map[keycode];
1131 type = KTYP(keysym);
1132
1133 if (type < 0xf0) {
fe1e8604
DT		 1134 if (down && !raw_mode)
1135 to_utf8(vc, keysym);
1da177e4
LT		 1136 return;
1137 }
1138
1139 type -= 0xf0;
1140
1141 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1142 return;
1143
1144 if (type == KT_LETTER) {
1145 type = KT_LATIN;
1146 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1147 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1148 if (key_map)
1149 keysym = key_map[keycode];
1150 }
1151 }
1152
1153 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1154
1155 if (type != KT_SLOCK)
1156 kbd->slockstate = 0;
1157}
1158
fe1e8604 1159static void kbd_event(struct input_handle *handle, unsigned int event_type,
1da177e4
LT		 1160 unsigned int event_code, int value)
1161{
1162 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1163 kbd_rawcode(value);
1164 if (event_type == EV_KEY)
1165 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1166 tasklet_schedule(&keyboard_tasklet);
1167 do_poke_blanked_console = 1;
1168 schedule_console_callback();
1169}
1170
1da177e4
LT		 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 */
fe1e8604 1177static struct input_handle *kbd_connect(struct input_handler *handler,
1da177e4
LT		 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++)
fe1e8604
DT		 1185 if (test_bit(i, dev->keybit))
1186 break;
1da177e4 1187
fe1e8604 1188 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1da177e4
LT		 1189 return NULL;
1190
fe1e8604 1191 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1da177e4
LT		 1192 return NULL;
1193 memset(handle, 0, sizeof(struct input_handle));
1194
1195 handle->dev = dev;
1196 handle->handler = handler;
fe1e8604 1197 handle->name = "kbd";
1da177e4
LT		 1198
1199 input_open_device(handle);
1200 kbd_refresh_leds(handle);
1201
1202 return handle;
1203}
1204
1205static void kbd_disconnect(struct input_handle *handle)
1206{
1207 input_close_device(handle);
1208 kfree(handle);
1209}
1210
1211static struct input_device_id kbd_ids[] = {
1212 {
1213 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1214 .evbit = { BIT(EV_KEY) },
1215 },
fe1e8604 1216
1da177e4
LT		 1217 {
1218 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1219 .evbit = { BIT(EV_SND) },
fe1e8604 1220 },
1da177e4
LT		 1221
1222 { }, /* Terminating entry */
1223};
1224
1225MODULE_DEVICE_TABLE(input, kbd_ids);
1226
1227static struct input_handler kbd_handler = {
1228 .event = kbd_event,
1229 .connect = kbd_connect,
1230 .disconnect = kbd_disconnect,
1231 .name = "kbd",
1232 .id_table = kbd_ids,
1233};
1234
1235int __init kbd_init(void)
1236{
1237 int i;
1238
1239 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1240 kbd0.ledmode = LED_SHOW_FLAGS;
1241 kbd0.lockstate = KBD_DEFLOCK;
1242 kbd0.slockstate = 0;
1243 kbd0.modeflags = KBD_DEFMODE;
1244 kbd0.kbdmode = VC_XLATE;
1245
1246 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1247 kbd_table[i] = kbd0;
1248
1249 input_register_handler(&kbd_handler);
1250
1251 tasklet_enable(&keyboard_tasklet);
1252 tasklet_schedule(&keyboard_tasklet);
1253
1254 return 0;
1255}
Linux 6.x block layer and io_uring tree(s)