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