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