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