?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qapi: rename input buttons
[qemu.git] / hw / input / virtio-input-hid.c
blob9ca5395739a3392bfc86dd86da953c3356878423
1 /*
2 * This work is licensed under the terms of the GNU GPL, version 2 or
3 * (at your option) any later version. See the COPYING file in the
4 * top-level directory.
5 */
6
7 #include "qemu/osdep.h"
8 #include "qemu/iov.h"
9
10 #include "hw/qdev.h"
11 #include "hw/virtio/virtio.h"
12 #include "hw/virtio/virtio-input.h"
13
14 #undef CONFIG_CURSES
15 #include "ui/console.h"
16
17 #include "standard-headers/linux/input.h"
18
19 #define VIRTIO_ID_NAME_KEYBOARD "QEMU Virtio Keyboard"
20 #define VIRTIO_ID_NAME_MOUSE "QEMU Virtio Mouse"
21 #define VIRTIO_ID_NAME_TABLET "QEMU Virtio Tablet"
22
23 /* ----------------------------------------------------------------- */
24
25 static const unsigned int keymap_qcode[Q_KEY_CODE__MAX] = {
26 [Q_KEY_CODE_ESC] = KEY_ESC,
27 [Q_KEY_CODE_1] = KEY_1,
28 [Q_KEY_CODE_2] = KEY_2,
29 [Q_KEY_CODE_3] = KEY_3,
30 [Q_KEY_CODE_4] = KEY_4,
31 [Q_KEY_CODE_5] = KEY_5,
32 [Q_KEY_CODE_6] = KEY_6,
33 [Q_KEY_CODE_7] = KEY_7,
34 [Q_KEY_CODE_8] = KEY_8,
35 [Q_KEY_CODE_9] = KEY_9,
36 [Q_KEY_CODE_0] = KEY_0,
37 [Q_KEY_CODE_MINUS] = KEY_MINUS,
38 [Q_KEY_CODE_EQUAL] = KEY_EQUAL,
39 [Q_KEY_CODE_BACKSPACE] = KEY_BACKSPACE,
40
41 [Q_KEY_CODE_TAB] = KEY_TAB,
42 [Q_KEY_CODE_Q] = KEY_Q,
43 [Q_KEY_CODE_W] = KEY_W,
44 [Q_KEY_CODE_E] = KEY_E,
45 [Q_KEY_CODE_R] = KEY_R,
46 [Q_KEY_CODE_T] = KEY_T,
47 [Q_KEY_CODE_Y] = KEY_Y,
48 [Q_KEY_CODE_U] = KEY_U,
49 [Q_KEY_CODE_I] = KEY_I,
50 [Q_KEY_CODE_O] = KEY_O,
51 [Q_KEY_CODE_P] = KEY_P,
52 [Q_KEY_CODE_BRACKET_LEFT] = KEY_LEFTBRACE,
53 [Q_KEY_CODE_BRACKET_RIGHT] = KEY_RIGHTBRACE,
54 [Q_KEY_CODE_RET] = KEY_ENTER,
55
56 [Q_KEY_CODE_CTRL] = KEY_LEFTCTRL,
57 [Q_KEY_CODE_A] = KEY_A,
58 [Q_KEY_CODE_S] = KEY_S,
59 [Q_KEY_CODE_D] = KEY_D,
60 [Q_KEY_CODE_F] = KEY_F,
61 [Q_KEY_CODE_G] = KEY_G,
62 [Q_KEY_CODE_H] = KEY_H,
63 [Q_KEY_CODE_J] = KEY_J,
64 [Q_KEY_CODE_K] = KEY_K,
65 [Q_KEY_CODE_L] = KEY_L,
66 [Q_KEY_CODE_SEMICOLON] = KEY_SEMICOLON,
67 [Q_KEY_CODE_APOSTROPHE] = KEY_APOSTROPHE,
68 [Q_KEY_CODE_GRAVE_ACCENT] = KEY_GRAVE,
69
70 [Q_KEY_CODE_SHIFT] = KEY_LEFTSHIFT,
71 [Q_KEY_CODE_BACKSLASH] = KEY_BACKSLASH,
72 [Q_KEY_CODE_LESS] = KEY_102ND,
73 [Q_KEY_CODE_Z] = KEY_Z,
74 [Q_KEY_CODE_X] = KEY_X,
75 [Q_KEY_CODE_C] = KEY_C,
76 [Q_KEY_CODE_V] = KEY_V,
77 [Q_KEY_CODE_B] = KEY_B,
78 [Q_KEY_CODE_N] = KEY_N,
79 [Q_KEY_CODE_M] = KEY_M,
80 [Q_KEY_CODE_COMMA] = KEY_COMMA,
81 [Q_KEY_CODE_DOT] = KEY_DOT,
82 [Q_KEY_CODE_SLASH] = KEY_SLASH,
83 [Q_KEY_CODE_SHIFT_R] = KEY_RIGHTSHIFT,
84
85 [Q_KEY_CODE_ALT] = KEY_LEFTALT,
86 [Q_KEY_CODE_SPC] = KEY_SPACE,
87 [Q_KEY_CODE_CAPS_LOCK] = KEY_CAPSLOCK,
88
89 [Q_KEY_CODE_F1] = KEY_F1,
90 [Q_KEY_CODE_F2] = KEY_F2,
91 [Q_KEY_CODE_F3] = KEY_F3,
92 [Q_KEY_CODE_F4] = KEY_F4,
93 [Q_KEY_CODE_F5] = KEY_F5,
94 [Q_KEY_CODE_F6] = KEY_F6,
95 [Q_KEY_CODE_F7] = KEY_F7,
96 [Q_KEY_CODE_F8] = KEY_F8,
97 [Q_KEY_CODE_F9] = KEY_F9,
98 [Q_KEY_CODE_F10] = KEY_F10,
99 [Q_KEY_CODE_NUM_LOCK] = KEY_NUMLOCK,
100 [Q_KEY_CODE_SCROLL_LOCK] = KEY_SCROLLLOCK,
101
102 [Q_KEY_CODE_KP_0] = KEY_KP0,
103 [Q_KEY_CODE_KP_1] = KEY_KP1,
104 [Q_KEY_CODE_KP_2] = KEY_KP2,
105 [Q_KEY_CODE_KP_3] = KEY_KP3,
106 [Q_KEY_CODE_KP_4] = KEY_KP4,
107 [Q_KEY_CODE_KP_5] = KEY_KP5,
108 [Q_KEY_CODE_KP_6] = KEY_KP6,
109 [Q_KEY_CODE_KP_7] = KEY_KP7,
110 [Q_KEY_CODE_KP_8] = KEY_KP8,
111 [Q_KEY_CODE_KP_9] = KEY_KP9,
112 [Q_KEY_CODE_KP_SUBTRACT] = KEY_KPMINUS,
113 [Q_KEY_CODE_KP_ADD] = KEY_KPPLUS,
114 [Q_KEY_CODE_KP_DECIMAL] = KEY_KPDOT,
115 [Q_KEY_CODE_KP_ENTER] = KEY_KPENTER,
116 [Q_KEY_CODE_KP_DIVIDE] = KEY_KPSLASH,
117 [Q_KEY_CODE_KP_MULTIPLY] = KEY_KPASTERISK,
118
119 [Q_KEY_CODE_F11] = KEY_F11,
120 [Q_KEY_CODE_F12] = KEY_F12,
121
122 [Q_KEY_CODE_CTRL_R] = KEY_RIGHTCTRL,
123 [Q_KEY_CODE_SYSRQ] = KEY_SYSRQ,
124 [Q_KEY_CODE_ALT_R] = KEY_RIGHTALT,
125
126 [Q_KEY_CODE_HOME] = KEY_HOME,
127 [Q_KEY_CODE_UP] = KEY_UP,
128 [Q_KEY_CODE_PGUP] = KEY_PAGEUP,
129 [Q_KEY_CODE_LEFT] = KEY_LEFT,
130 [Q_KEY_CODE_RIGHT] = KEY_RIGHT,
131 [Q_KEY_CODE_END] = KEY_END,
132 [Q_KEY_CODE_DOWN] = KEY_DOWN,
133 [Q_KEY_CODE_PGDN] = KEY_PAGEDOWN,
134 [Q_KEY_CODE_INSERT] = KEY_INSERT,
135 [Q_KEY_CODE_DELETE] = KEY_DELETE,
136
137 [Q_KEY_CODE_META_L] = KEY_LEFTMETA,
138 [Q_KEY_CODE_META_R] = KEY_RIGHTMETA,
139 [Q_KEY_CODE_MENU] = KEY_MENU,
140 };
141
142 static const unsigned int keymap_button[INPUT_BUTTON__MAX] = {
143 [INPUT_BUTTON_LEFT] = BTN_LEFT,
144 [INPUT_BUTTON_RIGHT] = BTN_RIGHT,
145 [INPUT_BUTTON_MIDDLE] = BTN_MIDDLE,
146 [INPUT_BUTTON_WHEEL_UP] = BTN_GEAR_UP,
147 [INPUT_BUTTON_WHEEL_DOWN] = BTN_GEAR_DOWN,
148 };
149
150 static const unsigned int axismap_rel[INPUT_AXIS__MAX] = {
151 [INPUT_AXIS_X] = REL_X,
152 [INPUT_AXIS_Y] = REL_Y,
153 };
154
155 static const unsigned int axismap_abs[INPUT_AXIS__MAX] = {
156 [INPUT_AXIS_X] = ABS_X,
157 [INPUT_AXIS_Y] = ABS_Y,
158 };
159
160 /* ----------------------------------------------------------------- */
161
162 static void virtio_input_key_config(VirtIOInput *vinput,
163 const unsigned int *keymap,
164 size_t mapsize)
165 {
166 virtio_input_config keys;
167 int i, bit, byte, bmax = 0;
168
169 memset(&keys, 0, sizeof(keys));
170 for (i = 0; i < mapsize; i++) {
171 bit = keymap[i];
172 if (!bit) {
173 continue;
174 }
175 byte = bit / 8;
176 bit = bit % 8;
177 keys.u.bitmap[byte] |= (1 << bit);
178 if (bmax < byte+1) {
179 bmax = byte+1;
180 }
181 }
182 keys.select = VIRTIO_INPUT_CFG_EV_BITS;
183 keys.subsel = EV_KEY;
184 keys.size = bmax;
185 virtio_input_add_config(vinput, &keys);
186 }
187
188 static void virtio_input_handle_event(DeviceState *dev, QemuConsole *src,
189 InputEvent *evt)
190 {
191 VirtIOInput *vinput = VIRTIO_INPUT(dev);
192 virtio_input_event event;
193 int qcode;
194
195 switch (evt->type) {
196 case INPUT_EVENT_KIND_KEY:
197 qcode = qemu_input_key_value_to_qcode(evt->u.key->key);
198 if (qcode && keymap_qcode[qcode]) {
199 event.type = cpu_to_le16(EV_KEY);
200 event.code = cpu_to_le16(keymap_qcode[qcode]);
201 event.value = cpu_to_le32(evt->u.key->down ? 1 : 0);
202 virtio_input_send(vinput, &event);
203 } else {
204 if (evt->u.key->down) {
205 fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__,
206 qcode, QKeyCode_lookup[qcode]);
207 }
208 }
209 break;
210 case INPUT_EVENT_KIND_BTN:
211 if (keymap_button[evt->u.btn->button]) {
212 event.type = cpu_to_le16(EV_KEY);
213 event.code = cpu_to_le16(keymap_button[evt->u.btn->button]);
214 event.value = cpu_to_le32(evt->u.btn->down ? 1 : 0);
215 virtio_input_send(vinput, &event);
216 } else {
217 if (evt->u.btn->down) {
218 fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__,
219 evt->u.btn->button,
220 InputButton_lookup[evt->u.btn->button]);
221 }
222 }
223 break;
224 case INPUT_EVENT_KIND_REL:
225 event.type = cpu_to_le16(EV_REL);
226 event.code = cpu_to_le16(axismap_rel[evt->u.rel->axis]);
227 event.value = cpu_to_le32(evt->u.rel->value);
228 virtio_input_send(vinput, &event);
229 break;
230 case INPUT_EVENT_KIND_ABS:
231 event.type = cpu_to_le16(EV_ABS);
232 event.code = cpu_to_le16(axismap_abs[evt->u.abs->axis]);
233 event.value = cpu_to_le32(evt->u.abs->value);
234 virtio_input_send(vinput, &event);
235 break;
236 default:
237 /* keep gcc happy */
238 break;
239 }
240 }
241
242 static void virtio_input_handle_sync(DeviceState *dev)
243 {
244 VirtIOInput *vinput = VIRTIO_INPUT(dev);
245 virtio_input_event event = {
246 .type = cpu_to_le16(EV_SYN),
247 .code = cpu_to_le16(SYN_REPORT),
248 .value = 0,
249 };
250
251 virtio_input_send(vinput, &event);
252 }
253
254 static void virtio_input_hid_realize(DeviceState *dev, Error **errp)
255 {
256 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
257
258 vhid->hs = qemu_input_handler_register(dev, vhid->handler);
259 if (vhid->display && vhid->hs) {
260 qemu_input_handler_bind(vhid->hs, vhid->display, vhid->head, NULL);
261 }
262 }
263
264 static void virtio_input_hid_unrealize(DeviceState *dev, Error **errp)
265 {
266 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
267 qemu_input_handler_unregister(vhid->hs);
268 }
269
270 static void virtio_input_hid_change_active(VirtIOInput *vinput)
271 {
272 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
273
274 if (vinput->active) {
275 qemu_input_handler_activate(vhid->hs);
276 } else {
277 qemu_input_handler_deactivate(vhid->hs);
278 }
279 }
280
281 static void virtio_input_hid_handle_status(VirtIOInput *vinput,
282 virtio_input_event *event)
283 {
284 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
285 int ledbit = 0;
286
287 switch (le16_to_cpu(event->type)) {
288 case EV_LED:
289 if (event->code == LED_NUML) {
290 ledbit = QEMU_NUM_LOCK_LED;
291 } else if (event->code == LED_CAPSL) {
292 ledbit = QEMU_CAPS_LOCK_LED;
293 } else if (event->code == LED_SCROLLL) {
294 ledbit = QEMU_SCROLL_LOCK_LED;
295 }
296 if (event->value) {
297 vhid->ledstate |= ledbit;
298 } else {
299 vhid->ledstate &= ~ledbit;
300 }
301 kbd_put_ledstate(vhid->ledstate);
302 break;
303 default:
304 fprintf(stderr, "%s: unknown type %d\n", __func__,
305 le16_to_cpu(event->type));
306 break;
307 }
308 }
309
310 static Property virtio_input_hid_properties[] = {
311 DEFINE_PROP_STRING("display", VirtIOInputHID, display),
312 DEFINE_PROP_UINT32("head", VirtIOInputHID, head, 0),
313 DEFINE_PROP_END_OF_LIST(),
314 };
315
316 static void virtio_input_hid_class_init(ObjectClass *klass, void *data)
317 {
318 DeviceClass *dc = DEVICE_CLASS(klass);
319 VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass);
320
321 dc->props = virtio_input_hid_properties;
322 vic->realize = virtio_input_hid_realize;
323 vic->unrealize = virtio_input_hid_unrealize;
324 vic->change_active = virtio_input_hid_change_active;
325 vic->handle_status = virtio_input_hid_handle_status;
326 }
327
328 static const TypeInfo virtio_input_hid_info = {
329 .name = TYPE_VIRTIO_INPUT_HID,
330 .parent = TYPE_VIRTIO_INPUT,
331 .instance_size = sizeof(VirtIOInputHID),
332 .class_init = virtio_input_hid_class_init,
333 .abstract = true,
334 };
335
336 /* ----------------------------------------------------------------- */
337
338 static QemuInputHandler virtio_keyboard_handler = {
339 .name = VIRTIO_ID_NAME_KEYBOARD,
340 .mask = INPUT_EVENT_MASK_KEY,
341 .event = virtio_input_handle_event,
342 .sync = virtio_input_handle_sync,
343 };
344
345 static struct virtio_input_config virtio_keyboard_config[] = {
346 {
347 .select = VIRTIO_INPUT_CFG_ID_NAME,
348 .size = sizeof(VIRTIO_ID_NAME_KEYBOARD),
349 .u.string = VIRTIO_ID_NAME_KEYBOARD,
350 },{
351 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
352 .size = sizeof(struct virtio_input_devids),
353 .u.ids = {
354 .bustype = const_le16(BUS_VIRTUAL),
355 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
356 .product = const_le16(0x0001),
357 .version = const_le16(0x0001),
358 },
359 },{
360 .select = VIRTIO_INPUT_CFG_EV_BITS,
361 .subsel = EV_REP,
362 .size = 1,
363 },{
364 .select = VIRTIO_INPUT_CFG_EV_BITS,
365 .subsel = EV_LED,
366 .size = 1,
367 .u.bitmap = {
368 (1 << LED_NUML) | (1 << LED_CAPSL) | (1 << LED_SCROLLL),
369 },
370 },
371 { /* end of list */ },
372 };
373
374 static void virtio_keyboard_init(Object *obj)
375 {
376 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
377 VirtIOInput *vinput = VIRTIO_INPUT(obj);
378
379 vhid->handler = &virtio_keyboard_handler;
380 virtio_input_init_config(vinput, virtio_keyboard_config);
381 virtio_input_key_config(vinput, keymap_qcode,
382 ARRAY_SIZE(keymap_qcode));
383 }
384
385 static const TypeInfo virtio_keyboard_info = {
386 .name = TYPE_VIRTIO_KEYBOARD,
387 .parent = TYPE_VIRTIO_INPUT_HID,
388 .instance_size = sizeof(VirtIOInputHID),
389 .instance_init = virtio_keyboard_init,
390 };
391
392 /* ----------------------------------------------------------------- */
393
394 static QemuInputHandler virtio_mouse_handler = {
395 .name = VIRTIO_ID_NAME_MOUSE,
396 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
397 .event = virtio_input_handle_event,
398 .sync = virtio_input_handle_sync,
399 };
400
401 static struct virtio_input_config virtio_mouse_config[] = {
402 {
403 .select = VIRTIO_INPUT_CFG_ID_NAME,
404 .size = sizeof(VIRTIO_ID_NAME_MOUSE),
405 .u.string = VIRTIO_ID_NAME_MOUSE,
406 },{
407 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
408 .size = sizeof(struct virtio_input_devids),
409 .u.ids = {
410 .bustype = const_le16(BUS_VIRTUAL),
411 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
412 .product = const_le16(0x0002),
413 .version = const_le16(0x0001),
414 },
415 },{
416 .select = VIRTIO_INPUT_CFG_EV_BITS,
417 .subsel = EV_REL,
418 .size = 1,
419 .u.bitmap = {
420 (1 << REL_X) | (1 << REL_Y),
421 },
422 },
423 { /* end of list */ },
424 };
425
426 static void virtio_mouse_init(Object *obj)
427 {
428 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
429 VirtIOInput *vinput = VIRTIO_INPUT(obj);
430
431 vhid->handler = &virtio_mouse_handler;
432 virtio_input_init_config(vinput, virtio_mouse_config);
433 virtio_input_key_config(vinput, keymap_button,
434 ARRAY_SIZE(keymap_button));
435 }
436
437 static const TypeInfo virtio_mouse_info = {
438 .name = TYPE_VIRTIO_MOUSE,
439 .parent = TYPE_VIRTIO_INPUT_HID,
440 .instance_size = sizeof(VirtIOInputHID),
441 .instance_init = virtio_mouse_init,
442 };
443
444 /* ----------------------------------------------------------------- */
445
446 static QemuInputHandler virtio_tablet_handler = {
447 .name = VIRTIO_ID_NAME_TABLET,
448 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
449 .event = virtio_input_handle_event,
450 .sync = virtio_input_handle_sync,
451 };
452
453 static struct virtio_input_config virtio_tablet_config[] = {
454 {
455 .select = VIRTIO_INPUT_CFG_ID_NAME,
456 .size = sizeof(VIRTIO_ID_NAME_TABLET),
457 .u.string = VIRTIO_ID_NAME_TABLET,
458 },{
459 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
460 .size = sizeof(struct virtio_input_devids),
461 .u.ids = {
462 .bustype = const_le16(BUS_VIRTUAL),
463 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
464 .product = const_le16(0x0003),
465 .version = const_le16(0x0001),
466 },
467 },{
468 .select = VIRTIO_INPUT_CFG_EV_BITS,
469 .subsel = EV_ABS,
470 .size = 1,
471 .u.bitmap = {
472 (1 << ABS_X) | (1 << ABS_Y),
473 },
474 },{
475 .select = VIRTIO_INPUT_CFG_ABS_INFO,
476 .subsel = ABS_X,
477 .size = sizeof(virtio_input_absinfo),
478 .u.abs.max = const_le32(INPUT_EVENT_ABS_SIZE),
479 },{
480 .select = VIRTIO_INPUT_CFG_ABS_INFO,
481 .subsel = ABS_Y,
482 .size = sizeof(virtio_input_absinfo),
483 .u.abs.max = const_le32(INPUT_EVENT_ABS_SIZE),
484 },
485 { /* end of list */ },
486 };
487
488 static void virtio_tablet_init(Object *obj)
489 {
490 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
491 VirtIOInput *vinput = VIRTIO_INPUT(obj);
492
493 vhid->handler = &virtio_tablet_handler;
494 virtio_input_init_config(vinput, virtio_tablet_config);
495 virtio_input_key_config(vinput, keymap_button,
496 ARRAY_SIZE(keymap_button));
497 }
498
499 static const TypeInfo virtio_tablet_info = {
500 .name = TYPE_VIRTIO_TABLET,
501 .parent = TYPE_VIRTIO_INPUT_HID,
502 .instance_size = sizeof(VirtIOInputHID),
503 .instance_init = virtio_tablet_init,
504 };
505
506 /* ----------------------------------------------------------------- */
507
508 static void virtio_register_types(void)
509 {
510 type_register_static(&virtio_input_hid_info);
511 type_register_static(&virtio_keyboard_info);
512 type_register_static(&virtio_mouse_info);
513 type_register_static(&virtio_tablet_info);
514 }
515
516 type_init(virtio_register_types)
QEmu