xref: /qemu/ui/input.c (revision 8b7b9c5c) 
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     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 
48 QemuInputHandlerState *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     notifier_list_notify(&mouse_mode_notifiers, NULL);
60     return s;
61 }
62 
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 
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 
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 
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*
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
586 void qemu_add_mouse_mode_change_notifier(Notifier *notify)
587 {
588     notifier_list_add(&mouse_mode_notifiers, notify);
589 }
590 
591 void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
592 {
593     notifier_remove(notify);
594 }
595 
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 
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