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