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
11 struct QemuInputHandlerState {
12 DeviceState *dev;
13 const QemuInputHandler *handler;
14 int id;
15 int events;
16 QemuConsole *con;
17 QTAILQ_ENTRY(QemuInputHandlerState) node;
18 };
19
20 typedef struct QemuInputEventQueue QemuInputEventQueue;
21 typedef QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue)
22 QemuInputEventQueueHead;
23
24 struct 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
37 static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
38 QTAILQ_HEAD_INITIALIZER(handlers);
39 static NotifierList mouse_mode_notifiers =
40 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
41
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;
47
qemu_input_handler_register(DeviceState * dev,const QemuInputHandler * handler)48 QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev,
49 const 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 notifier_list_notify(&mouse_mode_notifiers, NULL);
60 return s;
61 }
62
qemu_input_handler_activate(QemuInputHandlerState * s)63 void qemu_input_handler_activate(QemuInputHandlerState *s)
64 {
65 QTAILQ_REMOVE(&handlers, s, node);
66 QTAILQ_INSERT_HEAD(&handlers, s, node);
67 notifier_list_notify(&mouse_mode_notifiers, NULL);
68 }
69
qemu_input_handler_deactivate(QemuInputHandlerState * s)70 void qemu_input_handler_deactivate(QemuInputHandlerState *s)
71 {
72 QTAILQ_REMOVE(&handlers, s, node);
73 QTAILQ_INSERT_TAIL(&handlers, s, node);
74 notifier_list_notify(&mouse_mode_notifiers, NULL);
75 }
76
qemu_input_handler_unregister(QemuInputHandlerState * s)77 void qemu_input_handler_unregister(QemuInputHandlerState *s)
78 {
79 QTAILQ_REMOVE(&handlers, s, node);
80 g_free(s);
81 notifier_list_notify(&mouse_mode_notifiers, NULL);
82 }
83
qemu_input_handler_bind(QemuInputHandlerState * s,const char * device_id,int head,Error ** errp)84 void 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
100 static QemuInputHandlerState*
qemu_input_find_handler(uint32_t mask,QemuConsole * con)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
qmp_input_send_event(const char * device,bool has_head,int64_t head,InputEventList * events,Error ** errp)125 void 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
qemu_input_transform_invert_abs_value(int value)177 static 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
qemu_input_transform_abs_rotate(InputEvent * evt)182 static 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
qemu_input_event_trace(QemuConsole * src,InputEvent * evt)208 static 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 InputMultiTouchEvent *mtt;
216
217 if (src) {
218 idx = qemu_console_get_index(src);
219 }
220 switch (evt->type) {
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,
228 name, key->down);
229 break;
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);
233 break;
234 case KEY_VALUE_KIND__MAX:
235 /* keep gcc happy */
236 break;
237 }
238 break;
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);
243 break;
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);
248 break;
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);
253 break;
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);
258 break;
259 case INPUT_EVENT_KIND__MAX:
260 /* keep gcc happy */
261 break;
262 }
263 }
264
qemu_input_queue_process(void * opaque)265 static void qemu_input_queue_process(void *opaque)
266 {
267 QemuInputEventQueueHead *queue = opaque;
268 QemuInputEventQueue *item;
269
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);
274 queue_count--;
275 g_free(item);
276
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)
282 + item->delay_ms);
283 return;
284 case QEMU_INPUT_QUEUE_EVENT:
285 qemu_input_event_send(item->src, item->evt);
286 qapi_free_InputEvent(item->evt);
287 break;
288 case QEMU_INPUT_QUEUE_SYNC:
289 qemu_input_event_sync();
290 break;
291 }
292 QTAILQ_REMOVE(queue, item, node);
293 queue_count--;
294 g_free(item);
295 }
296 }
297
qemu_input_queue_delay(QemuInputEventQueueHead * queue,QEMUTimer * timer,uint32_t delay_ms)298 static void qemu_input_queue_delay(QemuInputEventQueueHead *queue,
299 QEMUTimer *timer, uint32_t delay_ms)
300 {
301 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
302 bool start_timer = QTAILQ_EMPTY(queue);
303
304 item->type = QEMU_INPUT_QUEUE_DELAY;
305 item->delay_ms = delay_ms;
306 item->timer = timer;
307 QTAILQ_INSERT_TAIL(queue, item, node);
308 queue_count++;
309
310 if (start_timer) {
311 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
312 + item->delay_ms);
313 }
314 }
315
qemu_input_queue_event(QemuInputEventQueueHead * queue,QemuConsole * src,InputEvent * evt)316 static void qemu_input_queue_event(QemuInputEventQueueHead *queue,
317 QemuConsole *src, InputEvent *evt)
318 {
319 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
320
321 item->type = QEMU_INPUT_QUEUE_EVENT;
322 item->src = src;
323 item->evt = evt;
324 QTAILQ_INSERT_TAIL(queue, item, node);
325 queue_count++;
326 }
327
qemu_input_queue_sync(QemuInputEventQueueHead * queue)328 static void qemu_input_queue_sync(QemuInputEventQueueHead *queue)
329 {
330 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
331
332 item->type = QEMU_INPUT_QUEUE_SYNC;
333 QTAILQ_INSERT_TAIL(queue, item, node);
334 queue_count++;
335 }
336
qemu_input_event_send_impl(QemuConsole * src,InputEvent * evt)337 void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt)
338 {
339 QemuInputHandlerState *s;
340
341 qemu_input_event_trace(src, evt);
342
343 /* pre processing */
344 if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) {
345 qemu_input_transform_abs_rotate(evt);
346 }
347
348 /* send event */
349 s = qemu_input_find_handler(1 << evt->type, src);
350 if (!s) {
351 return;
352 }
353 s->handler->event(s->dev, src, evt);
354 s->events++;
355 }
356
qemu_input_event_send(QemuConsole * src,InputEvent * evt)357 void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
358 {
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));
363
364
365 /*
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
372 */
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;
376 }
377
378 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
379 return;
380 }
381
382 replay_input_event(src, evt);
383 }
384
qemu_input_event_sync_impl(void)385 void qemu_input_event_sync_impl(void)
386 {
387 QemuInputHandlerState *s;
388
389 trace_input_event_sync();
390
391 QTAILQ_FOREACH(s, &handlers, node) {
392 if (!s->events) {
393 continue;
394 }
395 if (s->handler->sync) {
396 s->handler->sync(s->dev);
397 }
398 s->events = 0;
399 }
400 }
401
qemu_input_event_sync(void)402 void qemu_input_event_sync(void)
403 {
404 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
405 return;
406 }
407
408 replay_input_sync_event();
409 }
410
qemu_input_event_new_key(KeyValue * key,bool down)411 static InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
412 {
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;
418 return evt;
419 }
420
qemu_input_event_send_key(QemuConsole * src,KeyValue * key,bool down)421 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
422 {
423 InputEvent *evt;
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);
432 } else {
433 qapi_free_InputEvent(evt);
434 }
435 }
436
qemu_input_event_send_key_number(QemuConsole * src,int num,bool down)437 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
438 {
439 QKeyCode code = qemu_input_key_number_to_qcode(num);
440 qemu_input_event_send_key_qcode(src, code, down);
441 }
442
qemu_input_event_send_key_qcode(QemuConsole * src,QKeyCode q,bool down)443 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
444 {
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);
449 }
450
qemu_input_event_send_key_delay(uint32_t delay_ms)451 void qemu_input_event_send_key_delay(uint32_t delay_ms)
452 {
453 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
454 return;
455 }
456
457 if (!kbd_timer) {
458 kbd_timer = timer_new_full(NULL, QEMU_CLOCK_VIRTUAL,
459 SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
460 qemu_input_queue_process, &kbd_queue);
461 }
462 if (queue_count < queue_limit) {
463 qemu_input_queue_delay(&kbd_queue, kbd_timer,
464 delay_ms ? delay_ms : kbd_default_delay_ms);
465 }
466 }
467
qemu_input_queue_btn(QemuConsole * src,InputButton btn,bool down)468 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
469 {
470 InputBtnEvent bevt = {
471 .button = btn,
472 .down = down,
473 };
474 InputEvent evt = {
475 .type = INPUT_EVENT_KIND_BTN,
476 .u.btn.data = &bevt,
477 };
478
479 qemu_input_event_send(src, &evt);
480 }
481
qemu_input_update_buttons(QemuConsole * src,uint32_t * button_map,uint32_t button_old,uint32_t button_new)482 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
483 uint32_t button_old, uint32_t button_new)
484 {
485 InputButton btn;
486 uint32_t mask;
487
488 for (btn = 0; btn < INPUT_BUTTON__MAX; btn++) {
489 mask = button_map[btn];
490 if ((button_old & mask) == (button_new & mask)) {
491 continue;
492 }
493 qemu_input_queue_btn(src, btn, button_new & mask);
494 }
495 }
496
qemu_input_is_absolute(QemuConsole * con)497 bool qemu_input_is_absolute(QemuConsole *con)
498 {
499 QemuInputHandlerState *s;
500
501 s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
502 con);
503 return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
504 }
505
qemu_input_scale_axis(int value,int min_in,int max_in,int min_out,int max_out)506 int qemu_input_scale_axis(int value,
507 int min_in, int max_in,
508 int min_out, int max_out)
509 {
510 int64_t range_in = (int64_t)max_in - min_in;
511 int64_t range_out = (int64_t)max_out - min_out;
512
513 if (range_in < 1) {
514 return min_out + range_out / 2;
515 }
516 return ((int64_t)value - min_in) * range_out / range_in + min_out;
517 }
518
qemu_input_queue_rel(QemuConsole * src,InputAxis axis,int value)519 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
520 {
521 InputMoveEvent move = {
522 .axis = axis,
523 .value = value,
524 };
525 InputEvent evt = {
526 .type = INPUT_EVENT_KIND_REL,
527 .u.rel.data = &move,
528 };
529
530 qemu_input_event_send(src, &evt);
531 }
532
qemu_input_queue_abs(QemuConsole * src,InputAxis axis,int value,int min_in,int max_in)533 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value,
534 int min_in, int max_in)
535 {
536 InputMoveEvent move = {
537 .axis = axis,
538 .value = qemu_input_scale_axis(value, min_in, max_in,
539 INPUT_EVENT_ABS_MIN,
540 INPUT_EVENT_ABS_MAX),
541 };
542 InputEvent evt = {
543 .type = INPUT_EVENT_KIND_ABS,
544 .u.abs.data = &move,
545 };
546
547 qemu_input_event_send(src, &evt);
548 }
549
qemu_input_queue_mtt(QemuConsole * src,InputMultiTouchType type,int slot,int tracking_id)550 void qemu_input_queue_mtt(QemuConsole *src, InputMultiTouchType type,
551 int slot, int tracking_id)
552 {
553 InputMultiTouchEvent mtt = {
554 .type = type,
555 .slot = slot,
556 .tracking_id = tracking_id,
557 };
558 InputEvent evt = {
559 .type = INPUT_EVENT_KIND_MTT,
560 .u.mtt.data = &mtt,
561 };
562
563 qemu_input_event_send(src, &evt);
564 }
565
qemu_input_queue_mtt_abs(QemuConsole * src,InputAxis axis,int value,int min_in,int max_in,int slot,int tracking_id)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)
568 {
569 InputMultiTouchEvent mtt = {
570 .type = INPUT_MULTI_TOUCH_TYPE_DATA,
571 .slot = slot,
572 .tracking_id = tracking_id,
573 .axis = axis,
574 .value = qemu_input_scale_axis(value, min_in, max_in,
575 INPUT_EVENT_ABS_MIN,
576 INPUT_EVENT_ABS_MAX),
577 };
578 InputEvent evt = {
579 .type = INPUT_EVENT_KIND_MTT,
580 .u.mtt.data = &mtt,
581 };
582
583 qemu_input_event_send(src, &evt);
584 }
585
qemu_add_mouse_mode_change_notifier(Notifier * notify)586 void qemu_add_mouse_mode_change_notifier(Notifier *notify)
587 {
588 notifier_list_add(&mouse_mode_notifiers, notify);
589 }
590
qemu_remove_mouse_mode_change_notifier(Notifier * notify)591 void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
592 {
593 notifier_remove(notify);
594 }
595
qmp_query_mice(Error ** errp)596 MouseInfoList *qmp_query_mice(Error **errp)
597 {
598 MouseInfoList *mice_list = NULL;
599 MouseInfo *info;
600 QemuInputHandlerState *s;
601 bool current = true;
602
603 QTAILQ_FOREACH(s, &handlers, node) {
604 if (!(s->handler->mask &
605 (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
606 continue;
607 }
608
609 info = g_new0(MouseInfo, 1);
610 info->index = s->id;
611 info->name = g_strdup(s->handler->name);
612 info->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
613 info->current = current;
614
615 current = false;
616 QAPI_LIST_PREPEND(mice_list, info);
617 }
618
619 return mice_list;
620 }
621
qemu_mouse_set(int index,Error ** errp)622 bool qemu_mouse_set(int index, Error **errp)
623 {
624 QemuInputHandlerState *s;
625
626 QTAILQ_FOREACH(s, &handlers, node) {
627 if (s->id == index) {
628 break;
629 }
630 }
631
632 if (!s) {
633 error_setg(errp, "Mouse at index '%d' not found", index);
634 return false;
635 }
636
637 if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
638 INPUT_EVENT_MASK_ABS))) {
639 error_setg(errp, "Input device '%s' is not a mouse",
640 s->handler->name);
641 return false;
642 }
643
644 qemu_input_handler_activate(s);
645 notifier_list_notify(&mouse_mode_notifiers, NULL);
646 return true;
647 }
648