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