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
11struct QemuInputHandlerState {
12 DeviceState *dev;
13 QemuInputHandler *handler;
14 int id;
15 int events;
16 QemuConsole *con;
17 QTAILQ_ENTRY(QemuInputHandlerState) node;
18};
19
20typedef struct QemuInputEventQueue QemuInputEventQueue;
21typedef QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue)
22 QemuInputEventQueueHead;
23
24struct 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
37static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
38 QTAILQ_HEAD_INITIALIZER(handlers);
39static NotifierList mouse_mode_notifiers =
40 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
41
42static QemuInputEventQueueHead kbd_queue = QTAILQ_HEAD_INITIALIZER(kbd_queue);
43static QEMUTimer *kbd_timer;
44static uint32_t kbd_default_delay_ms = 10;
45static uint32_t queue_count;
46static uint32_t queue_limit = 1024;
47
48QemuInputHandlerState *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
63void 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
70void 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
77void 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
84void 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
100static QemuInputHandlerState*
101qemu_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
125void 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
177static 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
182static 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
208static 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
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
255 break;
256 }
257}
258
259static 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
292static 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
310static 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
322static 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
331void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt)
332{
333 QemuInputHandlerState *s;
334
335 qemu_input_event_trace(src, evt);
336
337
338 if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) {
339 qemu_input_transform_abs_rotate(evt);
340 }
341
342
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
351void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
352{
353
354
355 assert(!(evt->type == INPUT_EVENT_KIND_KEY &&
356 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER));
357
358
359
360
361
362
363
364
365
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
379void 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
396void 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
405static 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
415void 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
431void 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
437void 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
445void 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
462void 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
476void 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
491bool 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
500int 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
513void 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
527void 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
544void 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
559void qemu_add_mouse_mode_change_notifier(Notifier *notify)
560{
561 notifier_list_add(&mouse_mode_notifiers, notify);
562}
563
564void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
565{
566 notifier_remove(notify);
567}
568
569MouseInfoList *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
595bool 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}
621
