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
7 #include "qemu/osdep.h"
8 #include "qapi/error.h"
9 #include "qemu/config-file.h"
10 #include "qemu/main-loop.h"
11 #include "qemu/module.h"
12 #include "qemu/sockets.h"
14 #include "qom/object_interfaces.h"
15 #include "sysemu/iothread.h"
16 #include "block/aio.h"
18 #include <sys/ioctl.h>
19 #include "standard-headers/linux/input.h"
20 #include "qom/object.h"
22 static bool linux_is_button(unsigned int lnx)
27 if (lnx >= 0x160 && lnx < 0x2c0) {
33 #define TYPE_INPUT_LINUX "input-linux"
34 OBJECT_DECLARE_SIMPLE_TYPE(InputLinux,
47 bool keydown[KEY_CNT];
60 struct input_event event;
63 enum GrabToggleKeys grab_toggle;
65 QTAILQ_ENTRY(InputLinux) next;
69 static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs);
71 static void input_linux_toggle_grab(InputLinux *il)
73 intptr_t request = !il->grab_active;
77 rc = ioctl(il->fd, EVIOCGRAB, request);
81 il->grab_active = !il->grab_active;
86 QTAILQ_FOREACH(item, &inputs, next) {
87 if (item == il || item->grab_all) {
88 /* avoid endless loops */
91 if (item->grab_active != il->grab_active) {
92 input_linux_toggle_grab(item);
97 static bool input_linux_check_toggle(InputLinux *il)
99 switch (il->grab_toggle) {
100 case GRAB_TOGGLE_KEYS_CTRL_CTRL:
101 return il->keydown[KEY_LEFTCTRL] &&
102 il->keydown[KEY_RIGHTCTRL];
104 case GRAB_TOGGLE_KEYS_ALT_ALT:
105 return il->keydown[KEY_LEFTALT] &&
106 il->keydown[KEY_RIGHTALT];
108 case GRAB_TOGGLE_KEYS_SHIFT_SHIFT:
109 return il->keydown[KEY_LEFTSHIFT] &&
110 il->keydown[KEY_RIGHTSHIFT];
112 case GRAB_TOGGLE_KEYS_META_META:
113 return il->keydown[KEY_LEFTMETA] &&
114 il->keydown[KEY_RIGHTMETA];
116 case GRAB_TOGGLE_KEYS_SCROLLLOCK:
117 return il->keydown[KEY_SCROLLLOCK];
119 case GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK:
120 return (il->keydown[KEY_LEFTCTRL] ||
121 il->keydown[KEY_RIGHTCTRL]) &&
122 il->keydown[KEY_SCROLLLOCK];
124 case GRAB_TOGGLE_KEYS__MAX:
125 /* avoid gcc error */
131 static bool input_linux_should_skip(InputLinux *il,
132 struct input_event *event)
134 return (il->grab_toggle == GRAB_TOGGLE_KEYS_SCROLLLOCK ||
135 il->grab_toggle == GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK) &&
136 event->code == KEY_SCROLLLOCK;
139 static void input_linux_handle_keyboard(InputLinux *il,
140 struct input_event *event)
142 if (event->type == EV_KEY) {
143 if (event->value > 2 || (event->value > 1 && !il->repeat)) {
145 * ignore autorepeat + unknown key events
146 * 0 == up, 1 == down, 2 == autorepeat, other == undefined
150 if (event->code >= KEY_CNT) {
152 * Should not happen. But better safe than sorry,
153 * and we make Coverity happy too.
158 /* keep track of key state */
159 if (!il->keydown[event->code] && event->value) {
160 il->keydown[event->code] = true;
163 if (il->keydown[event->code] && !event->value) {
164 il->keydown[event->code] = false;
168 /* send event to guest when grab is active */
169 if (il->grab_active && !input_linux_should_skip(il, event)) {
170 int qcode = qemu_input_linux_to_qcode(event->code);
171 qemu_input_event_send_key_qcode(NULL, qcode, event->value);
174 /* hotkey -> record switch request ... */
175 if (input_linux_check_toggle(il)) {
176 il->grab_request = true;
180 * ... and do the switch when all keys are lifted, so we
181 * confuse neither guest nor host with keys which seem to
182 * be stuck due to missing key-up events.
184 if (il->grab_request && !il->keycount) {
185 il->grab_request = false;
186 input_linux_toggle_grab(il);
191 static void input_linux_event_mouse_button(int button)
193 qemu_input_queue_btn(NULL, button, true);
194 qemu_input_event_sync();
195 qemu_input_queue_btn(NULL, button, false);
196 qemu_input_event_sync();
199 static void input_linux_handle_mouse(InputLinux *il, struct input_event *event)
201 if (!il->grab_active) {
205 switch (event->type) {
207 switch (event->code) {
209 qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event->value);
212 qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event->value);
215 qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event->value);
218 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event->value);
221 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN,
225 qemu_input_queue_btn(NULL, INPUT_BUTTON_SIDE, event->value);
228 qemu_input_queue_btn(NULL, INPUT_BUTTON_EXTRA, event->value);
233 switch (event->code) {
235 qemu_input_queue_rel(NULL, INPUT_AXIS_X, event->value);
238 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event->value);
241 il->wheel = event->value;
246 switch (event->code) {
248 qemu_input_queue_abs(NULL, INPUT_AXIS_X, event->value,
249 il->abs_x_min, il->abs_x_max);
252 qemu_input_queue_abs(NULL, INPUT_AXIS_Y, event->value,
253 il->abs_y_min, il->abs_y_max);
258 qemu_input_event_sync();
259 if (il->wheel != 0) {
260 input_linux_event_mouse_button((il->wheel > 0)
261 ? INPUT_BUTTON_WHEEL_UP
262 : INPUT_BUTTON_WHEEL_DOWN);
269 static void input_linux_event(void *opaque)
271 InputLinux *il = opaque;
274 uint8_t *p = (uint8_t *)&il->event;
277 read_size = sizeof(il->event) - il->read_offset;
278 rc = read(il->fd, &p[il->read_offset], read_size);
279 if (rc != read_size) {
280 if (rc < 0 && errno != EAGAIN) {
281 fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
282 qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
285 il->read_offset += rc;
292 input_linux_handle_keyboard(il, &il->event);
294 if ((il->has_rel_x || il->has_abs_x) && il->num_btns) {
295 input_linux_handle_mouse(il, &il->event);
300 static void input_linux_complete(UserCreatable *uc, Error **errp)
302 InputLinux *il = INPUT_LINUX(uc);
303 uint8_t evtmap, relmap, absmap;
304 uint8_t keymap[KEY_CNT / 8], keystate[KEY_CNT / 8];
307 struct input_absinfo absinfo;
310 error_setg(errp, "no input device specified");
314 il->fd = open(il->evdev, O_RDWR);
316 error_setg_file_open(errp, errno, il->evdev);
319 if (!g_unix_set_fd_nonblocking(il->fd, true, NULL)) {
320 error_setg_errno(errp, errno, "Failed to set FD nonblocking");
324 rc = ioctl(il->fd, EVIOCGVERSION, &ver);
326 error_setg(errp, "%s: is not an evdev device", il->evdev);
330 rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap);
332 goto err_read_event_bits;
335 if (evtmap & (1 << EV_REL)) {
337 rc = ioctl(il->fd, EVIOCGBIT(EV_REL, sizeof(relmap)), &relmap);
339 goto err_read_event_bits;
341 if (relmap & (1 << REL_X)) {
342 il->has_rel_x = true;
346 if (evtmap & (1 << EV_ABS)) {
348 rc = ioctl(il->fd, EVIOCGBIT(EV_ABS, sizeof(absmap)), &absmap);
350 goto err_read_event_bits;
352 if (absmap & (1 << ABS_X)) {
353 il->has_abs_x = true;
354 rc = ioctl(il->fd, EVIOCGABS(ABS_X), &absinfo);
356 error_setg(errp, "%s: failed to get get absolute X value",
360 il->abs_x_min = absinfo.minimum;
361 il->abs_x_max = absinfo.maximum;
362 rc = ioctl(il->fd, EVIOCGABS(ABS_Y), &absinfo);
364 error_setg(errp, "%s: failed to get get absolute Y value",
368 il->abs_y_min = absinfo.minimum;
369 il->abs_y_max = absinfo.maximum;
373 if (evtmap & (1 << EV_KEY)) {
374 memset(keymap, 0, sizeof(keymap));
375 rc = ioctl(il->fd, EVIOCGBIT(EV_KEY, sizeof(keymap)), keymap);
377 goto err_read_event_bits;
379 rc = ioctl(il->fd, EVIOCGKEY(sizeof(keystate)), keystate);
381 error_setg(errp, "%s: failed to get global key state", il->evdev);
384 for (i = 0; i < KEY_CNT; i++) {
385 if (keymap[i / 8] & (1 << (i % 8))) {
386 if (linux_is_button(i)) {
391 if (keystate[i / 8] & (1 << (i % 8))) {
392 il->keydown[i] = true;
399 qemu_set_fd_handler(il->fd, input_linux_event, NULL, il);
401 /* delay grab until all keys are released */
402 il->grab_request = true;
404 input_linux_toggle_grab(il);
406 QTAILQ_INSERT_TAIL(&inputs, il, next);
407 il->initialized = true;
411 error_setg(errp, "%s: failed to read event bits", il->evdev);
418 static void input_linux_instance_finalize(Object *obj)
420 InputLinux *il = INPUT_LINUX(obj);
422 if (il->initialized) {
423 QTAILQ_REMOVE(&inputs, il, next);
424 qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
430 static char *input_linux_get_evdev(Object *obj, Error **errp)
432 InputLinux *il = INPUT_LINUX(obj);
434 return g_strdup(il->evdev);
437 static void input_linux_set_evdev(Object *obj, const char *value,
440 InputLinux *il = INPUT_LINUX(obj);
443 error_setg(errp, "evdev property already set");
446 il->evdev = g_strdup(value);
449 static bool input_linux_get_grab_all(Object *obj, Error **errp)
451 InputLinux *il = INPUT_LINUX(obj);
456 static void input_linux_set_grab_all(Object *obj, bool value,
459 InputLinux *il = INPUT_LINUX(obj);
461 il->grab_all = value;
464 static bool input_linux_get_repeat(Object *obj, Error **errp)
466 InputLinux *il = INPUT_LINUX(obj);
471 static void input_linux_set_repeat(Object *obj, bool value,
474 InputLinux *il = INPUT_LINUX(obj);
479 static int input_linux_get_grab_toggle(Object *obj, Error **errp)
481 InputLinux *il = INPUT_LINUX(obj);
483 return il->grab_toggle;
486 static void input_linux_set_grab_toggle(Object *obj, int value,
489 InputLinux *il = INPUT_LINUX(obj);
491 il->grab_toggle = value;
494 static void input_linux_instance_init(Object *obj)
498 static void input_linux_class_init(ObjectClass *oc, void *data)
500 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
502 ucc->complete = input_linux_complete;
504 object_class_property_add_str(oc, "evdev",
505 input_linux_get_evdev,
506 input_linux_set_evdev);
507 object_class_property_add_bool(oc, "grab_all",
508 input_linux_get_grab_all,
509 input_linux_set_grab_all);
510 object_class_property_add_bool(oc, "repeat",
511 input_linux_get_repeat,
512 input_linux_set_repeat);
513 object_class_property_add_enum(oc, "grab-toggle", "GrabToggleKeys",
514 &GrabToggleKeys_lookup,
515 input_linux_get_grab_toggle,
516 input_linux_set_grab_toggle);
519 static const TypeInfo input_linux_info = {
520 .name = TYPE_INPUT_LINUX,
521 .parent = TYPE_OBJECT,
522 .class_init = input_linux_class_init,
523 .instance_size = sizeof(InputLinux),
524 .instance_init = input_linux_instance_init,
525 .instance_finalize = input_linux_instance_finalize,
526 .interfaces = (InterfaceInfo[]) {
527 { TYPE_USER_CREATABLE },
532 static void register_types(void)
534 type_register_static(&input_linux_info);
537 type_init(register_types);