1 #include "qemu/osdep.h"
2 #include "sysemu/sysemu.h"
3 #include "qapi/error.h"
4 #include "qapi/qapi-commands-ui.h"
7 #include "ui/console.h"
8 #include "sysemu/replay.h"
9 #include "sysemu/runstate.h"
11 struct QemuInputHandlerState {
13 QemuInputHandler *handler;
17 QTAILQ_ENTRY(QemuInputHandlerState) node;
20 typedef struct QemuInputEventQueue QemuInputEventQueue;
21 typedef QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue)
22 QemuInputEventQueueHead;
24 struct QemuInputEventQueue {
26 QEMU_INPUT_QUEUE_DELAY = 1,
27 QEMU_INPUT_QUEUE_EVENT,
28 QEMU_INPUT_QUEUE_SYNC,
34 QTAILQ_ENTRY(QemuInputEventQueue) node;
37 static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
38 QTAILQ_HEAD_INITIALIZER(handlers);
39 static NotifierList mouse_mode_notifiers =
40 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
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;
48 QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev,
49 QemuInputHandler *handler)
51 QemuInputHandlerState *s = g_new0(QemuInputHandlerState, 1);
57 QTAILQ_INSERT_TAIL(&handlers, s, node);
59 qemu_input_check_mode_change();
63 void qemu_input_handler_activate(QemuInputHandlerState *s)
65 QTAILQ_REMOVE(&handlers, s, node);
66 QTAILQ_INSERT_HEAD(&handlers, s, node);
67 qemu_input_check_mode_change();
70 void qemu_input_handler_deactivate(QemuInputHandlerState *s)
72 QTAILQ_REMOVE(&handlers, s, node);
73 QTAILQ_INSERT_TAIL(&handlers, s, node);
74 qemu_input_check_mode_change();
77 void qemu_input_handler_unregister(QemuInputHandlerState *s)
79 QTAILQ_REMOVE(&handlers, s, node);
81 qemu_input_check_mode_change();
84 void qemu_input_handler_bind(QemuInputHandlerState *s,
85 const char *device_id, int head,
91 con = qemu_console_lookup_by_device_name(device_id, head, &err);
93 error_propagate(errp, err);
100 static QemuInputHandlerState*
101 qemu_input_find_handler(uint32_t mask, QemuConsole *con)
103 QemuInputHandlerState *s;
105 QTAILQ_FOREACH(s, &handlers, node) {
106 if (s->con == NULL || s->con != con) {
109 if (mask & s->handler->mask) {
114 QTAILQ_FOREACH(s, &handlers, node) {
115 if (s->con != NULL) {
118 if (mask & s->handler->mask) {
125 void qmp_input_send_event(const char *device,
126 bool has_head, int64_t head,
127 InputEventList *events, Error **errp)
138 con = qemu_console_lookup_by_device_name(device, head, &err);
140 error_propagate(errp, err);
145 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
146 error_setg(errp, "VM not running");
150 for (e = events; e != NULL; e = e->next) {
151 InputEvent *event = e->value;
153 if (!qemu_input_find_handler(1 << event->type, con)) {
154 error_setg(errp, "Input handler not found for "
156 InputEventKind_str(event->type));
161 for (e = events; e != NULL; e = e->next) {
162 InputEvent *evt = e->value;
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);
170 qemu_input_event_send(con, evt);
174 qemu_input_event_sync();
177 static int qemu_input_transform_invert_abs_value(int value)
179 return (int64_t)INPUT_EVENT_ABS_MAX - value + INPUT_EVENT_ABS_MIN;
182 static void qemu_input_transform_abs_rotate(InputEvent *evt)
184 InputMoveEvent *move = evt->u.abs.data;
185 switch (graphic_rotate) {
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);
195 move->value = qemu_input_transform_invert_abs_value(move->value);
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;
208 static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
214 InputMoveEvent *move;
215 InputMultiTouchEvent *mtt;
218 idx = qemu_console_get_index(src);
221 case INPUT_EVENT_KIND_KEY:
222 key = evt->u.key.data;
223 switch (key->key->type) {
224 case KEY_VALUE_KIND_NUMBER:
225 qcode = qemu_input_key_number_to_qcode(key->key->u.number.data);
226 name = QKeyCode_str(qcode);
227 trace_input_event_key_number(idx, key->key->u.number.data,
230 case KEY_VALUE_KIND_QCODE:
231 name = QKeyCode_str(key->key->u.qcode.data);
232 trace_input_event_key_qcode(idx, name, key->down);
234 case KEY_VALUE_KIND__MAX:
239 case INPUT_EVENT_KIND_BTN:
240 btn = evt->u.btn.data;
241 name = InputButton_str(btn->button);
242 trace_input_event_btn(idx, name, btn->down);
244 case INPUT_EVENT_KIND_REL:
245 move = evt->u.rel.data;
246 name = InputAxis_str(move->axis);
247 trace_input_event_rel(idx, name, move->value);
249 case INPUT_EVENT_KIND_ABS:
250 move = evt->u.abs.data;
251 name = InputAxis_str(move->axis);
252 trace_input_event_abs(idx, name, move->value);
254 case INPUT_EVENT_KIND_MTT:
255 mtt = evt->u.mtt.data;
256 name = InputAxis_str(mtt->axis);
257 trace_input_event_mtt(idx, name, mtt->value);
259 case INPUT_EVENT_KIND__MAX:
265 static void qemu_input_queue_process(void *opaque)
267 QemuInputEventQueueHead *queue = opaque;
268 QemuInputEventQueue *item;
270 g_assert(!QTAILQ_EMPTY(queue));
271 item = QTAILQ_FIRST(queue);
272 g_assert(item->type == QEMU_INPUT_QUEUE_DELAY);
273 QTAILQ_REMOVE(queue, item, node);
277 while (!QTAILQ_EMPTY(queue)) {
278 item = QTAILQ_FIRST(queue);
279 switch (item->type) {
280 case QEMU_INPUT_QUEUE_DELAY:
281 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
284 case QEMU_INPUT_QUEUE_EVENT:
285 qemu_input_event_send(item->src, item->evt);
286 qapi_free_InputEvent(item->evt);
288 case QEMU_INPUT_QUEUE_SYNC:
289 qemu_input_event_sync();
292 QTAILQ_REMOVE(queue, item, node);
298 static void qemu_input_queue_delay(QemuInputEventQueueHead *queue,
299 QEMUTimer *timer, uint32_t delay_ms)
301 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
302 bool start_timer = QTAILQ_EMPTY(queue);
304 item->type = QEMU_INPUT_QUEUE_DELAY;
305 item->delay_ms = delay_ms;
307 QTAILQ_INSERT_TAIL(queue, item, node);
311 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
316 static void qemu_input_queue_event(QemuInputEventQueueHead *queue,
317 QemuConsole *src, InputEvent *evt)
319 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
321 item->type = QEMU_INPUT_QUEUE_EVENT;
324 QTAILQ_INSERT_TAIL(queue, item, node);
328 static void qemu_input_queue_sync(QemuInputEventQueueHead *queue)
330 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
332 item->type = QEMU_INPUT_QUEUE_SYNC;
333 QTAILQ_INSERT_TAIL(queue, item, node);
337 void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt)
339 QemuInputHandlerState *s;
341 qemu_input_event_trace(src, evt);
344 if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) {
345 qemu_input_transform_abs_rotate(evt);
349 s = qemu_input_find_handler(1 << evt->type, src);
353 s->handler->event(s->dev, src, evt);
357 void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
359 /* Expect all parts of QEMU to send events with QCodes exclusively.
360 * Key numbers are only supported as end-user input via QMP */
361 assert(!(evt->type == INPUT_EVENT_KIND_KEY &&
362 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER));
366 * 'sysrq' was mistakenly added to hack around the fact that
367 * the ps2 driver was not generating correct scancodes sequences
368 * when 'alt+print' was pressed. This flaw is now fixed and the
369 * 'sysrq' key serves no further purpose. We normalize it to
370 * 'print', so that downstream receivers of the event don't
371 * need to deal with this mistake
373 if (evt->type == INPUT_EVENT_KIND_KEY &&
374 evt->u.key.data->key->u.qcode.data == Q_KEY_CODE_SYSRQ) {
375 evt->u.key.data->key->u.qcode.data = Q_KEY_CODE_PRINT;
378 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
382 replay_input_event(src, evt);
385 void qemu_input_event_sync_impl(void)
387 QemuInputHandlerState *s;
389 trace_input_event_sync();
391 QTAILQ_FOREACH(s, &handlers, node) {
395 if (s->handler->sync) {
396 s->handler->sync(s->dev);
402 void qemu_input_event_sync(void)
404 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
408 replay_input_sync_event();
411 static InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
413 InputEvent *evt = g_new0(InputEvent, 1);
414 evt->u.key.data = g_new0(InputKeyEvent, 1);
415 evt->type = INPUT_EVENT_KIND_KEY;
416 evt->u.key.data->key = key;
417 evt->u.key.data->down = down;
421 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
424 evt = qemu_input_event_new_key(key, down);
425 if (QTAILQ_EMPTY(&kbd_queue)) {
426 qemu_input_event_send(src, evt);
427 qemu_input_event_sync();
428 qapi_free_InputEvent(evt);
429 } else if (queue_count < queue_limit) {
430 qemu_input_queue_event(&kbd_queue, src, evt);
431 qemu_input_queue_sync(&kbd_queue);
433 qapi_free_InputEvent(evt);
437 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
439 QKeyCode code = qemu_input_key_number_to_qcode(num);
440 qemu_input_event_send_key_qcode(src, code, down);
443 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
445 KeyValue *key = g_new0(KeyValue, 1);
446 key->type = KEY_VALUE_KIND_QCODE;
447 key->u.qcode.data = q;
448 qemu_input_event_send_key(src, key, down);
451 void qemu_input_event_send_key_delay(uint32_t delay_ms)
453 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
458 kbd_timer = timer_new_full(NULL, QEMU_CLOCK_VIRTUAL,
459 SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
460 qemu_input_queue_process, &kbd_queue);
462 if (queue_count < queue_limit) {
463 qemu_input_queue_delay(&kbd_queue, kbd_timer,
464 delay_ms ? delay_ms : kbd_default_delay_ms);
468 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
470 InputBtnEvent bevt = {
475 .type = INPUT_EVENT_KIND_BTN,
479 qemu_input_event_send(src, &evt);
482 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
483 uint32_t button_old, uint32_t button_new)
488 for (btn = 0; btn < INPUT_BUTTON__MAX; btn++) {
489 mask = button_map[btn];
490 if ((button_old & mask) == (button_new & mask)) {
493 qemu_input_queue_btn(src, btn, button_new & mask);
497 bool qemu_input_is_absolute(void)
499 QemuInputHandlerState *s;
501 s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
503 return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
506 int qemu_input_scale_axis(int value,
507 int min_in, int max_in,
508 int min_out, int max_out)
510 int64_t range_in = (int64_t)max_in - min_in;
511 int64_t range_out = (int64_t)max_out - min_out;
514 return min_out + range_out / 2;
516 return ((int64_t)value - min_in) * range_out / range_in + min_out;
519 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
521 InputMoveEvent move = {
526 .type = INPUT_EVENT_KIND_REL,
530 qemu_input_event_send(src, &evt);
533 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value,
534 int min_in, int max_in)
536 InputMoveEvent move = {
538 .value = qemu_input_scale_axis(value, min_in, max_in,
540 INPUT_EVENT_ABS_MAX),
543 .type = INPUT_EVENT_KIND_ABS,
547 qemu_input_event_send(src, &evt);
550 void qemu_input_queue_mtt(QemuConsole *src, InputMultiTouchType type,
551 int slot, int tracking_id)
553 InputMultiTouchEvent mtt = {
556 .tracking_id = tracking_id,
559 .type = INPUT_EVENT_KIND_MTT,
563 qemu_input_event_send(src, &evt);
566 void qemu_input_queue_mtt_abs(QemuConsole *src, InputAxis axis, int value,
567 int min_in, int max_in, int slot, int tracking_id)
569 InputMultiTouchEvent mtt = {
570 .type = INPUT_MULTI_TOUCH_TYPE_DATA,
572 .tracking_id = tracking_id,
574 .value = qemu_input_scale_axis(value, min_in, max_in,
576 INPUT_EVENT_ABS_MAX),
579 .type = INPUT_EVENT_KIND_MTT,
583 qemu_input_event_send(src, &evt);
586 void qemu_input_check_mode_change(void)
588 static int current_is_absolute;
591 is_absolute = qemu_input_is_absolute();
593 if (is_absolute != current_is_absolute) {
594 trace_input_mouse_mode(is_absolute);
595 notifier_list_notify(&mouse_mode_notifiers, NULL);
598 current_is_absolute = is_absolute;
601 void qemu_add_mouse_mode_change_notifier(Notifier *notify)
603 notifier_list_add(&mouse_mode_notifiers, notify);
606 void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
608 notifier_remove(notify);
611 MouseInfoList *qmp_query_mice(Error **errp)
613 MouseInfoList *mice_list = NULL;
615 QemuInputHandlerState *s;
618 QTAILQ_FOREACH(s, &handlers, node) {
619 if (!(s->handler->mask &
620 (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
624 info = g_new0(MouseInfo, 1);
626 info->name = g_strdup(s->handler->name);
627 info->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
628 info->current = current;
631 QAPI_LIST_PREPEND(mice_list, info);
637 bool qemu_mouse_set(int index, Error **errp)
639 QemuInputHandlerState *s;
641 QTAILQ_FOREACH(s, &handlers, node) {
642 if (s->id == index) {
648 error_setg(errp, "Mouse at index '%d' not found", index);
652 if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
653 INPUT_EVENT_MASK_ABS))) {
654 error_setg(errp, "Input device '%s' is not a mouse",
659 qemu_input_handler_activate(s);
660 qemu_input_check_mode_change();