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