1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/sched/signal.h>
12#include <linux/slab.h>
13#include <linux/sysrq.h>
14
15#include <linux/consolemap.h>
16#include <linux/kbd_kern.h>
17#include <linux/kbd_diacr.h>
18#include <linux/uaccess.h>
19
20#include "keyboard.h"
21
22
23
24
25#define K_HANDLERS\
26 k_self, k_fn, k_spec, k_ignore,\
27 k_dead, k_ignore, k_ignore, k_ignore,\
28 k_ignore, k_ignore, k_ignore, k_ignore,\
29 k_ignore, k_ignore, k_ignore, k_ignore
30
31typedef void (k_handler_fn)(struct kbd_data *, unsigned char);
32static k_handler_fn K_HANDLERS;
33static k_handler_fn *k_handler[16] = { K_HANDLERS };
34
35
36static const int kbd_max_vals[] = {
37 255, ARRAY_SIZE(func_table) - 1, NR_FN_HANDLER - 1, 0,
38 NR_DEAD - 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
39};
40static const int KBD_NR_TYPES = ARRAY_SIZE(kbd_max_vals);
41
42static unsigned char ret_diacr[NR_DEAD] = {
43 '`', '\'', '^', '~', '"', ','
44};
45
46
47
48
49struct kbd_data *
50kbd_alloc(void) {
51 struct kbd_data *kbd;
52 int i;
53
54 kbd = kzalloc(sizeof(struct kbd_data), GFP_KERNEL);
55 if (!kbd)
56 goto out;
57 kbd->key_maps = kzalloc(sizeof(ebc_key_maps), GFP_KERNEL);
58 if (!kbd->key_maps)
59 goto out_kbd;
60 for (i = 0; i < ARRAY_SIZE(ebc_key_maps); i++) {
61 if (ebc_key_maps[i]) {
62 kbd->key_maps[i] = kmemdup(ebc_key_maps[i],
63 sizeof(u_short) * NR_KEYS,
64 GFP_KERNEL);
65 if (!kbd->key_maps[i])
66 goto out_maps;
67 }
68 }
69 kbd->func_table = kzalloc(sizeof(ebc_func_table), GFP_KERNEL);
70 if (!kbd->func_table)
71 goto out_maps;
72 for (i = 0; i < ARRAY_SIZE(ebc_func_table); i++) {
73 if (ebc_func_table[i]) {
74 kbd->func_table[i] = kstrdup(ebc_func_table[i],
75 GFP_KERNEL);
76 if (!kbd->func_table[i])
77 goto out_func;
78 }
79 }
80 kbd->fn_handler =
81 kzalloc(sizeof(fn_handler_fn *) * NR_FN_HANDLER, GFP_KERNEL);
82 if (!kbd->fn_handler)
83 goto out_func;
84 kbd->accent_table = kmemdup(ebc_accent_table,
85 sizeof(struct kbdiacruc) * MAX_DIACR,
86 GFP_KERNEL);
87 if (!kbd->accent_table)
88 goto out_fn_handler;
89 kbd->accent_table_size = ebc_accent_table_size;
90 return kbd;
91
92out_fn_handler:
93 kfree(kbd->fn_handler);
94out_func:
95 for (i = 0; i < ARRAY_SIZE(ebc_func_table); i++)
96 kfree(kbd->func_table[i]);
97 kfree(kbd->func_table);
98out_maps:
99 for (i = 0; i < ARRAY_SIZE(ebc_key_maps); i++)
100 kfree(kbd->key_maps[i]);
101 kfree(kbd->key_maps);
102out_kbd:
103 kfree(kbd);
104out:
105 return NULL;
106}
107
108void
109kbd_free(struct kbd_data *kbd)
110{
111 int i;
112
113 kfree(kbd->accent_table);
114 kfree(kbd->fn_handler);
115 for (i = 0; i < ARRAY_SIZE(ebc_func_table); i++)
116 kfree(kbd->func_table[i]);
117 kfree(kbd->func_table);
118 for (i = 0; i < ARRAY_SIZE(ebc_key_maps); i++)
119 kfree(kbd->key_maps[i]);
120 kfree(kbd->key_maps);
121 kfree(kbd);
122}
123
124
125
126
127void
128kbd_ascebc(struct kbd_data *kbd, unsigned char *ascebc)
129{
130 unsigned short *keymap, keysym;
131 int i, j, k;
132
133 memset(ascebc, 0x40, 256);
134 for (i = 0; i < ARRAY_SIZE(ebc_key_maps); i++) {
135 keymap = kbd->key_maps[i];
136 if (!keymap)
137 continue;
138 for (j = 0; j < NR_KEYS; j++) {
139 k = ((i & 1) << 7) + j;
140 keysym = keymap[j];
141 if (KTYP(keysym) == (KT_LATIN | 0xf0) ||
142 KTYP(keysym) == (KT_LETTER | 0xf0))
143 ascebc[KVAL(keysym)] = k;
144 else if (KTYP(keysym) == (KT_DEAD | 0xf0))
145 ascebc[ret_diacr[KVAL(keysym)]] = k;
146 }
147 }
148}
149
150#if 0
151
152
153
154void
155kbd_ebcasc(struct kbd_data *kbd, unsigned char *ebcasc)
156{
157 unsigned short *keymap, keysym;
158 int i, j, k;
159
160 memset(ebcasc, ' ', 256);
161 for (i = 0; i < ARRAY_SIZE(ebc_key_maps); i++) {
162 keymap = kbd->key_maps[i];
163 if (!keymap)
164 continue;
165 for (j = 0; j < NR_KEYS; j++) {
166 keysym = keymap[j];
167 k = ((i & 1) << 7) + j;
168 if (KTYP(keysym) == (KT_LATIN | 0xf0) ||
169 KTYP(keysym) == (KT_LETTER | 0xf0))
170 ebcasc[k] = KVAL(keysym);
171 else if (KTYP(keysym) == (KT_DEAD | 0xf0))
172 ebcasc[k] = ret_diacr[KVAL(keysym)];
173 }
174 }
175}
176#endif
177
178
179
180
181
182
183
184
185static unsigned int
186handle_diacr(struct kbd_data *kbd, unsigned int ch)
187{
188 int i, d;
189
190 d = kbd->diacr;
191 kbd->diacr = 0;
192
193 for (i = 0; i < kbd->accent_table_size; i++) {
194 if (kbd->accent_table[i].diacr == d &&
195 kbd->accent_table[i].base == ch)
196 return kbd->accent_table[i].result;
197 }
198
199 if (ch == ' ' || ch == d)
200 return d;
201
202 kbd_put_queue(kbd->port, d);
203 return ch;
204}
205
206
207
208
209static void
210k_dead(struct kbd_data *kbd, unsigned char value)
211{
212 value = ret_diacr[value];
213 kbd->diacr = (kbd->diacr ? handle_diacr(kbd, value) : value);
214}
215
216
217
218
219static void
220k_self(struct kbd_data *kbd, unsigned char value)
221{
222 if (kbd->diacr)
223 value = handle_diacr(kbd, value);
224 kbd_put_queue(kbd->port, value);
225}
226
227
228
229
230static void
231k_ignore(struct kbd_data *kbd, unsigned char value)
232{
233}
234
235
236
237
238static void
239k_fn(struct kbd_data *kbd, unsigned char value)
240{
241 if (kbd->func_table[value])
242 kbd_puts_queue(kbd->port, kbd->func_table[value]);
243}
244
245static void
246k_spec(struct kbd_data *kbd, unsigned char value)
247{
248 if (value >= NR_FN_HANDLER)
249 return;
250 if (kbd->fn_handler[value])
251 kbd->fn_handler[value](kbd);
252}
253
254
255
256
257
258
259static void
260to_utf8(struct tty_port *port, ushort c)
261{
262 if (c < 0x80)
263
264 kbd_put_queue(port, c);
265 else if (c < 0x800) {
266
267 kbd_put_queue(port, 0xc0 | (c >> 6));
268 kbd_put_queue(port, 0x80 | (c & 0x3f));
269 } else {
270
271 kbd_put_queue(port, 0xe0 | (c >> 12));
272 kbd_put_queue(port, 0x80 | ((c >> 6) & 0x3f));
273 kbd_put_queue(port, 0x80 | (c & 0x3f));
274 }
275}
276
277
278
279
280void
281kbd_keycode(struct kbd_data *kbd, unsigned int keycode)
282{
283 unsigned short keysym;
284 unsigned char type, value;
285
286 if (!kbd)
287 return;
288
289 if (keycode >= 384)
290 keysym = kbd->key_maps[5][keycode - 384];
291 else if (keycode >= 256)
292 keysym = kbd->key_maps[4][keycode - 256];
293 else if (keycode >= 128)
294 keysym = kbd->key_maps[1][keycode - 128];
295 else
296 keysym = kbd->key_maps[0][keycode];
297
298 type = KTYP(keysym);
299 if (type >= 0xf0) {
300 type -= 0xf0;
301 if (type == KT_LETTER)
302 type = KT_LATIN;
303 value = KVAL(keysym);
304#ifdef CONFIG_MAGIC_SYSRQ
305 if (kbd->sysrq) {
306 if (kbd->sysrq == K(KT_LATIN, '-')) {
307 kbd->sysrq = 0;
308 handle_sysrq(value);
309 return;
310 }
311 if (value == '-') {
312 kbd->sysrq = K(KT_LATIN, '-');
313 return;
314 }
315
316 (*k_handler[KTYP(kbd->sysrq)])(kbd, KVAL(kbd->sysrq));
317 kbd->sysrq = 0;
318 } else if ((type == KT_LATIN && value == '^') ||
319 (type == KT_DEAD && ret_diacr[value] == '^')) {
320 kbd->sysrq = K(type, value);
321 return;
322 }
323#endif
324 (*k_handler[type])(kbd, value);
325 } else
326 to_utf8(kbd->port, keysym);
327}
328
329
330
331
332static int
333do_kdsk_ioctl(struct kbd_data *kbd, struct kbentry __user *user_kbe,
334 int cmd, int perm)
335{
336 struct kbentry tmp;
337 ushort *key_map, val, ov;
338
339 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
340 return -EFAULT;
341#if NR_KEYS < 256
342 if (tmp.kb_index >= NR_KEYS)
343 return -EINVAL;
344#endif
345#if MAX_NR_KEYMAPS < 256
346 if (tmp.kb_table >= MAX_NR_KEYMAPS)
347 return -EINVAL;
348#endif
349
350 switch (cmd) {
351 case KDGKBENT:
352 key_map = kbd->key_maps[tmp.kb_table];
353 if (key_map) {
354 val = U(key_map[tmp.kb_index]);
355 if (KTYP(val) >= KBD_NR_TYPES)
356 val = K_HOLE;
357 } else
358 val = (tmp.kb_index ? K_HOLE : K_NOSUCHMAP);
359 return put_user(val, &user_kbe->kb_value);
360 case KDSKBENT:
361 if (!perm)
362 return -EPERM;
363 if (!tmp.kb_index && tmp.kb_value == K_NOSUCHMAP) {
364
365 key_map = kbd->key_maps[tmp.kb_table];
366 if (key_map) {
367 kbd->key_maps[tmp.kb_table] = NULL;
368 kfree(key_map);
369 }
370 break;
371 }
372
373 if (KTYP(tmp.kb_value) >= KBD_NR_TYPES)
374 return -EINVAL;
375 if (KVAL(tmp.kb_value) > kbd_max_vals[KTYP(tmp.kb_value)])
376 return -EINVAL;
377
378 if (!(key_map = kbd->key_maps[tmp.kb_table])) {
379 int j;
380
381 key_map = kmalloc(sizeof(plain_map),
382 GFP_KERNEL);
383 if (!key_map)
384 return -ENOMEM;
385 kbd->key_maps[tmp.kb_table] = key_map;
386 for (j = 0; j < NR_KEYS; j++)
387 key_map[j] = U(K_HOLE);
388 }
389 ov = U(key_map[tmp.kb_index]);
390 if (tmp.kb_value == ov)
391 break;
392
393
394
395 if (((ov == K_SAK) || (tmp.kb_value == K_SAK)) &&
396 !capable(CAP_SYS_ADMIN))
397 return -EPERM;
398 key_map[tmp.kb_index] = U(tmp.kb_value);
399 break;
400 }
401 return 0;
402}
403
404static int
405do_kdgkb_ioctl(struct kbd_data *kbd, struct kbsentry __user *u_kbs,
406 int cmd, int perm)
407{
408 unsigned char kb_func;
409 char *p;
410 int len;
411
412
413 if (get_user(kb_func, &u_kbs->kb_func))
414 return -EFAULT;
415#if MAX_NR_FUNC < 256
416 if (kb_func >= MAX_NR_FUNC)
417 return -EINVAL;
418#endif
419
420 switch (cmd) {
421 case KDGKBSENT:
422 p = kbd->func_table[kb_func];
423 if (p) {
424 len = strlen(p);
425 if (len >= sizeof(u_kbs->kb_string))
426 len = sizeof(u_kbs->kb_string) - 1;
427 if (copy_to_user(u_kbs->kb_string, p, len))
428 return -EFAULT;
429 } else
430 len = 0;
431 if (put_user('\0', u_kbs->kb_string + len))
432 return -EFAULT;
433 break;
434 case KDSKBSENT:
435 if (!perm)
436 return -EPERM;
437 p = strndup_user(u_kbs->kb_string, sizeof(u_kbs->kb_string));
438 if (IS_ERR(p))
439 return PTR_ERR(p);
440 kfree(kbd->func_table[kb_func]);
441 kbd->func_table[kb_func] = p;
442 break;
443 }
444 return 0;
445}
446
447int kbd_ioctl(struct kbd_data *kbd, unsigned int cmd, unsigned long arg)
448{
449 struct tty_struct *tty;
450 void __user *argp;
451 unsigned int ct;
452 int perm;
453
454 argp = (void __user *)arg;
455
456
457
458
459
460 tty = tty_port_tty_get(kbd->port);
461
462 perm = current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG);
463 tty_kref_put(tty);
464 switch (cmd) {
465 case KDGKBTYPE:
466 return put_user(KB_101, (char __user *)argp);
467 case KDGKBENT:
468 case KDSKBENT:
469 return do_kdsk_ioctl(kbd, argp, cmd, perm);
470 case KDGKBSENT:
471 case KDSKBSENT:
472 return do_kdgkb_ioctl(kbd, argp, cmd, perm);
473 case KDGKBDIACR:
474 {
475 struct kbdiacrs __user *a = argp;
476 struct kbdiacr diacr;
477 int i;
478
479 if (put_user(kbd->accent_table_size, &a->kb_cnt))
480 return -EFAULT;
481 for (i = 0; i < kbd->accent_table_size; i++) {
482 diacr.diacr = kbd->accent_table[i].diacr;
483 diacr.base = kbd->accent_table[i].base;
484 diacr.result = kbd->accent_table[i].result;
485 if (copy_to_user(a->kbdiacr + i, &diacr, sizeof(struct kbdiacr)))
486 return -EFAULT;
487 }
488 return 0;
489 }
490 case KDGKBDIACRUC:
491 {
492 struct kbdiacrsuc __user *a = argp;
493
494 ct = kbd->accent_table_size;
495 if (put_user(ct, &a->kb_cnt))
496 return -EFAULT;
497 if (copy_to_user(a->kbdiacruc, kbd->accent_table,
498 ct * sizeof(struct kbdiacruc)))
499 return -EFAULT;
500 return 0;
501 }
502 case KDSKBDIACR:
503 {
504 struct kbdiacrs __user *a = argp;
505 struct kbdiacr diacr;
506 int i;
507
508 if (!perm)
509 return -EPERM;
510 if (get_user(ct, &a->kb_cnt))
511 return -EFAULT;
512 if (ct >= MAX_DIACR)
513 return -EINVAL;
514 kbd->accent_table_size = ct;
515 for (i = 0; i < ct; i++) {
516 if (copy_from_user(&diacr, a->kbdiacr + i, sizeof(struct kbdiacr)))
517 return -EFAULT;
518 kbd->accent_table[i].diacr = diacr.diacr;
519 kbd->accent_table[i].base = diacr.base;
520 kbd->accent_table[i].result = diacr.result;
521 }
522 return 0;
523 }
524 case KDSKBDIACRUC:
525 {
526 struct kbdiacrsuc __user *a = argp;
527
528 if (!perm)
529 return -EPERM;
530 if (get_user(ct, &a->kb_cnt))
531 return -EFAULT;
532 if (ct >= MAX_DIACR)
533 return -EINVAL;
534 kbd->accent_table_size = ct;
535 if (copy_from_user(kbd->accent_table, a->kbdiacruc,
536 ct * sizeof(struct kbdiacruc)))
537 return -EFAULT;
538 return 0;
539 }
540 default:
541 return -ENOIOCTLCMD;
542 }
543}
544
545EXPORT_SYMBOL(kbd_ioctl);
546EXPORT_SYMBOL(kbd_ascebc);
547EXPORT_SYMBOL(kbd_free);
548EXPORT_SYMBOL(kbd_alloc);
549EXPORT_SYMBOL(kbd_keycode);
550
