input.c - qemu - FORK: QEMU emulator

input.c (17105B)
      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      * need 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     MouseInfo *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(MouseInfo, 1);
    585         info->index = s->id;
    586         info->name = g_strdup(s->handler->name);
    587         info->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
    588         info->current = current;
    589 
    590         current = false;
    591         QAPI_LIST_PREPEND(mice_list, info);
    592     }
    593 
    594     return mice_list;
    595 }
    596 
    597 void hmp_mouse_set(Monitor *mon, const QDict *qdict)
    598 {
    599     QemuInputHandlerState *s;
    600     int index = qdict_get_int(qdict, "index");
    601     int found = 0;
    602 
    603     QTAILQ_FOREACH(s, &handlers, node) {
    604         if (s->id != index) {
    605             continue;
    606         }
    607         if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
    608                                   INPUT_EVENT_MASK_ABS))) {
    609             error_report("Input device '%s' is not a mouse", s->handler->name);
    610             return;
    611         }
    612         found = 1;
    613         qemu_input_handler_activate(s);
    614         break;
    615     }
    616 
    617     if (!found) {
    618         error_report("Mouse at index '%d' not found", index);
    619     }
    620 
    621     qemu_input_check_mode_change();
    622 }
	qemu FORK: QEMU emulator
	git clone https://git.neptards.moe/neptards/qemu.git
	Log \| Files \| Refs \| Submodules \| LICENSE