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
13struct QemuInputHandlerState {
14 DeviceState *dev;
15 QemuInputHandler *handler;
16 int id;
17 int events;
18 QemuConsole *con;
19 QTAILQ_ENTRY(QemuInputHandlerState) node;
20};
21
22typedef struct QemuInputEventQueue QemuInputEventQueue;
23typedef QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue)
24 QemuInputEventQueueHead;
25
26struct 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
39static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
40 QTAILQ_HEAD_INITIALIZER(handlers);
41static NotifierList mouse_mode_notifiers =
42 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
43
44static QemuInputEventQueueHead kbd_queue = QTAILQ_HEAD_INITIALIZER(kbd_queue);
45static QEMUTimer *kbd_timer;
46static uint32_t kbd_default_delay_ms = 10;
47static uint32_t queue_count;
48static uint32_t queue_limit = 1024;
49
50QemuInputHandlerState *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
65void 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
72void 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
79void 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
86void 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
102static QemuInputHandlerState*
103qemu_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
127void 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
179static 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
184static 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
210static 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
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
257 break;
258 }
259}
260
261static 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
294static 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
312static 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
324static 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
333void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt)
334{
335 QemuInputHandlerState *s;
336
337 qemu_input_event_trace(src, evt);
338
339
340 if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) {
341 qemu_input_transform_abs_rotate(evt);
342 }
343
344
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
353void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
354{
355
356
357 assert(!(evt->type == INPUT_EVENT_KIND_KEY &&
358 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER));
359
360
361
362
363
364
365
366
367
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
381void 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
398void 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
407static 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
417void 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
433void 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
439void 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
447void 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
464void 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
478void 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
493bool 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
502int 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
515void 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
529void 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
546void 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
561void qemu_add_mouse_mode_change_notifier(Notifier *notify)
562{
563 notifier_list_add(&mouse_mode_notifiers, notify);
564}
565
566void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
567{
568 notifier_remove(notify);
569}
570
571MouseInfoList *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
597void 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}
623
