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