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