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