ui/input-linux.c

   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 "ui/input.h"
  14 #include "qom/object_interfaces.h"
  15 #include "sysemu/iothread.h"
  16 #include "block/aio.h"
  17
  18 #include <sys/ioctl.h>
  19 #include "standard-headers/linux/input.h"
  20 #include "qom/object.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 OBJECT_DECLARE_SIMPLE_TYPE(InputLinux,
  35                            INPUT_LINUX)
  36
  37
  38 struct InputLinux {
  39     Object parent;
  40
  41     char        *evdev;
  42     int         fd;
  43     bool        repeat;
  44     bool        grab_request;
  45     bool        grab_active;
  46     bool        grab_all;
  47     bool        keydown[KEY_CNT];
  48     int         keycount;
  49     int         wheel;
  50     bool        initialized;
  51
  52     bool        has_rel_x;
  53     bool        has_abs_x;
  54     int         num_keys;
  55     int         num_btns;
  56     int         abs_x_min;
  57     int         abs_x_max;
  58     int         abs_y_min;
  59     int         abs_y_max;
  60     struct input_event event;
  61     int         read_offset;
  62
  63     enum GrabToggleKeys grab_toggle;
  64
  65     QTAILQ_ENTRY(InputLinux) next;
  66 };
  67
  68
  69 static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs);
  70
  71 static void input_linux_toggle_grab(InputLinux *il)
  72 {
  73     intptr_t request = !il->grab_active;
  74     InputLinux *item;
  75     int rc;
  76
  77     rc = ioctl(il->fd, EVIOCGRAB, request);
  78     if (rc < 0) {
  79         return;
  80     }
  81     il->grab_active = !il->grab_active;
  82
  83     if (!il->grab_all) {
  84         return;
  85     }
  86     QTAILQ_FOREACH(item, &inputs, next) {
  87         if (item == il || item->grab_all) {
  88             /* avoid endless loops */
  89             continue;
  90         }
  91         if (item->grab_active != il->grab_active) {
  92             input_linux_toggle_grab(item);
  93         }
  94     }
  95 }
  96
  97 static bool input_linux_check_toggle(InputLinux *il)
  98 {
  99     switch (il->grab_toggle) {
 100     case GRAB_TOGGLE_KEYS_CTRL_CTRL:
 101         return il->keydown[KEY_LEFTCTRL] &&
 102             il->keydown[KEY_RIGHTCTRL];
 103
 104     case GRAB_TOGGLE_KEYS_ALT_ALT:
 105         return il->keydown[KEY_LEFTALT] &&
 106             il->keydown[KEY_RIGHTALT];
 107
 108     case GRAB_TOGGLE_KEYS_SHIFT_SHIFT:
 109         return il->keydown[KEY_LEFTSHIFT] &&
 110             il->keydown[KEY_RIGHTSHIFT];
 111
 112     case GRAB_TOGGLE_KEYS_META_META:
 113         return il->keydown[KEY_LEFTMETA] &&
 114             il->keydown[KEY_RIGHTMETA];
 115
 116     case GRAB_TOGGLE_KEYS_SCROLLLOCK:
 117         return il->keydown[KEY_SCROLLLOCK];
 118
 119     case GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK:
 120         return (il->keydown[KEY_LEFTCTRL] ||
 121                 il->keydown[KEY_RIGHTCTRL]) &&
 122             il->keydown[KEY_SCROLLLOCK];
 123
 124     case GRAB_TOGGLE_KEYS__MAX:
 125         /* avoid gcc error */
 126         break;
 127     }
 128     return false;
 129 }
 130
 131 static bool input_linux_should_skip(InputLinux *il,
 132                                     struct input_event *event)
 133 {
 134     return (il->grab_toggle == GRAB_TOGGLE_KEYS_SCROLLLOCK ||
 135             il->grab_toggle == GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK) &&
 136             event->code == KEY_SCROLLLOCK;
 137 }
 138
 139 static void input_linux_handle_keyboard(InputLinux *il,
 140                                         struct input_event *event)
 141 {
 142     if (event->type == EV_KEY) {
 143         if (event->value > 2 || (event->value > 1 && !il->repeat)) {
 144             /*
 145              * ignore autorepeat + unknown key events
 146              * 0 == up, 1 == down, 2 == autorepeat, other == undefined
 147              */
 148             return;
 149         }
 150         if (event->code >= KEY_CNT) {
 151             /*
 152              * Should not happen.  But better safe than sorry,
 153              * and we make Coverity happy too.
 154              */
 155             return;
 156         }
 157
 158         /* keep track of key state */
 159         if (!il->keydown[event->code] && event->value) {
 160             il->keydown[event->code] = true;
 161             il->keycount++;
 162         }
 163         if (il->keydown[event->code] && !event->value) {
 164             il->keydown[event->code] = false;
 165             il->keycount--;
 166         }
 167
 168         /* send event to guest when grab is active */
 169         if (il->grab_active && !input_linux_should_skip(il, event)) {
 170             int qcode = qemu_input_linux_to_qcode(event->code);
 171             qemu_input_event_send_key_qcode(NULL, qcode, event->value);
 172         }
 173
 174         /* hotkey -> record switch request ... */
 175         if (input_linux_check_toggle(il)) {
 176             il->grab_request = true;
 177         }
 178
 179         /*
 180          * ... and do the switch when all keys are lifted, so we
 181          * confuse neither guest nor host with keys which seem to
 182          * be stuck due to missing key-up events.
 183          */
 184         if (il->grab_request && !il->keycount) {
 185             il->grab_request = false;
 186             input_linux_toggle_grab(il);
 187         }
 188     }
 189 }
 190
 191 static void input_linux_event_mouse_button(int button)
 192 {
 193     qemu_input_queue_btn(NULL, button, true);
 194     qemu_input_event_sync();
 195     qemu_input_queue_btn(NULL, button, false);
 196     qemu_input_event_sync();
 197 }
 198
 199 static void input_linux_handle_mouse(InputLinux *il, struct input_event *event)
 200 {
 201     if (!il->grab_active) {
 202         return;
 203     }
 204
 205     switch (event->type) {
 206     case EV_KEY:
 207         switch (event->code) {
 208         case BTN_LEFT:
 209             qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event->value);
 210             break;
 211         case BTN_RIGHT:
 212             qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event->value);
 213             break;
 214         case BTN_MIDDLE:
 215             qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event->value);
 216             break;
 217         case BTN_GEAR_UP:
 218             qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event->value);
 219             break;
 220         case BTN_GEAR_DOWN:
 221             qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN,
 222                                  event->value);
 223             break;
 224         case BTN_SIDE:
 225             qemu_input_queue_btn(NULL, INPUT_BUTTON_SIDE, event->value);
 226             break;
 227         case BTN_EXTRA:
 228             qemu_input_queue_btn(NULL, INPUT_BUTTON_EXTRA, event->value);
 229             break;
 230         };
 231         break;
 232     case EV_REL:
 233         switch (event->code) {
 234         case REL_X:
 235             qemu_input_queue_rel(NULL, INPUT_AXIS_X, event->value);
 236             break;
 237         case REL_Y:
 238             qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event->value);
 239             break;
 240         case REL_WHEEL:
 241             il->wheel = event->value;
 242             break;
 243         }
 244         break;
 245     case EV_ABS:
 246         switch (event->code) {
 247         case ABS_X:
 248             qemu_input_queue_abs(NULL, INPUT_AXIS_X, event->value,
 249                                  il->abs_x_min, il->abs_x_max);
 250             break;
 251         case ABS_Y:
 252             qemu_input_queue_abs(NULL, INPUT_AXIS_Y, event->value,
 253                                  il->abs_y_min, il->abs_y_max);
 254             break;
 255         }
 256         break;
 257     case EV_SYN:
 258         qemu_input_event_sync();
 259         if (il->wheel != 0) {
 260             input_linux_event_mouse_button((il->wheel > 0)
 261                                            ? INPUT_BUTTON_WHEEL_UP
 262                                            : INPUT_BUTTON_WHEEL_DOWN);
 263             il->wheel = 0;
 264         }
 265         break;
 266     }
 267 }
 268
 269 static void input_linux_event(void *opaque)
 270 {
 271     InputLinux *il = opaque;
 272     int rc;
 273     int read_size;
 274     uint8_t *p = (uint8_t *)&il->event;
 275
 276     for (;;) {
 277         read_size = sizeof(il->event) - il->read_offset;
 278         rc = read(il->fd, &p[il->read_offset], read_size);
 279         if (rc != read_size) {
 280             if (rc < 0 && errno != EAGAIN) {
 281                 fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
 282                 qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
 283                 close(il->fd);
 284             } else if (rc > 0) {
 285                 il->read_offset += rc;
 286             }
 287             break;
 288         }
 289         il->read_offset = 0;
 290
 291         if (il->num_keys) {
 292             input_linux_handle_keyboard(il, &il->event);
 293         }
 294         if ((il->has_rel_x || il->has_abs_x) && il->num_btns) {
 295             input_linux_handle_mouse(il, &il->event);
 296         }
 297     }
 298 }
 299
 300 static void input_linux_complete(UserCreatable *uc, Error **errp)
 301 {
 302     InputLinux *il = INPUT_LINUX(uc);
 303     uint8_t evtmap, relmap, absmap;
 304     uint8_t keymap[KEY_CNT / 8], keystate[KEY_CNT / 8];
 305     unsigned int i;
 306     int rc, ver;
 307     struct input_absinfo absinfo;
 308
 309     if (!il->evdev) {
 310         error_setg(errp, "no input device specified");
 311         return;
 312     }
 313
 314     il->fd = open(il->evdev, O_RDWR);
 315     if (il->fd < 0)  {
 316         error_setg_file_open(errp, errno, il->evdev);
 317         return;
 318     }
 319     if (!g_unix_set_fd_nonblocking(il->fd, true, NULL)) {
 320         error_setg_errno(errp, errno, "Failed to set FD nonblocking");
 321         return;
 322     }
 323
 324     rc = ioctl(il->fd, EVIOCGVERSION, &ver);
 325     if (rc < 0) {
 326         error_setg(errp, "%s: is not an evdev device", il->evdev);
 327         goto err_close;
 328     }
 329
 330     rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap);
 331     if (rc < 0) {
 332         goto err_read_event_bits;
 333     }
 334
 335     if (evtmap & (1 << EV_REL)) {
 336         relmap = 0;
 337         rc = ioctl(il->fd, EVIOCGBIT(EV_REL, sizeof(relmap)), &relmap);
 338         if (rc < 0) {
 339             goto err_read_event_bits;
 340         }
 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 (rc < 0) {
 350             goto err_read_event_bits;
 351         }
 352         if (absmap & (1 << ABS_X)) {
 353             il->has_abs_x = true;
 354             rc = ioctl(il->fd, EVIOCGABS(ABS_X), &absinfo);
 355             if (rc < 0) {
 356                 error_setg(errp, "%s: failed to get get absolute X value",
 357                            il->evdev);
 358                 goto err_close;
 359             }
 360             il->abs_x_min = absinfo.minimum;
 361             il->abs_x_max = absinfo.maximum;
 362             rc = ioctl(il->fd, EVIOCGABS(ABS_Y), &absinfo);
 363             if (rc < 0) {
 364                 error_setg(errp, "%s: failed to get get absolute Y value",
 365                            il->evdev);
 366                 goto err_close;
 367             }
 368             il->abs_y_min = absinfo.minimum;
 369             il->abs_y_max = absinfo.maximum;
 370         }
 371     }
 372
 373     if (evtmap & (1 << EV_KEY)) {
 374         memset(keymap, 0, sizeof(keymap));
 375         rc = ioctl(il->fd, EVIOCGBIT(EV_KEY, sizeof(keymap)), keymap);
 376         if (rc < 0) {
 377             goto err_read_event_bits;
 378         }
 379         rc = ioctl(il->fd, EVIOCGKEY(sizeof(keystate)), keystate);
 380         if (rc < 0) {
 381             error_setg(errp, "%s: failed to get global key state", il->evdev);
 382             goto err_close;
 383         }
 384         for (i = 0; i < KEY_CNT; i++) {
 385             if (keymap[i / 8] & (1 << (i % 8))) {
 386                 if (linux_is_button(i)) {
 387                     il->num_btns++;
 388                 } else {
 389                     il->num_keys++;
 390                 }
 391                 if (keystate[i / 8] & (1 << (i % 8))) {
 392                     il->keydown[i] = true;
 393                     il->keycount++;
 394                 }
 395             }
 396         }
 397     }
 398
 399     qemu_set_fd_handler(il->fd, input_linux_event, NULL, il);
 400     if (il->keycount) {
 401         /* delay grab until all keys are released */
 402         il->grab_request = true;
 403     } else {
 404         input_linux_toggle_grab(il);
 405     }
 406     QTAILQ_INSERT_TAIL(&inputs, il, next);
 407     il->initialized = true;
 408     return;
 409
 410 err_read_event_bits:
 411     error_setg(errp, "%s: failed to read event bits", il->evdev);
 412
 413 err_close:
 414     close(il->fd);
 415     return;
 416 }
 417
 418 static void input_linux_instance_finalize(Object *obj)
 419 {
 420     InputLinux *il = INPUT_LINUX(obj);
 421
 422     if (il->initialized) {
 423         QTAILQ_REMOVE(&inputs, il, next);
 424         qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
 425         close(il->fd);
 426     }
 427     g_free(il->evdev);
 428 }
 429
 430 static char *input_linux_get_evdev(Object *obj, Error **errp)
 431 {
 432     InputLinux *il = INPUT_LINUX(obj);
 433
 434     return g_strdup(il->evdev);
 435 }
 436
 437 static void input_linux_set_evdev(Object *obj, const char *value,
 438                                   Error **errp)
 439 {
 440     InputLinux *il = INPUT_LINUX(obj);
 441
 442     if (il->evdev) {
 443         error_setg(errp, "evdev property already set");
 444         return;
 445     }
 446     il->evdev = g_strdup(value);
 447 }
 448
 449 static bool input_linux_get_grab_all(Object *obj, Error **errp)
 450 {
 451     InputLinux *il = INPUT_LINUX(obj);
 452
 453     return il->grab_all;
 454 }
 455
 456 static void input_linux_set_grab_all(Object *obj, bool value,
 457                                    Error **errp)
 458 {
 459     InputLinux *il = INPUT_LINUX(obj);
 460
 461     il->grab_all = value;
 462 }
 463
 464 static bool input_linux_get_repeat(Object *obj, Error **errp)
 465 {
 466     InputLinux *il = INPUT_LINUX(obj);
 467
 468     return il->repeat;
 469 }
 470
 471 static void input_linux_set_repeat(Object *obj, bool value,
 472                                    Error **errp)
 473 {
 474     InputLinux *il = INPUT_LINUX(obj);
 475
 476     il->repeat = value;
 477 }
 478
 479 static int input_linux_get_grab_toggle(Object *obj, Error **errp)
 480 {
 481     InputLinux *il = INPUT_LINUX(obj);
 482
 483     return il->grab_toggle;
 484 }
 485
 486 static void input_linux_set_grab_toggle(Object *obj, int value,
 487                                        Error **errp)
 488 {
 489     InputLinux *il = INPUT_LINUX(obj);
 490
 491     il->grab_toggle = value;
 492 }
 493
 494 static void input_linux_instance_init(Object *obj)
 495 {
 496 }
 497
 498 static void input_linux_class_init(ObjectClass *oc, void *data)
 499 {
 500     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 501
 502     ucc->complete = input_linux_complete;
 503
 504     object_class_property_add_str(oc, "evdev",
 505                                   input_linux_get_evdev,
 506                                   input_linux_set_evdev);
 507     object_class_property_add_bool(oc, "grab_all",
 508                                    input_linux_get_grab_all,
 509                                    input_linux_set_grab_all);
 510     object_class_property_add_bool(oc, "repeat",
 511                                    input_linux_get_repeat,
 512                                    input_linux_set_repeat);
 513     object_class_property_add_enum(oc, "grab-toggle", "GrabToggleKeys",
 514                                    &GrabToggleKeys_lookup,
 515                                    input_linux_get_grab_toggle,
 516                                    input_linux_set_grab_toggle);
 517 }
 518
 519 static const TypeInfo input_linux_info = {
 520     .name = TYPE_INPUT_LINUX,
 521     .parent = TYPE_OBJECT,
 522     .class_init = input_linux_class_init,
 523     .instance_size = sizeof(InputLinux),
 524     .instance_init = input_linux_instance_init,
 525     .instance_finalize = input_linux_instance_finalize,
 526     .interfaces = (InterfaceInfo[]) {
 527         { TYPE_USER_CREATABLE },
 528         { }
 529     }
 530 };
 531
 532 static void register_types(void)
 533 {
 534     type_register_static(&input_linux_info);
 535 }
 536
 537 type_init(register_types);