]>
Commit | Line | Data |
---|---|---|
e0d2bd51 GH |
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 | ||
14 | #include <sys/ioctl.h> | |
15 | #include "standard-headers/linux/input.h" | |
16 | ||
17 | static int linux_to_qcode[KEY_CNT] = { | |
18 | [KEY_ESC] = Q_KEY_CODE_ESC, | |
19 | [KEY_1] = Q_KEY_CODE_1, | |
20 | [KEY_2] = Q_KEY_CODE_2, | |
21 | [KEY_3] = Q_KEY_CODE_3, | |
22 | [KEY_4] = Q_KEY_CODE_4, | |
23 | [KEY_5] = Q_KEY_CODE_5, | |
24 | [KEY_6] = Q_KEY_CODE_6, | |
25 | [KEY_7] = Q_KEY_CODE_7, | |
26 | [KEY_8] = Q_KEY_CODE_8, | |
27 | [KEY_9] = Q_KEY_CODE_9, | |
28 | [KEY_0] = Q_KEY_CODE_0, | |
29 | [KEY_MINUS] = Q_KEY_CODE_MINUS, | |
30 | [KEY_EQUAL] = Q_KEY_CODE_EQUAL, | |
31 | [KEY_BACKSPACE] = Q_KEY_CODE_BACKSPACE, | |
32 | [KEY_TAB] = Q_KEY_CODE_TAB, | |
33 | [KEY_Q] = Q_KEY_CODE_Q, | |
34 | [KEY_W] = Q_KEY_CODE_W, | |
35 | [KEY_E] = Q_KEY_CODE_E, | |
36 | [KEY_R] = Q_KEY_CODE_R, | |
37 | [KEY_T] = Q_KEY_CODE_T, | |
38 | [KEY_Y] = Q_KEY_CODE_Y, | |
39 | [KEY_U] = Q_KEY_CODE_U, | |
40 | [KEY_I] = Q_KEY_CODE_I, | |
41 | [KEY_O] = Q_KEY_CODE_O, | |
42 | [KEY_P] = Q_KEY_CODE_P, | |
43 | [KEY_LEFTBRACE] = Q_KEY_CODE_BRACKET_LEFT, | |
44 | [KEY_RIGHTBRACE] = Q_KEY_CODE_BRACKET_RIGHT, | |
45 | [KEY_ENTER] = Q_KEY_CODE_RET, | |
46 | [KEY_LEFTCTRL] = Q_KEY_CODE_CTRL, | |
47 | [KEY_A] = Q_KEY_CODE_A, | |
48 | [KEY_S] = Q_KEY_CODE_S, | |
49 | [KEY_D] = Q_KEY_CODE_D, | |
50 | [KEY_F] = Q_KEY_CODE_F, | |
51 | [KEY_G] = Q_KEY_CODE_G, | |
52 | [KEY_H] = Q_KEY_CODE_H, | |
53 | [KEY_J] = Q_KEY_CODE_J, | |
54 | [KEY_K] = Q_KEY_CODE_K, | |
55 | [KEY_L] = Q_KEY_CODE_L, | |
56 | [KEY_SEMICOLON] = Q_KEY_CODE_SEMICOLON, | |
57 | [KEY_APOSTROPHE] = Q_KEY_CODE_APOSTROPHE, | |
58 | [KEY_GRAVE] = Q_KEY_CODE_GRAVE_ACCENT, | |
59 | [KEY_LEFTSHIFT] = Q_KEY_CODE_SHIFT, | |
60 | [KEY_BACKSLASH] = Q_KEY_CODE_BACKSLASH, | |
61 | [KEY_102ND] = Q_KEY_CODE_LESS, | |
62 | [KEY_Z] = Q_KEY_CODE_Z, | |
63 | [KEY_X] = Q_KEY_CODE_X, | |
64 | [KEY_C] = Q_KEY_CODE_C, | |
65 | [KEY_V] = Q_KEY_CODE_V, | |
66 | [KEY_B] = Q_KEY_CODE_B, | |
67 | [KEY_N] = Q_KEY_CODE_N, | |
68 | [KEY_M] = Q_KEY_CODE_M, | |
69 | [KEY_COMMA] = Q_KEY_CODE_COMMA, | |
70 | [KEY_DOT] = Q_KEY_CODE_DOT, | |
71 | [KEY_SLASH] = Q_KEY_CODE_SLASH, | |
72 | [KEY_RIGHTSHIFT] = Q_KEY_CODE_SHIFT_R, | |
73 | [KEY_LEFTALT] = Q_KEY_CODE_ALT, | |
74 | [KEY_SPACE] = Q_KEY_CODE_SPC, | |
75 | [KEY_CAPSLOCK] = Q_KEY_CODE_CAPS_LOCK, | |
76 | [KEY_F1] = Q_KEY_CODE_F1, | |
77 | [KEY_F2] = Q_KEY_CODE_F2, | |
78 | [KEY_F3] = Q_KEY_CODE_F3, | |
79 | [KEY_F4] = Q_KEY_CODE_F4, | |
80 | [KEY_F5] = Q_KEY_CODE_F5, | |
81 | [KEY_F6] = Q_KEY_CODE_F6, | |
82 | [KEY_F7] = Q_KEY_CODE_F7, | |
83 | [KEY_F8] = Q_KEY_CODE_F8, | |
84 | [KEY_F9] = Q_KEY_CODE_F9, | |
85 | [KEY_F10] = Q_KEY_CODE_F10, | |
86 | [KEY_NUMLOCK] = Q_KEY_CODE_NUM_LOCK, | |
87 | [KEY_SCROLLLOCK] = Q_KEY_CODE_SCROLL_LOCK, | |
88 | [KEY_KP0] = Q_KEY_CODE_KP_0, | |
89 | [KEY_KP1] = Q_KEY_CODE_KP_1, | |
90 | [KEY_KP2] = Q_KEY_CODE_KP_2, | |
91 | [KEY_KP3] = Q_KEY_CODE_KP_3, | |
92 | [KEY_KP4] = Q_KEY_CODE_KP_4, | |
93 | [KEY_KP5] = Q_KEY_CODE_KP_5, | |
94 | [KEY_KP6] = Q_KEY_CODE_KP_6, | |
95 | [KEY_KP7] = Q_KEY_CODE_KP_7, | |
96 | [KEY_KP8] = Q_KEY_CODE_KP_8, | |
97 | [KEY_KP9] = Q_KEY_CODE_KP_9, | |
98 | [KEY_KPMINUS] = Q_KEY_CODE_KP_SUBTRACT, | |
99 | [KEY_KPPLUS] = Q_KEY_CODE_KP_ADD, | |
100 | [KEY_KPDOT] = Q_KEY_CODE_KP_DECIMAL, | |
101 | [KEY_KPENTER] = Q_KEY_CODE_KP_ENTER, | |
102 | [KEY_KPSLASH] = Q_KEY_CODE_KP_DIVIDE, | |
103 | [KEY_KPASTERISK] = Q_KEY_CODE_KP_MULTIPLY, | |
104 | [KEY_F11] = Q_KEY_CODE_F11, | |
105 | [KEY_F12] = Q_KEY_CODE_F12, | |
106 | [KEY_RIGHTCTRL] = Q_KEY_CODE_CTRL_R, | |
107 | [KEY_SYSRQ] = Q_KEY_CODE_SYSRQ, | |
108 | [KEY_RIGHTALT] = Q_KEY_CODE_ALT_R, | |
109 | [KEY_HOME] = Q_KEY_CODE_HOME, | |
110 | [KEY_UP] = Q_KEY_CODE_UP, | |
111 | [KEY_PAGEUP] = Q_KEY_CODE_PGUP, | |
112 | [KEY_LEFT] = Q_KEY_CODE_LEFT, | |
113 | [KEY_RIGHT] = Q_KEY_CODE_RIGHT, | |
114 | [KEY_END] = Q_KEY_CODE_END, | |
115 | [KEY_DOWN] = Q_KEY_CODE_DOWN, | |
116 | [KEY_PAGEDOWN] = Q_KEY_CODE_PGDN, | |
117 | [KEY_INSERT] = Q_KEY_CODE_INSERT, | |
118 | [KEY_DELETE] = Q_KEY_CODE_DELETE, | |
119 | [KEY_LEFTMETA] = Q_KEY_CODE_META_L, | |
120 | [KEY_RIGHTMETA] = Q_KEY_CODE_META_R, | |
121 | [KEY_MENU] = Q_KEY_CODE_MENU, | |
122 | }; | |
123 | ||
124 | static int qemu_input_linux_to_qcode(unsigned int lnx) | |
125 | { | |
126 | assert(lnx < KEY_CNT); | |
127 | return linux_to_qcode[lnx]; | |
128 | } | |
129 | ||
130 | typedef struct InputLinux InputLinux; | |
131 | ||
132 | struct InputLinux { | |
133 | const char *evdev; | |
134 | int fd; | |
a6ccabd6 | 135 | bool repeat; |
e0d2bd51 GH |
136 | bool grab_request; |
137 | bool grab_active; | |
46d921be | 138 | bool grab_all; |
e0d2bd51 GH |
139 | bool keydown[KEY_CNT]; |
140 | int keycount; | |
141 | int wheel; | |
46d921be | 142 | QTAILQ_ENTRY(InputLinux) next; |
e0d2bd51 GH |
143 | }; |
144 | ||
46d921be GH |
145 | static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs); |
146 | ||
e0d2bd51 GH |
147 | static void input_linux_toggle_grab(InputLinux *il) |
148 | { | |
149 | intptr_t request = !il->grab_active; | |
46d921be | 150 | InputLinux *item; |
e0d2bd51 GH |
151 | int rc; |
152 | ||
153 | rc = ioctl(il->fd, EVIOCGRAB, request); | |
154 | if (rc < 0) { | |
155 | return; | |
156 | } | |
157 | il->grab_active = !il->grab_active; | |
46d921be GH |
158 | |
159 | if (!il->grab_all) { | |
160 | return; | |
161 | } | |
162 | QTAILQ_FOREACH(item, &inputs, next) { | |
163 | if (item == il || item->grab_all) { | |
164 | /* avoid endless loops */ | |
165 | continue; | |
166 | } | |
167 | if (item->grab_active != il->grab_active) { | |
168 | input_linux_toggle_grab(item); | |
169 | } | |
170 | } | |
e0d2bd51 GH |
171 | } |
172 | ||
173 | static void input_linux_event_keyboard(void *opaque) | |
174 | { | |
175 | InputLinux *il = opaque; | |
176 | struct input_event event; | |
177 | int rc; | |
178 | ||
179 | for (;;) { | |
180 | rc = read(il->fd, &event, sizeof(event)); | |
181 | if (rc != sizeof(event)) { | |
182 | if (rc < 0 && errno != EAGAIN) { | |
183 | fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno)); | |
184 | qemu_set_fd_handler(il->fd, NULL, NULL, NULL); | |
185 | close(il->fd); | |
186 | } | |
187 | break; | |
188 | } | |
189 | ||
190 | switch (event.type) { | |
191 | case EV_KEY: | |
a6ccabd6 | 192 | if (event.value > 2 || (event.value > 1 && !il->repeat)) { |
e0d2bd51 GH |
193 | /* |
194 | * ignore autorepeat + unknown key events | |
195 | * 0 == up, 1 == down, 2 == autorepeat, other == undefined | |
196 | */ | |
197 | continue; | |
198 | } | |
199 | /* keep track of key state */ | |
200 | if (!il->keydown[event.code] && event.value) { | |
201 | il->keydown[event.code] = true; | |
202 | il->keycount++; | |
203 | } | |
204 | if (il->keydown[event.code] && !event.value) { | |
205 | il->keydown[event.code] = false; | |
206 | il->keycount--; | |
207 | } | |
208 | ||
209 | /* send event to guest when grab is active */ | |
210 | if (il->grab_active) { | |
211 | int qcode = qemu_input_linux_to_qcode(event.code); | |
212 | qemu_input_event_send_key_qcode(NULL, qcode, event.value); | |
213 | } | |
214 | ||
215 | /* hotkey -> record switch request ... */ | |
216 | if (il->keydown[KEY_LEFTCTRL] && | |
217 | il->keydown[KEY_RIGHTCTRL]) { | |
218 | il->grab_request = true; | |
219 | } | |
220 | ||
221 | /* | |
222 | * ... and do the switch when all keys are lifted, so we | |
223 | * confuse neither guest nor host with keys which seem to | |
224 | * be stuck due to missing key-up events. | |
225 | */ | |
226 | if (il->grab_request && !il->keycount) { | |
227 | il->grab_request = false; | |
228 | input_linux_toggle_grab(il); | |
229 | } | |
230 | break; | |
231 | } | |
232 | } | |
233 | } | |
234 | ||
235 | static void input_linux_event_mouse_button(int button) | |
236 | { | |
237 | qemu_input_queue_btn(NULL, button, true); | |
238 | qemu_input_event_sync(); | |
239 | qemu_input_queue_btn(NULL, button, false); | |
240 | qemu_input_event_sync(); | |
241 | } | |
242 | ||
243 | static void input_linux_event_mouse(void *opaque) | |
244 | { | |
245 | InputLinux *il = opaque; | |
246 | struct input_event event; | |
247 | int rc; | |
248 | ||
249 | for (;;) { | |
250 | rc = read(il->fd, &event, sizeof(event)); | |
251 | if (rc != sizeof(event)) { | |
252 | if (rc < 0 && errno != EAGAIN) { | |
253 | fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno)); | |
254 | qemu_set_fd_handler(il->fd, NULL, NULL, NULL); | |
255 | close(il->fd); | |
256 | } | |
257 | break; | |
258 | } | |
259 | ||
46d921be GH |
260 | /* only send event to guest when grab is active */ |
261 | if (!il->grab_active) { | |
262 | continue; | |
263 | } | |
264 | ||
e0d2bd51 GH |
265 | switch (event.type) { |
266 | case EV_KEY: | |
267 | switch (event.code) { | |
268 | case BTN_LEFT: | |
269 | qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event.value); | |
270 | break; | |
271 | case BTN_RIGHT: | |
272 | qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event.value); | |
273 | break; | |
274 | case BTN_MIDDLE: | |
275 | qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event.value); | |
276 | break; | |
277 | case BTN_GEAR_UP: | |
278 | qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event.value); | |
279 | break; | |
280 | case BTN_GEAR_DOWN: | |
281 | qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN, | |
282 | event.value); | |
283 | break; | |
284 | }; | |
285 | break; | |
286 | case EV_REL: | |
287 | switch (event.code) { | |
288 | case REL_X: | |
289 | qemu_input_queue_rel(NULL, INPUT_AXIS_X, event.value); | |
290 | break; | |
291 | case REL_Y: | |
292 | qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event.value); | |
293 | break; | |
294 | case REL_WHEEL: | |
295 | il->wheel = event.value; | |
296 | break; | |
297 | } | |
298 | break; | |
299 | case EV_SYN: | |
300 | qemu_input_event_sync(); | |
301 | if (il->wheel != 0) { | |
302 | input_linux_event_mouse_button((il->wheel > 0) | |
303 | ? INPUT_BUTTON_WHEEL_UP | |
304 | : INPUT_BUTTON_WHEEL_DOWN); | |
305 | il->wheel = 0; | |
306 | } | |
307 | break; | |
308 | } | |
309 | } | |
310 | } | |
311 | ||
312 | int input_linux_init(void *opaque, QemuOpts *opts, Error **errp) | |
313 | { | |
314 | InputLinux *il = g_new0(InputLinux, 1); | |
315 | uint32_t evtmap; | |
316 | int rc, ver; | |
317 | ||
318 | il->evdev = qemu_opt_get(opts, "evdev"); | |
46d921be | 319 | il->grab_all = qemu_opt_get_bool(opts, "grab-all", false); |
a6ccabd6 | 320 | il->repeat = qemu_opt_get_bool(opts, "repeat", false); |
46d921be | 321 | |
e0d2bd51 GH |
322 | if (!il->evdev) { |
323 | error_setg(errp, "no input device specified"); | |
324 | goto err_free; | |
325 | } | |
326 | ||
327 | il->fd = open(il->evdev, O_RDWR); | |
328 | if (il->fd < 0) { | |
329 | error_setg_file_open(errp, errno, il->evdev); | |
330 | goto err_free; | |
331 | } | |
332 | qemu_set_nonblock(il->fd); | |
333 | ||
334 | rc = ioctl(il->fd, EVIOCGVERSION, &ver); | |
335 | if (rc < 0) { | |
336 | error_setg(errp, "%s: is not an evdev device", il->evdev); | |
337 | goto err_close; | |
338 | } | |
339 | ||
340 | rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap); | |
341 | ||
342 | if (evtmap & (1 << EV_REL)) { | |
343 | /* has relative axis -> assume mouse */ | |
344 | qemu_set_fd_handler(il->fd, input_linux_event_mouse, NULL, il); | |
345 | } else if (evtmap & (1 << EV_ABS)) { | |
346 | /* has absolute axis -> not supported */ | |
347 | error_setg(errp, "tablet/touchscreen not supported"); | |
348 | goto err_close; | |
349 | } else if (evtmap & (1 << EV_KEY)) { | |
350 | /* has keys/buttons (and no axis) -> assume keyboard */ | |
351 | qemu_set_fd_handler(il->fd, input_linux_event_keyboard, NULL, il); | |
352 | } else { | |
353 | /* Huh? What is this? */ | |
354 | error_setg(errp, "unknown kind of input device"); | |
355 | goto err_close; | |
356 | } | |
357 | input_linux_toggle_grab(il); | |
46d921be | 358 | QTAILQ_INSERT_TAIL(&inputs, il, next); |
e0d2bd51 GH |
359 | return 0; |
360 | ||
361 | err_close: | |
362 | close(il->fd); | |
363 | err_free: | |
364 | g_free(il); | |
365 | return -1; | |
366 | } | |
367 | ||
368 | static QemuOptsList qemu_input_linux_opts = { | |
369 | .name = "input-linux", | |
370 | .head = QTAILQ_HEAD_INITIALIZER(qemu_input_linux_opts.head), | |
371 | .implied_opt_name = "evdev", | |
372 | .desc = { | |
373 | { | |
374 | .name = "evdev", | |
375 | .type = QEMU_OPT_STRING, | |
46d921be GH |
376 | },{ |
377 | .name = "grab-all", | |
378 | .type = QEMU_OPT_BOOL, | |
a6ccabd6 GH |
379 | },{ |
380 | .name = "repeat", | |
381 | .type = QEMU_OPT_BOOL, | |
e0d2bd51 GH |
382 | }, |
383 | { /* end of list */ } | |
384 | }, | |
385 | }; | |
386 | ||
387 | static void input_linux_register_config(void) | |
388 | { | |
389 | qemu_add_opts(&qemu_input_linux_opts); | |
390 | } | |
34294e2f | 391 | opts_init(input_linux_register_config); |