ui/input.c

   1 #include "qemu/osdep.h"
   2 #include "hw/qdev.h"
   3 #include "sysemu/sysemu.h"
   4 #include "qapi-types.h"
   5 #include "qemu/error-report.h"
   6 #include "qmp-commands.h"
   7 #include "trace.h"
   8 #include "ui/input.h"
   9 #include "ui/console.h"
  10 #include "sysemu/replay.h"
  11
  12 struct QemuInputHandlerState {
  13     DeviceState       *dev;
  14     QemuInputHandler  *handler;
  15     int               id;
  16     int               events;
  17     QemuConsole       *con;
  18     QTAILQ_ENTRY(QemuInputHandlerState) node;
  19 };
  20
  21 typedef struct QemuInputEventQueue QemuInputEventQueue;
  22 struct QemuInputEventQueue {
  23     enum {
  24         QEMU_INPUT_QUEUE_DELAY = 1,
  25         QEMU_INPUT_QUEUE_EVENT,
  26         QEMU_INPUT_QUEUE_SYNC,
  27     } type;
  28     QEMUTimer *timer;
  29     uint32_t delay_ms;
  30     QemuConsole *src;
  31     InputEvent *evt;
  32     QTAILQ_ENTRY(QemuInputEventQueue) node;
  33 };
  34
  35 static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
  36     QTAILQ_HEAD_INITIALIZER(handlers);
  37 static NotifierList mouse_mode_notifiers =
  38     NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
  39
  40 static QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue) kbd_queue =
  41     QTAILQ_HEAD_INITIALIZER(kbd_queue);
  42 static QEMUTimer *kbd_timer;
  43 static uint32_t kbd_default_delay_ms = 10;
  44 static uint32_t queue_count;
  45 static uint32_t queue_limit = 1024;
  46
  47 QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev,
  48                                                    QemuInputHandler *handler)
  49 {
  50     QemuInputHandlerState *s = g_new0(QemuInputHandlerState, 1);
  51     static int id = 1;
  52
  53     s->dev = dev;
  54     s->handler = handler;
  55     s->id = id++;
  56     QTAILQ_INSERT_TAIL(&handlers, s, node);
  57
  58     qemu_input_check_mode_change();
  59     return s;
  60 }
  61
  62 void qemu_input_handler_activate(QemuInputHandlerState *s)
  63 {
  64     QTAILQ_REMOVE(&handlers, s, node);
  65     QTAILQ_INSERT_HEAD(&handlers, s, node);
  66     qemu_input_check_mode_change();
  67 }
  68
  69 void qemu_input_handler_deactivate(QemuInputHandlerState *s)
  70 {
  71     QTAILQ_REMOVE(&handlers, s, node);
  72     QTAILQ_INSERT_TAIL(&handlers, s, node);
  73     qemu_input_check_mode_change();
  74 }
  75
  76 void qemu_input_handler_unregister(QemuInputHandlerState *s)
  77 {
  78     QTAILQ_REMOVE(&handlers, s, node);
  79     g_free(s);
  80     qemu_input_check_mode_change();
  81 }
  82
  83 void qemu_input_handler_bind(QemuInputHandlerState *s,
  84                              const char *device_id, int head,
  85                              Error **errp)
  86 {
  87     QemuConsole *con;
  88     Error *err = NULL;
  89
  90     con = qemu_console_lookup_by_device_name(device_id, head, &err);
  91     if (err) {
  92         error_propagate(errp, err);
  93         return;
  94     }
  95
  96     s->con = con;
  97 }
  98
  99 static QemuInputHandlerState*
 100 qemu_input_find_handler(uint32_t mask, QemuConsole *con)
 101 {
 102     QemuInputHandlerState *s;
 103
 104     QTAILQ_FOREACH(s, &handlers, node) {
 105         if (s->con == NULL || s->con != con) {
 106             continue;
 107         }
 108         if (mask & s->handler->mask) {
 109             return s;
 110         }
 111     }
 112
 113     QTAILQ_FOREACH(s, &handlers, node) {
 114         if (s->con != NULL) {
 115             continue;
 116         }
 117         if (mask & s->handler->mask) {
 118             return s;
 119         }
 120     }
 121     return NULL;
 122 }
 123
 124 void qmp_input_send_event(bool has_device, const char *device,
 125                           bool has_head, int64_t head,
 126                           InputEventList *events, Error **errp)
 127 {
 128     InputEventList *e;
 129     QemuConsole *con;
 130     Error *err = NULL;
 131
 132     con = NULL;
 133     if (has_device) {
 134         if (!has_head) {
 135             head = 0;
 136         }
 137         con = qemu_console_lookup_by_device_name(device, head, &err);
 138         if (err) {
 139             error_propagate(errp, err);
 140             return;
 141         }
 142     }
 143
 144     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 145         error_setg(errp, "VM not running");
 146         return;
 147     }
 148
 149     for (e = events; e != NULL; e = e->next) {
 150         InputEvent *event = e->value;
 151
 152         if (!qemu_input_find_handler(1 << event->type, con)) {
 153             error_setg(errp, "Input handler not found for "
 154                              "event type %s",
 155                             InputEventKind_lookup[event->type]);
 156             return;
 157         }
 158     }
 159
 160     for (e = events; e != NULL; e = e->next) {
 161         InputEvent *event = e->value;
 162
 163         qemu_input_event_send(con, event);
 164     }
 165
 166     qemu_input_event_sync();
 167 }
 168
 169 static void qemu_input_transform_abs_rotate(InputEvent *evt)
 170 {
 171     InputMoveEvent *move = evt->u.abs.data;
 172     switch (graphic_rotate) {
 173     case 90:
 174         if (move->axis == INPUT_AXIS_X) {
 175             move->axis = INPUT_AXIS_Y;
 176         } else if (move->axis == INPUT_AXIS_Y) {
 177             move->axis = INPUT_AXIS_X;
 178             move->value = INPUT_EVENT_ABS_SIZE - 1 - move->value;
 179         }
 180         break;
 181     case 180:
 182         move->value = INPUT_EVENT_ABS_SIZE - 1 - move->value;
 183         break;
 184     case 270:
 185         if (move->axis == INPUT_AXIS_X) {
 186             move->axis = INPUT_AXIS_Y;
 187             move->value = INPUT_EVENT_ABS_SIZE - 1 - move->value;
 188         } else if (move->axis == INPUT_AXIS_Y) {
 189             move->axis = INPUT_AXIS_X;
 190         }
 191         break;
 192     }
 193 }
 194
 195 static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
 196 {
 197     const char *name;
 198     int qcode, idx = -1;
 199     InputKeyEvent *key;
 200     InputBtnEvent *btn;
 201     InputMoveEvent *move;
 202
 203     if (src) {
 204         idx = qemu_console_get_index(src);
 205     }
 206     switch (evt->type) {
 207     case INPUT_EVENT_KIND_KEY:
 208         key = evt->u.key.data;
 209         switch (key->key->type) {
 210         case KEY_VALUE_KIND_NUMBER:
 211             qcode = qemu_input_key_number_to_qcode(key->key->u.number.data);
 212             name = QKeyCode_lookup[qcode];
 213             trace_input_event_key_number(idx, key->key->u.number.data,
 214                                          name, key->down);
 215             break;
 216         case KEY_VALUE_KIND_QCODE:
 217             name = QKeyCode_lookup[key->key->u.qcode.data];
 218             trace_input_event_key_qcode(idx, name, key->down);
 219             break;
 220         case KEY_VALUE_KIND__MAX:
 221             /* keep gcc happy */
 222             break;
 223         }
 224         break;
 225     case INPUT_EVENT_KIND_BTN:
 226         btn = evt->u.btn.data;
 227         name = InputButton_lookup[btn->button];
 228         trace_input_event_btn(idx, name, btn->down);
 229         break;
 230     case INPUT_EVENT_KIND_REL:
 231         move = evt->u.rel.data;
 232         name = InputAxis_lookup[move->axis];
 233         trace_input_event_rel(idx, name, move->value);
 234         break;
 235     case INPUT_EVENT_KIND_ABS:
 236         move = evt->u.abs.data;
 237         name = InputAxis_lookup[move->axis];
 238         trace_input_event_abs(idx, name, move->value);
 239         break;
 240     case INPUT_EVENT_KIND__MAX:
 241         /* keep gcc happy */
 242         break;
 243     }
 244 }
 245
 246 static void qemu_input_queue_process(void *opaque)
 247 {
 248     struct QemuInputEventQueueHead *queue = opaque;
 249     QemuInputEventQueue *item;
 250
 251     g_assert(!QTAILQ_EMPTY(queue));
 252     item = QTAILQ_FIRST(queue);
 253     g_assert(item->type == QEMU_INPUT_QUEUE_DELAY);
 254     QTAILQ_REMOVE(queue, item, node);
 255     g_free(item);
 256
 257     while (!QTAILQ_EMPTY(queue)) {
 258         item = QTAILQ_FIRST(queue);
 259         switch (item->type) {
 260         case QEMU_INPUT_QUEUE_DELAY:
 261             timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
 262                       + item->delay_ms);
 263             return;
 264         case QEMU_INPUT_QUEUE_EVENT:
 265             qemu_input_event_send(item->src, item->evt);
 266             qapi_free_InputEvent(item->evt);
 267             break;
 268         case QEMU_INPUT_QUEUE_SYNC:
 269             qemu_input_event_sync();
 270             break;
 271         }
 272         QTAILQ_REMOVE(queue, item, node);
 273         queue_count--;
 274         g_free(item);
 275     }
 276 }
 277
 278 static void qemu_input_queue_delay(struct QemuInputEventQueueHead *queue,
 279                                    QEMUTimer *timer, uint32_t delay_ms)
 280 {
 281     QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
 282     bool start_timer = QTAILQ_EMPTY(queue);
 283
 284     item->type = QEMU_INPUT_QUEUE_DELAY;
 285     item->delay_ms = delay_ms;
 286     item->timer = timer;
 287     QTAILQ_INSERT_TAIL(queue, item, node);
 288     queue_count++;
 289
 290     if (start_timer) {
 291         timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
 292                   + item->delay_ms);
 293     }
 294 }
 295
 296 static void qemu_input_queue_event(struct QemuInputEventQueueHead *queue,
 297                                    QemuConsole *src, InputEvent *evt)
 298 {
 299     QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
 300
 301     item->type = QEMU_INPUT_QUEUE_EVENT;
 302     item->src = src;
 303     item->evt = evt;
 304     QTAILQ_INSERT_TAIL(queue, item, node);
 305     queue_count++;
 306 }
 307
 308 static void qemu_input_queue_sync(struct QemuInputEventQueueHead *queue)
 309 {
 310     QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
 311
 312     item->type = QEMU_INPUT_QUEUE_SYNC;
 313     QTAILQ_INSERT_TAIL(queue, item, node);
 314     queue_count++;
 315 }
 316
 317 void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt)
 318 {
 319     QemuInputHandlerState *s;
 320
 321     qemu_input_event_trace(src, evt);
 322
 323     /* pre processing */
 324     if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) {
 325             qemu_input_transform_abs_rotate(evt);
 326     }
 327
 328     /* send event */
 329     s = qemu_input_find_handler(1 << evt->type, src);
 330     if (!s) {
 331         return;
 332     }
 333     s->handler->event(s->dev, src, evt);
 334     s->events++;
 335 }
 336
 337 void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
 338 {
 339     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 340         return;
 341     }
 342
 343     replay_input_event(src, evt);
 344 }
 345
 346 void qemu_input_event_sync_impl(void)
 347 {
 348     QemuInputHandlerState *s;
 349
 350     trace_input_event_sync();
 351
 352     QTAILQ_FOREACH(s, &handlers, node) {
 353         if (!s->events) {
 354             continue;
 355         }
 356         if (s->handler->sync) {
 357             s->handler->sync(s->dev);
 358         }
 359         s->events = 0;
 360     }
 361 }
 362
 363 void qemu_input_event_sync(void)
 364 {
 365     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 366         return;
 367     }
 368
 369     replay_input_sync_event();
 370 }
 371
 372 InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
 373 {
 374     InputEvent *evt = g_new0(InputEvent, 1);
 375     evt->u.key.data = g_new0(InputKeyEvent, 1);
 376     evt->type = INPUT_EVENT_KIND_KEY;
 377     evt->u.key.data->key = key;
 378     evt->u.key.data->down = down;
 379     return evt;
 380 }
 381
 382 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
 383 {
 384     InputEvent *evt;
 385     evt = qemu_input_event_new_key(key, down);
 386     if (QTAILQ_EMPTY(&kbd_queue)) {
 387         qemu_input_event_send(src, evt);
 388         qemu_input_event_sync();
 389         qapi_free_InputEvent(evt);
 390     } else if (queue_count < queue_limit) {
 391         qemu_input_queue_event(&kbd_queue, src, evt);
 392         qemu_input_queue_sync(&kbd_queue);
 393     }
 394 }
 395
 396 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
 397 {
 398     KeyValue *key = g_new0(KeyValue, 1);
 399     key->type = KEY_VALUE_KIND_NUMBER;
 400     key->u.number.data = num;
 401     qemu_input_event_send_key(src, key, down);
 402 }
 403
 404 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
 405 {
 406     KeyValue *key = g_new0(KeyValue, 1);
 407     key->type = KEY_VALUE_KIND_QCODE;
 408     key->u.qcode.data = q;
 409     qemu_input_event_send_key(src, key, down);
 410 }
 411
 412 void qemu_input_event_send_key_delay(uint32_t delay_ms)
 413 {
 414     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 415         return;
 416     }
 417
 418     if (!kbd_timer) {
 419         kbd_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, qemu_input_queue_process,
 420                                  &kbd_queue);
 421     }
 422     if (queue_count < queue_limit) {
 423         qemu_input_queue_delay(&kbd_queue, kbd_timer,
 424                                delay_ms ? delay_ms : kbd_default_delay_ms);
 425     }
 426 }
 427
 428 InputEvent *qemu_input_event_new_btn(InputButton btn, bool down)
 429 {
 430     InputEvent *evt = g_new0(InputEvent, 1);
 431     evt->u.btn.data = g_new0(InputBtnEvent, 1);
 432     evt->type = INPUT_EVENT_KIND_BTN;
 433     evt->u.btn.data->button = btn;
 434     evt->u.btn.data->down = down;
 435     return evt;
 436 }
 437
 438 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
 439 {
 440     InputEvent *evt;
 441     evt = qemu_input_event_new_btn(btn, down);
 442     qemu_input_event_send(src, evt);
 443     qapi_free_InputEvent(evt);
 444 }
 445
 446 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
 447                                uint32_t button_old, uint32_t button_new)
 448 {
 449     InputButton btn;
 450     uint32_t mask;
 451
 452     for (btn = 0; btn < INPUT_BUTTON__MAX; btn++) {
 453         mask = button_map[btn];
 454         if ((button_old & mask) == (button_new & mask)) {
 455             continue;
 456         }
 457         qemu_input_queue_btn(src, btn, button_new & mask);
 458     }
 459 }
 460
 461 bool qemu_input_is_absolute(void)
 462 {
 463     QemuInputHandlerState *s;
 464
 465     s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
 466                                 NULL);
 467     return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
 468 }
 469
 470 int qemu_input_scale_axis(int value, int size_in, int size_out)
 471 {
 472     if (size_in < 2) {
 473         return size_out / 2;
 474     }
 475     return (int64_t)value * (size_out - 1) / (size_in - 1);
 476 }
 477
 478 InputEvent *qemu_input_event_new_move(InputEventKind kind,
 479                                       InputAxis axis, int value)
 480 {
 481     InputEvent *evt = g_new0(InputEvent, 1);
 482     InputMoveEvent *move = g_new0(InputMoveEvent, 1);
 483
 484     evt->type = kind;
 485     evt->u.rel.data = move; /* evt->u.rel is the same as evt->u.abs */
 486     move->axis = axis;
 487     move->value = value;
 488     return evt;
 489 }
 490
 491 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
 492 {
 493     InputEvent *evt;
 494     evt = qemu_input_event_new_move(INPUT_EVENT_KIND_REL, axis, value);
 495     qemu_input_event_send(src, evt);
 496     qapi_free_InputEvent(evt);
 497 }
 498
 499 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value, int size)
 500 {
 501     InputEvent *evt;
 502     int scaled = qemu_input_scale_axis(value, size, INPUT_EVENT_ABS_SIZE);
 503     evt = qemu_input_event_new_move(INPUT_EVENT_KIND_ABS, axis, scaled);
 504     qemu_input_event_send(src, evt);
 505     qapi_free_InputEvent(evt);
 506 }
 507
 508 void qemu_input_check_mode_change(void)
 509 {
 510     static int current_is_absolute;
 511     int is_absolute;
 512
 513     is_absolute = qemu_input_is_absolute();
 514
 515     if (is_absolute != current_is_absolute) {
 516         trace_input_mouse_mode(is_absolute);
 517         notifier_list_notify(&mouse_mode_notifiers, NULL);
 518     }
 519
 520     current_is_absolute = is_absolute;
 521 }
 522
 523 void qemu_add_mouse_mode_change_notifier(Notifier *notify)
 524 {
 525     notifier_list_add(&mouse_mode_notifiers, notify);
 526 }
 527
 528 void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
 529 {
 530     notifier_remove(notify);
 531 }
 532
 533 MouseInfoList *qmp_query_mice(Error **errp)
 534 {
 535     MouseInfoList *mice_list = NULL;
 536     MouseInfoList *info;
 537     QemuInputHandlerState *s;
 538     bool current = true;
 539
 540     QTAILQ_FOREACH(s, &handlers, node) {
 541         if (!(s->handler->mask &
 542               (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
 543             continue;
 544         }
 545
 546         info = g_new0(MouseInfoList, 1);
 547         info->value = g_new0(MouseInfo, 1);
 548         info->value->index = s->id;
 549         info->value->name = g_strdup(s->handler->name);
 550         info->value->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
 551         info->value->current = current;
 552
 553         current = false;
 554         info->next = mice_list;
 555         mice_list = info;
 556     }
 557
 558     return mice_list;
 559 }
 560
 561 void hmp_mouse_set(Monitor *mon, const QDict *qdict)
 562 {
 563     QemuInputHandlerState *s;
 564     int index = qdict_get_int(qdict, "index");
 565     int found = 0;
 566
 567     QTAILQ_FOREACH(s, &handlers, node) {
 568         if (s->id != index) {
 569             continue;
 570         }
 571         if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
 572                                   INPUT_EVENT_MASK_ABS))) {
 573             error_report("Input device '%s' is not a mouse", s->handler->name);
 574             return;
 575         }
 576         found = 1;
 577         qemu_input_handler_activate(s);
 578         break;
 579     }
 580
 581     if (!found) {
 582         error_report("Mouse at index '%d' not found", index);
 583     }
 584
 585     qemu_input_check_mode_change();
 586 }