Merge remote-tracking branch 'remotes/vivier-m68k/tags/q800-pull-request' into staging
[qemu.git] / contrib / vhost-user-input / main.c
1 /*
2 * This work is licensed under the terms of the GNU GPL, version 2 or
3 * (at your option) any later version. See the COPYING file in the
4 * top-level directory.
5 */
6
7 #include "qemu/osdep.h"
8
9 #include <sys/ioctl.h>
10
11 #include "qemu/iov.h"
12 #include "qemu/bswap.h"
13 #include "qemu/sockets.h"
14 #include "libvhost-user-glib.h"
15 #include "standard-headers/linux/input.h"
16 #include "standard-headers/linux/virtio_input.h"
17 #include "qapi/error.h"
18
19 enum {
20 VHOST_USER_INPUT_MAX_QUEUES = 2,
21 };
22
23 typedef struct virtio_input_event virtio_input_event;
24 typedef struct virtio_input_config virtio_input_config;
25
26 typedef struct VuInput {
27 VugDev dev;
28 GSource *evsrc;
29 int evdevfd;
30 GArray *config;
31 virtio_input_config *sel_config;
32 struct {
33 virtio_input_event event;
34 VuVirtqElement *elem;
35 } *queue;
36 uint32_t qindex, qsize;
37 } VuInput;
38
39 static void vi_input_send(VuInput *vi, struct virtio_input_event *event)
40 {
41 VuDev *dev = &vi->dev.parent;
42 VuVirtq *vq = vu_get_queue(dev, 0);
43 VuVirtqElement *elem;
44 int i, len;
45
46 /* queue up events ... */
47 if (vi->qindex == vi->qsize) {
48 vi->qsize++;
49 vi->queue = g_realloc_n(vi->queue, vi->qsize, sizeof(vi->queue[0]));
50 }
51 vi->queue[vi->qindex++].event = *event;
52
53 /* ... until we see a report sync ... */
54 if (event->type != htole16(EV_SYN) ||
55 event->code != htole16(SYN_REPORT)) {
56 return;
57 }
58
59 /* ... then check available space ... */
60 for (i = 0; i < vi->qindex; i++) {
61 elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
62 if (!elem) {
63 while (--i >= 0) {
64 vu_queue_unpop(dev, vq, vi->queue[i].elem, 0);
65 }
66 vi->qindex = 0;
67 g_warning("virtio-input queue full");
68 return;
69 }
70 vi->queue[i].elem = elem;
71 }
72
73 /* ... and finally pass them to the guest */
74 for (i = 0; i < vi->qindex; i++) {
75 elem = vi->queue[i].elem;
76 len = iov_from_buf(elem->in_sg, elem->in_num,
77 0, &vi->queue[i].event, sizeof(virtio_input_event));
78 vu_queue_push(dev, vq, elem, len);
79 free(elem);
80 }
81
82 vu_queue_notify(&vi->dev.parent, vq);
83 vi->qindex = 0;
84 }
85
86 static void
87 vi_evdev_watch(VuDev *dev, int condition, void *data)
88 {
89 VuInput *vi = data;
90 int fd = vi->evdevfd;
91
92 g_debug("Got evdev condition %x", condition);
93
94 struct virtio_input_event virtio;
95 struct input_event evdev;
96 int rc;
97
98 for (;;) {
99 rc = read(fd, &evdev, sizeof(evdev));
100 if (rc != sizeof(evdev)) {
101 break;
102 }
103
104 g_debug("input %d %d %d", evdev.type, evdev.code, evdev.value);
105
106 virtio.type = htole16(evdev.type);
107 virtio.code = htole16(evdev.code);
108 virtio.value = htole32(evdev.value);
109 vi_input_send(vi, &virtio);
110 }
111 }
112
113
114 static void vi_handle_status(VuInput *vi, virtio_input_event *event)
115 {
116 struct input_event evdev;
117 struct timeval tval;
118 int rc;
119
120 if (gettimeofday(&tval, NULL)) {
121 perror("vi_handle_status: gettimeofday");
122 return;
123 }
124
125 evdev.input_event_sec = tval.tv_sec;
126 evdev.input_event_usec = tval.tv_usec;
127 evdev.type = le16toh(event->type);
128 evdev.code = le16toh(event->code);
129 evdev.value = le32toh(event->value);
130
131 rc = write(vi->evdevfd, &evdev, sizeof(evdev));
132 if (rc == -1) {
133 perror("vi_host_handle_status: write");
134 }
135 }
136
137 static void vi_handle_sts(VuDev *dev, int qidx)
138 {
139 VuInput *vi = container_of(dev, VuInput, dev.parent);
140 VuVirtq *vq = vu_get_queue(dev, qidx);
141 virtio_input_event event;
142 VuVirtqElement *elem;
143 int len;
144
145 g_debug("%s", G_STRFUNC);
146
147 for (;;) {
148 elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
149 if (!elem) {
150 break;
151 }
152
153 memset(&event, 0, sizeof(event));
154 len = iov_to_buf(elem->out_sg, elem->out_num,
155 0, &event, sizeof(event));
156 vi_handle_status(vi, &event);
157 vu_queue_push(dev, vq, elem, len);
158 free(elem);
159 }
160
161 vu_queue_notify(&vi->dev.parent, vq);
162 }
163
164 static void
165 vi_panic(VuDev *dev, const char *msg)
166 {
167 g_critical("%s\n", msg);
168 exit(EXIT_FAILURE);
169 }
170
171 static void
172 vi_queue_set_started(VuDev *dev, int qidx, bool started)
173 {
174 VuInput *vi = container_of(dev, VuInput, dev.parent);
175 VuVirtq *vq = vu_get_queue(dev, qidx);
176
177 g_debug("queue started %d:%d", qidx, started);
178
179 if (qidx == 1) {
180 vu_set_queue_handler(dev, vq, started ? vi_handle_sts : NULL);
181 }
182
183 started = vu_queue_started(dev, vu_get_queue(dev, 0)) &&
184 vu_queue_started(dev, vu_get_queue(dev, 1));
185
186 if (started && !vi->evsrc) {
187 vi->evsrc = vug_source_new(&vi->dev, vi->evdevfd,
188 G_IO_IN, vi_evdev_watch, vi);
189 }
190
191 if (!started && vi->evsrc) {
192 vug_source_destroy(vi->evsrc);
193 vi->evsrc = NULL;
194 }
195 }
196
197 static virtio_input_config *
198 vi_find_config(VuInput *vi, uint8_t select, uint8_t subsel)
199 {
200 virtio_input_config *cfg;
201 int i;
202
203 for (i = 0; i < vi->config->len; i++) {
204 cfg = &g_array_index(vi->config, virtio_input_config, i);
205 if (select == cfg->select && subsel == cfg->subsel) {
206 return cfg;
207 }
208 }
209
210 return NULL;
211 }
212
213 static int vi_get_config(VuDev *dev, uint8_t *config, uint32_t len)
214 {
215 VuInput *vi = container_of(dev, VuInput, dev.parent);
216
217 if (len > sizeof(*vi->sel_config)) {
218 return -1;
219 }
220
221 if (vi->sel_config) {
222 memcpy(config, vi->sel_config, len);
223 } else {
224 memset(config, 0, len);
225 }
226
227 return 0;
228 }
229
230 static int vi_set_config(VuDev *dev, const uint8_t *data,
231 uint32_t offset, uint32_t size,
232 uint32_t flags)
233 {
234 VuInput *vi = container_of(dev, VuInput, dev.parent);
235 virtio_input_config *config = (virtio_input_config *)data;
236
237 vi->sel_config = vi_find_config(vi, config->select, config->subsel);
238
239 return 0;
240 }
241
242 static const VuDevIface vuiface = {
243 .queue_set_started = vi_queue_set_started,
244 .get_config = vi_get_config,
245 .set_config = vi_set_config,
246 };
247
248 static void
249 vi_bits_config(VuInput *vi, int type, int count)
250 {
251 virtio_input_config bits;
252 int rc, i, size = 0;
253
254 memset(&bits, 0, sizeof(bits));
255 rc = ioctl(vi->evdevfd, EVIOCGBIT(type, count / 8), bits.u.bitmap);
256 if (rc < 0) {
257 return;
258 }
259
260 for (i = 0; i < count / 8; i++) {
261 if (bits.u.bitmap[i]) {
262 size = i + 1;
263 }
264 }
265 if (size == 0) {
266 return;
267 }
268
269 bits.select = VIRTIO_INPUT_CFG_EV_BITS;
270 bits.subsel = type;
271 bits.size = size;
272 g_array_append_val(vi->config, bits);
273 }
274
275 static char *opt_evdev;
276 static int opt_fdnum = -1;
277 static char *opt_socket_path;
278 static gboolean opt_nograb;
279 static gboolean opt_print_caps;
280
281 static GOptionEntry entries[] = {
282 { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &opt_print_caps,
283 "Print capabilities", NULL },
284 { "no-grab", 'n', 0, G_OPTION_ARG_NONE, &opt_nograb,
285 "Don't grab device", NULL },
286 { "fd", 'f', 0, G_OPTION_ARG_INT, &opt_fdnum,
287 "Use inherited fd socket", "FDNUM" },
288 { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &opt_socket_path,
289 "Use UNIX socket path", "PATH" },
290 { "evdev-path", 'p', 0, G_OPTION_ARG_FILENAME, &opt_evdev,
291 "evdev input device path", "PATH" },
292 { NULL, }
293 };
294
295 int
296 main(int argc, char *argv[])
297 {
298 GMainLoop *loop = NULL;
299 VuInput vi = { 0, };
300 int rc, ver, fd;
301 virtio_input_config id;
302 struct input_id ids;
303 GError *error = NULL;
304 GOptionContext *context;
305
306 context = g_option_context_new(NULL);
307 g_option_context_add_main_entries(context, entries, NULL);
308 if (!g_option_context_parse(context, &argc, &argv, &error)) {
309 g_printerr("Option parsing failed: %s\n", error->message);
310 exit(EXIT_FAILURE);
311 }
312 if (opt_print_caps) {
313 g_print("{\n");
314 g_print(" \"type\": \"input\",\n");
315 g_print(" \"features\": [\n");
316 g_print(" \"evdev-path\",\n");
317 g_print(" \"no-grab\"\n");
318 g_print(" ]\n");
319 g_print("}\n");
320 exit(EXIT_SUCCESS);
321 }
322 if (!opt_evdev) {
323 g_printerr("Please specify an evdev path\n");
324 exit(EXIT_FAILURE);
325 }
326 if ((!!opt_socket_path + (opt_fdnum != -1)) != 1) {
327 g_printerr("Please specify either --fd or --socket-path\n");
328 exit(EXIT_FAILURE);
329 }
330
331 vi.evdevfd = open(opt_evdev, O_RDWR);
332 if (vi.evdevfd < 0) {
333 g_printerr("Failed to open evdev: %s\n", g_strerror(errno));
334 exit(EXIT_FAILURE);
335 }
336
337 rc = ioctl(vi.evdevfd, EVIOCGVERSION, &ver);
338 if (rc < 0) {
339 g_printerr("%s: is not an evdev device\n", argv[1]);
340 exit(EXIT_FAILURE);
341 }
342
343 if (!opt_nograb) {
344 rc = ioctl(vi.evdevfd, EVIOCGRAB, 1);
345 if (rc < 0) {
346 g_printerr("Failed to grab device\n");
347 exit(EXIT_FAILURE);
348 }
349 }
350
351 vi.config = g_array_new(false, false, sizeof(virtio_input_config));
352 memset(&id, 0, sizeof(id));
353 if (ioctl(vi.evdevfd, EVIOCGNAME(sizeof(id.u.string) - 1),
354 id.u.string) < 0) {
355 g_printerr("Failed to get evdev name: %s\n", g_strerror(errno));
356 exit(EXIT_FAILURE);
357 }
358 id.select = VIRTIO_INPUT_CFG_ID_NAME;
359 id.size = strlen(id.u.string);
360 g_array_append_val(vi.config, id);
361
362 if (ioctl(vi.evdevfd, EVIOCGID, &ids) == 0) {
363 memset(&id, 0, sizeof(id));
364 id.select = VIRTIO_INPUT_CFG_ID_DEVIDS;
365 id.size = sizeof(struct virtio_input_devids);
366 id.u.ids.bustype = cpu_to_le16(ids.bustype);
367 id.u.ids.vendor = cpu_to_le16(ids.vendor);
368 id.u.ids.product = cpu_to_le16(ids.product);
369 id.u.ids.version = cpu_to_le16(ids.version);
370 g_array_append_val(vi.config, id);
371 }
372
373 vi_bits_config(&vi, EV_KEY, KEY_CNT);
374 vi_bits_config(&vi, EV_REL, REL_CNT);
375 vi_bits_config(&vi, EV_ABS, ABS_CNT);
376 vi_bits_config(&vi, EV_MSC, MSC_CNT);
377 vi_bits_config(&vi, EV_SW, SW_CNT);
378 g_debug("config length: %u", vi.config->len);
379
380 if (opt_socket_path) {
381 int lsock = unix_listen(opt_socket_path, &error_fatal);
382 if (lsock < 0) {
383 g_printerr("Failed to listen on %s.\n", opt_socket_path);
384 exit(EXIT_FAILURE);
385 }
386 fd = accept(lsock, NULL, NULL);
387 close(lsock);
388 } else {
389 fd = opt_fdnum;
390 }
391 if (fd == -1) {
392 g_printerr("Invalid vhost-user socket.\n");
393 exit(EXIT_FAILURE);
394 }
395
396 if (!vug_init(&vi.dev, VHOST_USER_INPUT_MAX_QUEUES, fd, vi_panic,
397 &vuiface)) {
398 g_printerr("Failed to initialize libvhost-user-glib.\n");
399 exit(EXIT_FAILURE);
400 }
401
402 loop = g_main_loop_new(NULL, FALSE);
403 g_main_loop_run(loop);
404 g_main_loop_unref(loop);
405
406 vug_deinit(&vi.dev);
407
408 vug_source_destroy(vi.evsrc);
409 g_array_free(vi.config, TRUE);
410 g_free(vi.queue);
411 return 0;
412 }