[qemu.git] / hw / input / virtio-input-hid.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 "qemu/iov.h"

#include "hw/qdev.h"
#include "hw/virtio/virtio.h"
#include "hw/virtio/virtio-input.h"

#undef CONFIG_CURSES
#include "ui/console.h"

#include "standard-headers/linux/input.h"

#define VIRTIO_ID_NAME_KEYBOARD "QEMU Virtio Keyboard"
#define VIRTIO_ID_NAME_MOUSE    "QEMU Virtio Mouse"
#define VIRTIO_ID_NAME_TABLET   "QEMU Virtio Tablet"

/* ----------------------------------------------------------------- */

static const unsigned short keymap_button[INPUT_BUTTON__MAX] = {
    [INPUT_BUTTON_LEFT]              = BTN_LEFT,
    [INPUT_BUTTON_RIGHT]             = BTN_RIGHT,
    [INPUT_BUTTON_MIDDLE]            = BTN_MIDDLE,
    [INPUT_BUTTON_WHEEL_UP]          = BTN_GEAR_UP,
    [INPUT_BUTTON_WHEEL_DOWN]        = BTN_GEAR_DOWN,
    [INPUT_BUTTON_SIDE]              = BTN_SIDE,
    [INPUT_BUTTON_EXTRA]             = BTN_EXTRA,
};

static const unsigned short axismap_rel[INPUT_AXIS__MAX] = {
    [INPUT_AXIS_X]                   = REL_X,
    [INPUT_AXIS_Y]                   = REL_Y,
};

static const unsigned short axismap_abs[INPUT_AXIS__MAX] = {
    [INPUT_AXIS_X]                   = ABS_X,
    [INPUT_AXIS_Y]                   = ABS_Y,
};

/* ----------------------------------------------------------------- */

static void virtio_input_key_config(VirtIOInput *vinput,
                                    const unsigned short *keymap,
                                    size_t mapsize)
{
    virtio_input_config keys;
    int i, bit, byte, bmax = 0;

    memset(&keys, 0, sizeof(keys));
    for (i = 0; i < mapsize; i++) {
        bit = keymap[i];
        if (!bit) {
            continue;
        }
        byte = bit / 8;
        bit  = bit % 8;
        keys.u.bitmap[byte] |= (1 << bit);
        if (bmax < byte+1) {
            bmax = byte+1;
        }
    }
    keys.select = VIRTIO_INPUT_CFG_EV_BITS;
    keys.subsel = EV_KEY;
    keys.size   = bmax;
    virtio_input_add_config(vinput, &keys);
}

static void virtio_input_handle_event(DeviceState *dev, QemuConsole *src,
                                      InputEvent *evt)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
    VirtIOInput *vinput = VIRTIO_INPUT(dev);
    virtio_input_event event;
    int qcode;
    InputKeyEvent *key;
    InputMoveEvent *move;
    InputBtnEvent *btn;

    switch (evt->type) {
    case INPUT_EVENT_KIND_KEY:
        key = evt->u.key.data;
        qcode = qemu_input_key_value_to_qcode(key->key);
        if (qcode < qemu_input_map_qcode_to_linux_len &&
            qemu_input_map_qcode_to_linux[qcode]) {
            event.type  = cpu_to_le16(EV_KEY);
            event.code  = cpu_to_le16(qemu_input_map_qcode_to_linux[qcode]);
            event.value = cpu_to_le32(key->down ? 1 : 0);
            virtio_input_send(vinput, &event);
        } else {
            if (key->down) {
                fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__,
                        qcode, QKeyCode_str(qcode));
            }
        }
        break;
    case INPUT_EVENT_KIND_BTN:
        btn = evt->u.btn.data;
        if (vhid->wheel_axis &&
            (btn->button == INPUT_BUTTON_WHEEL_UP ||
             btn->button == INPUT_BUTTON_WHEEL_DOWN) &&
            btn->down) {
            event.type  = cpu_to_le16(EV_REL);
            event.code  = cpu_to_le16(REL_WHEEL);
            event.value = cpu_to_le32(btn->button == INPUT_BUTTON_WHEEL_UP
                                      ? 1 : -1);
            virtio_input_send(vinput, &event);
        } else if (keymap_button[btn->button]) {
            event.type  = cpu_to_le16(EV_KEY);
            event.code  = cpu_to_le16(keymap_button[btn->button]);
            event.value = cpu_to_le32(btn->down ? 1 : 0);
            virtio_input_send(vinput, &event);
        } else {
            if (btn->down) {
                fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__,
                        btn->button,
                        InputButton_str(btn->button));
            }
        }
        break;
    case INPUT_EVENT_KIND_REL:
        move = evt->u.rel.data;
        event.type  = cpu_to_le16(EV_REL);
        event.code  = cpu_to_le16(axismap_rel[move->axis]);
        event.value = cpu_to_le32(move->value);
        virtio_input_send(vinput, &event);
        break;
    case INPUT_EVENT_KIND_ABS:
        move = evt->u.abs.data;
        event.type  = cpu_to_le16(EV_ABS);
        event.code  = cpu_to_le16(axismap_abs[move->axis]);
        event.value = cpu_to_le32(move->value);
        virtio_input_send(vinput, &event);
        break;
    default:
        /* keep gcc happy */
        break;
    }
}

static void virtio_input_handle_sync(DeviceState *dev)
{
    VirtIOInput *vinput = VIRTIO_INPUT(dev);
    virtio_input_event event = {
        .type  = cpu_to_le16(EV_SYN),
        .code  = cpu_to_le16(SYN_REPORT),
        .value = 0,
    };

    virtio_input_send(vinput, &event);
}

static void virtio_input_hid_realize(DeviceState *dev, Error **errp)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);

    vhid->hs = qemu_input_handler_register(dev, vhid->handler);
    if (vhid->display && vhid->hs) {
        qemu_input_handler_bind(vhid->hs, vhid->display, vhid->head, NULL);
    }
}

static void virtio_input_hid_unrealize(DeviceState *dev, Error **errp)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
    qemu_input_handler_unregister(vhid->hs);
}

static void virtio_input_hid_change_active(VirtIOInput *vinput)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);

    if (vinput->active) {
        qemu_input_handler_activate(vhid->hs);
    } else {
        qemu_input_handler_deactivate(vhid->hs);
    }
}

static void virtio_input_hid_handle_status(VirtIOInput *vinput,
                                           virtio_input_event *event)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
    int ledbit = 0;

    switch (le16_to_cpu(event->type)) {
    case EV_LED:
        if (event->code == LED_NUML) {
            ledbit = QEMU_NUM_LOCK_LED;
        } else if (event->code == LED_CAPSL) {
            ledbit = QEMU_CAPS_LOCK_LED;
        } else if (event->code == LED_SCROLLL) {
            ledbit = QEMU_SCROLL_LOCK_LED;
        }
        if (event->value) {
            vhid->ledstate |= ledbit;
        } else {
            vhid->ledstate &= ~ledbit;
        }
        kbd_put_ledstate(vhid->ledstate);
        break;
    default:
        fprintf(stderr, "%s: unknown type %d\n", __func__,
                le16_to_cpu(event->type));
        break;
    }
}

static Property virtio_input_hid_properties[] = {
    DEFINE_PROP_STRING("display", VirtIOInputHID, display),
    DEFINE_PROP_UINT32("head", VirtIOInputHID, head, 0),
    DEFINE_PROP_END_OF_LIST(),
};

static void virtio_input_hid_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass);

    dc->props          = virtio_input_hid_properties;
    vic->realize       = virtio_input_hid_realize;
    vic->unrealize     = virtio_input_hid_unrealize;
    vic->change_active = virtio_input_hid_change_active;
    vic->handle_status = virtio_input_hid_handle_status;
}

static const TypeInfo virtio_input_hid_info = {
    .name          = TYPE_VIRTIO_INPUT_HID,
    .parent        = TYPE_VIRTIO_INPUT,
    .instance_size = sizeof(VirtIOInputHID),
    .class_init    = virtio_input_hid_class_init,
    .abstract      = true,
};

/* ----------------------------------------------------------------- */

static QemuInputHandler virtio_keyboard_handler = {
    .name  = VIRTIO_ID_NAME_KEYBOARD,
    .mask  = INPUT_EVENT_MASK_KEY,
    .event = virtio_input_handle_event,
    .sync  = virtio_input_handle_sync,
};

static struct virtio_input_config virtio_keyboard_config[] = {
    {
        .select    = VIRTIO_INPUT_CFG_ID_NAME,
        .size      = sizeof(VIRTIO_ID_NAME_KEYBOARD),
        .u.string  = VIRTIO_ID_NAME_KEYBOARD,
    },{
        .select    = VIRTIO_INPUT_CFG_ID_DEVIDS,
        .size      = sizeof(struct virtio_input_devids),
        .u.ids     = {
            .bustype = const_le16(BUS_VIRTUAL),
            .vendor  = const_le16(0x0627), /* same we use for usb hid devices */
            .product = const_le16(0x0001),
            .version = const_le16(0x0001),
        },
    },{
        .select    = VIRTIO_INPUT_CFG_EV_BITS,
        .subsel    = EV_REP,
        .size      = 1,
    },{
        .select    = VIRTIO_INPUT_CFG_EV_BITS,
        .subsel    = EV_LED,
        .size      = 1,
        .u.bitmap  = {
            (1 << LED_NUML) | (1 << LED_CAPSL) | (1 << LED_SCROLLL),
        },
    },
    { /* end of list */ },
};

static void virtio_keyboard_init(Object *obj)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
    VirtIOInput *vinput = VIRTIO_INPUT(obj);

    vhid->handler = &virtio_keyboard_handler;
    virtio_input_init_config(vinput, virtio_keyboard_config);
    virtio_input_key_config(vinput, qemu_input_map_qcode_to_linux,
                            qemu_input_map_qcode_to_linux_len);
}

static const TypeInfo virtio_keyboard_info = {
    .name          = TYPE_VIRTIO_KEYBOARD,
    .parent        = TYPE_VIRTIO_INPUT_HID,
    .instance_size = sizeof(VirtIOInputHID),
    .instance_init = virtio_keyboard_init,
};

/* ----------------------------------------------------------------- */

static QemuInputHandler virtio_mouse_handler = {
    .name  = VIRTIO_ID_NAME_MOUSE,
    .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
    .event = virtio_input_handle_event,
    .sync  = virtio_input_handle_sync,
};

static struct virtio_input_config virtio_mouse_config_v1[] = {
    {
        .select    = VIRTIO_INPUT_CFG_ID_NAME,
        .size      = sizeof(VIRTIO_ID_NAME_MOUSE),
        .u.string  = VIRTIO_ID_NAME_MOUSE,
    },{
        .select    = VIRTIO_INPUT_CFG_ID_DEVIDS,
        .size      = sizeof(struct virtio_input_devids),
        .u.ids     = {
            .bustype = const_le16(BUS_VIRTUAL),
            .vendor  = const_le16(0x0627), /* same we use for usb hid devices */
            .product = const_le16(0x0002),
            .version = const_le16(0x0001),
        },
    },{
        .select    = VIRTIO_INPUT_CFG_EV_BITS,
        .subsel    = EV_REL,
        .size      = 1,
        .u.bitmap  = {
            (1 << REL_X) | (1 << REL_Y),
        },
    },
    { /* end of list */ },
};

static struct virtio_input_config virtio_mouse_config_v2[] = {
    {
        .select    = VIRTIO_INPUT_CFG_ID_NAME,
        .size      = sizeof(VIRTIO_ID_NAME_MOUSE),
        .u.string  = VIRTIO_ID_NAME_MOUSE,
    },{
        .select    = VIRTIO_INPUT_CFG_ID_DEVIDS,
        .size      = sizeof(struct virtio_input_devids),
        .u.ids     = {
            .bustype = const_le16(BUS_VIRTUAL),
            .vendor  = const_le16(0x0627), /* same we use for usb hid devices */
            .product = const_le16(0x0002),
            .version = const_le16(0x0002),
        },
    },{
        .select    = VIRTIO_INPUT_CFG_EV_BITS,
        .subsel    = EV_REL,
        .size      = 2,
        .u.bitmap  = {
            (1 << REL_X) | (1 << REL_Y),
            (1 << (REL_WHEEL - 8))
        },
    },
    { /* end of list */ },
};

static Property virtio_mouse_properties[] = {
    DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
    DEFINE_PROP_END_OF_LIST(),
};

static void virtio_mouse_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);

    dc->props  = virtio_mouse_properties;
}

static void virtio_mouse_init(Object *obj)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
    VirtIOInput *vinput = VIRTIO_INPUT(obj);

    vhid->handler = &virtio_mouse_handler;
    virtio_input_init_config(vinput, vhid->wheel_axis
                             ? virtio_mouse_config_v2
                             : virtio_mouse_config_v1);
    virtio_input_key_config(vinput, keymap_button,
                            ARRAY_SIZE(keymap_button));
}

static const TypeInfo virtio_mouse_info = {
    .name          = TYPE_VIRTIO_MOUSE,
    .parent        = TYPE_VIRTIO_INPUT_HID,
    .instance_size = sizeof(VirtIOInputHID),
    .instance_init = virtio_mouse_init,
    .class_init    = virtio_mouse_class_init,
};

/* ----------------------------------------------------------------- */

static QemuInputHandler virtio_tablet_handler = {
    .name  = VIRTIO_ID_NAME_TABLET,
    .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
    .event = virtio_input_handle_event,
    .sync  = virtio_input_handle_sync,
};

static struct virtio_input_config virtio_tablet_config_v1[] = {
    {
        .select    = VIRTIO_INPUT_CFG_ID_NAME,
        .size      = sizeof(VIRTIO_ID_NAME_TABLET),
        .u.string  = VIRTIO_ID_NAME_TABLET,
    },{
        .select    = VIRTIO_INPUT_CFG_ID_DEVIDS,
        .size      = sizeof(struct virtio_input_devids),
        .u.ids     = {
            .bustype = const_le16(BUS_VIRTUAL),
            .vendor  = const_le16(0x0627), /* same we use for usb hid devices */
            .product = const_le16(0x0003),
            .version = const_le16(0x0001),
        },
    },{
        .select    = VIRTIO_INPUT_CFG_EV_BITS,
        .subsel    = EV_ABS,
        .size      = 1,
        .u.bitmap  = {
            (1 << ABS_X) | (1 << ABS_Y),
        },
    },{
        .select    = VIRTIO_INPUT_CFG_ABS_INFO,
        .subsel    = ABS_X,
        .size      = sizeof(virtio_input_absinfo),
        .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
        .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
    },{
        .select    = VIRTIO_INPUT_CFG_ABS_INFO,
        .subsel    = ABS_Y,
        .size      = sizeof(virtio_input_absinfo),
        .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
        .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
    },
    { /* end of list */ },
};

static struct virtio_input_config virtio_tablet_config_v2[] = {
    {
        .select    = VIRTIO_INPUT_CFG_ID_NAME,
        .size      = sizeof(VIRTIO_ID_NAME_TABLET),
        .u.string  = VIRTIO_ID_NAME_TABLET,
    },{
        .select    = VIRTIO_INPUT_CFG_ID_DEVIDS,
        .size      = sizeof(struct virtio_input_devids),
        .u.ids     = {
            .bustype = const_le16(BUS_VIRTUAL),
            .vendor  = const_le16(0x0627), /* same we use for usb hid devices */
            .product = const_le16(0x0003),
            .version = const_le16(0x0002),
        },
    },{
        .select    = VIRTIO_INPUT_CFG_EV_BITS,
        .subsel    = EV_ABS,
        .size      = 1,
        .u.bitmap  = {
            (1 << ABS_X) | (1 << ABS_Y),
        },
    },{
        .select    = VIRTIO_INPUT_CFG_EV_BITS,
        .subsel    = EV_REL,
        .size      = 2,
        .u.bitmap  = {
            0,
            (1 << (REL_WHEEL - 8))
        },
    },{
        .select    = VIRTIO_INPUT_CFG_ABS_INFO,
        .subsel    = ABS_X,
        .size      = sizeof(virtio_input_absinfo),
        .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
        .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
    },{
        .select    = VIRTIO_INPUT_CFG_ABS_INFO,
        .subsel    = ABS_Y,
        .size      = sizeof(virtio_input_absinfo),
        .u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
        .u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
    },
    { /* end of list */ },
};

static Property virtio_tablet_properties[] = {
    DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
    DEFINE_PROP_END_OF_LIST(),
};

static void virtio_tablet_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);

    dc->props  = virtio_tablet_properties;
}

static void virtio_tablet_init(Object *obj)
{
    VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
    VirtIOInput *vinput = VIRTIO_INPUT(obj);

    vhid->handler = &virtio_tablet_handler;
    virtio_input_init_config(vinput, vhid->wheel_axis
                             ? virtio_tablet_config_v2
                             : virtio_tablet_config_v1);
    virtio_input_key_config(vinput, keymap_button,
                            ARRAY_SIZE(keymap_button));
}

static const TypeInfo virtio_tablet_info = {
    .name          = TYPE_VIRTIO_TABLET,
    .parent        = TYPE_VIRTIO_INPUT_HID,
    .instance_size = sizeof(VirtIOInputHID),
    .instance_init = virtio_tablet_init,
    .class_init    = virtio_tablet_class_init,
};

/* ----------------------------------------------------------------- */

static void virtio_register_types(void)
{
    type_register_static(&virtio_input_hid_info);
    type_register_static(&virtio_keyboard_info);
    type_register_static(&virtio_mouse_info);
    type_register_static(&virtio_tablet_info);
}

type_init(virtio_register_types)
Commit	Line	Data
55a1d80a 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
9b8bfe21	7	#include "qemu/osdep.h"
55a1d80a GH	8	#include "qemu/iov.h"
	9
	10	#include "hw/qdev.h"
	11	#include "hw/virtio/virtio.h"
	12	#include "hw/virtio/virtio-input.h"
	13
	14	#undef CONFIG_CURSES
	15	#include "ui/console.h"
	16
	17	#include "standard-headers/linux/input.h"
	18
	19	#define VIRTIO_ID_NAME_KEYBOARD "QEMU Virtio Keyboard"
	20	#define VIRTIO_ID_NAME_MOUSE "QEMU Virtio Mouse"
	21	#define VIRTIO_ID_NAME_TABLET "QEMU Virtio Tablet"
	22
	23	/* ----------------------------------------------------------------- */
	24
ae6b06ab	25	static const unsigned short keymap_button[INPUT_BUTTON__MAX] = {
55a1d80a GH	26	[INPUT_BUTTON_LEFT] = BTN_LEFT,
	27	[INPUT_BUTTON_RIGHT] = BTN_RIGHT,
	28	[INPUT_BUTTON_MIDDLE] = BTN_MIDDLE,
f22d0af0 GH	29	[INPUT_BUTTON_WHEEL_UP] = BTN_GEAR_UP,
f22d0af0 GH	30	[INPUT_BUTTON_WHEEL_DOWN] = BTN_GEAR_DOWN,
2416760f M	31	[INPUT_BUTTON_SIDE] = BTN_SIDE,
2416760f M	32	[INPUT_BUTTON_EXTRA] = BTN_EXTRA,
55a1d80a GH	33	};
55a1d80a GH	34
ae6b06ab	35	static const unsigned short axismap_rel[INPUT_AXIS__MAX] = {
55a1d80a GH	36	[INPUT_AXIS_X] = REL_X,
	37	[INPUT_AXIS_Y] = REL_Y,
	38	};
	39
ae6b06ab	40	static const unsigned short axismap_abs[INPUT_AXIS__MAX] = {
55a1d80a GH	41	[INPUT_AXIS_X] = ABS_X,
	42	[INPUT_AXIS_Y] = ABS_Y,
	43	};
	44
	45	/* ----------------------------------------------------------------- */
	46
	47	static void virtio_input_key_config(VirtIOInput *vinput,
ae6b06ab	48	const unsigned short *keymap,
55a1d80a GH	49	size_t mapsize)
	50	{
	51	virtio_input_config keys;
	52	int i, bit, byte, bmax = 0;
	53
	54	memset(&keys, 0, sizeof(keys));
	55	for (i = 0; i < mapsize; i++) {
	56	bit = keymap[i];
	57	if (!bit) {
	58	continue;
	59	}
	60	byte = bit / 8;
	61	bit = bit % 8;
	62	keys.u.bitmap[byte] \|= (1 << bit);
	63	if (bmax < byte+1) {
	64	bmax = byte+1;
	65	}
	66	}
	67	keys.select = VIRTIO_INPUT_CFG_EV_BITS;
	68	keys.subsel = EV_KEY;
	69	keys.size = bmax;
	70	virtio_input_add_config(vinput, &keys);
	71	}
	72
	73	static void virtio_input_handle_event(DeviceState dev, QemuConsole src,
	74	InputEvent *evt)
	75	{
f4924974	76	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
55a1d80a GH	77	VirtIOInput *vinput = VIRTIO_INPUT(dev);
	78	virtio_input_event event;
	79	int qcode;
b5a1b443 EB	80	InputKeyEvent *key;
	81	InputMoveEvent *move;
	82	InputBtnEvent *btn;
55a1d80a	83
568c73a4	84	switch (evt->type) {
55a1d80a	85	case INPUT_EVENT_KIND_KEY:
32bafa8f	86	key = evt->u.key.data;
b5a1b443	87	qcode = qemu_input_key_value_to_qcode(key->key);
ae6b06ab DB	88	if (qcode < qemu_input_map_qcode_to_linux_len &&
ae6b06ab DB	89	qemu_input_map_qcode_to_linux[qcode]) {
55a1d80a	90	event.type = cpu_to_le16(EV_KEY);
ae6b06ab	91	event.code = cpu_to_le16(qemu_input_map_qcode_to_linux[qcode]);
b5a1b443	92	event.value = cpu_to_le32(key->down ? 1 : 0);
55a1d80a GH	93	virtio_input_send(vinput, &event);
55a1d80a GH	94	} else {
b5a1b443	95	if (key->down) {
55a1d80a	96	fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__,
977c736f	97	qcode, QKeyCode_str(qcode));
55a1d80a GH	98	}
	99	}
	100	break;
	101	case INPUT_EVENT_KIND_BTN:
32bafa8f	102	btn = evt->u.btn.data;
a5f99be4 M	103	if (vhid->wheel_axis &&
	104	(btn->button == INPUT_BUTTON_WHEEL_UP \|\|
	105	btn->button == INPUT_BUTTON_WHEEL_DOWN) &&
	106	btn->down) {
f4924974 GH	107	event.type = cpu_to_le16(EV_REL);
	108	event.code = cpu_to_le16(REL_WHEEL);
	109	event.value = cpu_to_le32(btn->button == INPUT_BUTTON_WHEEL_UP
	110	? 1 : -1);
	111	virtio_input_send(vinput, &event);
	112	} else if (keymap_button[btn->button]) {
55a1d80a	113	event.type = cpu_to_le16(EV_KEY);
b5a1b443 EB	114	event.code = cpu_to_le16(keymap_button[btn->button]);
b5a1b443 EB	115	event.value = cpu_to_le32(btn->down ? 1 : 0);
55a1d80a GH	116	virtio_input_send(vinput, &event);
55a1d80a GH	117	} else {
b5a1b443	118	if (btn->down) {
55a1d80a	119	fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__,
b5a1b443	120	btn->button,
977c736f	121	InputButton_str(btn->button));
55a1d80a GH	122	}
	123	}
	124	break;
	125	case INPUT_EVENT_KIND_REL:
32bafa8f	126	move = evt->u.rel.data;
55a1d80a	127	event.type = cpu_to_le16(EV_REL);
b5a1b443 EB	128	event.code = cpu_to_le16(axismap_rel[move->axis]);
b5a1b443 EB	129	event.value = cpu_to_le32(move->value);
55a1d80a GH	130	virtio_input_send(vinput, &event);
	131	break;
	132	case INPUT_EVENT_KIND_ABS:
32bafa8f	133	move = evt->u.abs.data;
55a1d80a	134	event.type = cpu_to_le16(EV_ABS);
b5a1b443 EB	135	event.code = cpu_to_le16(axismap_abs[move->axis]);
b5a1b443 EB	136	event.value = cpu_to_le32(move->value);
55a1d80a GH	137	virtio_input_send(vinput, &event);
	138	break;
	139	default:
	140	/* keep gcc happy */
	141	break;
	142	}
	143	}
	144
	145	static void virtio_input_handle_sync(DeviceState *dev)
	146	{
	147	VirtIOInput *vinput = VIRTIO_INPUT(dev);
	148	virtio_input_event event = {
	149	.type = cpu_to_le16(EV_SYN),
	150	.code = cpu_to_le16(SYN_REPORT),
	151	.value = 0,
	152	};
	153
	154	virtio_input_send(vinput, &event);
	155	}
	156
	157	static void virtio_input_hid_realize(DeviceState dev, Error *errp)
	158	{
	159	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
5cce1733	160
55a1d80a	161	vhid->hs = qemu_input_handler_register(dev, vhid->handler);
5cce1733 GH	162	if (vhid->display && vhid->hs) {
	163	qemu_input_handler_bind(vhid->hs, vhid->display, vhid->head, NULL);
	164	}
55a1d80a GH	165	}
	166
	167	static void virtio_input_hid_unrealize(DeviceState dev, Error *errp)
	168	{
	169	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(dev);
	170	qemu_input_handler_unregister(vhid->hs);
	171	}
	172
	173	static void virtio_input_hid_change_active(VirtIOInput *vinput)
	174	{
	175	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
	176
	177	if (vinput->active) {
	178	qemu_input_handler_activate(vhid->hs);
	179	} else {
	180	qemu_input_handler_deactivate(vhid->hs);
	181	}
	182	}
	183
	184	static void virtio_input_hid_handle_status(VirtIOInput *vinput,
	185	virtio_input_event *event)
	186	{
	187	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(vinput);
	188	int ledbit = 0;
	189
	190	switch (le16_to_cpu(event->type)) {
	191	case EV_LED:
	192	if (event->code == LED_NUML) {
	193	ledbit = QEMU_NUM_LOCK_LED;
	194	} else if (event->code == LED_CAPSL) {
	195	ledbit = QEMU_CAPS_LOCK_LED;
	196	} else if (event->code == LED_SCROLLL) {
	197	ledbit = QEMU_SCROLL_LOCK_LED;
	198	}
	199	if (event->value) {
	200	vhid->ledstate \|= ledbit;
	201	} else {
	202	vhid->ledstate &= ~ledbit;
	203	}
	204	kbd_put_ledstate(vhid->ledstate);
	205	break;
	206	default:
	207	fprintf(stderr, "%s: unknown type %d\n", __func__,
	208	le16_to_cpu(event->type));
	209	break;
	210	}
	211	}
	212
5cce1733 GH	213	static Property virtio_input_hid_properties[] = {
	214	DEFINE_PROP_STRING("display", VirtIOInputHID, display),
	215	DEFINE_PROP_UINT32("head", VirtIOInputHID, head, 0),
2a19b229	216	DEFINE_PROP_END_OF_LIST(),
5cce1733 GH	217	};
5cce1733 GH	218
55a1d80a GH	219	static void virtio_input_hid_class_init(ObjectClass klass, void data)
55a1d80a GH	220	{
5cce1733	221	DeviceClass *dc = DEVICE_CLASS(klass);
55a1d80a GH	222	VirtIOInputClass *vic = VIRTIO_INPUT_CLASS(klass);
55a1d80a GH	223
5cce1733	224	dc->props = virtio_input_hid_properties;
55a1d80a GH	225	vic->realize = virtio_input_hid_realize;
	226	vic->unrealize = virtio_input_hid_unrealize;
	227	vic->change_active = virtio_input_hid_change_active;
	228	vic->handle_status = virtio_input_hid_handle_status;
	229	}
	230
	231	static const TypeInfo virtio_input_hid_info = {
	232	.name = TYPE_VIRTIO_INPUT_HID,
	233	.parent = TYPE_VIRTIO_INPUT,
	234	.instance_size = sizeof(VirtIOInputHID),
	235	.class_init = virtio_input_hid_class_init,
	236	.abstract = true,
	237	};
	238
	239	/* ----------------------------------------------------------------- */
	240
	241	static QemuInputHandler virtio_keyboard_handler = {
	242	.name = VIRTIO_ID_NAME_KEYBOARD,
	243	.mask = INPUT_EVENT_MASK_KEY,
	244	.event = virtio_input_handle_event,
	245	.sync = virtio_input_handle_sync,
	246	};
	247
	248	static struct virtio_input_config virtio_keyboard_config[] = {
	249	{
	250	.select = VIRTIO_INPUT_CFG_ID_NAME,
	251	.size = sizeof(VIRTIO_ID_NAME_KEYBOARD),
	252	.u.string = VIRTIO_ID_NAME_KEYBOARD,
	253	},{
	254	.select = VIRTIO_INPUT_CFG_ID_DEVIDS,
	255	.size = sizeof(struct virtio_input_devids),
	256	.u.ids = {
	257	.bustype = const_le16(BUS_VIRTUAL),
	258	.vendor = const_le16(0x0627), /* same we use for usb hid devices */
	259	.product = const_le16(0x0001),
	260	.version = const_le16(0x0001),
	261	},
	262	},{
	263	.select = VIRTIO_INPUT_CFG_EV_BITS,
	264	.subsel = EV_REP,
	265	.size = 1,
	266	},{
	267	.select = VIRTIO_INPUT_CFG_EV_BITS,
	268	.subsel = EV_LED,
	269	.size = 1,
	270	.u.bitmap = {
	271	(1 << LED_NUML) \| (1 << LED_CAPSL) \| (1 << LED_SCROLLL),
	272	},
	273	},
	274	{ /* end of list */ },
	275	};
	276
	277	static void virtio_keyboard_init(Object *obj)
	278	{
	279	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
	280	VirtIOInput *vinput = VIRTIO_INPUT(obj);
	281
	282	vhid->handler = &virtio_keyboard_handler;
	283	virtio_input_init_config(vinput, virtio_keyboard_config);
ae6b06ab DB	284	virtio_input_key_config(vinput, qemu_input_map_qcode_to_linux,
ae6b06ab DB	285	qemu_input_map_qcode_to_linux_len);
55a1d80a GH	286	}
	287
	288	static const TypeInfo virtio_keyboard_info = {
	289	.name = TYPE_VIRTIO_KEYBOARD,
	290	.parent = TYPE_VIRTIO_INPUT_HID,
	291	.instance_size = sizeof(VirtIOInputHID),
	292	.instance_init = virtio_keyboard_init,
	293	};
	294
	295	/* ----------------------------------------------------------------- */
	296
	297	static QemuInputHandler virtio_mouse_handler = {
	298	.name = VIRTIO_ID_NAME_MOUSE,
	299	.mask = INPUT_EVENT_MASK_BTN \| INPUT_EVENT_MASK_REL,
	300	.event = virtio_input_handle_event,
	301	.sync = virtio_input_handle_sync,
	302	};
	303
f4924974	304	static struct virtio_input_config virtio_mouse_config_v1[] = {
55a1d80a GH	305	{
	306	.select = VIRTIO_INPUT_CFG_ID_NAME,
	307	.size = sizeof(VIRTIO_ID_NAME_MOUSE),
	308	.u.string = VIRTIO_ID_NAME_MOUSE,
	309	},{
	310	.select = VIRTIO_INPUT_CFG_ID_DEVIDS,
	311	.size = sizeof(struct virtio_input_devids),
	312	.u.ids = {
	313	.bustype = const_le16(BUS_VIRTUAL),
	314	.vendor = const_le16(0x0627), /* same we use for usb hid devices */
	315	.product = const_le16(0x0002),
	316	.version = const_le16(0x0001),
	317	},
	318	},{
	319	.select = VIRTIO_INPUT_CFG_EV_BITS,
	320	.subsel = EV_REL,
	321	.size = 1,
	322	.u.bitmap = {
	323	(1 << REL_X) \| (1 << REL_Y),
	324	},
	325	},
	326	{ /* end of list */ },
	327	};
	328
f4924974 GH	329	static struct virtio_input_config virtio_mouse_config_v2[] = {
	330	{
	331	.select = VIRTIO_INPUT_CFG_ID_NAME,
	332	.size = sizeof(VIRTIO_ID_NAME_MOUSE),
	333	.u.string = VIRTIO_ID_NAME_MOUSE,
	334	},{
	335	.select = VIRTIO_INPUT_CFG_ID_DEVIDS,
	336	.size = sizeof(struct virtio_input_devids),
	337	.u.ids = {
	338	.bustype = const_le16(BUS_VIRTUAL),
	339	.vendor = const_le16(0x0627), /* same we use for usb hid devices */
	340	.product = const_le16(0x0002),
	341	.version = const_le16(0x0002),
	342	},
	343	},{
	344	.select = VIRTIO_INPUT_CFG_EV_BITS,
	345	.subsel = EV_REL,
	346	.size = 2,
	347	.u.bitmap = {
	348	(1 << REL_X) \| (1 << REL_Y),
	349	(1 << (REL_WHEEL - 8))
	350	},
	351	},
	352	{ /* end of list */ },
	353	};
	354
	355	static Property virtio_mouse_properties[] = {
	356	DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
	357	DEFINE_PROP_END_OF_LIST(),
	358	};
	359
	360	static void virtio_mouse_class_init(ObjectClass klass, void data)
	361	{
	362	DeviceClass *dc = DEVICE_CLASS(klass);
	363
	364	dc->props = virtio_mouse_properties;
	365	}
	366
55a1d80a GH	367	static void virtio_mouse_init(Object *obj)
	368	{
	369	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
	370	VirtIOInput *vinput = VIRTIO_INPUT(obj);
	371
	372	vhid->handler = &virtio_mouse_handler;
f4924974 GH	373	virtio_input_init_config(vinput, vhid->wheel_axis
	374	? virtio_mouse_config_v2
	375	: virtio_mouse_config_v1);
55a1d80a GH	376	virtio_input_key_config(vinput, keymap_button,
	377	ARRAY_SIZE(keymap_button));
	378	}
	379
	380	static const TypeInfo virtio_mouse_info = {
	381	.name = TYPE_VIRTIO_MOUSE,
	382	.parent = TYPE_VIRTIO_INPUT_HID,
	383	.instance_size = sizeof(VirtIOInputHID),
	384	.instance_init = virtio_mouse_init,
f4924974	385	.class_init = virtio_mouse_class_init,
55a1d80a GH	386	};
	387
	388	/* ----------------------------------------------------------------- */
	389
	390	static QemuInputHandler virtio_tablet_handler = {
	391	.name = VIRTIO_ID_NAME_TABLET,
	392	.mask = INPUT_EVENT_MASK_BTN \| INPUT_EVENT_MASK_ABS,
	393	.event = virtio_input_handle_event,
	394	.sync = virtio_input_handle_sync,
	395	};
	396
f4924974	397	static struct virtio_input_config virtio_tablet_config_v1[] = {
55a1d80a GH	398	{
	399	.select = VIRTIO_INPUT_CFG_ID_NAME,
	400	.size = sizeof(VIRTIO_ID_NAME_TABLET),
	401	.u.string = VIRTIO_ID_NAME_TABLET,
	402	},{
	403	.select = VIRTIO_INPUT_CFG_ID_DEVIDS,
	404	.size = sizeof(struct virtio_input_devids),
	405	.u.ids = {
	406	.bustype = const_le16(BUS_VIRTUAL),
	407	.vendor = const_le16(0x0627), /* same we use for usb hid devices */
	408	.product = const_le16(0x0003),
	409	.version = const_le16(0x0001),
	410	},
	411	},{
	412	.select = VIRTIO_INPUT_CFG_EV_BITS,
	413	.subsel = EV_ABS,
	414	.size = 1,
	415	.u.bitmap = {
	416	(1 << ABS_X) \| (1 << ABS_Y),
	417	},
	418	},{
	419	.select = VIRTIO_INPUT_CFG_ABS_INFO,
	420	.subsel = ABS_X,
	421	.size = sizeof(virtio_input_absinfo),
9cfa7ab9 PV	422	.u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
9cfa7ab9 PV	423	.u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
55a1d80a GH	424	},{
	425	.select = VIRTIO_INPUT_CFG_ABS_INFO,
	426	.subsel = ABS_Y,
	427	.size = sizeof(virtio_input_absinfo),
9cfa7ab9 PV	428	.u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
9cfa7ab9 PV	429	.u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
55a1d80a GH	430	},
	431	{ /* end of list */ },
	432	};
	433
f4924974 GH	434	static struct virtio_input_config virtio_tablet_config_v2[] = {
	435	{
	436	.select = VIRTIO_INPUT_CFG_ID_NAME,
	437	.size = sizeof(VIRTIO_ID_NAME_TABLET),
	438	.u.string = VIRTIO_ID_NAME_TABLET,
	439	},{
	440	.select = VIRTIO_INPUT_CFG_ID_DEVIDS,
	441	.size = sizeof(struct virtio_input_devids),
	442	.u.ids = {
	443	.bustype = const_le16(BUS_VIRTUAL),
	444	.vendor = const_le16(0x0627), /* same we use for usb hid devices */
	445	.product = const_le16(0x0003),
	446	.version = const_le16(0x0002),
	447	},
	448	},{
	449	.select = VIRTIO_INPUT_CFG_EV_BITS,
	450	.subsel = EV_ABS,
	451	.size = 1,
	452	.u.bitmap = {
	453	(1 << ABS_X) \| (1 << ABS_Y),
	454	},
	455	},{
	456	.select = VIRTIO_INPUT_CFG_EV_BITS,
	457	.subsel = EV_REL,
	458	.size = 2,
	459	.u.bitmap = {
	460	0,
	461	(1 << (REL_WHEEL - 8))
	462	},
	463	},{
	464	.select = VIRTIO_INPUT_CFG_ABS_INFO,
	465	.subsel = ABS_X,
	466	.size = sizeof(virtio_input_absinfo),
	467	.u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
	468	.u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
	469	},{
	470	.select = VIRTIO_INPUT_CFG_ABS_INFO,
	471	.subsel = ABS_Y,
	472	.size = sizeof(virtio_input_absinfo),
	473	.u.abs.min = const_le32(INPUT_EVENT_ABS_MIN),
	474	.u.abs.max = const_le32(INPUT_EVENT_ABS_MAX),
	475	},
	476	{ /* end of list */ },
	477	};
	478
	479	static Property virtio_tablet_properties[] = {
	480	DEFINE_PROP_BOOL("wheel-axis", VirtIOInputHID, wheel_axis, true),
	481	DEFINE_PROP_END_OF_LIST(),
	482	};
	483
	484	static void virtio_tablet_class_init(ObjectClass klass, void data)
	485	{
	486	DeviceClass *dc = DEVICE_CLASS(klass);
	487
	488	dc->props = virtio_tablet_properties;
	489	}
	490
55a1d80a GH	491	static void virtio_tablet_init(Object *obj)
	492	{
	493	VirtIOInputHID *vhid = VIRTIO_INPUT_HID(obj);
	494	VirtIOInput *vinput = VIRTIO_INPUT(obj);
	495
	496	vhid->handler = &virtio_tablet_handler;
f4924974 GH	497	virtio_input_init_config(vinput, vhid->wheel_axis
	498	? virtio_tablet_config_v2
	499	: virtio_tablet_config_v1);
55a1d80a GH	500	virtio_input_key_config(vinput, keymap_button,
	501	ARRAY_SIZE(keymap_button));
	502	}
	503
	504	static const TypeInfo virtio_tablet_info = {
	505	.name = TYPE_VIRTIO_TABLET,
	506	.parent = TYPE_VIRTIO_INPUT_HID,
	507	.instance_size = sizeof(VirtIOInputHID),
	508	.instance_init = virtio_tablet_init,
f4924974	509	.class_init = virtio_tablet_class_init,
55a1d80a GH	510	};
	511
	512	/* ----------------------------------------------------------------- */
	513
	514	static void virtio_register_types(void)
	515	{
	516	type_register_static(&virtio_input_hid_info);
	517	type_register_static(&virtio_keyboard_info);
	518	type_register_static(&virtio_mouse_info);
	519	type_register_static(&virtio_tablet_info);
	520	}
	521
	522	type_init(virtio_register_types)