?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
migration: Fix analyze-migration.py when ignore-shared is used
[qemu/kevin.git] / hw / input / virtio-input-hid.c
blob7053ad72d4db7086ecbcc65d5d7c89b387e7121e
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 #define VIRTIO_ID_NAME_MULTITOUCH "QEMU Virtio MultiTouch"
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 [INPUT_BUTTON_TOUCH] = BTN_TOUCH,
35 };
36
37 static const unsigned short axismap_rel[INPUT_AXIS__MAX] = {
38 [INPUT_AXIS_X] = REL_X,
39 [INPUT_AXIS_Y] = REL_Y,
40 };
41
42 static const unsigned short axismap_abs[INPUT_AXIS__MAX] = {
43 [INPUT_AXIS_X] = ABS_X,
44 [INPUT_AXIS_Y] = ABS_Y,
45 };
46
47 static const unsigned short axismap_tch[INPUT_AXIS__MAX] = {
48 [INPUT_AXIS_X] = ABS_MT_POSITION_X,
49 [INPUT_AXIS_Y] = ABS_MT_POSITION_Y,
50 };
51
52 /* ----------------------------------------------------------------- */
53
54 static void virtio_input_extend_config(VirtIOInput *vinput,
55 const unsigned short *map,
56 size_t mapsize,
57 uint8_t select, uint8_t subsel)
58 {
59 virtio_input_config ext;
60 int i, bit, byte, bmax = 0;
61
62 memset(&ext, 0, sizeof(ext));
63 for (i = 0; i < mapsize; i++) {
64 bit = map[i];
65 if (!bit) {
66 continue;
67 }
68 byte = bit / 8;
69 bit = bit % 8;
70 ext.u.bitmap[byte] |= (1 << bit);
71 if (bmax < byte+1) {
72 bmax = byte+1;
73 }
74 }
75 ext.select = select;
76 ext.subsel = subsel;
77 ext.size = bmax;
78 virtio_input_add_config(vinput, &ext);
79 }
80
81 static void virtio_input_handle_event(DeviceState *dev, QemuConsole *src,
82 InputEvent *evt)
83 {
84 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
85 VirtIOInput *vinput = VIRTIO_INPUT(dev);
86 virtio_input_event event;
87 int qcode;
88 InputKeyEvent *key;
89 InputMoveEvent *move;
90 InputBtnEvent *btn;
91 InputMultiTouchEvent *mtt;
92
93 switch (evt->type) {
94 case INPUT_EVENT_KIND_KEY:
95 key = evt->u.key.data;
96 qcode = qemu_input_key_value_to_qcode(key->key);
97 if (qcode < qemu_input_map_qcode_to_linux_len &&
98 qemu_input_map_qcode_to_linux[qcode]) {
99 event.type = cpu_to_le16(EV_KEY);
100 event.code = cpu_to_le16(qemu_input_map_qcode_to_linux[qcode]);
101 event.value = cpu_to_le32(key->down ? 1 : 0);
102 virtio_input_send(vinput, &event);
103 } else {
104 if (key->down) {
105 fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__,
106 qcode, QKeyCode_str(qcode));
107 }
108 }
109 break;
110 case INPUT_EVENT_KIND_BTN:
111 btn = evt->u.btn.data;
112 if (vhid->wheel_axis &&
113 (btn->button == INPUT_BUTTON_WHEEL_UP ||
114 btn->button == INPUT_BUTTON_WHEEL_DOWN) &&
115 btn->down) {
116 event.type = cpu_to_le16(EV_REL);
117 event.code = cpu_to_le16(REL_WHEEL);
118 event.value = cpu_to_le32(btn->button == INPUT_BUTTON_WHEEL_UP
119 ? 1 : -1);
120 virtio_input_send(vinput, &event);
121 } else if (keymap_button[btn->button]) {
122 event.type = cpu_to_le16(EV_KEY);
123 event.code = cpu_to_le16(keymap_button[btn->button]);
124 event.value = cpu_to_le32(btn->down ? 1 : 0);
125 virtio_input_send(vinput, &event);
126 } else {
127 if (btn->down) {
128 fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__,
129 btn->button,
130 InputButton_str(btn->button));
131 }
132 }
133 break;
134 case INPUT_EVENT_KIND_REL:
135 move = evt->u.rel.data;
136 event.type = cpu_to_le16(EV_REL);
137 event.code = cpu_to_le16(axismap_rel[move->axis]);
138 event.value = cpu_to_le32(move->value);
139 virtio_input_send(vinput, &event);
140 break;
141 case INPUT_EVENT_KIND_ABS:
142 move = evt->u.abs.data;
143 event.type = cpu_to_le16(EV_ABS);
144 event.code = cpu_to_le16(axismap_abs[move->axis]);
145 event.value = cpu_to_le32(move->value);
146 virtio_input_send(vinput, &event);
147 break;
148 case INPUT_EVENT_KIND_MTT:
149 mtt = evt->u.mtt.data;
150 if (mtt->type == INPUT_MULTI_TOUCH_TYPE_DATA) {
151 event.type = cpu_to_le16(EV_ABS);
152 event.code = cpu_to_le16(axismap_tch[mtt->axis]);
153 event.value = cpu_to_le32(mtt->value);
154 virtio_input_send(vinput, &event);
155 } else {
156 event.type = cpu_to_le16(EV_ABS);
157 event.code = cpu_to_le16(ABS_MT_SLOT);
158 event.value = cpu_to_le32(mtt->slot);
159 virtio_input_send(vinput, &event);
160 event.type = cpu_to_le16(EV_ABS);
161 event.code = cpu_to_le16(ABS_MT_TRACKING_ID);
162 event.value = cpu_to_le32(mtt->tracking_id);
163 virtio_input_send(vinput, &event);
164 }
165 break;
166 default:
167 /* keep gcc happy */
168 break;
169 }
170 }
171
172 static void virtio_input_handle_sync(DeviceState *dev)
173 {
174 VirtIOInput *vinput = VIRTIO_INPUT(dev);
175 virtio_input_event event = {
176 .type = cpu_to_le16(EV_SYN),
177 .code = cpu_to_le16(SYN_REPORT),
178 .value = 0,
179 };
180
181 virtio_input_send(vinput, &event);
182 }
183
184 static void virtio_input_hid_realize(DeviceState *dev, Error **errp)
185 {
186 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
187
188 vhid->hs = qemu_input_handler_register(dev, vhid->handler);
189 if (vhid->display && vhid->hs) {
190 qemu_input_handler_bind(vhid->hs, vhid->display, vhid->head, NULL);
191 }
192 }
193
194 static void virtio_input_hid_unrealize(DeviceState *dev)
195 {
196 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
197 qemu_input_handler_unregister(vhid->hs);
198 }
199
200 static void virtio_input_hid_change_active(VirtIOInput *vinput)
201 {
202 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
203
204 if (vinput->active) {
205 qemu_input_handler_activate(vhid->hs);
206 } else {
207 qemu_input_handler_deactivate(vhid->hs);
208 }
209 }
210
211 static void virtio_input_hid_handle_status(VirtIOInput *vinput,
212 virtio_input_event *event)
213 {
214 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
215 int ledbit = 0;
216
217 switch (le16_to_cpu(event->type)) {
218 case EV_LED:
219 if (event->code == LED_NUML) {
220 ledbit = QEMU_NUM_LOCK_LED;
221 } else if (event->code == LED_CAPSL) {
222 ledbit = QEMU_CAPS_LOCK_LED;
223 } else if (event->code == LED_SCROLLL) {
224 ledbit = QEMU_SCROLL_LOCK_LED;
225 }
226 if (event->value) {
227 vhid->ledstate |= ledbit;
228 } else {
229 vhid->ledstate &= ~ledbit;
230 }
231 kbd_put_ledstate(vhid->ledstate);
232 break;
233 default:
234 fprintf(stderr, "%s: unknown type %d\n", __func__,
235 le16_to_cpu(event->type));
236 break;
237 }
238 }
239
240 static Property virtio_input_hid_properties[] = {
241 DEFINE_PROP_STRING("display", VirtIOInputHID, display),
242 DEFINE_PROP_UINT32("head", VirtIOInputHID, head, 0),
243 DEFINE_PROP_END_OF_LIST(),
244 };
245
246 static void virtio_input_hid_class_init(ObjectClass *klass, void *data)
247 {
248 DeviceClass *dc = DEVICE_CLASS(klass);
249 VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass);
250
251 device_class_set_props(dc, virtio_input_hid_properties);
252 vic->realize = virtio_input_hid_realize;
253 vic->unrealize = virtio_input_hid_unrealize;
254 vic->change_active = virtio_input_hid_change_active;
255 vic->handle_status = virtio_input_hid_handle_status;
256 }
257
258 static const TypeInfo virtio_input_hid_info = {
259 .name = TYPE_VIRTIO_INPUT_HID,
260 .parent = TYPE_VIRTIO_INPUT,
261 .instance_size = sizeof(VirtIOInputHID),
262 .class_init = virtio_input_hid_class_init,
263 .abstract = true,
264 };
265
266 /* ----------------------------------------------------------------- */
267
268 static QemuInputHandler virtio_keyboard_handler = {
269 .name = VIRTIO_ID_NAME_KEYBOARD,
270 .mask = INPUT_EVENT_MASK_KEY,
271 .event = virtio_input_handle_event,
272 .sync = virtio_input_handle_sync,
273 };
274
275 static struct virtio_input_config virtio_keyboard_config[] = {
276 {
277 .select = VIRTIO_INPUT_CFG_ID_NAME,
278 .size = sizeof(VIRTIO_ID_NAME_KEYBOARD),
279 .u.string = VIRTIO_ID_NAME_KEYBOARD,
280 },{
281 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
282 .size = sizeof(struct virtio_input_devids),
283 .u.ids = {
284 .bustype = const_le16(BUS_VIRTUAL),
285 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
286 .product = const_le16(0x0001),
287 .version = const_le16(0x0001),
288 },
289 },{
290 .select = VIRTIO_INPUT_CFG_EV_BITS,
291 .subsel = EV_REP,
292 .size = 1,
293 },{
294 .select = VIRTIO_INPUT_CFG_EV_BITS,
295 .subsel = EV_LED,
296 .size = 1,
297 .u.bitmap = {
298 (1 << LED_NUML) | (1 << LED_CAPSL) | (1 << LED_SCROLLL),
299 },
300 },
301 { /* end of list */ },
302 };
303
304 static void virtio_keyboard_init(Object *obj)
305 {
306 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
307 VirtIOInput *vinput = VIRTIO_INPUT(obj);
308
309 vhid->handler = &virtio_keyboard_handler;
310 virtio_input_init_config(vinput, virtio_keyboard_config);
311 virtio_input_extend_config(vinput, qemu_input_map_qcode_to_linux,
312 qemu_input_map_qcode_to_linux_len,
313 VIRTIO_INPUT_CFG_EV_BITS, EV_KEY);
314 }
315
316 static const TypeInfo virtio_keyboard_info = {
317 .name = TYPE_VIRTIO_KEYBOARD,
318 .parent = TYPE_VIRTIO_INPUT_HID,
319 .instance_size = sizeof(VirtIOInputHID),
320 .instance_init = virtio_keyboard_init,
321 };
322
323 /* ----------------------------------------------------------------- */
324
325 static QemuInputHandler virtio_mouse_handler = {
326 .name = VIRTIO_ID_NAME_MOUSE,
327 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
328 .event = virtio_input_handle_event,
329 .sync = virtio_input_handle_sync,
330 };
331
332 static struct virtio_input_config virtio_mouse_config_v1[] = {
333 {
334 .select = VIRTIO_INPUT_CFG_ID_NAME,
335 .size = sizeof(VIRTIO_ID_NAME_MOUSE),
336 .u.string = VIRTIO_ID_NAME_MOUSE,
337 },{
338 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
339 .size = sizeof(struct virtio_input_devids),
340 .u.ids = {
341 .bustype = const_le16(BUS_VIRTUAL),
342 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
343 .product = const_le16(0x0002),
344 .version = const_le16(0x0001),
345 },
346 },{
347 .select = VIRTIO_INPUT_CFG_EV_BITS,
348 .subsel = EV_REL,
349 .size = 1,
350 .u.bitmap = {
351 (1 << REL_X) | (1 << REL_Y),
352 },
353 },
354 { /* end of list */ },
355 };
356
357 static struct virtio_input_config virtio_mouse_config_v2[] = {
358 {
359 .select = VIRTIO_INPUT_CFG_ID_NAME,
360 .size = sizeof(VIRTIO_ID_NAME_MOUSE),
361 .u.string = VIRTIO_ID_NAME_MOUSE,
362 },{
363 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
364 .size = sizeof(struct virtio_input_devids),
365 .u.ids = {
366 .bustype = const_le16(BUS_VIRTUAL),
367 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
368 .product = const_le16(0x0002),
369 .version = const_le16(0x0002),
370 },
371 },{
372 .select = VIRTIO_INPUT_CFG_EV_BITS,
373 .subsel = EV_REL,
374 .size = 2,
375 .u.bitmap = {
376 (1 << REL_X) | (1 << REL_Y),
377 (1 << (REL_WHEEL - 8))
378 },
379 },
380 { /* end of list */ },
381 };
382
383 static Property virtio_mouse_properties[] = {
384 DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
385 DEFINE_PROP_END_OF_LIST(),
386 };
387
388 static void virtio_mouse_class_init(ObjectClass *klass, void *data)
389 {
390 DeviceClass *dc = DEVICE_CLASS(klass);
391
392 device_class_set_props(dc, virtio_mouse_properties);
393 }
394
395 static void virtio_mouse_init(Object *obj)
396 {
397 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
398 VirtIOInput *vinput = VIRTIO_INPUT(obj);
399
400 vhid->handler = &virtio_mouse_handler;
401 virtio_input_init_config(vinput, vhid->wheel_axis
402 ? virtio_mouse_config_v2
403 : virtio_mouse_config_v1);
404 virtio_input_extend_config(vinput, keymap_button,
405 ARRAY_SIZE(keymap_button),
406 VIRTIO_INPUT_CFG_EV_BITS, EV_KEY);
407 }
408
409 static const TypeInfo virtio_mouse_info = {
410 .name = TYPE_VIRTIO_MOUSE,
411 .parent = TYPE_VIRTIO_INPUT_HID,
412 .instance_size = sizeof(VirtIOInputHID),
413 .instance_init = virtio_mouse_init,
414 .class_init = virtio_mouse_class_init,
415 };
416
417 /* ----------------------------------------------------------------- */
418
419 static QemuInputHandler virtio_tablet_handler = {
420 .name = VIRTIO_ID_NAME_TABLET,
421 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
422 .event = virtio_input_handle_event,
423 .sync = virtio_input_handle_sync,
424 };
425
426 static struct virtio_input_config virtio_tablet_config_v1[] = {
427 {
428 .select = VIRTIO_INPUT_CFG_ID_NAME,
429 .size = sizeof(VIRTIO_ID_NAME_TABLET),
430 .u.string = VIRTIO_ID_NAME_TABLET,
431 },{
432 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
433 .size = sizeof(struct virtio_input_devids),
434 .u.ids = {
435 .bustype = const_le16(BUS_VIRTUAL),
436 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
437 .product = const_le16(0x0003),
438 .version = const_le16(0x0001),
439 },
440 },{
441 .select = VIRTIO_INPUT_CFG_EV_BITS,
442 .subsel = EV_ABS,
443 .size = 1,
444 .u.bitmap = {
445 (1 << ABS_X) | (1 << ABS_Y),
446 },
447 },{
448 .select = VIRTIO_INPUT_CFG_ABS_INFO,
449 .subsel = ABS_X,
450 .size = sizeof(virtio_input_absinfo),
451 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
452 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
453 },{
454 .select = VIRTIO_INPUT_CFG_ABS_INFO,
455 .subsel = ABS_Y,
456 .size = sizeof(virtio_input_absinfo),
457 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
458 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
459 },
460 { /* end of list */ },
461 };
462
463 static struct virtio_input_config virtio_tablet_config_v2[] = {
464 {
465 .select = VIRTIO_INPUT_CFG_ID_NAME,
466 .size = sizeof(VIRTIO_ID_NAME_TABLET),
467 .u.string = VIRTIO_ID_NAME_TABLET,
468 },{
469 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
470 .size = sizeof(struct virtio_input_devids),
471 .u.ids = {
472 .bustype = const_le16(BUS_VIRTUAL),
473 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
474 .product = const_le16(0x0003),
475 .version = const_le16(0x0002),
476 },
477 },{
478 .select = VIRTIO_INPUT_CFG_EV_BITS,
479 .subsel = EV_ABS,
480 .size = 1,
481 .u.bitmap = {
482 (1 << ABS_X) | (1 << ABS_Y),
483 },
484 },{
485 .select = VIRTIO_INPUT_CFG_EV_BITS,
486 .subsel = EV_REL,
487 .size = 2,
488 .u.bitmap = {
489 0,
490 (1 << (REL_WHEEL - 8))
491 },
492 },{
493 .select = VIRTIO_INPUT_CFG_ABS_INFO,
494 .subsel = ABS_X,
495 .size = sizeof(virtio_input_absinfo),
496 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
497 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
498 },{
499 .select = VIRTIO_INPUT_CFG_ABS_INFO,
500 .subsel = ABS_Y,
501 .size = sizeof(virtio_input_absinfo),
502 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
503 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
504 },
505 { /* end of list */ },
506 };
507
508 static Property virtio_tablet_properties[] = {
509 DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
510 DEFINE_PROP_END_OF_LIST(),
511 };
512
513 static void virtio_tablet_class_init(ObjectClass *klass, void *data)
514 {
515 DeviceClass *dc = DEVICE_CLASS(klass);
516
517 device_class_set_props(dc, virtio_tablet_properties);
518 }
519
520 static void virtio_tablet_init(Object *obj)
521 {
522 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
523 VirtIOInput *vinput = VIRTIO_INPUT(obj);
524
525 vhid->handler = &virtio_tablet_handler;
526 virtio_input_init_config(vinput, vhid->wheel_axis
527 ? virtio_tablet_config_v2
528 : virtio_tablet_config_v1);
529 virtio_input_extend_config(vinput, keymap_button,
530 ARRAY_SIZE(keymap_button),
531 VIRTIO_INPUT_CFG_EV_BITS, EV_KEY);
532 }
533
534 static const TypeInfo virtio_tablet_info = {
535 .name = TYPE_VIRTIO_TABLET,
536 .parent = TYPE_VIRTIO_INPUT_HID,
537 .instance_size = sizeof(VirtIOInputHID),
538 .instance_init = virtio_tablet_init,
539 .class_init = virtio_tablet_class_init,
540 };
541
542 /* ----------------------------------------------------------------- */
543
544 static QemuInputHandler virtio_multitouch_handler = {
545 .name = VIRTIO_ID_NAME_MULTITOUCH,
546 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_MTT,
547 .event = virtio_input_handle_event,
548 .sync = virtio_input_handle_sync,
549 };
550
551 static struct virtio_input_config virtio_multitouch_config[] = {
552 {
553 .select = VIRTIO_INPUT_CFG_ID_NAME,
554 .size = sizeof(VIRTIO_ID_NAME_MULTITOUCH),
555 .u.string = VIRTIO_ID_NAME_MULTITOUCH,
556 },{
557 .select = VIRTIO_INPUT_CFG_ID_DEVIDS,
558 .size = sizeof(struct virtio_input_devids),
559 .u.ids = {
560 .bustype = const_le16(BUS_VIRTUAL),
561 .vendor = const_le16(0x0627), /* same we use for usb hid devices */
562 .product = const_le16(0x0003),
563 .version = const_le16(0x0001),
564 },
565 },{
566 .select = VIRTIO_INPUT_CFG_ABS_INFO,
567 .subsel = ABS_MT_SLOT,
568 .size = sizeof(virtio_input_absinfo),
569 .u.abs.min = const_le32(INPUT_EVENT_SLOTS_MIN),
570 .u.abs.max = const_le32(INPUT_EVENT_SLOTS_MAX),
571 },{
572 .select = VIRTIO_INPUT_CFG_ABS_INFO,
573 .subsel = ABS_MT_TRACKING_ID,
574 .size = sizeof(virtio_input_absinfo),
575 .u.abs.min = const_le32(INPUT_EVENT_SLOTS_MIN),
576 .u.abs.max = const_le32(INPUT_EVENT_SLOTS_MAX),
577 },{
578 .select = VIRTIO_INPUT_CFG_ABS_INFO,
579 .subsel = ABS_MT_POSITION_X,
580 .size = sizeof(virtio_input_absinfo),
581 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
582 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
583 },{
584 .select = VIRTIO_INPUT_CFG_ABS_INFO,
585 .subsel = ABS_MT_POSITION_Y,
586 .size = sizeof(virtio_input_absinfo),
587 .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
588 .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
589 },
590 { /* end of list */ },
591 };
592
593 static void virtio_multitouch_init(Object *obj)
594 {
595 VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
596 VirtIOInput *vinput = VIRTIO_INPUT(obj);
597 unsigned short abs_props[] = {
598 INPUT_PROP_DIRECT,
599 };
600 unsigned short abs_bits[] = {
601 ABS_MT_SLOT,
602 ABS_MT_TRACKING_ID,
603 ABS_MT_POSITION_X,
604 ABS_MT_POSITION_Y,
605 };
606
607 vhid->handler = &virtio_multitouch_handler;
608 virtio_input_init_config(vinput, virtio_multitouch_config);
609 virtio_input_extend_config(vinput, keymap_button,
610 ARRAY_SIZE(keymap_button),
611 VIRTIO_INPUT_CFG_EV_BITS, EV_KEY);
612 virtio_input_extend_config(vinput, abs_props,
613 ARRAY_SIZE(abs_props),
614 VIRTIO_INPUT_CFG_PROP_BITS, 0);
615 virtio_input_extend_config(vinput, abs_bits,
616 ARRAY_SIZE(abs_bits),
617 VIRTIO_INPUT_CFG_EV_BITS, EV_ABS);
618 }
619
620 static const TypeInfo virtio_multitouch_info = {
621 .name = TYPE_VIRTIO_MULTITOUCH,
622 .parent = TYPE_VIRTIO_INPUT_HID,
623 .instance_size = sizeof(VirtIOInputHID),
624 .instance_init = virtio_multitouch_init,
625 };
626
627 /* ----------------------------------------------------------------- */
628
629 static void virtio_register_types(void)
630 {
631 type_register_static(&virtio_input_hid_info);
632 type_register_static(&virtio_keyboard_info);
633 type_register_static(&virtio_mouse_info);
634 type_register_static(&virtio_tablet_info);
635 type_register_static(&virtio_multitouch_info);
636 }
637
638 type_init(virtio_register_types)
Random patches