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-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);