ssb: remove the ssb DMA API
[linux-2.6.git] / include / linux / input.h
index 56f1e0e..83524e4 100644 (file)
@@ -16,7 +16,7 @@
 #include <sys/time.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
-#include <asm/types.h>
+#include <linux/types.h>
 #endif
 
 /*
@@ -53,14 +53,15 @@ struct input_absinfo {
        __s32 maximum;
        __s32 fuzz;
        __s32 flat;
+       __s32 resolution;
 };
 
 #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, int[2])                 /* get repeat settings */
-#define EVIOCSREP              _IOW('E', 0x03, int[2])                 /* set repeat settings */
-#define EVIOCGKEYCODE          _IOR('E', 0x04, int[2])                 /* get keycode */
-#define EVIOCSKEYCODE          _IOW('E', 0x04, int[2])                 /* set keycode */
+#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 EVIOCSKEYCODE          _IOW('E', 0x04, unsigned int[2])        /* set keycode */
 
 #define EVIOCGNAME(len)                _IOC(_IOC_READ, 'E', 0x06, len)         /* get device name */
 #define EVIOCGPHYS(len)                _IOC(_IOC_READ, 'E', 0x07, len)         /* get physical location */
@@ -98,6 +99,7 @@ struct input_absinfo {
 #define EV_PWR                 0x16
 #define EV_FF_STATUS           0x17
 #define EV_MAX                 0x1f
+#define EV_CNT                 (EV_MAX+1)
 
 /*
  * Synchronization events.
@@ -105,9 +107,17 @@ struct input_absinfo {
 
 #define SYN_REPORT             0
 #define SYN_CONFIG             1
+#define SYN_MT_REPORT          2
 
 /*
  * 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
@@ -226,10 +236,11 @@ struct input_absinfo {
 #define KEY_MUTE               113
 #define KEY_VOLUMEDOWN         114
 #define KEY_VOLUMEUP           115
-#define KEY_POWER              116
+#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
@@ -240,38 +251,39 @@ struct input_absinfo {
 #define KEY_RIGHTMETA          126
 #define KEY_COMPOSE            127
 
-#define KEY_STOP               128
+#define KEY_STOP               128     /* AC Stop */
 #define KEY_AGAIN              129
-#define KEY_PROPS              130
-#define KEY_UNDO               131
+#define KEY_PROPS              130     /* AC Properties */
+#define KEY_UNDO               131     /* AC Undo */
 #define KEY_FRONT              132
-#define KEY_COPY               133
-#define KEY_OPEN               134
-#define KEY_PASTE              135
-#define KEY_FIND               136
-#define KEY_CUT                        137
-#define KEY_HELP               138
-#define KEY_MENU               139
-#define KEY_CALC               140
+#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
-#define KEY_WAKEUP             143
-#define KEY_FILE               144
+#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
+#define KEY_WWW                        150     /* AL Internet Browser */
 #define KEY_MSDOS              151
-#define KEY_COFFEE             152
+#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
+#define KEY_BOOKMARKS          156     /* AC Bookmarks */
 #define KEY_COMPUTER           157
-#define KEY_BACK               158
-#define KEY_FORWARD            159
+#define KEY_BACK               158     /* AC Back */
+#define KEY_FORWARD            159     /* AC Forward */
 #define KEY_CLOSECD            160
 #define KEY_EJECTCD            161
 #define KEY_EJECTCLOSECD       162
@@ -281,20 +293,20 @@ struct input_absinfo {
 #define KEY_STOPCD             166
 #define KEY_RECORD             167
 #define KEY_REWIND             168
-#define KEY_PHONE              169
+#define KEY_PHONE              169     /* Media Select Telephone */
 #define KEY_ISO                        170
-#define KEY_CONFIG             171
-#define KEY_HOMEPAGE           172
-#define KEY_REFRESH            173
-#define KEY_EXIT               174
+#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
-#define KEY_REDO               182
+#define KEY_NEW                        181     /* AC New */
+#define KEY_REDO               182     /* AC Redo/Repeat */
 
 #define KEY_F13                        183
 #define KEY_F14                        184
@@ -313,12 +325,13 @@ struct input_absinfo {
 #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
+#define KEY_CLOSE              206     /* AC Close */
 #define KEY_PLAY               207
 #define KEY_FASTFORWARD                208
 #define KEY_BASSBOOST          209
-#define KEY_PRINT              210
+#define KEY_PRINT              210     /* AC Print */
 #define KEY_HP                 211
 #define KEY_CAMERA             212
 #define KEY_SOUND              213
@@ -327,30 +340,46 @@ struct input_absinfo {
 #define KEY_CHAT               216
 #define KEY_SEARCH             217
 #define KEY_CONNECT            218
-#define KEY_FINANCE            219
+#define KEY_FINANCE            219     /* AL Checkbook/Finance */
 #define KEY_SPORT              220
 #define KEY_SHOP               221
 #define KEY_ALTERASE           222
-#define KEY_CANCEL             223
+#define KEY_CANCEL             223     /* AC Cancel */
 #define KEY_BRIGHTNESSDOWN     224
 #define KEY_BRIGHTNESSUP       225
 #define KEY_MEDIA              226
 
-#define KEY_SWITCHVIDEOMODE    227
+#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
-#define KEY_REPLY              232
-#define KEY_FORWARDMAIL                233
-#define KEY_SAVE               234
+#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
@@ -419,6 +448,7 @@ struct input_absinfo {
 #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
@@ -430,15 +460,15 @@ struct input_absinfo {
 #define KEY_CLEAR              0x163
 #define KEY_POWER2             0x164
 #define KEY_OPTION             0x165
-#define KEY_INFO               0x166
+#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
+#define KEY_PROGRAM            0x16a   /* Media Select Program Guide */
 #define KEY_CHANNEL            0x16b
 #define KEY_FAVORITES          0x16c
 #define KEY_EPG                        0x16d
-#define KEY_PVR                        0x16e
+#define KEY_PVR                        0x16e   /* Media Select Home */
 #define KEY_MHP                        0x16f
 #define KEY_LANGUAGE           0x170
 #define KEY_TITLE              0x171
@@ -448,36 +478,36 @@ struct input_absinfo {
 #define KEY_MODE               0x175
 #define KEY_KEYBOARD           0x176
 #define KEY_SCREEN             0x177
-#define KEY_PC                 0x178
-#define KEY_TV                 0x179
-#define KEY_TV2                        0x17a
-#define KEY_VCR                        0x17b
-#define KEY_VCR2               0x17c
-#define KEY_SAT                        0x17d
+#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
-#define KEY_TAPE               0x180
+#define KEY_CD                 0x17f   /* Media Select CD */
+#define KEY_TAPE               0x180   /* Media Select Tape */
 #define KEY_RADIO              0x181
-#define KEY_TUNER              0x182
+#define KEY_TUNER              0x182   /* Media Select Tuner */
 #define KEY_PLAYER             0x183
 #define KEY_TEXT               0x184
-#define KEY_DVD                        0x185
+#define KEY_DVD                        0x185   /* Media Select DVD */
 #define KEY_AUX                        0x186
 #define KEY_MP3                        0x187
 #define KEY_AUDIO              0x188
 #define KEY_VIDEO              0x189
 #define KEY_DIRECTORY          0x18a
 #define KEY_LIST               0x18b
-#define KEY_MEMO               0x18c
+#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
-#define KEY_CHANNELDOWN                0x193
+#define KEY_CHANNELUP          0x192   /* Channel Increment */
+#define KEY_CHANNELDOWN                0x193   /* Channel Decrement */
 #define KEY_FIRST              0x194
-#define KEY_LAST               0x195
+#define KEY_LAST               0x195   /* Recall Last */
 #define KEY_AB                 0x196
 #define KEY_NEXT               0x197
 #define KEY_RESTART            0x198
@@ -488,6 +518,32 @@ struct input_absinfo {
 #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_DEL_EOL            0x1c0
 #define KEY_DEL_EOS            0x1c1
@@ -524,10 +580,71 @@ struct input_absinfo {
 #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 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                        0x1ff
+#define KEY_MAX                        0x2ff
+#define KEY_CNT                        (KEY_MAX+1)
 
 /*
  * Relative axes
@@ -544,6 +661,7 @@ struct input_absinfo {
 #define REL_WHEEL              0x08
 #define REL_MISC               0x09
 #define REL_MAX                        0x0f
+#define REL_CNT                        (REL_MAX+1)
 
 /*
  * Absolute axes
@@ -575,7 +693,21 @@ struct input_absinfo {
 #define ABS_TOOL_WIDTH         0x1c
 #define ABS_VOLUME             0x20
 #define ABS_MISC               0x28
+
+#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_MAX                        0x3f
+#define ABS_CNT                        (ABS_MAX+1)
 
 /*
  * Switch events
@@ -584,7 +716,19 @@ struct input_absinfo {
 #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_MAX                 0x0f
+#define SW_CNT                 (SW_MAX+1)
 
 /*
  * Misc events
@@ -596,6 +740,7 @@ struct input_absinfo {
 #define MSC_RAW                        0x03
 #define MSC_SCAN               0x04
 #define MSC_MAX                        0x07
+#define MSC_CNT                        (MSC_MAX+1)
 
 /*
  * LEDs
@@ -613,6 +758,7 @@ struct input_absinfo {
 #define LED_MAIL               0x09
 #define LED_CHARGING           0x0a
 #define LED_MAX                        0x0f
+#define LED_CNT                        (LED_MAX+1)
 
 /*
  * Autorepeat values
@@ -630,6 +776,7 @@ struct input_absinfo {
 #define SND_BELL               0x01
 #define SND_TONE               0x02
 #define SND_MAX                        0x07
+#define SND_CNT                        (SND_MAX+1)
 
 /*
  * IDs.
@@ -645,6 +792,7 @@ struct input_absinfo {
 #define BUS_USB                        0x03
 #define BUS_HIL                        0x04
 #define BUS_BLUETOOTH          0x05
+#define BUS_VIRTUAL            0x06
 
 #define BUS_ISA                        0x10
 #define BUS_I8042              0x11
@@ -657,9 +805,17 @@ struct input_absinfo {
 #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
 
 /*
- * Values describing the status of an effect
+ * Values describing the status of a force-feedback effect
  */
 #define FF_STATUS_STOPPED      0x00
 #define FF_STATUS_PLAYING      0x01
@@ -667,98 +823,167 @@ struct input_absinfo {
 
 /*
  * Structures used in ioctls to upload effects to a device
- * The first structures are not passed directly by using ioctls.
- * They are sub-structures of the actually sent structure (called ff_effect)
+ * 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; /* Duration of an effect in ms. All other times are also expressed in ms */
-       __u16 delay;  /* Time to wait before to start playing an effect */
+       __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;   /* Number of button triggering an effect */
-       __u16 interval; /* Time to wait before an effect can be re-triggered (ms) */
+       __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;    /* Duration of attack (ms) */
-       __u16 attack_level;     /* Level at beginning of attack */
-       __u16 fade_length;      /* Duration of fade (ms) */
-       __u16 fade_level;       /* Level at end of fade */
+       __u16 attack_length;
+       __u16 attack_level;
+       __u16 fade_length;
+       __u16 fade_level;
 };
 
-/* FF_CONSTANT */
+/**
+ * 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;        /* Strength of effect. Negative values are OK */
+       __s16 level;
        struct ff_envelope envelope;
 };
 
-/* FF_RAMP */
+/**
+ * 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;
 };
 
-/* FF_SPRING of FF_FRICTION */
+/**
+ * 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; /* Max level when joystick is on the right */
-       __u16 left_saturation;  /* Max level when joystick in on the left */
-
-       __s16 right_coeff;      /* Indicates how fast the force grows when the
-                                  joystick moves to the right */
-       __s16 left_coeff;       /* Same for left side */
+       __u16 right_saturation;
+       __u16 left_saturation;
 
-       __u16 deadband; /* Size of area where no force is produced */
-       __s16 center;   /* Position of dead zone */
+       __s16 right_coeff;
+       __s16 left_coeff;
 
+       __u16 deadband;
+       __s16 center;
 };
 
-/* FF_PERIODIC */
+/**
+ * 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; /* Kind of wave (sine, square...) */
-       __u16 period;   /* in ms */
-       __s16 magnitude;        /* Peak value */
-       __s16 offset;   /* Mean value of wave (roughly) */
-       __u16 phase;            /* 'Horizontal' shift */
+       __u16 waveform;
+       __u16 period;
+       __s16 magnitude;
+       __s16 offset;
+       __u16 phase;
 
        struct ff_envelope envelope;
 
-/* Only used if waveform == FF_CUSTOM */
-       __u32 custom_len;       /* Number of samples */
-       __s16 *custom_data;     /* Buffer of samples */
-/* Note: the data pointed by custom_data is copied by the driver. You can
- * therefore dispose of the memory after the upload/update */
+       __u32 custom_len;
+       __s16 __user *custom_data;
 };
 
-/* FF_RUMBLE */
-/* Some rumble pads have two motors of different weight.
-   strong_magnitude represents the magnitude of the vibration generated
-   by the heavy motor.
-*/
+/**
+ * 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;  /* Magnitude of the heavy motor */
-       __u16 weak_magnitude;    /* Magnitude of the light one */
+       __u16 strong_magnitude;
+       __u16 weak_magnitude;
 };
 
-/*
- * Structure sent through ioctl from the application to the driver
+/**
+ * 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;
-/* Following field denotes the unique id assigned to an effect.
- * If user sets if to -1, a new effect is created, and its id is returned in the same field
- * Else, the user sets it to the effect id it wants to update.
- */
        __s16 id;
-
-       __u16 direction;        /* Direction. 0 deg -> 0x0000 (down)
-                                            90 deg -> 0x4000 (left)
-                                           180 deg -> 0x8000 (up)
-                                           270 deg -> 0xC000 (right)
-                               */
-
+       __u16 direction;
        struct ff_trigger trigger;
        struct ff_replay replay;
 
@@ -784,6 +1009,9 @@ struct ff_effect {
 #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
  */
@@ -795,6 +1023,9 @@ struct ff_effect {
 #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
  */
@@ -803,6 +1034,7 @@ struct ff_effect {
 #define FF_AUTOCENTER  0x61
 
 #define FF_MAX         0x7f
+#define FF_CNT         (FF_MAX+1)
 
 #ifdef __KERNEL__
 
@@ -815,104 +1047,147 @@ struct ff_effect {
 #include <linux/timer.h>
 #include <linux/mod_devicetable.h>
 
-#define NBITS(x) (((x)/BITS_PER_LONG)+1)
-#define BIT(x) (1UL<<((x)%BITS_PER_LONG))
-#define LONG(x) ((x)/BITS_PER_LONG)
-
-#define INPUT_KEYCODE(dev, scancode) ((dev->keycodesize == 1) ? ((u8*)dev->keycode)[scancode] : \
-       ((dev->keycodesize == 2) ? ((u16*)dev->keycode)[scancode] : (((u32*)dev->keycode)[scancode])))
-
-#define SET_INPUT_KEYCODE(dev, scancode, val)                  \
-               ({      unsigned __old;                         \
-               switch (dev->keycodesize) {                     \
-                       case 1: {                               \
-                               u8 *k = (u8 *)dev->keycode;     \
-                               __old = k[scancode];            \
-                               k[scancode] = val;              \
-                               break;                          \
-                       }                                       \
-                       case 2: {                               \
-                               u16 *k = (u16 *)dev->keycode;   \
-                               __old = k[scancode];            \
-                               k[scancode] = val;              \
-                               break;                          \
-                       }                                       \
-                       default: {                              \
-                               u32 *k = (u32 *)dev->keycode;   \
-                               __old = k[scancode];            \
-                               k[scancode] = val;              \
-                               break;                          \
-                       }                                       \
-               }                                               \
-               __old; })
-
+/**
+ * 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)
+ * @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
+ * @keycodemax: size of keycode table
+ * @keycodesize: size of elements in keycode table
+ * @keycode: map of scancodes to keycodes for this device
+ * @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
+ * @getkeycode: optional method to retrieve current keymap. 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
+ * @sync: set to 1 when there were no new events since last EV_SYNC
+ * @abs: current values for reports from absolute axes
+ * @rep: current values for autorepeat parameters (delay, rate)
+ * @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
+ * @absmax: maximum values for events coming from absolute axes
+ * @absmin: minimum values for events coming from absolute axes
+ * @absfuzz: describes noisiness for axes
+ * @absflat: size of the center flat position (used by joydev)
+ * @absres: resolution used for events coming form absolute axes
+ * @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.
+ * @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 {
-
-       void *private;
-
        const char *name;
        const char *phys;
        const char *uniq;
        struct input_id id;
 
-       unsigned long evbit[NBITS(EV_MAX)];
-       unsigned long keybit[NBITS(KEY_MAX)];
-       unsigned long relbit[NBITS(REL_MAX)];
-       unsigned long absbit[NBITS(ABS_MAX)];
-       unsigned long mscbit[NBITS(MSC_MAX)];
-       unsigned long ledbit[NBITS(LED_MAX)];
-       unsigned long sndbit[NBITS(SND_MAX)];
-       unsigned long ffbit[NBITS(FF_MAX)];
-       unsigned long swbit[NBITS(SW_MAX)];
-       int ff_effects_max;
+       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 keycodemax;
        unsigned int keycodesize;
        void *keycode;
+       int (*setkeycode)(struct input_dev *dev,
+                         unsigned int scancode, unsigned int keycode);
+       int (*getkeycode)(struct input_dev *dev,
+                         unsigned int scancode, unsigned int *keycode);
+
+       struct ff_device *ff;
 
        unsigned int repeat_key;
        struct timer_list timer;
 
-       struct pt_regs *regs;
-       int state;
-
        int sync;
 
        int abs[ABS_MAX + 1];
        int rep[REP_MAX + 1];
 
-       unsigned long key[NBITS(KEY_MAX)];
-       unsigned long led[NBITS(LED_MAX)];
-       unsigned long snd[NBITS(SND_MAX)];
-       unsigned long sw[NBITS(SW_MAX)];
+       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 absmax[ABS_MAX + 1];
        int absmin[ABS_MAX + 1];
        int absfuzz[ABS_MAX + 1];
        int absflat[ABS_MAX + 1];
+       int absres[ABS_MAX + 1];
 
        int (*open)(struct input_dev *dev);
        void (*close)(struct input_dev *dev);
-       int (*accept)(struct input_dev *dev, struct file *file);
        int (*flush)(struct input_dev *dev, struct file *file);
        int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
-       int (*upload_effect)(struct input_dev *dev, struct ff_effect *effect);
-       int (*erase_effect)(struct input_dev *dev, int effect_id);
 
        struct input_handle *grab;
 
-       struct mutex mutex;     /* serializes open and close operations */
-       unsigned int users;
+       spinlock_t event_lock;
+       struct mutex mutex;
 
-       struct class_device cdev;
-       struct device *dev;     /* will be removed soon */
+       unsigned int users;
+       bool going_away;
 
-       int dynalloc;   /* temporarily */
+       struct device dev;
 
        struct list_head        h_list;
        struct list_head        node;
 };
-#define to_input_dev(d) container_of(d, struct input_dev, cdev)
+#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
@@ -922,6 +1197,10 @@ struct input_dev {
 #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
@@ -961,31 +1240,82 @@ struct input_dev {
 
 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);
-       struct input_handle* (*connect)(struct input_handler *handler, struct input_dev *dev, struct input_device_id *id);
+       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;
-       char *name;
+       const char *name;
 
-       struct input_device_id *id_table;
-       struct input_device_id *blacklist;
+       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;
-       char *name;
+       const char *name;
 
        struct input_dev *dev;
        struct input_handler *handler;
@@ -994,46 +1324,52 @@ struct input_handle {
        struct list_head        h_node;
 };
 
-#define to_dev(n) container_of(n,struct input_dev,node)
-#define to_handler(n) container_of(n,struct input_handler,node);
-#define to_handle(n) container_of(n,struct input_handle,d_node)
-#define to_handle_h(n) container_of(n,struct input_handle,h_node)
-
-static inline void init_input_dev(struct input_dev *dev)
-{
-       INIT_LIST_HEAD(&dev->h_list);
-       INIT_LIST_HEAD(&dev->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 to_input_dev(class_device_get(&dev->cdev));
+       return dev ? to_input_dev(get_device(&dev->dev)) : NULL;
 }
 
 static inline void input_put_device(struct input_dev *dev)
 {
-       class_device_put(&dev->cdev);
+       if (dev)
+               put_device(&dev->dev);
 }
 
-int input_register_device(struct input_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_register_handler(struct input_handler *);
+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_accept_process(struct input_handle *handle, struct file *file);
 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)
 {
@@ -1050,11 +1386,6 @@ static inline void input_report_abs(struct input_dev *dev, unsigned int code, in
        input_event(dev, EV_ABS, code, value);
 }
 
-static inline void input_report_ff(struct input_dev *dev, unsigned int code, int value)
-{
-       input_event(dev, EV_FF, 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);
@@ -1065,17 +1396,18 @@ static inline void input_report_switch(struct input_dev *dev, unsigned int code,
        input_event(dev, EV_SW, code, !!value);
 }
 
-static inline void input_regs(struct input_dev *dev, struct pt_regs *regs)
+static inline void input_sync(struct input_dev *dev)
 {
-       dev->regs = regs;
+       input_event(dev, EV_SYN, SYN_REPORT, 0);
 }
 
-static inline void input_sync(struct input_dev *dev)
+static inline void input_mt_sync(struct input_dev *dev)
 {
-       input_event(dev, EV_SYN, SYN_REPORT, 0);
-       dev->regs = NULL;
+       input_event(dev, EV_SYN, SYN_MT_REPORT, 0);
 }
 
+void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code);
+
 static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
 {
        dev->absmin[axis] = min;
@@ -1083,10 +1415,75 @@ static inline void input_set_abs_params(struct input_dev *dev, int axis, int min
        dev->absfuzz[axis] = fuzz;
        dev->absflat[axis] = flat;
 
-       dev->absbit[LONG(axis)] |= BIT(axis);
+       dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
 }
 
+int input_get_keycode(struct input_dev *dev,
+                     unsigned int scancode, unsigned int *keycode);
+int input_set_keycode(struct input_dev *dev,
+                     unsigned int scancode, unsigned int keycode);
+
 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