meson: convert qapi-specific to meson
[qemu.git] / hw / input / virtio-input-hid.c
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 #include "qemu/module.h"
10
11 #include "hw/virtio/virtio.h"
12 #include "hw/qdev-properties.h"
13 #include "hw/virtio/virtio-input.h"
14
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 short keymap_button[INPUT_BUTTON__MAX] = {
26 [INPUT_BUTTON_LEFT] = BTN_LEFT,
27 [INPUT_BUTTON_RIGHT] = BTN_RIGHT,
28 [INPUT_BUTTON_MIDDLE] = BTN_MIDDLE,
29 [INPUT_BUTTON_WHEEL_UP] = BTN_GEAR_UP,
30 [INPUT_BUTTON_WHEEL_DOWN] = BTN_GEAR_DOWN,
31 [INPUT_BUTTON_SIDE] = BTN_SIDE,
32 [INPUT_BUTTON_EXTRA] = BTN_EXTRA,
33 };
34
35 static const unsigned short axismap_rel[INPUT_AXIS__MAX] = {
36 [INPUT_AXIS_X] = REL_X,
37 [INPUT_AXIS_Y] = REL_Y,
38 };
39
40 static const unsigned short axismap_abs[INPUT_AXIS__MAX] = {
41 [INPUT_AXIS_X] = ABS_X,
42 [INPUT_AXIS_Y] = ABS_Y,
43 };
44
45 /* ----------------------------------------------------------------- */
46
47 static void virtio_input_key_config(VirtIOInput *vinput,
48 const unsigned short *keymap,
49 size_t mapsize)
50 {
51 virtio_input_config keys;
52 int i, bit, byte, bmax = 0;
53
54 memset(&keys, 0, sizeof(keys));
55 for (i = 0; i < mapsize; i++) {
56 bit = keymap[i];
57 if (!bit) {
58 continue;
59 }
60 byte = bit / 8;
61 bit = bit % 8;
62 keys.u.bitmap[byte] |= (1 << bit);
63 if (bmax < byte+1) {
64 bmax = byte+1;
65 }
66 }
67 keys.select = VIRTIO_INPUT_CFG_EV_BITS;
68 keys.subsel = EV_KEY;
69 keys.size = bmax;
70 virtio_input_add_config(vinput, &keys);
71 }
72
73 static void virtio_input_handle_event(DeviceState *dev, QemuConsole *src,
74 InputEvent *evt)
75 {
76 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
77 VirtIOInput *vinput = VIRTIO_INPUT(dev);
78 virtio_input_event event;
79 int qcode;
80 InputKeyEvent *key;
81 InputMoveEvent *move;
82 InputBtnEvent *btn;
83
84 switch (evt->type) {
85 case INPUT_EVENT_KIND_KEY:
86 key = evt->u.key.data;
87 qcode = qemu_input_key_value_to_qcode(key->key);
88 if (qcode < qemu_input_map_qcode_to_linux_len &&
89 qemu_input_map_qcode_to_linux[qcode]) {
90 event.type = cpu_to_le16(EV_KEY);
91 event.code = cpu_to_le16(qemu_input_map_qcode_to_linux[qcode]);
92 event.value = cpu_to_le32(key->down ? 1 : 0);
93 virtio_input_send(vinput, &event);
94 } else {
95 if (key->down) {
96 fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__,
97 qcode, QKeyCode_str(qcode));
98 }
99 }
100 break;
101 case INPUT_EVENT_KIND_BTN:
102 btn = evt->u.btn.data;
103 if (vhid->wheel_axis &&
104 (btn->button == INPUT_BUTTON_WHEEL_UP ||
105 btn->button == INPUT_BUTTON_WHEEL_DOWN) &&
106 btn->down) {
107 event.type = cpu_to_le16(EV_REL);
108 event.code = cpu_to_le16(REL_WHEEL);
109 event.value = cpu_to_le32(btn->button == INPUT_BUTTON_WHEEL_UP
110 ? 1 : -1);
111 virtio_input_send(vinput, &event);
112 } else if (keymap_button[btn->button]) {
113 event.type = cpu_to_le16(EV_KEY);
114 event.code = cpu_to_le16(keymap_button[btn->button]);
115 event.value = cpu_to_le32(btn->down ? 1 : 0);
116 virtio_input_send(vinput, &event);
117 } else {
118 if (btn->down) {
119 fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__,
120 btn->button,
121 InputButton_str(btn->button));
122 }
123 }
124 break;
125 case INPUT_EVENT_KIND_REL:
126 move = evt->u.rel.data;
127 event.type = cpu_to_le16(EV_REL);
128 event.code = cpu_to_le16(axismap_rel[move->axis]);
129 event.value = cpu_to_le32(move->value);
130 virtio_input_send(vinput, &event);
131 break;
132 case INPUT_EVENT_KIND_ABS:
133 move = evt->u.abs.data;
134 event.type = cpu_to_le16(EV_ABS);
135 event.code = cpu_to_le16(axismap_abs[move->axis]);
136 event.value = cpu_to_le32(move->value);
137 virtio_input_send(vinput, &event);
138 break;
139 default:
140 /* keep gcc happy */
141 break;
142 }
143 }
144
145 static void virtio_input_handle_sync(DeviceState *dev)
146 {
147 VirtIOInput *vinput = VIRTIO_INPUT(dev);
148 virtio_input_event event = {
149 .type = cpu_to_le16(EV_SYN),
150 .code = cpu_to_le16(SYN_REPORT),
151 .value = 0,
152 };
153
154 virtio_input_send(vinput, &event);
155 }
156
157 static void virtio_input_hid_realize(DeviceState *dev, Error **errp)
158 {
159 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
160
161 vhid->hs = qemu_input_handler_register(dev, vhid->handler);
162 if (vhid->display && vhid->hs) {
163 qemu_input_handler_bind(vhid->hs, vhid->display, vhid->head, NULL);
164 }
165 }
166
167 static void virtio_input_hid_unrealize(DeviceState *dev)
168 {
169 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
170 qemu_input_handler_unregister(vhid->hs);
171 }
172
173 static void virtio_input_hid_change_active(VirtIOInput *vinput)
174 {
175 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
176
177 if (vinput->active) {
178 qemu_input_handler_activate(vhid->hs);
179 } else {
180 qemu_input_handler_deactivate(vhid->hs);
181 }
182 }
183
184 static void virtio_input_hid_handle_status(VirtIOInput *vinput,
185 virtio_input_event *event)
186 {
187 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
188 int ledbit = 0;
189
190 switch (le16_to_cpu(event->type)) {
191 case EV_LED:
192 if (event->code == LED_NUML) {
193 ledbit = QEMU_NUM_LOCK_LED;
194 } else if (event->code == LED_CAPSL) {
195 ledbit = QEMU_CAPS_LOCK_LED;
196 } else if (event->code == LED_SCROLLL) {
197 ledbit = QEMU_SCROLL_LOCK_LED;
198 }
199 if (event->value) {
200 vhid->ledstate |= ledbit;
201 } else {
202 vhid->ledstate &= ~ledbit;
203 }
204 kbd_put_ledstate(vhid->ledstate);
205 break;
206 default:
207 fprintf(stderr, "%s: unknown type %d\n", __func__,
208 le16_to_cpu(event->type));
209 break;
210 }
211 }
212
213 static Property virtio_input_hid_properties[] = {
214 DEFINE_PROP_STRING("display", VirtIOInputHID, display),
215 DEFINE_PROP_UINT32("head", VirtIOInputHID, head, 0),
216 DEFINE_PROP_END_OF_LIST(),
217 };
218
219 static void virtio_input_hid_class_init(ObjectClass *klass, void *data)
220 {
221 DeviceClass *dc = DEVICE_CLASS(klass);
222 VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass);
223
224 device_class_set_props(dc, virtio_input_hid_properties);
225 vic->realize = virtio_input_hid_realize;
226 vic->unrealize = virtio_input_hid_unrealize;
227 vic->change_active = virtio_input_hid_change_active;
228 vic->handle_status = virtio_input_hid_handle_status;
229 }
230
231 static const TypeInfo virtio_input_hid_info = {
232 .name = TYPE_VIRTIO_INPUT_HID,
233 .parent = TYPE_VIRTIO_INPUT,
234 .instance_size = sizeof(VirtIOInputHID),
235 .class_init = virtio_input_hid_class_init,
236 .abstract = true,
237 };
238
239 /* ----------------------------------------------------------------- */
240
241 static QemuInputHandler virtio_keyboard_handler = {
242 .name = VIRTIO_ID_NAME_KEYBOARD,
243 .mask = INPUT_EVENT_MASK_KEY,
244 .event = virtio_input_handle_event,
245 .sync = virtio_input_handle_sync,
246 };
247
248 static struct virtio_input_config virtio_keyboard_config[] = {
249 {
250 .select = VIRTIO_INPUT_CFG_ID_NAME,
251 .size = sizeof(VIRTIO_ID_NAME_KEYBOARD),
252 .u.string = VIRTIO_ID_NAME_KEYBOARD,
253 },{
254 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
255 .size = sizeof(struct virtio_input_devids),
256 .u.ids = {
257 .bustype = const_le16(BUS_VIRTUAL),
258 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
259 .product = const_le16(0x0001),
260 .version = const_le16(0x0001),
261 },
262 },{
263 .select = VIRTIO_INPUT_CFG_EV_BITS,
264 .subsel = EV_REP,
265 .size = 1,
266 },{
267 .select = VIRTIO_INPUT_CFG_EV_BITS,
268 .subsel = EV_LED,
269 .size = 1,
270 .u.bitmap = {
271 (1 << LED_NUML) | (1 << LED_CAPSL) | (1 << LED_SCROLLL),
272 },
273 },
274 { /* end of list */ },
275 };
276
277 static void virtio_keyboard_init(Object *obj)
278 {
279 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
280 VirtIOInput *vinput = VIRTIO_INPUT(obj);
281
282 vhid->handler = &virtio_keyboard_handler;
283 virtio_input_init_config(vinput, virtio_keyboard_config);
284 virtio_input_key_config(vinput, qemu_input_map_qcode_to_linux,
285 qemu_input_map_qcode_to_linux_len);
286 }
287
288 static const TypeInfo virtio_keyboard_info = {
289 .name = TYPE_VIRTIO_KEYBOARD,
290 .parent = TYPE_VIRTIO_INPUT_HID,
291 .instance_size = sizeof(VirtIOInputHID),
292 .instance_init = virtio_keyboard_init,
293 };
294
295 /* ----------------------------------------------------------------- */
296
297 static QemuInputHandler virtio_mouse_handler = {
298 .name = VIRTIO_ID_NAME_MOUSE,
299 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
300 .event = virtio_input_handle_event,
301 .sync = virtio_input_handle_sync,
302 };
303
304 static struct virtio_input_config virtio_mouse_config_v1[] = {
305 {
306 .select = VIRTIO_INPUT_CFG_ID_NAME,
307 .size = sizeof(VIRTIO_ID_NAME_MOUSE),
308 .u.string = VIRTIO_ID_NAME_MOUSE,
309 },{
310 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
311 .size = sizeof(struct virtio_input_devids),
312 .u.ids = {
313 .bustype = const_le16(BUS_VIRTUAL),
314 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
315 .product = const_le16(0x0002),
316 .version = const_le16(0x0001),
317 },
318 },{
319 .select = VIRTIO_INPUT_CFG_EV_BITS,
320 .subsel = EV_REL,
321 .size = 1,
322 .u.bitmap = {
323 (1 << REL_X) | (1 << REL_Y),
324 },
325 },
326 { /* end of list */ },
327 };
328
329 static struct virtio_input_config virtio_mouse_config_v2[] = {
330 {
331 .select = VIRTIO_INPUT_CFG_ID_NAME,
332 .size = sizeof(VIRTIO_ID_NAME_MOUSE),
333 .u.string = VIRTIO_ID_NAME_MOUSE,
334 },{
335 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
336 .size = sizeof(struct virtio_input_devids),
337 .u.ids = {
338 .bustype = const_le16(BUS_VIRTUAL),
339 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
340 .product = const_le16(0x0002),
341 .version = const_le16(0x0002),
342 },
343 },{
344 .select = VIRTIO_INPUT_CFG_EV_BITS,
345 .subsel = EV_REL,
346 .size = 2,
347 .u.bitmap = {
348 (1 << REL_X) | (1 << REL_Y),
349 (1 << (REL_WHEEL - 8))
350 },
351 },
352 { /* end of list */ },
353 };
354
355 static Property virtio_mouse_properties[] = {
356 DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
357 DEFINE_PROP_END_OF_LIST(),
358 };
359
360 static void virtio_mouse_class_init(ObjectClass *klass, void *data)
361 {
362 DeviceClass *dc = DEVICE_CLASS(klass);
363
364 device_class_set_props(dc, virtio_mouse_properties);
365 }
366
367 static void virtio_mouse_init(Object *obj)
368 {
369 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
370 VirtIOInput *vinput = VIRTIO_INPUT(obj);
371
372 vhid->handler = &virtio_mouse_handler;
373 virtio_input_init_config(vinput, vhid->wheel_axis
374 ? virtio_mouse_config_v2
375 : virtio_mouse_config_v1);
376 virtio_input_key_config(vinput, keymap_button,
377 ARRAY_SIZE(keymap_button));
378 }
379
380 static const TypeInfo virtio_mouse_info = {
381 .name = TYPE_VIRTIO_MOUSE,
382 .parent = TYPE_VIRTIO_INPUT_HID,
383 .instance_size = sizeof(VirtIOInputHID),
384 .instance_init = virtio_mouse_init,
385 .class_init = virtio_mouse_class_init,
386 };
387
388 /* ----------------------------------------------------------------- */
389
390 static QemuInputHandler virtio_tablet_handler = {
391 .name = VIRTIO_ID_NAME_TABLET,
392 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
393 .event = virtio_input_handle_event,
394 .sync = virtio_input_handle_sync,
395 };
396
397 static struct virtio_input_config virtio_tablet_config_v1[] = {
398 {
399 .select = VIRTIO_INPUT_CFG_ID_NAME,
400 .size = sizeof(VIRTIO_ID_NAME_TABLET),
401 .u.string = VIRTIO_ID_NAME_TABLET,
402 },{
403 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
404 .size = sizeof(struct virtio_input_devids),
405 .u.ids = {
406 .bustype = const_le16(BUS_VIRTUAL),
407 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
408 .product = const_le16(0x0003),
409 .version = const_le16(0x0001),
410 },
411 },{
412 .select = VIRTIO_INPUT_CFG_EV_BITS,
413 .subsel = EV_ABS,
414 .size = 1,
415 .u.bitmap = {
416 (1 << ABS_X) | (1 << ABS_Y),
417 },
418 },{
419 .select = VIRTIO_INPUT_CFG_ABS_INFO,
420 .subsel = ABS_X,
421 .size = sizeof(virtio_input_absinfo),
422 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
423 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
424 },{
425 .select = VIRTIO_INPUT_CFG_ABS_INFO,
426 .subsel = ABS_Y,
427 .size = sizeof(virtio_input_absinfo),
428 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
429 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
430 },
431 { /* end of list */ },
432 };
433
434 static struct virtio_input_config virtio_tablet_config_v2[] = {
435 {
436 .select = VIRTIO_INPUT_CFG_ID_NAME,
437 .size = sizeof(VIRTIO_ID_NAME_TABLET),
438 .u.string = VIRTIO_ID_NAME_TABLET,
439 },{
440 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
441 .size = sizeof(struct virtio_input_devids),
442 .u.ids = {
443 .bustype = const_le16(BUS_VIRTUAL),
444 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
445 .product = const_le16(0x0003),
446 .version = const_le16(0x0002),
447 },
448 },{
449 .select = VIRTIO_INPUT_CFG_EV_BITS,
450 .subsel = EV_ABS,
451 .size = 1,
452 .u.bitmap = {
453 (1 << ABS_X) | (1 << ABS_Y),
454 },
455 },{
456 .select = VIRTIO_INPUT_CFG_EV_BITS,
457 .subsel = EV_REL,
458 .size = 2,
459 .u.bitmap = {
460 0,
461 (1 << (REL_WHEEL - 8))
462 },
463 },{
464 .select = VIRTIO_INPUT_CFG_ABS_INFO,
465 .subsel = ABS_X,
466 .size = sizeof(virtio_input_absinfo),
467 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
468 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
469 },{
470 .select = VIRTIO_INPUT_CFG_ABS_INFO,
471 .subsel = ABS_Y,
472 .size = sizeof(virtio_input_absinfo),
473 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
474 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
475 },
476 { /* end of list */ },
477 };
478
479 static Property virtio_tablet_properties[] = {
480 DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
481 DEFINE_PROP_END_OF_LIST(),
482 };
483
484 static void virtio_tablet_class_init(ObjectClass *klass, void *data)
485 {
486 DeviceClass *dc = DEVICE_CLASS(klass);
487
488 device_class_set_props(dc, virtio_tablet_properties);
489 }
490
491 static void virtio_tablet_init(Object *obj)
492 {
493 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
494 VirtIOInput *vinput = VIRTIO_INPUT(obj);
495
496 vhid->handler = &virtio_tablet_handler;
497 virtio_input_init_config(vinput, vhid->wheel_axis
498 ? virtio_tablet_config_v2
499 : virtio_tablet_config_v1);
500 virtio_input_key_config(vinput, keymap_button,
501 ARRAY_SIZE(keymap_button));
502 }
503
504 static const TypeInfo virtio_tablet_info = {
505 .name = TYPE_VIRTIO_TABLET,
506 .parent = TYPE_VIRTIO_INPUT_HID,
507 .instance_size = sizeof(VirtIOInputHID),
508 .instance_init = virtio_tablet_init,
509 .class_init = virtio_tablet_class_init,
510 };
511
512 /* ----------------------------------------------------------------- */
513
514 static void virtio_register_types(void)
515 {
516 type_register_static(&virtio_input_hid_info);
517 type_register_static(&virtio_keyboard_info);
518 type_register_static(&virtio_mouse_info);
519 type_register_static(&virtio_tablet_info);
520 }
521
522 type_init(virtio_register_types)