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
10 #include "hw/virtio/virtio.h"
11 #include "hw/virtio/virtio-input.h"
14 #include "ui/console.h"
16 #include "standard-headers/linux/input.h"
18 #define VIRTIO_ID_NAME_KEYBOARD "QEMU Virtio Keyboard"
19 #define VIRTIO_ID_NAME_MOUSE "QEMU Virtio Mouse"
20 #define VIRTIO_ID_NAME_TABLET "QEMU Virtio Tablet"
22 /* ----------------------------------------------------------------- */
24 static const unsigned int keymap_qcode
[Q_KEY_CODE_MAX
] = {
25 [Q_KEY_CODE_ESC
] = KEY_ESC
,
26 [Q_KEY_CODE_1
] = KEY_1
,
27 [Q_KEY_CODE_2
] = KEY_2
,
28 [Q_KEY_CODE_3
] = KEY_3
,
29 [Q_KEY_CODE_4
] = KEY_4
,
30 [Q_KEY_CODE_5
] = KEY_5
,
31 [Q_KEY_CODE_6
] = KEY_6
,
32 [Q_KEY_CODE_7
] = KEY_7
,
33 [Q_KEY_CODE_8
] = KEY_8
,
34 [Q_KEY_CODE_9
] = KEY_9
,
35 [Q_KEY_CODE_0
] = KEY_0
,
36 [Q_KEY_CODE_MINUS
] = KEY_MINUS
,
37 [Q_KEY_CODE_EQUAL
] = KEY_EQUAL
,
38 [Q_KEY_CODE_BACKSPACE
] = KEY_BACKSPACE
,
40 [Q_KEY_CODE_TAB
] = KEY_TAB
,
41 [Q_KEY_CODE_Q
] = KEY_Q
,
42 [Q_KEY_CODE_W
] = KEY_W
,
43 [Q_KEY_CODE_E
] = KEY_E
,
44 [Q_KEY_CODE_R
] = KEY_R
,
45 [Q_KEY_CODE_T
] = KEY_T
,
46 [Q_KEY_CODE_Y
] = KEY_Y
,
47 [Q_KEY_CODE_U
] = KEY_U
,
48 [Q_KEY_CODE_I
] = KEY_I
,
49 [Q_KEY_CODE_O
] = KEY_O
,
50 [Q_KEY_CODE_P
] = KEY_P
,
51 [Q_KEY_CODE_BRACKET_LEFT
] = KEY_LEFTBRACE
,
52 [Q_KEY_CODE_BRACKET_RIGHT
] = KEY_RIGHTBRACE
,
53 [Q_KEY_CODE_RET
] = KEY_ENTER
,
55 [Q_KEY_CODE_CTRL
] = KEY_LEFTCTRL
,
56 [Q_KEY_CODE_A
] = KEY_A
,
57 [Q_KEY_CODE_S
] = KEY_S
,
58 [Q_KEY_CODE_D
] = KEY_D
,
59 [Q_KEY_CODE_F
] = KEY_F
,
60 [Q_KEY_CODE_G
] = KEY_G
,
61 [Q_KEY_CODE_H
] = KEY_H
,
62 [Q_KEY_CODE_J
] = KEY_J
,
63 [Q_KEY_CODE_K
] = KEY_K
,
64 [Q_KEY_CODE_L
] = KEY_L
,
65 [Q_KEY_CODE_SEMICOLON
] = KEY_SEMICOLON
,
66 [Q_KEY_CODE_APOSTROPHE
] = KEY_APOSTROPHE
,
67 [Q_KEY_CODE_GRAVE_ACCENT
] = KEY_GRAVE
,
69 [Q_KEY_CODE_SHIFT
] = KEY_LEFTSHIFT
,
70 [Q_KEY_CODE_BACKSLASH
] = KEY_BACKSLASH
,
71 [Q_KEY_CODE_LESS
] = KEY_102ND
,
72 [Q_KEY_CODE_Z
] = KEY_Z
,
73 [Q_KEY_CODE_X
] = KEY_X
,
74 [Q_KEY_CODE_C
] = KEY_C
,
75 [Q_KEY_CODE_V
] = KEY_V
,
76 [Q_KEY_CODE_B
] = KEY_B
,
77 [Q_KEY_CODE_N
] = KEY_N
,
78 [Q_KEY_CODE_M
] = KEY_M
,
79 [Q_KEY_CODE_COMMA
] = KEY_COMMA
,
80 [Q_KEY_CODE_DOT
] = KEY_DOT
,
81 [Q_KEY_CODE_SLASH
] = KEY_SLASH
,
82 [Q_KEY_CODE_SHIFT_R
] = KEY_RIGHTSHIFT
,
84 [Q_KEY_CODE_ALT
] = KEY_LEFTALT
,
85 [Q_KEY_CODE_SPC
] = KEY_SPACE
,
86 [Q_KEY_CODE_CAPS_LOCK
] = KEY_CAPSLOCK
,
88 [Q_KEY_CODE_F1
] = KEY_F1
,
89 [Q_KEY_CODE_F2
] = KEY_F2
,
90 [Q_KEY_CODE_F3
] = KEY_F3
,
91 [Q_KEY_CODE_F4
] = KEY_F4
,
92 [Q_KEY_CODE_F5
] = KEY_F5
,
93 [Q_KEY_CODE_F6
] = KEY_F6
,
94 [Q_KEY_CODE_F7
] = KEY_F7
,
95 [Q_KEY_CODE_F8
] = KEY_F8
,
96 [Q_KEY_CODE_F9
] = KEY_F9
,
97 [Q_KEY_CODE_F10
] = KEY_F10
,
98 [Q_KEY_CODE_NUM_LOCK
] = KEY_NUMLOCK
,
99 [Q_KEY_CODE_SCROLL_LOCK
] = KEY_SCROLLLOCK
,
101 [Q_KEY_CODE_KP_0
] = KEY_KP0
,
102 [Q_KEY_CODE_KP_1
] = KEY_KP1
,
103 [Q_KEY_CODE_KP_2
] = KEY_KP2
,
104 [Q_KEY_CODE_KP_3
] = KEY_KP3
,
105 [Q_KEY_CODE_KP_4
] = KEY_KP4
,
106 [Q_KEY_CODE_KP_5
] = KEY_KP5
,
107 [Q_KEY_CODE_KP_6
] = KEY_KP6
,
108 [Q_KEY_CODE_KP_7
] = KEY_KP7
,
109 [Q_KEY_CODE_KP_8
] = KEY_KP8
,
110 [Q_KEY_CODE_KP_9
] = KEY_KP9
,
111 [Q_KEY_CODE_KP_SUBTRACT
] = KEY_KPMINUS
,
112 [Q_KEY_CODE_KP_ADD
] = KEY_KPPLUS
,
113 [Q_KEY_CODE_KP_DECIMAL
] = KEY_KPDOT
,
114 [Q_KEY_CODE_KP_ENTER
] = KEY_KPENTER
,
115 [Q_KEY_CODE_KP_DIVIDE
] = KEY_KPSLASH
,
116 [Q_KEY_CODE_KP_MULTIPLY
] = KEY_KPASTERISK
,
118 [Q_KEY_CODE_F11
] = KEY_F11
,
119 [Q_KEY_CODE_F12
] = KEY_F12
,
121 [Q_KEY_CODE_CTRL_R
] = KEY_RIGHTCTRL
,
122 [Q_KEY_CODE_SYSRQ
] = KEY_SYSRQ
,
123 [Q_KEY_CODE_ALT_R
] = KEY_RIGHTALT
,
125 [Q_KEY_CODE_HOME
] = KEY_HOME
,
126 [Q_KEY_CODE_UP
] = KEY_UP
,
127 [Q_KEY_CODE_PGUP
] = KEY_PAGEUP
,
128 [Q_KEY_CODE_LEFT
] = KEY_LEFT
,
129 [Q_KEY_CODE_RIGHT
] = KEY_RIGHT
,
130 [Q_KEY_CODE_END
] = KEY_END
,
131 [Q_KEY_CODE_DOWN
] = KEY_DOWN
,
132 [Q_KEY_CODE_PGDN
] = KEY_PAGEDOWN
,
133 [Q_KEY_CODE_INSERT
] = KEY_INSERT
,
134 [Q_KEY_CODE_DELETE
] = KEY_DELETE
,
136 [Q_KEY_CODE_META_L
] = KEY_LEFTMETA
,
137 [Q_KEY_CODE_META_R
] = KEY_RIGHTMETA
,
138 [Q_KEY_CODE_MENU
] = KEY_MENU
,
141 static const unsigned int keymap_button
[INPUT_BUTTON_MAX
] = {
142 [INPUT_BUTTON_LEFT
] = BTN_LEFT
,
143 [INPUT_BUTTON_RIGHT
] = BTN_RIGHT
,
144 [INPUT_BUTTON_MIDDLE
] = BTN_MIDDLE
,
145 [INPUT_BUTTON_WHEEL_UP
] = BTN_GEAR_UP
,
146 [INPUT_BUTTON_WHEEL_DOWN
] = BTN_GEAR_DOWN
,
149 static const unsigned int axismap_rel
[INPUT_AXIS_MAX
] = {
150 [INPUT_AXIS_X
] = REL_X
,
151 [INPUT_AXIS_Y
] = REL_Y
,
154 static const unsigned int axismap_abs
[INPUT_AXIS_MAX
] = {
155 [INPUT_AXIS_X
] = ABS_X
,
156 [INPUT_AXIS_Y
] = ABS_Y
,
159 /* ----------------------------------------------------------------- */
161 static void virtio_input_key_config(VirtIOInput
*vinput
,
162 const unsigned int *keymap
,
165 virtio_input_config keys
;
166 int i
, bit
, byte
, bmax
= 0;
168 memset(&keys
, 0, sizeof(keys
));
169 for (i
= 0; i
< mapsize
; i
++) {
176 keys
.u
.bitmap
[byte
] |= (1 << bit
);
181 keys
.select
= VIRTIO_INPUT_CFG_EV_BITS
;
182 keys
.subsel
= EV_KEY
;
184 virtio_input_add_config(vinput
, &keys
);
187 static void virtio_input_handle_event(DeviceState
*dev
, QemuConsole
*src
,
190 VirtIOInput
*vinput
= VIRTIO_INPUT(dev
);
191 virtio_input_event event
;
195 case INPUT_EVENT_KIND_KEY
:
196 qcode
= qemu_input_key_value_to_qcode(evt
->key
->key
);
197 if (qcode
&& keymap_qcode
[qcode
]) {
198 event
.type
= cpu_to_le16(EV_KEY
);
199 event
.code
= cpu_to_le16(keymap_qcode
[qcode
]);
200 event
.value
= cpu_to_le32(evt
->key
->down
? 1 : 0);
201 virtio_input_send(vinput
, &event
);
203 if (evt
->key
->down
) {
204 fprintf(stderr
, "%s: unmapped key: %d [%s]\n", __func__
,
205 qcode
, QKeyCode_lookup
[qcode
]);
209 case INPUT_EVENT_KIND_BTN
:
210 if (keymap_button
[evt
->btn
->button
]) {
211 event
.type
= cpu_to_le16(EV_KEY
);
212 event
.code
= cpu_to_le16(keymap_button
[evt
->btn
->button
]);
213 event
.value
= cpu_to_le32(evt
->btn
->down
? 1 : 0);
214 virtio_input_send(vinput
, &event
);
216 if (evt
->btn
->down
) {
217 fprintf(stderr
, "%s: unmapped button: %d [%s]\n", __func__
,
218 evt
->btn
->button
, InputButton_lookup
[evt
->btn
->button
]);
222 case INPUT_EVENT_KIND_REL
:
223 event
.type
= cpu_to_le16(EV_REL
);
224 event
.code
= cpu_to_le16(axismap_rel
[evt
->rel
->axis
]);
225 event
.value
= cpu_to_le32(evt
->rel
->value
);
226 virtio_input_send(vinput
, &event
);
228 case INPUT_EVENT_KIND_ABS
:
229 event
.type
= cpu_to_le16(EV_ABS
);
230 event
.code
= cpu_to_le16(axismap_abs
[evt
->abs
->axis
]);
231 event
.value
= cpu_to_le32(evt
->abs
->value
);
232 virtio_input_send(vinput
, &event
);
240 static void virtio_input_handle_sync(DeviceState
*dev
)
242 VirtIOInput
*vinput
= VIRTIO_INPUT(dev
);
243 virtio_input_event event
= {
244 .type
= cpu_to_le16(EV_SYN
),
245 .code
= cpu_to_le16(SYN_REPORT
),
249 virtio_input_send(vinput
, &event
);
252 static void virtio_input_hid_realize(DeviceState
*dev
, Error
**errp
)
254 VirtIOInputHID
*vhid
= VIRTIO_INPUT_HID(dev
);
256 vhid
->hs
= qemu_input_handler_register(dev
, vhid
->handler
);
257 if (vhid
->display
&& vhid
->hs
) {
258 qemu_input_handler_bind(vhid
->hs
, vhid
->display
, vhid
->head
, NULL
);
262 static void virtio_input_hid_unrealize(DeviceState
*dev
, Error
**errp
)
264 VirtIOInputHID
*vhid
= VIRTIO_INPUT_HID(dev
);
265 qemu_input_handler_unregister(vhid
->hs
);
268 static void virtio_input_hid_change_active(VirtIOInput
*vinput
)
270 VirtIOInputHID
*vhid
= VIRTIO_INPUT_HID(vinput
);
272 if (vinput
->active
) {
273 qemu_input_handler_activate(vhid
->hs
);
275 qemu_input_handler_deactivate(vhid
->hs
);
279 static void virtio_input_hid_handle_status(VirtIOInput
*vinput
,
280 virtio_input_event
*event
)
282 VirtIOInputHID
*vhid
= VIRTIO_INPUT_HID(vinput
);
285 switch (le16_to_cpu(event
->type
)) {
287 if (event
->code
== LED_NUML
) {
288 ledbit
= QEMU_NUM_LOCK_LED
;
289 } else if (event
->code
== LED_CAPSL
) {
290 ledbit
= QEMU_CAPS_LOCK_LED
;
291 } else if (event
->code
== LED_SCROLLL
) {
292 ledbit
= QEMU_SCROLL_LOCK_LED
;
295 vhid
->ledstate
|= ledbit
;
297 vhid
->ledstate
&= ~ledbit
;
299 kbd_put_ledstate(vhid
->ledstate
);
302 fprintf(stderr
, "%s: unknown type %d\n", __func__
,
303 le16_to_cpu(event
->type
));
308 static Property virtio_input_hid_properties
[] = {
309 DEFINE_PROP_STRING("display", VirtIOInputHID
, display
),
310 DEFINE_PROP_UINT32("head", VirtIOInputHID
, head
, 0),
311 DEFINE_PROP_END_OF_LIST(),
314 static void virtio_input_hid_class_init(ObjectClass
*klass
, void *data
)
316 DeviceClass
*dc
= DEVICE_CLASS(klass
);
317 VirtIOInputClass
*vic
= VIRTIO_INPUT_CLASS(klass
);
319 dc
->props
= virtio_input_hid_properties
;
320 vic
->realize
= virtio_input_hid_realize
;
321 vic
->unrealize
= virtio_input_hid_unrealize
;
322 vic
->change_active
= virtio_input_hid_change_active
;
323 vic
->handle_status
= virtio_input_hid_handle_status
;
326 static const TypeInfo virtio_input_hid_info
= {
327 .name
= TYPE_VIRTIO_INPUT_HID
,
328 .parent
= TYPE_VIRTIO_INPUT
,
329 .instance_size
= sizeof(VirtIOInputHID
),
330 .class_init
= virtio_input_hid_class_init
,
334 /* ----------------------------------------------------------------- */
336 static QemuInputHandler virtio_keyboard_handler
= {
337 .name
= VIRTIO_ID_NAME_KEYBOARD
,
338 .mask
= INPUT_EVENT_MASK_KEY
,
339 .event
= virtio_input_handle_event
,
340 .sync
= virtio_input_handle_sync
,
343 static struct virtio_input_config virtio_keyboard_config
[] = {
345 .select
= VIRTIO_INPUT_CFG_ID_NAME
,
346 .size
= sizeof(VIRTIO_ID_NAME_KEYBOARD
),
347 .u
.string
= VIRTIO_ID_NAME_KEYBOARD
,
349 .select
= VIRTIO_INPUT_CFG_ID_DEVIDS
,
350 .size
= sizeof(struct virtio_input_devids
),
352 .bustype
= const_le16(BUS_VIRTUAL
),
353 .vendor
= const_le16(0x0627), /* same we use for usb hid devices */
354 .product
= const_le16(0x0001),
355 .version
= const_le16(0x0001),
358 .select
= VIRTIO_INPUT_CFG_EV_BITS
,
362 .select
= VIRTIO_INPUT_CFG_EV_BITS
,
366 (1 << LED_NUML
) | (1 << LED_CAPSL
) | (1 << LED_SCROLLL
),
369 { /* end of list */ },
372 static void virtio_keyboard_init(Object
*obj
)
374 VirtIOInputHID
*vhid
= VIRTIO_INPUT_HID(obj
);
375 VirtIOInput
*vinput
= VIRTIO_INPUT(obj
);
377 vhid
->handler
= &virtio_keyboard_handler
;
378 virtio_input_init_config(vinput
, virtio_keyboard_config
);
379 virtio_input_key_config(vinput
, keymap_qcode
,
380 ARRAY_SIZE(keymap_qcode
));
383 static const TypeInfo virtio_keyboard_info
= {
384 .name
= TYPE_VIRTIO_KEYBOARD
,
385 .parent
= TYPE_VIRTIO_INPUT_HID
,
386 .instance_size
= sizeof(VirtIOInputHID
),
387 .instance_init
= virtio_keyboard_init
,
390 /* ----------------------------------------------------------------- */
392 static QemuInputHandler virtio_mouse_handler
= {
393 .name
= VIRTIO_ID_NAME_MOUSE
,
394 .mask
= INPUT_EVENT_MASK_BTN
| INPUT_EVENT_MASK_REL
,
395 .event
= virtio_input_handle_event
,
396 .sync
= virtio_input_handle_sync
,
399 static struct virtio_input_config virtio_mouse_config
[] = {
401 .select
= VIRTIO_INPUT_CFG_ID_NAME
,
402 .size
= sizeof(VIRTIO_ID_NAME_MOUSE
),
403 .u
.string
= VIRTIO_ID_NAME_MOUSE
,
405 .select
= VIRTIO_INPUT_CFG_ID_DEVIDS
,
406 .size
= sizeof(struct virtio_input_devids
),
408 .bustype
= const_le16(BUS_VIRTUAL
),
409 .vendor
= const_le16(0x0627), /* same we use for usb hid devices */
410 .product
= const_le16(0x0002),
411 .version
= const_le16(0x0001),
414 .select
= VIRTIO_INPUT_CFG_EV_BITS
,
418 (1 << REL_X
) | (1 << REL_Y
),
421 { /* end of list */ },
424 static void virtio_mouse_init(Object
*obj
)
426 VirtIOInputHID
*vhid
= VIRTIO_INPUT_HID(obj
);
427 VirtIOInput
*vinput
= VIRTIO_INPUT(obj
);
429 vhid
->handler
= &virtio_mouse_handler
;
430 virtio_input_init_config(vinput
, virtio_mouse_config
);
431 virtio_input_key_config(vinput
, keymap_button
,
432 ARRAY_SIZE(keymap_button
));
435 static const TypeInfo virtio_mouse_info
= {
436 .name
= TYPE_VIRTIO_MOUSE
,
437 .parent
= TYPE_VIRTIO_INPUT_HID
,
438 .instance_size
= sizeof(VirtIOInputHID
),
439 .instance_init
= virtio_mouse_init
,
442 /* ----------------------------------------------------------------- */
444 static QemuInputHandler virtio_tablet_handler
= {
445 .name
= VIRTIO_ID_NAME_TABLET
,
446 .mask
= INPUT_EVENT_MASK_BTN
| INPUT_EVENT_MASK_ABS
,
447 .event
= virtio_input_handle_event
,
448 .sync
= virtio_input_handle_sync
,
451 static struct virtio_input_config virtio_tablet_config
[] = {
453 .select
= VIRTIO_INPUT_CFG_ID_NAME
,
454 .size
= sizeof(VIRTIO_ID_NAME_TABLET
),
455 .u
.string
= VIRTIO_ID_NAME_TABLET
,
457 .select
= VIRTIO_INPUT_CFG_ID_DEVIDS
,
458 .size
= sizeof(struct virtio_input_devids
),
460 .bustype
= const_le16(BUS_VIRTUAL
),
461 .vendor
= const_le16(0x0627), /* same we use for usb hid devices */
462 .product
= const_le16(0x0003),
463 .version
= const_le16(0x0001),
466 .select
= VIRTIO_INPUT_CFG_EV_BITS
,
470 (1 << ABS_X
) | (1 << ABS_Y
),
473 .select
= VIRTIO_INPUT_CFG_ABS_INFO
,
475 .size
= sizeof(virtio_input_absinfo
),
476 .u
.abs
.max
= const_le32(INPUT_EVENT_ABS_SIZE
),
478 .select
= VIRTIO_INPUT_CFG_ABS_INFO
,
480 .size
= sizeof(virtio_input_absinfo
),
481 .u
.abs
.max
= const_le32(INPUT_EVENT_ABS_SIZE
),
483 { /* end of list */ },
486 static void virtio_tablet_init(Object
*obj
)
488 VirtIOInputHID
*vhid
= VIRTIO_INPUT_HID(obj
);
489 VirtIOInput
*vinput
= VIRTIO_INPUT(obj
);
491 vhid
->handler
= &virtio_tablet_handler
;
492 virtio_input_init_config(vinput
, virtio_tablet_config
);
493 virtio_input_key_config(vinput
, keymap_button
,
494 ARRAY_SIZE(keymap_button
));
497 static const TypeInfo virtio_tablet_info
= {
498 .name
= TYPE_VIRTIO_TABLET
,
499 .parent
= TYPE_VIRTIO_INPUT_HID
,
500 .instance_size
= sizeof(VirtIOInputHID
),
501 .instance_init
= virtio_tablet_init
,
504 /* ----------------------------------------------------------------- */
506 static void virtio_register_types(void)
508 type_register_static(&virtio_input_hid_info
);
509 type_register_static(&virtio_keyboard_info
);
510 type_register_static(&virtio_mouse_info
);
511 type_register_static(&virtio_tablet_info
);
514 type_init(virtio_register_types
)