Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[qemu.git] / ui / input-linux.c
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 "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"
13 #include "ui/input.h"
14 #include "qom/object_interfaces.h"
15 #include "sysemu/iothread.h"
16 #include "block/aio.h"
17
18 #include <sys/ioctl.h>
19 #include "standard-headers/linux/input.h"
20
21 static bool linux_is_button(unsigned int lnx)
22 {
23 if (lnx < 0x100) {
24 return false;
25 }
26 if (lnx >= 0x160 && lnx < 0x2c0) {
27 return false;
28 }
29 return true;
30 }
31
32 #define TYPE_INPUT_LINUX "input-linux"
33 #define INPUT_LINUX(obj) \
34 OBJECT_CHECK(InputLinux, (obj), TYPE_INPUT_LINUX)
35 #define INPUT_LINUX_GET_CLASS(obj) \
36 OBJECT_GET_CLASS(InputLinuxClass, (obj), TYPE_INPUT_LINUX)
37 #define INPUT_LINUX_CLASS(klass) \
38 OBJECT_CLASS_CHECK(InputLinuxClass, (klass), TYPE_INPUT_LINUX)
39
40 typedef struct InputLinux InputLinux;
41 typedef struct InputLinuxClass InputLinuxClass;
42
43 struct InputLinux {
44 Object parent;
45
46 char *evdev;
47 int fd;
48 bool repeat;
49 bool grab_request;
50 bool grab_active;
51 bool grab_all;
52 bool keydown[KEY_CNT];
53 int keycount;
54 int wheel;
55 bool initialized;
56
57 bool has_rel_x;
58 bool has_abs_x;
59 int num_keys;
60 int num_btns;
61 int abs_x_min;
62 int abs_x_max;
63 int abs_y_min;
64 int abs_y_max;
65 struct input_event event;
66 int read_offset;
67
68 enum GrabToggleKeys grab_toggle;
69
70 QTAILQ_ENTRY(InputLinux) next;
71 };
72
73 struct InputLinuxClass {
74 ObjectClass parent_class;
75 };
76
77 static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs);
78
79 static void input_linux_toggle_grab(InputLinux *il)
80 {
81 intptr_t request = !il->grab_active;
82 InputLinux *item;
83 int rc;
84
85 rc = ioctl(il->fd, EVIOCGRAB, request);
86 if (rc < 0) {
87 return;
88 }
89 il->grab_active = !il->grab_active;
90
91 if (!il->grab_all) {
92 return;
93 }
94 QTAILQ_FOREACH(item, &inputs, next) {
95 if (item == il || item->grab_all) {
96 /* avoid endless loops */
97 continue;
98 }
99 if (item->grab_active != il->grab_active) {
100 input_linux_toggle_grab(item);
101 }
102 }
103 }
104
105 static bool input_linux_check_toggle(InputLinux *il)
106 {
107 switch (il->grab_toggle) {
108 case GRAB_TOGGLE_KEYS_CTRL_CTRL:
109 return il->keydown[KEY_LEFTCTRL] &&
110 il->keydown[KEY_RIGHTCTRL];
111
112 case GRAB_TOGGLE_KEYS_ALT_ALT:
113 return il->keydown[KEY_LEFTALT] &&
114 il->keydown[KEY_RIGHTALT];
115
116 case GRAB_TOGGLE_KEYS_SHIFT_SHIFT:
117 return il->keydown[KEY_LEFTSHIFT] &&
118 il->keydown[KEY_RIGHTSHIFT];
119
120 case GRAB_TOGGLE_KEYS_META_META:
121 return il->keydown[KEY_LEFTMETA] &&
122 il->keydown[KEY_RIGHTMETA];
123
124 case GRAB_TOGGLE_KEYS_SCROLLLOCK:
125 return il->keydown[KEY_SCROLLLOCK];
126
127 case GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK:
128 return (il->keydown[KEY_LEFTCTRL] ||
129 il->keydown[KEY_RIGHTCTRL]) &&
130 il->keydown[KEY_SCROLLLOCK];
131
132 case GRAB_TOGGLE_KEYS__MAX:
133 /* avoid gcc error */
134 break;
135 }
136 return false;
137 }
138
139 static bool input_linux_should_skip(InputLinux *il,
140 struct input_event *event)
141 {
142 return (il->grab_toggle == GRAB_TOGGLE_KEYS_SCROLLLOCK ||
143 il->grab_toggle == GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK) &&
144 event->code == KEY_SCROLLLOCK;
145 }
146
147 static void input_linux_handle_keyboard(InputLinux *il,
148 struct input_event *event)
149 {
150 if (event->type == EV_KEY) {
151 if (event->value > 2 || (event->value > 1 && !il->repeat)) {
152 /*
153 * ignore autorepeat + unknown key events
154 * 0 == up, 1 == down, 2 == autorepeat, other == undefined
155 */
156 return;
157 }
158 if (event->code >= KEY_CNT) {
159 /*
160 * Should not happen. But better safe than sorry,
161 * and we make Coverity happy too.
162 */
163 return;
164 }
165
166 /* keep track of key state */
167 if (!il->keydown[event->code] && event->value) {
168 il->keydown[event->code] = true;
169 il->keycount++;
170 }
171 if (il->keydown[event->code] && !event->value) {
172 il->keydown[event->code] = false;
173 il->keycount--;
174 }
175
176 /* send event to guest when grab is active */
177 if (il->grab_active && !input_linux_should_skip(il, event)) {
178 int qcode = qemu_input_linux_to_qcode(event->code);
179 qemu_input_event_send_key_qcode(NULL, qcode, event->value);
180 }
181
182 /* hotkey -> record switch request ... */
183 if (input_linux_check_toggle(il)) {
184 il->grab_request = true;
185 }
186
187 /*
188 * ... and do the switch when all keys are lifted, so we
189 * confuse neither guest nor host with keys which seem to
190 * be stuck due to missing key-up events.
191 */
192 if (il->grab_request && !il->keycount) {
193 il->grab_request = false;
194 input_linux_toggle_grab(il);
195 }
196 }
197 }
198
199 static void input_linux_event_mouse_button(int button)
200 {
201 qemu_input_queue_btn(NULL, button, true);
202 qemu_input_event_sync();
203 qemu_input_queue_btn(NULL, button, false);
204 qemu_input_event_sync();
205 }
206
207 static void input_linux_handle_mouse(InputLinux *il, struct input_event *event)
208 {
209 if (!il->grab_active) {
210 return;
211 }
212
213 switch (event->type) {
214 case EV_KEY:
215 switch (event->code) {
216 case BTN_LEFT:
217 qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event->value);
218 break;
219 case BTN_RIGHT:
220 qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event->value);
221 break;
222 case BTN_MIDDLE:
223 qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event->value);
224 break;
225 case BTN_GEAR_UP:
226 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event->value);
227 break;
228 case BTN_GEAR_DOWN:
229 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN,
230 event->value);
231 break;
232 case BTN_SIDE:
233 qemu_input_queue_btn(NULL, INPUT_BUTTON_SIDE, event->value);
234 break;
235 case BTN_EXTRA:
236 qemu_input_queue_btn(NULL, INPUT_BUTTON_EXTRA, event->value);
237 break;
238 };
239 break;
240 case EV_REL:
241 switch (event->code) {
242 case REL_X:
243 qemu_input_queue_rel(NULL, INPUT_AXIS_X, event->value);
244 break;
245 case REL_Y:
246 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event->value);
247 break;
248 case REL_WHEEL:
249 il->wheel = event->value;
250 break;
251 }
252 break;
253 case EV_ABS:
254 switch (event->code) {
255 case ABS_X:
256 qemu_input_queue_abs(NULL, INPUT_AXIS_X, event->value,
257 il->abs_x_min, il->abs_x_max);
258 break;
259 case ABS_Y:
260 qemu_input_queue_abs(NULL, INPUT_AXIS_Y, event->value,
261 il->abs_y_min, il->abs_y_max);
262 break;
263 }
264 break;
265 case EV_SYN:
266 qemu_input_event_sync();
267 if (il->wheel != 0) {
268 input_linux_event_mouse_button((il->wheel > 0)
269 ? INPUT_BUTTON_WHEEL_UP
270 : INPUT_BUTTON_WHEEL_DOWN);
271 il->wheel = 0;
272 }
273 break;
274 }
275 }
276
277 static void input_linux_event(void *opaque)
278 {
279 InputLinux *il = opaque;
280 int rc;
281 int read_size;
282 uint8_t *p = (uint8_t *)&il->event;
283
284 for (;;) {
285 read_size = sizeof(il->event) - il->read_offset;
286 rc = read(il->fd, &p[il->read_offset], read_size);
287 if (rc != read_size) {
288 if (rc < 0 && errno != EAGAIN) {
289 fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
290 qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
291 close(il->fd);
292 } else if (rc > 0) {
293 il->read_offset += rc;
294 }
295 break;
296 }
297 il->read_offset = 0;
298
299 if (il->num_keys) {
300 input_linux_handle_keyboard(il, &il->event);
301 }
302 if ((il->has_rel_x || il->has_abs_x) && il->num_btns) {
303 input_linux_handle_mouse(il, &il->event);
304 }
305 }
306 }
307
308 static void input_linux_complete(UserCreatable *uc, Error **errp)
309 {
310 InputLinux *il = INPUT_LINUX(uc);
311 uint8_t evtmap, relmap, absmap;
312 uint8_t keymap[KEY_CNT / 8], keystate[KEY_CNT / 8];
313 unsigned int i;
314 int rc, ver;
315 struct input_absinfo absinfo;
316
317 if (!il->evdev) {
318 error_setg(errp, "no input device specified");
319 return;
320 }
321
322 il->fd = open(il->evdev, O_RDWR);
323 if (il->fd < 0) {
324 error_setg_file_open(errp, errno, il->evdev);
325 return;
326 }
327 qemu_set_nonblock(il->fd);
328
329 rc = ioctl(il->fd, EVIOCGVERSION, &ver);
330 if (rc < 0) {
331 error_setg(errp, "%s: is not an evdev device", il->evdev);
332 goto err_close;
333 }
334
335 rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap);
336 if (rc < 0) {
337 error_setg(errp, "%s: failed to read event bits", il->evdev);
338 goto err_close;
339 }
340
341 if (evtmap & (1 << EV_REL)) {
342 relmap = 0;
343 rc = ioctl(il->fd, EVIOCGBIT(EV_REL, sizeof(relmap)), &relmap);
344 if (relmap & (1 << REL_X)) {
345 il->has_rel_x = true;
346 }
347 }
348
349 if (evtmap & (1 << EV_ABS)) {
350 absmap = 0;
351 rc = ioctl(il->fd, EVIOCGBIT(EV_ABS, sizeof(absmap)), &absmap);
352 if (absmap & (1 << ABS_X)) {
353 il->has_abs_x = true;
354 rc = ioctl(il->fd, EVIOCGABS(ABS_X), &absinfo);
355 il->abs_x_min = absinfo.minimum;
356 il->abs_x_max = absinfo.maximum;
357 rc = ioctl(il->fd, EVIOCGABS(ABS_Y), &absinfo);
358 il->abs_y_min = absinfo.minimum;
359 il->abs_y_max = absinfo.maximum;
360 }
361 }
362
363 if (evtmap & (1 << EV_KEY)) {
364 memset(keymap, 0, sizeof(keymap));
365 rc = ioctl(il->fd, EVIOCGBIT(EV_KEY, sizeof(keymap)), keymap);
366 rc = ioctl(il->fd, EVIOCGKEY(sizeof(keystate)), keystate);
367 for (i = 0; i < KEY_CNT; i++) {
368 if (keymap[i / 8] & (1 << (i % 8))) {
369 if (linux_is_button(i)) {
370 il->num_btns++;
371 } else {
372 il->num_keys++;
373 }
374 if (keystate[i / 8] & (1 << (i % 8))) {
375 il->keydown[i] = true;
376 il->keycount++;
377 }
378 }
379 }
380 }
381
382 qemu_set_fd_handler(il->fd, input_linux_event, NULL, il);
383 if (il->keycount) {
384 /* delay grab until all keys are released */
385 il->grab_request = true;
386 } else {
387 input_linux_toggle_grab(il);
388 }
389 QTAILQ_INSERT_TAIL(&inputs, il, next);
390 il->initialized = true;
391 return;
392
393 err_close:
394 close(il->fd);
395 return;
396 }
397
398 static void input_linux_instance_finalize(Object *obj)
399 {
400 InputLinux *il = INPUT_LINUX(obj);
401
402 if (il->initialized) {
403 QTAILQ_REMOVE(&inputs, il, next);
404 close(il->fd);
405 }
406 g_free(il->evdev);
407 }
408
409 static char *input_linux_get_evdev(Object *obj, Error **errp)
410 {
411 InputLinux *il = INPUT_LINUX(obj);
412
413 return g_strdup(il->evdev);
414 }
415
416 static void input_linux_set_evdev(Object *obj, const char *value,
417 Error **errp)
418 {
419 InputLinux *il = INPUT_LINUX(obj);
420
421 if (il->evdev) {
422 error_setg(errp, "evdev property already set");
423 return;
424 }
425 il->evdev = g_strdup(value);
426 }
427
428 static bool input_linux_get_grab_all(Object *obj, Error **errp)
429 {
430 InputLinux *il = INPUT_LINUX(obj);
431
432 return il->grab_all;
433 }
434
435 static void input_linux_set_grab_all(Object *obj, bool value,
436 Error **errp)
437 {
438 InputLinux *il = INPUT_LINUX(obj);
439
440 il->grab_all = value;
441 }
442
443 static bool input_linux_get_repeat(Object *obj, Error **errp)
444 {
445 InputLinux *il = INPUT_LINUX(obj);
446
447 return il->repeat;
448 }
449
450 static void input_linux_set_repeat(Object *obj, bool value,
451 Error **errp)
452 {
453 InputLinux *il = INPUT_LINUX(obj);
454
455 il->repeat = value;
456 }
457
458 static int input_linux_get_grab_toggle(Object *obj, Error **errp)
459 {
460 InputLinux *il = INPUT_LINUX(obj);
461
462 return il->grab_toggle;
463 }
464
465 static void input_linux_set_grab_toggle(Object *obj, int value,
466 Error **errp)
467 {
468 InputLinux *il = INPUT_LINUX(obj);
469
470 il->grab_toggle = value;
471 }
472
473 static void input_linux_instance_init(Object *obj)
474 {
475 object_property_add_str(obj, "evdev",
476 input_linux_get_evdev,
477 input_linux_set_evdev, NULL);
478 object_property_add_bool(obj, "grab_all",
479 input_linux_get_grab_all,
480 input_linux_set_grab_all, NULL);
481 object_property_add_bool(obj, "repeat",
482 input_linux_get_repeat,
483 input_linux_set_repeat, NULL);
484 object_property_add_enum(obj, "grab-toggle", "GrabToggleKeys",
485 &GrabToggleKeys_lookup,
486 input_linux_get_grab_toggle,
487 input_linux_set_grab_toggle, NULL);
488 }
489
490 static void input_linux_class_init(ObjectClass *oc, void *data)
491 {
492 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
493
494 ucc->complete = input_linux_complete;
495 }
496
497 static const TypeInfo input_linux_info = {
498 .name = TYPE_INPUT_LINUX,
499 .parent = TYPE_OBJECT,
500 .class_size = sizeof(InputLinuxClass),
501 .class_init = input_linux_class_init,
502 .instance_size = sizeof(InputLinux),
503 .instance_init = input_linux_instance_init,
504 .instance_finalize = input_linux_instance_finalize,
505 .interfaces = (InterfaceInfo[]) {
506 { TYPE_USER_CREATABLE },
507 { }
508 }
509 };
510
511 static void register_types(void)
512 {
513 type_register_static(&input_linux_info);
514 }
515
516 type_init(register_types);