[mirror_qemu.git] / ui / input-linux.c

/*
 * This work is licensed under the terms of the GNU GPL, version 2 or
 * (at your option) any later version.  See the COPYING file in the
 * top-level directory.
 */

#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "qemu/config-file.h"
#include "qemu/sockets.h"
#include "sysemu/sysemu.h"
#include "ui/input.h"

#include <sys/ioctl.h>
#include "standard-headers/linux/input.h"

static int linux_to_qcode[KEY_CNT] = {
    [KEY_ESC]            = Q_KEY_CODE_ESC,
    [KEY_1]              = Q_KEY_CODE_1,
    [KEY_2]              = Q_KEY_CODE_2,
    [KEY_3]              = Q_KEY_CODE_3,
    [KEY_4]              = Q_KEY_CODE_4,
    [KEY_5]              = Q_KEY_CODE_5,
    [KEY_6]              = Q_KEY_CODE_6,
    [KEY_7]              = Q_KEY_CODE_7,
    [KEY_8]              = Q_KEY_CODE_8,
    [KEY_9]              = Q_KEY_CODE_9,
    [KEY_0]              = Q_KEY_CODE_0,
    [KEY_MINUS]          = Q_KEY_CODE_MINUS,
    [KEY_EQUAL]          = Q_KEY_CODE_EQUAL,
    [KEY_BACKSPACE]      = Q_KEY_CODE_BACKSPACE,
    [KEY_TAB]            = Q_KEY_CODE_TAB,
    [KEY_Q]              = Q_KEY_CODE_Q,
    [KEY_W]              = Q_KEY_CODE_W,
    [KEY_E]              = Q_KEY_CODE_E,
    [KEY_R]              = Q_KEY_CODE_R,
    [KEY_T]              = Q_KEY_CODE_T,
    [KEY_Y]              = Q_KEY_CODE_Y,
    [KEY_U]              = Q_KEY_CODE_U,
    [KEY_I]              = Q_KEY_CODE_I,
    [KEY_O]              = Q_KEY_CODE_O,
    [KEY_P]              = Q_KEY_CODE_P,
    [KEY_LEFTBRACE]      = Q_KEY_CODE_BRACKET_LEFT,
    [KEY_RIGHTBRACE]     = Q_KEY_CODE_BRACKET_RIGHT,
    [KEY_ENTER]          = Q_KEY_CODE_RET,
    [KEY_LEFTCTRL]       = Q_KEY_CODE_CTRL,
    [KEY_A]              = Q_KEY_CODE_A,
    [KEY_S]              = Q_KEY_CODE_S,
    [KEY_D]              = Q_KEY_CODE_D,
    [KEY_F]              = Q_KEY_CODE_F,
    [KEY_G]              = Q_KEY_CODE_G,
    [KEY_H]              = Q_KEY_CODE_H,
    [KEY_J]              = Q_KEY_CODE_J,
    [KEY_K]              = Q_KEY_CODE_K,
    [KEY_L]              = Q_KEY_CODE_L,
    [KEY_SEMICOLON]      = Q_KEY_CODE_SEMICOLON,
    [KEY_APOSTROPHE]     = Q_KEY_CODE_APOSTROPHE,
    [KEY_GRAVE]          = Q_KEY_CODE_GRAVE_ACCENT,
    [KEY_LEFTSHIFT]      = Q_KEY_CODE_SHIFT,
    [KEY_BACKSLASH]      = Q_KEY_CODE_BACKSLASH,
    [KEY_102ND]          = Q_KEY_CODE_LESS,
    [KEY_Z]              = Q_KEY_CODE_Z,
    [KEY_X]              = Q_KEY_CODE_X,
    [KEY_C]              = Q_KEY_CODE_C,
    [KEY_V]              = Q_KEY_CODE_V,
    [KEY_B]              = Q_KEY_CODE_B,
    [KEY_N]              = Q_KEY_CODE_N,
    [KEY_M]              = Q_KEY_CODE_M,
    [KEY_COMMA]          = Q_KEY_CODE_COMMA,
    [KEY_DOT]            = Q_KEY_CODE_DOT,
    [KEY_SLASH]          = Q_KEY_CODE_SLASH,
    [KEY_RIGHTSHIFT]     = Q_KEY_CODE_SHIFT_R,
    [KEY_LEFTALT]        = Q_KEY_CODE_ALT,
    [KEY_SPACE]          = Q_KEY_CODE_SPC,
    [KEY_CAPSLOCK]       = Q_KEY_CODE_CAPS_LOCK,
    [KEY_F1]             = Q_KEY_CODE_F1,
    [KEY_F2]             = Q_KEY_CODE_F2,
    [KEY_F3]             = Q_KEY_CODE_F3,
    [KEY_F4]             = Q_KEY_CODE_F4,
    [KEY_F5]             = Q_KEY_CODE_F5,
    [KEY_F6]             = Q_KEY_CODE_F6,
    [KEY_F7]             = Q_KEY_CODE_F7,
    [KEY_F8]             = Q_KEY_CODE_F8,
    [KEY_F9]             = Q_KEY_CODE_F9,
    [KEY_F10]            = Q_KEY_CODE_F10,
    [KEY_NUMLOCK]        = Q_KEY_CODE_NUM_LOCK,
    [KEY_SCROLLLOCK]     = Q_KEY_CODE_SCROLL_LOCK,
    [KEY_KP0]            = Q_KEY_CODE_KP_0,
    [KEY_KP1]            = Q_KEY_CODE_KP_1,
    [KEY_KP2]            = Q_KEY_CODE_KP_2,
    [KEY_KP3]            = Q_KEY_CODE_KP_3,
    [KEY_KP4]            = Q_KEY_CODE_KP_4,
    [KEY_KP5]            = Q_KEY_CODE_KP_5,
    [KEY_KP6]            = Q_KEY_CODE_KP_6,
    [KEY_KP7]            = Q_KEY_CODE_KP_7,
    [KEY_KP8]            = Q_KEY_CODE_KP_8,
    [KEY_KP9]            = Q_KEY_CODE_KP_9,
    [KEY_KPMINUS]        = Q_KEY_CODE_KP_SUBTRACT,
    [KEY_KPPLUS]         = Q_KEY_CODE_KP_ADD,
    [KEY_KPDOT]          = Q_KEY_CODE_KP_DECIMAL,
    [KEY_KPENTER]        = Q_KEY_CODE_KP_ENTER,
    [KEY_KPSLASH]        = Q_KEY_CODE_KP_DIVIDE,
    [KEY_KPASTERISK]     = Q_KEY_CODE_KP_MULTIPLY,
    [KEY_F11]            = Q_KEY_CODE_F11,
    [KEY_F12]            = Q_KEY_CODE_F12,
    [KEY_RIGHTCTRL]      = Q_KEY_CODE_CTRL_R,
    [KEY_SYSRQ]          = Q_KEY_CODE_SYSRQ,
    [KEY_RIGHTALT]       = Q_KEY_CODE_ALT_R,
    [KEY_HOME]           = Q_KEY_CODE_HOME,
    [KEY_UP]             = Q_KEY_CODE_UP,
    [KEY_PAGEUP]         = Q_KEY_CODE_PGUP,
    [KEY_LEFT]           = Q_KEY_CODE_LEFT,
    [KEY_RIGHT]          = Q_KEY_CODE_RIGHT,
    [KEY_END]            = Q_KEY_CODE_END,
    [KEY_DOWN]           = Q_KEY_CODE_DOWN,
    [KEY_PAGEDOWN]       = Q_KEY_CODE_PGDN,
    [KEY_INSERT]         = Q_KEY_CODE_INSERT,
    [KEY_DELETE]         = Q_KEY_CODE_DELETE,
    [KEY_LEFTMETA]       = Q_KEY_CODE_META_L,
    [KEY_RIGHTMETA]      = Q_KEY_CODE_META_R,
    [KEY_MENU]           = Q_KEY_CODE_MENU,
};

static int qemu_input_linux_to_qcode(unsigned int lnx)
{
    assert(lnx < KEY_CNT);
    return linux_to_qcode[lnx];
}

typedef struct InputLinux InputLinux;

struct InputLinux {
    const char  *evdev;
    int         fd;
    bool        repeat;
    bool        grab_request;
    bool        grab_active;
    bool        grab_all;
    bool        keydown[KEY_CNT];
    int         keycount;
    int         wheel;
    QTAILQ_ENTRY(InputLinux) next;
};

static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs);

static void input_linux_toggle_grab(InputLinux *il)
{
    intptr_t request = !il->grab_active;
    InputLinux *item;
    int rc;

    rc = ioctl(il->fd, EVIOCGRAB, request);
    if (rc < 0) {
        return;
    }
    il->grab_active = !il->grab_active;

    if (!il->grab_all) {
        return;
    }
    QTAILQ_FOREACH(item, &inputs, next) {
        if (item == il || item->grab_all) {
            /* avoid endless loops */
            continue;
        }
        if (item->grab_active != il->grab_active) {
            input_linux_toggle_grab(item);
        }
    }
}

static void input_linux_event_keyboard(void *opaque)
{
    InputLinux *il = opaque;
    struct input_event event;
    int rc;

    for (;;) {
        rc = read(il->fd, &event, sizeof(event));
        if (rc != sizeof(event)) {
            if (rc < 0 && errno != EAGAIN) {
                fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
                qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
                close(il->fd);
            }
            break;
        }

        switch (event.type) {
        case EV_KEY:
            if (event.value > 2 || (event.value > 1 && !il->repeat)) {
                /*
                 * ignore autorepeat + unknown key events
                 * 0 == up, 1 == down, 2 == autorepeat, other == undefined
                 */
                continue;
            }
            /* keep track of key state */
            if (!il->keydown[event.code] && event.value) {
                il->keydown[event.code] = true;
                il->keycount++;
            }
            if (il->keydown[event.code] && !event.value) {
                il->keydown[event.code] = false;
                il->keycount--;
            }

            /* send event to guest when grab is active */
            if (il->grab_active) {
                int qcode = qemu_input_linux_to_qcode(event.code);
                qemu_input_event_send_key_qcode(NULL, qcode, event.value);
            }

            /* hotkey -> record switch request ... */
            if (il->keydown[KEY_LEFTCTRL] &&
                il->keydown[KEY_RIGHTCTRL]) {
                il->grab_request = true;
            }

            /*
             * ... and do the switch when all keys are lifted, so we
             * confuse neither guest nor host with keys which seem to
             * be stuck due to missing key-up events.
             */
            if (il->grab_request && !il->keycount) {
                il->grab_request = false;
                input_linux_toggle_grab(il);
            }
            break;
        }
    }
}

static void input_linux_event_mouse_button(int button)
{
    qemu_input_queue_btn(NULL, button, true);
    qemu_input_event_sync();
    qemu_input_queue_btn(NULL, button, false);
    qemu_input_event_sync();
}

static void input_linux_event_mouse(void *opaque)
{
    InputLinux *il = opaque;
    struct input_event event;
    int rc;

    for (;;) {
        rc = read(il->fd, &event, sizeof(event));
        if (rc != sizeof(event)) {
            if (rc < 0 && errno != EAGAIN) {
                fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
                qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
                close(il->fd);
            }
            break;
        }

        /* only send event to guest when grab is active */
        if (!il->grab_active) {
            continue;
        }

        switch (event.type) {
        case EV_KEY:
            switch (event.code) {
            case BTN_LEFT:
                qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event.value);
                break;
            case BTN_RIGHT:
                qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event.value);
                break;
            case BTN_MIDDLE:
                qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event.value);
                break;
            case BTN_GEAR_UP:
                qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event.value);
                break;
            case BTN_GEAR_DOWN:
                qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN,
                                     event.value);
                break;
            };
            break;
        case EV_REL:
            switch (event.code) {
            case REL_X:
                qemu_input_queue_rel(NULL, INPUT_AXIS_X, event.value);
                break;
            case REL_Y:
                qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event.value);
                break;
            case REL_WHEEL:
                il->wheel = event.value;
                break;
            }
            break;
        case EV_SYN:
            qemu_input_event_sync();
            if (il->wheel != 0) {
                input_linux_event_mouse_button((il->wheel > 0)
                                               ? INPUT_BUTTON_WHEEL_UP
                                               : INPUT_BUTTON_WHEEL_DOWN);
                il->wheel = 0;
            }
            break;
        }
    }
}

int input_linux_init(void *opaque, QemuOpts *opts, Error **errp)
{
    InputLinux *il = g_new0(InputLinux, 1);
    uint32_t evtmap;
    int rc, ver;

    il->evdev = qemu_opt_get(opts, "evdev");
    il->grab_all = qemu_opt_get_bool(opts, "grab-all", false);
    il->repeat = qemu_opt_get_bool(opts, "repeat", false);

    if (!il->evdev) {
        error_setg(errp, "no input device specified");
        goto err_free;
    }

    il->fd = open(il->evdev, O_RDWR);
    if (il->fd < 0)  {
        error_setg_file_open(errp, errno, il->evdev);
        goto err_free;
    }
    qemu_set_nonblock(il->fd);

    rc = ioctl(il->fd, EVIOCGVERSION, &ver);
    if (rc < 0) {
        error_setg(errp, "%s: is not an evdev device", il->evdev);
        goto err_close;
    }

    rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap);

    if (evtmap & (1 << EV_REL)) {
        /* has relative axis -> assume mouse */
        qemu_set_fd_handler(il->fd, input_linux_event_mouse, NULL, il);
    } else if (evtmap & (1 << EV_ABS)) {
        /* has absolute axis -> not supported */
        error_setg(errp, "tablet/touchscreen not supported");
        goto err_close;
    } else if (evtmap & (1 << EV_KEY)) {
        /* has keys/buttons (and no axis) -> assume keyboard */
        qemu_set_fd_handler(il->fd, input_linux_event_keyboard, NULL, il);
    } else {
        /* Huh? What is this? */
        error_setg(errp, "unknown kind of input device");
        goto err_close;
    }
    input_linux_toggle_grab(il);
    QTAILQ_INSERT_TAIL(&inputs, il, next);
    return 0;

err_close:
    close(il->fd);
err_free:
    g_free(il);
    return -1;
}

static QemuOptsList qemu_input_linux_opts = {
    .name = "input-linux",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_input_linux_opts.head),
    .implied_opt_name = "evdev",
    .desc = {
        {
            .name = "evdev",
            .type = QEMU_OPT_STRING,
        },{
            .name = "grab-all",
            .type = QEMU_OPT_BOOL,
        },{
            .name = "repeat",
            .type = QEMU_OPT_BOOL,
        },
        { /* end of list */ }
    },
};

static void input_linux_register_config(void)
{
    qemu_add_opts(&qemu_input_linux_opts);
}
opts_init(input_linux_register_config);
Commit	Line	Data
e0d2bd51 GH	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"
da34e65c	8	#include "qapi/error.h"
e0d2bd51 GH	9	#include "qemu-common.h"
	10	#include "qemu/config-file.h"
	11	#include "qemu/sockets.h"
	12	#include "sysemu/sysemu.h"
	13	#include "ui/input.h"
	14
	15	#include <sys/ioctl.h>
	16	#include "standard-headers/linux/input.h"
	17
	18	static int linux_to_qcode[KEY_CNT] = {
	19	[KEY_ESC] = Q_KEY_CODE_ESC,
	20	[KEY_1] = Q_KEY_CODE_1,
	21	[KEY_2] = Q_KEY_CODE_2,
	22	[KEY_3] = Q_KEY_CODE_3,
	23	[KEY_4] = Q_KEY_CODE_4,
	24	[KEY_5] = Q_KEY_CODE_5,
	25	[KEY_6] = Q_KEY_CODE_6,
	26	[KEY_7] = Q_KEY_CODE_7,
	27	[KEY_8] = Q_KEY_CODE_8,
	28	[KEY_9] = Q_KEY_CODE_9,
	29	[KEY_0] = Q_KEY_CODE_0,
	30	[KEY_MINUS] = Q_KEY_CODE_MINUS,
	31	[KEY_EQUAL] = Q_KEY_CODE_EQUAL,
	32	[KEY_BACKSPACE] = Q_KEY_CODE_BACKSPACE,
	33	[KEY_TAB] = Q_KEY_CODE_TAB,
	34	[KEY_Q] = Q_KEY_CODE_Q,
	35	[KEY_W] = Q_KEY_CODE_W,
	36	[KEY_E] = Q_KEY_CODE_E,
	37	[KEY_R] = Q_KEY_CODE_R,
	38	[KEY_T] = Q_KEY_CODE_T,
	39	[KEY_Y] = Q_KEY_CODE_Y,
	40	[KEY_U] = Q_KEY_CODE_U,
	41	[KEY_I] = Q_KEY_CODE_I,
	42	[KEY_O] = Q_KEY_CODE_O,
	43	[KEY_P] = Q_KEY_CODE_P,
	44	[KEY_LEFTBRACE] = Q_KEY_CODE_BRACKET_LEFT,
	45	[KEY_RIGHTBRACE] = Q_KEY_CODE_BRACKET_RIGHT,
	46	[KEY_ENTER] = Q_KEY_CODE_RET,
	47	[KEY_LEFTCTRL] = Q_KEY_CODE_CTRL,
	48	[KEY_A] = Q_KEY_CODE_A,
	49	[KEY_S] = Q_KEY_CODE_S,
	50	[KEY_D] = Q_KEY_CODE_D,
	51	[KEY_F] = Q_KEY_CODE_F,
	52	[KEY_G] = Q_KEY_CODE_G,
	53	[KEY_H] = Q_KEY_CODE_H,
	54	[KEY_J] = Q_KEY_CODE_J,
	55	[KEY_K] = Q_KEY_CODE_K,
	56	[KEY_L] = Q_KEY_CODE_L,
	57	[KEY_SEMICOLON] = Q_KEY_CODE_SEMICOLON,
	58	[KEY_APOSTROPHE] = Q_KEY_CODE_APOSTROPHE,
	59	[KEY_GRAVE] = Q_KEY_CODE_GRAVE_ACCENT,
	60	[KEY_LEFTSHIFT] = Q_KEY_CODE_SHIFT,
	61	[KEY_BACKSLASH] = Q_KEY_CODE_BACKSLASH,
	62	[KEY_102ND] = Q_KEY_CODE_LESS,
	63	[KEY_Z] = Q_KEY_CODE_Z,
	64	[KEY_X] = Q_KEY_CODE_X,
	65	[KEY_C] = Q_KEY_CODE_C,
	66	[KEY_V] = Q_KEY_CODE_V,
	67	[KEY_B] = Q_KEY_CODE_B,
	68	[KEY_N] = Q_KEY_CODE_N,
	69	[KEY_M] = Q_KEY_CODE_M,
	70	[KEY_COMMA] = Q_KEY_CODE_COMMA,
	71	[KEY_DOT] = Q_KEY_CODE_DOT,
	72	[KEY_SLASH] = Q_KEY_CODE_SLASH,
73	[KEY_RIGHTSHIFT] = Q_KEY_CODE_SHIFT_R,
74	[KEY_LEFTALT] = Q_KEY_CODE_ALT,
75	[KEY_SPACE] = Q_KEY_CODE_SPC,
76	[KEY_CAPSLOCK] = Q_KEY_CODE_CAPS_LOCK,
77	[KEY_F1] = Q_KEY_CODE_F1,
78	[KEY_F2] = Q_KEY_CODE_F2,
79	[KEY_F3] = Q_KEY_CODE_F3,
80	[KEY_F4] = Q_KEY_CODE_F4,
81	[KEY_F5] = Q_KEY_CODE_F5,
82	[KEY_F6] = Q_KEY_CODE_F6,
83	[KEY_F7] = Q_KEY_CODE_F7,
84	[KEY_F8] = Q_KEY_CODE_F8,
85	[KEY_F9] = Q_KEY_CODE_F9,
86	[KEY_F10] = Q_KEY_CODE_F10,
87	[KEY_NUMLOCK] = Q_KEY_CODE_NUM_LOCK,
88	[KEY_SCROLLLOCK] = Q_KEY_CODE_SCROLL_LOCK,
89	[KEY_KP0] = Q_KEY_CODE_KP_0,
90	[KEY_KP1] = Q_KEY_CODE_KP_1,
91	[KEY_KP2] = Q_KEY_CODE_KP_2,
92	[KEY_KP3] = Q_KEY_CODE_KP_3,
93	[KEY_KP4] = Q_KEY_CODE_KP_4,
94	[KEY_KP5] = Q_KEY_CODE_KP_5,
95	[KEY_KP6] = Q_KEY_CODE_KP_6,
96	[KEY_KP7] = Q_KEY_CODE_KP_7,
97	[KEY_KP8] = Q_KEY_CODE_KP_8,
98	[KEY_KP9] = Q_KEY_CODE_KP_9,
99	[KEY_KPMINUS] = Q_KEY_CODE_KP_SUBTRACT,
100	[KEY_KPPLUS] = Q_KEY_CODE_KP_ADD,
101	[KEY_KPDOT] = Q_KEY_CODE_KP_DECIMAL,
102	[KEY_KPENTER] = Q_KEY_CODE_KP_ENTER,
103	[KEY_KPSLASH] = Q_KEY_CODE_KP_DIVIDE,
104	[KEY_KPASTERISK] = Q_KEY_CODE_KP_MULTIPLY,
105	[KEY_F11] = Q_KEY_CODE_F11,
106	[KEY_F12] = Q_KEY_CODE_F12,
107	[KEY_RIGHTCTRL] = Q_KEY_CODE_CTRL_R,
108	[KEY_SYSRQ] = Q_KEY_CODE_SYSRQ,
109	[KEY_RIGHTALT] = Q_KEY_CODE_ALT_R,
110	[KEY_HOME] = Q_KEY_CODE_HOME,
111	[KEY_UP] = Q_KEY_CODE_UP,
112	[KEY_PAGEUP] = Q_KEY_CODE_PGUP,
113	[KEY_LEFT] = Q_KEY_CODE_LEFT,
114	[KEY_RIGHT] = Q_KEY_CODE_RIGHT,
115	[KEY_END] = Q_KEY_CODE_END,
116	[KEY_DOWN] = Q_KEY_CODE_DOWN,
117	[KEY_PAGEDOWN] = Q_KEY_CODE_PGDN,
118	[KEY_INSERT] = Q_KEY_CODE_INSERT,
119	[KEY_DELETE] = Q_KEY_CODE_DELETE,
120	[KEY_LEFTMETA] = Q_KEY_CODE_META_L,
121	[KEY_RIGHTMETA] = Q_KEY_CODE_META_R,
122	[KEY_MENU] = Q_KEY_CODE_MENU,
123	};
124
125	static int qemu_input_linux_to_qcode(unsigned int lnx)
126	{
127	assert(lnx < KEY_CNT);
128	return linux_to_qcode[lnx];
129	}
130
131	typedef struct InputLinux InputLinux;
132
133	struct InputLinux {
134	const char *evdev;
135	int fd;
a6ccabd6	136	bool repeat;
e0d2bd51 GH	137	bool grab_request;
e0d2bd51 GH	138	bool grab_active;
46d921be	139	bool grab_all;
e0d2bd51 GH	140	bool keydown[KEY_CNT];
	141	int keycount;
	142	int wheel;
46d921be	143	QTAILQ_ENTRY(InputLinux) next;
e0d2bd51 GH	144	};
e0d2bd51 GH	145
46d921be GH	146	static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs);
46d921be GH	147
e0d2bd51 GH	148	static void input_linux_toggle_grab(InputLinux *il)
	149	{
	150	intptr_t request = !il->grab_active;
46d921be	151	InputLinux *item;
e0d2bd51 GH	152	int rc;
	153
	154	rc = ioctl(il->fd, EVIOCGRAB, request);
	155	if (rc < 0) {
	156	return;
	157	}
	158	il->grab_active = !il->grab_active;
46d921be GH	159
	160	if (!il->grab_all) {
	161	return;
	162	}
	163	QTAILQ_FOREACH(item, &inputs, next) {
	164	if (item == il \|\| item->grab_all) {
	165	/* avoid endless loops */
	166	continue;
	167	}
	168	if (item->grab_active != il->grab_active) {
	169	input_linux_toggle_grab(item);
	170	}
	171	}
e0d2bd51 GH	172	}
	173
	174	static void input_linux_event_keyboard(void *opaque)
	175	{
	176	InputLinux *il = opaque;
	177	struct input_event event;
	178	int rc;
	179
	180	for (;;) {
	181	rc = read(il->fd, &event, sizeof(event));
	182	if (rc != sizeof(event)) {
	183	if (rc < 0 && errno != EAGAIN) {
	184	fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
	185	qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
	186	close(il->fd);
	187	}
	188	break;
	189	}
	190
	191	switch (event.type) {
	192	case EV_KEY:
a6ccabd6	193	if (event.value > 2 \|\| (event.value > 1 && !il->repeat)) {
e0d2bd51 GH	194	/*
	195	* ignore autorepeat + unknown key events
	196	* 0 == up, 1 == down, 2 == autorepeat, other == undefined
	197	*/
	198	continue;
	199	}
	200	/* keep track of key state */
	201	if (!il->keydown[event.code] && event.value) {
	202	il->keydown[event.code] = true;
	203	il->keycount++;
	204	}
	205	if (il->keydown[event.code] && !event.value) {
	206	il->keydown[event.code] = false;
	207	il->keycount--;
	208	}
	209
	210	/* send event to guest when grab is active */
	211	if (il->grab_active) {
	212	int qcode = qemu_input_linux_to_qcode(event.code);
	213	qemu_input_event_send_key_qcode(NULL, qcode, event.value);
	214	}
	215
	216	/* hotkey -> record switch request ... */
	217	if (il->keydown[KEY_LEFTCTRL] &&
	218	il->keydown[KEY_RIGHTCTRL]) {
	219	il->grab_request = true;
	220	}
	221
	222	/*
	223	* ... and do the switch when all keys are lifted, so we
	224	* confuse neither guest nor host with keys which seem to
	225	* be stuck due to missing key-up events.
	226	*/
	227	if (il->grab_request && !il->keycount) {
	228	il->grab_request = false;
	229	input_linux_toggle_grab(il);
	230	}
	231	break;
	232	}
	233	}
	234	}
	235
	236	static void input_linux_event_mouse_button(int button)
	237	{
	238	qemu_input_queue_btn(NULL, button, true);
	239	qemu_input_event_sync();
	240	qemu_input_queue_btn(NULL, button, false);
	241	qemu_input_event_sync();
	242	}
	243
	244	static void input_linux_event_mouse(void *opaque)
	245	{
	246	InputLinux *il = opaque;
	247	struct input_event event;
	248	int rc;
	249
	250	for (;;) {
	251	rc = read(il->fd, &event, sizeof(event));
	252	if (rc != sizeof(event)) {
	253	if (rc < 0 && errno != EAGAIN) {
	254	fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
	255	qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
	256	close(il->fd);
	257	}
258	break;
259	}
260
46d921be GH	261	/* only send event to guest when grab is active */
	262	if (!il->grab_active) {
	263	continue;
	264	}
	265
e0d2bd51 GH	266	switch (event.type) {
	267	case EV_KEY:
	268	switch (event.code) {
	269	case BTN_LEFT:
	270	qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event.value);
	271	break;
	272	case BTN_RIGHT:
	273	qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event.value);
	274	break;
	275	case BTN_MIDDLE:
	276	qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event.value);
	277	break;
	278	case BTN_GEAR_UP:
	279	qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event.value);
	280	break;
	281	case BTN_GEAR_DOWN:
	282	qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN,
	283	event.value);
	284	break;
	285	};
	286	break;
	287	case EV_REL:
	288	switch (event.code) {
	289	case REL_X:
	290	qemu_input_queue_rel(NULL, INPUT_AXIS_X, event.value);
	291	break;
	292	case REL_Y:
	293	qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event.value);
	294	break;
	295	case REL_WHEEL:
	296	il->wheel = event.value;
	297	break;
	298	}
	299	break;
	300	case EV_SYN:
	301	qemu_input_event_sync();
	302	if (il->wheel != 0) {
	303	input_linux_event_mouse_button((il->wheel > 0)
	304	? INPUT_BUTTON_WHEEL_UP
	305	: INPUT_BUTTON_WHEEL_DOWN);
	306	il->wheel = 0;
	307	}
	308	break;
	309	}
	310	}
	311	}
	312
	313	int input_linux_init(void opaque, QemuOpts opts, Error **errp)
	314	{
	315	InputLinux *il = g_new0(InputLinux, 1);
	316	uint32_t evtmap;
	317	int rc, ver;
	318
	319	il->evdev = qemu_opt_get(opts, "evdev");
46d921be	320	il->grab_all = qemu_opt_get_bool(opts, "grab-all", false);
a6ccabd6	321	il->repeat = qemu_opt_get_bool(opts, "repeat", false);
46d921be	322
e0d2bd51 GH	323	if (!il->evdev) {
	324	error_setg(errp, "no input device specified");
	325	goto err_free;
	326	}
	327
	328	il->fd = open(il->evdev, O_RDWR);
	329	if (il->fd < 0) {
	330	error_setg_file_open(errp, errno, il->evdev);
	331	goto err_free;
	332	}
	333	qemu_set_nonblock(il->fd);
	334
	335	rc = ioctl(il->fd, EVIOCGVERSION, &ver);
	336	if (rc < 0) {
	337	error_setg(errp, "%s: is not an evdev device", il->evdev);
	338	goto err_close;
	339	}
	340
	341	rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap);
	342
	343	if (evtmap & (1 << EV_REL)) {
	344	/* has relative axis -> assume mouse */
	345	qemu_set_fd_handler(il->fd, input_linux_event_mouse, NULL, il);
	346	} else if (evtmap & (1 << EV_ABS)) {
	347	/* has absolute axis -> not supported */
	348	error_setg(errp, "tablet/touchscreen not supported");
	349	goto err_close;
	350	} else if (evtmap & (1 << EV_KEY)) {
	351	/* has keys/buttons (and no axis) -> assume keyboard */
	352	qemu_set_fd_handler(il->fd, input_linux_event_keyboard, NULL, il);
	353	} else {
	354	/* Huh? What is this? */
	355	error_setg(errp, "unknown kind of input device");
	356	goto err_close;
	357	}
	358	input_linux_toggle_grab(il);
46d921be	359	QTAILQ_INSERT_TAIL(&inputs, il, next);
e0d2bd51 GH	360	return 0;
	361
	362	err_close:
	363	close(il->fd);
	364	err_free:
	365	g_free(il);
	366	return -1;
	367	}
	368
	369	static QemuOptsList qemu_input_linux_opts = {
	370	.name = "input-linux",
	371	.head = QTAILQ_HEAD_INITIALIZER(qemu_input_linux_opts.head),
	372	.implied_opt_name = "evdev",
	373	.desc = {
	374	{
	375	.name = "evdev",
	376	.type = QEMU_OPT_STRING,
46d921be GH	377	},{
	378	.name = "grab-all",
	379	.type = QEMU_OPT_BOOL,
a6ccabd6 GH	380	},{
	381	.name = "repeat",
	382	.type = QEMU_OPT_BOOL,
e0d2bd51 GH	383	},
	384	{ /* end of list */ }
	385	},
	386	};
	387
	388	static void input_linux_register_config(void)
	389	{
	390	qemu_add_opts(&qemu_input_linux_opts);
	391	}
34294e2f	392	opts_init(input_linux_register_config);