xref: /qemu/ui/input-linux.c (revision f18f2e7cfcdc31d7f82af15947aae60c4b16e131)
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-common.h"
9 #include "qemu/config-file.h"
10 #include "qemu/sockets.h"
11 #include "sysemu/sysemu.h"
12 #include "ui/input.h"
13 #include "qom/object_interfaces.h"
14 
15 #include <sys/ioctl.h>
16 #include "standard-headers/linux/input.h"
17 
18 static int linux_to_qcode[KEY_CNT] = {
19     [KEY_ESC]            = Q_KEY_CODE_ESC,
20     [KEY_1]              = Q_KEY_CODE_1,
21     [KEY_2]              = Q_KEY_CODE_2,
22     [KEY_3]              = Q_KEY_CODE_3,
23     [KEY_4]              = Q_KEY_CODE_4,
24     [KEY_5]              = Q_KEY_CODE_5,
25     [KEY_6]              = Q_KEY_CODE_6,
26     [KEY_7]              = Q_KEY_CODE_7,
27     [KEY_8]              = Q_KEY_CODE_8,
28     [KEY_9]              = Q_KEY_CODE_9,
29     [KEY_0]              = Q_KEY_CODE_0,
30     [KEY_MINUS]          = Q_KEY_CODE_MINUS,
31     [KEY_EQUAL]          = Q_KEY_CODE_EQUAL,
32     [KEY_BACKSPACE]      = Q_KEY_CODE_BACKSPACE,
33     [KEY_TAB]            = Q_KEY_CODE_TAB,
34     [KEY_Q]              = Q_KEY_CODE_Q,
35     [KEY_W]              = Q_KEY_CODE_W,
36     [KEY_E]              = Q_KEY_CODE_E,
37     [KEY_R]              = Q_KEY_CODE_R,
38     [KEY_T]              = Q_KEY_CODE_T,
39     [KEY_Y]              = Q_KEY_CODE_Y,
40     [KEY_U]              = Q_KEY_CODE_U,
41     [KEY_I]              = Q_KEY_CODE_I,
42     [KEY_O]              = Q_KEY_CODE_O,
43     [KEY_P]              = Q_KEY_CODE_P,
44     [KEY_LEFTBRACE]      = Q_KEY_CODE_BRACKET_LEFT,
45     [KEY_RIGHTBRACE]     = Q_KEY_CODE_BRACKET_RIGHT,
46     [KEY_ENTER]          = Q_KEY_CODE_RET,
47     [KEY_LEFTCTRL]       = Q_KEY_CODE_CTRL,
48     [KEY_A]              = Q_KEY_CODE_A,
49     [KEY_S]              = Q_KEY_CODE_S,
50     [KEY_D]              = Q_KEY_CODE_D,
51     [KEY_F]              = Q_KEY_CODE_F,
52     [KEY_G]              = Q_KEY_CODE_G,
53     [KEY_H]              = Q_KEY_CODE_H,
54     [KEY_J]              = Q_KEY_CODE_J,
55     [KEY_K]              = Q_KEY_CODE_K,
56     [KEY_L]              = Q_KEY_CODE_L,
57     [KEY_SEMICOLON]      = Q_KEY_CODE_SEMICOLON,
58     [KEY_APOSTROPHE]     = Q_KEY_CODE_APOSTROPHE,
59     [KEY_GRAVE]          = Q_KEY_CODE_GRAVE_ACCENT,
60     [KEY_LEFTSHIFT]      = Q_KEY_CODE_SHIFT,
61     [KEY_BACKSLASH]      = Q_KEY_CODE_BACKSLASH,
62     [KEY_102ND]          = Q_KEY_CODE_LESS,
63     [KEY_Z]              = Q_KEY_CODE_Z,
64     [KEY_X]              = Q_KEY_CODE_X,
65     [KEY_C]              = Q_KEY_CODE_C,
66     [KEY_V]              = Q_KEY_CODE_V,
67     [KEY_B]              = Q_KEY_CODE_B,
68     [KEY_N]              = Q_KEY_CODE_N,
69     [KEY_M]              = Q_KEY_CODE_M,
70     [KEY_COMMA]          = Q_KEY_CODE_COMMA,
71     [KEY_DOT]            = Q_KEY_CODE_DOT,
72     [KEY_SLASH]          = Q_KEY_CODE_SLASH,
73     [KEY_RIGHTSHIFT]     = Q_KEY_CODE_SHIFT_R,
74     [KEY_LEFTALT]        = Q_KEY_CODE_ALT,
75     [KEY_SPACE]          = Q_KEY_CODE_SPC,
76     [KEY_CAPSLOCK]       = Q_KEY_CODE_CAPS_LOCK,
77     [KEY_F1]             = Q_KEY_CODE_F1,
78     [KEY_F2]             = Q_KEY_CODE_F2,
79     [KEY_F3]             = Q_KEY_CODE_F3,
80     [KEY_F4]             = Q_KEY_CODE_F4,
81     [KEY_F5]             = Q_KEY_CODE_F5,
82     [KEY_F6]             = Q_KEY_CODE_F6,
83     [KEY_F7]             = Q_KEY_CODE_F7,
84     [KEY_F8]             = Q_KEY_CODE_F8,
85     [KEY_F9]             = Q_KEY_CODE_F9,
86     [KEY_F10]            = Q_KEY_CODE_F10,
87     [KEY_NUMLOCK]        = Q_KEY_CODE_NUM_LOCK,
88     [KEY_SCROLLLOCK]     = Q_KEY_CODE_SCROLL_LOCK,
89     [KEY_KP0]            = Q_KEY_CODE_KP_0,
90     [KEY_KP1]            = Q_KEY_CODE_KP_1,
91     [KEY_KP2]            = Q_KEY_CODE_KP_2,
92     [KEY_KP3]            = Q_KEY_CODE_KP_3,
93     [KEY_KP4]            = Q_KEY_CODE_KP_4,
94     [KEY_KP5]            = Q_KEY_CODE_KP_5,
95     [KEY_KP6]            = Q_KEY_CODE_KP_6,
96     [KEY_KP7]            = Q_KEY_CODE_KP_7,
97     [KEY_KP8]            = Q_KEY_CODE_KP_8,
98     [KEY_KP9]            = Q_KEY_CODE_KP_9,
99     [KEY_KPMINUS]        = Q_KEY_CODE_KP_SUBTRACT,
100     [KEY_KPPLUS]         = Q_KEY_CODE_KP_ADD,
101     [KEY_KPDOT]          = Q_KEY_CODE_KP_DECIMAL,
102     [KEY_KPENTER]        = Q_KEY_CODE_KP_ENTER,
103     [KEY_KPSLASH]        = Q_KEY_CODE_KP_DIVIDE,
104     [KEY_KPASTERISK]     = Q_KEY_CODE_KP_MULTIPLY,
105     [KEY_F11]            = Q_KEY_CODE_F11,
106     [KEY_F12]            = Q_KEY_CODE_F12,
107     [KEY_RIGHTCTRL]      = Q_KEY_CODE_CTRL_R,
108     [KEY_SYSRQ]          = Q_KEY_CODE_SYSRQ,
109     [KEY_RIGHTALT]       = Q_KEY_CODE_ALT_R,
110     [KEY_HOME]           = Q_KEY_CODE_HOME,
111     [KEY_UP]             = Q_KEY_CODE_UP,
112     [KEY_PAGEUP]         = Q_KEY_CODE_PGUP,
113     [KEY_LEFT]           = Q_KEY_CODE_LEFT,
114     [KEY_RIGHT]          = Q_KEY_CODE_RIGHT,
115     [KEY_END]            = Q_KEY_CODE_END,
116     [KEY_DOWN]           = Q_KEY_CODE_DOWN,
117     [KEY_PAGEDOWN]       = Q_KEY_CODE_PGDN,
118     [KEY_INSERT]         = Q_KEY_CODE_INSERT,
119     [KEY_DELETE]         = Q_KEY_CODE_DELETE,
120     [KEY_LEFTMETA]       = Q_KEY_CODE_META_L,
121     [KEY_RIGHTMETA]      = Q_KEY_CODE_META_R,
122     [KEY_MENU]           = Q_KEY_CODE_MENU,
123 };
124 
125 static int qemu_input_linux_to_qcode(unsigned int lnx)
126 {
127     assert(lnx < KEY_CNT);
128     return linux_to_qcode[lnx];
129 }
130 
131 #define TYPE_INPUT_LINUX "input-linux"
132 #define INPUT_LINUX(obj) \
133     OBJECT_CHECK(InputLinux, (obj), TYPE_INPUT_LINUX)
134 #define INPUT_LINUX_GET_CLASS(obj) \
135     OBJECT_GET_CLASS(InputLinuxClass, (obj), TYPE_INPUT_LINUX)
136 #define INPUT_LINUX_CLASS(klass) \
137     OBJECT_CLASS_CHECK(InputLinuxClass, (klass), TYPE_INPUT_LINUX)
138 
139 typedef struct InputLinux InputLinux;
140 typedef struct InputLinuxClass InputLinuxClass;
141 
142 struct InputLinux {
143     Object parent;
144 
145     char        *evdev;
146     int         fd;
147     bool        repeat;
148     bool        grab_request;
149     bool        grab_active;
150     bool        grab_all;
151     bool        keydown[KEY_CNT];
152     int         keycount;
153     int         wheel;
154     bool        initialized;
155     QTAILQ_ENTRY(InputLinux) next;
156 };
157 
158 struct InputLinuxClass {
159     ObjectClass parent_class;
160 };
161 
162 static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs);
163 
164 static void input_linux_toggle_grab(InputLinux *il)
165 {
166     intptr_t request = !il->grab_active;
167     InputLinux *item;
168     int rc;
169 
170     rc = ioctl(il->fd, EVIOCGRAB, request);
171     if (rc < 0) {
172         return;
173     }
174     il->grab_active = !il->grab_active;
175 
176     if (!il->grab_all) {
177         return;
178     }
179     QTAILQ_FOREACH(item, &inputs, next) {
180         if (item == il || item->grab_all) {
181             /* avoid endless loops */
182             continue;
183         }
184         if (item->grab_active != il->grab_active) {
185             input_linux_toggle_grab(item);
186         }
187     }
188 }
189 
190 static void input_linux_event_keyboard(void *opaque)
191 {
192     InputLinux *il = opaque;
193     struct input_event event;
194     int rc;
195 
196     for (;;) {
197         rc = read(il->fd, &event, sizeof(event));
198         if (rc != sizeof(event)) {
199             if (rc < 0 && errno != EAGAIN) {
200                 fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
201                 qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
202                 close(il->fd);
203             }
204             break;
205         }
206 
207         switch (event.type) {
208         case EV_KEY:
209             if (event.value > 2 || (event.value > 1 && !il->repeat)) {
210                 /*
211                  * ignore autorepeat + unknown key events
212                  * 0 == up, 1 == down, 2 == autorepeat, other == undefined
213                  */
214                 continue;
215             }
216             if (event.code >= KEY_CNT) {
217                 /*
218                  * Should not happen.  But better safe than sorry,
219                  * and we make Coverity happy too.
220                  */
221                 continue;
222             }
223             /* keep track of key state */
224             if (!il->keydown[event.code] && event.value) {
225                 il->keydown[event.code] = true;
226                 il->keycount++;
227             }
228             if (il->keydown[event.code] && !event.value) {
229                 il->keydown[event.code] = false;
230                 il->keycount--;
231             }
232 
233             /* send event to guest when grab is active */
234             if (il->grab_active) {
235                 int qcode = qemu_input_linux_to_qcode(event.code);
236                 qemu_input_event_send_key_qcode(NULL, qcode, event.value);
237             }
238 
239             /* hotkey -> record switch request ... */
240             if (il->keydown[KEY_LEFTCTRL] &&
241                 il->keydown[KEY_RIGHTCTRL]) {
242                 il->grab_request = true;
243             }
244 
245             /*
246              * ... and do the switch when all keys are lifted, so we
247              * confuse neither guest nor host with keys which seem to
248              * be stuck due to missing key-up events.
249              */
250             if (il->grab_request && !il->keycount) {
251                 il->grab_request = false;
252                 input_linux_toggle_grab(il);
253             }
254             break;
255         }
256     }
257 }
258 
259 static void input_linux_event_mouse_button(int button)
260 {
261     qemu_input_queue_btn(NULL, button, true);
262     qemu_input_event_sync();
263     qemu_input_queue_btn(NULL, button, false);
264     qemu_input_event_sync();
265 }
266 
267 static void input_linux_event_mouse(void *opaque)
268 {
269     InputLinux *il = opaque;
270     struct input_event event;
271     int rc;
272 
273     for (;;) {
274         rc = read(il->fd, &event, sizeof(event));
275         if (rc != sizeof(event)) {
276             if (rc < 0 && errno != EAGAIN) {
277                 fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
278                 qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
279                 close(il->fd);
280             }
281             break;
282         }
283 
284         /* only send event to guest when grab is active */
285         if (!il->grab_active) {
286             continue;
287         }
288 
289         switch (event.type) {
290         case EV_KEY:
291             switch (event.code) {
292             case BTN_LEFT:
293                 qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event.value);
294                 break;
295             case BTN_RIGHT:
296                 qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event.value);
297                 break;
298             case BTN_MIDDLE:
299                 qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event.value);
300                 break;
301             case BTN_GEAR_UP:
302                 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event.value);
303                 break;
304             case BTN_GEAR_DOWN:
305                 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN,
306                                      event.value);
307                 break;
308             };
309             break;
310         case EV_REL:
311             switch (event.code) {
312             case REL_X:
313                 qemu_input_queue_rel(NULL, INPUT_AXIS_X, event.value);
314                 break;
315             case REL_Y:
316                 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event.value);
317                 break;
318             case REL_WHEEL:
319                 il->wheel = event.value;
320                 break;
321             }
322             break;
323         case EV_SYN:
324             qemu_input_event_sync();
325             if (il->wheel != 0) {
326                 input_linux_event_mouse_button((il->wheel > 0)
327                                                ? INPUT_BUTTON_WHEEL_UP
328                                                : INPUT_BUTTON_WHEEL_DOWN);
329                 il->wheel = 0;
330             }
331             break;
332         }
333     }
334 }
335 
336 static void input_linux_complete(UserCreatable *uc, Error **errp)
337 {
338     InputLinux *il = INPUT_LINUX(uc);
339     uint32_t evtmap;
340     int rc, ver;
341 
342     if (!il->evdev) {
343         error_setg(errp, "no input device specified");
344         return;
345     }
346 
347     il->fd = open(il->evdev, O_RDWR);
348     if (il->fd < 0)  {
349         error_setg_file_open(errp, errno, il->evdev);
350         return;
351     }
352     qemu_set_nonblock(il->fd);
353 
354     rc = ioctl(il->fd, EVIOCGVERSION, &ver);
355     if (rc < 0) {
356         error_setg(errp, "%s: is not an evdev device", il->evdev);
357         goto err_close;
358     }
359 
360     rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap);
361 
362     if (evtmap & (1 << EV_REL)) {
363         /* has relative axis -> assume mouse */
364         qemu_set_fd_handler(il->fd, input_linux_event_mouse, NULL, il);
365     } else if (evtmap & (1 << EV_ABS)) {
366         /* has absolute axis -> not supported */
367         error_setg(errp, "tablet/touchscreen not supported");
368         goto err_close;
369     } else if (evtmap & (1 << EV_KEY)) {
370         /* has keys/buttons (and no axis) -> assume keyboard */
371         qemu_set_fd_handler(il->fd, input_linux_event_keyboard, NULL, il);
372     } else {
373         /* Huh? What is this? */
374         error_setg(errp, "unknown kind of input device");
375         goto err_close;
376     }
377     input_linux_toggle_grab(il);
378     QTAILQ_INSERT_TAIL(&inputs, il, next);
379     il->initialized = true;
380     return;
381 
382 err_close:
383     close(il->fd);
384     return;
385 }
386 
387 static void input_linux_instance_finalize(Object *obj)
388 {
389     InputLinux *il = INPUT_LINUX(obj);
390 
391     if (il->initialized) {
392         QTAILQ_REMOVE(&inputs, il, next);
393         close(il->fd);
394     }
395     g_free(il->evdev);
396 }
397 
398 static char *input_linux_get_evdev(Object *obj, Error **errp)
399 {
400     InputLinux *il = INPUT_LINUX(obj);
401 
402     return g_strdup(il->evdev);
403 }
404 
405 static void input_linux_set_evdev(Object *obj, const char *value,
406                                   Error **errp)
407 {
408     InputLinux *il = INPUT_LINUX(obj);
409 
410     if (il->evdev) {
411         error_setg(errp, "evdev property already set");
412         return;
413     }
414     il->evdev = g_strdup(value);
415 }
416 
417 static bool input_linux_get_grab_all(Object *obj, Error **errp)
418 {
419     InputLinux *il = INPUT_LINUX(obj);
420 
421     return il->grab_all;
422 }
423 
424 static void input_linux_set_grab_all(Object *obj, bool value,
425                                    Error **errp)
426 {
427     InputLinux *il = INPUT_LINUX(obj);
428 
429     il->grab_all = value;
430 }
431 
432 static bool input_linux_get_repeat(Object *obj, Error **errp)
433 {
434     InputLinux *il = INPUT_LINUX(obj);
435 
436     return il->repeat;
437 }
438 
439 static void input_linux_set_repeat(Object *obj, bool value,
440                                    Error **errp)
441 {
442     InputLinux *il = INPUT_LINUX(obj);
443 
444     il->repeat = value;
445 }
446 
447 static void input_linux_instance_init(Object *obj)
448 {
449     object_property_add_str(obj, "evdev",
450                             input_linux_get_evdev,
451                             input_linux_set_evdev, NULL);
452     object_property_add_bool(obj, "grab_all",
453                              input_linux_get_grab_all,
454                              input_linux_set_grab_all, NULL);
455     object_property_add_bool(obj, "repeat",
456                              input_linux_get_repeat,
457                              input_linux_set_repeat, NULL);
458 }
459 
460 static void input_linux_class_init(ObjectClass *oc, void *data)
461 {
462     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
463 
464     ucc->complete = input_linux_complete;
465 }
466 
467 static const TypeInfo input_linux_info = {
468     .name = TYPE_INPUT_LINUX,
469     .parent = TYPE_OBJECT,
470     .class_size = sizeof(InputLinuxClass),
471     .class_init = input_linux_class_init,
472     .instance_size = sizeof(InputLinux),
473     .instance_init = input_linux_instance_init,
474     .instance_finalize = input_linux_instance_finalize,
475     .interfaces = (InterfaceInfo[]) {
476         { TYPE_USER_CREATABLE },
477         { }
478     }
479 };
480 
481 static void register_types(void)
482 {
483     type_register_static(&input_linux_info);
484 }
485 
486 type_init(register_types);
487