Loading...
1/*
2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
4 *
5 * Some additional features added by Christoph Niemann (ChN), March 1993
6 *
7 * Loadable keymaps by Risto Kankkunen, May 1993
8 *
9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
10 * Added decr/incr_console, dynamic keymaps, Unicode support,
11 * dynamic function/string keys, led setting, Sept 1994
12 * `Sticky' modifier keys, 951006.
13 *
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
15 *
16 * Modified to provide 'generic' keyboard support by Hamish Macdonald
17 * Merge with the m68k keyboard driver and split-off of the PC low-level
18 * parts by Geert Uytterhoeven, May 1997
19 *
20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
21 * 30-07-98: Dead keys redone, aeb@cwi.nl.
22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
23 */
24
25#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27#include <linux/consolemap.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#include <linux/irq.h>
37
38#include <linux/kbd_kern.h>
39#include <linux/kbd_diacr.h>
40#include <linux/vt_kern.h>
41#include <linux/input.h>
42#include <linux/reboot.h>
43#include <linux/notifier.h>
44#include <linux/jiffies.h>
45
46extern void ctrl_alt_del(void);
47
48/*
49 * Exported functions/variables
50 */
51
52#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
53
54/*
55 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
56 * This seems a good reason to start with NumLock off. On HIL keyboards
57 * of PARISC machines however there is no NumLock key and everyone expects the keypad
58 * to be used for numbers.
59 */
60
61#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
62#define KBD_DEFLEDS (1 << VC_NUMLOCK)
63#else
64#define KBD_DEFLEDS 0
65#endif
66
67#define KBD_DEFLOCK 0
68
69void compute_shiftstate(void);
70
71/*
72 * Handler Tables.
73 */
74
75#define K_HANDLERS\
76 k_self, k_fn, k_spec, k_pad,\
77 k_dead, k_cons, k_cur, k_shift,\
78 k_meta, k_ascii, k_lock, k_lowercase,\
79 k_slock, k_dead2, k_brl, k_ignore
80
81typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
82 char up_flag);
83static k_handler_fn K_HANDLERS;
84static k_handler_fn *k_handler[16] = { K_HANDLERS };
85
86#define FN_HANDLERS\
87 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
88 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
89 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
90 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
91 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
92
93typedef void (fn_handler_fn)(struct vc_data *vc);
94static fn_handler_fn FN_HANDLERS;
95static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
96
97/*
98 * Variables exported for vt_ioctl.c
99 */
100
101/* maximum values each key_handler can handle */
102const int max_vals[] = {
103 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
104 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
105 255, NR_LOCK - 1, 255, NR_BRL - 1
106};
107
108const int NR_TYPES = ARRAY_SIZE(max_vals);
109
110struct kbd_struct kbd_table[MAX_NR_CONSOLES];
111EXPORT_SYMBOL_GPL(kbd_table);
112static struct kbd_struct *kbd = kbd_table;
113
114struct vt_spawn_console vt_spawn_con = {
115 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
116 .pid = NULL,
117 .sig = 0,
118};
119
120/*
121 * Variables exported for vt.c
122 */
123
124int shift_state = 0;
125
126/*
127 * Internal Data.
128 */
129
130static struct input_handler kbd_handler;
131static DEFINE_SPINLOCK(kbd_event_lock);
132static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
133static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
134static bool dead_key_next;
135static int npadch = -1; /* -1 or number assembled on pad */
136static unsigned int diacr;
137static char rep; /* flag telling character repeat */
138
139static unsigned char ledstate = 0xff; /* undefined */
140static unsigned char ledioctl;
141
142static struct ledptr {
143 unsigned int *addr;
144 unsigned int mask;
145 unsigned char valid:1;
146} ledptrs[3];
147
148/*
149 * Notifier list for console keyboard events
150 */
151static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
152
153int register_keyboard_notifier(struct notifier_block *nb)
154{
155 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
156}
157EXPORT_SYMBOL_GPL(register_keyboard_notifier);
158
159int unregister_keyboard_notifier(struct notifier_block *nb)
160{
161 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
162}
163EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
164
165/*
166 * Translation of scancodes to keycodes. We set them on only the first
167 * keyboard in the list that accepts the scancode and keycode.
168 * Explanation for not choosing the first attached keyboard anymore:
169 * USB keyboards for example have two event devices: one for all "normal"
170 * keys and one for extra function keys (like "volume up", "make coffee",
171 * etc.). So this means that scancodes for the extra function keys won't
172 * be valid for the first event device, but will be for the second.
173 */
174
175struct getset_keycode_data {
176 struct input_keymap_entry ke;
177 int error;
178};
179
180static int getkeycode_helper(struct input_handle *handle, void *data)
181{
182 struct getset_keycode_data *d = data;
183
184 d->error = input_get_keycode(handle->dev, &d->ke);
185
186 return d->error == 0; /* stop as soon as we successfully get one */
187}
188
189int getkeycode(unsigned int scancode)
190{
191 struct getset_keycode_data d = {
192 .ke = {
193 .flags = 0,
194 .len = sizeof(scancode),
195 .keycode = 0,
196 },
197 .error = -ENODEV,
198 };
199
200 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
201
202 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
203
204 return d.error ?: d.ke.keycode;
205}
206
207static int setkeycode_helper(struct input_handle *handle, void *data)
208{
209 struct getset_keycode_data *d = data;
210
211 d->error = input_set_keycode(handle->dev, &d->ke);
212
213 return d->error == 0; /* stop as soon as we successfully set one */
214}
215
216int setkeycode(unsigned int scancode, unsigned int keycode)
217{
218 struct getset_keycode_data d = {
219 .ke = {
220 .flags = 0,
221 .len = sizeof(scancode),
222 .keycode = keycode,
223 },
224 .error = -ENODEV,
225 };
226
227 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
228
229 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
230
231 return d.error;
232}
233
234/*
235 * Making beeps and bells. Note that we prefer beeps to bells, but when
236 * shutting the sound off we do both.
237 */
238
239static int kd_sound_helper(struct input_handle *handle, void *data)
240{
241 unsigned int *hz = data;
242 struct input_dev *dev = handle->dev;
243
244 if (test_bit(EV_SND, dev->evbit)) {
245 if (test_bit(SND_TONE, dev->sndbit)) {
246 input_inject_event(handle, EV_SND, SND_TONE, *hz);
247 if (*hz)
248 return 0;
249 }
250 if (test_bit(SND_BELL, dev->sndbit))
251 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
252 }
253
254 return 0;
255}
256
257static void kd_nosound(unsigned long ignored)
258{
259 static unsigned int zero;
260
261 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
262}
263
264static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
265
266void kd_mksound(unsigned int hz, unsigned int ticks)
267{
268 del_timer_sync(&kd_mksound_timer);
269
270 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
271
272 if (hz && ticks)
273 mod_timer(&kd_mksound_timer, jiffies + ticks);
274}
275EXPORT_SYMBOL(kd_mksound);
276
277/*
278 * Setting the keyboard rate.
279 */
280
281static int kbd_rate_helper(struct input_handle *handle, void *data)
282{
283 struct input_dev *dev = handle->dev;
284 struct kbd_repeat *rep = data;
285
286 if (test_bit(EV_REP, dev->evbit)) {
287
288 if (rep[0].delay > 0)
289 input_inject_event(handle,
290 EV_REP, REP_DELAY, rep[0].delay);
291 if (rep[0].period > 0)
292 input_inject_event(handle,
293 EV_REP, REP_PERIOD, rep[0].period);
294
295 rep[1].delay = dev->rep[REP_DELAY];
296 rep[1].period = dev->rep[REP_PERIOD];
297 }
298
299 return 0;
300}
301
302int kbd_rate(struct kbd_repeat *rep)
303{
304 struct kbd_repeat data[2] = { *rep };
305
306 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
307 *rep = data[1]; /* Copy currently used settings */
308
309 return 0;
310}
311
312/*
313 * Helper Functions.
314 */
315static void put_queue(struct vc_data *vc, int ch)
316{
317 struct tty_struct *tty = vc->port.tty;
318
319 if (tty) {
320 tty_insert_flip_char(tty, ch, 0);
321 con_schedule_flip(tty);
322 }
323}
324
325static void puts_queue(struct vc_data *vc, char *cp)
326{
327 struct tty_struct *tty = vc->port.tty;
328
329 if (!tty)
330 return;
331
332 while (*cp) {
333 tty_insert_flip_char(tty, *cp, 0);
334 cp++;
335 }
336 con_schedule_flip(tty);
337}
338
339static void applkey(struct vc_data *vc, int key, char mode)
340{
341 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
342
343 buf[1] = (mode ? 'O' : '[');
344 buf[2] = key;
345 puts_queue(vc, buf);
346}
347
348/*
349 * Many other routines do put_queue, but I think either
350 * they produce ASCII, or they produce some user-assigned
351 * string, and in both cases we might assume that it is
352 * in utf-8 already.
353 */
354static void to_utf8(struct vc_data *vc, uint c)
355{
356 if (c < 0x80)
357 /* 0******* */
358 put_queue(vc, c);
359 else if (c < 0x800) {
360 /* 110***** 10****** */
361 put_queue(vc, 0xc0 | (c >> 6));
362 put_queue(vc, 0x80 | (c & 0x3f));
363 } else if (c < 0x10000) {
364 if (c >= 0xD800 && c < 0xE000)
365 return;
366 if (c == 0xFFFF)
367 return;
368 /* 1110**** 10****** 10****** */
369 put_queue(vc, 0xe0 | (c >> 12));
370 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
371 put_queue(vc, 0x80 | (c & 0x3f));
372 } else if (c < 0x110000) {
373 /* 11110*** 10****** 10****** 10****** */
374 put_queue(vc, 0xf0 | (c >> 18));
375 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
376 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
377 put_queue(vc, 0x80 | (c & 0x3f));
378 }
379}
380
381/*
382 * Called after returning from RAW mode or when changing consoles - recompute
383 * shift_down[] and shift_state from key_down[] maybe called when keymap is
384 * undefined, so that shiftkey release is seen
385 */
386void compute_shiftstate(void)
387{
388 unsigned int i, j, k, sym, val;
389
390 shift_state = 0;
391 memset(shift_down, 0, sizeof(shift_down));
392
393 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
394
395 if (!key_down[i])
396 continue;
397
398 k = i * BITS_PER_LONG;
399
400 for (j = 0; j < BITS_PER_LONG; j++, k++) {
401
402 if (!test_bit(k, key_down))
403 continue;
404
405 sym = U(key_maps[0][k]);
406 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
407 continue;
408
409 val = KVAL(sym);
410 if (val == KVAL(K_CAPSSHIFT))
411 val = KVAL(K_SHIFT);
412
413 shift_down[val]++;
414 shift_state |= (1 << val);
415 }
416 }
417}
418
419/*
420 * We have a combining character DIACR here, followed by the character CH.
421 * If the combination occurs in the table, return the corresponding value.
422 * Otherwise, if CH is a space or equals DIACR, return DIACR.
423 * Otherwise, conclude that DIACR was not combining after all,
424 * queue it and return CH.
425 */
426static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
427{
428 unsigned int d = diacr;
429 unsigned int i;
430
431 diacr = 0;
432
433 if ((d & ~0xff) == BRL_UC_ROW) {
434 if ((ch & ~0xff) == BRL_UC_ROW)
435 return d | ch;
436 } else {
437 for (i = 0; i < accent_table_size; i++)
438 if (accent_table[i].diacr == d && accent_table[i].base == ch)
439 return accent_table[i].result;
440 }
441
442 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
443 return d;
444
445 if (kbd->kbdmode == VC_UNICODE)
446 to_utf8(vc, d);
447 else {
448 int c = conv_uni_to_8bit(d);
449 if (c != -1)
450 put_queue(vc, c);
451 }
452
453 return ch;
454}
455
456/*
457 * Special function handlers
458 */
459static void fn_enter(struct vc_data *vc)
460{
461 if (diacr) {
462 if (kbd->kbdmode == VC_UNICODE)
463 to_utf8(vc, diacr);
464 else {
465 int c = conv_uni_to_8bit(diacr);
466 if (c != -1)
467 put_queue(vc, c);
468 }
469 diacr = 0;
470 }
471
472 put_queue(vc, 13);
473 if (vc_kbd_mode(kbd, VC_CRLF))
474 put_queue(vc, 10);
475}
476
477static void fn_caps_toggle(struct vc_data *vc)
478{
479 if (rep)
480 return;
481
482 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
483}
484
485static void fn_caps_on(struct vc_data *vc)
486{
487 if (rep)
488 return;
489
490 set_vc_kbd_led(kbd, VC_CAPSLOCK);
491}
492
493static void fn_show_ptregs(struct vc_data *vc)
494{
495 struct pt_regs *regs = get_irq_regs();
496
497 if (regs)
498 show_regs(regs);
499}
500
501static void fn_hold(struct vc_data *vc)
502{
503 struct tty_struct *tty = vc->port.tty;
504
505 if (rep || !tty)
506 return;
507
508 /*
509 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
510 * these routines are also activated by ^S/^Q.
511 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
512 */
513 if (tty->stopped)
514 start_tty(tty);
515 else
516 stop_tty(tty);
517}
518
519static void fn_num(struct vc_data *vc)
520{
521 if (vc_kbd_mode(kbd, VC_APPLIC))
522 applkey(vc, 'P', 1);
523 else
524 fn_bare_num(vc);
525}
526
527/*
528 * Bind this to Shift-NumLock if you work in application keypad mode
529 * but want to be able to change the NumLock flag.
530 * Bind this to NumLock if you prefer that the NumLock key always
531 * changes the NumLock flag.
532 */
533static void fn_bare_num(struct vc_data *vc)
534{
535 if (!rep)
536 chg_vc_kbd_led(kbd, VC_NUMLOCK);
537}
538
539static void fn_lastcons(struct vc_data *vc)
540{
541 /* switch to the last used console, ChN */
542 set_console(last_console);
543}
544
545static void fn_dec_console(struct vc_data *vc)
546{
547 int i, cur = fg_console;
548
549 /* Currently switching? Queue this next switch relative to that. */
550 if (want_console != -1)
551 cur = want_console;
552
553 for (i = cur - 1; i != cur; i--) {
554 if (i == -1)
555 i = MAX_NR_CONSOLES - 1;
556 if (vc_cons_allocated(i))
557 break;
558 }
559 set_console(i);
560}
561
562static void fn_inc_console(struct vc_data *vc)
563{
564 int i, cur = fg_console;
565
566 /* Currently switching? Queue this next switch relative to that. */
567 if (want_console != -1)
568 cur = want_console;
569
570 for (i = cur+1; i != cur; i++) {
571 if (i == MAX_NR_CONSOLES)
572 i = 0;
573 if (vc_cons_allocated(i))
574 break;
575 }
576 set_console(i);
577}
578
579static void fn_send_intr(struct vc_data *vc)
580{
581 struct tty_struct *tty = vc->port.tty;
582
583 if (!tty)
584 return;
585 tty_insert_flip_char(tty, 0, TTY_BREAK);
586 con_schedule_flip(tty);
587}
588
589static void fn_scroll_forw(struct vc_data *vc)
590{
591 scrollfront(vc, 0);
592}
593
594static void fn_scroll_back(struct vc_data *vc)
595{
596 scrollback(vc, 0);
597}
598
599static void fn_show_mem(struct vc_data *vc)
600{
601 show_mem(0);
602}
603
604static void fn_show_state(struct vc_data *vc)
605{
606 show_state();
607}
608
609static void fn_boot_it(struct vc_data *vc)
610{
611 ctrl_alt_del();
612}
613
614static void fn_compose(struct vc_data *vc)
615{
616 dead_key_next = true;
617}
618
619static void fn_spawn_con(struct vc_data *vc)
620{
621 spin_lock(&vt_spawn_con.lock);
622 if (vt_spawn_con.pid)
623 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
624 put_pid(vt_spawn_con.pid);
625 vt_spawn_con.pid = NULL;
626 }
627 spin_unlock(&vt_spawn_con.lock);
628}
629
630static void fn_SAK(struct vc_data *vc)
631{
632 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
633 schedule_work(SAK_work);
634}
635
636static void fn_null(struct vc_data *vc)
637{
638 compute_shiftstate();
639}
640
641/*
642 * Special key handlers
643 */
644static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
645{
646}
647
648static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
649{
650 if (up_flag)
651 return;
652 if (value >= ARRAY_SIZE(fn_handler))
653 return;
654 if ((kbd->kbdmode == VC_RAW ||
655 kbd->kbdmode == VC_MEDIUMRAW ||
656 kbd->kbdmode == VC_OFF) &&
657 value != KVAL(K_SAK))
658 return; /* SAK is allowed even in raw mode */
659 fn_handler[value](vc);
660}
661
662static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
663{
664 pr_err("k_lowercase was called - impossible\n");
665}
666
667static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
668{
669 if (up_flag)
670 return; /* no action, if this is a key release */
671
672 if (diacr)
673 value = handle_diacr(vc, value);
674
675 if (dead_key_next) {
676 dead_key_next = false;
677 diacr = value;
678 return;
679 }
680 if (kbd->kbdmode == VC_UNICODE)
681 to_utf8(vc, value);
682 else {
683 int c = conv_uni_to_8bit(value);
684 if (c != -1)
685 put_queue(vc, c);
686 }
687}
688
689/*
690 * Handle dead key. Note that we now may have several
691 * dead keys modifying the same character. Very useful
692 * for Vietnamese.
693 */
694static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
695{
696 if (up_flag)
697 return;
698
699 diacr = (diacr ? handle_diacr(vc, value) : value);
700}
701
702static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
703{
704 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
705}
706
707static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
708{
709 k_deadunicode(vc, value, up_flag);
710}
711
712/*
713 * Obsolete - for backwards compatibility only
714 */
715static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
716{
717 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
718
719 k_deadunicode(vc, ret_diacr[value], up_flag);
720}
721
722static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
723{
724 if (up_flag)
725 return;
726
727 set_console(value);
728}
729
730static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
731{
732 if (up_flag)
733 return;
734
735 if ((unsigned)value < ARRAY_SIZE(func_table)) {
736 if (func_table[value])
737 puts_queue(vc, func_table[value]);
738 } else
739 pr_err("k_fn called with value=%d\n", value);
740}
741
742static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
743{
744 static const char cur_chars[] = "BDCA";
745
746 if (up_flag)
747 return;
748
749 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
750}
751
752static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
753{
754 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
755 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
756
757 if (up_flag)
758 return; /* no action, if this is a key release */
759
760 /* kludge... shift forces cursor/number keys */
761 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
762 applkey(vc, app_map[value], 1);
763 return;
764 }
765
766 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
767
768 switch (value) {
769 case KVAL(K_PCOMMA):
770 case KVAL(K_PDOT):
771 k_fn(vc, KVAL(K_REMOVE), 0);
772 return;
773 case KVAL(K_P0):
774 k_fn(vc, KVAL(K_INSERT), 0);
775 return;
776 case KVAL(K_P1):
777 k_fn(vc, KVAL(K_SELECT), 0);
778 return;
779 case KVAL(K_P2):
780 k_cur(vc, KVAL(K_DOWN), 0);
781 return;
782 case KVAL(K_P3):
783 k_fn(vc, KVAL(K_PGDN), 0);
784 return;
785 case KVAL(K_P4):
786 k_cur(vc, KVAL(K_LEFT), 0);
787 return;
788 case KVAL(K_P6):
789 k_cur(vc, KVAL(K_RIGHT), 0);
790 return;
791 case KVAL(K_P7):
792 k_fn(vc, KVAL(K_FIND), 0);
793 return;
794 case KVAL(K_P8):
795 k_cur(vc, KVAL(K_UP), 0);
796 return;
797 case KVAL(K_P9):
798 k_fn(vc, KVAL(K_PGUP), 0);
799 return;
800 case KVAL(K_P5):
801 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
802 return;
803 }
804 }
805
806 put_queue(vc, pad_chars[value]);
807 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
808 put_queue(vc, 10);
809}
810
811static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
812{
813 int old_state = shift_state;
814
815 if (rep)
816 return;
817 /*
818 * Mimic typewriter:
819 * a CapsShift key acts like Shift but undoes CapsLock
820 */
821 if (value == KVAL(K_CAPSSHIFT)) {
822 value = KVAL(K_SHIFT);
823 if (!up_flag)
824 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
825 }
826
827 if (up_flag) {
828 /*
829 * handle the case that two shift or control
830 * keys are depressed simultaneously
831 */
832 if (shift_down[value])
833 shift_down[value]--;
834 } else
835 shift_down[value]++;
836
837 if (shift_down[value])
838 shift_state |= (1 << value);
839 else
840 shift_state &= ~(1 << value);
841
842 /* kludge */
843 if (up_flag && shift_state != old_state && npadch != -1) {
844 if (kbd->kbdmode == VC_UNICODE)
845 to_utf8(vc, npadch);
846 else
847 put_queue(vc, npadch & 0xff);
848 npadch = -1;
849 }
850}
851
852static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
853{
854 if (up_flag)
855 return;
856
857 if (vc_kbd_mode(kbd, VC_META)) {
858 put_queue(vc, '\033');
859 put_queue(vc, value);
860 } else
861 put_queue(vc, value | 0x80);
862}
863
864static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
865{
866 int base;
867
868 if (up_flag)
869 return;
870
871 if (value < 10) {
872 /* decimal input of code, while Alt depressed */
873 base = 10;
874 } else {
875 /* hexadecimal input of code, while AltGr depressed */
876 value -= 10;
877 base = 16;
878 }
879
880 if (npadch == -1)
881 npadch = value;
882 else
883 npadch = npadch * base + value;
884}
885
886static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
887{
888 if (up_flag || rep)
889 return;
890
891 chg_vc_kbd_lock(kbd, value);
892}
893
894static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
895{
896 k_shift(vc, value, up_flag);
897 if (up_flag || rep)
898 return;
899
900 chg_vc_kbd_slock(kbd, value);
901 /* try to make Alt, oops, AltGr and such work */
902 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
903 kbd->slockstate = 0;
904 chg_vc_kbd_slock(kbd, value);
905 }
906}
907
908/* by default, 300ms interval for combination release */
909static unsigned brl_timeout = 300;
910MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
911module_param(brl_timeout, uint, 0644);
912
913static unsigned brl_nbchords = 1;
914MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
915module_param(brl_nbchords, uint, 0644);
916
917static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
918{
919 static unsigned long chords;
920 static unsigned committed;
921
922 if (!brl_nbchords)
923 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
924 else {
925 committed |= pattern;
926 chords++;
927 if (chords == brl_nbchords) {
928 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
929 chords = 0;
930 committed = 0;
931 }
932 }
933}
934
935static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
936{
937 static unsigned pressed, committing;
938 static unsigned long releasestart;
939
940 if (kbd->kbdmode != VC_UNICODE) {
941 if (!up_flag)
942 pr_warning("keyboard mode must be unicode for braille patterns\n");
943 return;
944 }
945
946 if (!value) {
947 k_unicode(vc, BRL_UC_ROW, up_flag);
948 return;
949 }
950
951 if (value > 8)
952 return;
953
954 if (!up_flag) {
955 pressed |= 1 << (value - 1);
956 if (!brl_timeout)
957 committing = pressed;
958 } else if (brl_timeout) {
959 if (!committing ||
960 time_after(jiffies,
961 releasestart + msecs_to_jiffies(brl_timeout))) {
962 committing = pressed;
963 releasestart = jiffies;
964 }
965 pressed &= ~(1 << (value - 1));
966 if (!pressed && committing) {
967 k_brlcommit(vc, committing, 0);
968 committing = 0;
969 }
970 } else {
971 if (committing) {
972 k_brlcommit(vc, committing, 0);
973 committing = 0;
974 }
975 pressed &= ~(1 << (value - 1));
976 }
977}
978
979/*
980 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
981 * or (ii) whatever pattern of lights people want to show using KDSETLED,
982 * or (iii) specified bits of specified words in kernel memory.
983 */
984unsigned char getledstate(void)
985{
986 return ledstate;
987}
988
989void setledstate(struct kbd_struct *kbd, unsigned int led)
990{
991 if (!(led & ~7)) {
992 ledioctl = led;
993 kbd->ledmode = LED_SHOW_IOCTL;
994 } else
995 kbd->ledmode = LED_SHOW_FLAGS;
996
997 set_leds();
998}
999
1000static inline unsigned char getleds(void)
1001{
1002 struct kbd_struct *kbd = kbd_table + fg_console;
1003 unsigned char leds;
1004 int i;
1005
1006 if (kbd->ledmode == LED_SHOW_IOCTL)
1007 return ledioctl;
1008
1009 leds = kbd->ledflagstate;
1010
1011 if (kbd->ledmode == LED_SHOW_MEM) {
1012 for (i = 0; i < 3; i++)
1013 if (ledptrs[i].valid) {
1014 if (*ledptrs[i].addr & ledptrs[i].mask)
1015 leds |= (1 << i);
1016 else
1017 leds &= ~(1 << i);
1018 }
1019 }
1020 return leds;
1021}
1022
1023static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1024{
1025 unsigned char leds = *(unsigned char *)data;
1026
1027 if (test_bit(EV_LED, handle->dev->evbit)) {
1028 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1029 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1030 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1031 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1032 }
1033
1034 return 0;
1035}
1036
1037/*
1038 * This is the tasklet that updates LED state on all keyboards
1039 * attached to the box. The reason we use tasklet is that we
1040 * need to handle the scenario when keyboard handler is not
1041 * registered yet but we already getting updates form VT to
1042 * update led state.
1043 */
1044static void kbd_bh(unsigned long dummy)
1045{
1046 unsigned char leds = getleds();
1047
1048 if (leds != ledstate) {
1049 input_handler_for_each_handle(&kbd_handler, &leds,
1050 kbd_update_leds_helper);
1051 ledstate = leds;
1052 }
1053}
1054
1055DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1056
1057#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1058 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1059 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1060 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1061 defined(CONFIG_AVR32)
1062
1063#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1064 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1065
1066static const unsigned short x86_keycodes[256] =
1067 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1068 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1069 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1070 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1071 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1072 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1073 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1074 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1075 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1076 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1077 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1078 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1079 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1080 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1081 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1082
1083#ifdef CONFIG_SPARC
1084static int sparc_l1_a_state;
1085extern void sun_do_break(void);
1086#endif
1087
1088static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1089 unsigned char up_flag)
1090{
1091 int code;
1092
1093 switch (keycode) {
1094
1095 case KEY_PAUSE:
1096 put_queue(vc, 0xe1);
1097 put_queue(vc, 0x1d | up_flag);
1098 put_queue(vc, 0x45 | up_flag);
1099 break;
1100
1101 case KEY_HANGEUL:
1102 if (!up_flag)
1103 put_queue(vc, 0xf2);
1104 break;
1105
1106 case KEY_HANJA:
1107 if (!up_flag)
1108 put_queue(vc, 0xf1);
1109 break;
1110
1111 case KEY_SYSRQ:
1112 /*
1113 * Real AT keyboards (that's what we're trying
1114 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1115 * pressing PrtSc/SysRq alone, but simply 0x54
1116 * when pressing Alt+PrtSc/SysRq.
1117 */
1118 if (test_bit(KEY_LEFTALT, key_down) ||
1119 test_bit(KEY_RIGHTALT, key_down)) {
1120 put_queue(vc, 0x54 | up_flag);
1121 } else {
1122 put_queue(vc, 0xe0);
1123 put_queue(vc, 0x2a | up_flag);
1124 put_queue(vc, 0xe0);
1125 put_queue(vc, 0x37 | up_flag);
1126 }
1127 break;
1128
1129 default:
1130 if (keycode > 255)
1131 return -1;
1132
1133 code = x86_keycodes[keycode];
1134 if (!code)
1135 return -1;
1136
1137 if (code & 0x100)
1138 put_queue(vc, 0xe0);
1139 put_queue(vc, (code & 0x7f) | up_flag);
1140
1141 break;
1142 }
1143
1144 return 0;
1145}
1146
1147#else
1148
1149#define HW_RAW(dev) 0
1150
1151static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1152{
1153 if (keycode > 127)
1154 return -1;
1155
1156 put_queue(vc, keycode | up_flag);
1157 return 0;
1158}
1159#endif
1160
1161static void kbd_rawcode(unsigned char data)
1162{
1163 struct vc_data *vc = vc_cons[fg_console].d;
1164
1165 kbd = kbd_table + vc->vc_num;
1166 if (kbd->kbdmode == VC_RAW)
1167 put_queue(vc, data);
1168}
1169
1170static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1171{
1172 struct vc_data *vc = vc_cons[fg_console].d;
1173 unsigned short keysym, *key_map;
1174 unsigned char type;
1175 bool raw_mode;
1176 struct tty_struct *tty;
1177 int shift_final;
1178 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1179 int rc;
1180
1181 tty = vc->port.tty;
1182
1183 if (tty && (!tty->driver_data)) {
1184 /* No driver data? Strange. Okay we fix it then. */
1185 tty->driver_data = vc;
1186 }
1187
1188 kbd = kbd_table + vc->vc_num;
1189
1190#ifdef CONFIG_SPARC
1191 if (keycode == KEY_STOP)
1192 sparc_l1_a_state = down;
1193#endif
1194
1195 rep = (down == 2);
1196
1197 raw_mode = (kbd->kbdmode == VC_RAW);
1198 if (raw_mode && !hw_raw)
1199 if (emulate_raw(vc, keycode, !down << 7))
1200 if (keycode < BTN_MISC && printk_ratelimit())
1201 pr_warning("can't emulate rawmode for keycode %d\n",
1202 keycode);
1203
1204#ifdef CONFIG_SPARC
1205 if (keycode == KEY_A && sparc_l1_a_state) {
1206 sparc_l1_a_state = false;
1207 sun_do_break();
1208 }
1209#endif
1210
1211 if (kbd->kbdmode == VC_MEDIUMRAW) {
1212 /*
1213 * This is extended medium raw mode, with keys above 127
1214 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1215 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1216 * interfere with anything else. The two bytes after 0 will
1217 * always have the up flag set not to interfere with older
1218 * applications. This allows for 16384 different keycodes,
1219 * which should be enough.
1220 */
1221 if (keycode < 128) {
1222 put_queue(vc, keycode | (!down << 7));
1223 } else {
1224 put_queue(vc, !down << 7);
1225 put_queue(vc, (keycode >> 7) | 0x80);
1226 put_queue(vc, keycode | 0x80);
1227 }
1228 raw_mode = true;
1229 }
1230
1231 if (down)
1232 set_bit(keycode, key_down);
1233 else
1234 clear_bit(keycode, key_down);
1235
1236 if (rep &&
1237 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1238 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1239 /*
1240 * Don't repeat a key if the input buffers are not empty and the
1241 * characters get aren't echoed locally. This makes key repeat
1242 * usable with slow applications and under heavy loads.
1243 */
1244 return;
1245 }
1246
1247 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1248 param.ledstate = kbd->ledflagstate;
1249 key_map = key_maps[shift_final];
1250
1251 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1252 KBD_KEYCODE, ¶m);
1253 if (rc == NOTIFY_STOP || !key_map) {
1254 atomic_notifier_call_chain(&keyboard_notifier_list,
1255 KBD_UNBOUND_KEYCODE, ¶m);
1256 compute_shiftstate();
1257 kbd->slockstate = 0;
1258 return;
1259 }
1260
1261 if (keycode < NR_KEYS)
1262 keysym = key_map[keycode];
1263 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1264 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1265 else
1266 return;
1267
1268 type = KTYP(keysym);
1269
1270 if (type < 0xf0) {
1271 param.value = keysym;
1272 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1273 KBD_UNICODE, ¶m);
1274 if (rc != NOTIFY_STOP)
1275 if (down && !raw_mode)
1276 to_utf8(vc, keysym);
1277 return;
1278 }
1279
1280 type -= 0xf0;
1281
1282 if (type == KT_LETTER) {
1283 type = KT_LATIN;
1284 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1285 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1286 if (key_map)
1287 keysym = key_map[keycode];
1288 }
1289 }
1290
1291 param.value = keysym;
1292 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1293 KBD_KEYSYM, ¶m);
1294 if (rc == NOTIFY_STOP)
1295 return;
1296
1297 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1298 return;
1299
1300 (*k_handler[type])(vc, keysym & 0xff, !down);
1301
1302 param.ledstate = kbd->ledflagstate;
1303 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1304
1305 if (type != KT_SLOCK)
1306 kbd->slockstate = 0;
1307}
1308
1309static void kbd_event(struct input_handle *handle, unsigned int event_type,
1310 unsigned int event_code, int value)
1311{
1312 /* We are called with interrupts disabled, just take the lock */
1313 spin_lock(&kbd_event_lock);
1314
1315 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1316 kbd_rawcode(value);
1317 if (event_type == EV_KEY)
1318 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1319
1320 spin_unlock(&kbd_event_lock);
1321
1322 tasklet_schedule(&keyboard_tasklet);
1323 do_poke_blanked_console = 1;
1324 schedule_console_callback();
1325}
1326
1327static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1328{
1329 int i;
1330
1331 if (test_bit(EV_SND, dev->evbit))
1332 return true;
1333
1334 if (test_bit(EV_KEY, dev->evbit)) {
1335 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1336 if (test_bit(i, dev->keybit))
1337 return true;
1338 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1339 if (test_bit(i, dev->keybit))
1340 return true;
1341 }
1342
1343 return false;
1344}
1345
1346/*
1347 * When a keyboard (or other input device) is found, the kbd_connect
1348 * function is called. The function then looks at the device, and if it
1349 * likes it, it can open it and get events from it. In this (kbd_connect)
1350 * function, we should decide which VT to bind that keyboard to initially.
1351 */
1352static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1353 const struct input_device_id *id)
1354{
1355 struct input_handle *handle;
1356 int error;
1357
1358 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1359 if (!handle)
1360 return -ENOMEM;
1361
1362 handle->dev = dev;
1363 handle->handler = handler;
1364 handle->name = "kbd";
1365
1366 error = input_register_handle(handle);
1367 if (error)
1368 goto err_free_handle;
1369
1370 error = input_open_device(handle);
1371 if (error)
1372 goto err_unregister_handle;
1373
1374 return 0;
1375
1376 err_unregister_handle:
1377 input_unregister_handle(handle);
1378 err_free_handle:
1379 kfree(handle);
1380 return error;
1381}
1382
1383static void kbd_disconnect(struct input_handle *handle)
1384{
1385 input_close_device(handle);
1386 input_unregister_handle(handle);
1387 kfree(handle);
1388}
1389
1390/*
1391 * Start keyboard handler on the new keyboard by refreshing LED state to
1392 * match the rest of the system.
1393 */
1394static void kbd_start(struct input_handle *handle)
1395{
1396 tasklet_disable(&keyboard_tasklet);
1397
1398 if (ledstate != 0xff)
1399 kbd_update_leds_helper(handle, &ledstate);
1400
1401 tasklet_enable(&keyboard_tasklet);
1402}
1403
1404static const struct input_device_id kbd_ids[] = {
1405 {
1406 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1407 .evbit = { BIT_MASK(EV_KEY) },
1408 },
1409
1410 {
1411 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1412 .evbit = { BIT_MASK(EV_SND) },
1413 },
1414
1415 { }, /* Terminating entry */
1416};
1417
1418MODULE_DEVICE_TABLE(input, kbd_ids);
1419
1420static struct input_handler kbd_handler = {
1421 .event = kbd_event,
1422 .match = kbd_match,
1423 .connect = kbd_connect,
1424 .disconnect = kbd_disconnect,
1425 .start = kbd_start,
1426 .name = "kbd",
1427 .id_table = kbd_ids,
1428};
1429
1430int __init kbd_init(void)
1431{
1432 int i;
1433 int error;
1434
1435 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1436 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1437 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1438 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1439 kbd_table[i].lockstate = KBD_DEFLOCK;
1440 kbd_table[i].slockstate = 0;
1441 kbd_table[i].modeflags = KBD_DEFMODE;
1442 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1443 }
1444
1445 error = input_register_handler(&kbd_handler);
1446 if (error)
1447 return error;
1448
1449 tasklet_enable(&keyboard_tasklet);
1450 tasklet_schedule(&keyboard_tasklet);
1451
1452 return 0;
1453}
1/*
2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
4 *
5 * Some additional features added by Christoph Niemann (ChN), March 1993
6 *
7 * Loadable keymaps by Risto Kankkunen, May 1993
8 *
9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
10 * Added decr/incr_console, dynamic keymaps, Unicode support,
11 * dynamic function/string keys, led setting, Sept 1994
12 * `Sticky' modifier keys, 951006.
13 *
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
15 *
16 * Modified to provide 'generic' keyboard support by Hamish Macdonald
17 * Merge with the m68k keyboard driver and split-off of the PC low-level
18 * parts by Geert Uytterhoeven, May 1997
19 *
20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
21 * 30-07-98: Dead keys redone, aeb@cwi.nl.
22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
23 */
24
25#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27#include <linux/consolemap.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/input.h>
41#include <linux/reboot.h>
42#include <linux/notifier.h>
43#include <linux/jiffies.h>
44#include <linux/uaccess.h>
45
46#include <asm/irq_regs.h>
47
48extern void ctrl_alt_del(void);
49
50/*
51 * Exported functions/variables
52 */
53
54#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
55
56#if defined(CONFIG_X86) || defined(CONFIG_PARISC)
57#include <asm/kbdleds.h>
58#else
59static inline int kbd_defleds(void)
60{
61 return 0;
62}
63#endif
64
65#define KBD_DEFLOCK 0
66
67/*
68 * Handler Tables.
69 */
70
71#define K_HANDLERS\
72 k_self, k_fn, k_spec, k_pad,\
73 k_dead, k_cons, k_cur, k_shift,\
74 k_meta, k_ascii, k_lock, k_lowercase,\
75 k_slock, k_dead2, k_brl, k_ignore
76
77typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
78 char up_flag);
79static k_handler_fn K_HANDLERS;
80static k_handler_fn *k_handler[16] = { K_HANDLERS };
81
82#define FN_HANDLERS\
83 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
84 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
85 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
86 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
87 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
88
89typedef void (fn_handler_fn)(struct vc_data *vc);
90static fn_handler_fn FN_HANDLERS;
91static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
92
93/*
94 * Variables exported for vt_ioctl.c
95 */
96
97struct vt_spawn_console vt_spawn_con = {
98 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
99 .pid = NULL,
100 .sig = 0,
101};
102
103
104/*
105 * Internal Data.
106 */
107
108static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109static struct kbd_struct *kbd = kbd_table;
110
111/* maximum values each key_handler can handle */
112static const int max_vals[] = {
113 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
114 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
115 255, NR_LOCK - 1, 255, NR_BRL - 1
116};
117
118static const int NR_TYPES = ARRAY_SIZE(max_vals);
119
120static struct input_handler kbd_handler;
121static DEFINE_SPINLOCK(kbd_event_lock);
122static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
123static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
124static bool dead_key_next;
125static int npadch = -1; /* -1 or number assembled on pad */
126static unsigned int diacr;
127static char rep; /* flag telling character repeat */
128
129static int shift_state = 0;
130
131static unsigned char ledstate = 0xff; /* undefined */
132static unsigned char ledioctl;
133
134static struct ledptr {
135 unsigned int *addr;
136 unsigned int mask;
137 unsigned char valid:1;
138} ledptrs[3];
139
140/*
141 * Notifier list for console keyboard events
142 */
143static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
144
145int register_keyboard_notifier(struct notifier_block *nb)
146{
147 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
148}
149EXPORT_SYMBOL_GPL(register_keyboard_notifier);
150
151int unregister_keyboard_notifier(struct notifier_block *nb)
152{
153 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
154}
155EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
156
157/*
158 * Translation of scancodes to keycodes. We set them on only the first
159 * keyboard in the list that accepts the scancode and keycode.
160 * Explanation for not choosing the first attached keyboard anymore:
161 * USB keyboards for example have two event devices: one for all "normal"
162 * keys and one for extra function keys (like "volume up", "make coffee",
163 * etc.). So this means that scancodes for the extra function keys won't
164 * be valid for the first event device, but will be for the second.
165 */
166
167struct getset_keycode_data {
168 struct input_keymap_entry ke;
169 int error;
170};
171
172static int getkeycode_helper(struct input_handle *handle, void *data)
173{
174 struct getset_keycode_data *d = data;
175
176 d->error = input_get_keycode(handle->dev, &d->ke);
177
178 return d->error == 0; /* stop as soon as we successfully get one */
179}
180
181static int getkeycode(unsigned int scancode)
182{
183 struct getset_keycode_data d = {
184 .ke = {
185 .flags = 0,
186 .len = sizeof(scancode),
187 .keycode = 0,
188 },
189 .error = -ENODEV,
190 };
191
192 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
193
194 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
195
196 return d.error ?: d.ke.keycode;
197}
198
199static int setkeycode_helper(struct input_handle *handle, void *data)
200{
201 struct getset_keycode_data *d = data;
202
203 d->error = input_set_keycode(handle->dev, &d->ke);
204
205 return d->error == 0; /* stop as soon as we successfully set one */
206}
207
208static int setkeycode(unsigned int scancode, unsigned int keycode)
209{
210 struct getset_keycode_data d = {
211 .ke = {
212 .flags = 0,
213 .len = sizeof(scancode),
214 .keycode = keycode,
215 },
216 .error = -ENODEV,
217 };
218
219 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
220
221 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
222
223 return d.error;
224}
225
226/*
227 * Making beeps and bells. Note that we prefer beeps to bells, but when
228 * shutting the sound off we do both.
229 */
230
231static int kd_sound_helper(struct input_handle *handle, void *data)
232{
233 unsigned int *hz = data;
234 struct input_dev *dev = handle->dev;
235
236 if (test_bit(EV_SND, dev->evbit)) {
237 if (test_bit(SND_TONE, dev->sndbit)) {
238 input_inject_event(handle, EV_SND, SND_TONE, *hz);
239 if (*hz)
240 return 0;
241 }
242 if (test_bit(SND_BELL, dev->sndbit))
243 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
244 }
245
246 return 0;
247}
248
249static void kd_nosound(unsigned long ignored)
250{
251 static unsigned int zero;
252
253 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
254}
255
256static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
257
258void kd_mksound(unsigned int hz, unsigned int ticks)
259{
260 del_timer_sync(&kd_mksound_timer);
261
262 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
263
264 if (hz && ticks)
265 mod_timer(&kd_mksound_timer, jiffies + ticks);
266}
267EXPORT_SYMBOL(kd_mksound);
268
269/*
270 * Setting the keyboard rate.
271 */
272
273static int kbd_rate_helper(struct input_handle *handle, void *data)
274{
275 struct input_dev *dev = handle->dev;
276 struct kbd_repeat *rep = data;
277
278 if (test_bit(EV_REP, dev->evbit)) {
279
280 if (rep[0].delay > 0)
281 input_inject_event(handle,
282 EV_REP, REP_DELAY, rep[0].delay);
283 if (rep[0].period > 0)
284 input_inject_event(handle,
285 EV_REP, REP_PERIOD, rep[0].period);
286
287 rep[1].delay = dev->rep[REP_DELAY];
288 rep[1].period = dev->rep[REP_PERIOD];
289 }
290
291 return 0;
292}
293
294int kbd_rate(struct kbd_repeat *rep)
295{
296 struct kbd_repeat data[2] = { *rep };
297
298 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
299 *rep = data[1]; /* Copy currently used settings */
300
301 return 0;
302}
303
304/*
305 * Helper Functions.
306 */
307static void put_queue(struct vc_data *vc, int ch)
308{
309 struct tty_struct *tty = vc->port.tty;
310
311 if (tty) {
312 tty_insert_flip_char(tty, ch, 0);
313 con_schedule_flip(tty);
314 }
315}
316
317static void puts_queue(struct vc_data *vc, char *cp)
318{
319 struct tty_struct *tty = vc->port.tty;
320
321 if (!tty)
322 return;
323
324 while (*cp) {
325 tty_insert_flip_char(tty, *cp, 0);
326 cp++;
327 }
328 con_schedule_flip(tty);
329}
330
331static void applkey(struct vc_data *vc, int key, char mode)
332{
333 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
334
335 buf[1] = (mode ? 'O' : '[');
336 buf[2] = key;
337 puts_queue(vc, buf);
338}
339
340/*
341 * Many other routines do put_queue, but I think either
342 * they produce ASCII, or they produce some user-assigned
343 * string, and in both cases we might assume that it is
344 * in utf-8 already.
345 */
346static void to_utf8(struct vc_data *vc, uint c)
347{
348 if (c < 0x80)
349 /* 0******* */
350 put_queue(vc, c);
351 else if (c < 0x800) {
352 /* 110***** 10****** */
353 put_queue(vc, 0xc0 | (c >> 6));
354 put_queue(vc, 0x80 | (c & 0x3f));
355 } else if (c < 0x10000) {
356 if (c >= 0xD800 && c < 0xE000)
357 return;
358 if (c == 0xFFFF)
359 return;
360 /* 1110**** 10****** 10****** */
361 put_queue(vc, 0xe0 | (c >> 12));
362 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
363 put_queue(vc, 0x80 | (c & 0x3f));
364 } else if (c < 0x110000) {
365 /* 11110*** 10****** 10****** 10****** */
366 put_queue(vc, 0xf0 | (c >> 18));
367 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
368 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
369 put_queue(vc, 0x80 | (c & 0x3f));
370 }
371}
372
373/*
374 * Called after returning from RAW mode or when changing consoles - recompute
375 * shift_down[] and shift_state from key_down[] maybe called when keymap is
376 * undefined, so that shiftkey release is seen. The caller must hold the
377 * kbd_event_lock.
378 */
379
380static void do_compute_shiftstate(void)
381{
382 unsigned int i, j, k, sym, val;
383
384 shift_state = 0;
385 memset(shift_down, 0, sizeof(shift_down));
386
387 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
388
389 if (!key_down[i])
390 continue;
391
392 k = i * BITS_PER_LONG;
393
394 for (j = 0; j < BITS_PER_LONG; j++, k++) {
395
396 if (!test_bit(k, key_down))
397 continue;
398
399 sym = U(key_maps[0][k]);
400 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
401 continue;
402
403 val = KVAL(sym);
404 if (val == KVAL(K_CAPSSHIFT))
405 val = KVAL(K_SHIFT);
406
407 shift_down[val]++;
408 shift_state |= (1 << val);
409 }
410 }
411}
412
413/* We still have to export this method to vt.c */
414void compute_shiftstate(void)
415{
416 unsigned long flags;
417 spin_lock_irqsave(&kbd_event_lock, flags);
418 do_compute_shiftstate();
419 spin_unlock_irqrestore(&kbd_event_lock, flags);
420}
421
422/*
423 * We have a combining character DIACR here, followed by the character CH.
424 * If the combination occurs in the table, return the corresponding value.
425 * Otherwise, if CH is a space or equals DIACR, return DIACR.
426 * Otherwise, conclude that DIACR was not combining after all,
427 * queue it and return CH.
428 */
429static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
430{
431 unsigned int d = diacr;
432 unsigned int i;
433
434 diacr = 0;
435
436 if ((d & ~0xff) == BRL_UC_ROW) {
437 if ((ch & ~0xff) == BRL_UC_ROW)
438 return d | ch;
439 } else {
440 for (i = 0; i < accent_table_size; i++)
441 if (accent_table[i].diacr == d && accent_table[i].base == ch)
442 return accent_table[i].result;
443 }
444
445 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
446 return d;
447
448 if (kbd->kbdmode == VC_UNICODE)
449 to_utf8(vc, d);
450 else {
451 int c = conv_uni_to_8bit(d);
452 if (c != -1)
453 put_queue(vc, c);
454 }
455
456 return ch;
457}
458
459/*
460 * Special function handlers
461 */
462static void fn_enter(struct vc_data *vc)
463{
464 if (diacr) {
465 if (kbd->kbdmode == VC_UNICODE)
466 to_utf8(vc, diacr);
467 else {
468 int c = conv_uni_to_8bit(diacr);
469 if (c != -1)
470 put_queue(vc, c);
471 }
472 diacr = 0;
473 }
474
475 put_queue(vc, 13);
476 if (vc_kbd_mode(kbd, VC_CRLF))
477 put_queue(vc, 10);
478}
479
480static void fn_caps_toggle(struct vc_data *vc)
481{
482 if (rep)
483 return;
484
485 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
486}
487
488static void fn_caps_on(struct vc_data *vc)
489{
490 if (rep)
491 return;
492
493 set_vc_kbd_led(kbd, VC_CAPSLOCK);
494}
495
496static void fn_show_ptregs(struct vc_data *vc)
497{
498 struct pt_regs *regs = get_irq_regs();
499
500 if (regs)
501 show_regs(regs);
502}
503
504static void fn_hold(struct vc_data *vc)
505{
506 struct tty_struct *tty = vc->port.tty;
507
508 if (rep || !tty)
509 return;
510
511 /*
512 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
513 * these routines are also activated by ^S/^Q.
514 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
515 */
516 if (tty->stopped)
517 start_tty(tty);
518 else
519 stop_tty(tty);
520}
521
522static void fn_num(struct vc_data *vc)
523{
524 if (vc_kbd_mode(kbd, VC_APPLIC))
525 applkey(vc, 'P', 1);
526 else
527 fn_bare_num(vc);
528}
529
530/*
531 * Bind this to Shift-NumLock if you work in application keypad mode
532 * but want to be able to change the NumLock flag.
533 * Bind this to NumLock if you prefer that the NumLock key always
534 * changes the NumLock flag.
535 */
536static void fn_bare_num(struct vc_data *vc)
537{
538 if (!rep)
539 chg_vc_kbd_led(kbd, VC_NUMLOCK);
540}
541
542static void fn_lastcons(struct vc_data *vc)
543{
544 /* switch to the last used console, ChN */
545 set_console(last_console);
546}
547
548static void fn_dec_console(struct vc_data *vc)
549{
550 int i, cur = fg_console;
551
552 /* Currently switching? Queue this next switch relative to that. */
553 if (want_console != -1)
554 cur = want_console;
555
556 for (i = cur - 1; i != cur; i--) {
557 if (i == -1)
558 i = MAX_NR_CONSOLES - 1;
559 if (vc_cons_allocated(i))
560 break;
561 }
562 set_console(i);
563}
564
565static void fn_inc_console(struct vc_data *vc)
566{
567 int i, cur = fg_console;
568
569 /* Currently switching? Queue this next switch relative to that. */
570 if (want_console != -1)
571 cur = want_console;
572
573 for (i = cur+1; i != cur; i++) {
574 if (i == MAX_NR_CONSOLES)
575 i = 0;
576 if (vc_cons_allocated(i))
577 break;
578 }
579 set_console(i);
580}
581
582static void fn_send_intr(struct vc_data *vc)
583{
584 struct tty_struct *tty = vc->port.tty;
585
586 if (!tty)
587 return;
588 tty_insert_flip_char(tty, 0, TTY_BREAK);
589 con_schedule_flip(tty);
590}
591
592static void fn_scroll_forw(struct vc_data *vc)
593{
594 scrollfront(vc, 0);
595}
596
597static void fn_scroll_back(struct vc_data *vc)
598{
599 scrollback(vc, 0);
600}
601
602static void fn_show_mem(struct vc_data *vc)
603{
604 show_mem(0);
605}
606
607static void fn_show_state(struct vc_data *vc)
608{
609 show_state();
610}
611
612static void fn_boot_it(struct vc_data *vc)
613{
614 ctrl_alt_del();
615}
616
617static void fn_compose(struct vc_data *vc)
618{
619 dead_key_next = true;
620}
621
622static void fn_spawn_con(struct vc_data *vc)
623{
624 spin_lock(&vt_spawn_con.lock);
625 if (vt_spawn_con.pid)
626 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
627 put_pid(vt_spawn_con.pid);
628 vt_spawn_con.pid = NULL;
629 }
630 spin_unlock(&vt_spawn_con.lock);
631}
632
633static void fn_SAK(struct vc_data *vc)
634{
635 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
636 schedule_work(SAK_work);
637}
638
639static void fn_null(struct vc_data *vc)
640{
641 do_compute_shiftstate();
642}
643
644/*
645 * Special key handlers
646 */
647static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
648{
649}
650
651static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
652{
653 if (up_flag)
654 return;
655 if (value >= ARRAY_SIZE(fn_handler))
656 return;
657 if ((kbd->kbdmode == VC_RAW ||
658 kbd->kbdmode == VC_MEDIUMRAW ||
659 kbd->kbdmode == VC_OFF) &&
660 value != KVAL(K_SAK))
661 return; /* SAK is allowed even in raw mode */
662 fn_handler[value](vc);
663}
664
665static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
666{
667 pr_err("k_lowercase was called - impossible\n");
668}
669
670static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
671{
672 if (up_flag)
673 return; /* no action, if this is a key release */
674
675 if (diacr)
676 value = handle_diacr(vc, value);
677
678 if (dead_key_next) {
679 dead_key_next = false;
680 diacr = value;
681 return;
682 }
683 if (kbd->kbdmode == VC_UNICODE)
684 to_utf8(vc, value);
685 else {
686 int c = conv_uni_to_8bit(value);
687 if (c != -1)
688 put_queue(vc, c);
689 }
690}
691
692/*
693 * Handle dead key. Note that we now may have several
694 * dead keys modifying the same character. Very useful
695 * for Vietnamese.
696 */
697static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
698{
699 if (up_flag)
700 return;
701
702 diacr = (diacr ? handle_diacr(vc, value) : value);
703}
704
705static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
706{
707 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
708}
709
710static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
711{
712 k_deadunicode(vc, value, up_flag);
713}
714
715/*
716 * Obsolete - for backwards compatibility only
717 */
718static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
719{
720 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
721
722 k_deadunicode(vc, ret_diacr[value], up_flag);
723}
724
725static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
726{
727 if (up_flag)
728 return;
729
730 set_console(value);
731}
732
733static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
734{
735 if (up_flag)
736 return;
737
738 if ((unsigned)value < ARRAY_SIZE(func_table)) {
739 if (func_table[value])
740 puts_queue(vc, func_table[value]);
741 } else
742 pr_err("k_fn called with value=%d\n", value);
743}
744
745static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
746{
747 static const char cur_chars[] = "BDCA";
748
749 if (up_flag)
750 return;
751
752 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
753}
754
755static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
756{
757 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
758 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
759
760 if (up_flag)
761 return; /* no action, if this is a key release */
762
763 /* kludge... shift forces cursor/number keys */
764 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
765 applkey(vc, app_map[value], 1);
766 return;
767 }
768
769 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
770
771 switch (value) {
772 case KVAL(K_PCOMMA):
773 case KVAL(K_PDOT):
774 k_fn(vc, KVAL(K_REMOVE), 0);
775 return;
776 case KVAL(K_P0):
777 k_fn(vc, KVAL(K_INSERT), 0);
778 return;
779 case KVAL(K_P1):
780 k_fn(vc, KVAL(K_SELECT), 0);
781 return;
782 case KVAL(K_P2):
783 k_cur(vc, KVAL(K_DOWN), 0);
784 return;
785 case KVAL(K_P3):
786 k_fn(vc, KVAL(K_PGDN), 0);
787 return;
788 case KVAL(K_P4):
789 k_cur(vc, KVAL(K_LEFT), 0);
790 return;
791 case KVAL(K_P6):
792 k_cur(vc, KVAL(K_RIGHT), 0);
793 return;
794 case KVAL(K_P7):
795 k_fn(vc, KVAL(K_FIND), 0);
796 return;
797 case KVAL(K_P8):
798 k_cur(vc, KVAL(K_UP), 0);
799 return;
800 case KVAL(K_P9):
801 k_fn(vc, KVAL(K_PGUP), 0);
802 return;
803 case KVAL(K_P5):
804 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
805 return;
806 }
807 }
808
809 put_queue(vc, pad_chars[value]);
810 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
811 put_queue(vc, 10);
812}
813
814static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
815{
816 int old_state = shift_state;
817
818 if (rep)
819 return;
820 /*
821 * Mimic typewriter:
822 * a CapsShift key acts like Shift but undoes CapsLock
823 */
824 if (value == KVAL(K_CAPSSHIFT)) {
825 value = KVAL(K_SHIFT);
826 if (!up_flag)
827 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
828 }
829
830 if (up_flag) {
831 /*
832 * handle the case that two shift or control
833 * keys are depressed simultaneously
834 */
835 if (shift_down[value])
836 shift_down[value]--;
837 } else
838 shift_down[value]++;
839
840 if (shift_down[value])
841 shift_state |= (1 << value);
842 else
843 shift_state &= ~(1 << value);
844
845 /* kludge */
846 if (up_flag && shift_state != old_state && npadch != -1) {
847 if (kbd->kbdmode == VC_UNICODE)
848 to_utf8(vc, npadch);
849 else
850 put_queue(vc, npadch & 0xff);
851 npadch = -1;
852 }
853}
854
855static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
856{
857 if (up_flag)
858 return;
859
860 if (vc_kbd_mode(kbd, VC_META)) {
861 put_queue(vc, '\033');
862 put_queue(vc, value);
863 } else
864 put_queue(vc, value | 0x80);
865}
866
867static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
868{
869 int base;
870
871 if (up_flag)
872 return;
873
874 if (value < 10) {
875 /* decimal input of code, while Alt depressed */
876 base = 10;
877 } else {
878 /* hexadecimal input of code, while AltGr depressed */
879 value -= 10;
880 base = 16;
881 }
882
883 if (npadch == -1)
884 npadch = value;
885 else
886 npadch = npadch * base + value;
887}
888
889static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
890{
891 if (up_flag || rep)
892 return;
893
894 chg_vc_kbd_lock(kbd, value);
895}
896
897static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
898{
899 k_shift(vc, value, up_flag);
900 if (up_flag || rep)
901 return;
902
903 chg_vc_kbd_slock(kbd, value);
904 /* try to make Alt, oops, AltGr and such work */
905 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
906 kbd->slockstate = 0;
907 chg_vc_kbd_slock(kbd, value);
908 }
909}
910
911/* by default, 300ms interval for combination release */
912static unsigned brl_timeout = 300;
913MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
914module_param(brl_timeout, uint, 0644);
915
916static unsigned brl_nbchords = 1;
917MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
918module_param(brl_nbchords, uint, 0644);
919
920static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
921{
922 static unsigned long chords;
923 static unsigned committed;
924
925 if (!brl_nbchords)
926 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
927 else {
928 committed |= pattern;
929 chords++;
930 if (chords == brl_nbchords) {
931 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
932 chords = 0;
933 committed = 0;
934 }
935 }
936}
937
938static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
939{
940 static unsigned pressed, committing;
941 static unsigned long releasestart;
942
943 if (kbd->kbdmode != VC_UNICODE) {
944 if (!up_flag)
945 pr_warning("keyboard mode must be unicode for braille patterns\n");
946 return;
947 }
948
949 if (!value) {
950 k_unicode(vc, BRL_UC_ROW, up_flag);
951 return;
952 }
953
954 if (value > 8)
955 return;
956
957 if (!up_flag) {
958 pressed |= 1 << (value - 1);
959 if (!brl_timeout)
960 committing = pressed;
961 } else if (brl_timeout) {
962 if (!committing ||
963 time_after(jiffies,
964 releasestart + msecs_to_jiffies(brl_timeout))) {
965 committing = pressed;
966 releasestart = jiffies;
967 }
968 pressed &= ~(1 << (value - 1));
969 if (!pressed && committing) {
970 k_brlcommit(vc, committing, 0);
971 committing = 0;
972 }
973 } else {
974 if (committing) {
975 k_brlcommit(vc, committing, 0);
976 committing = 0;
977 }
978 pressed &= ~(1 << (value - 1));
979 }
980}
981
982/*
983 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
984 * or (ii) whatever pattern of lights people want to show using KDSETLED,
985 * or (iii) specified bits of specified words in kernel memory.
986 */
987unsigned char getledstate(void)
988{
989 return ledstate;
990}
991
992void setledstate(struct kbd_struct *kbd, unsigned int led)
993{
994 unsigned long flags;
995 spin_lock_irqsave(&kbd_event_lock, flags);
996 if (!(led & ~7)) {
997 ledioctl = led;
998 kbd->ledmode = LED_SHOW_IOCTL;
999 } else
1000 kbd->ledmode = LED_SHOW_FLAGS;
1001
1002 set_leds();
1003 spin_unlock_irqrestore(&kbd_event_lock, flags);
1004}
1005
1006static inline unsigned char getleds(void)
1007{
1008 struct kbd_struct *kbd = kbd_table + fg_console;
1009 unsigned char leds;
1010 int i;
1011
1012 if (kbd->ledmode == LED_SHOW_IOCTL)
1013 return ledioctl;
1014
1015 leds = kbd->ledflagstate;
1016
1017 if (kbd->ledmode == LED_SHOW_MEM) {
1018 for (i = 0; i < 3; i++)
1019 if (ledptrs[i].valid) {
1020 if (*ledptrs[i].addr & ledptrs[i].mask)
1021 leds |= (1 << i);
1022 else
1023 leds &= ~(1 << i);
1024 }
1025 }
1026 return leds;
1027}
1028
1029static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1030{
1031 unsigned char leds = *(unsigned char *)data;
1032
1033 if (test_bit(EV_LED, handle->dev->evbit)) {
1034 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1035 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1036 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1037 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1038 }
1039
1040 return 0;
1041}
1042
1043/**
1044 * vt_get_leds - helper for braille console
1045 * @console: console to read
1046 * @flag: flag we want to check
1047 *
1048 * Check the status of a keyboard led flag and report it back
1049 */
1050int vt_get_leds(int console, int flag)
1051{
1052 struct kbd_struct * kbd = kbd_table + console;
1053 int ret;
1054
1055 ret = vc_kbd_led(kbd, flag);
1056
1057 return ret;
1058}
1059EXPORT_SYMBOL_GPL(vt_get_leds);
1060
1061/**
1062 * vt_set_led_state - set LED state of a console
1063 * @console: console to set
1064 * @leds: LED bits
1065 *
1066 * Set the LEDs on a console. This is a wrapper for the VT layer
1067 * so that we can keep kbd knowledge internal
1068 */
1069void vt_set_led_state(int console, int leds)
1070{
1071 struct kbd_struct * kbd = kbd_table + console;
1072 setledstate(kbd, leds);
1073}
1074
1075/**
1076 * vt_kbd_con_start - Keyboard side of console start
1077 * @console: console
1078 *
1079 * Handle console start. This is a wrapper for the VT layer
1080 * so that we can keep kbd knowledge internal
1081 *
1082 * FIXME: We eventually need to hold the kbd lock here to protect
1083 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1084 * and start_tty under the kbd_event_lock, while normal tty paths
1085 * don't hold the lock. We probably need to split out an LED lock
1086 * but not during an -rc release!
1087 */
1088void vt_kbd_con_start(int console)
1089{
1090 struct kbd_struct * kbd = kbd_table + console;
1091/* unsigned long flags; */
1092/* spin_lock_irqsave(&kbd_event_lock, flags); */
1093 clr_vc_kbd_led(kbd, VC_SCROLLOCK);
1094 set_leds();
1095/* spin_unlock_irqrestore(&kbd_event_lock, flags); */
1096}
1097
1098/**
1099 * vt_kbd_con_stop - Keyboard side of console stop
1100 * @console: console
1101 *
1102 * Handle console stop. This is a wrapper for the VT layer
1103 * so that we can keep kbd knowledge internal
1104 *
1105 * FIXME: We eventually need to hold the kbd lock here to protect
1106 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1107 * and start_tty under the kbd_event_lock, while normal tty paths
1108 * don't hold the lock. We probably need to split out an LED lock
1109 * but not during an -rc release!
1110 */
1111void vt_kbd_con_stop(int console)
1112{
1113 struct kbd_struct * kbd = kbd_table + console;
1114/* unsigned long flags; */
1115/* spin_lock_irqsave(&kbd_event_lock, flags); */
1116 set_vc_kbd_led(kbd, VC_SCROLLOCK);
1117 set_leds();
1118/* spin_unlock_irqrestore(&kbd_event_lock, flags); */
1119}
1120
1121/*
1122 * This is the tasklet that updates LED state on all keyboards
1123 * attached to the box. The reason we use tasklet is that we
1124 * need to handle the scenario when keyboard handler is not
1125 * registered yet but we already getting updates from the VT to
1126 * update led state.
1127 */
1128static void kbd_bh(unsigned long dummy)
1129{
1130 unsigned char leds = getleds();
1131
1132 if (leds != ledstate) {
1133 input_handler_for_each_handle(&kbd_handler, &leds,
1134 kbd_update_leds_helper);
1135 ledstate = leds;
1136 }
1137}
1138
1139DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1140
1141#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1142 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1143 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1144 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1145 defined(CONFIG_AVR32)
1146
1147#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1148 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1149
1150static const unsigned short x86_keycodes[256] =
1151 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1152 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1153 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1154 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1155 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1156 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1157 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1158 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1159 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1160 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1161 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1162 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1163 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1164 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1165 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1166
1167#ifdef CONFIG_SPARC
1168static int sparc_l1_a_state;
1169extern void sun_do_break(void);
1170#endif
1171
1172static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1173 unsigned char up_flag)
1174{
1175 int code;
1176
1177 switch (keycode) {
1178
1179 case KEY_PAUSE:
1180 put_queue(vc, 0xe1);
1181 put_queue(vc, 0x1d | up_flag);
1182 put_queue(vc, 0x45 | up_flag);
1183 break;
1184
1185 case KEY_HANGEUL:
1186 if (!up_flag)
1187 put_queue(vc, 0xf2);
1188 break;
1189
1190 case KEY_HANJA:
1191 if (!up_flag)
1192 put_queue(vc, 0xf1);
1193 break;
1194
1195 case KEY_SYSRQ:
1196 /*
1197 * Real AT keyboards (that's what we're trying
1198 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1199 * pressing PrtSc/SysRq alone, but simply 0x54
1200 * when pressing Alt+PrtSc/SysRq.
1201 */
1202 if (test_bit(KEY_LEFTALT, key_down) ||
1203 test_bit(KEY_RIGHTALT, key_down)) {
1204 put_queue(vc, 0x54 | up_flag);
1205 } else {
1206 put_queue(vc, 0xe0);
1207 put_queue(vc, 0x2a | up_flag);
1208 put_queue(vc, 0xe0);
1209 put_queue(vc, 0x37 | up_flag);
1210 }
1211 break;
1212
1213 default:
1214 if (keycode > 255)
1215 return -1;
1216
1217 code = x86_keycodes[keycode];
1218 if (!code)
1219 return -1;
1220
1221 if (code & 0x100)
1222 put_queue(vc, 0xe0);
1223 put_queue(vc, (code & 0x7f) | up_flag);
1224
1225 break;
1226 }
1227
1228 return 0;
1229}
1230
1231#else
1232
1233#define HW_RAW(dev) 0
1234
1235static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1236{
1237 if (keycode > 127)
1238 return -1;
1239
1240 put_queue(vc, keycode | up_flag);
1241 return 0;
1242}
1243#endif
1244
1245static void kbd_rawcode(unsigned char data)
1246{
1247 struct vc_data *vc = vc_cons[fg_console].d;
1248
1249 kbd = kbd_table + vc->vc_num;
1250 if (kbd->kbdmode == VC_RAW)
1251 put_queue(vc, data);
1252}
1253
1254static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1255{
1256 struct vc_data *vc = vc_cons[fg_console].d;
1257 unsigned short keysym, *key_map;
1258 unsigned char type;
1259 bool raw_mode;
1260 struct tty_struct *tty;
1261 int shift_final;
1262 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1263 int rc;
1264
1265 tty = vc->port.tty;
1266
1267 if (tty && (!tty->driver_data)) {
1268 /* No driver data? Strange. Okay we fix it then. */
1269 tty->driver_data = vc;
1270 }
1271
1272 kbd = kbd_table + vc->vc_num;
1273
1274#ifdef CONFIG_SPARC
1275 if (keycode == KEY_STOP)
1276 sparc_l1_a_state = down;
1277#endif
1278
1279 rep = (down == 2);
1280
1281 raw_mode = (kbd->kbdmode == VC_RAW);
1282 if (raw_mode && !hw_raw)
1283 if (emulate_raw(vc, keycode, !down << 7))
1284 if (keycode < BTN_MISC && printk_ratelimit())
1285 pr_warning("can't emulate rawmode for keycode %d\n",
1286 keycode);
1287
1288#ifdef CONFIG_SPARC
1289 if (keycode == KEY_A && sparc_l1_a_state) {
1290 sparc_l1_a_state = false;
1291 sun_do_break();
1292 }
1293#endif
1294
1295 if (kbd->kbdmode == VC_MEDIUMRAW) {
1296 /*
1297 * This is extended medium raw mode, with keys above 127
1298 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1299 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1300 * interfere with anything else. The two bytes after 0 will
1301 * always have the up flag set not to interfere with older
1302 * applications. This allows for 16384 different keycodes,
1303 * which should be enough.
1304 */
1305 if (keycode < 128) {
1306 put_queue(vc, keycode | (!down << 7));
1307 } else {
1308 put_queue(vc, !down << 7);
1309 put_queue(vc, (keycode >> 7) | 0x80);
1310 put_queue(vc, keycode | 0x80);
1311 }
1312 raw_mode = true;
1313 }
1314
1315 if (down)
1316 set_bit(keycode, key_down);
1317 else
1318 clear_bit(keycode, key_down);
1319
1320 if (rep &&
1321 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1322 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1323 /*
1324 * Don't repeat a key if the input buffers are not empty and the
1325 * characters get aren't echoed locally. This makes key repeat
1326 * usable with slow applications and under heavy loads.
1327 */
1328 return;
1329 }
1330
1331 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1332 param.ledstate = kbd->ledflagstate;
1333 key_map = key_maps[shift_final];
1334
1335 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1336 KBD_KEYCODE, ¶m);
1337 if (rc == NOTIFY_STOP || !key_map) {
1338 atomic_notifier_call_chain(&keyboard_notifier_list,
1339 KBD_UNBOUND_KEYCODE, ¶m);
1340 do_compute_shiftstate();
1341 kbd->slockstate = 0;
1342 return;
1343 }
1344
1345 if (keycode < NR_KEYS)
1346 keysym = key_map[keycode];
1347 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1348 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1349 else
1350 return;
1351
1352 type = KTYP(keysym);
1353
1354 if (type < 0xf0) {
1355 param.value = keysym;
1356 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1357 KBD_UNICODE, ¶m);
1358 if (rc != NOTIFY_STOP)
1359 if (down && !raw_mode)
1360 to_utf8(vc, keysym);
1361 return;
1362 }
1363
1364 type -= 0xf0;
1365
1366 if (type == KT_LETTER) {
1367 type = KT_LATIN;
1368 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1369 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1370 if (key_map)
1371 keysym = key_map[keycode];
1372 }
1373 }
1374
1375 param.value = keysym;
1376 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1377 KBD_KEYSYM, ¶m);
1378 if (rc == NOTIFY_STOP)
1379 return;
1380
1381 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1382 return;
1383
1384 (*k_handler[type])(vc, keysym & 0xff, !down);
1385
1386 param.ledstate = kbd->ledflagstate;
1387 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1388
1389 if (type != KT_SLOCK)
1390 kbd->slockstate = 0;
1391}
1392
1393static void kbd_event(struct input_handle *handle, unsigned int event_type,
1394 unsigned int event_code, int value)
1395{
1396 /* We are called with interrupts disabled, just take the lock */
1397 spin_lock(&kbd_event_lock);
1398
1399 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1400 kbd_rawcode(value);
1401 if (event_type == EV_KEY)
1402 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1403
1404 spin_unlock(&kbd_event_lock);
1405
1406 tasklet_schedule(&keyboard_tasklet);
1407 do_poke_blanked_console = 1;
1408 schedule_console_callback();
1409}
1410
1411static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1412{
1413 int i;
1414
1415 if (test_bit(EV_SND, dev->evbit))
1416 return true;
1417
1418 if (test_bit(EV_KEY, dev->evbit)) {
1419 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1420 if (test_bit(i, dev->keybit))
1421 return true;
1422 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1423 if (test_bit(i, dev->keybit))
1424 return true;
1425 }
1426
1427 return false;
1428}
1429
1430/*
1431 * When a keyboard (or other input device) is found, the kbd_connect
1432 * function is called. The function then looks at the device, and if it
1433 * likes it, it can open it and get events from it. In this (kbd_connect)
1434 * function, we should decide which VT to bind that keyboard to initially.
1435 */
1436static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1437 const struct input_device_id *id)
1438{
1439 struct input_handle *handle;
1440 int error;
1441
1442 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1443 if (!handle)
1444 return -ENOMEM;
1445
1446 handle->dev = dev;
1447 handle->handler = handler;
1448 handle->name = "kbd";
1449
1450 error = input_register_handle(handle);
1451 if (error)
1452 goto err_free_handle;
1453
1454 error = input_open_device(handle);
1455 if (error)
1456 goto err_unregister_handle;
1457
1458 return 0;
1459
1460 err_unregister_handle:
1461 input_unregister_handle(handle);
1462 err_free_handle:
1463 kfree(handle);
1464 return error;
1465}
1466
1467static void kbd_disconnect(struct input_handle *handle)
1468{
1469 input_close_device(handle);
1470 input_unregister_handle(handle);
1471 kfree(handle);
1472}
1473
1474/*
1475 * Start keyboard handler on the new keyboard by refreshing LED state to
1476 * match the rest of the system.
1477 */
1478static void kbd_start(struct input_handle *handle)
1479{
1480 tasklet_disable(&keyboard_tasklet);
1481
1482 if (ledstate != 0xff)
1483 kbd_update_leds_helper(handle, &ledstate);
1484
1485 tasklet_enable(&keyboard_tasklet);
1486}
1487
1488static const struct input_device_id kbd_ids[] = {
1489 {
1490 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1491 .evbit = { BIT_MASK(EV_KEY) },
1492 },
1493
1494 {
1495 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1496 .evbit = { BIT_MASK(EV_SND) },
1497 },
1498
1499 { }, /* Terminating entry */
1500};
1501
1502MODULE_DEVICE_TABLE(input, kbd_ids);
1503
1504static struct input_handler kbd_handler = {
1505 .event = kbd_event,
1506 .match = kbd_match,
1507 .connect = kbd_connect,
1508 .disconnect = kbd_disconnect,
1509 .start = kbd_start,
1510 .name = "kbd",
1511 .id_table = kbd_ids,
1512};
1513
1514int __init kbd_init(void)
1515{
1516 int i;
1517 int error;
1518
1519 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1520 kbd_table[i].ledflagstate = kbd_defleds();
1521 kbd_table[i].default_ledflagstate = kbd_defleds();
1522 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1523 kbd_table[i].lockstate = KBD_DEFLOCK;
1524 kbd_table[i].slockstate = 0;
1525 kbd_table[i].modeflags = KBD_DEFMODE;
1526 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1527 }
1528
1529 error = input_register_handler(&kbd_handler);
1530 if (error)
1531 return error;
1532
1533 tasklet_enable(&keyboard_tasklet);
1534 tasklet_schedule(&keyboard_tasklet);
1535
1536 return 0;
1537}
1538
1539/* Ioctl support code */
1540
1541/**
1542 * vt_do_diacrit - diacritical table updates
1543 * @cmd: ioctl request
1544 * @up: pointer to user data for ioctl
1545 * @perm: permissions check computed by caller
1546 *
1547 * Update the diacritical tables atomically and safely. Lock them
1548 * against simultaneous keypresses
1549 */
1550int vt_do_diacrit(unsigned int cmd, void __user *up, int perm)
1551{
1552 struct kbdiacrs __user *a = up;
1553 unsigned long flags;
1554 int asize;
1555 int ret = 0;
1556
1557 switch (cmd) {
1558 case KDGKBDIACR:
1559 {
1560 struct kbdiacr *diacr;
1561 int i;
1562
1563 diacr = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1564 GFP_KERNEL);
1565 if (diacr == NULL)
1566 return -ENOMEM;
1567
1568 /* Lock the diacriticals table, make a copy and then
1569 copy it after we unlock */
1570 spin_lock_irqsave(&kbd_event_lock, flags);
1571
1572 asize = accent_table_size;
1573 for (i = 0; i < asize; i++) {
1574 diacr[i].diacr = conv_uni_to_8bit(
1575 accent_table[i].diacr);
1576 diacr[i].base = conv_uni_to_8bit(
1577 accent_table[i].base);
1578 diacr[i].result = conv_uni_to_8bit(
1579 accent_table[i].result);
1580 }
1581 spin_unlock_irqrestore(&kbd_event_lock, flags);
1582
1583 if (put_user(asize, &a->kb_cnt))
1584 ret = -EFAULT;
1585 else if (copy_to_user(a->kbdiacr, diacr,
1586 asize * sizeof(struct kbdiacr)))
1587 ret = -EFAULT;
1588 kfree(diacr);
1589 return ret;
1590 }
1591 case KDGKBDIACRUC:
1592 {
1593 struct kbdiacrsuc __user *a = up;
1594 void *buf;
1595
1596 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1597 GFP_KERNEL);
1598 if (buf == NULL)
1599 return -ENOMEM;
1600
1601 /* Lock the diacriticals table, make a copy and then
1602 copy it after we unlock */
1603 spin_lock_irqsave(&kbd_event_lock, flags);
1604
1605 asize = accent_table_size;
1606 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1607
1608 spin_unlock_irqrestore(&kbd_event_lock, flags);
1609
1610 if (put_user(asize, &a->kb_cnt))
1611 ret = -EFAULT;
1612 else if (copy_to_user(a->kbdiacruc, buf,
1613 asize*sizeof(struct kbdiacruc)))
1614 ret = -EFAULT;
1615 kfree(buf);
1616 return ret;
1617 }
1618
1619 case KDSKBDIACR:
1620 {
1621 struct kbdiacrs __user *a = up;
1622 struct kbdiacr *diacr = NULL;
1623 unsigned int ct;
1624 int i;
1625
1626 if (!perm)
1627 return -EPERM;
1628 if (get_user(ct, &a->kb_cnt))
1629 return -EFAULT;
1630 if (ct >= MAX_DIACR)
1631 return -EINVAL;
1632
1633 if (ct) {
1634 diacr = kmalloc(sizeof(struct kbdiacr) * ct,
1635 GFP_KERNEL);
1636 if (diacr == NULL)
1637 return -ENOMEM;
1638
1639 if (copy_from_user(diacr, a->kbdiacr,
1640 sizeof(struct kbdiacr) * ct)) {
1641 kfree(diacr);
1642 return -EFAULT;
1643 }
1644 }
1645
1646 spin_lock_irqsave(&kbd_event_lock, flags);
1647 accent_table_size = ct;
1648 for (i = 0; i < ct; i++) {
1649 accent_table[i].diacr =
1650 conv_8bit_to_uni(diacr[i].diacr);
1651 accent_table[i].base =
1652 conv_8bit_to_uni(diacr[i].base);
1653 accent_table[i].result =
1654 conv_8bit_to_uni(diacr[i].result);
1655 }
1656 spin_unlock_irqrestore(&kbd_event_lock, flags);
1657 kfree(diacr);
1658 return 0;
1659 }
1660
1661 case KDSKBDIACRUC:
1662 {
1663 struct kbdiacrsuc __user *a = up;
1664 unsigned int ct;
1665 void *buf = NULL;
1666
1667 if (!perm)
1668 return -EPERM;
1669
1670 if (get_user(ct, &a->kb_cnt))
1671 return -EFAULT;
1672
1673 if (ct >= MAX_DIACR)
1674 return -EINVAL;
1675
1676 if (ct) {
1677 buf = kmalloc(ct * sizeof(struct kbdiacruc),
1678 GFP_KERNEL);
1679 if (buf == NULL)
1680 return -ENOMEM;
1681
1682 if (copy_from_user(buf, a->kbdiacruc,
1683 ct * sizeof(struct kbdiacruc))) {
1684 kfree(buf);
1685 return -EFAULT;
1686 }
1687 }
1688 spin_lock_irqsave(&kbd_event_lock, flags);
1689 if (ct)
1690 memcpy(accent_table, buf,
1691 ct * sizeof(struct kbdiacruc));
1692 accent_table_size = ct;
1693 spin_unlock_irqrestore(&kbd_event_lock, flags);
1694 kfree(buf);
1695 return 0;
1696 }
1697 }
1698 return ret;
1699}
1700
1701/**
1702 * vt_do_kdskbmode - set keyboard mode ioctl
1703 * @console: the console to use
1704 * @arg: the requested mode
1705 *
1706 * Update the keyboard mode bits while holding the correct locks.
1707 * Return 0 for success or an error code.
1708 */
1709int vt_do_kdskbmode(int console, unsigned int arg)
1710{
1711 struct kbd_struct * kbd = kbd_table + console;
1712 int ret = 0;
1713 unsigned long flags;
1714
1715 spin_lock_irqsave(&kbd_event_lock, flags);
1716 switch(arg) {
1717 case K_RAW:
1718 kbd->kbdmode = VC_RAW;
1719 break;
1720 case K_MEDIUMRAW:
1721 kbd->kbdmode = VC_MEDIUMRAW;
1722 break;
1723 case K_XLATE:
1724 kbd->kbdmode = VC_XLATE;
1725 do_compute_shiftstate();
1726 break;
1727 case K_UNICODE:
1728 kbd->kbdmode = VC_UNICODE;
1729 do_compute_shiftstate();
1730 break;
1731 case K_OFF:
1732 kbd->kbdmode = VC_OFF;
1733 break;
1734 default:
1735 ret = -EINVAL;
1736 }
1737 spin_unlock_irqrestore(&kbd_event_lock, flags);
1738 return ret;
1739}
1740
1741/**
1742 * vt_do_kdskbmeta - set keyboard meta state
1743 * @console: the console to use
1744 * @arg: the requested meta state
1745 *
1746 * Update the keyboard meta bits while holding the correct locks.
1747 * Return 0 for success or an error code.
1748 */
1749int vt_do_kdskbmeta(int console, unsigned int arg)
1750{
1751 struct kbd_struct * kbd = kbd_table + console;
1752 int ret = 0;
1753 unsigned long flags;
1754
1755 spin_lock_irqsave(&kbd_event_lock, flags);
1756 switch(arg) {
1757 case K_METABIT:
1758 clr_vc_kbd_mode(kbd, VC_META);
1759 break;
1760 case K_ESCPREFIX:
1761 set_vc_kbd_mode(kbd, VC_META);
1762 break;
1763 default:
1764 ret = -EINVAL;
1765 }
1766 spin_unlock_irqrestore(&kbd_event_lock, flags);
1767 return ret;
1768}
1769
1770int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1771 int perm)
1772{
1773 struct kbkeycode tmp;
1774 int kc = 0;
1775
1776 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1777 return -EFAULT;
1778 switch (cmd) {
1779 case KDGETKEYCODE:
1780 kc = getkeycode(tmp.scancode);
1781 if (kc >= 0)
1782 kc = put_user(kc, &user_kbkc->keycode);
1783 break;
1784 case KDSETKEYCODE:
1785 if (!perm)
1786 return -EPERM;
1787 kc = setkeycode(tmp.scancode, tmp.keycode);
1788 break;
1789 }
1790 return kc;
1791}
1792
1793#define i (tmp.kb_index)
1794#define s (tmp.kb_table)
1795#define v (tmp.kb_value)
1796
1797int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1798 int console)
1799{
1800 struct kbd_struct * kbd = kbd_table + console;
1801 struct kbentry tmp;
1802 ushort *key_map, *new_map, val, ov;
1803 unsigned long flags;
1804
1805 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1806 return -EFAULT;
1807
1808 if (!capable(CAP_SYS_TTY_CONFIG))
1809 perm = 0;
1810
1811 switch (cmd) {
1812 case KDGKBENT:
1813 /* Ensure another thread doesn't free it under us */
1814 spin_lock_irqsave(&kbd_event_lock, flags);
1815 key_map = key_maps[s];
1816 if (key_map) {
1817 val = U(key_map[i]);
1818 if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1819 val = K_HOLE;
1820 } else
1821 val = (i ? K_HOLE : K_NOSUCHMAP);
1822 spin_unlock_irqrestore(&kbd_event_lock, flags);
1823 return put_user(val, &user_kbe->kb_value);
1824 case KDSKBENT:
1825 if (!perm)
1826 return -EPERM;
1827 if (!i && v == K_NOSUCHMAP) {
1828 spin_lock_irqsave(&kbd_event_lock, flags);
1829 /* deallocate map */
1830 key_map = key_maps[s];
1831 if (s && key_map) {
1832 key_maps[s] = NULL;
1833 if (key_map[0] == U(K_ALLOCATED)) {
1834 kfree(key_map);
1835 keymap_count--;
1836 }
1837 }
1838 spin_unlock_irqrestore(&kbd_event_lock, flags);
1839 break;
1840 }
1841
1842 if (KTYP(v) < NR_TYPES) {
1843 if (KVAL(v) > max_vals[KTYP(v)])
1844 return -EINVAL;
1845 } else
1846 if (kbd->kbdmode != VC_UNICODE)
1847 return -EINVAL;
1848
1849 /* ++Geert: non-PC keyboards may generate keycode zero */
1850#if !defined(__mc68000__) && !defined(__powerpc__)
1851 /* assignment to entry 0 only tests validity of args */
1852 if (!i)
1853 break;
1854#endif
1855
1856 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1857 if (!new_map)
1858 return -ENOMEM;
1859 spin_lock_irqsave(&kbd_event_lock, flags);
1860 key_map = key_maps[s];
1861 if (key_map == NULL) {
1862 int j;
1863
1864 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1865 !capable(CAP_SYS_RESOURCE)) {
1866 spin_unlock_irqrestore(&kbd_event_lock, flags);
1867 kfree(new_map);
1868 return -EPERM;
1869 }
1870 key_maps[s] = new_map;
1871 key_map = new_map;
1872 key_map[0] = U(K_ALLOCATED);
1873 for (j = 1; j < NR_KEYS; j++)
1874 key_map[j] = U(K_HOLE);
1875 keymap_count++;
1876 } else
1877 kfree(new_map);
1878
1879 ov = U(key_map[i]);
1880 if (v == ov)
1881 goto out;
1882 /*
1883 * Attention Key.
1884 */
1885 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1886 spin_unlock_irqrestore(&kbd_event_lock, flags);
1887 return -EPERM;
1888 }
1889 key_map[i] = U(v);
1890 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1891 do_compute_shiftstate();
1892out:
1893 spin_unlock_irqrestore(&kbd_event_lock, flags);
1894 break;
1895 }
1896 return 0;
1897}
1898#undef i
1899#undef s
1900#undef v
1901
1902/* FIXME: This one needs untangling and locking */
1903int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1904{
1905 struct kbsentry *kbs;
1906 char *p;
1907 u_char *q;
1908 u_char __user *up;
1909 int sz;
1910 int delta;
1911 char *first_free, *fj, *fnw;
1912 int i, j, k;
1913 int ret;
1914
1915 if (!capable(CAP_SYS_TTY_CONFIG))
1916 perm = 0;
1917
1918 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1919 if (!kbs) {
1920 ret = -ENOMEM;
1921 goto reterr;
1922 }
1923
1924 /* we mostly copy too much here (512bytes), but who cares ;) */
1925 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1926 ret = -EFAULT;
1927 goto reterr;
1928 }
1929 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1930 i = kbs->kb_func;
1931
1932 switch (cmd) {
1933 case KDGKBSENT:
1934 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1935 a struct member */
1936 up = user_kdgkb->kb_string;
1937 p = func_table[i];
1938 if(p)
1939 for ( ; *p && sz; p++, sz--)
1940 if (put_user(*p, up++)) {
1941 ret = -EFAULT;
1942 goto reterr;
1943 }
1944 if (put_user('\0', up)) {
1945 ret = -EFAULT;
1946 goto reterr;
1947 }
1948 kfree(kbs);
1949 return ((p && *p) ? -EOVERFLOW : 0);
1950 case KDSKBSENT:
1951 if (!perm) {
1952 ret = -EPERM;
1953 goto reterr;
1954 }
1955
1956 q = func_table[i];
1957 first_free = funcbufptr + (funcbufsize - funcbufleft);
1958 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
1959 ;
1960 if (j < MAX_NR_FUNC)
1961 fj = func_table[j];
1962 else
1963 fj = first_free;
1964
1965 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
1966 if (delta <= funcbufleft) { /* it fits in current buf */
1967 if (j < MAX_NR_FUNC) {
1968 memmove(fj + delta, fj, first_free - fj);
1969 for (k = j; k < MAX_NR_FUNC; k++)
1970 if (func_table[k])
1971 func_table[k] += delta;
1972 }
1973 if (!q)
1974 func_table[i] = fj;
1975 funcbufleft -= delta;
1976 } else { /* allocate a larger buffer */
1977 sz = 256;
1978 while (sz < funcbufsize - funcbufleft + delta)
1979 sz <<= 1;
1980 fnw = kmalloc(sz, GFP_KERNEL);
1981 if(!fnw) {
1982 ret = -ENOMEM;
1983 goto reterr;
1984 }
1985
1986 if (!q)
1987 func_table[i] = fj;
1988 if (fj > funcbufptr)
1989 memmove(fnw, funcbufptr, fj - funcbufptr);
1990 for (k = 0; k < j; k++)
1991 if (func_table[k])
1992 func_table[k] = fnw + (func_table[k] - funcbufptr);
1993
1994 if (first_free > fj) {
1995 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
1996 for (k = j; k < MAX_NR_FUNC; k++)
1997 if (func_table[k])
1998 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
1999 }
2000 if (funcbufptr != func_buf)
2001 kfree(funcbufptr);
2002 funcbufptr = fnw;
2003 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2004 funcbufsize = sz;
2005 }
2006 strcpy(func_table[i], kbs->kb_string);
2007 break;
2008 }
2009 ret = 0;
2010reterr:
2011 kfree(kbs);
2012 return ret;
2013}
2014
2015int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2016{
2017 struct kbd_struct * kbd = kbd_table + console;
2018 unsigned long flags;
2019 unsigned char ucval;
2020
2021 switch(cmd) {
2022 /* the ioctls below read/set the flags usually shown in the leds */
2023 /* don't use them - they will go away without warning */
2024 case KDGKBLED:
2025 spin_lock_irqsave(&kbd_event_lock, flags);
2026 ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4);
2027 spin_unlock_irqrestore(&kbd_event_lock, flags);
2028 return put_user(ucval, (char __user *)arg);
2029
2030 case KDSKBLED:
2031 if (!perm)
2032 return -EPERM;
2033 if (arg & ~0x77)
2034 return -EINVAL;
2035 spin_lock_irqsave(&kbd_event_lock, flags);
2036 kbd->ledflagstate = (arg & 7);
2037 kbd->default_ledflagstate = ((arg >> 4) & 7);
2038 set_leds();
2039 spin_unlock_irqrestore(&kbd_event_lock, flags);
2040 return 0;
2041
2042 /* the ioctls below only set the lights, not the functions */
2043 /* for those, see KDGKBLED and KDSKBLED above */
2044 case KDGETLED:
2045 ucval = getledstate();
2046 return put_user(ucval, (char __user *)arg);
2047
2048 case KDSETLED:
2049 if (!perm)
2050 return -EPERM;
2051 setledstate(kbd, arg);
2052 return 0;
2053 }
2054 return -ENOIOCTLCMD;
2055}
2056
2057int vt_do_kdgkbmode(int console)
2058{
2059 struct kbd_struct * kbd = kbd_table + console;
2060 /* This is a spot read so needs no locking */
2061 switch (kbd->kbdmode) {
2062 case VC_RAW:
2063 return K_RAW;
2064 case VC_MEDIUMRAW:
2065 return K_MEDIUMRAW;
2066 case VC_UNICODE:
2067 return K_UNICODE;
2068 case VC_OFF:
2069 return K_OFF;
2070 default:
2071 return K_XLATE;
2072 }
2073}
2074
2075/**
2076 * vt_do_kdgkbmeta - report meta status
2077 * @console: console to report
2078 *
2079 * Report the meta flag status of this console
2080 */
2081int vt_do_kdgkbmeta(int console)
2082{
2083 struct kbd_struct * kbd = kbd_table + console;
2084 /* Again a spot read so no locking */
2085 return vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT;
2086}
2087
2088/**
2089 * vt_reset_unicode - reset the unicode status
2090 * @console: console being reset
2091 *
2092 * Restore the unicode console state to its default
2093 */
2094void vt_reset_unicode(int console)
2095{
2096 unsigned long flags;
2097
2098 spin_lock_irqsave(&kbd_event_lock, flags);
2099 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2100 spin_unlock_irqrestore(&kbd_event_lock, flags);
2101}
2102
2103/**
2104 * vt_get_shiftstate - shift bit state
2105 *
2106 * Report the shift bits from the keyboard state. We have to export
2107 * this to support some oddities in the vt layer.
2108 */
2109int vt_get_shift_state(void)
2110{
2111 /* Don't lock as this is a transient report */
2112 return shift_state;
2113}
2114
2115/**
2116 * vt_reset_keyboard - reset keyboard state
2117 * @console: console to reset
2118 *
2119 * Reset the keyboard bits for a console as part of a general console
2120 * reset event
2121 */
2122void vt_reset_keyboard(int console)
2123{
2124 struct kbd_struct * kbd = kbd_table + console;
2125 unsigned long flags;
2126
2127 spin_lock_irqsave(&kbd_event_lock, flags);
2128 set_vc_kbd_mode(kbd, VC_REPEAT);
2129 clr_vc_kbd_mode(kbd, VC_CKMODE);
2130 clr_vc_kbd_mode(kbd, VC_APPLIC);
2131 clr_vc_kbd_mode(kbd, VC_CRLF);
2132 kbd->lockstate = 0;
2133 kbd->slockstate = 0;
2134 kbd->ledmode = LED_SHOW_FLAGS;
2135 kbd->ledflagstate = kbd->default_ledflagstate;
2136 /* do not do set_leds here because this causes an endless tasklet loop
2137 when the keyboard hasn't been initialized yet */
2138 spin_unlock_irqrestore(&kbd_event_lock, flags);
2139}
2140
2141/**
2142 * vt_get_kbd_mode_bit - read keyboard status bits
2143 * @console: console to read from
2144 * @bit: mode bit to read
2145 *
2146 * Report back a vt mode bit. We do this without locking so the
2147 * caller must be sure that there are no synchronization needs
2148 */
2149
2150int vt_get_kbd_mode_bit(int console, int bit)
2151{
2152 struct kbd_struct * kbd = kbd_table + console;
2153 return vc_kbd_mode(kbd, bit);
2154}
2155
2156/**
2157 * vt_set_kbd_mode_bit - read keyboard status bits
2158 * @console: console to read from
2159 * @bit: mode bit to read
2160 *
2161 * Set a vt mode bit. We do this without locking so the
2162 * caller must be sure that there are no synchronization needs
2163 */
2164
2165void vt_set_kbd_mode_bit(int console, int bit)
2166{
2167 struct kbd_struct * kbd = kbd_table + console;
2168 unsigned long flags;
2169
2170 spin_lock_irqsave(&kbd_event_lock, flags);
2171 set_vc_kbd_mode(kbd, bit);
2172 spin_unlock_irqrestore(&kbd_event_lock, flags);
2173}
2174
2175/**
2176 * vt_clr_kbd_mode_bit - read keyboard status bits
2177 * @console: console to read from
2178 * @bit: mode bit to read
2179 *
2180 * Report back a vt mode bit. We do this without locking so the
2181 * caller must be sure that there are no synchronization needs
2182 */
2183
2184void vt_clr_kbd_mode_bit(int console, int bit)
2185{
2186 struct kbd_struct * kbd = kbd_table + console;
2187 unsigned long flags;
2188
2189 spin_lock_irqsave(&kbd_event_lock, flags);
2190 clr_vc_kbd_mode(kbd, bit);
2191 spin_unlock_irqrestore(&kbd_event_lock, flags);
2192}