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