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