2 * drivers/s390/char/keyboard.c
3 * ebcdic keycode functions for s390 console drivers
6 * Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
10 #include <linux/module.h>
11 #include <linux/sched.h>
12 #include <linux/slab.h>
13 #include <linux/sysrq.h>
15 #include <linux/consolemap.h>
16 #include <linux/kbd_kern.h>
17 #include <linux/kbd_diacr.h>
18 #include <asm/uaccess.h>
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
31 typedef void (k_handler_fn
)(struct kbd_data
*, unsigned char);
32 static k_handler_fn K_HANDLERS
;
33 static k_handler_fn
*k_handler
[16] = { K_HANDLERS
};
35 /* maximum values each key_handler can handle */
36 static 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
40 static const int KBD_NR_TYPES
= ARRAY_SIZE(kbd_max_vals
);
42 static unsigned char ret_diacr
[NR_DEAD
] = {
43 '`', '\'', '^', '~', '"', ','
47 * Alloc/free of kbd_data structures.
54 kbd
= kzalloc(sizeof(struct kbd_data
), GFP_KERNEL
);
57 kbd
->key_maps
= kzalloc(sizeof(key_maps
), GFP_KERNEL
);
60 for (i
= 0; i
< ARRAY_SIZE(key_maps
); i
++) {
62 kbd
->key_maps
[i
] = kmemdup(key_maps
[i
],
63 sizeof(u_short
) * NR_KEYS
,
65 if (!kbd
->key_maps
[i
])
69 kbd
->func_table
= kzalloc(sizeof(func_table
), GFP_KERNEL
);
72 for (i
= 0; i
< ARRAY_SIZE(func_table
); i
++) {
74 kbd
->func_table
[i
] = kstrdup(func_table
[i
],
76 if (!kbd
->func_table
[i
])
81 kzalloc(sizeof(fn_handler_fn
*) * NR_FN_HANDLER
, GFP_KERNEL
);
84 kbd
->accent_table
= kmemdup(accent_table
,
85 sizeof(struct kbdiacruc
) * MAX_DIACR
,
87 if (!kbd
->accent_table
)
89 kbd
->accent_table_size
= accent_table_size
;
93 kfree(kbd
->fn_handler
);
95 for (i
= 0; i
< ARRAY_SIZE(func_table
); i
++)
96 kfree(kbd
->func_table
[i
]);
97 kfree(kbd
->func_table
);
99 for (i
= 0; i
< ARRAY_SIZE(key_maps
); i
++)
100 kfree(kbd
->key_maps
[i
]);
101 kfree(kbd
->key_maps
);
109 kbd_free(struct kbd_data
*kbd
)
113 kfree(kbd
->accent_table
);
114 kfree(kbd
->fn_handler
);
115 for (i
= 0; i
< ARRAY_SIZE(func_table
); i
++)
116 kfree(kbd
->func_table
[i
]);
117 kfree(kbd
->func_table
);
118 for (i
= 0; i
< ARRAY_SIZE(key_maps
); i
++)
119 kfree(kbd
->key_maps
[i
]);
120 kfree(kbd
->key_maps
);
125 * Generate ascii -> ebcdic translation table from kbd_data.
128 kbd_ascebc(struct kbd_data
*kbd
, unsigned char *ascebc
)
130 unsigned short *keymap
, keysym
;
133 memset(ascebc
, 0x40, 256);
134 for (i
= 0; i
< ARRAY_SIZE(key_maps
); i
++) {
135 keymap
= kbd
->key_maps
[i
];
138 for (j
= 0; j
< NR_KEYS
; j
++) {
139 k
= ((i
& 1) << 7) + 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
;
152 * We have a combining character DIACR here, followed by the character CH.
153 * If the combination occurs in the table, return the corresponding value.
154 * Otherwise, if CH is a space or equals DIACR, return DIACR.
155 * Otherwise, conclude that DIACR was not combining after all,
156 * queue it and return CH.
159 handle_diacr(struct kbd_data
*kbd
, unsigned int ch
)
166 for (i
= 0; i
< kbd
->accent_table_size
; i
++) {
167 if (kbd
->accent_table
[i
].diacr
== d
&&
168 kbd
->accent_table
[i
].base
== ch
)
169 return kbd
->accent_table
[i
].result
;
172 if (ch
== ' ' || ch
== d
)
175 kbd_put_queue(kbd
->tty
, d
);
183 k_dead(struct kbd_data
*kbd
, unsigned char value
)
185 value
= ret_diacr
[value
];
186 kbd
->diacr
= (kbd
->diacr
? handle_diacr(kbd
, value
) : value
);
190 * Normal character handler.
193 k_self(struct kbd_data
*kbd
, unsigned char value
)
196 value
= handle_diacr(kbd
, value
);
197 kbd_put_queue(kbd
->tty
, value
);
201 * Special key handlers
204 k_ignore(struct kbd_data
*kbd
, unsigned char value
)
209 * Function key handler.
212 k_fn(struct kbd_data
*kbd
, unsigned char value
)
214 if (kbd
->func_table
[value
])
215 kbd_puts_queue(kbd
->tty
, kbd
->func_table
[value
]);
219 k_spec(struct kbd_data
*kbd
, unsigned char value
)
221 if (value
>= NR_FN_HANDLER
)
223 if (kbd
->fn_handler
[value
])
224 kbd
->fn_handler
[value
](kbd
);
228 * Put utf8 character to tty flip buffer.
229 * UTF-8 is defined for words of up to 31 bits,
230 * but we need only 16 bits here
233 to_utf8(struct tty_struct
*tty
, ushort c
)
237 kbd_put_queue(tty
, c
);
238 else if (c
< 0x800) {
239 /* 110***** 10****** */
240 kbd_put_queue(tty
, 0xc0 | (c
>> 6));
241 kbd_put_queue(tty
, 0x80 | (c
& 0x3f));
243 /* 1110**** 10****** 10****** */
244 kbd_put_queue(tty
, 0xe0 | (c
>> 12));
245 kbd_put_queue(tty
, 0x80 | ((c
>> 6) & 0x3f));
246 kbd_put_queue(tty
, 0x80 | (c
& 0x3f));
254 kbd_keycode(struct kbd_data
*kbd
, unsigned int keycode
)
256 unsigned short keysym
;
257 unsigned char type
, value
;
259 if (!kbd
|| !kbd
->tty
)
263 keysym
= kbd
->key_maps
[5][keycode
- 384];
264 else if (keycode
>= 256)
265 keysym
= kbd
->key_maps
[4][keycode
- 256];
266 else if (keycode
>= 128)
267 keysym
= kbd
->key_maps
[1][keycode
- 128];
269 keysym
= kbd
->key_maps
[0][keycode
];
274 if (type
== KT_LETTER
)
276 value
= KVAL(keysym
);
277 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
279 if (kbd
->sysrq
== K(KT_LATIN
, '-')) {
285 kbd
->sysrq
= K(KT_LATIN
, '-');
288 /* Incomplete sysrq sequence. */
289 (*k_handler
[KTYP(kbd
->sysrq
)])(kbd
, KVAL(kbd
->sysrq
));
291 } else if ((type
== KT_LATIN
&& value
== '^') ||
292 (type
== KT_DEAD
&& ret_diacr
[value
] == '^')) {
293 kbd
->sysrq
= K(type
, value
);
297 (*k_handler
[type
])(kbd
, value
);
299 to_utf8(kbd
->tty
, keysym
);
306 do_kdsk_ioctl(struct kbd_data
*kbd
, struct kbentry __user
*user_kbe
,
310 ushort
*key_map
, val
, ov
;
312 if (copy_from_user(&tmp
, user_kbe
, sizeof(struct kbentry
)))
315 if (tmp
.kb_index
>= NR_KEYS
)
318 #if MAX_NR_KEYMAPS < 256
319 if (tmp
.kb_table
>= MAX_NR_KEYMAPS
)
325 key_map
= kbd
->key_maps
[tmp
.kb_table
];
327 val
= U(key_map
[tmp
.kb_index
]);
328 if (KTYP(val
) >= KBD_NR_TYPES
)
331 val
= (tmp
.kb_index
? K_HOLE
: K_NOSUCHMAP
);
332 return put_user(val
, &user_kbe
->kb_value
);
336 if (!tmp
.kb_index
&& tmp
.kb_value
== K_NOSUCHMAP
) {
337 /* disallocate map */
338 key_map
= kbd
->key_maps
[tmp
.kb_table
];
340 kbd
->key_maps
[tmp
.kb_table
] = NULL
;
346 if (KTYP(tmp
.kb_value
) >= KBD_NR_TYPES
)
348 if (KVAL(tmp
.kb_value
) > kbd_max_vals
[KTYP(tmp
.kb_value
)])
351 if (!(key_map
= kbd
->key_maps
[tmp
.kb_table
])) {
354 key_map
= kmalloc(sizeof(plain_map
),
358 kbd
->key_maps
[tmp
.kb_table
] = key_map
;
359 for (j
= 0; j
< NR_KEYS
; j
++)
360 key_map
[j
] = U(K_HOLE
);
362 ov
= U(key_map
[tmp
.kb_index
]);
363 if (tmp
.kb_value
== ov
)
364 break; /* nothing to do */
368 if (((ov
== K_SAK
) || (tmp
.kb_value
== K_SAK
)) &&
369 !capable(CAP_SYS_ADMIN
))
371 key_map
[tmp
.kb_index
] = U(tmp
.kb_value
);
378 do_kdgkb_ioctl(struct kbd_data
*kbd
, struct kbsentry __user
*u_kbs
,
381 unsigned char kb_func
;
385 /* Get u_kbs->kb_func. */
386 if (get_user(kb_func
, &u_kbs
->kb_func
))
388 #if MAX_NR_FUNC < 256
389 if (kb_func
>= MAX_NR_FUNC
)
395 p
= kbd
->func_table
[kb_func
];
398 if (len
>= sizeof(u_kbs
->kb_string
))
399 len
= sizeof(u_kbs
->kb_string
) - 1;
400 if (copy_to_user(u_kbs
->kb_string
, p
, len
))
404 if (put_user('\0', u_kbs
->kb_string
+ len
))
410 len
= strnlen_user(u_kbs
->kb_string
,
411 sizeof(u_kbs
->kb_string
) - 1);
414 if (len
> sizeof(u_kbs
->kb_string
) - 1)
416 p
= kmalloc(len
+ 1, GFP_KERNEL
);
419 if (copy_from_user(p
, u_kbs
->kb_string
, len
)) {
424 kfree(kbd
->func_table
[kb_func
]);
425 kbd
->func_table
[kb_func
] = p
;
432 kbd_ioctl(struct kbd_data
*kbd
, struct file
*file
,
433 unsigned int cmd
, unsigned long arg
)
438 argp
= (void __user
*)arg
;
441 * To have permissions to do most of the vt ioctls, we either have
442 * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
444 perm
= current
->signal
->tty
== kbd
->tty
|| capable(CAP_SYS_TTY_CONFIG
);
447 return put_user(KB_101
, (char __user
*)argp
);
450 return do_kdsk_ioctl(kbd
, argp
, cmd
, perm
);
453 return do_kdgkb_ioctl(kbd
, argp
, cmd
, perm
);
456 struct kbdiacrs __user
*a
= argp
;
457 struct kbdiacr diacr
;
460 if (put_user(kbd
->accent_table_size
, &a
->kb_cnt
))
462 for (i
= 0; i
< kbd
->accent_table_size
; i
++) {
463 diacr
.diacr
= kbd
->accent_table
[i
].diacr
;
464 diacr
.base
= kbd
->accent_table
[i
].base
;
465 diacr
.result
= kbd
->accent_table
[i
].result
;
466 if (copy_to_user(a
->kbdiacr
+ i
, &diacr
, sizeof(struct kbdiacr
)))
473 struct kbdiacrsuc __user
*a
= argp
;
475 ct
= kbd
->accent_table_size
;
476 if (put_user(ct
, &a
->kb_cnt
))
478 if (copy_to_user(a
->kbdiacruc
, kbd
->accent_table
,
479 ct
* sizeof(struct kbdiacruc
)))
485 struct kbdiacrs __user
*a
= argp
;
486 struct kbdiacr diacr
;
491 if (get_user(ct
, &a
->kb_cnt
))
495 kbd
->accent_table_size
= ct
;
496 for (i
= 0; i
< ct
; i
++) {
497 if (copy_from_user(&diacr
, a
->kbdiacr
+ i
, sizeof(struct kbdiacr
)))
499 kbd
->accent_table
[i
].diacr
= diacr
.diacr
;
500 kbd
->accent_table
[i
].base
= diacr
.base
;
501 kbd
->accent_table
[i
].result
= diacr
.result
;
507 struct kbdiacrsuc __user
*a
= argp
;
511 if (get_user(ct
, &a
->kb_cnt
))
515 kbd
->accent_table_size
= ct
;
516 if (copy_from_user(kbd
->accent_table
, a
->kbdiacruc
,
517 ct
* sizeof(struct kbdiacruc
)))
526 EXPORT_SYMBOL(kbd_ioctl
);
527 EXPORT_SYMBOL(kbd_ascebc
);
528 EXPORT_SYMBOL(kbd_free
);
529 EXPORT_SYMBOL(kbd_alloc
);
530 EXPORT_SYMBOL(kbd_keycode
);