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