]>
Commit | Line | Data |
---|---|---|
55a1d80a GH |
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 | ||
9b8bfe21 | 7 | #include "qemu/osdep.h" |
55a1d80a | 8 | #include "qemu/iov.h" |
0b8fa32f | 9 | #include "qemu/module.h" |
55a1d80a | 10 | |
55a1d80a | 11 | #include "hw/virtio/virtio.h" |
a27bd6c7 | 12 | #include "hw/qdev-properties.h" |
55a1d80a GH |
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 | ||
ae6b06ab | 26 | static const unsigned short keymap_button[INPUT_BUTTON__MAX] = { |
55a1d80a GH |
27 | [INPUT_BUTTON_LEFT] = BTN_LEFT, |
28 | [INPUT_BUTTON_RIGHT] = BTN_RIGHT, | |
29 | [INPUT_BUTTON_MIDDLE] = BTN_MIDDLE, | |
f22d0af0 GH |
30 | [INPUT_BUTTON_WHEEL_UP] = BTN_GEAR_UP, |
31 | [INPUT_BUTTON_WHEEL_DOWN] = BTN_GEAR_DOWN, | |
2416760f M |
32 | [INPUT_BUTTON_SIDE] = BTN_SIDE, |
33 | [INPUT_BUTTON_EXTRA] = BTN_EXTRA, | |
55a1d80a GH |
34 | }; |
35 | ||
ae6b06ab | 36 | static const unsigned short axismap_rel[INPUT_AXIS__MAX] = { |
55a1d80a GH |
37 | [INPUT_AXIS_X] = REL_X, |
38 | [INPUT_AXIS_Y] = REL_Y, | |
39 | }; | |
40 | ||
ae6b06ab | 41 | static const unsigned short axismap_abs[INPUT_AXIS__MAX] = { |
55a1d80a GH |
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, | |
ae6b06ab | 49 | const unsigned short *keymap, |
55a1d80a GH |
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 | { | |
f4924974 | 77 | VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev); |
55a1d80a GH |
78 | VirtIOInput *vinput = VIRTIO_INPUT(dev); |
79 | virtio_input_event event; | |
80 | int qcode; | |
b5a1b443 EB |
81 | InputKeyEvent *key; |
82 | InputMoveEvent *move; | |
83 | InputBtnEvent *btn; | |
55a1d80a | 84 | |
568c73a4 | 85 | switch (evt->type) { |
55a1d80a | 86 | case INPUT_EVENT_KIND_KEY: |
32bafa8f | 87 | key = evt->u.key.data; |
b5a1b443 | 88 | qcode = qemu_input_key_value_to_qcode(key->key); |
ae6b06ab DB |
89 | if (qcode < qemu_input_map_qcode_to_linux_len && |
90 | qemu_input_map_qcode_to_linux[qcode]) { | |
55a1d80a | 91 | event.type = cpu_to_le16(EV_KEY); |
ae6b06ab | 92 | event.code = cpu_to_le16(qemu_input_map_qcode_to_linux[qcode]); |
b5a1b443 | 93 | event.value = cpu_to_le32(key->down ? 1 : 0); |
55a1d80a GH |
94 | virtio_input_send(vinput, &event); |
95 | } else { | |
b5a1b443 | 96 | if (key->down) { |
55a1d80a | 97 | fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__, |
977c736f | 98 | qcode, QKeyCode_str(qcode)); |
55a1d80a GH |
99 | } |
100 | } | |
101 | break; | |
102 | case INPUT_EVENT_KIND_BTN: | |
32bafa8f | 103 | btn = evt->u.btn.data; |
a5f99be4 M |
104 | if (vhid->wheel_axis && |
105 | (btn->button == INPUT_BUTTON_WHEEL_UP || | |
106 | btn->button == INPUT_BUTTON_WHEEL_DOWN) && | |
107 | btn->down) { | |
f4924974 GH |
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]) { | |
55a1d80a | 114 | event.type = cpu_to_le16(EV_KEY); |
b5a1b443 EB |
115 | event.code = cpu_to_le16(keymap_button[btn->button]); |
116 | event.value = cpu_to_le32(btn->down ? 1 : 0); | |
55a1d80a GH |
117 | virtio_input_send(vinput, &event); |
118 | } else { | |
b5a1b443 | 119 | if (btn->down) { |
55a1d80a | 120 | fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__, |
b5a1b443 | 121 | btn->button, |
977c736f | 122 | InputButton_str(btn->button)); |
55a1d80a GH |
123 | } |
124 | } | |
125 | break; | |
126 | case INPUT_EVENT_KIND_REL: | |
32bafa8f | 127 | move = evt->u.rel.data; |
55a1d80a | 128 | event.type = cpu_to_le16(EV_REL); |
b5a1b443 EB |
129 | event.code = cpu_to_le16(axismap_rel[move->axis]); |
130 | event.value = cpu_to_le32(move->value); | |
55a1d80a GH |
131 | virtio_input_send(vinput, &event); |
132 | break; | |
133 | case INPUT_EVENT_KIND_ABS: | |
32bafa8f | 134 | move = evt->u.abs.data; |
55a1d80a | 135 | event.type = cpu_to_le16(EV_ABS); |
b5a1b443 EB |
136 | event.code = cpu_to_le16(axismap_abs[move->axis]); |
137 | event.value = cpu_to_le32(move->value); | |
55a1d80a GH |
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); | |
5cce1733 | 161 | |
55a1d80a | 162 | vhid->hs = qemu_input_handler_register(dev, vhid->handler); |
5cce1733 GH |
163 | if (vhid->display && vhid->hs) { |
164 | qemu_input_handler_bind(vhid->hs, vhid->display, vhid->head, NULL); | |
165 | } | |
55a1d80a GH |
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 | ||
5cce1733 GH |
214 | static Property virtio_input_hid_properties[] = { |
215 | DEFINE_PROP_STRING("display", VirtIOInputHID, display), | |
216 | DEFINE_PROP_UINT32("head", VirtIOInputHID, head, 0), | |
2a19b229 | 217 | DEFINE_PROP_END_OF_LIST(), |
5cce1733 GH |
218 | }; |
219 | ||
55a1d80a GH |
220 | static void virtio_input_hid_class_init(ObjectClass *klass, void *data) |
221 | { | |
5cce1733 | 222 | DeviceClass *dc = DEVICE_CLASS(klass); |
55a1d80a GH |
223 | VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass); |
224 | ||
5cce1733 | 225 | dc->props = virtio_input_hid_properties; |
55a1d80a GH |
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); | |
ae6b06ab DB |
285 | virtio_input_key_config(vinput, qemu_input_map_qcode_to_linux, |
286 | qemu_input_map_qcode_to_linux_len); | |
55a1d80a GH |
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 | ||
f4924974 | 305 | static struct virtio_input_config virtio_mouse_config_v1[] = { |
55a1d80a GH |
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 | ||
f4924974 GH |
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 | ||
55a1d80a GH |
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; | |
f4924974 GH |
374 | virtio_input_init_config(vinput, vhid->wheel_axis |
375 | ? virtio_mouse_config_v2 | |
376 | : virtio_mouse_config_v1); | |
55a1d80a GH |
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, | |
f4924974 | 386 | .class_init = virtio_mouse_class_init, |
55a1d80a GH |
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 | ||
f4924974 | 398 | static struct virtio_input_config virtio_tablet_config_v1[] = { |
55a1d80a GH |
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), | |
9cfa7ab9 PV |
423 | .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN), |
424 | .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX), | |
55a1d80a GH |
425 | },{ |
426 | .select = VIRTIO_INPUT_CFG_ABS_INFO, | |
427 | .subsel = ABS_Y, | |
428 | .size = sizeof(virtio_input_absinfo), | |
9cfa7ab9 PV |
429 | .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN), |
430 | .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX), | |
55a1d80a GH |
431 | }, |
432 | { /* end of list */ }, | |
433 | }; | |
434 | ||
f4924974 GH |
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 | ||
55a1d80a GH |
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; | |
f4924974 GH |
498 | virtio_input_init_config(vinput, vhid->wheel_axis |
499 | ? virtio_tablet_config_v2 | |
500 | : virtio_tablet_config_v1); | |
55a1d80a GH |
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, | |
f4924974 | 510 | .class_init = virtio_tablet_class_init, |
55a1d80a GH |
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) |