ui/input.c

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