Linux模拟鼠标和键盘事件的方法

#ifndef _INPUT_H
#define _INPUT_H

/*
 * Copyright (c) 1999-2002 Vojtech Pavlik
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

#ifdef __KERNEL__
#include
#include
#else
#include
#include
#include
#include
#endif

/*
 * The event structure itself
 */

struct input_event {
    struct timeval time;
    __u16 type;
    __u16 code;
    __s32 value;
};

/*
 * Protocol version.
 */

#define EV_VERSION        0x010001

/*
 * IOCTLs (0x00 - 0x7f)
 */

struct input_id {
    __u16 bustype;
    __u16 vendor;
    __u16 product;
    __u16 version;
};

/**
 * struct input_absinfo - used by EVIOCGABS/EVIOCSABS ioctls
 * @value: latest reported value for the axis.
 * @minimum: specifies minimum value for the axis.
 * @maximum: specifies maximum value for the axis.
 * @fuzz: specifies fuzz value that is used to filter noise from
 *    the event stream.
 * @flat: values that are within this value will be discarded by
 *    joydev interface and reported as 0 instead.
 * @resolution: specifies resolution for the values reported for
 *    the axis.
 *
 * Note that input core does not clamp reported values to the
 * [minimum, maximum] limits, such task is left to userspace.
 *
 * Resolution for main axes (ABS_X, ABS_Y, ABS_Z) is reported in
 * units per millimeter (units/mm), resolution for rotational axes
 * (ABS_RX, ABS_RY, ABS_RZ) is reported in units per radian.
 */
struct input_absinfo {
    __s32 value;
    __s32 minimum;
    __s32 maximum;
    __s32 fuzz;
    __s32 flat;
    __s32 resolution;
};

/**
 * struct input_keymap_entry - used by EVIOCGKEYCODE/EVIOCSKEYCODE ioctls
 * @scancode: scancode represented in machine-endian form.
 * @len: length of the scancode that resides in @scancode buffer.
 * @index: index in the keymap, may be used instead of scancode
 * @flags: allows to specify how kernel should handle the request. For
 *    example, setting INPUT_KEYMAP_BY_INDEX flag indicates that kernel
 *    should perform lookup in keymap by @index instead of @scancode
 * @keycode: key code assigned to this scancode
 *
 * The structure is used to retrieve and modify keymap data. Users have
 * option of performing lookup either by @scancode itself or by @index
 * in keymap entry. EVIOCGKEYCODE will also return scancode or index
 * (depending on which element was used to perform lookup).
 */
struct input_keymap_entry {
#define INPUT_KEYMAP_BY_INDEX    (1 << 0)
    __u8  flags;
    __u8  len;
    __u16 index;
    __u32 keycode;
    __u8  scancode[32];
};

#define EVIOCGVERSION        _IOR('E', 0x01, int)            /* get driver version */
#define EVIOCGID        _IOR('E', 0x02, struct input_id)    /* get device ID */
#define EVIOCGREP        _IOR('E', 0x03, unsigned int[2])    /* get repeat settings */
#define EVIOCSREP        _IOW('E', 0x03, unsigned int[2])    /* set repeat settings */

#define EVIOCGKEYCODE        _IOR('E', 0x04, unsigned int[2])        /* get keycode */
#define EVIOCGKEYCODE_V2    _IOR('E', 0x04, struct input_keymap_entry)
#define EVIOCSKEYCODE        _IOW('E', 0x04, unsigned int[2])        /* set keycode */
#define EVIOCSKEYCODE_V2    _IOW('E', 0x04, struct input_keymap_entry)

#define EVIOCGNAME(len)        _IOC(_IOC_READ, 'E', 0x06, len)        /* get device name */
#define EVIOCGPHYS(len)        _IOC(_IOC_READ, 'E', 0x07, len)        /* get physical location */
#define EVIOCGUNIQ(len)        _IOC(_IOC_READ, 'E', 0x08, len)        /* get unique identifier */
#define EVIOCGPROP(len)        _IOC(_IOC_READ, 'E', 0x09, len)        /* get device properties */

#define EVIOCGKEY(len)        _IOC(_IOC_READ, 'E', 0x18, len)        /* get global key state */
#define EVIOCGLED(len)        _IOC(_IOC_READ, 'E', 0x19, len)        /* get all LEDs */
#define EVIOCGSND(len)        _IOC(_IOC_READ, 'E', 0x1a, len)        /* get all sounds status */
#define EVIOCGSW(len)        _IOC(_IOC_READ, 'E', 0x1b, len)        /* get all switch states */

#define EVIOCGBIT(ev,len)    _IOC(_IOC_READ, 'E', 0x20 + ev, len)    /* get event bits */
#define EVIOCGABS(abs)        _IOR('E', 0x40 + abs, struct input_absinfo)    /* get abs value/limits */
#define EVIOCSABS(abs)        _IOW('E', 0xc0 + abs, struct input_absinfo)    /* set abs value/limits */

#define EVIOCSFF        _IOC(_IOC_WRITE, 'E', 0x80, sizeof(struct ff_effect))    /* send a force effect to a force feedback device */
#define EVIOCRMFF        _IOW('E', 0x81, int)            /* Erase a force effect */
#define EVIOCGEFFECTS        _IOR('E', 0x84, int)            /* Report number of effects playable at the same time */

#define EVIOCGRAB        _IOW('E', 0x90, int)            /* Grab/Release device */

/*
 * Device properties and quirks
 */

#define INPUT_PROP_POINTER        0x00    /* needs a pointer */
#define INPUT_PROP_DIRECT        0x01    /* direct input devices */
#define INPUT_PROP_BUTTONPAD        0x02    /* has button(s) under pad */
#define INPUT_PROP_SEMI_MT        0x03    /* touch rectangle only */

#define INPUT_PROP_MAX            0x1f
#define INPUT_PROP_CNT            (INPUT_PROP_MAX + 1)

/*
 * Event types
 */

#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_CNT            (EV_MAX+1)

/*
 * Synchronization events.
 */

#define SYN_REPORT        0
#define SYN_CONFIG        1
#define SYN_MT_REPORT        2
#define SYN_DROPPED        3

/*
 * Keys and buttons
 *
 * Most of the keys/buttons are modeled after USB HUT 1.12
 * (see http://www.usb.org/developers/hidpage).
 * Abbreviations in the comments:
 * AC - Application Control
 * AL - Application Launch Button
 * SC - System Control
 */

#define KEY_RESERVED        0
#define KEY_ESC            1
#define KEY_1            2
#define KEY_2            3
#define KEY_3            4
#define KEY_4            5
#define KEY_5            6
#define KEY_6            7
#define KEY_7            8
#define KEY_8            9
#define KEY_9            10
#define KEY_0            11
#define KEY_MINUS        12
#define KEY_EQUAL        13
#define KEY_BACKSPACE        14
#define KEY_TAB            15
#define KEY_Q            16
#define KEY_W            17
#define KEY_E            18
#define KEY_R            19
#define KEY_T            20
#define KEY_Y            21
#define KEY_U            22
#define KEY_I            23
#define KEY_O            24
#define KEY_P            25
#define KEY_LEFTBRACE        26
#define KEY_RIGHTBRACE        27
#define KEY_ENTER        28
#define KEY_LEFTCTRL        29
#define KEY_A            30
#define KEY_S            31
#define KEY_D            32
#define KEY_F            33
#define KEY_G            34
#define KEY_H            35
#define KEY_J            36
#define KEY_K            37
#define KEY_L            38
#define KEY_SEMICOLON        39
#define KEY_APOSTROPHE        40
#define KEY_GRAVE        41
#define KEY_LEFTSHIFT        42
#define KEY_BACKSLASH        43
#define KEY_Z            44
#define KEY_X            45
#define KEY_C            46
#define KEY_V            47
#define KEY_B            48
#define KEY_N            49
#define KEY_M            50
#define KEY_COMMA        51
#define KEY_DOT            52
#define KEY_SLASH        53
#define KEY_RIGHTSHIFT        54
#define KEY_KPASTERISK        55
#define KEY_LEFTALT        56
#define KEY_SPACE        57
#define KEY_CAPSLOCK        58
#define KEY_F1            59
#define KEY_F2            60
#define KEY_F3            61
#define KEY_F4            62
#define KEY_F5            63
#define KEY_F6            64
#define KEY_F7            65
#define KEY_F8            66
#define KEY_F9            67
#define KEY_F10            68
#define KEY_NUMLOCK        69
#define KEY_SCROLLLOCK        70
#define KEY_KP7            71
#define KEY_KP8            72
#define KEY_KP9            73
#define KEY_KPMINUS        74
#define KEY_KP4            75
#define KEY_KP5            76
#define KEY_KP6            77
#define KEY_KPPLUS        78
#define KEY_KP1            79
#define KEY_KP2            80
#define KEY_KP3            81
#define KEY_KP0            82
#define KEY_KPDOT        83

#define KEY_ZENKAKUHANKAKU    85
#define KEY_102ND        86
#define KEY_F11            87
#define KEY_F12            88
#define KEY_RO            89
#define KEY_KATAKANA        90
#define KEY_HIRAGANA        91
#define KEY_HENKAN        92
#define KEY_KATAKANAHIRAGANA    93
#define KEY_MUHENKAN        94
#define KEY_KPJPCOMMA        95
#define KEY_KPENTER        96
#define KEY_RIGHTCTRL        97
#define KEY_KPSLASH        98
#define KEY_SYSRQ        99
#define KEY_RIGHTALT        100
#define KEY_LINEFEED        101
#define KEY_HOME        102
#define KEY_UP            103
#define KEY_PAGEUP        104
#define KEY_LEFT        105
#define KEY_RIGHT        106
#define KEY_END            107
#define KEY_DOWN        108
#define KEY_PAGEDOWN        109
#define KEY_INSERT        110
#define KEY_DELETE        111
#define KEY_MACRO        112
#define KEY_MUTE        113
#define KEY_VOLUMEDOWN        114
#define KEY_VOLUMEUP        115
#define KEY_POWER        116    /* SC System Power Down */
#define KEY_KPEQUAL        117
#define KEY_KPPLUSMINUS        118
#define KEY_PAUSE        119
#define KEY_SCALE        120    /* AL Compiz Scale (Expose) */

#define KEY_KPCOMMA        121
#define KEY_HANGEUL        122
#define KEY_HANGUEL        KEY_HANGEUL
#define KEY_HANJA        123
#define KEY_YEN            124
#define KEY_LEFTMETA        125
#define KEY_RIGHTMETA        126
#define KEY_COMPOSE        127

#define KEY_STOP        128    /* AC Stop */
#define KEY_AGAIN        129
#define KEY_PROPS        130    /* AC Properties */
#define KEY_UNDO        131    /* AC Undo */
#define KEY_FRONT        132
#define KEY_COPY        133    /* AC Copy */
#define KEY_OPEN        134    /* AC Open */
#define KEY_PASTE        135    /* AC Paste */
#define KEY_FIND        136    /* AC Search */
#define KEY_CUT            137    /* AC Cut */
#define KEY_HELP        138    /* AL Integrated Help Center */
#define KEY_MENU        139    /* Menu (show menu) */
#define KEY_CALC        140    /* AL Calculator */
#define KEY_SETUP        141
#define KEY_SLEEP        142    /* SC System Sleep */
#define KEY_WAKEUP        143    /* System Wake Up */
#define KEY_FILE        144    /* AL Local Machine Browser */
#define KEY_SENDFILE        145
#define KEY_DELETEFILE        146
#define KEY_XFER        147
#define KEY_PROG1        148
#define KEY_PROG2        149
#define KEY_WWW            150    /* AL Internet Browser */
#define KEY_MSDOS        151
#define KEY_COFFEE        152    /* AL Terminal Lock/Screensaver */
#define KEY_SCREENLOCK        KEY_COFFEE
#define KEY_DIRECTION        153
#define KEY_CYCLEWINDOWS    154
#define KEY_MAIL        155
#define KEY_BOOKMARKS        156    /* AC Bookmarks */
#define KEY_COMPUTER        157
#define KEY_BACK        158    /* AC Back */
#define KEY_FORWARD        159    /* AC Forward */
#define KEY_CLOSECD        160
#define KEY_EJECTCD        161
#define KEY_EJECTCLOSECD    162
#define KEY_NEXTSONG        163
#define KEY_PLAYPAUSE        164
#define KEY_PREVIOUSSONG    165
#define KEY_STOPCD        166
#define KEY_RECORD        167
#define KEY_REWIND        168
#define KEY_PHONE        169    /* Media Select Telephone */
#define KEY_ISO            170
#define KEY_CONFIG        171    /* AL Consumer Control Configuration */
#define KEY_HOMEPAGE        172    /* AC Home */
#define KEY_REFRESH        173    /* AC Refresh */
#define KEY_EXIT        174    /* AC Exit */
#define KEY_MOVE        175
#define KEY_EDIT        176
#define KEY_SCROLLUP        177
#define KEY_SCROLLDOWN        178
#define KEY_KPLEFTPAREN        179
#define KEY_KPRIGHTPAREN    180
#define KEY_NEW            181    /* AC New */
#define KEY_REDO        182    /* AC Redo/Repeat */

#define KEY_F13            183
#define KEY_F14            184
#define KEY_F15            185
#define KEY_F16            186
#define KEY_F17            187
#define KEY_F18            188
#define KEY_F19            189
#define KEY_F20            190
#define KEY_F21            191
#define KEY_F22            192
#define KEY_F23            193
#define KEY_F24            194

#define KEY_PLAYCD        200
#define KEY_PAUSECD        201
#define KEY_PROG3        202
#define KEY_PROG4        203
#define KEY_DASHBOARD        204    /* AL Dashboard */
#define KEY_SUSPEND        205
#define KEY_CLOSE        206    /* AC Close */
#define KEY_PLAY        207
#define KEY_FASTFORWARD        208
#define KEY_BASSBOOST        209
#define KEY_PRINT        210    /* AC Print */
#define KEY_HP            211
#define KEY_CAMERA        212
#define KEY_SOUND        213
#define KEY_QUESTION        214
#define KEY_EMAIL        215
#define KEY_CHAT        216
#define KEY_SEARCH        217
#define KEY_CONNECT        218
#define KEY_FINANCE        219    /* AL Checkbook/Finance */
#define KEY_SPORT        220
#define KEY_SHOP        221
#define KEY_ALTERASE        222
#define KEY_CANCEL        223    /* AC Cancel */
#define KEY_BRIGHTNESSDOWN    224
#define KEY_BRIGHTNESSUP    225
#define KEY_MEDIA        226

#define KEY_SWITCHVIDEOMODE    227    /* Cycle between available video
                       outputs (Monitor/LCD/TV-out/etc) */
#define KEY_KBDILLUMTOGGLE    228
#define KEY_KBDILLUMDOWN    229
#define KEY_KBDILLUMUP        230

#define KEY_SEND        231    /* AC Send */
#define KEY_REPLY        232    /* AC Reply */
#define KEY_FORWARDMAIL        233    /* AC Forward Msg */
#define KEY_SAVE        234    /* AC Save */
#define KEY_DOCUMENTS        235

#define KEY_BATTERY        236

#define KEY_BLUETOOTH        237
#define KEY_WLAN        238
#define KEY_UWB            239

#define KEY_UNKNOWN        240

#define KEY_VIDEO_NEXT        241    /* drive next video source */
#define KEY_VIDEO_PREV        242    /* drive previous video source */
#define KEY_BRIGHTNESS_CYCLE    243    /* brightness up, after max is min */
#define KEY_BRIGHTNESS_ZERO    244    /* brightness off, use ambient */
#define KEY_DISPLAY_OFF        245    /* display device to off state */

#define KEY_WIMAX        246
#define KEY_RFKILL        247    /* Key that controls all radios */

/* Code 255 is reserved for special needs of AT keyboard driver */

#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_TOOL_QUADTAP    0x14f    /* Four fingers on trackpad */

#define BTN_WHEEL        0x150
#define BTN_GEAR_DOWN        0x150
#define BTN_GEAR_UP        0x151

#define KEY_OK            0x160
#define KEY_SELECT        0x161
#define KEY_GOTO        0x162
#define KEY_CLEAR        0x163
#define KEY_POWER2        0x164
#define KEY_OPTION        0x165
#define KEY_INFO        0x166    /* AL OEM Features/Tips/Tutorial */
#define KEY_TIME        0x167
#define KEY_VENDOR        0x168
#define KEY_ARCHIVE        0x169
#define KEY_PROGRAM        0x16a    /* Media Select Program Guide */
#define KEY_CHANNEL        0x16b
#define KEY_FAVORITES        0x16c
#define KEY_EPG            0x16d
#define KEY_PVR            0x16e    /* Media Select Home */
#define KEY_MHP            0x16f
#define KEY_LANGUAGE        0x170
#define KEY_TITLE        0x171
#define KEY_SUBTITLE        0x172
#define KEY_ANGLE        0x173
#define KEY_ZOOM        0x174
#define KEY_MODE        0x175
#define KEY_KEYBOARD        0x176
#define KEY_SCREEN        0x177
#define KEY_PC            0x178    /* Media Select Computer */
#define KEY_TV            0x179    /* Media Select TV */
#define KEY_TV2            0x17a    /* Media Select Cable */
#define KEY_VCR            0x17b    /* Media Select VCR */
#define KEY_VCR2        0x17c    /* VCR Plus */
#define KEY_SAT            0x17d    /* Media Select Satellite */
#define KEY_SAT2        0x17e
#define KEY_CD            0x17f    /* Media Select CD */
#define KEY_TAPE        0x180    /* Media Select Tape */
#define KEY_RADIO        0x181
#define KEY_TUNER        0x182    /* Media Select Tuner */
#define KEY_PLAYER        0x183
#define KEY_TEXT        0x184
#define KEY_DVD            0x185    /* Media Select DVD */
#define KEY_AUX            0x186
#define KEY_MP3            0x187
#define KEY_AUDIO        0x188    /* AL Audio Browser */
#define KEY_VIDEO        0x189    /* AL Movie Browser */
#define KEY_DIRECTORY        0x18a
#define KEY_LIST        0x18b
#define KEY_MEMO        0x18c    /* Media Select Messages */
#define KEY_CALENDAR        0x18d
#define KEY_RED            0x18e
#define KEY_GREEN        0x18f
#define KEY_YELLOW        0x190
#define KEY_BLUE        0x191
#define KEY_CHANNELUP        0x192    /* Channel Increment */
#define KEY_CHANNELDOWN        0x193    /* Channel Decrement */
#define KEY_FIRST        0x194
#define KEY_LAST        0x195    /* Recall Last */
#define KEY_AB            0x196
#define KEY_NEXT        0x197
#define KEY_RESTART        0x198
#define KEY_SLOW        0x199
#define KEY_SHUFFLE        0x19a
#define KEY_BREAK        0x19b
#define KEY_PREVIOUS        0x19c
#define KEY_DIGITS        0x19d
#define KEY_TEEN        0x19e
#define KEY_TWEN        0x19f
#define KEY_VIDEOPHONE        0x1a0    /* Media Select Video Phone */
#define KEY_GAMES        0x1a1    /* Media Select Games */
#define KEY_ZOOMIN        0x1a2    /* AC Zoom In */
#define KEY_ZOOMOUT        0x1a3    /* AC Zoom Out */
#define KEY_ZOOMRESET        0x1a4    /* AC Zoom */
#define KEY_WORDPROCESSOR    0x1a5    /* AL Word Processor */
#define KEY_EDITOR        0x1a6    /* AL Text Editor */
#define KEY_SPREADSHEET        0x1a7    /* AL Spreadsheet */
#define KEY_GRAPHICSEDITOR    0x1a8    /* AL Graphics Editor */
#define KEY_PRESENTATION    0x1a9    /* AL Presentation App */
#define KEY_DATABASE        0x1aa    /* AL Database App */
#define KEY_NEWS        0x1ab    /* AL Newsreader */
#define KEY_VOICEMAIL        0x1ac    /* AL Voicemail */
#define KEY_ADDRESSBOOK        0x1ad    /* AL Contacts/Address Book */
#define KEY_MESSENGER        0x1ae    /* AL Instant Messaging */
#define KEY_DISPLAYTOGGLE    0x1af    /* Turn display (LCD) on and off */
#define KEY_SPELLCHECK        0x1b0   /* AL Spell Check */
#define KEY_LOGOFF        0x1b1   /* AL Logoff */

#define KEY_DOLLAR        0x1b2
#define KEY_EURO        0x1b3

#define KEY_FRAMEBACK        0x1b4    /* Consumer - transport controls */
#define KEY_FRAMEFORWARD    0x1b5
#define KEY_CONTEXT_MENU    0x1b6    /* GenDesc - system context menu */
#define KEY_MEDIA_REPEAT    0x1b7    /* Consumer - transport control */
#define KEY_10CHANNELSUP    0x1b8    /* 10 channels up (10+) */
#define KEY_10CHANNELSDOWN    0x1b9    /* 10 channels down (10-) */
#define KEY_IMAGES        0x1ba    /* AL Image Browser */

#define KEY_DEL_EOL        0x1c0
#define KEY_DEL_EOS        0x1c1
#define KEY_INS_LINE        0x1c2
#define KEY_DEL_LINE        0x1c3

#define KEY_FN            0x1d0
#define KEY_FN_ESC        0x1d1
#define KEY_FN_F1        0x1d2
#define KEY_FN_F2        0x1d3
#define KEY_FN_F3        0x1d4
#define KEY_FN_F4        0x1d5
#define KEY_FN_F5        0x1d6
#define KEY_FN_F6        0x1d7
#define KEY_FN_F7        0x1d8
#define KEY_FN_F8        0x1d9
#define KEY_FN_F9        0x1da
#define KEY_FN_F10        0x1db
#define KEY_FN_F11        0x1dc
#define KEY_FN_F12        0x1dd
#define KEY_FN_1        0x1de
#define KEY_FN_2        0x1df
#define KEY_FN_D        0x1e0
#define KEY_FN_E        0x1e1
#define KEY_FN_F        0x1e2
#define KEY_FN_S        0x1e3
#define KEY_FN_B        0x1e4

#define KEY_BRL_DOT1        0x1f1
#define KEY_BRL_DOT2        0x1f2
#define KEY_BRL_DOT3        0x1f3
#define KEY_BRL_DOT4        0x1f4
#define KEY_BRL_DOT5        0x1f5
#define KEY_BRL_DOT6        0x1f6
#define KEY_BRL_DOT7        0x1f7
#define KEY_BRL_DOT8        0x1f8
#define KEY_BRL_DOT9        0x1f9
#define KEY_BRL_DOT10        0x1fa

#define KEY_NUMERIC_0        0x200    /* used by phones, remote controls, */
#define KEY_NUMERIC_1        0x201    /* and other keypads */
#define KEY_NUMERIC_2        0x202
#define KEY_NUMERIC_3        0x203
#define KEY_NUMERIC_4        0x204
#define KEY_NUMERIC_5        0x205
#define KEY_NUMERIC_6        0x206
#define KEY_NUMERIC_7        0x207
#define KEY_NUMERIC_8        0x208
#define KEY_NUMERIC_9        0x209
#define KEY_NUMERIC_STAR    0x20a
#define KEY_NUMERIC_POUND    0x20b

#define KEY_CAMERA_FOCUS    0x210
#define KEY_WPS_BUTTON        0x211    /* WiFi Protected Setup key */

#define KEY_TOUCHPAD_TOGGLE    0x212    /* Request switch touchpad on or off */
#define KEY_TOUCHPAD_ON        0x213
#define KEY_TOUCHPAD_OFF    0x214

#define KEY_CAMERA_ZOOMIN    0x215
#define KEY_CAMERA_ZOOMOUT    0x216
#define KEY_CAMERA_UP        0x217
#define KEY_CAMERA_DOWN        0x218
#define KEY_CAMERA_LEFT        0x219
#define KEY_CAMERA_RIGHT    0x21a

#define BTN_TRIGGER_HAPPY        0x2c0
#define BTN_TRIGGER_HAPPY1        0x2c0
#define BTN_TRIGGER_HAPPY2        0x2c1
#define BTN_TRIGGER_HAPPY3        0x2c2
#define BTN_TRIGGER_HAPPY4        0x2c3
#define BTN_TRIGGER_HAPPY5        0x2c4
#define BTN_TRIGGER_HAPPY6        0x2c5
#define BTN_TRIGGER_HAPPY7        0x2c6
#define BTN_TRIGGER_HAPPY8        0x2c7
#define BTN_TRIGGER_HAPPY9        0x2c8
#define BTN_TRIGGER_HAPPY10        0x2c9
#define BTN_TRIGGER_HAPPY11        0x2ca
#define BTN_TRIGGER_HAPPY12        0x2cb
#define BTN_TRIGGER_HAPPY13        0x2cc
#define BTN_TRIGGER_HAPPY14        0x2cd
#define BTN_TRIGGER_HAPPY15        0x2ce
#define BTN_TRIGGER_HAPPY16        0x2cf
#define BTN_TRIGGER_HAPPY17        0x2d0
#define BTN_TRIGGER_HAPPY18        0x2d1
#define BTN_TRIGGER_HAPPY19        0x2d2
#define BTN_TRIGGER_HAPPY20        0x2d3
#define BTN_TRIGGER_HAPPY21        0x2d4
#define BTN_TRIGGER_HAPPY22        0x2d5
#define BTN_TRIGGER_HAPPY23        0x2d6
#define BTN_TRIGGER_HAPPY24        0x2d7
#define BTN_TRIGGER_HAPPY25        0x2d8
#define BTN_TRIGGER_HAPPY26        0x2d9
#define BTN_TRIGGER_HAPPY27        0x2da
#define BTN_TRIGGER_HAPPY28        0x2db
#define BTN_TRIGGER_HAPPY29        0x2dc
#define BTN_TRIGGER_HAPPY30        0x2dd
#define BTN_TRIGGER_HAPPY31        0x2de
#define BTN_TRIGGER_HAPPY32        0x2df
#define BTN_TRIGGER_HAPPY33        0x2e0
#define BTN_TRIGGER_HAPPY34        0x2e1
#define BTN_TRIGGER_HAPPY35        0x2e2
#define BTN_TRIGGER_HAPPY36        0x2e3
#define BTN_TRIGGER_HAPPY37        0x2e4
#define BTN_TRIGGER_HAPPY38        0x2e5
#define BTN_TRIGGER_HAPPY39        0x2e6
#define BTN_TRIGGER_HAPPY40        0x2e7

/* We avoid low common keys in module aliases so they don't get huge. */
#define KEY_MIN_INTERESTING    KEY_MUTE
#define KEY_MAX            0x2ff
#define KEY_CNT            (KEY_MAX+1)

/*
 * Relative axes
 */

#define REL_X            0x00
#define REL_Y            0x01
#define REL_Z            0x02
#define REL_RX            0x03
#define REL_RY            0x04
#define REL_RZ            0x05
#define REL_HWHEEL        0x06
#define REL_DIAL        0x07
#define REL_WHEEL        0x08
#define REL_MISC        0x09
#define REL_MAX            0x0f
#define REL_CNT            (REL_MAX+1)

/*
 * Absolute axes
 */

#define ABS_X            0x00
#define ABS_Y            0x01
#define ABS_Z            0x02
#define ABS_RX            0x03
#define ABS_RY            0x04
#define ABS_RZ            0x05
#define ABS_THROTTLE        0x06
#define ABS_RUDDER        0x07
#define ABS_WHEEL        0x08
#define ABS_GAS            0x09
#define ABS_BRAKE        0x0a
#define ABS_HAT0X        0x10
#define ABS_HAT0Y        0x11
#define ABS_HAT1X        0x12
#define ABS_HAT1Y        0x13
#define ABS_HAT2X        0x14
#define ABS_HAT2Y        0x15
#define ABS_HAT3X        0x16
#define ABS_HAT3Y        0x17
#define ABS_PRESSURE        0x18
#define ABS_DISTANCE        0x19
#define ABS_TILT_X        0x1a
#define ABS_TILT_Y        0x1b
#define ABS_TOOL_WIDTH        0x1c

#define ABS_VOLUME        0x20

#define ABS_MISC        0x28

#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 */

#ifdef __KERNEL__
/* Implementation details, userspace should not care about these */
#define ABS_MT_FIRST        ABS_MT_TOUCH_MAJOR
#define ABS_MT_LAST        ABS_MT_DISTANCE
#endif

#define ABS_MAX            0x3f
#define ABS_CNT            (ABS_MAX+1)

/*
 * Switch events
 */

#define SW_LID            0x00  /* set = lid shut */
#define SW_TABLET_MODE        0x01  /* set = tablet mode */
#define SW_HEADPHONE_INSERT    0x02  /* set = inserted */
#define SW_RFKILL_ALL        0x03  /* rfkill master switch, type "any"
                     set = radio enabled */
#define SW_RADIO        SW_RFKILL_ALL    /* deprecated */
#define SW_MICROPHONE_INSERT    0x04  /* set = inserted */
#define SW_DOCK            0x05  /* set = plugged into dock */
#define SW_LINEOUT_INSERT    0x06  /* set = inserted */
#define SW_JACK_PHYSICAL_INSERT 0x07  /* set = mechanical switch set */
#define SW_VIDEOOUT_INSERT    0x08  /* set = inserted */
#define SW_CAMERA_LENS_COVER    0x09  /* set = lens covered */
#define SW_KEYPAD_SLIDE        0x0a  /* set = keypad slide out */
#define SW_FRONT_PROXIMITY    0x0b  /* set = front proximity sensor active */
#define SW_ROTATE_LOCK        0x0c  /* set = rotate locked/disabled */
#define SW_MAX            0x0f
#define SW_CNT            (SW_MAX+1)

/*
 * Misc events
 */

#define MSC_SERIAL        0x00
#define MSC_PULSELED        0x01
#define MSC_GESTURE        0x02
#define MSC_RAW            0x03
#define MSC_SCAN        0x04
#define MSC_MAX            0x07
#define MSC_CNT            (MSC_MAX+1)

/*
 * LEDs
 */

#define LED_NUML        0x00
#define LED_CAPSL        0x01
#define LED_SCROLLL        0x02
#define LED_COMPOSE        0x03
#define LED_KANA        0x04
#define LED_SLEEP        0x05
#define LED_SUSPEND        0x06
#define LED_MUTE        0x07
#define LED_MISC        0x08
#define LED_MAIL        0x09
#define LED_CHARGING        0x0a
#define LED_MAX            0x0f
#define LED_CNT            (LED_MAX+1)

/*
 * Autorepeat values
 */

#define REP_DELAY        0x00
#define REP_PERIOD        0x01
#define REP_MAX            0x01
#define REP_CNT            (REP_MAX+1)

/*
 * Sounds
 */

#define SND_CLICK        0x00
#define SND_BELL        0x01
#define SND_TONE        0x02
#define SND_MAX            0x07
#define SND_CNT            (SND_MAX+1)

/*
 * IDs.
 */

#define ID_BUS            0
#define ID_VENDOR        1
#define ID_PRODUCT        2
#define ID_VERSION        3

#define BUS_PCI            0x01
#define BUS_ISAPNP        0x02
#define BUS_USB            0x03
#define BUS_HIL            0x04
#define BUS_BLUETOOTH        0x05
#define BUS_VIRTUAL        0x06

#define BUS_ISA            0x10
#define BUS_I8042        0x11
#define BUS_XTKBD        0x12
#define BUS_RS232        0x13
#define BUS_GAMEPORT        0x14
#define BUS_PARPORT        0x15
#define BUS_AMIGA        0x16
#define BUS_ADB            0x17
#define BUS_I2C            0x18
#define BUS_HOST        0x19
#define BUS_GSC            0x1A
#define BUS_ATARI        0x1B
#define BUS_SPI            0x1C

/*
 * MT_TOOL types
 */
#define MT_TOOL_FINGER        0
#define MT_TOOL_PEN        1
#define MT_TOOL_MAX        1

/*
 * Values describing the status of a force-feedback effect
 */
#define FF_STATUS_STOPPED    0x00
#define FF_STATUS_PLAYING    0x01
#define FF_STATUS_MAX        0x01

/*
 * Structures used in ioctls to upload effects to a device
 * They are pieces of a bigger structure (called ff_effect)
 */

/*
 * All duration values are expressed in ms. Values above 32767 ms (0x7fff)
 * should not be used and have unspecified results.
 */

/**
 * struct ff_replay - defines scheduling of the force-feedback effect
 * @length: duration of the effect
 * @delay: delay before effect should start playing
 */
struct ff_replay {
    __u16 length;
    __u16 delay;
};

/**
 * struct ff_trigger - defines what triggers the force-feedback effect
 * @button: number of the button triggering the effect
 * @interval: controls how soon the effect can be re-triggered
 */
struct ff_trigger {
    __u16 button;
    __u16 interval;
};

/**
 * struct ff_envelope - generic force-feedback effect envelope
 * @attack_length: duration of the attack (ms)
 * @attack_level: level at the beginning of the attack
 * @fade_length: duration of fade (ms)
 * @fade_level: level at the end of fade
 *
 * The @attack_level and @fade_level are absolute values; when applying
 * envelope force-feedback core will convert to positive/negative
 * value based on polarity of the default level of the effect.
 * Valid range for the attack and fade levels is 0x0000 - 0x7fff
 */
struct ff_envelope {
    __u16 attack_length;
    __u16 attack_level;
    __u16 fade_length;
    __u16 fade_level;
};

/**
 * struct ff_constant_effect - defines parameters of a constant force-feedback effect
 * @level: strength of the effect; may be negative
 * @envelope: envelope data
 */
struct ff_constant_effect {
    __s16 level;
    struct ff_envelope envelope;
};

/**
 * struct ff_ramp_effect - defines parameters of a ramp force-feedback effect
 * @start_level: beginning strength of the effect; may be negative
 * @end_level: final strength of the effect; may be negative
 * @envelope: envelope data
 */
struct ff_ramp_effect {
    __s16 start_level;
    __s16 end_level;
    struct ff_envelope envelope;
};

/**
 * struct ff_condition_effect - defines a spring or friction force-feedback effect
 * @right_saturation: maximum level when joystick moved all way to the right
 * @left_saturation: same for the left side
 * @right_coeff: controls how fast the force grows when the joystick moves
 *    to the right
 * @left_coeff: same for the left side
 * @deadband: size of the dead zone, where no force is produced
 * @center: position of the dead zone
 */
struct ff_condition_effect {
    __u16 right_saturation;
    __u16 left_saturation;

    __s16 right_coeff;
    __s16 left_coeff;

    __u16 deadband;
    __s16 center;
};

/**
 * struct ff_periodic_effect - defines parameters of a periodic force-feedback effect
 * @waveform: kind of the effect (wave)
 * @period: period of the wave (ms)
 * @magnitude: peak value
 * @offset: mean value of the wave (roughly)
 * @phase: 'horizontal' shift
 * @envelope: envelope data
 * @custom_len: number of samples (FF_CUSTOM only)
 * @custom_data: buffer of samples (FF_CUSTOM only)
 *
 * Known waveforms - FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP,
 * FF_SAW_DOWN, FF_CUSTOM. The exact syntax FF_CUSTOM is undefined
 * for the time being as no driver supports it yet.
 *
 * Note: the data pointed by custom_data is copied by the driver.
 * You can therefore dispose of the memory after the upload/update.
 */
struct ff_periodic_effect {
    __u16 waveform;
    __u16 period;
    __s16 magnitude;
    __s16 offset;
    __u16 phase;

    struct ff_envelope envelope;

    __u32 custom_len;
    __s16 __user *custom_data;
};

/**
 * struct ff_rumble_effect - defines parameters of a periodic force-feedback effect
 * @strong_magnitude: magnitude of the heavy motor
 * @weak_magnitude: magnitude of the light one
 *
 * Some rumble pads have two motors of different weight. Strong_magnitude
 * represents the magnitude of the vibration generated by the heavy one.
 */
struct ff_rumble_effect {
    __u16 strong_magnitude;
    __u16 weak_magnitude;
};

/**
 * struct ff_effect - defines force feedback effect
 * @type: type of the effect (FF_CONSTANT, FF_PERIODIC, FF_RAMP, FF_SPRING,
 *    FF_FRICTION, FF_DAMPER, FF_RUMBLE, FF_INERTIA, or FF_CUSTOM)
 * @id: an unique id assigned to an effect
 * @direction: direction of the effect
 * @trigger: trigger conditions (struct ff_trigger)
 * @replay: scheduling of the effect (struct ff_replay)
 * @u: effect-specific structure (one of ff_constant_effect, ff_ramp_effect,
 *    ff_periodic_effect, ff_condition_effect, ff_rumble_effect) further
 *    defining effect parameters
 *
 * This structure is sent through ioctl from the application to the driver.
 * To create a new effect application should set its @id to -1; the kernel
 * will return assigned @id which can later be used to update or delete
 * this effect.
 *
 * Direction of the effect is encoded as follows:
 *    0 deg -> 0x0000 (down)
 *    90 deg -> 0x4000 (left)
 *    180 deg -> 0x8000 (up)
 *    270 deg -> 0xC000 (right)
 */
struct ff_effect {
    __u16 type;
    __s16 id;
    __u16 direction;
    struct ff_trigger trigger;
    struct ff_replay replay;

    union {
        struct ff_constant_effect constant;
        struct ff_ramp_effect ramp;
        struct ff_periodic_effect periodic;
        struct ff_condition_effect condition[2]; /* One for each axis */
        struct ff_rumble_effect rumble;
    } u;
};

/*
 * Force feedback effect types
 */

#define FF_RUMBLE    0x50
#define FF_PERIODIC    0x51
#define FF_CONSTANT    0x52
#define FF_SPRING    0x53
#define FF_FRICTION    0x54
#define FF_DAMPER    0x55
#define FF_INERTIA    0x56
#define FF_RAMP        0x57

#define FF_EFFECT_MIN    FF_RUMBLE
#define FF_EFFECT_MAX    FF_RAMP

/*
 * Force feedback periodic effect types
 */

#define FF_SQUARE    0x58
#define FF_TRIANGLE    0x59
#define FF_SINE        0x5a
#define FF_SAW_UP    0x5b
#define FF_SAW_DOWN    0x5c
#define FF_CUSTOM    0x5d

#define FF_WAVEFORM_MIN    FF_SQUARE
#define FF_WAVEFORM_MAX    FF_CUSTOM

/*
 * Set ff device properties
 */

#define FF_GAIN        0x60
#define FF_AUTOCENTER    0x61

#define FF_MAX        0x7f
#define FF_CNT        (FF_MAX+1)

#ifdef __KERNEL__

/*
 * In-kernel definitions.
 */

#include
#include
#include
#include

/**
 * struct input_dev - represents an input device
 * @name: name of the device
 * @phys: physical path to the device in the system hierarchy
 * @uniq: unique identification code for the device (if device has it)
 * @id: id of the device (struct input_id)
 * @propbit: bitmap of device properties and quirks
 * @evbit: bitmap of types of events supported by the device (EV_KEY,
 *    EV_REL, etc.)
 * @keybit: bitmap of keys/buttons this device has
 * @relbit: bitmap of relative axes for the device
 * @absbit: bitmap of absolute axes for the device
 * @mscbit: bitmap of miscellaneous events supported by the device
 * @ledbit: bitmap of leds present on the device
 * @sndbit: bitmap of sound effects supported by the device
 * @ffbit: bitmap of force feedback effects supported by the device
 * @swbit: bitmap of switches present on the device
 * @hint_events_per_packet: average number of events generated by the
 *    device in a packet (between EV_SYN/SYN_REPORT events). Used by
 *    event handlers to estimate size of the buffer needed to hold
 *    events.
 * @keycodemax: size of keycode table
 * @keycodesize: size of elements in keycode table
 * @keycode: map of scancodes to keycodes for this device
 * @getkeycode: optional legacy method to retrieve current keymap.
 * @setkeycode: optional method to alter current keymap, used to implement
 *    sparse keymaps. If not supplied default mechanism will be used.
 *    The method is being called while holding event_lock and thus must
 *    not sleep
 * @ff: force feedback structure associated with the device if device
 *    supports force feedback effects
 * @repeat_key: stores key code of the last key pressed; used to implement
 *    software autorepeat
 * @timer: timer for software autorepeat
 * @rep: current values for autorepeat parameters (delay, rate)
 * @mt: pointer to array of struct input_mt_slot holding current values
 *    of tracked contacts
 * @mtsize: number of MT slots the device uses
 * @slot: MT slot currently being transmitted
 * @trkid: stores MT tracking ID for the current contact
 * @absinfo: array of &struct input_absinfo elements holding information
 *    about absolute axes (current value, min, max, flat, fuzz,
 *    resolution)
 * @key: reflects current state of device's keys/buttons
 * @led: reflects current state of device's LEDs
 * @snd: reflects current state of sound effects
 * @sw: reflects current state of device's switches
 * @open: this method is called when the very first user calls
 *    input_open_device(). The driver must prepare the device
 *    to start generating events (start polling thread,
 *    request an IRQ, submit URB, etc.)
 * @close: this method is called when the very last user calls
 *    input_close_device().
 * @flush: purges the device. Most commonly used to get rid of force
 *    feedback effects loaded into the device when disconnecting
 *    from it
 * @event: event handler for events sent _to_ the device, like EV_LED
 *    or EV_SND. The device is expected to carry out the requested
 *    action (turn on a LED, play sound, etc.) The call is protected
 *    by @event_lock and must not sleep
 * @grab: input handle that currently has the device grabbed (via
 *    EVIOCGRAB ioctl). When a handle grabs a device it becomes sole
 *    recipient for all input events coming from the device
 * @event_lock: this spinlock is is taken when input core receives
 *    and processes a new event for the device (in input_event()).
 *    Code that accesses and/or modifies parameters of a device
 *    (such as keymap or absmin, absmax, absfuzz, etc.) after device
 *    has been registered with input core must take this lock.
 * @mutex: serializes calls to open(), close() and flush() methods
 * @users: stores number of users (input handlers) that opened this
 *    device. It is used by input_open_device() and input_close_device()
 *    to make sure that dev->open() is only called when the first
 *    user opens device and dev->close() is called when the very
 *    last user closes the device
 * @going_away: marks devices that are in a middle of unregistering and
 *    causes input_open_device*() fail with -ENODEV.
 * @sync: set to %true when there were no new events since last EV_SYN
 * @dev: driver model's view of this device
 * @h_list: list of input handles associated with the device. When
 *    accessing the list dev->mutex must be held
 * @node: used to place the device onto input_dev_list
 */
struct input_dev {
    const char *name;
    const char *phys;
    const char *uniq;
    struct input_id id;

    unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];

    unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
    unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
    unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
    unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
    unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
    unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
    unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
    unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
    unsigned long swbit[BITS_TO_LONGS(SW_CNT)];

    unsigned int hint_events_per_packet;

    unsigned int keycodemax;
    unsigned int keycodesize;
    void *keycode;

    int (*setkeycode)(struct input_dev *dev,
              const struct input_keymap_entry *ke,
              unsigned int *old_keycode);
    int (*getkeycode)(struct input_dev *dev,
              struct input_keymap_entry *ke);

    struct ff_device *ff;

    unsigned int repeat_key;
    struct timer_list timer;

    int rep[REP_CNT];

    struct input_mt_slot *mt;
    int mtsize;
    int slot;
    int trkid;

    struct input_absinfo *absinfo;

    unsigned long key[BITS_TO_LONGS(KEY_CNT)];
    unsigned long led[BITS_TO_LONGS(LED_CNT)];
    unsigned long snd[BITS_TO_LONGS(SND_CNT)];
    unsigned long sw[BITS_TO_LONGS(SW_CNT)];

    int (*open)(struct input_dev *dev);
    void (*close)(struct input_dev *dev);
    int (*flush)(struct input_dev *dev, struct file *file);
    int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

    struct input_handle __rcu *grab;

    spinlock_t event_lock;
    struct mutex mutex;

    unsigned int users;
    bool going_away;

    bool sync;

    struct device dev;

    struct list_head    h_list;
    struct list_head    node;
};
#define to_input_dev(d) container_of(d, struct input_dev, dev)

/*
 * Verify that we are in sync with input_device_id mod_devicetable.h #defines
 */

#if EV_MAX != INPUT_DEVICE_ID_EV_MAX
#error "EV_MAX and INPUT_DEVICE_ID_EV_MAX do not match"
#endif

#if KEY_MIN_INTERESTING != INPUT_DEVICE_ID_KEY_MIN_INTERESTING
#error "KEY_MIN_INTERESTING and INPUT_DEVICE_ID_KEY_MIN_INTERESTING do not match"
#endif

#if KEY_MAX != INPUT_DEVICE_ID_KEY_MAX
#error "KEY_MAX and INPUT_DEVICE_ID_KEY_MAX do not match"
#endif

#if REL_MAX != INPUT_DEVICE_ID_REL_MAX
#error "REL_MAX and INPUT_DEVICE_ID_REL_MAX do not match"
#endif

#if ABS_MAX != INPUT_DEVICE_ID_ABS_MAX
#error "ABS_MAX and INPUT_DEVICE_ID_ABS_MAX do not match"
#endif

#if MSC_MAX != INPUT_DEVICE_ID_MSC_MAX
#error "MSC_MAX and INPUT_DEVICE_ID_MSC_MAX do not match"
#endif

#if LED_MAX != INPUT_DEVICE_ID_LED_MAX
#error "LED_MAX and INPUT_DEVICE_ID_LED_MAX do not match"
#endif

#if SND_MAX != INPUT_DEVICE_ID_SND_MAX
#error "SND_MAX and INPUT_DEVICE_ID_SND_MAX do not match"
#endif

#if FF_MAX != INPUT_DEVICE_ID_FF_MAX
#error "FF_MAX and INPUT_DEVICE_ID_FF_MAX do not match"
#endif

#if SW_MAX != INPUT_DEVICE_ID_SW_MAX
#error "SW_MAX and INPUT_DEVICE_ID_SW_MAX do not match"
#endif

#define INPUT_DEVICE_ID_MATCH_DEVICE \
    (INPUT_DEVICE_ID_MATCH_BUS | INPUT_DEVICE_ID_MATCH_VENDOR | INPUT_DEVICE_ID_MATCH_PRODUCT)
#define INPUT_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
    (INPUT_DEVICE_ID_MATCH_DEVICE | INPUT_DEVICE_ID_MATCH_VERSION)

struct input_handle;

/**
 * struct input_handler - implements one of interfaces for input devices
 * @private: driver-specific data
 * @event: event handler. This method is being called by input core with
 *    interrupts disabled and dev->event_lock spinlock held and so
 *    it may not sleep
 * @filter: similar to @event; separates normal event handlers from
 *    "filters".
 * @match: called after comparing device's id with handler's id_table
 *    to perform fine-grained matching between device and handler
 * @connect: called when attaching a handler to an input device
 * @disconnect: disconnects a handler from input device
 * @start: starts handler for given handle. This function is called by
 *    input core right after connect() method and also when a process
 *    that "grabbed" a device releases it
 * @fops: file operations this driver implements
 * @minor: beginning of range of 32 minors for devices this driver
 *    can provide
 * @name: name of the handler, to be shown in /proc/bus/input/handlers
 * @id_table: pointer to a table of input_device_ids this driver can
 *    handle
 * @h_list: list of input handles associated with the handler
 * @node: for placing the driver onto input_handler_list
 *
 * Input handlers attach to input devices and create input handles. There
 * are likely several handlers attached to any given input device at the
 * same time. All of them will get their copy of input event generated by
 * the device.
 *
 * The very same structure is used to implement input filters. Input core
 * allows filters to run first and will not pass event to regular handlers
 * if any of the filters indicate that the event should be filtered (by
 * returning %true from their filter() method).
 *
 * Note that input core serializes calls to connect() and disconnect()
 * methods.
 */
struct input_handler {

    void *private;

    void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
    bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
    bool (*match)(struct input_handler *handler, struct input_dev *dev);
    int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
    void (*disconnect)(struct input_handle *handle);
    void (*start)(struct input_handle *handle);

    const struct file_operations *fops;
    int minor;
    const char *name;

    const struct input_device_id *id_table;

    struct list_head    h_list;
    struct list_head    node;
};

/**
 * struct input_handle - links input device with an input handler
 * @private: handler-specific data
 * @open: counter showing whether the handle is 'open', i.e. should deliver
 *    events from its device
 * @name: name given to the handle by handler that created it
 * @dev: input device the handle is attached to
 * @handler: handler that works with the device through this handle
 * @d_node: used to put the handle on device's list of attached handles
 * @h_node: used to put the handle on handler's list of handles from which
 *    it gets events
 */
struct input_handle {

    void *private;

    int open;
    const char *name;

    struct input_dev *dev;
    struct input_handler *handler;

    struct list_head    d_node;
    struct list_head    h_node;
};

struct input_dev *input_allocate_device(void);
void input_free_device(struct input_dev *dev);

static inline struct input_dev *input_get_device(struct input_dev *dev)
{
    return dev ? to_input_dev(get_device(&dev->dev)) : NULL;
}

static inline void input_put_device(struct input_dev *dev)
{
    if (dev)
        put_device(&dev->dev);
}

static inline void *input_get_drvdata(struct input_dev *dev)
{
    return dev_get_drvdata(&dev->dev);
}

static inline void input_set_drvdata(struct input_dev *dev, void *data)
{
    dev_set_drvdata(&dev->dev, data);
}

int __must_check input_register_device(struct input_dev *);
void input_unregister_device(struct input_dev *);

void input_reset_device(struct input_dev *);

int __must_check input_register_handler(struct input_handler *);
void input_unregister_handler(struct input_handler *);

int input_handler_for_each_handle(struct input_handler *, void *data,
                  int (*fn)(struct input_handle *, void *));

int input_register_handle(struct input_handle *);
void input_unregister_handle(struct input_handle *);

int input_grab_device(struct input_handle *);
void input_release_device(struct input_handle *);

int input_open_device(struct input_handle *);
void input_close_device(struct input_handle *);

int input_flush_device(struct input_handle *handle, struct file *file);

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);
void input_inject_event(struct input_handle *handle, unsigned int type, unsigned int code, int value);

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_KEY, code, !!value);
}

static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_REL, code, value);
}

static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_ABS, code, value);
}

static inline void input_report_ff_status(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_FF_STATUS, code, value);
}

static inline void input_report_switch(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_SW, code, !!value);
}

static inline void input_sync(struct input_dev *dev)
{
    input_event(dev, EV_SYN, SYN_REPORT, 0);
}

static inline void input_mt_sync(struct input_dev *dev)
{
    input_event(dev, EV_SYN, SYN_MT_REPORT, 0);
}

void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code);

/**
 * input_set_events_per_packet - tell handlers about the driver event rate
 * @dev: the input device used by the driver
 * @n_events: the average number of events between calls to input_sync()
 *
 * If the event rate sent from a device is unusually large, use this
 * function to set the expected event rate. This will allow handlers
 * to set up an appropriate buffer size for the event stream, in order
 * to minimize information loss.
 */
static inline void input_set_events_per_packet(struct input_dev *dev, int n_events)
{
    dev->hint_events_per_packet = n_events;
}

void input_alloc_absinfo(struct input_dev *dev);
void input_set_abs_params(struct input_dev *dev, unsigned int axis,
              int min, int max, int fuzz, int flat);

#define INPUT_GENERATE_ABS_ACCESSORS(_suffix, _item)            \
static inline int input_abs_get_##_suffix(struct input_dev *dev,    \
                      unsigned int axis)        \
{                                    \
    return dev->absinfo ? dev->absinfo[axis]._item : 0;        \
}                                    \
                                    \
static inline void input_abs_set_##_suffix(struct input_dev *dev,    \
                       unsigned int axis, int val)    \
{                                    \
    input_alloc_absinfo(dev);                    \
    if (dev->absinfo)                        \
        dev->absinfo[axis]._item = val;                \
}

INPUT_GENERATE_ABS_ACCESSORS(val, value)
INPUT_GENERATE_ABS_ACCESSORS(min, minimum)
INPUT_GENERATE_ABS_ACCESSORS(max, maximum)
INPUT_GENERATE_ABS_ACCESSORS(fuzz, fuzz)
INPUT_GENERATE_ABS_ACCESSORS(flat, flat)
INPUT_GENERATE_ABS_ACCESSORS(res, resolution)

int input_scancode_to_scalar(const struct input_keymap_entry *ke,
                 unsigned int *scancode);

int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke);
int input_set_keycode(struct input_dev *dev,
              const struct input_keymap_entry *ke);

extern struct class input_class;

/**
 * struct ff_device - force-feedback part of an input device
 * @upload: Called to upload an new effect into device
 * @erase: Called to erase an effect from device
 * @playback: Called to request device to start playing specified effect
 * @set_gain: Called to set specified gain
 * @set_autocenter: Called to auto-center device
 * @destroy: called by input core when parent input device is being
 *    destroyed
 * @private: driver-specific data, will be freed automatically
 * @ffbit: bitmap of force feedback capabilities truly supported by
 *    device (not emulated like ones in input_dev->ffbit)
 * @mutex: mutex for serializing access to the device
 * @max_effects: maximum number of effects supported by device
 * @effects: pointer to an array of effects currently loaded into device
 * @effect_owners: array of effect owners; when file handle owning
 *    an effect gets closed the effect is automatically erased
 *
 * Every force-feedback device must implement upload() and playback()
 * methods; erase() is optional. set_gain() and set_autocenter() need
 * only be implemented if driver sets up FF_GAIN and FF_AUTOCENTER
 * bits.
 *
 * Note that playback(), set_gain() and set_autocenter() are called with
 * dev->event_lock spinlock held and interrupts off and thus may not
 * sleep.
 */
struct ff_device {
    int (*upload)(struct input_dev *dev, struct ff_effect *effect,
              struct ff_effect *old);
    int (*erase)(struct input_dev *dev, int effect_id);

    int (*playback)(struct input_dev *dev, int effect_id, int value);
    void (*set_gain)(struct input_dev *dev, u16 gain);
    void (*set_autocenter)(struct input_dev *dev, u16 magnitude);

    void (*destroy)(struct ff_device *);

    void *private;

    unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];

    struct mutex mutex;

    int max_effects;
    struct ff_effect *effects;
    struct file *effect_owners[];
};

int input_ff_create(struct input_dev *dev, int max_effects);
void input_ff_destroy(struct input_dev *dev);

int input_ff_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);

int input_ff_upload(struct input_dev *dev, struct ff_effect *effect, struct file *file);
int input_ff_erase(struct input_dev *dev, int effect_id, struct file *file);

int input_ff_create_memless(struct input_dev *dev, void *data,
        int (*play_effect)(struct input_dev *, void *, struct ff_effect *));

#endif
#endif

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Linux模拟鼠标和键盘事件的方法

1、在内核中实现一个虚拟的驱动程序,接收应用层数据,使用输入子系统的接口函数input_report_key()向内核inputcore投递事件。

2、直接向/dev/input/event*写入structinput_event值。


现在看一下linu/input.h这个文件中定义的结构本及按键编码值以及所支持的ioctl()命令
structinput_event {
   structtimeval time;  //按键时间
   __u16type; //类型,在下面有定义
   __u16code; //要模拟成什么按键
   __s32value;//是按下还是释放
};

code
事件的代码.如果事件的类型代码是EV_KEY,该代码code为设备键盘代码.代码植0~127为键盘上的按键代码,0x110~0x116 为鼠标上按键代码,其中0x110(BTN_LEFT)为鼠标左键,0x111(BTN_RIGHT)为鼠标右键,0x112(BTN_MIDDLE)为鼠标中键.其它代码含义请参看include/linux/input.h文件.如果事件的类型代码是EV_REL,code值表示轨迹的类型.如指示鼠标的X轴方向REL_X(代码为0x00),指示鼠标的Y轴方向REL_Y(代码为0x01),指示鼠标中轮子方向REL_WHEEL(代码为0x08).

type:
EV_KEY,键盘
EV_REL,相对坐标
EV_ABS,绝对坐标

value
事件的值.如果事件的类型代码是EV_KEY,当按键按下时值为1,松开时值为0;如果事件的类型代码是EV_REL,value的正数值和负数值分别代表两个不同方向的值.
/*
 *Event types
 /

#defineEV_SYN           0x00
#defineEV_KEY           0x01 //按键
#defineEV_REL           0x02 //相对坐标(轨迹球)
#defineEV_ABS           0x03 //绝对坐标
#defineEV_MSC           0x04 //其他
#defineEV_SW           0x05
#defineEV_LED           0x11 //LED
#defineEV_SND           0x12//声音
#defineEV_REP           0x14//repeat
#defineEV_FF           0x15
#defineEV_PWR           0x16
#defineEV_FF_STATUS        0x17
#defineEV_MAX           0x1f
#defineEV_CNT           (EV_MAX+1)

下面是一个模拟鼠标和键盘输入的例子:

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

voidsimulate_key(int fd,int kval)
{
   structinput_event event;
   event.type= EV_KEY; 键盘事件
   event.value= 1;按键按下
   event.code= kval;

   gettimeofday(&event.time,0);
   write(fd,&event,sizeof(event));//写入到/dev/input/event中。

       event.type= EV_SYN; 这里的同步,相当于刷新吧?
       event.code= SYN_REPORT;
       event.value= 0;
       write(fd,&event, sizeof(event));
   
       memset(&event,0, sizeof(event));
       gettimeofday(&event.time,NULL);
       event.type= EV_KEY; 键盘事件
       event.code= kval;
       event.value= 0; 按键松开
       write(fd,&event, sizeof(event));


       event.type= EV_SYN; 再次刷新一下?
       event.code= SYN_REPORT;
       event.value= 0;
       write(fd,&event, sizeof(event));

}

voidsimulate_mouse(int fd)
{
   structinput_event event;
       memset(&event,0, sizeof(event));
       gettimeofday(&event.time,NULL);
       event.type= EV_REL; 轨迹球事件(鼠标事件)
       event.code= REL_X; 轨迹球x
       event.value= 10; 具体的值
       write(fd,&event, sizeof(event));写入到设备结点,传到驱动程序中。

       event.type= EV_REL; 轨迹球事件(鼠标事件)
       event.code= REL_Y; 轨迹y
       event.value= 10; 具体的值
       write(fd,&event, sizeof(event)); 传给驱动

       event.type= EV_SYN; 同步一下。
       event.code= SYN_REPORT;
       event.value= 0;
       write(fd,&event, sizeof(event));
}

intmain()
{
   intfd_kbd; 
   intfd_mouse; 

键盘事件,设备节点
   fd_kbd= open("/dev/input/event1",O_RDWR);
   if(fd_kbd<=0){
       printf("erroropen keyboard:/n");
       return-1;

   }
鼠标事件,设备节点
   fd_mouse= open("/dev/input/event2",O_RDWR); 
   if(fd_mouse<=0){
       printf("erroropen mouse/n");
       return-2;
   }

   inti = 0;
   for(i=0;i< 10; i++)
   {
       simulate_key(fd_kbd,KEY_A + i);
       simulate_mouse(fd_mouse);
       sleep(1);
   }

   close(fd_kbd);
}
模拟了鼠标和键盘的输入事件。
关于这里open哪个event,可以通过 cat/proc/bus/input/devices 
I:Bus=0017 Vendor=0001 Product=0001 Version=0100
N:Name="Macintosh mouse button emulation"
P:Phys=
S:Sysfs=/class/input/input0
U:Uniq=
H:Handlers=mouse0 event0 
B:EV=7
B:KEY=70000 0 0 0 0 0 0 0 0
B:REL=3

I:Bus=0011 Vendor=0001 Product=0001 Version=ab41
N:Name="AT Translated Set 2 keyboard"
P:Phys=isa0060/serio0/input0
S:Sysfs=/class/input/input1
U:Uniq=
H:Handlers=kbd event1 
B:EV=120013
B:KEY=4 2000000 3803078 f800d001 feffffdf ffefffff ffffffff fffffffe
B:MSC=10
B:LED=7

I:Bus=0019 Vendor=0000 Product=0002 Version=0000
N:Name="Power Button (FF)"
P:Phys=LNXPWRBN/button/input0
S:Sysfs=/class/input/input3
U:Uniq=
H:Handlers=kbd event3 
B:EV=3
B:KEY=100000 0 0 0

I:Bus=0019 Vendor=0000 Product=0001 Version=0000
N:Name="Power Button (CM)"
P:Phys=PNP0C0C/button/input0
S:Sysfs=/class/input/input4
U:Uniq=
H:Handlers=kbd event4 
B:EV=3
B:KEY=100000 0 0 0

I:Bus=0003 Vendor=046d Product=c018 Version=0111
N:Name="Logitech USB Optical Mouse"
P:Phys=usb-0000:00:1d.1-2/input0
S:Sysfs=/class/input/input24
U:Uniq=
H:Handlers=mouse1 event2 
B:EV=7
B:KEY=70000 0 0 0 0 0 0 0 0
B:REL=103

下面是一个读取鼠标和键盘事件的例子:
#include
#include
#include
#include
#include
#include
#include
#include

staticvoid show_event(struct input_event* event)
{
       printf("%d%d %d/n", event->type, event->code, event->value);
       return;
}

intmain(int argc, char* argv[])
{
       structinput_event event = {{0}, 0};
       constchar* file_name = argc == 2 ? argv[1] : "/dev/input/event2";
       intfd = open(file_name, O_RDWR);
       if(fd> 0)
       {
               while(1)
               {
                       intret = read(fd, &event,sizeof(event));读取事件!
                       if(ret== sizeof(event))
                       {
                               show_event(&event);
                       }
                       else
                       {
                               break;
                       }
               }
               close(fd);
       }

       return0;
}

模拟CTRL+ SPACE组合按键
voidsimulate_ctrl_space(int fd)
{
       structinput_event event;

    //先发送一个CTRL按下去的事件。
       event.type= EV_KEY;
       event.value= 1; 按键按下
       event.code= KEY_LEFTCTRL;
       gettimeofday(&event.time,0);
       write(fd,&event,sizeof(event));

       event.type= EV_SYN;
       event.code= SYN_REPORT;
       event.value= 0;
       write(fd,&event, sizeof(event));

    //先发送一个SPACE按下去的事件。
       event.type= EV_KEY;
       event.value= 1; 按键按下
       event.code= KEY_SPACE;
       gettimeofday(&event.time,0);
       write(fd,&event,sizeof(event));

    //发送一个释放 SPACE的事件
       memset(&event,0, sizeof(event));
       gettimeofday(&event.time,NULL);
       event.type= EV_KEY;
       event.code= KEY_SPACE;
       event.value= 0;按键松开
       write(fd,&event, sizeof(event));

       event.type= EV_SYN;
       event.code= SYN_REPORT;
       event.value= 0;
       write(fd,&event, sizeof(event));


    //发送一个释放 CTRL的事件
       memset(&event,0, sizeof(event));
       gettimeofday(&event.time,NULL);
       event.type= EV_KEY;
       event.code= KEY_LEFTCTRL;
       event.value= 0; 按键松开
       write(fd,&event, sizeof(event));

       event.type= EV_SYN;
       event.code= SYN_REPORT;
       event.value= 0;
       write(fd,&event, sizeof(event));
}



接下来分析一下uinputlinuxinput子系统。

linuxuinput 

本文以2.6.22.7kernel为基础。
首先uinput是一个字符设备,其次它还是一个 input设备。另外它可以是一个鼠标或者键盘设备。

init部分说起吧。

staticconst struct file_operations uinput_fops = {
   .owner        = THIS_MODULE,
   .open        = uinput_open,
   .release    = uinput_release,
   .read        = uinput_read,
   .write        = uinput_write,
   .poll        = uinput_poll,
   .unlocked_ioctl    = uinput_ioctl,
};
staticstruct miscdevice uinput_misc = {
    .fops       = &uinput_fops,
   .minor        = UINPUT_MINOR,
   .name        = UINPUT_NAME,
};

staticint __init uinput_init(void)
{
    returnmisc_register(&uinput_misc);
}

首先说说miscdevice,很方便的东西,对device做了简单的包装,
misc_register的时候就完成了设备的 注册安装一类的东东, 不用自己再操心了。真是懒人的设计阿。
所有的misc设备公用同一个主设备号,在misc_init中,
staticint __init misc_init(void)
{
#ifdef CONFIG_PROC_FS
   struct proc_dir_entry *ent;

    ent =create_proc_entry("misc", 0, NULL);
   if (ent)
        ent->proc_fops =&misc_proc_fops;
#endif
    misc_class =class_create(THIS_MODULE, "misc");
    if(IS_ERR(misc_class))
        returnPTR_ERR(misc_class);

    if(register_chrdev(MISC_MAJOR,"misc",&misc_fops)) {
       printk("unable to get major %d for miscdevices/n",
              MISC_MAJOR);
       class_destroy(misc_class);
       return -EIO;
    }
    return0;
}
register_chrdev
接口真BT,
__register_chrdev_region(major, 0, 256, name);
直接占用了0255的次设备号,注册misc类型设备的时候,直接从里面取就是了。
而在misc_open通过设备节点把file_operations指向对应的设备驱动上去,很良好的设计, 呵呵。
有点类似其他总线的设计,但是只有 device_list,没有driver_list,当然也不需要。
不在misc上浪费时间了。接下来再到 uinput中去。
uinput_open说起吧,uinput_open其实啥事情都没干。。做了一些简单的初始化工作。

要创建一个input设备,我们在调用input_register_device前需要设置好input_dev的各种属性。
而设置input_dev的属性在uinput_setup_device接口中,但驱动怎么知道你想模拟什么设备呢?
又需要通过uinput_ioctl设置先。很糟糕的设计。 用户若是不知道这些流程,如何能使用这个模拟驱动?
下面是一个使用uinput的用户态程序:

intsetup_uinput_device(char *device)
{
               // Temporary variable
               int i=0;
               // Open the input device
               //uinp_fd = open("/dev/input/uinput", O_WRONLY |O_NDELAY);
               uinp_fd = open(device, O_WRONLY | O_NDELAY);

              if (uinp_fd == 0)
                 {
                       printf("Unable to open/dev/input/uinput/n");
                       return -1;
                 }

               memset(&uinp,0,sizeof(uinp)); // Intialize the uInput device toNULL
               strncpy(uinp.name, "HID Keyboard Device", strlen("HIDKeyboard Device"));
               uinp.id.version = 4;
               uinp.id.bustype = BUS_USB;
               uinp.id.product = 1;
               uinp.id.vendor = 1;
               // Setup the uinput device
               ioctl(uinp_fd, UI_SET_EVBIT, EV_KEY);
               ioctl(uinp_fd, UI_SET_EVBIT, EV_REL);
               ioctl(uinp_fd,UI_SET_RELBIT, REL_X);
               ioctl(uinp_fd, UI_SET_RELBIT, REL_Y);

           for (i=0; i < 256; i++){
               ioctl(uinp_fd, UI_SET_KEYBIT, i);
           }
          ioctl(uinp_fd, UI_SET_KEYBIT, BTN_MOUSE);
          ioctl(uinp_fd, UI_SET_KEYBIT,BTN_TOUCH);
          ioctl(uinp_fd, UI_SET_KEYBIT, BTN_MOUSE);
          ioctl(uinp_fd, UI_SET_KEYBIT,BTN_LEFT);
          ioctl(uinp_fd, UI_SET_KEYBIT, BTN_MIDDLE);
          ioctl(uinp_fd, UI_SET_KEYBIT,BTN_RIGHT);
          ioctl(uinp_fd, UI_SET_KEYBIT, BTN_FORWARD);
          ioctl(uinp_fd, UI_SET_KEYBIT,BTN_BACK);
 
         write(uinp_fd, &uinp, sizeof(uinp));
         if (ioctl(uinp_fd, UI_DEV_CREATE))
          {
                       printf("Unable to create UINPUT device.");
                      return -1;
          }
           return 1;
}

很变态的流程,先用 ioctl设置参数(模拟鼠标,键盘),再 write,在第一次write的时候创建inputdev,
然后ioctl调用UI_DEV_CREATE向系统注册.BT............
今天先写到这里拉。。

浅析linux下键盘设备工作和注册流程

【浅析linux下鼠标驱动的实现】 
 input_init( ) = > 
= > 
class_register
( & input_class) ; 注册input
input_proc_init
( ) ; 创建proc下的目录和文件
register_chrdev
( INPUT_MAJOR, "input" , & input_fops) ; 注册驱动程序到cdev_map, 以待驱动设备. 

drivers/input/keyboard/pxa3xx_keypad
. c为我们的keyboard设备, 
pxa3xx_keypad_probe
= > 
request_irq
( IRQ_ENHROT, & enhanced_rotary_interrupt, 
            IRQF_DISABLED
, "EnhancedRotary" , ( void * ) keypad) ; 注册快捷键中断
request_irq
( IRQ_KEYPAD, pxa3xx_keypad_interrupt, IRQF_DISABLED, pdev- > name, keypad) ; 注册中断
static irqreturn_tpxa3xx_keypad_interrupt( int irq, void * dev_id) 
{ 
    
struct pxa3xx_keypad * keypad = dev_id; 
    
uint32_t kpc = keypad_readl( KPC) ; 

    
if ( kpc & KPC_MI) 
        pxa3xx_keypad_scan_matrix
( keypad) ; 

    
if ( kpc & KPC_DI) 
        pxa3xx_keypad_scan_direct
( keypad) ; 

    
return IRQ_HANDLED; 
} 
irq中如果读到了key, 那么会直接调用
input_report_key
( keypad- > input_dev, lookup_matrix_keycode( keypad, row, col) , 
                new_state
[ col] & ( 1 < < row) ) ; 
static inline unsigned int lookup_matrix_keycode( 
        
struct pxa3xx_keypad * keypad, int row, int col) 
{ 
    
return keypad- > matrix_keycodes[ ( row < < 3) + col] ; 
} 
input_report_key
( struct input_dev * dev, unsigned int code, int value) 
dev
input_dev设备, 我们的4* 4键盘
code
为标准PC键盘码值
value
为按键动作, 1表示键盘按下, 0表示按键抬起
static inline void input_report_key( struct input_dev * dev, unsigned int code, int value) 
{ 
    input_event
( dev, EV_KEY, code, ! ! value) ; 
} 
void input_event( struct input_dev * dev, 
         
unsigned int type, unsigned int code, int value) 
{ 
    
unsigned long flags; 

    
if ( is_event_supported( type, dev- > evbit, EV_MAX) ) { 
        spin_lock_irqsave
( & dev- > event_lock, flags) ; 
        add_input_randomness
( type, code, value) ; //因为按键的存在随机性,所以按键是给系统提供墒随机数的好来源. 
        input_handle_event
( dev, type, code, value) ; 
        spin_unlock_irqrestore
( & dev- > event_lock, flags) ; 
    
} 
} 
static void input_handle_event( struct input_dev * dev, 
                   
unsigned int type, unsigned int code, int value) 
{ 
    
. . . 
        
case EV_KEY: 
        
if ( is_event_supported( code, dev- > keybit, KEY_MAX) & & 
            
! ! test_bit( code, dev- > key) ! = value) { //这次来的是否为新的键值

            
if ( value ! = 2) { 
                __change_bit
( code, dev- > key) ; //通过异或^操作,反转code对应的bitmap,如果value等于2,那么将忽略该按键 
                
if ( value) 
                    input_start_autorepeat
( dev, code) ; //键盘按下,那么开启定时检测,这样可以出现连续输入的效果 
            
} 

            disposition 
= INPUT_PASS_TO_HANDLERS; 
        
} 
        
break ; 
    
. . . 
} 
static void input_start_autorepeat( struct input_dev * dev, int code) 
{ 
    
if ( test_bit( EV_REP, dev- > evbit) & & 
    dev
- > rep[ REP_PERIOD] & & dev- > rep[ REP_DELAY] & & 
    dev
- > timer. data) { 
        dev
- > repeat_key = code; 
        mod_timer
( & dev- > timer, //重新启动定时器input_repeat_key,时间间隔msecs_to_jiffies(dev->rep[REP_DELAY]) 
            jiffies 
+ msecs_to_jiffies( dev- > rep[ REP_DELAY] ) ) ; 
    
} 
} 

static void input_repeat_key( unsigned long data) 
{ 
    
struct input_dev * dev = ( void * ) data; 
    
unsigned long flags; 

    spin_lock_irqsave
( & dev- > event_lock, flags) ; 

    
if ( test_bit( dev- > repeat_key, dev- > key) & & 
    is_event_supported
( dev- > repeat_key, dev- > keybit, KEY_MAX) ) { 

        input_pass_event
( dev, EV_KEY, dev- > repeat_key, 2) ; //交给处理按键函数 

        
if ( dev- > sync) { 
            
/*
            * Only send SYN_REPORT if we are not in a middle
            * of driver parsing a new hardware packet.
            * Otherwise assume that the driver will send
            * SYN_REPORT once it's done.
            */
 
            input_pass_event
( dev, EV_SYN, SYN_REPORT, 1) ; 
        
} 

        
if ( dev- > rep[ REP_PERIOD] ) 
            mod_timer
( & dev- > timer, jiffies + 
                    msecs_to_jiffies
( dev- > rep[ REP_PERIOD] ) ) ; 
    
} 

    spin_unlock_irqrestore
( & dev- > event_lock, flags) ; 
} 

input_pass_event
= > 
handle
- > handler- > event( handle, type, code, value) ; 
就是kbd_handlerkbd_event= > kbd_keycode= > 
atomic_notifier_call_chain
( & keyboard_notifier_list, KBD_UNICODE, & param) 
通知挂在keyboard链上所有等待键盘输入的应用程序, 
通过register_keyboard_notifier( ) 函数可以注册到键盘链上【gliethttp. Leith, 


input_dev 
= input_allocate_device( ) ; 申请一个input设备空间
input_dev
- > open = pxa3xx_keypad_open; 给这个空间填充方法
input_dev
- > close = pxa3xx_keypad_close; 
input_dev
- > private = keypad; 
set_bit
( EV_KEY, input_dev- > evbit) ; //键按下 
set_bit
( EV_REL, input_dev- > evbit) ; //键释放 
pxa3xx_keypad_build_keycode
( keypad) ; //设备键盘映射码 
该函数将根据pxa3xx_device_keypad设备下的matrix_key_map进行键控设置, 
pxa_set_keypad_info
( & jades_keypad_info) = > jades_keypad_info登记为pdata; 
# define MAX_MATRIX_KEY_NUM ( 8 * 8) 
matrix_keycodes
[ MAX_MATRIX_KEY_NUM] ; 表示为8* 8键盘
keypad
- > matrix_keycodes[ ( row < < 3) + col] = code; 表示第row行的第col列处按键, 代表code编码值, 这个为我们内部使用. 
set_bit
( code, input_dev- > keybit) ; //设置code为我们的键盘对操作系统可用的键盘值 
if ( pdata- > direct_key_num) { 
    
for ( i = 0; i < pdata- > direct_key_num; i+ + ) { 
        set_bit
( pdata- > direct_key_map[ i] , input_dev- > keybit) ; //快捷键单元 
    
} 
} 
set_bit
( KEY_POWER, input_dev- > keybit) ; //登记电源按键为系统可见按键 
input_register_device
( input_dev) ; = > //注册设该备devices_subsys总线上 
int input_register_device( struct input_dev * dev) 
{ 
    
static atomic_tinput_no = ATOMIC_INIT( 0) ; 
    
struct input_handler * handler; 
    
const char * path; 
    
int error ; 

    __set_bit
( EV_SYN, dev- > evbit) ; 

    
/*
     *If delay and period are pre-set by the driver, thenautorepeating
     * is handled by thedriver itself and we don't do it ininput.c.
     */
 

    init_timer
( & dev- > timer) ; 
    
if ( ! dev- > rep[ REP_DELAY] & & ! dev- > rep[ REP_PERIOD] ) { 
        dev
- > timer. data = ( long ) dev; 
        dev
- > timer. function = input_repeat_key; //消抖处理函数,采用延时消抖 
        dev
- > rep[ REP_DELAY] = 500; //250; 
        dev
- > rep[ REP_PERIOD] = 66; //33; 
    
} 

    
if ( ! dev- > getkeycode) 
        dev
- > getkeycode = input_default_getkeycode; 

    
if ( ! dev- > setkeycode) 
        dev
- > setkeycode = input_default_setkeycode; 
    
///sys/class/input下创建以input0,input1为目录名的input类型设备 
    snprintf
( dev- > dev. bus_id, sizeof ( dev- > dev. bus_id) , 
         
"input%ld" , ( unsigned long ) atomic_inc_return( & input_no) - 1) ; 

    
if ( dev- > cdev. dev) 
        dev
- > dev. parent = dev- > cdev. dev; 

    
error = device_add( & dev- > dev) ; //将设备登记到设备总线上,之后将以目录和文件的形式呈现 
    
if ( error ) 
        
return error ; 

    path 
= kobject_get_path( & dev- > dev. kobj, GFP_KERNEL) ; 
    printk
( KERN_INFO "input:%s as %s/n" , 
        dev
- > name ? dev- > name : "Unspecifieddevice" , path ? path : "N/A" ) ; 
    kfree
( path) ; 

    
error = mutex_lock_interruptible( & input_mutex) ; 
    
if ( error ) { 
        device_del
( & dev- > dev) ; 
        
return error ; 
    
} 

    list_add_tail
( & dev- > node, & input_dev_list) ; 
//将设备放到input的链表上,该链表上存放着所有input类型的dev设备对象【gliethttp.Leith 
    list_for_each_entry
( handler, & input_handler_list, node) 
        input_attach_handler
( dev, handler) ; 
//input_handler_list驱动链表上尝试匹配,是否有驱动该dev设备的driver驱动,如果有,那么将匹配的驱动绑定给dev设备,来驱动这个dev. 
    input_wakeup_procfs_readers
( ) ; 

    mutex_unlock
( & input_mutex) ; 

    
return 0; 
} 

drivers/
char / keyboard. c
kbd_init
( ) = > 
input_register_handler
( & kbd_handler) ; 注册键盘驱动到input_handler_list链表上

static int input_attach_handler( struct input_dev * dev, struct input_handler * handler) 
{ 
    
const struct input_device_id * id; 
    
int error ; 

    
if ( handler- > blacklist & & input_match_device( handler- > blacklist, dev) ) 
        
return - ENODEV; 

    id 
= input_match_device( handler- > id_table, dev) ; 
    
if ( ! id) 
        
return - ENODEV; 

    
error = handler- > connect ( handler, dev, id) ; //ok,找到驱动该devdriver,那么尝试连接 
    
if ( error & & error ! = - ENODEV) 
        printk
( KERN_ERR
            
"input:failed to attach handler %s to device %s, " 
            
"error:%d/n" , 
            handler
- > name, kobject_name( & dev- > dev. kobj) , error ) ; 

    
return error ; 
} 

kbd_connect
= > input_register_handle= > input_open_device= > pxa3xx_keypad_open配置键盘io


以下内容转自: http://ericxiao.cublog.cn/

:evdev的初始化
Evdev
的模块初始化函数为evdev_init().代码如下:
staticint __init evdev_init(void)
{
        returninput_register_handler(&evdev_handler);
}
它调用了input_register_handler注册了一个handler.
注意到,在这里evdev_handler中定义的minorEVDEV_MINOR_BASE(64).也就是说evdev_handler所表示的设备文件范围为(13,64)à(13,64+32).
从之前的分析我们知道.匹配成功的关键在于handler中的blacklistid_talbe.Evdev_handlerid_table定义如下:
staticconst struct input_device_id evdev_ids[] = {
        { .driver_info = 1 },     /* Matches all devices*/
         {},                      /* Terminating zero entry*/
};
它没有定义flags.也没有定义匹配属性值.这个handler是匹配所有inputdevice.从前面的分析我们知道.匹配成功之后会调用handler->connect函数.
Evdev_handler,该成员函数如下所示:
 
staticint evdev_connect(struct input_handler *handler, struct input_dev*dev,
                            const struct input_device_id *id)
{
        struct evdev *evdev;
        int minor;
         interror;
 
        for (minor = 0; minor < EVDEV_MINORS; minor++)
                  if (!evdev_table[minor])
                           break;
 
        if (minor == EVDEV_MINORS) {
                  printk(KERN_ERR "evdev: no more free evdevdevices/n");
                  return -ENFILE;
        }
EVDEV_MINORS
定义为32.表示evdev_handler所表示的32个设备文件.evdev_talbe是一个structevdev类型的数组.structevdev是模块使用的封装结构.在接下来的代码中我们可以看到这个结构的使用.
这一段代码的在evdev_talbe找到为空的那一项.minor就是数组中第一项为空的序号.
 
        evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
        if (!evdev)
                  return -ENOMEM;
 
        INIT_LIST_HEAD(&evdev->client_list);
        spin_lock_init(&evdev->client_lock);
        mutex_init(&evdev->mutex);
        init_waitqueue_head(&evdev->wait);
 
        snprintf(evdev->name, sizeof(evdev->name), "event%d",minor);
        evdev->exist = 1;
        evdev->minor = minor;
 
        evdev->handle.dev = input_get_device(dev);
        evdev->handle.name = evdev->name;
        evdev->handle.handler = handler;
        evdev->handle.private = evdev;
接下来,分配了一个evdev结构,并对这个结构进行初始化.在这里我们可以看到,这个结构封装了一个handle结构,这结构与我们之前所讨论的handler是不相同的.注意有一个字母的差别哦.我们可以把handle看成是handlerinputdevice的信息集合体.在这个结构里集合了匹配成功的handlerinputdevice
 
        strlcpy(evdev->dev.bus_id, evdev->name,sizeof(evdev->dev.bus_id));
        evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE +minor);
        evdev->dev.class = &input_class;
        evdev->dev.parent = &dev->dev;
        evdev->dev.release = evdev_free;
        device_initialize(&evdev->dev);
在这段代码里主要完成evdev封装的device的初始化.注意在这里,使它所属的类指向input_class.这样在/sysfs中创建的设备目录就会在/sys/class/input/下面显示.
 
        error = input_register_handle(&evdev->handle);
        if (error)
                  goto err_free_evdev;
        error = evdev_install_chrdev(evdev);
        if (error)
                  goto err_unregister_handle;
 
        error = device_add(&evdev->dev);
        if (error)
                  goto err_cleanup_evdev;
 
        return 0;
 
 err_cleanup_evdev:
        evdev_cleanup(evdev);
 err_unregister_handle:
        input_unregister_handle(&evdev->handle);
 err_free_evdev:
        put_device(&evdev->dev);
        returnerror;
}
注册handle,如果是成功的,那么调用evdev_install_chrdevevdev_tableminor项指向evdev.然后将evdev->device注册到sysfs.如果失败,将进行相关的错误处理.
万事俱备了,但是要接收事件,还得要等”东风”.这个”东风”就是要打开相应的handle.这个打开过程是在文件的open()中完成的.
 
:evdev设备结点的open()操作
我们知道.对主设备号为INPUT_MAJOR的设备节点进行操作,会将操作集转换成handler的操作集.evdev,这个操作集就是evdev_fops.对应的open函数如下示:
staticint evdev_open(struct inode *inode, struct file *file)
{
        struct evdev *evdev;
        struct evdev_client *client;
        int i = iminor(inode) - EVDEV_MINOR_BASE;
        int error;
 
        if (i >= EVDEV_MINORS)
                  return -ENODEV;
 
        error = mutex_lock_interruptible(&evdev_table_mutex);
        if (error)
                  return error;
        evdev = evdev_table[i];
        if (evdev)
                  get_device(&evdev->dev);
        mutex_unlock(&evdev_table_mutex);
 
        if (!evdev)
                  return -ENODEV;
 
        client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
        if (!client) {
                  error = -ENOMEM;
                  goto err_put_evdev;
        }
        spin_lock_init(&client->buffer_lock);
        client->evdev = evdev;
        evdev_attach_client(evdev, client);
 
        error = evdev_open_device(evdev);
        if (error)
                  goto err_free_client;
 
        file->private_data = client;
        return 0;
 
 err_free_client:
        evdev_detach_client(evdev, client);
        kfree(client);
 err_put_evdev:
        put_device(&evdev->dev);
        return error;
}
iminor(inode) -EVDEV_MINOR_BASE
就得到了在evdev_table[]中的序号.然后将数组中对应的evdev取出.递增devdevdevice的引用计数.
分配并初始化一个client.并将它和evdev关联起来:client->evdev指向它所表示的evdev.client挂到evdev->client_list.client赋为file的私有区.
对应handle的打开是在此evdev_open_device()中完成的.代码如下:
staticint evdev_open_device(struct evdev *evdev)
{
        int retval;
 
        retval = mutex_lock_interruptible(&evdev->mutex);
        if (retval)
                  return retval;
 
        if (!evdev->exist)
                  retval = -ENODEV;
        else if (!evdev->open++) {
                  retval = input_open_device(&evdev->handle);
                  if (retval)
                           evdev->open--;
        }
 
        mutex_unlock(&evdev->mutex);
        returnretval;
}
如果evdev是第一次打开,就会调用input_open_device()打开evdev对应的handle.跟踪一下这个函数:
intinput_open_device(struct input_handle *handle)
{
        struct input_dev *dev = handle->dev;
        int retval;
 
        retval = mutex_lock_interruptible(&dev->mutex);
        if (retval)
                  return retval;
 
        if (dev->going_away) {
                  retval = -ENODEV;
                  goto out;
        }
 
        handle->open++;
 
        if (!dev->users++ && dev->open)
                  retval = dev->open(dev);
 
        if (retval) {
                  dev->users--;
                  if (!--handle->open) {
                           /*
                            * Make sure we are not delivering any moreevents
                            * through this handle
                            */
                           synchronize_rcu();
                  }
        }
 
 out:
        mutex_unlock(&dev->mutex);
        return retval;
}
在这个函数中,我们看到.递增handle的打开计数.如果是第一次打开.则调用inputdeviceopen()函数.
 
十一:evdev的事件处理
经过上面的分析.每当inputdevice上报一个事件时,会将其交给和它匹配的handlerevent函数处理.evdev.这个event函数对应的代码为:
staticvoid evdev_event(struct input_handle*handle,
                           unsigned int type, unsigned int code, int value)
{
        struct evdev *evdev = handle->private;
        struct evdev_client *client;
        struct input_event event;
 
        do_gettimeofday(&event.time);
        event.type = type;
        event.code = code;
        event.value = value;
 
        rcu_read_lock();
 
        client = rcu_dereference(evdev->grab);
        if (client)
                  evdev_pass_event(client, &event);
        else
                  list_for_each_entry_rcu(client, &evdev->client_list,node)
                           evdev_pass_event(client, &event);
 
        rcu_read_unlock();
 
        wake_up_interruptible(&evdev->wait);
}
首先构造一个structinput_event结构.并设备它的type.code,value为处理事件的相关属性.如果该设备被强制设置了handle.则调用如之对应的client.
我们在open的时候分析到.会初始化clinet并将其链入到evdev->client_list.这样,就可以通过evdev->client_list找到这个client.
对于找到的第一个client都会调用evdev_pass_event().代码如下:
staticvoid evdev_pass_event(struct evdev_client*client,
                                struct input_event *event)
{
        /*
          *Interrupts are disabled, just acquire the lock
         */
        spin_lock(&client->buffer_lock);
        client->buffer[client->head++] = *event;
        client->head &= EVDEV_BUFFER_SIZE - 1;
        spin_unlock(&client->buffer_lock);
 
        kill_fasync(&client->fasync, SIGIO,POLL_IN);
}
这里的操作很简单.就是将event保存到client->buffer.client->head就是当前的数据位置.注意这里是一个环形缓存区.写数据是从client->head.而读数据则是从client->tail中读.
 
十二:设备节点的read处理
对于evdev设备节点的read操作都会由evdev_read()完成.它的代码如下:
staticssize_t evdev_read(struct file *file, char __user*buffer,
                             size_t count, loff_t *ppos)
{
        struct evdev_client *client = file->private_data;
        struct evdev *evdev = client->evdev;
        struct input_event event;
        int retval;
 
        if (count < evdev_event_size())
                  return -EINVAL;
 
        if (client->head == client->tail && evdev->exist&&
            (file->f_flags & O_NONBLOCK))
                  return -EAGAIN;
 
        retval = wait_event_interruptible(evdev->wait,
                  client->head != client->tail || !evdev->exist);
        if (retval)
                  return retval;
 
        if (!evdev->exist)
                  return -ENODEV;
 
        while (retval + evdev_event_size() <= count &&
               evdev_fetch_next_event(client, &event)) {
 
                  if (evdev_event_to_user(buffer + retval,&event))
                           return -EFAULT;
 
                  retval += evdev_event_size();
        }
 
        returnretval;
}
首先,它判断缓存区大小是否足够.在读取数据的情况下,可能当前缓存区内没有数据可读.在这里先睡眠等待缓存区中有数据.如果在睡眠的时候,.条件满足.是不会进行睡眠状态而直接返回的.
然后根据read()提够的缓存区大小.client中的数据写入到用户空间的缓存区中.
十三:设备节点的写操作
同样.对设备节点的写操作是由evdev_write()完成的.代码如下:
 
staticssize_t evdev_write(struct file *file, const char __user*buffer,
                              size_t count, loff_t *ppos)
{
        struct evdev_client *client = file->private_data;
        struct evdev *evdev = client->evdev;
        struct input_event event;
        int retval;
 
        retval = mutex_lock_interruptible(&evdev->mutex);
        if (retval)
                  return retval;
 
        if (!evdev->exist) {
                  retval = -ENODEV;
                  goto out;
        }
 
         while(retval < count) {
 
                  if (evdev_event_from_user(buffer + retval, &event)){
                           retval = -EFAULT;
                           goto out;
                  }
 
                  input_inject_event(&evdev->handle,
                                       event.type, event.code, event.value);
                  retval += evdev_event_size();
        }
 
 out:
        mutex_unlock(&evdev->mutex);
        returnretval;
}
首先取得操作设备文件所对应的evdev.
实际上,这里写入设备文件的是一个event结构的数组.我们在之前分析过,这个结构里包含了事件的type.codeevent.
将写入设备的event数组取出.然后对每一项调用event_inject_event().
这个函数的操作和input_event()差不多.就是将第一个参数handle转换为输入设备结构.然后这个设备再产生一个事件.
代码如下:
voidinput_inject_event(struct input_handle*handle,
                           unsigned int type, unsigned int code, int value)
{
        struct input_dev *dev = handle->dev;
        struct input_handle *grab;
        unsigned long flags;
 
        if (is_event_supported(type, dev->evbit, EV_MAX)){
                  spin_lock_irqsave(&dev->event_lock,flags);
 
                  rcu_read_lock();
                  grab = rcu_dereference(dev->grab);
                  if (!grab || grab == handle)
                           input_handle_event(dev, type, code, value);
                  rcu_read_unlock();
 
                  spin_unlock_irqrestore(&dev->event_lock, flags);
        }
}
我们在这里也可以跟input_event()对比一下,这里设备可以产生任意事件,而不需要和设备所支持的事件类型相匹配.
由此可见.对于写操作而言.就是让与设备文件相关的输入设备产生一个特定的事件.
将上述设备文件的操作过程以图的方式表示如下:
 
 
十四:小结
在这一节点,分析了整个input子系统的架构,各个环节的流程.最后还以evdev为例.将各个流程贯穿在一起.以加深对input子系统的理解.由此也可以看出.linux设备驱动采用了分层的模式.从最下层的设备模型到设备,驱动,总线再到input子系统最后到inputdevice.这样的分层结构使得最上层的驱动不必关心下层是怎么实现的.而下层驱动又为多种型号同样功能的驱动提供了一个统一的接口.







你可能感兴趣的:(Linux驱动开发)