ui/input.c

   1 #include "qemu/osdep.h"
   2 #include "sysemu/sysemu.h"
   3 #include "qapi/error.h"
   4 #include "qapi/qapi-commands-ui.h"
   5 #include "qapi/qmp/qdict.h"
   6 #include "qemu/error-report.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_str(event->type));
 156             return;
 157         }
 158     }
 159
 160     for (e = events; e != NULL; e = e->next) {
 161         InputEvent *evt = e->value;
 162
 163         if (evt->type == INPUT_EVENT_KIND_KEY &&
 164             evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER) {
 165             KeyValue *key = evt->u.key.data->key;
 166             QKeyCode code = qemu_input_key_number_to_qcode(key->u.number.data);
 167             qemu_input_event_send_key_qcode(con, code, evt->u.key.data->down);
 168         } else {
 169             qemu_input_event_send(con, evt);
 170         }
 171     }
 172
 173     qemu_input_event_sync();
 174 }
 175
 176 static int qemu_input_transform_invert_abs_value(int value)
 177 {
 178   return (int64_t)INPUT_EVENT_ABS_MAX - value + INPUT_EVENT_ABS_MIN;
 179 }
 180
 181 static void qemu_input_transform_abs_rotate(InputEvent *evt)
 182 {
 183     InputMoveEvent *move = evt->u.abs.data;
 184     switch (graphic_rotate) {
 185     case 90:
 186         if (move->axis == INPUT_AXIS_X) {
 187             move->axis = INPUT_AXIS_Y;
 188         } else if (move->axis == INPUT_AXIS_Y) {
 189             move->axis = INPUT_AXIS_X;
 190             move->value = qemu_input_transform_invert_abs_value(move->value);
 191         }
 192         break;
 193     case 180:
 194         move->value = qemu_input_transform_invert_abs_value(move->value);
 195         break;
 196     case 270:
 197         if (move->axis == INPUT_AXIS_X) {
 198             move->axis = INPUT_AXIS_Y;
 199             move->value = qemu_input_transform_invert_abs_value(move->value);
 200         } else if (move->axis == INPUT_AXIS_Y) {
 201             move->axis = INPUT_AXIS_X;
 202         }
 203         break;
 204     }
 205 }
 206
 207 static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
 208 {
 209     const char *name;
 210     int qcode, idx = -1;
 211     InputKeyEvent *key;
 212     InputBtnEvent *btn;
 213     InputMoveEvent *move;
 214
 215     if (src) {
 216         idx = qemu_console_get_index(src);
 217     }
 218     switch (evt->type) {
 219     case INPUT_EVENT_KIND_KEY:
 220         key = evt->u.key.data;
 221         switch (key->key->type) {
 222         case KEY_VALUE_KIND_NUMBER:
 223             qcode = qemu_input_key_number_to_qcode(key->key->u.number.data);
 224             name = QKeyCode_str(qcode);
 225             trace_input_event_key_number(idx, key->key->u.number.data,
 226                                          name, key->down);
 227             break;
 228         case KEY_VALUE_KIND_QCODE:
 229             name = QKeyCode_str(key->key->u.qcode.data);
 230             trace_input_event_key_qcode(idx, name, key->down);
 231             break;
 232         case KEY_VALUE_KIND__MAX:
 233             /* keep gcc happy */
 234             break;
 235         }
 236         break;
 237     case INPUT_EVENT_KIND_BTN:
 238         btn = evt->u.btn.data;
 239         name = InputButton_str(btn->button);
 240         trace_input_event_btn(idx, name, btn->down);
 241         break;
 242     case INPUT_EVENT_KIND_REL:
 243         move = evt->u.rel.data;
 244         name = InputAxis_str(move->axis);
 245         trace_input_event_rel(idx, name, move->value);
 246         break;
 247     case INPUT_EVENT_KIND_ABS:
 248         move = evt->u.abs.data;
 249         name = InputAxis_str(move->axis);
 250         trace_input_event_abs(idx, name, move->value);
 251         break;
 252     case INPUT_EVENT_KIND__MAX:
 253         /* keep gcc happy */
 254         break;
 255     }
 256 }
 257
 258 static void qemu_input_queue_process(void *opaque)
 259 {
 260     struct QemuInputEventQueueHead *queue = opaque;
 261     QemuInputEventQueue *item;
 262
 263     g_assert(!QTAILQ_EMPTY(queue));
 264     item = QTAILQ_FIRST(queue);
 265     g_assert(item->type == QEMU_INPUT_QUEUE_DELAY);
 266     QTAILQ_REMOVE(queue, item, node);
 267     queue_count--;
 268     g_free(item);
 269
 270     while (!QTAILQ_EMPTY(queue)) {
 271         item = QTAILQ_FIRST(queue);
 272         switch (item->type) {
 273         case QEMU_INPUT_QUEUE_DELAY:
 274             timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
 275                       + item->delay_ms);
 276             return;
 277         case QEMU_INPUT_QUEUE_EVENT:
 278             qemu_input_event_send(item->src, item->evt);
 279             qapi_free_InputEvent(item->evt);
 280             break;
 281         case QEMU_INPUT_QUEUE_SYNC:
 282             qemu_input_event_sync();
 283             break;
 284         }
 285         QTAILQ_REMOVE(queue, item, node);
 286         queue_count--;
 287         g_free(item);
 288     }
 289 }
 290
 291 static void qemu_input_queue_delay(struct QemuInputEventQueueHead *queue,
 292                                    QEMUTimer *timer, uint32_t delay_ms)
 293 {
 294     QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
 295     bool start_timer = QTAILQ_EMPTY(queue);
 296
 297     item->type = QEMU_INPUT_QUEUE_DELAY;
 298     item->delay_ms = delay_ms;
 299     item->timer = timer;
 300     QTAILQ_INSERT_TAIL(queue, item, node);
 301     queue_count++;
 302
 303     if (start_timer) {
 304         timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
 305                   + item->delay_ms);
 306     }
 307 }
 308
 309 static void qemu_input_queue_event(struct QemuInputEventQueueHead *queue,
 310                                    QemuConsole *src, InputEvent *evt)
 311 {
 312     QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
 313
 314     item->type = QEMU_INPUT_QUEUE_EVENT;
 315     item->src = src;
 316     item->evt = evt;
 317     QTAILQ_INSERT_TAIL(queue, item, node);
 318     queue_count++;
 319 }
 320
 321 static void qemu_input_queue_sync(struct QemuInputEventQueueHead *queue)
 322 {
 323     QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
 324
 325     item->type = QEMU_INPUT_QUEUE_SYNC;
 326     QTAILQ_INSERT_TAIL(queue, item, node);
 327     queue_count++;
 328 }
 329
 330 void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt)
 331 {
 332     QemuInputHandlerState *s;
 333
 334     qemu_input_event_trace(src, evt);
 335
 336     /* pre processing */
 337     if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) {
 338             qemu_input_transform_abs_rotate(evt);
 339     }
 340
 341     /* send event */
 342     s = qemu_input_find_handler(1 << evt->type, src);
 343     if (!s) {
 344         return;
 345     }
 346     s->handler->event(s->dev, src, evt);
 347     s->events++;
 348 }
 349
 350 void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
 351 {
 352     /* Expect all parts of QEMU to send events with QCodes exclusively.
 353      * Key numbers are only supported as end-user input via QMP */
 354     assert(!(evt->type == INPUT_EVENT_KIND_KEY &&
 355              evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER));
 356
 357
 358     /*
 359      * 'sysrq' was mistakenly added to hack around the fact that
 360      * the ps2 driver was not generating correct scancodes sequences
 361      * when 'alt+print' was pressed. This flaw is now fixed and the
 362      * 'sysrq' key serves no further purpose. We normalize it to
 363      * 'print', so that downstream receivers of the event don't
 364      * neeed to deal with this mistake
 365      */
 366     if (evt->type == INPUT_EVENT_KIND_KEY &&
 367         evt->u.key.data->key->u.qcode.data == Q_KEY_CODE_SYSRQ) {
 368         evt->u.key.data->key->u.qcode.data = Q_KEY_CODE_PRINT;
 369     }
 370
 371     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 372         return;
 373     }
 374
 375     replay_input_event(src, evt);
 376 }
 377
 378 void qemu_input_event_sync_impl(void)
 379 {
 380     QemuInputHandlerState *s;
 381
 382     trace_input_event_sync();
 383
 384     QTAILQ_FOREACH(s, &handlers, node) {
 385         if (!s->events) {
 386             continue;
 387         }
 388         if (s->handler->sync) {
 389             s->handler->sync(s->dev);
 390         }
 391         s->events = 0;
 392     }
 393 }
 394
 395 void qemu_input_event_sync(void)
 396 {
 397     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 398         return;
 399     }
 400
 401     replay_input_sync_event();
 402 }
 403
 404 static InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
 405 {
 406     InputEvent *evt = g_new0(InputEvent, 1);
 407     evt->u.key.data = g_new0(InputKeyEvent, 1);
 408     evt->type = INPUT_EVENT_KIND_KEY;
 409     evt->u.key.data->key = key;
 410     evt->u.key.data->down = down;
 411     return evt;
 412 }
 413
 414 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
 415 {
 416     InputEvent *evt;
 417     evt = qemu_input_event_new_key(key, down);
 418     if (QTAILQ_EMPTY(&kbd_queue)) {
 419         qemu_input_event_send(src, evt);
 420         qemu_input_event_sync();
 421         qapi_free_InputEvent(evt);
 422     } else if (queue_count < queue_limit) {
 423         qemu_input_queue_event(&kbd_queue, src, evt);
 424         qemu_input_queue_sync(&kbd_queue);
 425     } else {
 426         qapi_free_InputEvent(evt);
 427     }
 428 }
 429
 430 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
 431 {
 432     QKeyCode code = qemu_input_key_number_to_qcode(num);
 433     qemu_input_event_send_key_qcode(src, code, down);
 434 }
 435
 436 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
 437 {
 438     KeyValue *key = g_new0(KeyValue, 1);
 439     key->type = KEY_VALUE_KIND_QCODE;
 440     key->u.qcode.data = q;
 441     qemu_input_event_send_key(src, key, down);
 442 }
 443
 444 void qemu_input_event_send_key_delay(uint32_t delay_ms)
 445 {
 446     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 447         return;
 448     }
 449
 450     if (!kbd_timer) {
 451         kbd_timer = timer_new_full(NULL, QEMU_CLOCK_VIRTUAL,
 452                                    SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
 453                                    qemu_input_queue_process, &kbd_queue);
 454     }
 455     if (queue_count < queue_limit) {
 456         qemu_input_queue_delay(&kbd_queue, kbd_timer,
 457                                delay_ms ? delay_ms : kbd_default_delay_ms);
 458     }
 459 }
 460
 461 InputEvent *qemu_input_event_new_btn(InputButton btn, bool down)
 462 {
 463     InputEvent *evt = g_new0(InputEvent, 1);
 464     evt->u.btn.data = g_new0(InputBtnEvent, 1);
 465     evt->type = INPUT_EVENT_KIND_BTN;
 466     evt->u.btn.data->button = btn;
 467     evt->u.btn.data->down = down;
 468     return evt;
 469 }
 470
 471 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
 472 {
 473     InputEvent *evt;
 474     evt = qemu_input_event_new_btn(btn, down);
 475     qemu_input_event_send(src, evt);
 476     qapi_free_InputEvent(evt);
 477 }
 478
 479 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
 480                                uint32_t button_old, uint32_t button_new)
 481 {
 482     InputButton btn;
 483     uint32_t mask;
 484
 485     for (btn = 0; btn < INPUT_BUTTON__MAX; btn++) {
 486         mask = button_map[btn];
 487         if ((button_old & mask) == (button_new & mask)) {
 488             continue;
 489         }
 490         qemu_input_queue_btn(src, btn, button_new & mask);
 491     }
 492 }
 493
 494 bool qemu_input_is_absolute(void)
 495 {
 496     QemuInputHandlerState *s;
 497
 498     s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
 499                                 NULL);
 500     return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
 501 }
 502
 503 int qemu_input_scale_axis(int value,
 504                           int min_in, int max_in,
 505                           int min_out, int max_out)
 506 {
 507     int64_t range_in = (int64_t)max_in - min_in;
 508     int64_t range_out = (int64_t)max_out - min_out;
 509
 510     if (range_in < 1) {
 511         return min_out + range_out / 2;
 512     }
 513     return ((int64_t)value - min_in) * range_out / range_in + min_out;
 514 }
 515
 516 InputEvent *qemu_input_event_new_move(InputEventKind kind,
 517                                       InputAxis axis, int value)
 518 {
 519     InputEvent *evt = g_new0(InputEvent, 1);
 520     InputMoveEvent *move = g_new0(InputMoveEvent, 1);
 521
 522     evt->type = kind;
 523     evt->u.rel.data = move; /* evt->u.rel is the same as evt->u.abs */
 524     move->axis = axis;
 525     move->value = value;
 526     return evt;
 527 }
 528
 529 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
 530 {
 531     InputEvent *evt;
 532     evt = qemu_input_event_new_move(INPUT_EVENT_KIND_REL, axis, value);
 533     qemu_input_event_send(src, evt);
 534     qapi_free_InputEvent(evt);
 535 }
 536
 537 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value,
 538                           int min_in, int max_in)
 539 {
 540     InputEvent *evt;
 541     int scaled = qemu_input_scale_axis(value, min_in, max_in,
 542                                        INPUT_EVENT_ABS_MIN,
 543                                        INPUT_EVENT_ABS_MAX);
 544     evt = qemu_input_event_new_move(INPUT_EVENT_KIND_ABS, axis, scaled);
 545     qemu_input_event_send(src, evt);
 546     qapi_free_InputEvent(evt);
 547 }
 548
 549 void qemu_input_check_mode_change(void)
 550 {
 551     static int current_is_absolute;
 552     int is_absolute;
 553
 554     is_absolute = qemu_input_is_absolute();
 555
 556     if (is_absolute != current_is_absolute) {
 557         trace_input_mouse_mode(is_absolute);
 558         notifier_list_notify(&mouse_mode_notifiers, NULL);
 559     }
 560
 561     current_is_absolute = is_absolute;
 562 }
 563
 564 void qemu_add_mouse_mode_change_notifier(Notifier *notify)
 565 {
 566     notifier_list_add(&mouse_mode_notifiers, notify);
 567 }
 568
 569 void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
 570 {
 571     notifier_remove(notify);
 572 }
 573
 574 MouseInfoList *qmp_query_mice(Error **errp)
 575 {
 576     MouseInfoList *mice_list = NULL;
 577     MouseInfoList *info;
 578     QemuInputHandlerState *s;
 579     bool current = true;
 580
 581     QTAILQ_FOREACH(s, &handlers, node) {
 582         if (!(s->handler->mask &
 583               (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
 584             continue;
 585         }
 586
 587         info = g_new0(MouseInfoList, 1);
 588         info->value = g_new0(MouseInfo, 1);
 589         info->value->index = s->id;
 590         info->value->name = g_strdup(s->handler->name);
 591         info->value->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
 592         info->value->current = current;
 593
 594         current = false;
 595         info->next = mice_list;
 596         mice_list = info;
 597     }
 598
 599     return mice_list;
 600 }
 601
 602 void hmp_mouse_set(Monitor *mon, const QDict *qdict)
 603 {
 604     QemuInputHandlerState *s;
 605     int index = qdict_get_int(qdict, "index");
 606     int found = 0;
 607
 608     QTAILQ_FOREACH(s, &handlers, node) {
 609         if (s->id != index) {
 610             continue;
 611         }
 612         if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
 613                                   INPUT_EVENT_MASK_ABS))) {
 614             error_report("Input device '%s' is not a mouse", s->handler->name);
 615             return;
 616         }
 617         found = 1;
 618         qemu_input_handler_activate(s);
 619         break;
 620     }
 621
 622     if (!found) {
 623         error_report("Mouse at index '%d' not found", index);
 624     }
 625
 626     qemu_input_check_mode_change();
 627 }