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