/*
 * Goldfish 'events' device model
 *
 * Copyright (C) 2007-2008 The Android Open Source Project
 * Copyright (c) 2014 Linaro Limited
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include "hw/sysbus.h"
#include "ui/input.h"
#include "ui/console.h"
#include "hw/input/android_keycodes.h"
#include "hw/input/linux_keycodes.h"

#include "hw/input/goldfish_events.h"

#if defined(USE_ANDROID_EMU)
#include "android/globals.h"  /* for android_hw */
#include "android-qemu2-glue/qemu-control-impl.h"
#endif

/* Multitouch specific code is defined out via EVDEV_MULTITOUCH currently,
 * because upstream has no multitouch related APIs.
 */
/* #define EVDEV_MULTITOUCH */

#define MAX_EVENTS (256 * 4)

typedef struct {
    const char *name;
    int value;
} GoldfishEventCodeInfo;

/* Absolute axes */
#define ABS_X                   0x00
#define ABS_Y                   0x01
#define ABS_Z                   0x02
#define ABS_MT_SLOT             0x2f    /* MT slot being modified */
#define ABS_MT_TOUCH_MAJOR      0x30    /* Major axis of touching ellipse */
#define ABS_MT_TOUCH_MINOR      0x31    /* Minor axis (omit if circular) */
#define ABS_MT_WIDTH_MAJOR      0x32    /* Major axis of approaching ellipse */
#define ABS_MT_WIDTH_MINOR      0x33    /* Minor axis (omit if circular) */
#define ABS_MT_ORIENTATION      0x34    /* Ellipse orientation */
#define ABS_MT_POSITION_X       0x35    /* Center X ellipse position */
#define ABS_MT_POSITION_Y       0x36    /* Center Y ellipse position */
#define ABS_MT_TOOL_TYPE        0x37    /* Type of touching device */
#define ABS_MT_BLOB_ID          0x38    /* Group a set of packets as a blob */
#define ABS_MT_TRACKING_ID      0x39    /* Unique ID of initiated contact */
#define ABS_MT_PRESSURE         0x3a    /* Pressure on contact area */
#define ABS_MT_DISTANCE         0x3b    /* Contact hover distance */
#define ABS_MAX                 0x3f

/* Relative axes */
#define REL_X                   0x00
#define REL_Y                   0x01

#define BTN_TOUCH 0x14a
#define BTN_MOUSE 0x110

#define EV_CODE(_code)    {#_code, (_code)}
#define EV_CODE_END     {NULL, 0}
static const GoldfishEventCodeInfo ev_abs_codes_table[] = {
    EV_CODE(ABS_X),
    EV_CODE(ABS_Y),
    EV_CODE(ABS_Z),
    EV_CODE(ABS_MT_SLOT),
    EV_CODE(ABS_MT_TOUCH_MAJOR),
    EV_CODE(ABS_MT_TOUCH_MINOR),
    EV_CODE(ABS_MT_WIDTH_MAJOR),
    EV_CODE(ABS_MT_WIDTH_MINOR),
    EV_CODE(ABS_MT_ORIENTATION),
    EV_CODE(ABS_MT_POSITION_X),
    EV_CODE(ABS_MT_POSITION_Y),
    EV_CODE(ABS_MT_TOOL_TYPE),
    EV_CODE(ABS_MT_BLOB_ID),
    EV_CODE(ABS_MT_TRACKING_ID),
    EV_CODE(ABS_MT_PRESSURE),
    EV_CODE(ABS_MT_DISTANCE),
    EV_CODE(ABS_MAX),
    EV_CODE_END,
};

/* Relative axes */
#define REL_X                   0x00
#define REL_Y                   0x01
static const GoldfishEventCodeInfo ev_rel_codes_table[] = {
    EV_CODE(REL_X),
    EV_CODE(REL_Y),
    EV_CODE_END,
};

#define BTN_MISC 0x100
#define BTN_0 0x100
#define BTN_1 0x101
#define BTN_2 0x102
#define BTN_3 0x103
#define BTN_4 0x104
#define BTN_5 0x105
#define BTN_6 0x106
#define BTN_7 0x107
#define BTN_8 0x108
#define BTN_9 0x109
#define BTN_MOUSE 0x110
#define BTN_LEFT 0x110
#define BTN_RIGHT 0x111
#define BTN_MIDDLE 0x112
#define BTN_SIDE 0x113
#define BTN_EXTRA 0x114
#define BTN_FORWARD 0x115
#define BTN_BACK 0x116
#define BTN_TASK 0x117
#define BTN_JOYSTICK 0x120
#define BTN_TRIGGER 0x120
#define BTN_THUMB 0x121
#define BTN_THUMB2 0x122
#define BTN_TOP 0x123
#define BTN_TOP2 0x124
#define BTN_PINKIE 0x125
#define BTN_BASE 0x126
#define BTN_BASE2 0x127
#define BTN_BASE3 0x128
#define BTN_BASE4 0x129
#define BTN_BASE5 0x12a
#define BTN_BASE6 0x12b
#define BTN_DEAD 0x12f
#define BTN_GAMEPAD 0x130
#define BTN_A 0x130
#define BTN_B 0x131
#define BTN_C 0x132
#define BTN_X 0x133
#define BTN_Y 0x134
#define BTN_Z 0x135
#define BTN_TL 0x136
#define BTN_TR 0x137
#define BTN_TL2 0x138
#define BTN_TR2 0x139
#define BTN_SELECT 0x13a
#define BTN_START 0x13b
#define BTN_MODE 0x13c
#define BTN_THUMBL 0x13d
#define BTN_THUMBR 0x13e
#define BTN_DIGI 0x140
#define BTN_TOOL_PEN 0x140
#define BTN_TOOL_RUBBER 0x141
#define BTN_TOOL_BRUSH 0x142
#define BTN_TOOL_PENCIL 0x143
#define BTN_TOOL_AIRBRUSH 0x144
#define BTN_TOOL_FINGER 0x145
#define BTN_TOOL_MOUSE 0x146
#define BTN_TOOL_LENS 0x147
#define BTN_TOUCH 0x14a
#define BTN_STYLUS 0x14b
#define BTN_STYLUS2 0x14c
#define BTN_TOOL_DOUBLETAP 0x14d
#define BTN_TOOL_TRIPLETAP 0x14e
#define BTN_WHEEL 0x150
#define BTN_GEAR_DOWN 0x150
#define BTN_GEAR_UP  0x151

#define KEY_CODE(_name, _val) {#_name, _val}
#define BTN_CODE(_code) {#_code, (_code)}
static const GoldfishEventCodeInfo ev_key_codes_table[] = {
    KEY_CODE(KEY_ESC, LINUX_KEY_ESC),
    KEY_CODE(KEY_1, LINUX_KEY_1),
    KEY_CODE(KEY_2, LINUX_KEY_2),
    KEY_CODE(KEY_3, LINUX_KEY_3),
    KEY_CODE(KEY_4, LINUX_KEY_4),
    KEY_CODE(KEY_5, LINUX_KEY_5),
    KEY_CODE(KEY_6, LINUX_KEY_6),
    KEY_CODE(KEY_7, LINUX_KEY_7),
    KEY_CODE(KEY_8, LINUX_KEY_8),
    KEY_CODE(KEY_9, LINUX_KEY_9),
    KEY_CODE(KEY_0, LINUX_KEY_0),
    KEY_CODE(KEY_MINUS, LINUX_KEY_MINUS),
    KEY_CODE(KEY_EQUAL, LINUX_KEY_EQUAL),
    KEY_CODE(KEY_BACKSPACE, LINUX_KEY_BACKSPACE),
    KEY_CODE(KEY_TAB, LINUX_KEY_TAB),
    KEY_CODE(KEY_Q, LINUX_KEY_Q),
    KEY_CODE(KEY_W, LINUX_KEY_W),
    KEY_CODE(KEY_E, LINUX_KEY_E),
    KEY_CODE(KEY_R, LINUX_KEY_R),
    KEY_CODE(KEY_T, LINUX_KEY_T),
    KEY_CODE(KEY_Y, LINUX_KEY_Y),
    KEY_CODE(KEY_U, LINUX_KEY_U),
    KEY_CODE(KEY_I, LINUX_KEY_I),
    KEY_CODE(KEY_O, LINUX_KEY_O),
    KEY_CODE(KEY_P, LINUX_KEY_P),
    KEY_CODE(KEY_LEFTBRACE, LINUX_KEY_LEFTBRACE),
    KEY_CODE(KEY_RIGHTBRACE, LINUX_KEY_RIGHTBRACE),
    KEY_CODE(KEY_ENTER, LINUX_KEY_ENTER),
    KEY_CODE(KEY_LEFTCTRL, LINUX_KEY_LEFTCTRL),
    KEY_CODE(KEY_A, LINUX_KEY_A),
    KEY_CODE(KEY_S, LINUX_KEY_S),
    KEY_CODE(KEY_D, LINUX_KEY_D),
    KEY_CODE(KEY_F, LINUX_KEY_F),
    KEY_CODE(KEY_G, LINUX_KEY_G),
    KEY_CODE(KEY_H, LINUX_KEY_H),
    KEY_CODE(KEY_J, LINUX_KEY_J),
    KEY_CODE(KEY_K, LINUX_KEY_K),
    KEY_CODE(KEY_L, LINUX_KEY_L),
    KEY_CODE(KEY_SEMICOLON, LINUX_KEY_SEMICOLON),
    KEY_CODE(KEY_APOSTROPHE, LINUX_KEY_APOSTROPHE),
    KEY_CODE(KEY_GRAVE, LINUX_KEY_GRAVE),
    KEY_CODE(KEY_LEFTSHIFT, LINUX_KEY_LEFTSHIFT),
    KEY_CODE(KEY_BACKSLASH, LINUX_KEY_BACKSLASH),
    KEY_CODE(KEY_Z, LINUX_KEY_Z),
    KEY_CODE(KEY_X, LINUX_KEY_X),
    KEY_CODE(KEY_C, LINUX_KEY_C),
    KEY_CODE(KEY_V, LINUX_KEY_V),
    KEY_CODE(KEY_B, LINUX_KEY_B),
    KEY_CODE(KEY_N, LINUX_KEY_N),
    KEY_CODE(KEY_M, LINUX_KEY_M),
    KEY_CODE(KEY_COMMA, LINUX_KEY_COMMA),
    KEY_CODE(KEY_DOT, LINUX_KEY_DOT),
    KEY_CODE(KEY_SLASH, LINUX_KEY_SLASH),
    KEY_CODE(KEY_RIGHTSHIFT, LINUX_KEY_RIGHTSHIFT),
    KEY_CODE(KEY_KPASTERISK, LINUX_KEY_KPASTERISK),
    KEY_CODE(KEY_LEFTALT, LINUX_KEY_LEFTALT),
    KEY_CODE(KEY_SPACE, LINUX_KEY_SPACE),
    KEY_CODE(KEY_CAPSLOCK, LINUX_KEY_CAPSLOCK),
    KEY_CODE(KEY_F1, LINUX_KEY_F1),
    KEY_CODE(KEY_F2, LINUX_KEY_F2),
    KEY_CODE(KEY_F3, LINUX_KEY_F3),
    KEY_CODE(KEY_F4, LINUX_KEY_F4),
    KEY_CODE(KEY_F5, LINUX_KEY_F5),
    KEY_CODE(KEY_F6, LINUX_KEY_F6),
    KEY_CODE(KEY_F7, LINUX_KEY_F7),
    KEY_CODE(KEY_F8, LINUX_KEY_F8),
    KEY_CODE(KEY_F9, LINUX_KEY_F9),
    KEY_CODE(KEY_F10, LINUX_KEY_F10),
    KEY_CODE(KEY_NUMLOCK, LINUX_KEY_NUMLOCK),
    KEY_CODE(KEY_SCROLLLOCK, LINUX_KEY_SCROLLLOCK),
    KEY_CODE(KEY_KP7, LINUX_KEY_KP7),
    KEY_CODE(KEY_KP8, LINUX_KEY_KP8),
    KEY_CODE(KEY_KP9, LINUX_KEY_KP9),
    KEY_CODE(KEY_KPMINUS, LINUX_KEY_KPMINUS),
    KEY_CODE(KEY_KP4, LINUX_KEY_KP4),
    KEY_CODE(KEY_KP5, LINUX_KEY_KP5),
    KEY_CODE(KEY_KP6, LINUX_KEY_KP6),
    KEY_CODE(KEY_KPPLUS, LINUX_KEY_KPPLUS),
    KEY_CODE(KEY_KP1, LINUX_KEY_KP1),
    KEY_CODE(KEY_KP2, LINUX_KEY_KP2),
    KEY_CODE(KEY_KP3, LINUX_KEY_KP3),
    KEY_CODE(KEY_KP0, LINUX_KEY_KP0),
    KEY_CODE(KEY_KPDOT, LINUX_KEY_KPDOT),
    KEY_CODE(KEY_ZENKAKUHANKAKU, LINUX_KEY_ZENKAKUHANKAKU),
    KEY_CODE(KEY_102ND, LINUX_KEY_102ND),
    KEY_CODE(KEY_F11, LINUX_KEY_F11),
    KEY_CODE(KEY_F12, LINUX_KEY_F12),
    KEY_CODE(KEY_RO, LINUX_KEY_RO),
    KEY_CODE(KEY_KATAKANA, LINUX_KEY_KATAKANA),
    KEY_CODE(KEY_HIRAGANA, LINUX_KEY_HIRAGANA),
    KEY_CODE(KEY_HENKAN, LINUX_KEY_HENKAN),
    KEY_CODE(KEY_KATAKANAHIRAGANA, LINUX_KEY_KATAKANAHIRAGANA),
    KEY_CODE(KEY_MUHENKAN, LINUX_KEY_MUHENKAN),
    KEY_CODE(KEY_KPJPCOMMA, LINUX_KEY_KPJPCOMMA),
    KEY_CODE(KEY_KPENTER, LINUX_KEY_KPENTER),
    KEY_CODE(KEY_RIGHTCTRL, LINUX_KEY_RIGHTCTRL),
    KEY_CODE(KEY_KPSLASH, LINUX_KEY_KPSLASH),
    KEY_CODE(KEY_SYSRQ, LINUX_KEY_SYSRQ),
    KEY_CODE(KEY_RIGHTALT, LINUX_KEY_RIGHTALT),
    KEY_CODE(KEY_LINEFEED, LINUX_KEY_LINEFEED),
    KEY_CODE(KEY_HOME, LINUX_KEY_HOME),
    KEY_CODE(KEY_UP, LINUX_KEY_UP),
    KEY_CODE(KEY_PAGEUP, LINUX_KEY_PAGEUP),
    KEY_CODE(KEY_LEFT, LINUX_KEY_LEFT),
    KEY_CODE(KEY_RIGHT, LINUX_KEY_RIGHT),
    KEY_CODE(KEY_END, LINUX_KEY_END),
    KEY_CODE(KEY_DOWN, LINUX_KEY_DOWN),
    KEY_CODE(KEY_PAGEDOWN, LINUX_KEY_PAGEDOWN),
    KEY_CODE(KEY_INSERT, LINUX_KEY_INSERT),
    KEY_CODE(KEY_DELETE, LINUX_KEY_DELETE),
    KEY_CODE(KEY_MACRO, LINUX_KEY_MACRO),
    KEY_CODE(KEY_MUTE, LINUX_KEY_MUTE),
    KEY_CODE(KEY_VOLUMEDOWN, LINUX_KEY_VOLUMEDOWN),
    KEY_CODE(KEY_VOLUMEUP, LINUX_KEY_VOLUMEUP),
    KEY_CODE(KEY_POWER, LINUX_KEY_POWER),
    KEY_CODE(KEY_KPEQUAL, LINUX_KEY_KPEQUAL),
    KEY_CODE(KEY_KPPLUSMINUS, LINUX_KEY_KPPLUSMINUS),
    KEY_CODE(KEY_PAUSE, LINUX_KEY_PAUSE),
    KEY_CODE(KEY_KPCOMMA, LINUX_KEY_KPCOMMA),
    KEY_CODE(KEY_HANGEUL, LINUX_KEY_HANGEUL),
    KEY_CODE(KEY_HANJA, LINUX_KEY_HANJA),
    KEY_CODE(KEY_YEN, LINUX_KEY_YEN),
    KEY_CODE(KEY_LEFTMETA, LINUX_KEY_LEFTMETA),
    KEY_CODE(KEY_RIGHTMETA, LINUX_KEY_RIGHTMETA),
    KEY_CODE(KEY_COMPOSE, LINUX_KEY_COMPOSE),
    KEY_CODE(KEY_AGAIN, LINUX_KEY_AGAIN),
    KEY_CODE(KEY_PROPS, LINUX_KEY_PROPS),
    KEY_CODE(KEY_UNDO, LINUX_KEY_UNDO),
    KEY_CODE(KEY_FRONT, LINUX_KEY_FRONT),
    KEY_CODE(KEY_COPY, LINUX_KEY_COPY),
    KEY_CODE(KEY_OPEN, LINUX_KEY_OPEN),
    KEY_CODE(KEY_PASTE, LINUX_KEY_PASTE),
    KEY_CODE(KEY_FIND, LINUX_KEY_FIND),
    KEY_CODE(KEY_CUT, LINUX_KEY_CUT),
    KEY_CODE(KEY_HELP, LINUX_KEY_HELP),
    KEY_CODE(KEY_MENU, LINUX_KEY_MENU),
    KEY_CODE(KEY_CALC, LINUX_KEY_CALC),
    KEY_CODE(KEY_SETUP, LINUX_KEY_SETUP),
    KEY_CODE(KEY_SLEEP, LINUX_KEY_SLEEP),
    KEY_CODE(KEY_WAKEUP, LINUX_KEY_WAKEUP),
    KEY_CODE(KEY_FILE, LINUX_KEY_FILE),
    KEY_CODE(KEY_SENDFILE, LINUX_KEY_SENDFILE),
    KEY_CODE(KEY_DELETEFILE, LINUX_KEY_DELETEFILE),
    KEY_CODE(KEY_XFER, LINUX_KEY_XFER),
    KEY_CODE(KEY_PROG1, LINUX_KEY_PROG1),
    KEY_CODE(KEY_PROG2, LINUX_KEY_PROG2),
    KEY_CODE(KEY_WWW, LINUX_KEY_WWW),
    KEY_CODE(KEY_MSDOS, LINUX_KEY_MSDOS),
    KEY_CODE(KEY_COFFEE, LINUX_KEY_COFFEE),
    KEY_CODE(KEY_DIRECTION, LINUX_KEY_DIRECTION),
    KEY_CODE(KEY_CYCLEWINDOWS, LINUX_KEY_CYCLEWINDOWS),
    KEY_CODE(KEY_MAIL, LINUX_KEY_MAIL),
    KEY_CODE(KEY_BOOKMARKS, LINUX_KEY_BOOKMARKS),
    KEY_CODE(KEY_COMPUTER, LINUX_KEY_COMPUTER),
    KEY_CODE(KEY_BACK, LINUX_KEY_BACK),
    KEY_CODE(KEY_FORWARD, LINUX_KEY_FORWARD),
    KEY_CODE(KEY_CLOSECD, LINUX_KEY_CLOSECD),
    KEY_CODE(KEY_EJECTCD, LINUX_KEY_EJECTCD),
    KEY_CODE(KEY_EJECTCLOSECD, LINUX_KEY_EJECTCLOSECD),
    KEY_CODE(KEY_NEXTSONG, LINUX_KEY_NEXTSONG),
    KEY_CODE(KEY_PLAYPAUSE, LINUX_KEY_PLAYPAUSE),
    KEY_CODE(KEY_PREVIOUSSONG, LINUX_KEY_PREVIOUSSONG),
    KEY_CODE(KEY_STOPCD, LINUX_KEY_STOPCD),
    KEY_CODE(KEY_RECORD, LINUX_KEY_RECORD),
    KEY_CODE(KEY_REWIND, LINUX_KEY_REWIND),
    KEY_CODE(KEY_PHONE, LINUX_KEY_PHONE),
    KEY_CODE(KEY_ISO, LINUX_KEY_ISO),
    KEY_CODE(KEY_CONFIG, LINUX_KEY_CONFIG),
    KEY_CODE(KEY_HOMEPAGE, LINUX_KEY_HOMEPAGE),
    KEY_CODE(KEY_REFRESH, LINUX_KEY_REFRESH),
    KEY_CODE(KEY_EXIT, LINUX_KEY_EXIT),
    KEY_CODE(KEY_MOVE, LINUX_KEY_MOVE),
    KEY_CODE(KEY_EDIT, LINUX_KEY_EDIT),
    KEY_CODE(KEY_SCROLLUP, LINUX_KEY_SCROLLUP),
    KEY_CODE(KEY_SCROLLDOWN, LINUX_KEY_SCROLLDOWN),
    KEY_CODE(KEY_KPLEFTPAREN, LINUX_KEY_KPLEFTPAREN),
    KEY_CODE(KEY_KPRIGHTPAREN, LINUX_KEY_KPRIGHTPAREN),
    KEY_CODE(KEY_NEW, LINUX_KEY_NEW),
    KEY_CODE(KEY_REDO, LINUX_KEY_REDO),
    KEY_CODE(KEY_F13, LINUX_KEY_F13),
    KEY_CODE(KEY_F14, LINUX_KEY_F14),
    KEY_CODE(KEY_F15, LINUX_KEY_F15),
    KEY_CODE(KEY_F16, LINUX_KEY_F16),
    KEY_CODE(KEY_F17, LINUX_KEY_F17),
    KEY_CODE(KEY_F18, LINUX_KEY_F18),
    KEY_CODE(KEY_F19, LINUX_KEY_F19),
    KEY_CODE(KEY_F20, LINUX_KEY_F20),
    KEY_CODE(KEY_F21, LINUX_KEY_F21),
    KEY_CODE(KEY_F22, LINUX_KEY_F22),
    KEY_CODE(KEY_F23, LINUX_KEY_F23),
    KEY_CODE(KEY_F24, LINUX_KEY_F24),
    KEY_CODE(KEY_PLAYCD, LINUX_KEY_PLAYCD),
    KEY_CODE(KEY_PAUSECD, LINUX_KEY_PAUSECD),
    KEY_CODE(KEY_PROG3, LINUX_KEY_PROG3),
    KEY_CODE(KEY_PROG4, LINUX_KEY_PROG4),
    KEY_CODE(KEY_SUSPEND, LINUX_KEY_SUSPEND),
    KEY_CODE(KEY_CLOSE, LINUX_KEY_CLOSE),
    KEY_CODE(KEY_PLAY, LINUX_KEY_PLAY),
    KEY_CODE(KEY_FASTFORWARD, LINUX_KEY_FASTFORWARD),
    KEY_CODE(KEY_BASSBOOST, LINUX_KEY_BASSBOOST),
    KEY_CODE(KEY_PRINT, LINUX_KEY_PRINT),
    KEY_CODE(KEY_HP, LINUX_KEY_HP),
    KEY_CODE(KEY_CAMERA, LINUX_KEY_CAMERA),
    KEY_CODE(KEY_SOUND, LINUX_KEY_SOUND),
    KEY_CODE(KEY_QUESTION, LINUX_KEY_QUESTION),
    KEY_CODE(KEY_EMAIL, LINUX_KEY_EMAIL),
    KEY_CODE(KEY_CHAT, LINUX_KEY_CHAT),
    KEY_CODE(KEY_SEARCH, LINUX_KEY_SEARCH),
    KEY_CODE(KEY_CONNECT, LINUX_KEY_CONNECT),
    KEY_CODE(KEY_FINANCE, LINUX_KEY_FINANCE),
    KEY_CODE(KEY_SPORT, LINUX_KEY_SPORT),
    KEY_CODE(KEY_SHOP, LINUX_KEY_SHOP),
    KEY_CODE(KEY_ALTERASE, LINUX_KEY_ALTERASE),
    KEY_CODE(KEY_CANCEL, LINUX_KEY_CANCEL),
    KEY_CODE(KEY_BRIGHTNESSDOWN, LINUX_KEY_BRIGHTNESSDOWN),
    KEY_CODE(KEY_BRIGHTNESSUP, LINUX_KEY_BRIGHTNESSUP),
    KEY_CODE(KEY_MEDIA, LINUX_KEY_MEDIA),
    KEY_CODE(KEY_STAR, LINUX_KEY_STAR),
    KEY_CODE(KEY_SHARP, LINUX_KEY_SHARP),
    KEY_CODE(KEY_SOFT1, LINUX_KEY_SOFT1),
    KEY_CODE(KEY_SOFT2, LINUX_KEY_SOFT2),
    KEY_CODE(KEY_CENTER, LINUX_KEY_CENTER),
    KEY_CODE(KEY_HEADSETHOOK, LINUX_KEY_HEADSETHOOK),
    KEY_CODE(KEY_0_5, LINUX_KEY_0_5),
    KEY_CODE(KEY_2_5, LINUX_KEY_2_5),
    KEY_CODE(KEY_SWITCHVIDEOMODE, LINUX_KEY_SWITCHVIDEOMODE),
    KEY_CODE(KEY_KBDILLUMTOGGLE, LINUX_KEY_KBDILLUMTOGGLE),
    KEY_CODE(KEY_KBDILLUMDOWN, LINUX_KEY_KBDILLUMDOWN),
    KEY_CODE(KEY_KBDILLUMUP, LINUX_KEY_KBDILLUMUP),
    KEY_CODE(KEY_SEND, LINUX_KEY_SEND),
    KEY_CODE(KEY_REPLY, LINUX_KEY_REPLY),
    KEY_CODE(KEY_FORWARDMAIL, LINUX_KEY_FORWARDMAIL),
    KEY_CODE(KEY_SAVE, LINUX_KEY_SAVE),
    KEY_CODE(KEY_DOCUMENTS, LINUX_KEY_DOCUMENTS),
    KEY_CODE(KEY_BATTERY, LINUX_KEY_BATTERY),
    KEY_CODE(KEY_UNKNOWN, LINUX_KEY_UNKNOWN),
    KEY_CODE(KEY_NUM, LINUX_KEY_NUM),
    KEY_CODE(KEY_FOCUS, LINUX_KEY_FOCUS),
    KEY_CODE(KEY_PLUS, LINUX_KEY_PLUS),
    KEY_CODE(KEY_NOTIFICATION, LINUX_KEY_NOTIFICATION),

    KEY_CODE(KEY_APPSWITCH, ANDROID_KEY_APPSWITCH),

    BTN_CODE(BTN_MISC),
    BTN_CODE(BTN_0),
    BTN_CODE(BTN_1),
    BTN_CODE(BTN_2),
    BTN_CODE(BTN_3),
    BTN_CODE(BTN_4),
    BTN_CODE(BTN_5),
    BTN_CODE(BTN_6),
    BTN_CODE(BTN_7),
    BTN_CODE(BTN_8),
    BTN_CODE(BTN_9),
    BTN_CODE(BTN_MOUSE),
    BTN_CODE(BTN_LEFT),
    BTN_CODE(BTN_RIGHT),
    BTN_CODE(BTN_MIDDLE),
    BTN_CODE(BTN_SIDE),
    BTN_CODE(BTN_EXTRA),
    BTN_CODE(BTN_FORWARD),
    BTN_CODE(BTN_BACK),
    BTN_CODE(BTN_TASK),
    BTN_CODE(BTN_JOYSTICK),
    BTN_CODE(BTN_TRIGGER),
    BTN_CODE(BTN_THUMB),
    BTN_CODE(BTN_THUMB2),
    BTN_CODE(BTN_TOP),
    BTN_CODE(BTN_TOP2),
    BTN_CODE(BTN_PINKIE),
    BTN_CODE(BTN_BASE),
    BTN_CODE(BTN_BASE2),
    BTN_CODE(BTN_BASE3),
    BTN_CODE(BTN_BASE4),
    BTN_CODE(BTN_BASE5),
    BTN_CODE(BTN_BASE6),
    BTN_CODE(BTN_DEAD),
    BTN_CODE(BTN_GAMEPAD),
    BTN_CODE(BTN_A),
    BTN_CODE(BTN_B),
    BTN_CODE(BTN_C),
    BTN_CODE(BTN_X),
    BTN_CODE(BTN_Y),
    BTN_CODE(BTN_Z),
    BTN_CODE(BTN_TL),
    BTN_CODE(BTN_TR),
    BTN_CODE(BTN_TL2),
    BTN_CODE(BTN_TR2),
    BTN_CODE(BTN_SELECT),
    BTN_CODE(BTN_START),
    BTN_CODE(BTN_MODE),
    BTN_CODE(BTN_THUMBL),
    BTN_CODE(BTN_THUMBR),
    BTN_CODE(BTN_DIGI),
    BTN_CODE(BTN_TOOL_PEN),
    BTN_CODE(BTN_TOOL_RUBBER),
    BTN_CODE(BTN_TOOL_BRUSH),
    BTN_CODE(BTN_TOOL_PENCIL),
    BTN_CODE(BTN_TOOL_AIRBRUSH),
    BTN_CODE(BTN_TOOL_FINGER),
    BTN_CODE(BTN_TOOL_MOUSE),
    BTN_CODE(BTN_TOOL_LENS),
    BTN_CODE(BTN_TOUCH),
    BTN_CODE(BTN_STYLUS),
    BTN_CODE(BTN_STYLUS2),
    BTN_CODE(BTN_TOOL_DOUBLETAP),
    BTN_CODE(BTN_TOOL_TRIPLETAP),
    BTN_CODE(BTN_WHEEL),
    BTN_CODE(BTN_GEAR_DOWN),
    BTN_CODE(BTN_GEAR_UP),
    EV_CODE_END,
};

typedef struct {
    const char *name;
    int value;
    const GoldfishEventCodeInfo *codes;
} GoldfishEventTypeInfo;

/* Event types (as per Linux input event layer) */
#define EV_SYN                  0x00
#define EV_KEY                  0x01
#define EV_REL                  0x02
#define EV_ABS                  0x03
#define EV_MSC                  0x04
#define EV_SW                   0x05
#define EV_LED                  0x11
#define EV_SND                  0x12
#define EV_REP                  0x14
#define EV_FF                   0x15
#define EV_PWR                  0x16
#define EV_FF_STATUS            0x17
#define EV_MAX                  0x1f

#define EV_TYPE(_type, _codes)    {#_type, (_type), _codes}
#define EV_TYPE_END     {NULL, 0}
static const GoldfishEventTypeInfo ev_type_table[] = {
    EV_TYPE(EV_SYN, NULL),
    EV_TYPE(EV_KEY, ev_key_codes_table),
    EV_TYPE(EV_REL, ev_rel_codes_table),
    EV_TYPE(EV_ABS, ev_abs_codes_table),
    EV_TYPE(EV_MSC, NULL),
    EV_TYPE(EV_SW, NULL),
    EV_TYPE(EV_LED, NULL),
    EV_TYPE(EV_SND, NULL),
    EV_TYPE(EV_REP, NULL),
    EV_TYPE(EV_FF, NULL),
    EV_TYPE(EV_PWR, NULL),
    EV_TYPE(EV_FF_STATUS, NULL),
    EV_TYPE(EV_MAX, NULL),
    EV_TYPE_END
};

enum {
    REG_READ        = 0x00,
    REG_SET_PAGE    = 0x00,
    REG_LEN         = 0x04,
    REG_DATA        = 0x08,

    PAGE_NAME       = 0x00000,
    PAGE_EVBITS     = 0x10000,
    PAGE_ABSDATA    = 0x20000 | EV_ABS,
};

/* These corresponds to the state of the driver.
 * Unfortunately, we have to buffer events coming
 * from the UI, since the kernel driver is not
 * capable of receiving them until XXXXXX
 */
enum {
    STATE_INIT = 0,  /* The device is initialized */
    STATE_BUFFERED,  /* Events have been buffered, but no IRQ raised yet */
    STATE_LIVE       /* Events can be sent directly to the kernel */
};

/* NOTE: The ev_bits arrays are used to indicate to the kernel
 *       which events can be sent by the emulated hardware.
 */

#define TYPE_GOLDFISHEVDEV "goldfish-events"
#define GOLDFISHEVDEV(obj) \
    OBJECT_CHECK(GoldfishEvDevState, (obj), TYPE_GOLDFISHEVDEV)

typedef struct GoldfishEvDevState {
    /*< private >*/
    SysBusDevice parent_obj;
    /*< public >*/

    MemoryRegion iomem;
    qemu_irq irq;

    /* Device properties (TODO: actually make these props) */
    bool have_dpad;
    bool have_trackball;
    bool have_camera;
    bool have_keyboard;
    bool have_keyboard_lid;
    bool have_touch;
    bool have_multitouch;

    /* Actual device state */
    int32_t page;
    uint32_t events[MAX_EVENTS];
    uint32_t first;
    uint32_t last;
    uint32_t state;

    uint32_t modifier_state;

    /* All data below here is set up at realize and not modified thereafter */

    const char *name;

    struct {
        size_t   len;
        uint8_t *bits;
    } ev_bits[EV_MAX + 1];

    int32_t *abs_info;
    size_t abs_info_count;
} GoldfishEvDevState;

/* Bitfield meanings for modifier_state. */
#define MODSTATE_SHIFT (1 << 0)
#define MODSTATE_CTRL (1 << 1)
#define MODSTATE_ALT (1 << 2)
#define MODSTATE_MASK (MODSTATE_SHIFT | MODSTATE_CTRL | MODSTATE_ALT)

/* An entry in the array of ABS_XXX values */
typedef struct ABSEntry {
    /* Minimum ABS_XXX value. */
    uint32_t    min;
    /* Maximum ABS_XXX value. */
    uint32_t    max;
    /* 'fuzz;, and 'flat' ABS_XXX values are always zero here. */
    uint32_t    fuzz;
    uint32_t    flat;
} ABSEntry;

static const VMStateDescription vmstate_gf_evdev = {
    .name = "goldfish-events",
    .version_id = 1,
    .minimum_version_id = 1,
    .fields = (VMStateField[]) {
        VMSTATE_INT32(page, GoldfishEvDevState),
        VMSTATE_UINT32_ARRAY(events, GoldfishEvDevState, MAX_EVENTS),
        VMSTATE_UINT32(first, GoldfishEvDevState),
        VMSTATE_UINT32(last, GoldfishEvDevState),
        VMSTATE_UINT32(state, GoldfishEvDevState),
        VMSTATE_UINT32(modifier_state, GoldfishEvDevState),
        VMSTATE_END_OF_LIST()
    }
};

static void enqueue_event(GoldfishEvDevState *s,
                          unsigned int type, unsigned int code, int value)
{
    int  enqueued = s->last - s->first;

    if (enqueued < 0) {
        enqueued += MAX_EVENTS;
    }

    if (enqueued + 3 > MAX_EVENTS) {
        fprintf(stderr, "##KBD: Full queue, lose event\n");
        return;
    }

    if (s->first == s->last) {
        if (s->state == STATE_LIVE) {
            qemu_irq_raise(s->irq);
        } else {
            s->state = STATE_BUFFERED;
        }
    }

    s->events[s->last] = type;
    s->last = (s->last + 1) & (MAX_EVENTS-1);
    s->events[s->last] = code;
    s->last = (s->last + 1) & (MAX_EVENTS-1);
    s->events[s->last] = value;
    s->last = (s->last + 1) & (MAX_EVENTS-1);
}

static unsigned dequeue_event(GoldfishEvDevState *s)
{
    unsigned n;

    if (s->first == s->last) {
        return 0;
    }

    n = s->events[s->first];

    s->first = (s->first + 1) & (MAX_EVENTS - 1);

    if (s->first == s->last) {
        qemu_irq_lower(s->irq);
    }
#ifdef TARGET_I386
    /*
     * Adding the logic to handle edge-triggered interrupts for x86
     * because the exisiting goldfish events device basically provides
     * level-trigger interrupts only.
     *
     * Logic: When an event (including the type/code/value) is fetched
     * by the driver, if there is still another event in the event
     * queue, the goldfish event device will re-assert the IRQ so that
     * the driver can be notified to fetch the event again.
     */
    else if (((s->first + 2) & (MAX_EVENTS - 1)) < s->last ||
               (s->first & (MAX_EVENTS - 1)) > s->last) {
        /* if there still is an event */
        qemu_irq_lower(s->irq);
        qemu_irq_raise(s->irq);
    }
#endif
    return n;
}

static int get_page_len(GoldfishEvDevState *s)
{
    int page = s->page;
    if (page == PAGE_NAME) {
        const char *name = s->name;
        return strlen(name);
    }
    if (page >= PAGE_EVBITS && page <= PAGE_EVBITS + EV_MAX) {
        return s->ev_bits[page - PAGE_EVBITS].len;
    }
    if (page == PAGE_ABSDATA) {
        return s->abs_info_count * sizeof(s->abs_info[0]);
    }
    return 0;
}

static int get_page_data(GoldfishEvDevState *s, int offset)
{
    int page_len = get_page_len(s);
    int page = s->page;
    if (offset > page_len) {
        return 0;
    }
    if (page == PAGE_NAME) {
        const char *name = s->name;
        return name[offset];
    }
    if (page >= PAGE_EVBITS && page <= PAGE_EVBITS + EV_MAX) {
        return s->ev_bits[page - PAGE_EVBITS].bits[offset];
    }
    if (page == PAGE_ABSDATA) {
        return s->abs_info[offset / sizeof(s->abs_info[0])];
    }
    return 0;
}

int gf_event_send(int type, int code, int value)
{
    DeviceState *s = qdev_find_recursive(sysbus_get_default(),
                                           TYPE_GOLDFISHEVDEV);
    GoldfishEvDevState *dev = GOLDFISHEVDEV(s);

    if (dev) {
        enqueue_event(dev, type, code, value);
    }

    return 0;
}

static uint64_t events_read(void *opaque, hwaddr offset, unsigned size)
{
    GoldfishEvDevState *s = (GoldfishEvDevState *)opaque;

    /* This gross hack below is used to ensure that we
     * only raise the IRQ when the kernel driver is
     * properly ready! If done before this, the driver
     * becomes confused and ignores all input events
     * as soon as one was buffered!
     */
    if (offset == REG_LEN && s->page == PAGE_ABSDATA) {
        if (s->state == STATE_BUFFERED) {
            qemu_irq_raise(s->irq);
        }
        s->state = STATE_LIVE;
    }

    switch (offset) {
    case REG_READ:
        return dequeue_event(s);
    case REG_LEN:
        return get_page_len(s);
    default:
        if (offset >= REG_DATA) {
            return get_page_data(s, offset - REG_DATA);
        }
        qemu_log_mask(LOG_GUEST_ERROR,
                      "goldfish events device read: bad offset %x\n",
                      (int)offset);
        return 0;
    }
}

static void events_write(void *opaque, hwaddr offset,
                         uint64_t val, unsigned size)
{
    GoldfishEvDevState *s = (GoldfishEvDevState *)opaque;
    switch (offset) {
    case REG_SET_PAGE:
        s->page = val;
        break;
    default:
        qemu_log_mask(LOG_GUEST_ERROR,
                      "goldfish events device write: bad offset %x\n",
                      (int)offset);
        break;
    }
}

static const MemoryRegionOps gf_evdev_ops = {
    .read = events_read,
    .write = events_write,
    .endianness = DEVICE_NATIVE_ENDIAN,
};

static void gf_evdev_put_mouse(void *opaque,
                               int dx, int dy, int dz, int buttons_state)
{
    GoldfishEvDevState *s = (GoldfishEvDevState *)opaque;

    /* Note that unlike the "classic" Android emulator, we don't
     * have the "dz == 0 for touchscreen, == 1 for trackball"
     * distinction.
     */
#ifdef EVDEV_MULTITOUCH
    if (s->have_multitouch) {
        /* Convert mouse event into multi-touch event */
        multitouch_update_pointer(MTES_MOUSE, 0, dx, dy,
                                  (buttons_state & 1) ? 0x81 : 0);
        return;
    }
#endif
    if (s->have_touch) {
        enqueue_event(s, EV_ABS, ABS_X, dx);
        enqueue_event(s, EV_ABS, ABS_Y, dy);
        enqueue_event(s, EV_ABS, ABS_Z, dz);
        enqueue_event(s, EV_KEY, BTN_TOUCH, buttons_state & 1);
        enqueue_event(s, EV_SYN, 0, 0);
        return;
    }
    if (s->have_trackball) {
        enqueue_event(s, EV_REL, REL_X, dx);
        enqueue_event(s, EV_REL, REL_Y, dy);
        enqueue_event(s, EV_SYN, 0, 0);
        return;
    }
}

/* set bits [bitl..bith] in the ev_bits[type] array
 */
static void
events_set_bits(GoldfishEvDevState *s, int type, int bitl, int bith)
{
    uint8_t *bits;
    uint8_t maskl, maskh;
    int il, ih;
    il = bitl / 8;
    ih = bith / 8;
    if (ih >= s->ev_bits[type].len) {
        bits = g_malloc0(ih + 1);
        if (bits == NULL) {
            return;
        }
        memcpy(bits, s->ev_bits[type].bits, s->ev_bits[type].len);
        g_free(s->ev_bits[type].bits);
        s->ev_bits[type].bits = bits;
        s->ev_bits[type].len = ih + 1;
    } else {
        bits = s->ev_bits[type].bits;
    }
    maskl = 0xffU << (bitl & 7);
    maskh = 0xffU >> (7 - (bith & 7));
    if (il >= ih) {
        maskh &= maskl;
    } else {
        bits[il] |= maskl;
        while (++il < ih) {
            bits[il] = 0xff;
        }
    }
    bits[ih] |= maskh;
}

static void
events_set_bit(GoldfishEvDevState *s, int  type, int  bit)
{
    events_set_bits(s, type, bit, bit);
}

static void
events_clr_bit(GoldfishEvDevState *s, int type, int bit)
{
    int ii = bit / 8;
    if (ii < s->ev_bits[type].len) {
        uint8_t *bits = s->ev_bits[type].bits;
        uint8_t  mask = 0x01U << (bit & 7);
        bits[ii] &= ~mask;
    }
}

/* Keycode mappings to match the classic Android emulator as documented in
 * http://developer.android.com/tools/help/emulator.html
 */
static const uint16_t hardbutton_map[Q_KEY_CODE_MAX] = {
    [Q_KEY_CODE_HOME] = LINUX_KEY_HOME,
    [Q_KEY_CODE_F2] = LINUX_KEY_SOFT1, /* Android menu key */
    [Q_KEY_CODE_PGUP] = LINUX_KEY_SOFT1,
    [Q_KEY_CODE_PGDN] = LINUX_KEY_SOFT2,
    [Q_KEY_CODE_ESC] = LINUX_KEY_BACK,
    [Q_KEY_CODE_F3] = LINUX_KEY_SEND, /* dial */
    [Q_KEY_CODE_F4] = LINUX_KEY_END, /* end call */
    [Q_KEY_CODE_F5] = LINUX_KEY_SEARCH,
    [Q_KEY_CODE_F7] = LINUX_KEY_POWER,
    [Q_KEY_CODE_KP_ADD] = LINUX_KEY_VOLUMEUP,
    [Q_KEY_CODE_KP_SUBTRACT] = LINUX_KEY_VOLUMEDOWN,
};

static const uint16_t hardbutton_shift_map[Q_KEY_CODE_MAX] = {
    [Q_KEY_CODE_F2] = LINUX_KEY_SOFT2,
};

static const uint16_t hardbutton_control_map[Q_KEY_CODE_MAX] = {
    [Q_KEY_CODE_F5] = LINUX_KEY_VOLUMEUP,
    [Q_KEY_CODE_F6] = LINUX_KEY_VOLUMEDOWN,
    /* ctrl-kp5, ctrl-f3 -> LINUX_KEY_CAMERA (if have_camera) */
};

static const int dpad_map[Q_KEY_CODE_MAX] = {
    [Q_KEY_CODE_KP_4] = LINUX_KEY_LEFT,
    [Q_KEY_CODE_KP_6] = LINUX_KEY_RIGHT,
    [Q_KEY_CODE_KP_8] = LINUX_KEY_UP,
    [Q_KEY_CODE_KP_2] = LINUX_KEY_DOWN,
    [Q_KEY_CODE_KP_5] = LINUX_KEY_CENTER,
};

static void gf_evdev_handle_keyevent(DeviceState *dev, QemuConsole *src,
                                     InputEvent *evt)
{

    GoldfishEvDevState *s = GOLDFISHEVDEV(dev);
    int lkey = 0;
    int mod;

    assert(evt->kind == INPUT_EVENT_KIND_KEY);

    KeyValue* kv = evt->key->key;

    int qcode = kv->qcode;
    
    enqueue_event(s, EV_KEY, qcode, evt->key->down);
    
    /* Keep our modifier state up to date */
    switch (qcode) {
    case Q_KEY_CODE_SHIFT:
    case Q_KEY_CODE_SHIFT_R:
        mod = MODSTATE_SHIFT;
        break;
    case Q_KEY_CODE_ALT:
    case Q_KEY_CODE_ALT_R:
        mod = MODSTATE_ALT;
        break;
    case Q_KEY_CODE_CTRL:
    case Q_KEY_CODE_CTRL_R:
        mod = MODSTATE_CTRL;
        break;
    default:
        mod = 0;
        break;
    }

    if (mod) {
        if (evt->key->down) {
            s->modifier_state |= mod;
        } else {
            s->modifier_state &= ~mod;
        }
    }

    if (s->modifier_state & MODSTATE_ALT) {
        /* No alt-keys defined currently */
    } else if (s->modifier_state & MODSTATE_CTRL) {
        lkey = hardbutton_control_map[qcode];
    } else if (s->modifier_state & MODSTATE_SHIFT) {
        lkey = hardbutton_shift_map[qcode];
    } else {
        lkey = hardbutton_map[qcode];
    }

    if (!lkey && s->have_dpad && s->modifier_state == 0) {
        lkey = dpad_map[qcode];
    }

    if (lkey) {
        enqueue_event(s, EV_KEY, lkey, evt->key->down);
    }
}

static const GoldfishEventTypeInfo *gf_get_event_type(const char *typename)
{
    const GoldfishEventTypeInfo *type = NULL;
    int count = 0;

    /* Find the type descriptor by doing a name match */
    while (ev_type_table[count].name != NULL) {
        if (typename && !strcmp(ev_type_table[count].name, typename)) {
            type = &ev_type_table[count];
            break;
        }
        count++;
    }

    return type;
}

int gf_get_event_type_count(void)
{
    int count = 0;

    while (ev_type_table[count].name != NULL) {
        count++;
    }

    return count;
}

int gf_get_event_type_name(int type, char *buf)
{
   g_stpcpy(buf, ev_type_table[type].name);

   return 0;
}

int gf_get_event_type_value(char *typename)
{
    const GoldfishEventTypeInfo *type = gf_get_event_type(typename);
    int ret = -1;

    if (type) {
        ret = type->value;
    }

    return ret;
}

static const GoldfishEventCodeInfo *gf_get_event_code(int typeval,
                                                      const char *codename)
{
    const GoldfishEventTypeInfo *type = &ev_type_table[typeval];
    const GoldfishEventCodeInfo *code = NULL;
    int count = 0;

    /* Find the type descriptor by doing a name match */
    while (type->codes[count].name != NULL) {
        if (codename && !strcmp(type->codes[count].name, codename)) {
            code = &type->codes[count];
            break;
        }
        count++;
    }

    return code;
}

int gf_get_event_code_count(const char *typename)
{
    const GoldfishEventTypeInfo *type = NULL;
    const GoldfishEventCodeInfo *codes;
    int count = -1;     /* Return -1 if type not found */

    type = gf_get_event_type(typename);

    /* Count the number of codes for the specified type if found */
    if (type) {
        count = 0;
        codes = type->codes;
        if (codes) {
            while (codes[count].name != NULL) {
                count++;
            }
        }
    }

    return count;
}

int gf_get_event_code_name(const char *typename, unsigned int code, char *buf)
{
    const GoldfishEventTypeInfo *type = gf_get_event_type(typename);
    int ret = -1;   /* Return -1 if type not found */

    if (type && type->codes && code < gf_get_event_code_count(typename)) {
        g_stpcpy(buf, type->codes[code].name);
        ret = 0;
    }

    return ret;
}

int gf_get_event_code_value(int typeval, char *codename)
{
    const GoldfishEventCodeInfo *code = gf_get_event_code(typeval, codename);
    int ret = -1;

    if (code) {
        ret = code->value;
    }

    return ret;
}

static QemuInputHandler gf_evdev_key_input_handler = {
    .name = "goldfish event device key handler",
    .mask = INPUT_EVENT_MASK_KEY,
    .event = gf_evdev_handle_keyevent,
};

static void gf_evdev_init(Object *obj)
{
    GoldfishEvDevState *s = GOLDFISHEVDEV(obj);
    DeviceState *dev = DEVICE(obj);
    SysBusDevice *sbd = SYS_BUS_DEVICE(obj);

    memory_region_init_io(&s->iomem, obj, &gf_evdev_ops, s,
                          "goldfish-events", 0x1000);
    sysbus_init_mmio(sbd, &s->iomem);
    sysbus_init_irq(sbd, &s->irq);

    qemu_input_handler_register(dev, &gf_evdev_key_input_handler);
    qemu_add_mouse_event_handler(gf_evdev_put_mouse, s, 1, "goldfish-events");
}

static void gf_evdev_realize(DeviceState *dev, Error **errp)
{
    GoldfishEvDevState *s = GOLDFISHEVDEV(dev);

    /* Initialize the device ID so the event dev can be looked up duringi
     * monitor commands.
     */
    dev->id = g_strdup(TYPE_GOLDFISHEVDEV);

    /* now set the events capability bits depending on hardware configuration */
    /* apparently, the EV_SYN array is used to indicate which other
     * event classes to consider.
     */

    /* XXX PMM properties ? */
    s->name = "qwerty2";

    if (s->have_multitouch) {
        s->have_touch = true;
    }

    /* configure EV_KEY array
     *
     * All Android devices must have the following keys:
     *   KEY_HOME, KEY_BACK, KEY_SEND (Call), KEY_END (EndCall),
     *   KEY_SOFT1 (Menu), VOLUME_UP, VOLUME_DOWN
     *
     *   Note that previous models also had a KEY_SOFT2,
     *   and a KEY_POWER  which we still support here.
     *
     *   Newer models have a KEY_SEARCH key, which we always
     *   enable here.
     *
     * A Dpad will send: KEY_DOWN / UP / LEFT / RIGHT / CENTER
     *
     * The KEY_CAMERA button isn't very useful if there is no camera.
     *
     * BTN_MOUSE is sent when the trackball is pressed
     * BTN_TOUCH is sent when the touchscreen is pressed
     */
    events_set_bit(s, EV_SYN, EV_KEY);

    events_set_bit(s, EV_KEY, LINUX_KEY_HOME);
    events_set_bit(s, EV_KEY, LINUX_KEY_BACK);
    events_set_bit(s, EV_KEY, LINUX_KEY_SEND);
    events_set_bit(s, EV_KEY, LINUX_KEY_END);
    events_set_bit(s, EV_KEY, LINUX_KEY_SOFT1);
    events_set_bit(s, EV_KEY, LINUX_KEY_VOLUMEUP);
    events_set_bit(s, EV_KEY, LINUX_KEY_VOLUMEDOWN);
    events_set_bit(s, EV_KEY, LINUX_KEY_SOFT2);
    events_set_bit(s, EV_KEY, LINUX_KEY_POWER);
    events_set_bit(s, EV_KEY, LINUX_KEY_SEARCH);

    events_set_bit(s, EV_KEY, ANDROID_KEY_APPSWITCH);

    if (s->have_dpad) {
        events_set_bit(s, EV_KEY, LINUX_KEY_DOWN);
        events_set_bit(s, EV_KEY, LINUX_KEY_UP);
        events_set_bit(s, EV_KEY, LINUX_KEY_LEFT);
        events_set_bit(s, EV_KEY, LINUX_KEY_RIGHT);
        events_set_bit(s, EV_KEY, LINUX_KEY_CENTER);
    }

    if (s->have_trackball) {
        events_set_bit(s, EV_KEY, BTN_MOUSE);
    }
    if (s->have_touch) {
        events_set_bit(s, EV_KEY, BTN_TOUCH);
    }

    if (s->have_camera) {
        /* Camera emulation is enabled. */
        events_set_bit(s, EV_KEY, LINUX_KEY_CAMERA);
    }

#if defined(USE_ANDROID_EMU)
    if (android_hw->hw_keyboard) {
#else
    {
#endif
        /* since we want to implement Unicode reverse-mapping
         * allow any kind of key, even those not available on
         * the skin.
         *
         * the previous code did set the [1..0x1ff] range, but
         * we don't want to enable certain bits in the middle
         * of the range that are registered for mouse/trackball/joystick
         * events.
         *
         * see "linux_keycodes.h" for the list of events codes.
         */
        events_set_bits(s, EV_KEY, 1, 0xff);
        events_set_bits(s, EV_KEY, 0x160, 0x1ff);

        /* If there is a keyboard, but no DPad, we need to clear the
         * corresponding bits. Doing this is simpler than trying to exclude
         * the DPad values from the ranges above.
         */
        if (!s->have_dpad) {
            events_clr_bit(s, EV_KEY, LINUX_KEY_DOWN);
            events_clr_bit(s, EV_KEY, LINUX_KEY_UP);
            events_clr_bit(s, EV_KEY, LINUX_KEY_LEFT);
            events_clr_bit(s, EV_KEY, LINUX_KEY_RIGHT);
            events_clr_bit(s, EV_KEY, LINUX_KEY_CENTER);
        }
    }

    /* configure EV_REL array
     *
     * EV_REL events are sent when the trackball is moved
     */
    if (s->have_trackball) {
        events_set_bit(s, EV_SYN, EV_REL);
        events_set_bits(s, EV_REL, REL_X, REL_Y);
    }

    /* configure EV_ABS array.
     *
     * EV_ABS events are sent when the touchscreen is pressed
     */
    if (s->have_touch) {
        ABSEntry *abs_values;

        events_set_bit(s, EV_SYN, EV_ABS);
        events_set_bits(s, EV_ABS, ABS_X, ABS_Z);
        /* Allocate the absinfo to report the min/max bounds for each
         * absolute dimension. The array must contain 3, or ABS_MAX tuples
         * of (min,max,fuzz,flat) 32-bit values.
         *
         * min and max are the bounds
         * fuzz corresponds to the device's fuziness, we set it to 0
         * flat corresponds to the flat position for JOEYDEV devices,
         * we also set it to 0.
         *
         * There is no need to save/restore this array in a snapshot
         * since the values only depend on the hardware configuration.
         */
        s->abs_info_count = s->have_multitouch ? ABS_MAX * 4 : 3 * 4;
        s->abs_info = g_new0(int32_t, s->abs_info_count);
        abs_values = (ABSEntry *)s->abs_info;

        /* QEMU provides absolute coordinates in the [0,0x7fff] range
         * regardless of the display resolution.
         */
        abs_values[ABS_X].max = 0x7fff;
        abs_values[ABS_Y].max = 0x7fff;
        abs_values[ABS_Z].max = 1;

#ifdef EVDEV_MULTITOUCH
        if (s->have_multitouch) {
            /*
             * Setup multitouch.
             */
            events_set_bit(s, EV_ABS, ABS_MT_SLOT);
            events_set_bit(s, EV_ABS, ABS_MT_POSITION_X);
            events_set_bit(s, EV_ABS, ABS_MT_POSITION_Y);
            events_set_bit(s, EV_ABS, ABS_MT_TRACKING_ID);
            events_set_bit(s, EV_ABS, ABS_MT_TOUCH_MAJOR);
            events_set_bit(s, EV_ABS, ABS_MT_PRESSURE);

            abs_values[ABS_MT_SLOT].max = multitouch_get_max_slot();
            abs_values[ABS_MT_TRACKING_ID].max
                = abs_values[ABS_MT_SLOT].max + 1;
            abs_values[ABS_MT_POSITION_X].max = abs_values[ABS_X].max;
            abs_values[ABS_MT_POSITION_Y].max = abs_values[ABS_Y].max;
            /* TODO : make next 2 less random */
            abs_values[ABS_MT_TOUCH_MAJOR].max = 0x7fffffff;
            abs_values[ABS_MT_PRESSURE].max = 0x100;
        }
#endif
    }

    /* configure EV_SW array
     *
     * EV_SW events are sent to indicate that the keyboard lid
     * was closed or opened (done when we switch layouts through
     * KP-7 or KP-9).
     *
     * We only support this when hw.keyboard.lid is true.
     */
    if (s->have_keyboard && s->have_keyboard_lid) {
        events_set_bit(s, EV_SYN, EV_SW);
        events_set_bit(s, EV_SW, 0);
    }

#if defined(USE_ANDROID_EMU)
    // The android control agent might fire buffered events to the device, so
    // ensure that it is enabled after the initialization is complete.
    qemu_control_setEventDevice(s);
#endif
}

static void gf_evdev_reset(DeviceState *dev)
{
    GoldfishEvDevState *s = GOLDFISHEVDEV(dev);

    s->state = STATE_INIT;
    s->first = 0;
    s->last = 0;
    s->state = 0;
}

static Property gf_evdev_props[] = {
    DEFINE_PROP_BOOL("have-dpad", GoldfishEvDevState, have_dpad, false),
    DEFINE_PROP_BOOL("have-trackball", GoldfishEvDevState,
                     have_trackball, false),
    DEFINE_PROP_BOOL("have-camera", GoldfishEvDevState, have_camera, false),
    DEFINE_PROP_BOOL("have-keyboard", GoldfishEvDevState, have_keyboard, false),
    DEFINE_PROP_BOOL("have-lidswitch", GoldfishEvDevState,
                     have_keyboard_lid, false),
    DEFINE_PROP_BOOL("have-touch", GoldfishEvDevState,
                     have_touch, true),
    DEFINE_PROP_BOOL("have-multitouch", GoldfishEvDevState,
                     have_multitouch, false),
    DEFINE_PROP_END_OF_LIST()
};

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

    dc->realize = gf_evdev_realize;
    dc->reset = gf_evdev_reset;
    dc->props = gf_evdev_props;
    dc->vmsd = &vmstate_gf_evdev;
}

static const TypeInfo gf_evdev_info = {
    .name = TYPE_GOLDFISHEVDEV,
    .parent = TYPE_SYS_BUS_DEVICE,
    .instance_size = sizeof(GoldfishEvDevState),
    .instance_init = gf_evdev_init,
    .class_init = gf_evdev_class_init,
};

static void gf_evdev_register_types(void)
{
    type_register_static(&gf_evdev_info);
}

type_init(gf_evdev_register_types)