blob: 147e69c1c3c5ce288bfcd6f3e3baec4ec5448132 [file] [log] [blame]
Peter Maydelle16f4c82016-01-29 17:49:51 +00001#include "qemu/osdep.h"
Philippe Mathieu-Daudé32cad1f2024-12-03 15:20:13 +01002#include "system/system.h"
Markus Armbrustere688df62018-02-01 12:18:31 +01003#include "qapi/error.h"
Markus Armbruster9af23982018-02-11 10:36:01 +01004#include "qapi/qapi-commands-ui.h"
Gerd Hoffmannc43ce552013-12-04 15:20:05 +01005#include "trace.h"
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +01006#include "ui/input.h"
Gerd Hoffmannc43ce552013-12-04 15:20:05 +01007#include "ui/console.h"
Philippe Mathieu-Daudé32cad1f2024-12-03 15:20:13 +01008#include "system/replay.h"
9#include "system/runstate.h"
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010010
11struct QemuInputHandlerState {
12 DeviceState *dev;
Philippe Mathieu-Daudéb1be65f2023-10-17 15:05:00 +020013 const QemuInputHandler *handler;
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010014 int id;
15 int events;
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +020016 QemuConsole *con;
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010017 QTAILQ_ENTRY(QemuInputHandlerState) node;
18};
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +020019
20typedef struct QemuInputEventQueue QemuInputEventQueue;
Paolo Bonzinif481ee22018-12-06 11:56:15 +010021typedef QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue)
22 QemuInputEventQueueHead;
23
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +020024struct 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
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010037static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
38 QTAILQ_HEAD_INITIALIZER(handlers);
Gerd Hoffmann4a33f452013-12-05 11:23:42 +010039static NotifierList mouse_mode_notifiers =
40 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010041
Paolo Bonzinif481ee22018-12-06 11:56:15 +010042static QemuInputEventQueueHead kbd_queue = QTAILQ_HEAD_INITIALIZER(kbd_queue);
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +020043static QEMUTimer *kbd_timer;
44static uint32_t kbd_default_delay_ms = 10;
Gerd Hoffmannfa18f362017-04-28 10:42:37 +020045static uint32_t queue_count;
46static uint32_t queue_limit = 1024;
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +020047
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010048QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev,
Philippe Mathieu-Daudéb1be65f2023-10-17 15:05:00 +020049 const QemuInputHandler *handler)
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010050{
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);
Gerd Hoffmann4a33f452013-12-05 11:23:42 +010058
Akihiko Odaki0337e412023-09-21 17:29:34 +090059 notifier_list_notify(&mouse_mode_notifiers, NULL);
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010060 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);
Akihiko Odaki0337e412023-09-21 17:29:34 +090067 notifier_list_notify(&mouse_mode_notifiers, NULL);
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010068}
69
Gerd Hoffmann528728f2014-03-16 00:38:45 +010070void qemu_input_handler_deactivate(QemuInputHandlerState *s)
71{
72 QTAILQ_REMOVE(&handlers, s, node);
73 QTAILQ_INSERT_TAIL(&handlers, s, node);
Akihiko Odaki0337e412023-09-21 17:29:34 +090074 notifier_list_notify(&mouse_mode_notifiers, NULL);
Gerd Hoffmann528728f2014-03-16 00:38:45 +010075}
76
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010077void qemu_input_handler_unregister(QemuInputHandlerState *s)
78{
79 QTAILQ_REMOVE(&handlers, s, node);
80 g_free(s);
Akihiko Odaki0337e412023-09-21 17:29:34 +090081 notifier_list_notify(&mouse_mode_notifiers, NULL);
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +010082}
83
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +020084void qemu_input_handler_bind(QemuInputHandlerState *s,
85 const char *device_id, int head,
86 Error **errp)
87{
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +020088 QemuConsole *con;
Gerd Hoffmannf2c1d542016-01-12 11:45:43 +010089 Error *err = NULL;
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +020090
Gerd Hoffmannf2c1d542016-01-12 11:45:43 +010091 con = qemu_console_lookup_by_device_name(device_id, head, &err);
92 if (err) {
93 error_propagate(errp, err);
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +020094 return;
95 }
96
97 s->con = con;
98}
99
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100100static QemuInputHandlerState*
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +0200101qemu_input_find_handler(uint32_t mask, QemuConsole *con)
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100102{
103 QemuInputHandlerState *s;
104
105 QTAILQ_FOREACH(s, &handlers, node) {
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +0200106 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 }
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100118 if (mask & s->handler->mask) {
119 return s;
120 }
121 }
122 return NULL;
123}
124
Markus Armbruster3f41a3ad2022-11-04 17:07:09 +0100125void qmp_input_send_event(const char *device,
Gerd Hoffmann6575ccd2016-01-12 12:39:33 +0100126 bool has_head, int64_t head,
127 InputEventList *events, Error **errp)
Marcelo Tosatti50c66172014-09-30 18:10:17 -0300128{
129 InputEventList *e;
130 QemuConsole *con;
Gerd Hoffmannb98d26e2016-01-12 12:11:14 +0100131 Error *err = NULL;
Marcelo Tosatti50c66172014-09-30 18:10:17 -0300132
Amos Kong51fc4472014-11-07 12:41:25 +0800133 con = NULL;
Markus Armbruster3f41a3ad2022-11-04 17:07:09 +0100134 if (device) {
Gerd Hoffmannb98d26e2016-01-12 12:11:14 +0100135 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);
Amos Kong51fc4472014-11-07 12:41:25 +0800141 return;
142 }
Marcelo Tosatti50c66172014-09-30 18:10:17 -0300143 }
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
Eric Blake568c73a2015-10-26 16:34:58 -0600153 if (!qemu_input_find_handler(1 << event->type, con)) {
Marcelo Tosatti50c66172014-09-30 18:10:17 -0300154 error_setg(errp, "Input handler not found for "
155 "event type %s",
Markus Armbruster977c7362017-08-24 10:46:08 +0200156 InputEventKind_str(event->type));
Marcelo Tosatti50c66172014-09-30 18:10:17 -0300157 return;
158 }
159 }
160
161 for (e = events; e != NULL; e = e->next) {
Daniel P. Berrangeaf07e5f2017-09-29 11:12:00 +0100162 InputEvent *evt = e->value;
Marcelo Tosatti50c66172014-09-30 18:10:17 -0300163
Daniel P. Berrangeaf07e5f2017-09-29 11:12:00 +0100164 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;
Daniel P. Berrange237925b2017-10-19 15:28:42 +0100167 QKeyCode code = qemu_input_key_number_to_qcode(key->u.number.data);
Daniel P. Berrangeaf07e5f2017-09-29 11:12:00 +0100168 qemu_input_event_send_key_qcode(con, code, evt->u.key.data->down);
169 } else {
170 qemu_input_event_send(con, evt);
171 }
Marcelo Tosatti50c66172014-09-30 18:10:17 -0300172 }
173
174 qemu_input_event_sync();
175}
176
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100177static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
178{
179 const char *name;
Gerd Hoffmann2386a902014-05-21 13:49:59 +0200180 int qcode, idx = -1;
Eric Blakeb5a1b442016-03-03 09:16:49 -0700181 InputKeyEvent *key;
182 InputBtnEvent *btn;
183 InputMoveEvent *move;
Sergio Lopez2bfb10d2023-05-26 13:29:21 +0200184 InputMultiTouchEvent *mtt;
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100185
186 if (src) {
187 idx = qemu_console_get_index(src);
188 }
Eric Blake568c73a2015-10-26 16:34:58 -0600189 switch (evt->type) {
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100190 case INPUT_EVENT_KIND_KEY:
Eric Blake32bafa82016-03-17 16:48:37 -0600191 key = evt->u.key.data;
Eric Blakeb5a1b442016-03-03 09:16:49 -0700192 switch (key->key->type) {
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100193 case KEY_VALUE_KIND_NUMBER:
Eric Blake32bafa82016-03-17 16:48:37 -0600194 qcode = qemu_input_key_number_to_qcode(key->key->u.number.data);
Markus Armbruster977c7362017-08-24 10:46:08 +0200195 name = QKeyCode_str(qcode);
Eric Blake32bafa82016-03-17 16:48:37 -0600196 trace_input_event_key_number(idx, key->key->u.number.data,
Eric Blakeb5a1b442016-03-03 09:16:49 -0700197 name, key->down);
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100198 break;
199 case KEY_VALUE_KIND_QCODE:
Markus Armbruster977c7362017-08-24 10:46:08 +0200200 name = QKeyCode_str(key->key->u.qcode.data);
Eric Blakeb5a1b442016-03-03 09:16:49 -0700201 trace_input_event_key_qcode(idx, name, key->down);
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100202 break;
Eric Blake7fb1cf12015-11-18 01:52:57 -0700203 case KEY_VALUE_KIND__MAX:
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100204 /* keep gcc happy */
205 break;
206 }
207 break;
208 case INPUT_EVENT_KIND_BTN:
Eric Blake32bafa82016-03-17 16:48:37 -0600209 btn = evt->u.btn.data;
Markus Armbruster977c7362017-08-24 10:46:08 +0200210 name = InputButton_str(btn->button);
Eric Blakeb5a1b442016-03-03 09:16:49 -0700211 trace_input_event_btn(idx, name, btn->down);
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100212 break;
213 case INPUT_EVENT_KIND_REL:
Eric Blake32bafa82016-03-17 16:48:37 -0600214 move = evt->u.rel.data;
Markus Armbruster977c7362017-08-24 10:46:08 +0200215 name = InputAxis_str(move->axis);
Eric Blakeb5a1b442016-03-03 09:16:49 -0700216 trace_input_event_rel(idx, name, move->value);
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100217 break;
218 case INPUT_EVENT_KIND_ABS:
Eric Blake32bafa82016-03-17 16:48:37 -0600219 move = evt->u.abs.data;
Markus Armbruster977c7362017-08-24 10:46:08 +0200220 name = InputAxis_str(move->axis);
Eric Blakeb5a1b442016-03-03 09:16:49 -0700221 trace_input_event_abs(idx, name, move->value);
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100222 break;
Sergio Lopez2bfb10d2023-05-26 13:29:21 +0200223 case INPUT_EVENT_KIND_MTT:
224 mtt = evt->u.mtt.data;
225 name = InputAxis_str(mtt->axis);
226 trace_input_event_mtt(idx, name, mtt->value);
227 break;
Eric Blake7fb1cf12015-11-18 01:52:57 -0700228 case INPUT_EVENT_KIND__MAX:
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100229 /* keep gcc happy */
230 break;
231 }
232}
233
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200234static void qemu_input_queue_process(void *opaque)
235{
Paolo Bonzinif481ee22018-12-06 11:56:15 +0100236 QemuInputEventQueueHead *queue = opaque;
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200237 QemuInputEventQueue *item;
238
239 g_assert(!QTAILQ_EMPTY(queue));
240 item = QTAILQ_FIRST(queue);
241 g_assert(item->type == QEMU_INPUT_QUEUE_DELAY);
242 QTAILQ_REMOVE(queue, item, node);
Alexander Graf77b03592017-06-22 09:41:58 +0200243 queue_count--;
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200244 g_free(item);
245
246 while (!QTAILQ_EMPTY(queue)) {
247 item = QTAILQ_FIRST(queue);
248 switch (item->type) {
249 case QEMU_INPUT_QUEUE_DELAY:
Artem Pisarenko05ff8dc2018-10-17 14:24:18 +0600250 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200251 + item->delay_ms);
252 return;
253 case QEMU_INPUT_QUEUE_EVENT:
254 qemu_input_event_send(item->src, item->evt);
255 qapi_free_InputEvent(item->evt);
256 break;
257 case QEMU_INPUT_QUEUE_SYNC:
258 qemu_input_event_sync();
259 break;
260 }
261 QTAILQ_REMOVE(queue, item, node);
Gerd Hoffmannfa18f362017-04-28 10:42:37 +0200262 queue_count--;
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200263 g_free(item);
264 }
265}
266
Paolo Bonzinif481ee22018-12-06 11:56:15 +0100267static void qemu_input_queue_delay(QemuInputEventQueueHead *queue,
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200268 QEMUTimer *timer, uint32_t delay_ms)
269{
270 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
271 bool start_timer = QTAILQ_EMPTY(queue);
272
273 item->type = QEMU_INPUT_QUEUE_DELAY;
274 item->delay_ms = delay_ms;
275 item->timer = timer;
276 QTAILQ_INSERT_TAIL(queue, item, node);
Gerd Hoffmannfa18f362017-04-28 10:42:37 +0200277 queue_count++;
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200278
279 if (start_timer) {
Artem Pisarenko05ff8dc2018-10-17 14:24:18 +0600280 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200281 + item->delay_ms);
282 }
283}
284
Paolo Bonzinif481ee22018-12-06 11:56:15 +0100285static void qemu_input_queue_event(QemuInputEventQueueHead *queue,
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200286 QemuConsole *src, InputEvent *evt)
287{
288 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
289
290 item->type = QEMU_INPUT_QUEUE_EVENT;
291 item->src = src;
292 item->evt = evt;
293 QTAILQ_INSERT_TAIL(queue, item, node);
Gerd Hoffmannfa18f362017-04-28 10:42:37 +0200294 queue_count++;
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200295}
296
Paolo Bonzinif481ee22018-12-06 11:56:15 +0100297static void qemu_input_queue_sync(QemuInputEventQueueHead *queue)
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200298{
299 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
300
301 item->type = QEMU_INPUT_QUEUE_SYNC;
302 QTAILQ_INSERT_TAIL(queue, item, node);
Gerd Hoffmannfa18f362017-04-28 10:42:37 +0200303 queue_count++;
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200304}
305
Pavel Dovgalyukee312992015-09-17 19:25:24 +0300306void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt)
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100307{
308 QemuInputHandlerState *s;
309
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100310 qemu_input_event_trace(src, evt);
311
Gerd Hoffmannd3535432013-11-28 11:29:33 +0100312 /* send event */
Eric Blake568c73a2015-10-26 16:34:58 -0600313 s = qemu_input_find_handler(1 << evt->type, src);
Gerd Hoffmannbdcc3a22014-03-31 16:07:30 +0200314 if (!s) {
315 return;
316 }
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100317 s->handler->event(s->dev, src, evt);
318 s->events++;
319}
320
Pavel Dovgalyukee312992015-09-17 19:25:24 +0300321void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100322{
Daniel P. Berrangeaf07e5f2017-09-29 11:12:00 +0100323 /* Expect all parts of QEMU to send events with QCodes exclusively.
324 * Key numbers are only supported as end-user input via QMP */
325 assert(!(evt->type == INPUT_EVENT_KIND_KEY &&
326 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER));
327
Daniel P. Berrange80b857f2017-10-19 15:28:47 +0100328
329 /*
330 * 'sysrq' was mistakenly added to hack around the fact that
331 * the ps2 driver was not generating correct scancodes sequences
332 * when 'alt+print' was pressed. This flaw is now fixed and the
333 * 'sysrq' key serves no further purpose. We normalize it to
334 * 'print', so that downstream receivers of the event don't
Dr. David Alan Gilbert118d4ed2022-06-14 11:40:44 +0100335 * need to deal with this mistake
Daniel P. Berrange80b857f2017-10-19 15:28:47 +0100336 */
337 if (evt->type == INPUT_EVENT_KIND_KEY &&
338 evt->u.key.data->key->u.qcode.data == Q_KEY_CODE_SYSRQ) {
339 evt->u.key.data->key->u.qcode.data = Q_KEY_CODE_PRINT;
340 }
341
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100342 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
343 return;
344 }
345
Pavel Dovgalyukee312992015-09-17 19:25:24 +0300346 replay_input_event(src, evt);
347}
348
349void qemu_input_event_sync_impl(void)
350{
351 QemuInputHandlerState *s;
352
Gerd Hoffmannc43ce552013-12-04 15:20:05 +0100353 trace_input_event_sync();
354
Gerd Hoffmannc8b405b2013-11-27 10:35:26 +0100355 QTAILQ_FOREACH(s, &handlers, node) {
356 if (!s->events) {
357 continue;
358 }
359 if (s->handler->sync) {
360 s->handler->sync(s->dev);
361 }
362 s->events = 0;
363 }
364}
Gerd Hoffmann65671472013-11-27 11:38:47 +0100365
Pavel Dovgalyukee312992015-09-17 19:25:24 +0300366void qemu_input_event_sync(void)
367{
368 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
369 return;
370 }
371
372 replay_input_sync_event();
373}
374
Daniel P. Berrange3ad35e72017-09-29 11:12:01 +0100375static InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
Gerd Hoffmann65671472013-11-27 11:38:47 +0100376{
377 InputEvent *evt = g_new0(InputEvent, 1);
Eric Blake32bafa82016-03-17 16:48:37 -0600378 evt->u.key.data = g_new0(InputKeyEvent, 1);
Eric Blake568c73a2015-10-26 16:34:58 -0600379 evt->type = INPUT_EVENT_KIND_KEY;
Eric Blake32bafa82016-03-17 16:48:37 -0600380 evt->u.key.data->key = key;
381 evt->u.key.data->down = down;
Gerd Hoffmann65671472013-11-27 11:38:47 +0100382 return evt;
383}
384
385void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
386{
387 InputEvent *evt;
388 evt = qemu_input_event_new_key(key, down);
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200389 if (QTAILQ_EMPTY(&kbd_queue)) {
390 qemu_input_event_send(src, evt);
391 qemu_input_event_sync();
392 qapi_free_InputEvent(evt);
Gerd Hoffmannfa18f362017-04-28 10:42:37 +0200393 } else if (queue_count < queue_limit) {
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200394 qemu_input_queue_event(&kbd_queue, src, evt);
395 qemu_input_queue_sync(&kbd_queue);
linzhechengfca47742017-12-25 10:37:30 +0800396 } else {
397 qapi_free_InputEvent(evt);
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200398 }
Gerd Hoffmann65671472013-11-27 11:38:47 +0100399}
400
401void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
402{
Daniel P. Berrangeaf07e5f2017-09-29 11:12:00 +0100403 QKeyCode code = qemu_input_key_number_to_qcode(num);
404 qemu_input_event_send_key_qcode(src, code, down);
Gerd Hoffmann65671472013-11-27 11:38:47 +0100405}
406
407void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
408{
409 KeyValue *key = g_new0(KeyValue, 1);
Eric Blake568c73a2015-10-26 16:34:58 -0600410 key->type = KEY_VALUE_KIND_QCODE;
Eric Blake32bafa82016-03-17 16:48:37 -0600411 key->u.qcode.data = q;
Gerd Hoffmann65671472013-11-27 11:38:47 +0100412 qemu_input_event_send_key(src, key, down);
413}
Gerd Hoffmann43579402013-11-27 18:24:29 +0100414
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200415void qemu_input_event_send_key_delay(uint32_t delay_ms)
416{
Marc-André Lureau05c66382017-04-25 17:05:20 +0400417 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
418 return;
419 }
420
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200421 if (!kbd_timer) {
Artem Pisarenkoe81f8672018-10-17 14:24:20 +0600422 kbd_timer = timer_new_full(NULL, QEMU_CLOCK_VIRTUAL,
423 SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
424 qemu_input_queue_process, &kbd_queue);
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200425 }
Gerd Hoffmannfa18f362017-04-28 10:42:37 +0200426 if (queue_count < queue_limit) {
427 qemu_input_queue_delay(&kbd_queue, kbd_timer,
428 delay_ms ? delay_ms : kbd_default_delay_ms);
429 }
Gerd Hoffmannbe1a7172014-05-28 13:02:40 +0200430}
431
Gerd Hoffmann43579402013-11-27 18:24:29 +0100432void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
433{
Gerd Hoffmann7a1b46e2018-12-10 15:08:08 +0100434 InputBtnEvent bevt = {
435 .button = btn,
436 .down = down,
437 };
438 InputEvent evt = {
439 .type = INPUT_EVENT_KIND_BTN,
440 .u.btn.data = &bevt,
441 };
442
443 qemu_input_event_send(src, &evt);
Gerd Hoffmann43579402013-11-27 18:24:29 +0100444}
445
446void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
447 uint32_t button_old, uint32_t button_new)
448{
449 InputButton btn;
450 uint32_t mask;
451
Eric Blake7fb1cf12015-11-18 01:52:57 -0700452 for (btn = 0; btn < INPUT_BUTTON__MAX; btn++) {
Gerd Hoffmann43579402013-11-27 18:24:29 +0100453 mask = button_map[btn];
454 if ((button_old & mask) == (button_new & mask)) {
455 continue;
456 }
457 qemu_input_queue_btn(src, btn, button_new & mask);
458 }
459}
460
Akihiko Odaki0337e412023-09-21 17:29:34 +0900461bool qemu_input_is_absolute(QemuConsole *con)
Gerd Hoffmann502c8db2013-11-28 11:31:09 +0100462{
463 QemuInputHandlerState *s;
464
Gerd Hoffmann6f5943c2014-05-19 15:18:37 +0200465 s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
Akihiko Odaki0337e412023-09-21 17:29:34 +0900466 con);
Gerd Hoffmann502c8db2013-11-28 11:31:09 +0100467 return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
468}
469
Philippe Voinov9cfa7ab2017-05-05 15:39:52 +0200470int qemu_input_scale_axis(int value,
471 int min_in, int max_in,
472 int min_out, int max_out)
Gerd Hoffmann43579402013-11-27 18:24:29 +0100473{
Philippe Voinov9cfa7ab2017-05-05 15:39:52 +0200474 int64_t range_in = (int64_t)max_in - min_in;
475 int64_t range_out = (int64_t)max_out - min_out;
476
477 if (range_in < 1) {
478 return min_out + range_out / 2;
Gerd Hoffmann43579402013-11-27 18:24:29 +0100479 }
Philippe Voinov9cfa7ab2017-05-05 15:39:52 +0200480 return ((int64_t)value - min_in) * range_out / range_in + min_out;
Gerd Hoffmann43579402013-11-27 18:24:29 +0100481}
482
Gerd Hoffmann43579402013-11-27 18:24:29 +0100483void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
484{
Gerd Hoffmann7a1b46e2018-12-10 15:08:08 +0100485 InputMoveEvent move = {
486 .axis = axis,
487 .value = value,
488 };
489 InputEvent evt = {
490 .type = INPUT_EVENT_KIND_REL,
491 .u.rel.data = &move,
492 };
493
494 qemu_input_event_send(src, &evt);
Gerd Hoffmann43579402013-11-27 18:24:29 +0100495}
496
Philippe Voinov9cfa7ab2017-05-05 15:39:52 +0200497void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value,
498 int min_in, int max_in)
Gerd Hoffmann43579402013-11-27 18:24:29 +0100499{
Gerd Hoffmann7a1b46e2018-12-10 15:08:08 +0100500 InputMoveEvent move = {
501 .axis = axis,
502 .value = qemu_input_scale_axis(value, min_in, max_in,
Philippe Voinov9cfa7ab2017-05-05 15:39:52 +0200503 INPUT_EVENT_ABS_MIN,
Gerd Hoffmann7a1b46e2018-12-10 15:08:08 +0100504 INPUT_EVENT_ABS_MAX),
505 };
506 InputEvent evt = {
507 .type = INPUT_EVENT_KIND_ABS,
508 .u.abs.data = &move,
509 };
510
511 qemu_input_event_send(src, &evt);
Gerd Hoffmann43579402013-11-27 18:24:29 +0100512}
Gerd Hoffmann4a33f452013-12-05 11:23:42 +0100513
Sergio Lopezf6157392023-05-26 13:29:24 +0200514void qemu_input_queue_mtt(QemuConsole *src, InputMultiTouchType type,
515 int slot, int tracking_id)
516{
517 InputMultiTouchEvent mtt = {
518 .type = type,
519 .slot = slot,
520 .tracking_id = tracking_id,
521 };
522 InputEvent evt = {
523 .type = INPUT_EVENT_KIND_MTT,
524 .u.mtt.data = &mtt,
525 };
526
527 qemu_input_event_send(src, &evt);
528}
529
530void qemu_input_queue_mtt_abs(QemuConsole *src, InputAxis axis, int value,
531 int min_in, int max_in, int slot, int tracking_id)
532{
533 InputMultiTouchEvent mtt = {
534 .type = INPUT_MULTI_TOUCH_TYPE_DATA,
535 .slot = slot,
536 .tracking_id = tracking_id,
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_MTT,
544 .u.mtt.data = &mtt,
545 };
546
547 qemu_input_event_send(src, &evt);
548}
549
Gerd Hoffmann4a33f452013-12-05 11:23:42 +0100550void qemu_add_mouse_mode_change_notifier(Notifier *notify)
551{
552 notifier_list_add(&mouse_mode_notifiers, notify);
553}
554
555void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
556{
557 notifier_remove(notify);
558}
Gerd Hoffmanne842c682013-12-10 17:09:36 +0100559
560MouseInfoList *qmp_query_mice(Error **errp)
561{
562 MouseInfoList *mice_list = NULL;
Eric Blake54aa3de2020-11-12 19:13:37 -0600563 MouseInfo *info;
Gerd Hoffmanne842c682013-12-10 17:09:36 +0100564 QemuInputHandlerState *s;
565 bool current = true;
566
567 QTAILQ_FOREACH(s, &handlers, node) {
568 if (!(s->handler->mask &
569 (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
570 continue;
571 }
572
Eric Blake54aa3de2020-11-12 19:13:37 -0600573 info = g_new0(MouseInfo, 1);
574 info->index = s->id;
575 info->name = g_strdup(s->handler->name);
576 info->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
577 info->current = current;
Gerd Hoffmanne842c682013-12-10 17:09:36 +0100578
579 current = false;
Eric Blake54aa3de2020-11-12 19:13:37 -0600580 QAPI_LIST_PREPEND(mice_list, info);
Gerd Hoffmanne842c682013-12-10 17:09:36 +0100581 }
582
583 return mice_list;
584}
Gerd Hoffmann70b52f62013-12-10 17:16:03 +0100585
Markus Armbrusterec843b92023-01-09 20:03:20 +0100586bool qemu_mouse_set(int index, Error **errp)
Gerd Hoffmann70b52f62013-12-10 17:16:03 +0100587{
588 QemuInputHandlerState *s;
Gerd Hoffmann70b52f62013-12-10 17:16:03 +0100589
590 QTAILQ_FOREACH(s, &handlers, node) {
Markus Armbrustera0506b72023-01-09 20:03:21 +0100591 if (s->id == index) {
592 break;
Gerd Hoffmann70b52f62013-12-10 17:16:03 +0100593 }
594 }
595
Markus Armbrustera0506b72023-01-09 20:03:21 +0100596 if (!s) {
Markus Armbrusterec843b92023-01-09 20:03:20 +0100597 error_setg(errp, "Mouse at index '%d' not found", index);
598 return false;
Gerd Hoffmann70b52f62013-12-10 17:16:03 +0100599 }
600
Markus Armbrustera0506b72023-01-09 20:03:21 +0100601 if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
602 INPUT_EVENT_MASK_ABS))) {
603 error_setg(errp, "Input device '%s' is not a mouse",
604 s->handler->name);
605 return false;
606 }
607
608 qemu_input_handler_activate(s);
Akihiko Odaki0337e412023-09-21 17:29:34 +0900609 notifier_list_notify(&mouse_mode_notifiers, NULL);
Markus Armbrusterec843b92023-01-09 20:03:20 +0100610 return true;
Gerd Hoffmann70b52f62013-12-10 17:16:03 +0100611}