blob: 0f8caae4267df8b3a19e39011730478f2c63c9d3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * 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)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050015 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 * 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
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -070025#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
Jan Engelhardt759448f2007-07-15 23:40:40 -070027#include <linux/consolemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#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>
Samuel Thibault52355522015-03-16 21:19:44 -070036#include <linux/leds.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#include <linux/kbd_kern.h>
39#include <linux/kbd_diacr.h>
40#include <linux/vt_kern.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/input.h>
Adrian Bunk83cc5ed2006-06-25 05:47:41 -070042#include <linux/reboot.h>
Samuel Thibault41ab4392007-10-18 23:39:12 -070043#include <linux/notifier.h>
Julia Lawallb39b0442008-04-17 09:28:25 -040044#include <linux/jiffies.h>
Greg Kroah-Hartman6623d642012-02-27 15:18:56 -080045#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Geert Uytterhoeven98c2b372011-09-11 13:59:29 +020047#include <asm/irq_regs.h>
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049extern void ctrl_alt_del(void);
50
51/*
52 * Exported functions/variables
53 */
54
55#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
56
Joshua Covb2d0b7a2012-04-13 21:08:26 +020057#if defined(CONFIG_X86) || defined(CONFIG_PARISC)
58#include <asm/kbdleds.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#else
Joshua Covb2d0b7a2012-04-13 21:08:26 +020060static inline int kbd_defleds(void)
61{
62 return 0;
63}
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#endif
65
66#define KBD_DEFLOCK 0
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068/*
69 * Handler Tables.
70 */
71
72#define K_HANDLERS\
73 k_self, k_fn, k_spec, k_pad,\
74 k_dead, k_cons, k_cur, k_shift,\
75 k_meta, k_ascii, k_lock, k_lowercase,\
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -050076 k_slock, k_dead2, k_brl, k_ignore
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050078typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
David Howells7d12e782006-10-05 14:55:46 +010079 char up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080static k_handler_fn K_HANDLERS;
Dmitry Torokhov97f5f0c2010-03-21 22:31:26 -070081static k_handler_fn *k_handler[16] = { K_HANDLERS };
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83#define FN_HANDLERS\
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050084 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
85 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
86 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
87 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
88 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
David Howells7d12e782006-10-05 14:55:46 +010090typedef void (fn_handler_fn)(struct vc_data *vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091static fn_handler_fn FN_HANDLERS;
92static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
93
94/*
95 * Variables exported for vt_ioctl.c
96 */
97
Eric W. Biederman81af8d62006-10-02 02:17:13 -070098struct vt_spawn_console vt_spawn_con = {
Milind Arun Choudharyccc94252007-05-08 00:30:09 -070099 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700100 .pid = NULL,
101 .sig = 0,
102};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105/*
106 * Internal Data.
107 */
108
Alan Cox079c9532012-02-28 14:49:23 +0000109static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
110static struct kbd_struct *kbd = kbd_table;
111
112/* maximum values each key_handler can handle */
113static const int max_vals[] = {
114 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
115 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
116 255, NR_LOCK - 1, 255, NR_BRL - 1
117};
118
119static const int NR_TYPES = ARRAY_SIZE(max_vals);
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121static struct input_handler kbd_handler;
Dmitry Torokhov21cea582009-11-29 23:40:58 -0800122static DEFINE_SPINLOCK(kbd_event_lock);
Alan Cox3db1ddb2012-07-17 17:06:41 +0100123static DEFINE_SPINLOCK(led_lock);
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700124static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
Dmitry Torokhove0785572010-03-21 22:31:26 -0700126static bool dead_key_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127static int npadch = -1; /* -1 or number assembled on pad */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500128static unsigned int diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129static char rep; /* flag telling character repeat */
130
Alan Cox079c9532012-02-28 14:49:23 +0000131static int shift_state = 0;
132
Samuel Thibaulteeb64c12015-06-06 11:44:39 -0700133static unsigned int ledstate = -1U; /* undefined */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134static unsigned char ledioctl;
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136/*
Samuel Thibault41ab4392007-10-18 23:39:12 -0700137 * Notifier list for console keyboard events
138 */
139static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
140
141int register_keyboard_notifier(struct notifier_block *nb)
142{
143 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
144}
145EXPORT_SYMBOL_GPL(register_keyboard_notifier);
146
147int unregister_keyboard_notifier(struct notifier_block *nb)
148{
149 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
150}
151EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
152
153/*
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400154 * Translation of scancodes to keycodes. We set them on only the first
155 * keyboard in the list that accepts the scancode and keycode.
156 * Explanation for not choosing the first attached keyboard anymore:
157 * USB keyboards for example have two event devices: one for all "normal"
158 * keys and one for extra function keys (like "volume up", "make coffee",
159 * etc.). So this means that scancodes for the extra function keys won't
160 * be valid for the first event device, but will be for the second.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 */
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800162
163struct getset_keycode_data {
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700164 struct input_keymap_entry ke;
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800165 int error;
166};
167
168static int getkeycode_helper(struct input_handle *handle, void *data)
169{
170 struct getset_keycode_data *d = data;
171
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700172 d->error = input_get_keycode(handle->dev, &d->ke);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800173
174 return d->error == 0; /* stop as soon as we successfully get one */
175}
176
Alan Cox079c9532012-02-28 14:49:23 +0000177static int getkeycode(unsigned int scancode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700179 struct getset_keycode_data d = {
180 .ke = {
181 .flags = 0,
182 .len = sizeof(scancode),
183 .keycode = 0,
184 },
185 .error = -ENODEV,
186 };
187
188 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800190 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700192 return d.error ?: d.ke.keycode;
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800193}
194
195static int setkeycode_helper(struct input_handle *handle, void *data)
196{
197 struct getset_keycode_data *d = data;
198
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700199 d->error = input_set_keycode(handle->dev, &d->ke);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800200
201 return d->error == 0; /* stop as soon as we successfully set one */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
Alan Cox079c9532012-02-28 14:49:23 +0000204static int setkeycode(unsigned int scancode, unsigned int keycode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Mauro Carvalho Chehab8613e4c2010-09-09 21:54:22 -0700206 struct getset_keycode_data d = {
207 .ke = {
208 .flags = 0,
209 .len = sizeof(scancode),
210 .keycode = keycode,
211 },
212 .error = -ENODEV,
213 };
214
215 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800217 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800219 return d.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
222/*
Dmitry Torokhov18f7ad52009-12-15 16:26:53 -0800223 * Making beeps and bells. Note that we prefer beeps to bells, but when
224 * shutting the sound off we do both.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 */
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800226
227static int kd_sound_helper(struct input_handle *handle, void *data)
228{
229 unsigned int *hz = data;
230 struct input_dev *dev = handle->dev;
231
232 if (test_bit(EV_SND, dev->evbit)) {
Dmitry Torokhov18f7ad52009-12-15 16:26:53 -0800233 if (test_bit(SND_TONE, dev->sndbit)) {
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800234 input_inject_event(handle, EV_SND, SND_TONE, *hz);
Dmitry Torokhov18f7ad52009-12-15 16:26:53 -0800235 if (*hz)
236 return 0;
237 }
238 if (test_bit(SND_BELL, dev->sndbit))
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800239 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
240 }
241
242 return 0;
243}
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245static void kd_nosound(unsigned long ignored)
246{
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800247 static unsigned int zero;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800249 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250}
251
Ingo Molnar8d06afa2005-09-09 13:10:40 -0700252static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254void kd_mksound(unsigned int hz, unsigned int ticks)
255{
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800256 del_timer_sync(&kd_mksound_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800258 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800260 if (hz && ticks)
261 mod_timer(&kd_mksound_timer, jiffies + ticks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262}
Samuel Thibaultf7511d52008-04-30 00:54:51 -0700263EXPORT_SYMBOL(kd_mksound);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265/*
266 * Setting the keyboard rate.
267 */
268
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800269static int kbd_rate_helper(struct input_handle *handle, void *data)
270{
271 struct input_dev *dev = handle->dev;
Mark Rustad9d329c12014-09-05 18:57:57 -0700272 struct kbd_repeat *rpt = data;
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800273
274 if (test_bit(EV_REP, dev->evbit)) {
275
Mark Rustad9d329c12014-09-05 18:57:57 -0700276 if (rpt[0].delay > 0)
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800277 input_inject_event(handle,
Mark Rustad9d329c12014-09-05 18:57:57 -0700278 EV_REP, REP_DELAY, rpt[0].delay);
279 if (rpt[0].period > 0)
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800280 input_inject_event(handle,
Mark Rustad9d329c12014-09-05 18:57:57 -0700281 EV_REP, REP_PERIOD, rpt[0].period);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800282
Mark Rustad9d329c12014-09-05 18:57:57 -0700283 rpt[1].delay = dev->rep[REP_DELAY];
284 rpt[1].period = dev->rep[REP_PERIOD];
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800285 }
286
287 return 0;
288}
289
Mark Rustad9d329c12014-09-05 18:57:57 -0700290int kbd_rate(struct kbd_repeat *rpt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
Mark Rustad9d329c12014-09-05 18:57:57 -0700292 struct kbd_repeat data[2] = { *rpt };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800294 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
Mark Rustad9d329c12014-09-05 18:57:57 -0700295 *rpt = data[1]; /* Copy currently used settings */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 return 0;
298}
299
300/*
301 * Helper Functions.
302 */
303static void put_queue(struct vc_data *vc, int ch)
304{
Jiri Slaby92a19f92013-01-03 15:53:03 +0100305 tty_insert_flip_char(&vc->port, ch, 0);
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100306 tty_schedule_flip(&vc->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308
309static void puts_queue(struct vc_data *vc, char *cp)
310{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 while (*cp) {
Jiri Slaby92a19f92013-01-03 15:53:03 +0100312 tty_insert_flip_char(&vc->port, *cp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 cp++;
314 }
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100315 tty_schedule_flip(&vc->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316}
317
318static void applkey(struct vc_data *vc, int key, char mode)
319{
320 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
321
322 buf[1] = (mode ? 'O' : '[');
323 buf[2] = key;
324 puts_queue(vc, buf);
325}
326
327/*
328 * Many other routines do put_queue, but I think either
329 * they produce ASCII, or they produce some user-assigned
330 * string, and in both cases we might assume that it is
Jan Engelhardt759448f2007-07-15 23:40:40 -0700331 * in utf-8 already.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 */
Jan Engelhardt759448f2007-07-15 23:40:40 -0700333static void to_utf8(struct vc_data *vc, uint c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
335 if (c < 0x80)
336 /* 0******* */
337 put_queue(vc, c);
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500338 else if (c < 0x800) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 /* 110***** 10****** */
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500340 put_queue(vc, 0xc0 | (c >> 6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhove0785572010-03-21 22:31:26 -0700342 } else if (c < 0x10000) {
343 if (c >= 0xD800 && c < 0xE000)
Jan Engelhardt759448f2007-07-15 23:40:40 -0700344 return;
345 if (c == 0xFFFF)
346 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 /* 1110**** 10****** 10****** */
348 put_queue(vc, 0xe0 | (c >> 12));
349 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
350 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhove0785572010-03-21 22:31:26 -0700351 } else if (c < 0x110000) {
Jan Engelhardt759448f2007-07-15 23:40:40 -0700352 /* 11110*** 10****** 10****** 10****** */
353 put_queue(vc, 0xf0 | (c >> 18));
354 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
355 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
356 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500357 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500360/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 * Called after returning from RAW mode or when changing consoles - recompute
362 * shift_down[] and shift_state from key_down[] maybe called when keymap is
Alan Cox079c9532012-02-28 14:49:23 +0000363 * undefined, so that shiftkey release is seen. The caller must hold the
364 * kbd_event_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 */
Alan Cox079c9532012-02-28 14:49:23 +0000366
367static void do_compute_shiftstate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
Dmitry Torokhov510cccb2016-06-27 14:12:34 -0700369 unsigned int k, sym, val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371 shift_state = 0;
372 memset(shift_down, 0, sizeof(shift_down));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500373
Dmitry Torokhov510cccb2016-06-27 14:12:34 -0700374 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
375 sym = U(key_maps[0][k]);
376 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 continue;
378
Dmitry Torokhov510cccb2016-06-27 14:12:34 -0700379 val = KVAL(sym);
380 if (val == KVAL(K_CAPSSHIFT))
381 val = KVAL(K_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Dmitry Torokhov510cccb2016-06-27 14:12:34 -0700383 shift_down[val]++;
384 shift_state |= BIT(val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 }
386}
387
Alan Cox079c9532012-02-28 14:49:23 +0000388/* We still have to export this method to vt.c */
389void compute_shiftstate(void)
390{
391 unsigned long flags;
392 spin_lock_irqsave(&kbd_event_lock, flags);
393 do_compute_shiftstate();
394 spin_unlock_irqrestore(&kbd_event_lock, flags);
395}
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397/*
398 * We have a combining character DIACR here, followed by the character CH.
399 * If the combination occurs in the table, return the corresponding value.
400 * Otherwise, if CH is a space or equals DIACR, return DIACR.
401 * Otherwise, conclude that DIACR was not combining after all,
402 * queue it and return CH.
403 */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500404static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500406 unsigned int d = diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 unsigned int i;
408
409 diacr = 0;
410
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500411 if ((d & ~0xff) == BRL_UC_ROW) {
412 if ((ch & ~0xff) == BRL_UC_ROW)
413 return d | ch;
414 } else {
415 for (i = 0; i < accent_table_size; i++)
416 if (accent_table[i].diacr == d && accent_table[i].base == ch)
417 return accent_table[i].result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 }
419
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500420 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return d;
422
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500423 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700424 to_utf8(vc, d);
425 else {
426 int c = conv_uni_to_8bit(d);
427 if (c != -1)
428 put_queue(vc, c);
429 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500430
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return ch;
432}
433
434/*
435 * Special function handlers
436 */
David Howells7d12e782006-10-05 14:55:46 +0100437static void fn_enter(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 if (diacr) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500440 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700441 to_utf8(vc, diacr);
442 else {
443 int c = conv_uni_to_8bit(diacr);
444 if (c != -1)
445 put_queue(vc, c);
446 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 diacr = 0;
448 }
Dmitry Torokhove0785572010-03-21 22:31:26 -0700449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 put_queue(vc, 13);
451 if (vc_kbd_mode(kbd, VC_CRLF))
452 put_queue(vc, 10);
453}
454
David Howells7d12e782006-10-05 14:55:46 +0100455static void fn_caps_toggle(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
457 if (rep)
458 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
461}
462
David Howells7d12e782006-10-05 14:55:46 +0100463static void fn_caps_on(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464{
465 if (rep)
466 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 set_vc_kbd_led(kbd, VC_CAPSLOCK);
469}
470
David Howells7d12e782006-10-05 14:55:46 +0100471static void fn_show_ptregs(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472{
David Howells7d12e782006-10-05 14:55:46 +0100473 struct pt_regs *regs = get_irq_regs();
Dmitry Torokhove0785572010-03-21 22:31:26 -0700474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 if (regs)
476 show_regs(regs);
477}
478
David Howells7d12e782006-10-05 14:55:46 +0100479static void fn_hold(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
Alan Cox8ce73262010-06-01 22:52:56 +0200481 struct tty_struct *tty = vc->port.tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483 if (rep || !tty)
484 return;
485
486 /*
487 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
488 * these routines are also activated by ^S/^Q.
489 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
490 */
491 if (tty->stopped)
492 start_tty(tty);
493 else
494 stop_tty(tty);
495}
496
David Howells7d12e782006-10-05 14:55:46 +0100497static void fn_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498{
Dmitry Torokhove0785572010-03-21 22:31:26 -0700499 if (vc_kbd_mode(kbd, VC_APPLIC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 applkey(vc, 'P', 1);
501 else
David Howells7d12e782006-10-05 14:55:46 +0100502 fn_bare_num(vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503}
504
505/*
506 * Bind this to Shift-NumLock if you work in application keypad mode
507 * but want to be able to change the NumLock flag.
508 * Bind this to NumLock if you prefer that the NumLock key always
509 * changes the NumLock flag.
510 */
David Howells7d12e782006-10-05 14:55:46 +0100511static void fn_bare_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
513 if (!rep)
514 chg_vc_kbd_led(kbd, VC_NUMLOCK);
515}
516
David Howells7d12e782006-10-05 14:55:46 +0100517static void fn_lastcons(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518{
519 /* switch to the last used console, ChN */
520 set_console(last_console);
521}
522
David Howells7d12e782006-10-05 14:55:46 +0100523static void fn_dec_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 int i, cur = fg_console;
526
527 /* Currently switching? Queue this next switch relative to that. */
528 if (want_console != -1)
529 cur = want_console;
530
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500531 for (i = cur - 1; i != cur; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 if (i == -1)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500533 i = MAX_NR_CONSOLES - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 if (vc_cons_allocated(i))
535 break;
536 }
537 set_console(i);
538}
539
David Howells7d12e782006-10-05 14:55:46 +0100540static void fn_inc_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
542 int i, cur = fg_console;
543
544 /* Currently switching? Queue this next switch relative to that. */
545 if (want_console != -1)
546 cur = want_console;
547
548 for (i = cur+1; i != cur; i++) {
549 if (i == MAX_NR_CONSOLES)
550 i = 0;
551 if (vc_cons_allocated(i))
552 break;
553 }
554 set_console(i);
555}
556
David Howells7d12e782006-10-05 14:55:46 +0100557static void fn_send_intr(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
Jiri Slaby92a19f92013-01-03 15:53:03 +0100559 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
Jiri Slaby6732c8b2013-01-03 15:53:07 +0100560 tty_schedule_flip(&vc->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561}
562
David Howells7d12e782006-10-05 14:55:46 +0100563static void fn_scroll_forw(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
565 scrollfront(vc, 0);
566}
567
David Howells7d12e782006-10-05 14:55:46 +0100568static void fn_scroll_back(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Jiri Slaby1b0ec882016-06-23 13:34:23 +0200570 scrollback(vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571}
572
David Howells7d12e782006-10-05 14:55:46 +0100573static void fn_show_mem(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574{
David Rientjesb2b755b2011-03-24 15:18:15 -0700575 show_mem(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
577
David Howells7d12e782006-10-05 14:55:46 +0100578static void fn_show_state(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
580 show_state();
581}
582
David Howells7d12e782006-10-05 14:55:46 +0100583static void fn_boot_it(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584{
585 ctrl_alt_del();
586}
587
David Howells7d12e782006-10-05 14:55:46 +0100588static void fn_compose(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
Dmitry Torokhove0785572010-03-21 22:31:26 -0700590 dead_key_next = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
592
David Howells7d12e782006-10-05 14:55:46 +0100593static void fn_spawn_con(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700595 spin_lock(&vt_spawn_con.lock);
596 if (vt_spawn_con.pid)
597 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
598 put_pid(vt_spawn_con.pid);
599 vt_spawn_con.pid = NULL;
600 }
601 spin_unlock(&vt_spawn_con.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602}
603
David Howells7d12e782006-10-05 14:55:46 +0100604static void fn_SAK(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800606 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800607 schedule_work(SAK_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
609
David Howells7d12e782006-10-05 14:55:46 +0100610static void fn_null(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
Alan Cox079c9532012-02-28 14:49:23 +0000612 do_compute_shiftstate();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613}
614
615/*
616 * Special key handlers
617 */
David Howells7d12e782006-10-05 14:55:46 +0100618static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619{
620}
621
David Howells7d12e782006-10-05 14:55:46 +0100622static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
624 if (up_flag)
625 return;
626 if (value >= ARRAY_SIZE(fn_handler))
627 return;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500628 if ((kbd->kbdmode == VC_RAW ||
Arthur Taylor9fc3de92011-02-04 13:55:50 -0800629 kbd->kbdmode == VC_MEDIUMRAW ||
630 kbd->kbdmode == VC_OFF) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 value != KVAL(K_SAK))
632 return; /* SAK is allowed even in raw mode */
David Howells7d12e782006-10-05 14:55:46 +0100633 fn_handler[value](vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634}
635
David Howells7d12e782006-10-05 14:55:46 +0100636static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637{
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -0700638 pr_err("k_lowercase was called - impossible\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639}
640
David Howells7d12e782006-10-05 14:55:46 +0100641static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
643 if (up_flag)
644 return; /* no action, if this is a key release */
645
646 if (diacr)
647 value = handle_diacr(vc, value);
648
649 if (dead_key_next) {
Dmitry Torokhove0785572010-03-21 22:31:26 -0700650 dead_key_next = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 diacr = value;
652 return;
653 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500654 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700655 to_utf8(vc, value);
656 else {
657 int c = conv_uni_to_8bit(value);
658 if (c != -1)
659 put_queue(vc, c);
660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661}
662
663/*
664 * Handle dead key. Note that we now may have several
665 * dead keys modifying the same character. Very useful
666 * for Vietnamese.
667 */
David Howells7d12e782006-10-05 14:55:46 +0100668static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
670 if (up_flag)
671 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 diacr = (diacr ? handle_diacr(vc, value) : value);
674}
675
David Howells7d12e782006-10-05 14:55:46 +0100676static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500677{
Jiri Bohacd2187eb2008-06-12 15:21:51 -0700678 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500679}
680
David Howells7d12e782006-10-05 14:55:46 +0100681static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500682{
David Howells7d12e782006-10-05 14:55:46 +0100683 k_deadunicode(vc, value, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500684}
685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686/*
687 * Obsolete - for backwards compatibility only
688 */
David Howells7d12e782006-10-05 14:55:46 +0100689static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400691 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
Dmitry Torokhove0785572010-03-21 22:31:26 -0700692
693 k_deadunicode(vc, ret_diacr[value], up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}
695
David Howells7d12e782006-10-05 14:55:46 +0100696static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
698 if (up_flag)
699 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 set_console(value);
702}
703
David Howells7d12e782006-10-05 14:55:46 +0100704static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 if (up_flag)
707 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700708
709 if ((unsigned)value < ARRAY_SIZE(func_table)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 if (func_table[value])
711 puts_queue(vc, func_table[value]);
712 } else
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -0700713 pr_err("k_fn called with value=%d\n", value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714}
715
David Howells7d12e782006-10-05 14:55:46 +0100716static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717{
Brandon Philipse52b29c2006-11-04 22:09:08 -0500718 static const char cur_chars[] = "BDCA";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 if (up_flag)
721 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
724}
725
David Howells7d12e782006-10-05 14:55:46 +0100726static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400728 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
729 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
731 if (up_flag)
732 return; /* no action, if this is a key release */
733
734 /* kludge... shift forces cursor/number keys */
735 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
736 applkey(vc, app_map[value], 1);
737 return;
738 }
739
Dmitry Torokhove0785572010-03-21 22:31:26 -0700740 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 switch (value) {
Dmitry Torokhove0785572010-03-21 22:31:26 -0700743 case KVAL(K_PCOMMA):
744 case KVAL(K_PDOT):
745 k_fn(vc, KVAL(K_REMOVE), 0);
746 return;
747 case KVAL(K_P0):
748 k_fn(vc, KVAL(K_INSERT), 0);
749 return;
750 case KVAL(K_P1):
751 k_fn(vc, KVAL(K_SELECT), 0);
752 return;
753 case KVAL(K_P2):
754 k_cur(vc, KVAL(K_DOWN), 0);
755 return;
756 case KVAL(K_P3):
757 k_fn(vc, KVAL(K_PGDN), 0);
758 return;
759 case KVAL(K_P4):
760 k_cur(vc, KVAL(K_LEFT), 0);
761 return;
762 case KVAL(K_P6):
763 k_cur(vc, KVAL(K_RIGHT), 0);
764 return;
765 case KVAL(K_P7):
766 k_fn(vc, KVAL(K_FIND), 0);
767 return;
768 case KVAL(K_P8):
769 k_cur(vc, KVAL(K_UP), 0);
770 return;
771 case KVAL(K_P9):
772 k_fn(vc, KVAL(K_PGUP), 0);
773 return;
774 case KVAL(K_P5):
775 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
776 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 }
Dmitry Torokhove0785572010-03-21 22:31:26 -0700778 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 put_queue(vc, pad_chars[value]);
781 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
782 put_queue(vc, 10);
783}
784
David Howells7d12e782006-10-05 14:55:46 +0100785static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
787 int old_state = shift_state;
788
789 if (rep)
790 return;
791 /*
792 * Mimic typewriter:
793 * a CapsShift key acts like Shift but undoes CapsLock
794 */
795 if (value == KVAL(K_CAPSSHIFT)) {
796 value = KVAL(K_SHIFT);
797 if (!up_flag)
798 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
799 }
800
801 if (up_flag) {
802 /*
803 * handle the case that two shift or control
804 * keys are depressed simultaneously
805 */
806 if (shift_down[value])
807 shift_down[value]--;
808 } else
809 shift_down[value]++;
810
811 if (shift_down[value])
812 shift_state |= (1 << value);
813 else
814 shift_state &= ~(1 << value);
815
816 /* kludge */
817 if (up_flag && shift_state != old_state && npadch != -1) {
818 if (kbd->kbdmode == VC_UNICODE)
Jan Engelhardt759448f2007-07-15 23:40:40 -0700819 to_utf8(vc, npadch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 else
821 put_queue(vc, npadch & 0xff);
822 npadch = -1;
823 }
824}
825
David Howells7d12e782006-10-05 14:55:46 +0100826static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827{
828 if (up_flag)
829 return;
830
831 if (vc_kbd_mode(kbd, VC_META)) {
832 put_queue(vc, '\033');
833 put_queue(vc, value);
834 } else
835 put_queue(vc, value | 0x80);
836}
837
David Howells7d12e782006-10-05 14:55:46 +0100838static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839{
840 int base;
841
842 if (up_flag)
843 return;
844
845 if (value < 10) {
846 /* decimal input of code, while Alt depressed */
847 base = 10;
848 } else {
849 /* hexadecimal input of code, while AltGr depressed */
850 value -= 10;
851 base = 16;
852 }
853
854 if (npadch == -1)
855 npadch = value;
856 else
857 npadch = npadch * base + value;
858}
859
David Howells7d12e782006-10-05 14:55:46 +0100860static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
862 if (up_flag || rep)
863 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 chg_vc_kbd_lock(kbd, value);
866}
867
David Howells7d12e782006-10-05 14:55:46 +0100868static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869{
David Howells7d12e782006-10-05 14:55:46 +0100870 k_shift(vc, value, up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 if (up_flag || rep)
872 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700873
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 chg_vc_kbd_slock(kbd, value);
875 /* try to make Alt, oops, AltGr and such work */
876 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
877 kbd->slockstate = 0;
878 chg_vc_kbd_slock(kbd, value);
879 }
880}
881
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500882/* by default, 300ms interval for combination release */
Samuel Thibault77426d72006-04-26 00:14:10 -0400883static unsigned brl_timeout = 300;
884MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
885module_param(brl_timeout, uint, 0644);
886
887static unsigned brl_nbchords = 1;
888MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
889module_param(brl_nbchords, uint, 0644);
890
David Howells7d12e782006-10-05 14:55:46 +0100891static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
Samuel Thibault77426d72006-04-26 00:14:10 -0400892{
893 static unsigned long chords;
894 static unsigned committed;
895
896 if (!brl_nbchords)
David Howells7d12e782006-10-05 14:55:46 +0100897 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400898 else {
899 committed |= pattern;
900 chords++;
901 if (chords == brl_nbchords) {
David Howells7d12e782006-10-05 14:55:46 +0100902 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400903 chords = 0;
904 committed = 0;
905 }
906 }
907}
908
David Howells7d12e782006-10-05 14:55:46 +0100909static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500910{
Dmitry Torokhove0785572010-03-21 22:31:26 -0700911 static unsigned pressed, committing;
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500912 static unsigned long releasestart;
913
914 if (kbd->kbdmode != VC_UNICODE) {
915 if (!up_flag)
Joe Perchese620e542014-11-09 22:46:35 -0800916 pr_warn("keyboard mode must be unicode for braille patterns\n");
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500917 return;
918 }
919
920 if (!value) {
David Howells7d12e782006-10-05 14:55:46 +0100921 k_unicode(vc, BRL_UC_ROW, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500922 return;
923 }
924
925 if (value > 8)
926 return;
927
Dmitry Torokhove0785572010-03-21 22:31:26 -0700928 if (!up_flag) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500929 pressed |= 1 << (value - 1);
930 if (!brl_timeout)
931 committing = pressed;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700932 } else if (brl_timeout) {
933 if (!committing ||
934 time_after(jiffies,
935 releasestart + msecs_to_jiffies(brl_timeout))) {
936 committing = pressed;
937 releasestart = jiffies;
938 }
939 pressed &= ~(1 << (value - 1));
940 if (!pressed && committing) {
941 k_brlcommit(vc, committing, 0);
942 committing = 0;
943 }
944 } else {
945 if (committing) {
946 k_brlcommit(vc, committing, 0);
947 committing = 0;
948 }
949 pressed &= ~(1 << (value - 1));
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500950 }
951}
952
Samuel Thibault52355522015-03-16 21:19:44 -0700953#if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
954
955struct kbd_led_trigger {
956 struct led_trigger trigger;
957 unsigned int mask;
958};
959
960static void kbd_led_trigger_activate(struct led_classdev *cdev)
961{
962 struct kbd_led_trigger *trigger =
963 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
964
965 tasklet_disable(&keyboard_tasklet);
Samuel Thibaulteeb64c12015-06-06 11:44:39 -0700966 if (ledstate != -1U)
Samuel Thibault52355522015-03-16 21:19:44 -0700967 led_trigger_event(&trigger->trigger,
968 ledstate & trigger->mask ?
969 LED_FULL : LED_OFF);
970 tasklet_enable(&keyboard_tasklet);
971}
972
973#define KBD_LED_TRIGGER(_led_bit, _name) { \
974 .trigger = { \
975 .name = _name, \
976 .activate = kbd_led_trigger_activate, \
977 }, \
978 .mask = BIT(_led_bit), \
979 }
980
Samuel Thibaulteeb64c12015-06-06 11:44:39 -0700981#define KBD_LOCKSTATE_TRIGGER(_led_bit, _name) \
982 KBD_LED_TRIGGER((_led_bit) + 8, _name)
983
Samuel Thibault52355522015-03-16 21:19:44 -0700984static struct kbd_led_trigger kbd_led_triggers[] = {
985 KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrollock"),
986 KBD_LED_TRIGGER(VC_NUMLOCK, "kbd-numlock"),
987 KBD_LED_TRIGGER(VC_CAPSLOCK, "kbd-capslock"),
988 KBD_LED_TRIGGER(VC_KANALOCK, "kbd-kanalock"),
Samuel Thibaulteeb64c12015-06-06 11:44:39 -0700989
990 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK, "kbd-shiftlock"),
991 KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK, "kbd-altgrlock"),
992 KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK, "kbd-ctrllock"),
993 KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK, "kbd-altlock"),
994 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
995 KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
996 KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK, "kbd-ctrlllock"),
997 KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK, "kbd-ctrlrlock"),
Samuel Thibault52355522015-03-16 21:19:44 -0700998};
999
1000static void kbd_propagate_led_state(unsigned int old_state,
1001 unsigned int new_state)
1002{
1003 struct kbd_led_trigger *trigger;
1004 unsigned int changed = old_state ^ new_state;
1005 int i;
1006
1007 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1008 trigger = &kbd_led_triggers[i];
1009
1010 if (changed & trigger->mask)
1011 led_trigger_event(&trigger->trigger,
1012 new_state & trigger->mask ?
1013 LED_FULL : LED_OFF);
1014 }
1015}
1016
1017static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1018{
1019 unsigned int led_state = *(unsigned int *)data;
1020
1021 if (test_bit(EV_LED, handle->dev->evbit))
1022 kbd_propagate_led_state(~led_state, led_state);
1023
1024 return 0;
1025}
1026
1027static void kbd_init_leds(void)
1028{
1029 int error;
1030 int i;
1031
1032 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1033 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1034 if (error)
1035 pr_err("error %d while registering trigger %s\n",
1036 error, kbd_led_triggers[i].trigger.name);
1037 }
1038}
1039
1040#else
1041
1042static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1043{
1044 unsigned int leds = *(unsigned int *)data;
1045
1046 if (test_bit(EV_LED, handle->dev->evbit)) {
1047 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1048 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1049 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1050 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1051 }
1052
1053 return 0;
1054}
1055
1056static void kbd_propagate_led_state(unsigned int old_state,
1057 unsigned int new_state)
1058{
1059 input_handler_for_each_handle(&kbd_handler, &new_state,
1060 kbd_update_leds_helper);
1061}
1062
1063static void kbd_init_leds(void)
1064{
1065}
1066
1067#endif
1068
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069/*
1070 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1071 * or (ii) whatever pattern of lights people want to show using KDSETLED,
1072 * or (iii) specified bits of specified words in kernel memory.
1073 */
Alan Cox3db1ddb2012-07-17 17:06:41 +01001074static unsigned char getledstate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075{
Samuel Thibaulteeb64c12015-06-06 11:44:39 -07001076 return ledstate & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077}
1078
Mark Rustad9d329c12014-09-05 18:57:57 -07001079void setledstate(struct kbd_struct *kb, unsigned int led)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080{
Alan Cox079c9532012-02-28 14:49:23 +00001081 unsigned long flags;
Alan Cox3db1ddb2012-07-17 17:06:41 +01001082 spin_lock_irqsave(&led_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 if (!(led & ~7)) {
1084 ledioctl = led;
Mark Rustad9d329c12014-09-05 18:57:57 -07001085 kb->ledmode = LED_SHOW_IOCTL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 } else
Mark Rustad9d329c12014-09-05 18:57:57 -07001087 kb->ledmode = LED_SHOW_FLAGS;
Dmitry Torokhove0785572010-03-21 22:31:26 -07001088
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 set_leds();
Alan Cox3db1ddb2012-07-17 17:06:41 +01001090 spin_unlock_irqrestore(&led_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091}
1092
1093static inline unsigned char getleds(void)
1094{
Mark Rustad9d329c12014-09-05 18:57:57 -07001095 struct kbd_struct *kb = kbd_table + fg_console;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Mark Rustad9d329c12014-09-05 18:57:57 -07001097 if (kb->ledmode == LED_SHOW_IOCTL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 return ledioctl;
1099
Mark Rustad9d329c12014-09-05 18:57:57 -07001100 return kb->ledflagstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101}
1102
Alan Cox079c9532012-02-28 14:49:23 +00001103/**
1104 * vt_get_leds - helper for braille console
1105 * @console: console to read
1106 * @flag: flag we want to check
1107 *
1108 * Check the status of a keyboard led flag and report it back
1109 */
1110int vt_get_leds(int console, int flag)
1111{
Mark Rustad9d329c12014-09-05 18:57:57 -07001112 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00001113 int ret;
Alan Cox3db1ddb2012-07-17 17:06:41 +01001114 unsigned long flags;
Alan Cox079c9532012-02-28 14:49:23 +00001115
Alan Cox3db1ddb2012-07-17 17:06:41 +01001116 spin_lock_irqsave(&led_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07001117 ret = vc_kbd_led(kb, flag);
Alan Cox3db1ddb2012-07-17 17:06:41 +01001118 spin_unlock_irqrestore(&led_lock, flags);
Alan Cox079c9532012-02-28 14:49:23 +00001119
1120 return ret;
1121}
1122EXPORT_SYMBOL_GPL(vt_get_leds);
1123
1124/**
1125 * vt_set_led_state - set LED state of a console
1126 * @console: console to set
1127 * @leds: LED bits
1128 *
1129 * Set the LEDs on a console. This is a wrapper for the VT layer
1130 * so that we can keep kbd knowledge internal
1131 */
1132void vt_set_led_state(int console, int leds)
1133{
Mark Rustad9d329c12014-09-05 18:57:57 -07001134 struct kbd_struct *kb = kbd_table + console;
1135 setledstate(kb, leds);
Alan Cox079c9532012-02-28 14:49:23 +00001136}
1137
1138/**
1139 * vt_kbd_con_start - Keyboard side of console start
1140 * @console: console
1141 *
1142 * Handle console start. This is a wrapper for the VT layer
1143 * so that we can keep kbd knowledge internal
Alan Cox84f904e2012-05-01 16:12:19 +01001144 *
1145 * FIXME: We eventually need to hold the kbd lock here to protect
1146 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1147 * and start_tty under the kbd_event_lock, while normal tty paths
1148 * don't hold the lock. We probably need to split out an LED lock
1149 * but not during an -rc release!
Alan Cox079c9532012-02-28 14:49:23 +00001150 */
1151void vt_kbd_con_start(int console)
1152{
Mark Rustad9d329c12014-09-05 18:57:57 -07001153 struct kbd_struct *kb = kbd_table + console;
Alan Cox3db1ddb2012-07-17 17:06:41 +01001154 unsigned long flags;
1155 spin_lock_irqsave(&led_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07001156 clr_vc_kbd_led(kb, VC_SCROLLOCK);
Alan Cox079c9532012-02-28 14:49:23 +00001157 set_leds();
Alan Cox3db1ddb2012-07-17 17:06:41 +01001158 spin_unlock_irqrestore(&led_lock, flags);
Alan Cox079c9532012-02-28 14:49:23 +00001159}
1160
1161/**
1162 * vt_kbd_con_stop - Keyboard side of console stop
1163 * @console: console
1164 *
1165 * Handle console stop. This is a wrapper for the VT layer
1166 * so that we can keep kbd knowledge internal
1167 */
1168void vt_kbd_con_stop(int console)
1169{
Mark Rustad9d329c12014-09-05 18:57:57 -07001170 struct kbd_struct *kb = kbd_table + console;
Alan Cox3db1ddb2012-07-17 17:06:41 +01001171 unsigned long flags;
1172 spin_lock_irqsave(&led_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07001173 set_vc_kbd_led(kb, VC_SCROLLOCK);
Alan Cox079c9532012-02-28 14:49:23 +00001174 set_leds();
Alan Cox3db1ddb2012-07-17 17:06:41 +01001175 spin_unlock_irqrestore(&led_lock, flags);
Alan Cox079c9532012-02-28 14:49:23 +00001176}
1177
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001178/*
Samuel Thibault52355522015-03-16 21:19:44 -07001179 * This is the tasklet that updates LED state of LEDs using standard
1180 * keyboard triggers. The reason we use tasklet is that we need to
1181 * handle the scenario when keyboard handler is not registered yet
1182 * but we already getting updates from the VT to update led state.
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001183 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184static void kbd_bh(unsigned long dummy)
1185{
Samuel Thibaulteeb64c12015-06-06 11:44:39 -07001186 unsigned int leds;
Alan Cox3db1ddb2012-07-17 17:06:41 +01001187 unsigned long flags;
Samuel Thibault52355522015-03-16 21:19:44 -07001188
Alan Cox3db1ddb2012-07-17 17:06:41 +01001189 spin_lock_irqsave(&led_lock, flags);
1190 leds = getleds();
Samuel Thibaulteeb64c12015-06-06 11:44:39 -07001191 leds |= (unsigned int)kbd->lockstate << 8;
Alan Cox3db1ddb2012-07-17 17:06:41 +01001192 spin_unlock_irqrestore(&led_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193
1194 if (leds != ledstate) {
Samuel Thibault52355522015-03-16 21:19:44 -07001195 kbd_propagate_led_state(ledstate, leds);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001196 ledstate = leds;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198}
1199
1200DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1201
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001203 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1204 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
Hans-Christian Egtvedt3a4e8322007-12-04 13:15:41 +01001205 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1206 defined(CONFIG_AVR32)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1209 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1210
Andreas Mohr0f5e5602006-06-05 00:18:00 -04001211static const unsigned short x86_keycodes[256] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1213 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1214 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1215 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1216 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1217 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001218 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1220 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
Hans de Goede72a42f22007-07-03 01:55:18 -04001221 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1222 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1224 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1225 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1226 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1227
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001228#ifdef CONFIG_SPARC
Dmitry Torokhove0785572010-03-21 22:31:26 -07001229static int sparc_l1_a_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230extern void sun_do_break(void);
1231#endif
1232
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001233static int emulate_raw(struct vc_data *vc, unsigned int keycode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 unsigned char up_flag)
1235{
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001236 int code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
1238 switch (keycode) {
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001239
Dmitry Torokhove0785572010-03-21 22:31:26 -07001240 case KEY_PAUSE:
1241 put_queue(vc, 0xe1);
1242 put_queue(vc, 0x1d | up_flag);
1243 put_queue(vc, 0x45 | up_flag);
1244 break;
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001245
Dmitry Torokhove0785572010-03-21 22:31:26 -07001246 case KEY_HANGEUL:
1247 if (!up_flag)
1248 put_queue(vc, 0xf2);
1249 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250
Dmitry Torokhove0785572010-03-21 22:31:26 -07001251 case KEY_HANJA:
1252 if (!up_flag)
1253 put_queue(vc, 0xf1);
1254 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
Dmitry Torokhove0785572010-03-21 22:31:26 -07001256 case KEY_SYSRQ:
1257 /*
1258 * Real AT keyboards (that's what we're trying
1259 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1260 * pressing PrtSc/SysRq alone, but simply 0x54
1261 * when pressing Alt+PrtSc/SysRq.
1262 */
1263 if (test_bit(KEY_LEFTALT, key_down) ||
1264 test_bit(KEY_RIGHTALT, key_down)) {
1265 put_queue(vc, 0x54 | up_flag);
1266 } else {
1267 put_queue(vc, 0xe0);
1268 put_queue(vc, 0x2a | up_flag);
1269 put_queue(vc, 0xe0);
1270 put_queue(vc, 0x37 | up_flag);
1271 }
1272 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
Dmitry Torokhove0785572010-03-21 22:31:26 -07001274 default:
1275 if (keycode > 255)
1276 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Dmitry Torokhove0785572010-03-21 22:31:26 -07001278 code = x86_keycodes[keycode];
1279 if (!code)
1280 return -1;
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001281
Dmitry Torokhove0785572010-03-21 22:31:26 -07001282 if (code & 0x100)
1283 put_queue(vc, 0xe0);
1284 put_queue(vc, (code & 0x7f) | up_flag);
1285
1286 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 }
1288
1289 return 0;
1290}
1291
1292#else
1293
1294#define HW_RAW(dev) 0
1295
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1297{
1298 if (keycode > 127)
1299 return -1;
1300
1301 put_queue(vc, keycode | up_flag);
1302 return 0;
1303}
1304#endif
1305
1306static void kbd_rawcode(unsigned char data)
1307{
1308 struct vc_data *vc = vc_cons[fg_console].d;
Dmitry Torokhove0785572010-03-21 22:31:26 -07001309
Alan Jenkins0c09b2a2009-11-18 00:40:48 -08001310 kbd = kbd_table + vc->vc_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 if (kbd->kbdmode == VC_RAW)
1312 put_queue(vc, data);
1313}
1314
David Howells7d12e782006-10-05 14:55:46 +01001315static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316{
1317 struct vc_data *vc = vc_cons[fg_console].d;
1318 unsigned short keysym, *key_map;
Dmitry Torokhove0785572010-03-21 22:31:26 -07001319 unsigned char type;
1320 bool raw_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 struct tty_struct *tty;
1322 int shift_final;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001323 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
Dmitry Torokhove0785572010-03-21 22:31:26 -07001324 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
Alan Cox8ce73262010-06-01 22:52:56 +02001326 tty = vc->port.tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
1328 if (tty && (!tty->driver_data)) {
1329 /* No driver data? Strange. Okay we fix it then. */
1330 tty->driver_data = vc;
1331 }
1332
Alan Jenkins0c09b2a2009-11-18 00:40:48 -08001333 kbd = kbd_table + vc->vc_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001335#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 if (keycode == KEY_STOP)
1337 sparc_l1_a_state = down;
1338#endif
1339
1340 rep = (down == 2);
1341
Dmitry Torokhove0785572010-03-21 22:31:26 -07001342 raw_mode = (kbd->kbdmode == VC_RAW);
1343 if (raw_mode && !hw_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 if (emulate_raw(vc, keycode, !down << 7))
Dmitry Torokhov9e35d202007-04-12 01:30:52 -04001345 if (keycode < BTN_MISC && printk_ratelimit())
Joe Perchese620e542014-11-09 22:46:35 -08001346 pr_warn("can't emulate rawmode for keycode %d\n",
1347 keycode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001349#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 if (keycode == KEY_A && sparc_l1_a_state) {
Dmitry Torokhove0785572010-03-21 22:31:26 -07001351 sparc_l1_a_state = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 sun_do_break();
1353 }
1354#endif
1355
1356 if (kbd->kbdmode == VC_MEDIUMRAW) {
1357 /*
1358 * This is extended medium raw mode, with keys above 127
1359 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1360 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1361 * interfere with anything else. The two bytes after 0 will
1362 * always have the up flag set not to interfere with older
1363 * applications. This allows for 16384 different keycodes,
1364 * which should be enough.
1365 */
1366 if (keycode < 128) {
1367 put_queue(vc, keycode | (!down << 7));
1368 } else {
1369 put_queue(vc, !down << 7);
1370 put_queue(vc, (keycode >> 7) | 0x80);
1371 put_queue(vc, keycode | 0x80);
1372 }
Dmitry Torokhove0785572010-03-21 22:31:26 -07001373 raw_mode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 }
1375
1376 if (down)
1377 set_bit(keycode, key_down);
1378 else
1379 clear_bit(keycode, key_down);
1380
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001381 if (rep &&
1382 (!vc_kbd_mode(kbd, VC_REPEAT) ||
Alan Coxf34d7a52008-04-30 00:54:13 -07001383 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 /*
1385 * Don't repeat a key if the input buffers are not empty and the
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001386 * characters get aren't echoed locally. This makes key repeat
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 * usable with slow applications and under heavy loads.
1388 */
1389 return;
1390 }
1391
Samuel Thibault41ab4392007-10-18 23:39:12 -07001392 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001393 param.ledstate = kbd->ledflagstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 key_map = key_maps[shift_final];
1395
Dmitry Torokhove0785572010-03-21 22:31:26 -07001396 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1397 KBD_KEYCODE, &param);
1398 if (rc == NOTIFY_STOP || !key_map) {
1399 atomic_notifier_call_chain(&keyboard_notifier_list,
1400 KBD_UNBOUND_KEYCODE, &param);
Alan Cox079c9532012-02-28 14:49:23 +00001401 do_compute_shiftstate();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 kbd->slockstate = 0;
1403 return;
1404 }
1405
Dmitry Torokhove0785572010-03-21 22:31:26 -07001406 if (keycode < NR_KEYS)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -05001407 keysym = key_map[keycode];
Dmitry Torokhove0785572010-03-21 22:31:26 -07001408 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1409 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1410 else
1411 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 type = KTYP(keysym);
1414
1415 if (type < 0xf0) {
Samuel Thibault41ab4392007-10-18 23:39:12 -07001416 param.value = keysym;
Dmitry Torokhove0785572010-03-21 22:31:26 -07001417 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1418 KBD_UNICODE, &param);
1419 if (rc != NOTIFY_STOP)
1420 if (down && !raw_mode)
1421 to_utf8(vc, keysym);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 return;
1423 }
1424
1425 type -= 0xf0;
1426
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 if (type == KT_LETTER) {
1428 type = KT_LATIN;
1429 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1430 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1431 if (key_map)
1432 keysym = key_map[keycode];
1433 }
1434 }
Samuel Thibault41ab4392007-10-18 23:39:12 -07001435
Dmitry Torokhove0785572010-03-21 22:31:26 -07001436 param.value = keysym;
1437 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1438 KBD_KEYSYM, &param);
1439 if (rc == NOTIFY_STOP)
Samuel Thibault41ab4392007-10-18 23:39:12 -07001440 return;
1441
Arthur Taylor9fc3de92011-02-04 13:55:50 -08001442 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
Samuel Thibault41ab4392007-10-18 23:39:12 -07001443 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444
David Howells7d12e782006-10-05 14:55:46 +01001445 (*k_handler[type])(vc, keysym & 0xff, !down);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001447 param.ledstate = kbd->ledflagstate;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001448 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1449
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 if (type != KT_SLOCK)
1451 kbd->slockstate = 0;
1452}
1453
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001454static void kbd_event(struct input_handle *handle, unsigned int event_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 unsigned int event_code, int value)
1456{
Dmitry Torokhov21cea582009-11-29 23:40:58 -08001457 /* We are called with interrupts disabled, just take the lock */
1458 spin_lock(&kbd_event_lock);
1459
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1461 kbd_rawcode(value);
1462 if (event_type == EV_KEY)
David Howells7d12e782006-10-05 14:55:46 +01001463 kbd_keycode(event_code, value, HW_RAW(handle->dev));
Dmitry Torokhov21cea582009-11-29 23:40:58 -08001464
1465 spin_unlock(&kbd_event_lock);
1466
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 tasklet_schedule(&keyboard_tasklet);
1468 do_poke_blanked_console = 1;
1469 schedule_console_callback();
1470}
1471
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -08001472static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1473{
1474 int i;
1475
1476 if (test_bit(EV_SND, dev->evbit))
1477 return true;
1478
Samuel Thibault53c1f762010-07-31 02:28:51 -07001479 if (test_bit(EV_KEY, dev->evbit)) {
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -08001480 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1481 if (test_bit(i, dev->keybit))
1482 return true;
Samuel Thibault53c1f762010-07-31 02:28:51 -07001483 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1484 if (test_bit(i, dev->keybit))
1485 return true;
1486 }
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -08001487
1488 return false;
1489}
1490
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491/*
1492 * When a keyboard (or other input device) is found, the kbd_connect
1493 * function is called. The function then looks at the device, and if it
1494 * likes it, it can open it and get events from it. In this (kbd_connect)
1495 * function, we should decide which VT to bind that keyboard to initially.
1496 */
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001497static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1498 const struct input_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499{
1500 struct input_handle *handle;
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001501 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
Dmitry Torokhov22479e12006-08-04 22:51:51 -04001503 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1504 if (!handle)
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001505 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
1507 handle->dev = dev;
1508 handle->handler = handler;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001509 handle->name = "kbd";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001511 error = input_register_handle(handle);
1512 if (error)
1513 goto err_free_handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001515 error = input_open_device(handle);
1516 if (error)
1517 goto err_unregister_handle;
1518
1519 return 0;
1520
1521 err_unregister_handle:
1522 input_unregister_handle(handle);
1523 err_free_handle:
1524 kfree(handle);
1525 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526}
1527
1528static void kbd_disconnect(struct input_handle *handle)
1529{
1530 input_close_device(handle);
Dmitry Torokhov5b2a08262007-04-12 01:29:46 -04001531 input_unregister_handle(handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 kfree(handle);
1533}
1534
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001535/*
1536 * Start keyboard handler on the new keyboard by refreshing LED state to
1537 * match the rest of the system.
1538 */
1539static void kbd_start(struct input_handle *handle)
1540{
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001541 tasklet_disable(&keyboard_tasklet);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001542
Samuel Thibaulteeb64c12015-06-06 11:44:39 -07001543 if (ledstate != -1U)
1544 kbd_update_leds_helper(handle, &ledstate);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001545
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001546 tasklet_enable(&keyboard_tasklet);
1547}
1548
Dmitry Torokhov66e66112006-09-14 01:31:59 -04001549static const struct input_device_id kbd_ids[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 {
Alan Cox6aeed472012-02-24 12:47:29 +00001551 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1552 .evbit = { BIT_MASK(EV_KEY) },
1553 },
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001554
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 {
Alan Cox6aeed472012-02-24 12:47:29 +00001556 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1557 .evbit = { BIT_MASK(EV_SND) },
1558 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
1560 { }, /* Terminating entry */
1561};
1562
1563MODULE_DEVICE_TABLE(input, kbd_ids);
1564
1565static struct input_handler kbd_handler = {
1566 .event = kbd_event,
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -08001567 .match = kbd_match,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 .connect = kbd_connect,
1569 .disconnect = kbd_disconnect,
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001570 .start = kbd_start,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 .name = "kbd",
1572 .id_table = kbd_ids,
1573};
1574
1575int __init kbd_init(void)
1576{
1577 int i;
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001578 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579
Alan Cox6aeed472012-02-24 12:47:29 +00001580 for (i = 0; i < MAX_NR_CONSOLES; i++) {
Joshua Covb2d0b7a2012-04-13 21:08:26 +02001581 kbd_table[i].ledflagstate = kbd_defleds();
1582 kbd_table[i].default_ledflagstate = kbd_defleds();
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001583 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1584 kbd_table[i].lockstate = KBD_DEFLOCK;
1585 kbd_table[i].slockstate = 0;
1586 kbd_table[i].modeflags = KBD_DEFMODE;
Bill Nottingham2e8ecb92007-10-16 23:29:38 -07001587 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001588 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
Samuel Thibault52355522015-03-16 21:19:44 -07001590 kbd_init_leds();
1591
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001592 error = input_register_handler(&kbd_handler);
1593 if (error)
1594 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 tasklet_enable(&keyboard_tasklet);
1597 tasklet_schedule(&keyboard_tasklet);
1598
1599 return 0;
1600}
Alan Cox247ff8e2012-02-24 12:47:11 +00001601
1602/* Ioctl support code */
1603
1604/**
1605 * vt_do_diacrit - diacritical table updates
1606 * @cmd: ioctl request
Mark Rustad9d329c12014-09-05 18:57:57 -07001607 * @udp: pointer to user data for ioctl
Alan Cox247ff8e2012-02-24 12:47:11 +00001608 * @perm: permissions check computed by caller
1609 *
1610 * Update the diacritical tables atomically and safely. Lock them
1611 * against simultaneous keypresses
1612 */
Mark Rustad9d329c12014-09-05 18:57:57 -07001613int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
Alan Cox247ff8e2012-02-24 12:47:11 +00001614{
Alan Cox247ff8e2012-02-24 12:47:11 +00001615 unsigned long flags;
1616 int asize;
1617 int ret = 0;
1618
1619 switch (cmd) {
1620 case KDGKBDIACR:
1621 {
Mark Rustad9d329c12014-09-05 18:57:57 -07001622 struct kbdiacrs __user *a = udp;
1623 struct kbdiacr *dia;
Alan Cox247ff8e2012-02-24 12:47:11 +00001624 int i;
1625
Mark Rustad9d329c12014-09-05 18:57:57 -07001626 dia = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
Alan Cox247ff8e2012-02-24 12:47:11 +00001627 GFP_KERNEL);
Mark Rustad9d329c12014-09-05 18:57:57 -07001628 if (!dia)
Alan Cox247ff8e2012-02-24 12:47:11 +00001629 return -ENOMEM;
1630
1631 /* Lock the diacriticals table, make a copy and then
1632 copy it after we unlock */
1633 spin_lock_irqsave(&kbd_event_lock, flags);
1634
1635 asize = accent_table_size;
1636 for (i = 0; i < asize; i++) {
Mark Rustad9d329c12014-09-05 18:57:57 -07001637 dia[i].diacr = conv_uni_to_8bit(
Alan Cox247ff8e2012-02-24 12:47:11 +00001638 accent_table[i].diacr);
Mark Rustad9d329c12014-09-05 18:57:57 -07001639 dia[i].base = conv_uni_to_8bit(
Alan Cox247ff8e2012-02-24 12:47:11 +00001640 accent_table[i].base);
Mark Rustad9d329c12014-09-05 18:57:57 -07001641 dia[i].result = conv_uni_to_8bit(
Alan Cox247ff8e2012-02-24 12:47:11 +00001642 accent_table[i].result);
1643 }
1644 spin_unlock_irqrestore(&kbd_event_lock, flags);
1645
1646 if (put_user(asize, &a->kb_cnt))
1647 ret = -EFAULT;
Mark Rustad9d329c12014-09-05 18:57:57 -07001648 else if (copy_to_user(a->kbdiacr, dia,
Alan Cox247ff8e2012-02-24 12:47:11 +00001649 asize * sizeof(struct kbdiacr)))
1650 ret = -EFAULT;
Mark Rustad9d329c12014-09-05 18:57:57 -07001651 kfree(dia);
Alan Cox247ff8e2012-02-24 12:47:11 +00001652 return ret;
1653 }
1654 case KDGKBDIACRUC:
1655 {
Mark Rustad9d329c12014-09-05 18:57:57 -07001656 struct kbdiacrsuc __user *a = udp;
Alan Cox247ff8e2012-02-24 12:47:11 +00001657 void *buf;
1658
1659 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1660 GFP_KERNEL);
1661 if (buf == NULL)
1662 return -ENOMEM;
1663
1664 /* Lock the diacriticals table, make a copy and then
1665 copy it after we unlock */
1666 spin_lock_irqsave(&kbd_event_lock, flags);
1667
1668 asize = accent_table_size;
1669 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1670
1671 spin_unlock_irqrestore(&kbd_event_lock, flags);
1672
1673 if (put_user(asize, &a->kb_cnt))
1674 ret = -EFAULT;
1675 else if (copy_to_user(a->kbdiacruc, buf,
1676 asize*sizeof(struct kbdiacruc)))
1677 ret = -EFAULT;
1678 kfree(buf);
1679 return ret;
1680 }
1681
1682 case KDSKBDIACR:
1683 {
Mark Rustad9d329c12014-09-05 18:57:57 -07001684 struct kbdiacrs __user *a = udp;
1685 struct kbdiacr *dia = NULL;
Alan Cox247ff8e2012-02-24 12:47:11 +00001686 unsigned int ct;
1687 int i;
1688
1689 if (!perm)
1690 return -EPERM;
1691 if (get_user(ct, &a->kb_cnt))
1692 return -EFAULT;
1693 if (ct >= MAX_DIACR)
1694 return -EINVAL;
1695
1696 if (ct) {
Alan Cox247ff8e2012-02-24 12:47:11 +00001697
Saurabh Sengar10519372015-10-28 11:56:44 +05301698 dia = memdup_user(a->kbdiacr,
1699 sizeof(struct kbdiacr) * ct);
1700 if (IS_ERR(dia))
1701 return PTR_ERR(dia);
1702
Alan Cox247ff8e2012-02-24 12:47:11 +00001703 }
1704
1705 spin_lock_irqsave(&kbd_event_lock, flags);
1706 accent_table_size = ct;
1707 for (i = 0; i < ct; i++) {
1708 accent_table[i].diacr =
Mark Rustad9d329c12014-09-05 18:57:57 -07001709 conv_8bit_to_uni(dia[i].diacr);
Alan Cox247ff8e2012-02-24 12:47:11 +00001710 accent_table[i].base =
Mark Rustad9d329c12014-09-05 18:57:57 -07001711 conv_8bit_to_uni(dia[i].base);
Alan Cox247ff8e2012-02-24 12:47:11 +00001712 accent_table[i].result =
Mark Rustad9d329c12014-09-05 18:57:57 -07001713 conv_8bit_to_uni(dia[i].result);
Alan Cox247ff8e2012-02-24 12:47:11 +00001714 }
1715 spin_unlock_irqrestore(&kbd_event_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07001716 kfree(dia);
Alan Cox247ff8e2012-02-24 12:47:11 +00001717 return 0;
1718 }
1719
1720 case KDSKBDIACRUC:
1721 {
Mark Rustad9d329c12014-09-05 18:57:57 -07001722 struct kbdiacrsuc __user *a = udp;
Alan Cox247ff8e2012-02-24 12:47:11 +00001723 unsigned int ct;
1724 void *buf = NULL;
1725
1726 if (!perm)
1727 return -EPERM;
1728
1729 if (get_user(ct, &a->kb_cnt))
1730 return -EFAULT;
1731
1732 if (ct >= MAX_DIACR)
1733 return -EINVAL;
1734
1735 if (ct) {
Muhammad Falak R Wani9b651902016-05-20 17:53:28 +05301736 buf = memdup_user(a->kbdiacruc,
1737 ct * sizeof(struct kbdiacruc));
1738 if (IS_ERR(buf))
1739 return PTR_ERR(buf);
Alan Cox247ff8e2012-02-24 12:47:11 +00001740 }
1741 spin_lock_irqsave(&kbd_event_lock, flags);
1742 if (ct)
1743 memcpy(accent_table, buf,
1744 ct * sizeof(struct kbdiacruc));
1745 accent_table_size = ct;
1746 spin_unlock_irqrestore(&kbd_event_lock, flags);
1747 kfree(buf);
1748 return 0;
1749 }
1750 }
1751 return ret;
1752}
Alan Cox079c9532012-02-28 14:49:23 +00001753
1754/**
1755 * vt_do_kdskbmode - set keyboard mode ioctl
1756 * @console: the console to use
1757 * @arg: the requested mode
1758 *
1759 * Update the keyboard mode bits while holding the correct locks.
1760 * Return 0 for success or an error code.
1761 */
1762int vt_do_kdskbmode(int console, unsigned int arg)
1763{
Mark Rustad9d329c12014-09-05 18:57:57 -07001764 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00001765 int ret = 0;
1766 unsigned long flags;
1767
1768 spin_lock_irqsave(&kbd_event_lock, flags);
1769 switch(arg) {
1770 case K_RAW:
Mark Rustad9d329c12014-09-05 18:57:57 -07001771 kb->kbdmode = VC_RAW;
Alan Cox079c9532012-02-28 14:49:23 +00001772 break;
1773 case K_MEDIUMRAW:
Mark Rustad9d329c12014-09-05 18:57:57 -07001774 kb->kbdmode = VC_MEDIUMRAW;
Alan Cox079c9532012-02-28 14:49:23 +00001775 break;
1776 case K_XLATE:
Mark Rustad9d329c12014-09-05 18:57:57 -07001777 kb->kbdmode = VC_XLATE;
Alan Cox079c9532012-02-28 14:49:23 +00001778 do_compute_shiftstate();
1779 break;
1780 case K_UNICODE:
Mark Rustad9d329c12014-09-05 18:57:57 -07001781 kb->kbdmode = VC_UNICODE;
Alan Cox079c9532012-02-28 14:49:23 +00001782 do_compute_shiftstate();
1783 break;
1784 case K_OFF:
Mark Rustad9d329c12014-09-05 18:57:57 -07001785 kb->kbdmode = VC_OFF;
Alan Cox079c9532012-02-28 14:49:23 +00001786 break;
1787 default:
1788 ret = -EINVAL;
1789 }
1790 spin_unlock_irqrestore(&kbd_event_lock, flags);
1791 return ret;
1792}
1793
1794/**
1795 * vt_do_kdskbmeta - set keyboard meta state
1796 * @console: the console to use
1797 * @arg: the requested meta state
1798 *
1799 * Update the keyboard meta bits while holding the correct locks.
1800 * Return 0 for success or an error code.
1801 */
1802int vt_do_kdskbmeta(int console, unsigned int arg)
1803{
Mark Rustad9d329c12014-09-05 18:57:57 -07001804 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00001805 int ret = 0;
1806 unsigned long flags;
1807
1808 spin_lock_irqsave(&kbd_event_lock, flags);
1809 switch(arg) {
1810 case K_METABIT:
Mark Rustad9d329c12014-09-05 18:57:57 -07001811 clr_vc_kbd_mode(kb, VC_META);
Alan Cox079c9532012-02-28 14:49:23 +00001812 break;
1813 case K_ESCPREFIX:
Mark Rustad9d329c12014-09-05 18:57:57 -07001814 set_vc_kbd_mode(kb, VC_META);
Alan Cox079c9532012-02-28 14:49:23 +00001815 break;
1816 default:
1817 ret = -EINVAL;
1818 }
1819 spin_unlock_irqrestore(&kbd_event_lock, flags);
1820 return ret;
1821}
1822
1823int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1824 int perm)
1825{
1826 struct kbkeycode tmp;
1827 int kc = 0;
1828
1829 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1830 return -EFAULT;
1831 switch (cmd) {
1832 case KDGETKEYCODE:
1833 kc = getkeycode(tmp.scancode);
1834 if (kc >= 0)
1835 kc = put_user(kc, &user_kbkc->keycode);
1836 break;
1837 case KDSETKEYCODE:
1838 if (!perm)
1839 return -EPERM;
1840 kc = setkeycode(tmp.scancode, tmp.keycode);
1841 break;
1842 }
1843 return kc;
1844}
1845
1846#define i (tmp.kb_index)
1847#define s (tmp.kb_table)
1848#define v (tmp.kb_value)
1849
1850int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1851 int console)
1852{
Mark Rustad9d329c12014-09-05 18:57:57 -07001853 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00001854 struct kbentry tmp;
1855 ushort *key_map, *new_map, val, ov;
1856 unsigned long flags;
1857
1858 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1859 return -EFAULT;
1860
1861 if (!capable(CAP_SYS_TTY_CONFIG))
1862 perm = 0;
1863
1864 switch (cmd) {
1865 case KDGKBENT:
1866 /* Ensure another thread doesn't free it under us */
1867 spin_lock_irqsave(&kbd_event_lock, flags);
1868 key_map = key_maps[s];
1869 if (key_map) {
1870 val = U(key_map[i]);
Mark Rustad9d329c12014-09-05 18:57:57 -07001871 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
Alan Cox079c9532012-02-28 14:49:23 +00001872 val = K_HOLE;
1873 } else
1874 val = (i ? K_HOLE : K_NOSUCHMAP);
1875 spin_unlock_irqrestore(&kbd_event_lock, flags);
1876 return put_user(val, &user_kbe->kb_value);
1877 case KDSKBENT:
1878 if (!perm)
1879 return -EPERM;
1880 if (!i && v == K_NOSUCHMAP) {
1881 spin_lock_irqsave(&kbd_event_lock, flags);
1882 /* deallocate map */
1883 key_map = key_maps[s];
1884 if (s && key_map) {
1885 key_maps[s] = NULL;
1886 if (key_map[0] == U(K_ALLOCATED)) {
1887 kfree(key_map);
1888 keymap_count--;
1889 }
1890 }
1891 spin_unlock_irqrestore(&kbd_event_lock, flags);
1892 break;
1893 }
1894
1895 if (KTYP(v) < NR_TYPES) {
1896 if (KVAL(v) > max_vals[KTYP(v)])
1897 return -EINVAL;
1898 } else
Mark Rustad9d329c12014-09-05 18:57:57 -07001899 if (kb->kbdmode != VC_UNICODE)
Alan Cox079c9532012-02-28 14:49:23 +00001900 return -EINVAL;
1901
1902 /* ++Geert: non-PC keyboards may generate keycode zero */
1903#if !defined(__mc68000__) && !defined(__powerpc__)
1904 /* assignment to entry 0 only tests validity of args */
1905 if (!i)
1906 break;
1907#endif
1908
1909 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1910 if (!new_map)
1911 return -ENOMEM;
1912 spin_lock_irqsave(&kbd_event_lock, flags);
1913 key_map = key_maps[s];
1914 if (key_map == NULL) {
1915 int j;
1916
1917 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1918 !capable(CAP_SYS_RESOURCE)) {
1919 spin_unlock_irqrestore(&kbd_event_lock, flags);
1920 kfree(new_map);
1921 return -EPERM;
1922 }
1923 key_maps[s] = new_map;
Dan Carpenter82896212012-03-10 11:59:23 +03001924 key_map = new_map;
Alan Cox079c9532012-02-28 14:49:23 +00001925 key_map[0] = U(K_ALLOCATED);
1926 for (j = 1; j < NR_KEYS; j++)
1927 key_map[j] = U(K_HOLE);
1928 keymap_count++;
1929 } else
1930 kfree(new_map);
1931
1932 ov = U(key_map[i]);
1933 if (v == ov)
1934 goto out;
1935 /*
1936 * Attention Key.
1937 */
1938 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1939 spin_unlock_irqrestore(&kbd_event_lock, flags);
1940 return -EPERM;
1941 }
1942 key_map[i] = U(v);
1943 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1944 do_compute_shiftstate();
1945out:
1946 spin_unlock_irqrestore(&kbd_event_lock, flags);
1947 break;
1948 }
1949 return 0;
1950}
1951#undef i
1952#undef s
1953#undef v
1954
1955/* FIXME: This one needs untangling and locking */
1956int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1957{
1958 struct kbsentry *kbs;
1959 char *p;
1960 u_char *q;
1961 u_char __user *up;
1962 int sz;
1963 int delta;
1964 char *first_free, *fj, *fnw;
1965 int i, j, k;
1966 int ret;
1967
1968 if (!capable(CAP_SYS_TTY_CONFIG))
1969 perm = 0;
1970
1971 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1972 if (!kbs) {
1973 ret = -ENOMEM;
1974 goto reterr;
1975 }
1976
1977 /* we mostly copy too much here (512bytes), but who cares ;) */
1978 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1979 ret = -EFAULT;
1980 goto reterr;
1981 }
1982 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1983 i = kbs->kb_func;
1984
1985 switch (cmd) {
1986 case KDGKBSENT:
1987 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1988 a struct member */
1989 up = user_kdgkb->kb_string;
1990 p = func_table[i];
1991 if(p)
1992 for ( ; *p && sz; p++, sz--)
1993 if (put_user(*p, up++)) {
1994 ret = -EFAULT;
1995 goto reterr;
1996 }
1997 if (put_user('\0', up)) {
1998 ret = -EFAULT;
1999 goto reterr;
2000 }
2001 kfree(kbs);
2002 return ((p && *p) ? -EOVERFLOW : 0);
2003 case KDSKBSENT:
2004 if (!perm) {
2005 ret = -EPERM;
2006 goto reterr;
2007 }
2008
2009 q = func_table[i];
2010 first_free = funcbufptr + (funcbufsize - funcbufleft);
2011 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2012 ;
2013 if (j < MAX_NR_FUNC)
2014 fj = func_table[j];
2015 else
2016 fj = first_free;
2017
2018 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2019 if (delta <= funcbufleft) { /* it fits in current buf */
2020 if (j < MAX_NR_FUNC) {
2021 memmove(fj + delta, fj, first_free - fj);
2022 for (k = j; k < MAX_NR_FUNC; k++)
2023 if (func_table[k])
2024 func_table[k] += delta;
2025 }
2026 if (!q)
2027 func_table[i] = fj;
2028 funcbufleft -= delta;
2029 } else { /* allocate a larger buffer */
2030 sz = 256;
2031 while (sz < funcbufsize - funcbufleft + delta)
2032 sz <<= 1;
2033 fnw = kmalloc(sz, GFP_KERNEL);
2034 if(!fnw) {
2035 ret = -ENOMEM;
2036 goto reterr;
2037 }
2038
2039 if (!q)
2040 func_table[i] = fj;
2041 if (fj > funcbufptr)
2042 memmove(fnw, funcbufptr, fj - funcbufptr);
2043 for (k = 0; k < j; k++)
2044 if (func_table[k])
2045 func_table[k] = fnw + (func_table[k] - funcbufptr);
2046
2047 if (first_free > fj) {
2048 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2049 for (k = j; k < MAX_NR_FUNC; k++)
2050 if (func_table[k])
2051 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2052 }
2053 if (funcbufptr != func_buf)
2054 kfree(funcbufptr);
2055 funcbufptr = fnw;
2056 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2057 funcbufsize = sz;
2058 }
2059 strcpy(func_table[i], kbs->kb_string);
2060 break;
2061 }
2062 ret = 0;
2063reterr:
2064 kfree(kbs);
2065 return ret;
2066}
2067
2068int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2069{
Mark Rustad9d329c12014-09-05 18:57:57 -07002070 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00002071 unsigned long flags;
2072 unsigned char ucval;
2073
2074 switch(cmd) {
2075 /* the ioctls below read/set the flags usually shown in the leds */
2076 /* don't use them - they will go away without warning */
2077 case KDGKBLED:
2078 spin_lock_irqsave(&kbd_event_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07002079 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
Alan Cox079c9532012-02-28 14:49:23 +00002080 spin_unlock_irqrestore(&kbd_event_lock, flags);
2081 return put_user(ucval, (char __user *)arg);
2082
2083 case KDSKBLED:
2084 if (!perm)
2085 return -EPERM;
2086 if (arg & ~0x77)
2087 return -EINVAL;
Alan Cox3db1ddb2012-07-17 17:06:41 +01002088 spin_lock_irqsave(&led_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07002089 kb->ledflagstate = (arg & 7);
2090 kb->default_ledflagstate = ((arg >> 4) & 7);
Alan Cox079c9532012-02-28 14:49:23 +00002091 set_leds();
Alan Cox3db1ddb2012-07-17 17:06:41 +01002092 spin_unlock_irqrestore(&led_lock, flags);
Alan Coxeea41ae2012-05-14 14:41:31 +01002093 return 0;
Alan Cox079c9532012-02-28 14:49:23 +00002094
2095 /* the ioctls below only set the lights, not the functions */
2096 /* for those, see KDGKBLED and KDSKBLED above */
2097 case KDGETLED:
2098 ucval = getledstate();
2099 return put_user(ucval, (char __user *)arg);
2100
2101 case KDSETLED:
2102 if (!perm)
2103 return -EPERM;
Mark Rustad9d329c12014-09-05 18:57:57 -07002104 setledstate(kb, arg);
Alan Cox079c9532012-02-28 14:49:23 +00002105 return 0;
2106 }
2107 return -ENOIOCTLCMD;
2108}
2109
2110int vt_do_kdgkbmode(int console)
2111{
Mark Rustad9d329c12014-09-05 18:57:57 -07002112 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00002113 /* This is a spot read so needs no locking */
Mark Rustad9d329c12014-09-05 18:57:57 -07002114 switch (kb->kbdmode) {
Alan Cox079c9532012-02-28 14:49:23 +00002115 case VC_RAW:
2116 return K_RAW;
2117 case VC_MEDIUMRAW:
2118 return K_MEDIUMRAW;
2119 case VC_UNICODE:
2120 return K_UNICODE;
2121 case VC_OFF:
2122 return K_OFF;
2123 default:
2124 return K_XLATE;
2125 }
2126}
2127
2128/**
2129 * vt_do_kdgkbmeta - report meta status
2130 * @console: console to report
2131 *
2132 * Report the meta flag status of this console
2133 */
2134int vt_do_kdgkbmeta(int console)
2135{
Mark Rustad9d329c12014-09-05 18:57:57 -07002136 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00002137 /* Again a spot read so no locking */
Mark Rustad9d329c12014-09-05 18:57:57 -07002138 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
Alan Cox079c9532012-02-28 14:49:23 +00002139}
2140
2141/**
2142 * vt_reset_unicode - reset the unicode status
2143 * @console: console being reset
2144 *
2145 * Restore the unicode console state to its default
2146 */
2147void vt_reset_unicode(int console)
2148{
2149 unsigned long flags;
2150
2151 spin_lock_irqsave(&kbd_event_lock, flags);
2152 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2153 spin_unlock_irqrestore(&kbd_event_lock, flags);
2154}
2155
2156/**
2157 * vt_get_shiftstate - shift bit state
2158 *
2159 * Report the shift bits from the keyboard state. We have to export
2160 * this to support some oddities in the vt layer.
2161 */
2162int vt_get_shift_state(void)
2163{
2164 /* Don't lock as this is a transient report */
2165 return shift_state;
2166}
2167
2168/**
2169 * vt_reset_keyboard - reset keyboard state
2170 * @console: console to reset
2171 *
2172 * Reset the keyboard bits for a console as part of a general console
2173 * reset event
2174 */
2175void vt_reset_keyboard(int console)
2176{
Mark Rustad9d329c12014-09-05 18:57:57 -07002177 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00002178 unsigned long flags;
2179
2180 spin_lock_irqsave(&kbd_event_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07002181 set_vc_kbd_mode(kb, VC_REPEAT);
2182 clr_vc_kbd_mode(kb, VC_CKMODE);
2183 clr_vc_kbd_mode(kb, VC_APPLIC);
2184 clr_vc_kbd_mode(kb, VC_CRLF);
2185 kb->lockstate = 0;
2186 kb->slockstate = 0;
Alan Cox3db1ddb2012-07-17 17:06:41 +01002187 spin_lock(&led_lock);
Mark Rustad9d329c12014-09-05 18:57:57 -07002188 kb->ledmode = LED_SHOW_FLAGS;
2189 kb->ledflagstate = kb->default_ledflagstate;
Alan Cox3db1ddb2012-07-17 17:06:41 +01002190 spin_unlock(&led_lock);
Alan Cox079c9532012-02-28 14:49:23 +00002191 /* do not do set_leds here because this causes an endless tasklet loop
2192 when the keyboard hasn't been initialized yet */
2193 spin_unlock_irqrestore(&kbd_event_lock, flags);
2194}
2195
2196/**
2197 * vt_get_kbd_mode_bit - read keyboard status bits
2198 * @console: console to read from
2199 * @bit: mode bit to read
2200 *
2201 * Report back a vt mode bit. We do this without locking so the
2202 * caller must be sure that there are no synchronization needs
2203 */
2204
2205int vt_get_kbd_mode_bit(int console, int bit)
2206{
Mark Rustad9d329c12014-09-05 18:57:57 -07002207 struct kbd_struct *kb = kbd_table + console;
2208 return vc_kbd_mode(kb, bit);
Alan Cox079c9532012-02-28 14:49:23 +00002209}
2210
2211/**
2212 * vt_set_kbd_mode_bit - read keyboard status bits
2213 * @console: console to read from
2214 * @bit: mode bit to read
2215 *
2216 * Set a vt mode bit. We do this without locking so the
2217 * caller must be sure that there are no synchronization needs
2218 */
2219
2220void vt_set_kbd_mode_bit(int console, int bit)
2221{
Mark Rustad9d329c12014-09-05 18:57:57 -07002222 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00002223 unsigned long flags;
2224
2225 spin_lock_irqsave(&kbd_event_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07002226 set_vc_kbd_mode(kb, bit);
Alan Cox079c9532012-02-28 14:49:23 +00002227 spin_unlock_irqrestore(&kbd_event_lock, flags);
2228}
2229
2230/**
2231 * vt_clr_kbd_mode_bit - read keyboard status bits
2232 * @console: console to read from
2233 * @bit: mode bit to read
2234 *
2235 * Report back a vt mode bit. We do this without locking so the
2236 * caller must be sure that there are no synchronization needs
2237 */
2238
2239void vt_clr_kbd_mode_bit(int console, int bit)
2240{
Mark Rustad9d329c12014-09-05 18:57:57 -07002241 struct kbd_struct *kb = kbd_table + console;
Alan Cox079c9532012-02-28 14:49:23 +00002242 unsigned long flags;
2243
2244 spin_lock_irqsave(&kbd_event_lock, flags);
Mark Rustad9d329c12014-09-05 18:57:57 -07002245 clr_vc_kbd_mode(kb, bit);
Alan Cox079c9532012-02-28 14:49:23 +00002246 spin_unlock_irqrestore(&kbd_event_lock, flags);
2247}