Initial version of hid-multitouch-dkms packagev1.0.0

This is identical to jikos multitouch tree from 06APR2011.

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

7 files changed, 1538 insertions, 0 deletions

diff --git a/usr/src/dkms_main_tree/dkms_dbversion b/usr/src/dkms_main_tree/dkms_dbversion
new file mode 100644
index 0000000..227cea2
--- /dev/null
+++ b/usr/src/dkms_main_tree/dkms_dbversion
@@ -0,0 +1 @@
+2.0.0
diff --git a/usr/src/dkms_source_tree/Makefile b/usr/src/dkms_source_tree/Makefile
new file mode 100644
index 0000000..3a1990a
--- /dev/null
+++ b/usr/src/dkms_source_tree/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for input/mouse drivers
+#
+
+obj-m   := hid-multitouch.o
diff --git a/usr/src/dkms_source_tree/dkms.conf b/usr/src/dkms_source_tree/dkms.conf
new file mode 100644
index 0000000..50f64db
--- /dev/null
+++ b/usr/src/dkms_source_tree/dkms.conf
@@ -0,0 +1,10 @@
+NAME=hid-multitouch
+VERSION=1.0.0
+PACKAGE_NAME="$NAME"
+PACKAGE_VERSION="$VERSION"
+MAKE[0]="make -C ${kernel_source_dir}
+  SUBDIRS=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build modules"
+BUILT_MODULE_NAME[0]="hid-multitouch"
+DEST_MODULE_LOCATION[0]="/kernel/drivers/hid"
+POST_INSTALL="scripts/hid-multitouch-post-install"
+AUTOINSTALL="yes"
diff --git a/usr/src/dkms_source_tree/hid-ids.h b/usr/src/dkms_source_tree/hid-ids.h
new file mode 100644
index 0000000..b1dd7ad
--- /dev/null
+++ b/usr/src/dkms_source_tree/hid-ids.h
@@ -0,0 +1,601 @@
+/*
+ *  USB HID quirks support for Linux
+ *
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
+ *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2007 Paul Walmsley
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#ifndef HID_IDS_H_FILE
+#define HID_IDS_H_FILE
+
+#define USB_VENDOR_ID_3M                0x0596
+#define USB_DEVICE_ID_3M1968            0x0500
+#define USB_DEVICE_ID_3M2256            0x0502
+
+#define USB_VENDOR_ID_A4TECH            0x09da
+#define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
+#define USB_DEVICE_ID_A4TECH_X5_005D    0x000a
+#define USB_DEVICE_ID_A4TECH_RP_649     0x001a
+
+#define USB_VENDOR_ID_AASHIMA           0x06d6
+#define USB_DEVICE_ID_AASHIMA_GAMEPAD   0x0025
+#define USB_DEVICE_ID_AASHIMA_PREDATOR  0x0026
+
+#define USB_VENDOR_ID_ACECAD            0x0460
+#define USB_DEVICE_ID_ACECAD_FLAIR      0x0004
+#define USB_DEVICE_ID_ACECAD_302        0x0008
+
+#define USB_VENDOR_ID_ACRUX             0x1a34
+
+#define USB_VENDOR_ID_ADS_TECH          0x06e1
+#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X     0xa155
+
+#define USB_VENDOR_ID_AFATECH           0x15a4
+#define USB_DEVICE_ID_AFATECH_AF9016    0x9016
+
+#define USB_VENDOR_ID_AIPTEK            0x08ca
+#define USB_DEVICE_ID_AIPTEK_01         0x0001
+#define USB_DEVICE_ID_AIPTEK_10         0x0010
+#define USB_DEVICE_ID_AIPTEK_20         0x0020
+#define USB_DEVICE_ID_AIPTEK_21         0x0021
+#define USB_DEVICE_ID_AIPTEK_22         0x0022
+#define USB_DEVICE_ID_AIPTEK_23         0x0023
+#define USB_DEVICE_ID_AIPTEK_24         0x0024
+
+#define USB_VENDOR_ID_AIRCABLE          0x16CA
+#define USB_DEVICE_ID_AIRCABLE1         0x1502
+
+#define USB_VENDOR_ID_ALCOR             0x058f
+#define USB_DEVICE_ID_ALCOR_USBRS232    0x9720
+
+#define USB_VENDOR_ID_ALPS              0x0433
+#define USB_DEVICE_ID_IBM_GAMEPAD       0x1101
+
+#define USB_VENDOR_ID_APPLE             0x05ac
+#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
+#define USB_DEVICE_ID_APPLE_MAGICMOUSE  0x030d
+#define USB_DEVICE_ID_APPLE_MAGICTRACKPAD       0x030e
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI       0x020e
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO        0x020f
+#define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214
+#define USB_DEVICE_ID_APPLE_GEYSER_ISO  0x0215
+#define USB_DEVICE_ID_APPLE_GEYSER_JIS  0x0216
+#define USB_DEVICE_ID_APPLE_GEYSER3_ANSI        0x0217
+#define USB_DEVICE_ID_APPLE_GEYSER3_ISO 0x0218
+#define USB_DEVICE_ID_APPLE_GEYSER3_JIS 0x0219
+#define USB_DEVICE_ID_APPLE_GEYSER4_ANSI        0x021a
+#define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b
+#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
+#define USB_DEVICE_ID_APPLE_ALU_MINI_ANSI       0x021d
+#define USB_DEVICE_ID_APPLE_ALU_MINI_ISO        0x021e
+#define USB_DEVICE_ID_APPLE_ALU_MINI_JIS        0x021f
+#define USB_DEVICE_ID_APPLE_ALU_ANSI    0x0220
+#define USB_DEVICE_ID_APPLE_ALU_ISO     0x0221
+#define USB_DEVICE_ID_APPLE_ALU_JIS     0x0222
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI     0x0223
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ISO      0x0224
+#define USB_DEVICE_ID_APPLE_WELLSPRING_JIS      0x0225
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI     0x0229
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO      0x022a
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS      0x022b
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI   0x022c
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO    0x022d
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS    0x022e
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI    0x0230
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO     0x0231
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS     0x0232
+#define USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI    0x0236
+#define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO     0x0237
+#define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS     0x0238
+#define USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI    0x023f
+#define USB_DEVICE_ID_APPLE_WELLSPRING4_ISO     0x0240
+#define USB_DEVICE_ID_APPLE_WELLSPRING4_JIS     0x0241
+#define USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI   0x0242
+#define USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO    0x0243
+#define USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS    0x0244
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY    0x030a
+#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY     0x030b
+#define USB_DEVICE_ID_APPLE_ATV_IRCONTROL       0x8241
+#define USB_DEVICE_ID_APPLE_IRCONTROL4  0x8242
+
+#define USB_VENDOR_ID_ASUS              0x0486
+#define USB_DEVICE_ID_ASUS_T91MT        0x0185
+#define USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO    0x0186
+
+#define USB_VENDOR_ID_ASUSTEK           0x0b05
+#define USB_DEVICE_ID_ASUSTEK_LCM       0x1726
+#define USB_DEVICE_ID_ASUSTEK_LCM2      0x175b
+
+#define USB_VENDOR_ID_ATEN              0x0557
+#define USB_DEVICE_ID_ATEN_UC100KM      0x2004
+#define USB_DEVICE_ID_ATEN_CS124U       0x2202
+#define USB_DEVICE_ID_ATEN_2PORTKVM     0x2204
+#define USB_DEVICE_ID_ATEN_4PORTKVM     0x2205
+#define USB_DEVICE_ID_ATEN_4PORTKVMC    0x2208
+
+#define USB_VENDOR_ID_AVERMEDIA         0x07ca
+#define USB_DEVICE_ID_AVER_FM_MR800     0xb800
+
+#define USB_VENDOR_ID_BELKIN            0x050d
+#define USB_DEVICE_ID_FLIP_KVM          0x3201
+
+#define USB_VENDOR_ID_BERKSHIRE         0x0c98
+#define USB_DEVICE_ID_BERKSHIRE_PCWD    0x1140
+
+#define USB_VENDOR_ID_BTC               0x046e
+#define USB_DEVICE_ID_BTC_EMPREX_REMOTE 0x5578
+#define USB_DEVICE_ID_BTC_EMPREX_REMOTE_2       0x5577
+
+#define USB_VENDOR_ID_CANDO             0x2087
+#define USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH 0x0703
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH 0x0a01
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1 0x0a02
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6 0x0b03
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6 0x0f01
+
+#define USB_VENDOR_ID_CH                0x068e
+#define USB_DEVICE_ID_CH_PRO_PEDALS     0x00f2
+#define USB_DEVICE_ID_CH_COMBATSTICK    0x00f4
+#define USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE       0x0051
+#define USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE        0x00ff
+#define USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK    0x00d3
+#define USB_DEVICE_ID_CH_AXIS_295       0x001c
+
+#define USB_VENDOR_ID_CHERRY            0x046a
+#define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
+#define USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR     0x0027
+
+#define USB_VENDOR_ID_CHIC              0x05fe
+#define USB_DEVICE_ID_CHIC_GAMEPAD      0x0014
+
+#define USB_VENDOR_ID_CHICONY           0x04f2
+#define USB_DEVICE_ID_CHICONY_TACTICAL_PAD      0x0418
+#define USB_DEVICE_ID_CHICONY_MULTI_TOUCH       0xb19d
+#define USB_DEVICE_ID_CHICONY_WIRELESS  0x0618
+
+#define USB_VENDOR_ID_CIDC              0x1677
+
+#define USB_VENDOR_ID_CMEDIA            0x0d8c
+#define USB_DEVICE_ID_CM109             0x000e
+
+#define USB_VENDOR_ID_CODEMERCS         0x07c0
+#define USB_DEVICE_ID_CODEMERCS_IOW_FIRST       0x1500
+#define USB_DEVICE_ID_CODEMERCS_IOW_LAST        0x15ff
+
+#define USB_VENDOR_ID_CREATIVELABS      0x041e
+#define USB_DEVICE_ID_PRODIKEYS_PCMIDI  0x2801
+
+#define USB_VENDOR_ID_CYGNAL            0x10c4
+#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X       0x818a
+
+#define USB_VENDOR_ID_CYPRESS           0x04b4
+#define USB_DEVICE_ID_CYPRESS_MOUSE     0x0001
+#define USB_DEVICE_ID_CYPRESS_HIDCOM    0x5500
+#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE        0x7417
+#define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61
+#define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64
+#define USB_DEVICE_ID_CYPRESS_BARCODE_3 0xbca1
+#define USB_DEVICE_ID_CYPRESS_TRUETOUCH 0xc001
+
+#define USB_VENDOR_ID_DEALEXTREAME      0x10c5
+#define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701 0x819a
+
+#define USB_VENDOR_ID_DELORME           0x1163
+#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
+#define USB_DEVICE_ID_DELORME_EM_LT20   0x0200
+
+#define USB_VENDOR_ID_DMI               0x0c0b
+#define USB_DEVICE_ID_DMI_ENC           0x5fab
+
+#define USB_VENDOR_ID_DRAGONRISE        0x0079
+
+#define USB_VENDOR_ID_DWAV              0x0eef
+#define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER    0x0001
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH    0x480d
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1   0x720c
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2   0x72a1
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3   0x480e
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4   0x726b
+
+#define USB_VENDOR_ID_ELECOM            0x056e
+#define USB_DEVICE_ID_ELECOM_BM084      0x0061
+
+#define USB_VENDOR_ID_DREAM_CHEEKY      0x1d34
+
+#define USB_VENDOR_ID_ELO               0x04E7
+#define USB_DEVICE_ID_ELO_TS2700        0x0020
+
+#define USB_VENDOR_ID_EMS               0x2006
+#define USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II 0x0118
+
+#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
+#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
+
+#define USB_VENDOR_ID_ETT               0x0664
+#define USB_DEVICE_ID_TC5UH             0x0309
+#define USB_DEVICE_ID_TC4UM             0x0306
+
+#define USB_VENDOR_ID_ETURBOTOUCH       0x22b9
+#define USB_DEVICE_ID_ETURBOTOUCH       0x0006
+
+#define USB_VENDOR_ID_EZKEY             0x0518
+#define USB_DEVICE_ID_BTC_8193          0x0002
+
+#define USB_VENDOR_ID_GAMERON           0x0810
+#define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR  0x0001
+#define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR  0x0002
+
+#define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
+#define USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS 0x0001
+
+#define USB_VENDOR_ID_GLAB              0x06c2
+#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
+#define USB_DEVICE_ID_1_PHIDGETSERVO_30 0x0039
+#define USB_DEVICE_ID_0_0_4_IF_KIT      0x0040
+#define USB_DEVICE_ID_0_16_16_IF_KIT    0x0044
+#define USB_DEVICE_ID_8_8_8_IF_KIT      0x0045
+#define USB_DEVICE_ID_0_8_7_IF_KIT      0x0051
+#define USB_DEVICE_ID_0_8_8_IF_KIT      0x0053
+#define USB_DEVICE_ID_PHIDGET_MOTORCONTROL      0x0058
+
+#define USB_VENDOR_ID_GOTOP             0x08f2
+#define USB_DEVICE_ID_SUPER_Q2          0x007f
+#define USB_DEVICE_ID_GOGOPEN           0x00ce
+#define USB_DEVICE_ID_PENPOWER          0x00f4
+
+#define USB_VENDOR_ID_GREENASIA         0x0e8f
+
+#define USB_VENDOR_ID_GRETAGMACBETH     0x0971
+#define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
+
+#define USB_VENDOR_ID_GRIFFIN           0x077d
+#define USB_DEVICE_ID_POWERMATE         0x0410
+#define USB_DEVICE_ID_SOUNDKNOB         0x04AA
+
+#define USB_VENDOR_ID_GTCO              0x078c
+#define USB_DEVICE_ID_GTCO_90           0x0090
+#define USB_DEVICE_ID_GTCO_100          0x0100
+#define USB_DEVICE_ID_GTCO_101          0x0101
+#define USB_DEVICE_ID_GTCO_103          0x0103
+#define USB_DEVICE_ID_GTCO_104          0x0104
+#define USB_DEVICE_ID_GTCO_105          0x0105
+#define USB_DEVICE_ID_GTCO_106          0x0106
+#define USB_DEVICE_ID_GTCO_107          0x0107
+#define USB_DEVICE_ID_GTCO_108          0x0108
+#define USB_DEVICE_ID_GTCO_200          0x0200
+#define USB_DEVICE_ID_GTCO_201          0x0201
+#define USB_DEVICE_ID_GTCO_202          0x0202
+#define USB_DEVICE_ID_GTCO_203          0x0203
+#define USB_DEVICE_ID_GTCO_204          0x0204
+#define USB_DEVICE_ID_GTCO_205          0x0205
+#define USB_DEVICE_ID_GTCO_206          0x0206
+#define USB_DEVICE_ID_GTCO_207          0x0207
+#define USB_DEVICE_ID_GTCO_300          0x0300
+#define USB_DEVICE_ID_GTCO_301          0x0301
+#define USB_DEVICE_ID_GTCO_302          0x0302
+#define USB_DEVICE_ID_GTCO_303          0x0303
+#define USB_DEVICE_ID_GTCO_304          0x0304
+#define USB_DEVICE_ID_GTCO_305          0x0305
+#define USB_DEVICE_ID_GTCO_306          0x0306
+#define USB_DEVICE_ID_GTCO_307          0x0307
+#define USB_DEVICE_ID_GTCO_308          0x0308
+#define USB_DEVICE_ID_GTCO_309          0x0309
+#define USB_DEVICE_ID_GTCO_400          0x0400
+#define USB_DEVICE_ID_GTCO_401          0x0401
+#define USB_DEVICE_ID_GTCO_402          0x0402
+#define USB_DEVICE_ID_GTCO_403          0x0403
+#define USB_DEVICE_ID_GTCO_404          0x0404
+#define USB_DEVICE_ID_GTCO_405          0x0405
+#define USB_DEVICE_ID_GTCO_500          0x0500
+#define USB_DEVICE_ID_GTCO_501          0x0501
+#define USB_DEVICE_ID_GTCO_502          0x0502
+#define USB_DEVICE_ID_GTCO_503          0x0503
+#define USB_DEVICE_ID_GTCO_504          0x0504
+#define USB_DEVICE_ID_GTCO_1000         0x1000
+#define USB_DEVICE_ID_GTCO_1001         0x1001
+#define USB_DEVICE_ID_GTCO_1002         0x1002
+#define USB_DEVICE_ID_GTCO_1003         0x1003
+#define USB_DEVICE_ID_GTCO_1004         0x1004
+#define USB_DEVICE_ID_GTCO_1005         0x1005
+#define USB_DEVICE_ID_GTCO_1006         0x1006
+#define USB_DEVICE_ID_GTCO_1007         0x1007
+
+#define USB_VENDOR_ID_GYRATION          0x0c16
+#define USB_DEVICE_ID_GYRATION_REMOTE   0x0002
+#define USB_DEVICE_ID_GYRATION_REMOTE_2 0x0003
+#define USB_DEVICE_ID_GYRATION_REMOTE_3 0x0008
+
+#define USB_VENDOR_ID_HANWANG           0x0b57
+#define USB_DEVICE_ID_HANWANG_TABLET_FIRST      0x5000
+#define USB_DEVICE_ID_HANWANG_TABLET_LAST       0x8fff
+
+#define USB_VENDOR_ID_HANVON            0x20b3
+#define USB_DEVICE_ID_HANVON_MULTITOUCH 0x0a18
+
+#define USB_VENDOR_ID_HAPP              0x078b
+#define USB_DEVICE_ID_UGCI_DRIVING      0x0010
+#define USB_DEVICE_ID_UGCI_FLYING       0x0020
+#define USB_DEVICE_ID_UGCI_FIGHTING     0x0030
+
+#define USB_VENDOR_ID_IMATION           0x0718
+#define USB_DEVICE_ID_DISC_STAKKA       0xd000
+
+#define USB_VENDOR_ID_IRTOUCHSYSTEMS    0x6615
+#define USB_DEVICE_ID_IRTOUCH_INFRARED_USB      0x0070
+
+#define USB_VENDOR_ID_JESS              0x0c45
+#define USB_DEVICE_ID_JESS_YUREX        0x1010
+
+#define USB_VENDOR_ID_KBGEAR            0x084e
+#define USB_DEVICE_ID_KBGEAR_JAMSTUDIO  0x1001
+
+#define USB_VENDOR_ID_KENSINGTON        0x047d
+#define USB_DEVICE_ID_KS_SLIMBLADE      0x2041
+
+#define USB_VENDOR_ID_KWORLD            0x1b80
+#define USB_DEVICE_ID_KWORLD_RADIO_FM700        0xd700
+
+#define USB_VENDOR_ID_KYE               0x0458
+#define USB_DEVICE_ID_KYE_ERGO_525V     0x0087
+#define USB_DEVICE_ID_KYE_GPEN_560      0x5003
+
+#define USB_VENDOR_ID_LABTEC            0x1020
+#define USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD  0x0006
+
+#define USB_VENDOR_ID_LD                0x0f11
+#define USB_DEVICE_ID_LD_CASSY          0x1000
+#define USB_DEVICE_ID_LD_POCKETCASSY    0x1010
+#define USB_DEVICE_ID_LD_MOBILECASSY    0x1020
+#define USB_DEVICE_ID_LD_JWM            0x1080
+#define USB_DEVICE_ID_LD_DMMP           0x1081
+#define USB_DEVICE_ID_LD_UMIP           0x1090
+#define USB_DEVICE_ID_LD_XRAY1          0x1100
+#define USB_DEVICE_ID_LD_XRAY2          0x1101
+#define USB_DEVICE_ID_LD_VIDEOCOM       0x1200
+#define USB_DEVICE_ID_LD_COM3LAB        0x2000
+#define USB_DEVICE_ID_LD_TELEPORT       0x2010
+#define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
+#define USB_DEVICE_ID_LD_POWERCONTROL   0x2030
+#define USB_DEVICE_ID_LD_MACHINETEST    0x2040
+
+#define USB_VENDOR_ID_LOGITECH          0x046d
+#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
+#define USB_DEVICE_ID_LOGITECH_HARMONY_FIRST  0xc110
+#define USB_DEVICE_ID_LOGITECH_HARMONY_LAST 0xc14f
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD   0xc20a
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD        0xc211
+#define USB_DEVICE_ID_LOGITECH_EXTREME_3D       0xc215
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2       0xc218
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2     0xc219
+#define USB_DEVICE_ID_LOGITECH_WINGMAN_F3D      0xc283
+#define USB_DEVICE_ID_LOGITECH_FORCE3D_PRO      0xc286
+#define USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940       0xc287
+#define USB_DEVICE_ID_LOGITECH_WHEEL    0xc294
+#define USB_DEVICE_ID_LOGITECH_WINGMAN_FFG      0xc293
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL       0xc295
+#define USB_DEVICE_ID_LOGITECH_G25_WHEEL        0xc299
+#define USB_DEVICE_ID_LOGITECH_WII_WHEEL        0xc29c
+#define USB_DEVICE_ID_LOGITECH_ELITE_KBD        0xc30a
+#define USB_DEVICE_ID_S510_RECEIVER     0xc50c
+#define USB_DEVICE_ID_S510_RECEIVER_2   0xc517
+#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500   0xc512
+#define USB_DEVICE_ID_MX3000_RECEIVER   0xc513
+#define USB_DEVICE_ID_SPACETRAVELLER    0xc623
+#define USB_DEVICE_ID_SPACENAVIGATOR    0xc626
+#define USB_DEVICE_ID_DINOVO_DESKTOP    0xc704
+#define USB_DEVICE_ID_DINOVO_EDGE       0xc714
+#define USB_DEVICE_ID_DINOVO_MINI       0xc71f
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2      0xca03
+
+#define USB_VENDOR_ID_MCC               0x09db
+#define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
+#define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
+
+#define USB_VENDOR_ID_MGE               0x0463
+#define USB_DEVICE_ID_MGE_UPS           0xffff
+#define USB_DEVICE_ID_MGE_UPS1          0x0001
+
+#define USB_VENDOR_ID_MICROCHIP         0x04d8
+#define USB_DEVICE_ID_PICKIT1           0x0032
+#define USB_DEVICE_ID_PICKIT2           0x0033
+#define USB_DEVICE_ID_PICOLCD           0xc002
+#define USB_DEVICE_ID_PICOLCD_BOOTLOADER        0xf002
+
+#define USB_VENDOR_ID_MICROSOFT         0x045e
+#define USB_DEVICE_ID_SIDEWINDER_GV     0x003b
+#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
+#define USB_DEVICE_ID_MS_NE4K           0x00db
+#define USB_DEVICE_ID_MS_LK6K           0x00f9
+#define USB_DEVICE_ID_MS_PRESENTER_8K_BT        0x0701
+#define USB_DEVICE_ID_MS_PRESENTER_8K_USB       0x0713
+
+#define USB_VENDOR_ID_MOJO              0x8282
+#define USB_DEVICE_ID_RETRO_ADAPTER     0x3201
+
+#define USB_VENDOR_ID_MONTEREY          0x0566
+#define USB_DEVICE_ID_GENIUS_KB29E      0x3004
+
+#define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400
+#define USB_DEVICE_ID_N_S_HARMONY       0xc359
+
+#define USB_VENDOR_ID_NATSU             0x08b7
+#define USB_DEVICE_ID_NATSU_GAMEPAD     0x0001
+
+#define USB_VENDOR_ID_NCR               0x0404
+#define USB_DEVICE_ID_NCR_FIRST         0x0300
+#define USB_DEVICE_ID_NCR_LAST          0x03ff
+
+#define USB_VENDOR_ID_NEC               0x073e
+#define USB_DEVICE_ID_NEC_USB_GAME_PAD  0x0301
+
+#define USB_VENDOR_ID_NEXTWINDOW        0x1926
+#define USB_DEVICE_ID_NEXTWINDOW_TOUCHSCREEN    0x0003
+
+#define USB_VENDOR_ID_NTRIG             0x1b96
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN   0x0001
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1   0x0003
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2   0x0004
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3   0x0005
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4   0x0006
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5   0x0007
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6   0x0008
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7   0x0009
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8   0x000A
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9   0x000B
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10   0x000C
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11   0x000D
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12   0x000E
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13   0x000F
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14   0x0010
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15   0x0011
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16   0x0012
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17   0x0013
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18   0x0014
+
+#define USB_VENDOR_ID_ONTRAK            0x0a07
+#define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
+
+#define USB_VENDOR_ID_ORTEK             0x05a4
+#define USB_DEVICE_ID_ORTEK_WKB2000     0x2000
+
+#define USB_VENDOR_ID_PANJIT            0x134c
+
+#define USB_VENDOR_ID_PANTHERLORD       0x0810
+#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK     0x0001
+
+#define USB_VENDOR_ID_PETALYNX          0x18b1
+#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE    0x0037
+
+#define USB_VENDOR_ID_PHILIPS           0x0471
+#define USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE 0x0617
+
+#define USB_VENDOR_ID_PI_ENGINEERING    0x05f3
+#define USB_DEVICE_ID_PI_ENGINEERING_VEC_USB_FOOTPEDAL  0xff
+
+#define USB_VENDOR_ID_PLAYDOTCOM        0x0b43
+#define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII      0x0003
+
+#define USB_VENDOR_ID_POWERCOM          0x0d9f
+#define USB_DEVICE_ID_POWERCOM_UPS      0x0002
+
+#define USB_VENDOR_ID_PRODIGE           0x05af
+#define USB_DEVICE_ID_PRODIGE_CORDLESS  0x3062
+
+#define USB_VENDOR_ID_QUANTA            0x0408
+#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH      0x3000
+#define USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN   0x3001
+
+#define USB_VENDOR_ID_ROCCAT            0x1e7d
+#define USB_DEVICE_ID_ROCCAT_KONE       0x2ced
+#define USB_DEVICE_ID_ROCCAT_KONEPLUS   0x2d51
+#define USB_DEVICE_ID_ROCCAT_PYRA_WIRED 0x2c24
+#define USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS      0x2cf6
+
+#define USB_VENDOR_ID_SAITEK            0x06a3
+#define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
+
+#define USB_VENDOR_ID_SAMSUNG           0x0419
+#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
+#define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE        0x0600
+
+#define USB_VENDOR_ID_SONY                      0x054c
+#define USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE       0x024b
+#define USB_DEVICE_ID_SONY_PS3_CONTROLLER       0x0268
+
+#define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
+#define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST     0x0034
+#define USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST      0x0046
+
+#define USB_VENDOR_ID_STANTUM           0x1f87
+#define USB_DEVICE_ID_MTP               0x0002
+
+#define USB_VENDOR_ID_STANTUM_STM               0x0483
+#define USB_DEVICE_ID_MTP_STM           0x3261
+
+#define USB_VENDOR_ID_STANTUM_SITRONIX          0x1403
+#define USB_DEVICE_ID_MTP_SITRONIX              0x5001
+
+#define USB_VENDOR_ID_SUN               0x0430
+#define USB_DEVICE_ID_RARITAN_KVM_DONGLE        0xcdab
+
+#define USB_VENDOR_ID_SUNPLUS           0x04fc
+#define USB_DEVICE_ID_SUNPLUS_WDESKTOP  0x05d8
+
+#define USB_VENDOR_ID_THRUSTMASTER      0x044f
+
+#define USB_VENDOR_ID_TOPSEED           0x0766
+#define USB_DEVICE_ID_TOPSEED_CYBERLINK 0x0204
+
+#define USB_VENDOR_ID_TOPSEED2          0x1784
+#define USB_DEVICE_ID_TOPSEED2_RF_COMBO 0x0004
+
+#define USB_VENDOR_ID_TOPMAX            0x0663
+#define USB_DEVICE_ID_TOPMAX_COBRAPAD   0x0103
+
+#define USB_VENDOR_ID_TOUCHPACK         0x1bfd
+#define USB_DEVICE_ID_TOUCHPACK_RTS     0x1688
+
+#define USB_VENDOR_ID_TURBOX            0x062a
+#define USB_DEVICE_ID_TURBOX_KEYBOARD   0x0201
+#define USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART 0x7100
+
+#define USB_VENDOR_ID_TWINHAN           0x6253
+#define USB_DEVICE_ID_TWINHAN_IR_REMOTE 0x0100
+
+#define USB_VENDOR_ID_UCLOGIC           0x5543
+#define USB_DEVICE_ID_UCLOGIC_TABLET_PF1209     0x0042
+#define USB_DEVICE_ID_UCLOGIC_TABLET_KNA5       0x6001
+#define USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U    0x0003
+#define USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U    0x0004
+#define USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U    0x0005
+
+#define USB_VENDOR_ID_VERNIER           0x08f7
+#define USB_DEVICE_ID_VERNIER_LABPRO    0x0001
+#define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
+#define USB_DEVICE_ID_VERNIER_SKIP      0x0003
+#define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
+#define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
+
+#define USB_VENDOR_ID_WACOM             0x056a
+#define USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH  0x81
+
+#define USB_VENDOR_ID_WALTOP                            0x172f
+#define USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH       0x0032
+#define USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH      0x0034
+#define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH     0x0501
+#define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH     0x0500
+
+#define USB_VENDOR_ID_WISEGROUP         0x0925
+#define USB_DEVICE_ID_SMARTJOY_PLUS     0x0005
+#define USB_DEVICE_ID_1_PHIDGETSERVO_20 0x8101
+#define USB_DEVICE_ID_4_PHIDGETSERVO_20 0x8104
+#define USB_DEVICE_ID_8_8_4_IF_KIT      0x8201
+#define USB_DEVICE_ID_QUAD_USB_JOYPAD   0x8800
+#define USB_DEVICE_ID_DUAL_USB_JOYPAD   0x8866
+
+#define USB_VENDOR_ID_WISEGROUP_LTD     0x6666
+#define USB_VENDOR_ID_WISEGROUP_LTD2    0x6677
+#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
+
+#define USB_VENDOR_ID_YEALINK           0x6993
+#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K       0xb001
+
+#define USB_VENDOR_ID_ZEROPLUS          0x0c12
+
+#define USB_VENDOR_ID_ZYDACRON  0x13EC
+#define USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL   0x0006
+
+#endif
diff --git a/usr/src/dkms_source_tree/hid-multitouch.c b/usr/src/dkms_source_tree/hid-multitouch.c
new file mode 100644
index 0000000..02a6675
--- /dev/null
+++ b/usr/src/dkms_source_tree/hid-multitouch.c
@@ -0,0 +1,660 @@
+/*
+ *  HID driver for multitouch panels
+ *
+ *  Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
+ *  Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
+ *  Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
+ *
+ *  This code is partly based on hid-egalax.c:
+ *
+ *  Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
+ *  Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
+ *  Copyright (c) 2010 Canonical, Ltd.
+ *
+ *  This code is partly based on hid-3m-pct.c:
+ *
+ *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
+ *  Copyright (c) 2010      Henrik Rydberg <rydberg@euromail.se>
+ *  Copyright (c) 2010      Canonical, Ltd.
+ *
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include "input-mt.h"
+#include "usbhid.h"
+
+MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
+MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
+MODULE_DESCRIPTION("HID multitouch panels");
+MODULE_LICENSE("GPL");
+
+#include "hid-ids.h"
+
+/* quirks to control the device */
+#define MT_QUIRK_NOT_SEEN_MEANS_UP      (1 << 0)
+#define MT_QUIRK_SLOT_IS_CONTACTID      (1 << 1)
+#define MT_QUIRK_CYPRESS                (1 << 2)
+#define MT_QUIRK_SLOT_IS_CONTACTNUMBER  (1 << 3)
+#define MT_QUIRK_VALID_IS_INRANGE       (1 << 4)
+#define MT_QUIRK_VALID_IS_CONFIDENCE    (1 << 5)
+#define MT_QUIRK_EGALAX_XYZ_FIXUP       (1 << 6)
+
+struct mt_slot {
+        __s32 x, y, p, w, h;
+        __s32 contactid;        /* the device ContactID assigned to this slot */
+        bool touch_state;       /* is the touch valid? */
+        bool seen_in_this_frame;/* has this slot been updated */
+};
+
+struct mt_device {
+        struct mt_slot curdata; /* placeholder of incoming data */
+        struct mt_class *mtclass;       /* our mt device class */
+        unsigned last_field_index;      /* last field index of the report */
+        unsigned last_slot_field;       /* the last field of a slot */
+        __s8 inputmode;         /* InputMode HID feature, -1 if non-existent */
+        __u8 num_received;      /* how many contacts we received */
+        __u8 num_expected;      /* expected last contact index */
+        __u8 maxcontacts;
+        bool curvalid;          /* is the current contact valid? */
+        struct mt_slot *slots;
+};
+
+struct mt_class {
+        __s32 name;     /* MT_CLS */
+        __s32 quirks;
+        __s32 sn_move;  /* Signal/noise ratio for move events */
+        __s32 sn_width; /* Signal/noise ratio for width events */
+        __s32 sn_height;        /* Signal/noise ratio for height events */
+        __s32 sn_pressure;      /* Signal/noise ratio for pressure events */
+        __u8 maxcontacts;
+};
+
+/* classes of device behavior */
+#define MT_CLS_DEFAULT                          1
+#define MT_CLS_DUAL_INRANGE_CONTACTID           2
+#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER       3
+#define MT_CLS_CYPRESS                          4
+#define MT_CLS_EGALAX                           5
+#define MT_CLS_STANTUM                          6
+#define MT_CLS_3M                               7
+
+#define MT_DEFAULT_MAXCONTACT   10
+
+/*
+ * these device-dependent functions determine what slot corresponds
+ * to a valid contact that was just read.
+ */
+
+static int cypress_compute_slot(struct mt_device *td)
+{
+        if (td->curdata.contactid != 0 || td->num_received == 0)
+                return td->curdata.contactid;
+        else
+                return -1;
+}
+
+static int find_slot_from_contactid(struct mt_device *td)
+{
+        int i;
+        for (i = 0; i < td->maxcontacts; ++i) {
+                if (td->slots[i].contactid == td->curdata.contactid &&
+                        td->slots[i].touch_state)
+                        return i;
+        }
+        for (i = 0; i < td->maxcontacts; ++i) {
+                if (!td->slots[i].seen_in_this_frame &&
+                        !td->slots[i].touch_state)
+                        return i;
+        }
+        /* should not occurs. If this happens that means
+         * that the device sent more touches that it says
+         * in the report descriptor. It is ignored then. */
+        return -1;
+}
+
+struct mt_class mt_classes[] = {
+        { .name = MT_CLS_DEFAULT,
+                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
+        { .name = MT_CLS_DUAL_INRANGE_CONTACTID,
+                .quirks = MT_QUIRK_VALID_IS_INRANGE |
+                        MT_QUIRK_SLOT_IS_CONTACTID,
+                .maxcontacts = 2 },
+        { .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
+                .quirks = MT_QUIRK_VALID_IS_INRANGE |
+                        MT_QUIRK_SLOT_IS_CONTACTNUMBER,
+                .maxcontacts = 2 },
+        { .name = MT_CLS_CYPRESS,
+                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
+                        MT_QUIRK_CYPRESS,
+                .maxcontacts = 10 },
+
+        { .name = MT_CLS_EGALAX,
+                .quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
+                        MT_QUIRK_VALID_IS_INRANGE |
+                        MT_QUIRK_EGALAX_XYZ_FIXUP,
+                .maxcontacts = 2,
+                .sn_move = 4096,
+                .sn_pressure = 32,
+        },
+        { .name = MT_CLS_STANTUM,
+                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
+        { .name = MT_CLS_3M,
+                .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
+                        MT_QUIRK_SLOT_IS_CONTACTID,
+                .sn_move = 2048,
+                .sn_width = 128,
+                .sn_height = 128 },
+
+        { }
+};
+
+static void mt_feature_mapping(struct hid_device *hdev,
+                struct hid_field *field, struct hid_usage *usage)
+{
+        struct mt_device *td = hid_get_drvdata(hdev);
+
+        switch (usage->hid) {
+        case HID_DG_INPUTMODE:
+                td->inputmode = field->report->id;
+                break;
+        case HID_DG_CONTACTMAX:
+                td->maxcontacts = field->value[0];
+                if (td->mtclass->maxcontacts)
+                        /* check if the maxcontacts is given by the class */
+                        td->maxcontacts = td->mtclass->maxcontacts;
+
+                break;
+        }
+}
+
+static void set_abs(struct input_dev *input, unsigned int code,
+                struct hid_field *field, int snratio)
+{
+        int fmin = field->logical_minimum;
+        int fmax = field->logical_maximum;
+        int fuzz = snratio ? (fmax - fmin) / snratio : 0;
+        input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
+}
+
+static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct mt_device *td = hid_get_drvdata(hdev);
+        struct mt_class *cls = td->mtclass;
+        __s32 quirks = cls->quirks;
+
+        switch (usage->hid & HID_USAGE_PAGE) {
+
+        case HID_UP_GENDESK:
+                switch (usage->hid) {
+                case HID_GD_X:
+                        if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
+                                field->logical_maximum = 32760;
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_X);
+                        set_abs(hi->input, ABS_MT_POSITION_X, field,
+                                cls->sn_move);
+                        /* touchscreen emulation */
+                        set_abs(hi->input, ABS_X, field, cls->sn_move);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_GD_Y:
+                        if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
+                                field->logical_maximum = 32760;
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_Y);
+                        set_abs(hi->input, ABS_MT_POSITION_Y, field,
+                                cls->sn_move);
+                        /* touchscreen emulation */
+                        set_abs(hi->input, ABS_Y, field, cls->sn_move);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                }
+                return 0;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_CONFIDENCE:
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_TIPSWITCH:
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
+                        input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_CONTACTID:
+                        input_mt_init_slots(hi->input, td->maxcontacts);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_WIDTH:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TOUCH_MAJOR);
+                        set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
+                                cls->sn_width);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_HEIGHT:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TOUCH_MINOR);
+                        set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
+                                cls->sn_height);
+                        input_set_abs_params(hi->input,
+                                        ABS_MT_ORIENTATION, 0, 1, 0, 0);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_TIPPRESSURE:
+                        if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
+                                field->logical_minimum = 0;
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_PRESSURE);
+                        set_abs(hi->input, ABS_MT_PRESSURE, field,
+                                cls->sn_pressure);
+                        /* touchscreen emulation */
+                        set_abs(hi->input, ABS_PRESSURE, field,
+                                cls->sn_pressure);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_CONTACTCOUNT:
+                        td->last_field_index = field->report->maxfield - 1;
+                        return 1;
+                case HID_DG_CONTACTMAX:
+                        /* we don't set td->last_slot_field as contactcount and
+                         * contact max are global to the report */
+                        return -1;
+                }
+                /* let hid-input decide for the others */
+                return 0;
+
+        case 0xff000000:
+                /* we do not want to map these: no input-oriented meaning */
+                return -1;
+        }
+
+        return 0;
+}
+
+static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->type == EV_KEY || usage->type == EV_ABS)
+                set_bit(usage->type, hi->input->evbit);
+
+        return -1;
+}
+
+static int mt_compute_slot(struct mt_device *td)
+{
+        __s32 quirks = td->mtclass->quirks;
+
+        if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
+                return td->curdata.contactid;
+
+        if (quirks & MT_QUIRK_CYPRESS)
+                return cypress_compute_slot(td);
+
+        if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
+                return td->num_received;
+
+        return find_slot_from_contactid(td);
+}
+
+/*
+ * this function is called when a whole contact has been processed,
+ * so that it can assign it to a slot and store the data there
+ */
+static void mt_complete_slot(struct mt_device *td)
+{
+        td->curdata.seen_in_this_frame = true;
+        if (td->curvalid) {
+                int slotnum = mt_compute_slot(td);
+
+                if (slotnum >= 0 && slotnum < td->maxcontacts)
+                        td->slots[slotnum] = td->curdata;
+        }
+        td->num_received++;
+}
+
+
+/*
+ * this function is called when a whole packet has been received and processed,
+ * so that it can decide what to send to the input layer.
+ */
+static void mt_emit_event(struct mt_device *td, struct input_dev *input)
+{
+        int i;
+
+        for (i = 0; i < td->maxcontacts; ++i) {
+                struct mt_slot *s = &(td->slots[i]);
+                if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
+                        !s->seen_in_this_frame) {
+                        s->touch_state = false;
+                }
+
+                input_mt_slot(input, i);
+                input_mt_report_slot_state(input, MT_TOOL_FINGER,
+                        s->touch_state);
+                if (s->touch_state) {
+                        /* this finger is on the screen */
+                        int wide = (s->w > s->h);
+                        /* divided by two to match visual scale of touch */
+                        int major = max(s->w, s->h) >> 1;
+                        int minor = min(s->w, s->h) >> 1;
+
+                        input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
+                        input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
+                        input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
+                        input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
+                        input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
+                        input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
+                }
+                s->seen_in_this_frame = false;
+
+        }
+
+        input_mt_report_pointer_emulation(input, true);
+        input_sync(input);
+        td->num_received = 0;
+}
+
+
+
+static int mt_event(struct hid_device *hid, struct hid_field *field,
+                                struct hid_usage *usage, __s32 value)
+{
+        struct mt_device *td = hid_get_drvdata(hid);
+        __s32 quirks = td->mtclass->quirks;
+
+        if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                        if (quirks & MT_QUIRK_VALID_IS_INRANGE)
+                                td->curvalid = value;
+                        break;
+                case HID_DG_TIPSWITCH:
+                        if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
+                                td->curvalid = value;
+                        td->curdata.touch_state = value;
+                        break;
+                case HID_DG_CONFIDENCE:
+                        if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
+                                td->curvalid = value;
+                        break;
+                case HID_DG_CONTACTID:
+                        td->curdata.contactid = value;
+                        break;
+                case HID_DG_TIPPRESSURE:
+                        td->curdata.p = value;
+                        break;
+                case HID_GD_X:
+                        td->curdata.x = value;
+                        break;
+                case HID_GD_Y:
+                        td->curdata.y = value;
+                        break;
+                case HID_DG_WIDTH:
+                        td->curdata.w = value;
+                        break;
+                case HID_DG_HEIGHT:
+                        td->curdata.h = value;
+                        break;
+                case HID_DG_CONTACTCOUNT:
+                        /*
+                         * Includes multi-packet support where subsequent
+                         * packets are sent with zero contactcount.
+                         */
+                        if (value)
+                                td->num_expected = value;
+                        break;
+
+                default:
+                        if (td->last_field_index
+                                && field->index == td->last_field_index)
+                                /* we reach here when the last field in the
+                                 * report is not related to multitouch.
+                                 * This is not good. As a temporary solution,
+                                 * we trigger our mt event completion and
+                                 * ignore the field.
+                                 */
+                                break;
+                        /* fallback to the generic hidinput handling */
+                        return 0;
+                }
+
+                if (usage->hid == td->last_slot_field) {
+                        mt_complete_slot(td);
+                        if (!td->last_field_index)
+                                mt_emit_event(td, field->hidinput->input);
+                }
+
+                if (field->index == td->last_field_index
+                        && td->num_received >= td->num_expected)
+                        mt_emit_event(td, field->hidinput->input);
+
+        }
+
+        /* we have handled the hidinput part, now remains hiddev */
+        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
+                hid->hiddev_hid_event(hid, field, usage, value);
+
+        return 1;
+}
+
+static void mt_set_input_mode(struct hid_device *hdev)
+{
+        struct mt_device *td = hid_get_drvdata(hdev);
+        struct hid_report *r;
+        struct hid_report_enum *re;
+
+        if (td->inputmode < 0)
+                return;
+
+        re = &(hdev->report_enum[HID_FEATURE_REPORT]);
+        r = re->report_id_hash[td->inputmode];
+        if (r) {
+                r->field[0]->value[0] = 0x02;
+                usbhid_submit_report(hdev, r, USB_DIR_OUT);
+        }
+}
+
+static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret, i;
+        struct mt_device *td;
+        struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
+
+        for (i = 0; mt_classes[i].name ; i++) {
+                if (id->driver_data == mt_classes[i].name) {
+                        mtclass = &(mt_classes[i]);
+                        break;
+                }
+        }
+
+        /* This allows the driver to correctly support devices
+         * that emit events over several HID messages.
+         */
+        hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
+
+        td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
+        if (!td) {
+                dev_err(&hdev->dev, "cannot allocate multitouch data\n");
+                return -ENOMEM;
+        }
+        td->mtclass = mtclass;
+        td->inputmode = -1;
+        hid_set_drvdata(hdev, td);
+
+        ret = hid_parse(hdev);
+        if (ret != 0)
+                goto fail;
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret)
+                goto fail;
+
+        if (!td->maxcontacts)
+                td->maxcontacts = MT_DEFAULT_MAXCONTACT;
+
+        td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
+                                GFP_KERNEL);
+        if (!td->slots) {
+                dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
+                hid_hw_stop(hdev);
+                ret = -ENOMEM;
+                goto fail;
+        }
+
+        mt_set_input_mode(hdev);
+
+        return 0;
+
+fail:
+        kfree(td);
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int mt_reset_resume(struct hid_device *hdev)
+{
+        mt_set_input_mode(hdev);
+        return 0;
+}
+#endif
+
+static void mt_remove(struct hid_device *hdev)
+{
+        struct mt_device *td = hid_get_drvdata(hdev);
+        hid_hw_stop(hdev);
+        kfree(td->slots);
+        kfree(td);
+        hid_set_drvdata(hdev, NULL);
+}
+
+static const struct hid_device_id mt_devices[] = {
+
+        /* 3M panels */
+        { .driver_data = MT_CLS_3M,
+                HID_USB_DEVICE(USB_VENDOR_ID_3M,
+                        USB_DEVICE_ID_3M1968) },
+        { .driver_data = MT_CLS_3M,
+                HID_USB_DEVICE(USB_VENDOR_ID_3M,
+                        USB_DEVICE_ID_3M2256) },
+
+        /* Cando panels */
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
+                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
+                        USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
+                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
+                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
+                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
+                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
+                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
+                        USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
+
+        /* Cypress panel */
+        { .driver_data = MT_CLS_CYPRESS,
+                HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
+                        USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
+
+        /* GeneralTouch panel */
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
+                HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
+                        USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
+
+        /* IRTOUCH panels */
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
+                HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
+                        USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
+
+        /* PixCir-based panels */
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
+                HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
+                        USB_DEVICE_ID_HANVON_MULTITOUCH) },
+        { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
+                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
+                        USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
+
+        /* Resistive eGalax devices */
+        {  .driver_data = MT_CLS_EGALAX,
+                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
+        {  .driver_data = MT_CLS_EGALAX,
+                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },
+
+        /* Capacitive eGalax devices */
+        {  .driver_data = MT_CLS_EGALAX,
+                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
+        {  .driver_data = MT_CLS_EGALAX,
+                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
+        {  .driver_data = MT_CLS_EGALAX,
+                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },
+
+        /* Stantum panels */
+        { .driver_data = MT_CLS_STANTUM,
+                HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
+                        USB_DEVICE_ID_MTP)},
+        { .driver_data = MT_CLS_STANTUM,
+                HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
+                        USB_DEVICE_ID_MTP_STM)},
+        { .driver_data = MT_CLS_STANTUM,
+                HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
+                        USB_DEVICE_ID_MTP_SITRONIX)},
+
+        { }
+};
+MODULE_DEVICE_TABLE(hid, mt_devices);
+
+static const struct hid_usage_id mt_grabbed_usages[] = {
+        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
+        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
+};
+
+static struct hid_driver mt_driver = {
+        .name = "hid-multitouch",
+        .id_table = mt_devices,
+        .probe = mt_probe,
+        .remove = mt_remove,
+        .input_mapping = mt_input_mapping,
+        .input_mapped = mt_input_mapped,
+        .feature_mapping = mt_feature_mapping,
+        .usage_table = mt_grabbed_usages,
+        .event = mt_event,
+#ifdef CONFIG_PM
+        .reset_resume = mt_reset_resume,
+#endif
+};
+
+static int __init mt_init(void)
+{
+        return hid_register_driver(&mt_driver);
+}
+
+static void __exit mt_exit(void)
+{
+        hid_unregister_driver(&mt_driver);
+}
+
+module_init(mt_init);
+module_exit(mt_exit);
diff --git a/usr/src/dkms_source_tree/input-mt.h b/usr/src/dkms_source_tree/input-mt.h
new file mode 100644
index 0000000..e53d274
--- /dev/null
+++ b/usr/src/dkms_source_tree/input-mt.h
@@ -0,0 +1,155 @@
+#ifndef _INPUT_MT_LOCAL_H
+#define _INPUT_MT_LOCAL_H
+
+/*
+ * Input Multitouch Library
+ *
+ * Copyright (c) 2010 Henrik Rydberg
+ *
+ * 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.
+ */
+
+#include <linux/version.h>
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38)
+
+#include <linux/input/mt.h>
+
+#else
+
+#include <linux/input.h>
+
+#define MT_TOOL_MAX             1
+
+#define TRKID_MAX       0xffff
+#define TRKID_SGN       ((TRKID_MAX + 1) >> 1)
+
+static int trkid;
+
+static inline void input_abs_set_res(struct input_dev *dev,
+                                     unsigned int axis, int val)
+{
+        dev->absres[axis] = val;
+}
+
+static inline void input_mt_set_value(struct input_mt_slot *slot,
+                                      unsigned code, int value)
+{
+        slot->abs[code - ABS_MT_FIRST] = value;
+}
+
+static inline int input_mt_get_value(const struct input_mt_slot *slot,
+                                     unsigned code)
+{
+        return slot->abs[code - ABS_MT_FIRST];
+}
+
+static inline int input_mt_new_trkid(struct input_dev *dev)
+{
+        return trkid++ & TRKID_MAX;
+}
+
+/**
+ * input_mt_init_slots() - initialize MT input slots
+ * @dev: input device supporting MT events and finger tracking
+ * @num_slots: number of slots used by the device
+ *
+ * This function allocates all necessary memory for MT slot handling
+ * in the input device, prepares the ABS_MT_SLOT and
+ * ABS_MT_TRACKING_ID events for use and sets up appropriate buffers.
+ * May be called repeatedly. Returns -EINVAL if attempting to
+ * reinitialize with a different number of slots.
+ */
+static int input_mt_init_slots(struct input_dev *dev, unsigned int num_slots)
+{
+        int ret;
+
+        if (dev->mt)
+                return dev->mtsize != num_slots ? -EINVAL : 0;
+
+        ret = input_mt_create_slots(dev, num_slots);
+        if (ret)
+                return ret;
+
+        input_set_abs_params(dev, ABS_MT_TRACKING_ID, 0, TRKID_MAX, 0, 0);
+        input_set_events_per_packet(dev, 6 * num_slots);
+
+        return 0;
+}
+
+/**
+ * input_mt_report_state() - report contact state
+ * @dev: input device with allocated MT slots
+ * @active: true if contact is active, false otherwise
+ *
+ * Reports an active touch via ABS_MT_TRACKING_ID. If active is
+ * true and the slot is currently inactive, a new tracking id is
+ * assigned to the slot.
+ */
+static void input_mt_report_slot_state(struct input_dev *dev, unsigned type,
+                                       bool active)
+{
+        struct input_mt_slot *mt = dev->mt;
+        int id;
+
+        if (!mt || !active) {
+                input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
+                return;
+        }
+
+        id = input_mt_get_value(&mt[dev->slot], ABS_MT_TRACKING_ID);
+        if (id < 0)
+                id = input_mt_new_trkid(dev);
+        input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, id);
+}
+
+/**
+ * input_mt_report_pointer_emulation() - common pointer emulation
+ * @dev: input device with allocated MT slots
+ *
+ * Performs legacy pointer emulation via BTN_TOUCH.
+ */
+static void input_mt_report_pointer_emulation(struct input_dev *dev, bool more)
+{
+        struct input_mt_slot *oldest = 0;
+        int oldid = trkid;
+        int count = 0;
+        int i;
+
+        for (i = 0; i < dev->mtsize; ++i) {
+                struct input_mt_slot *ps = &dev->mt[i];
+                int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
+
+                if (id < 0)
+                        continue;
+                if ((id - oldid) & TRKID_SGN) {
+                        oldest = ps;
+                        oldid = id;
+                }
+                count++;
+        }
+
+        input_event(dev, EV_KEY, BTN_TOUCH, count > 0);
+        input_event(dev, EV_KEY, BTN_TOOL_FINGER, count == 1);
+        input_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, count == 2);
+        input_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, count == 3);
+        input_event(dev, EV_KEY, BTN_TOOL_QUADTAP, count > 3);
+
+        if (oldest) {
+                int x = input_mt_get_value(oldest, ABS_MT_POSITION_X);
+                int y = input_mt_get_value(oldest, ABS_MT_POSITION_Y);
+                int p = input_mt_get_value(oldest, ABS_MT_PRESSURE);
+
+                input_event(dev, EV_ABS, ABS_X, x);
+                input_event(dev, EV_ABS, ABS_Y, y);
+                input_event(dev, EV_ABS, ABS_PRESSURE, p);
+        } else {
+                input_event(dev, EV_ABS, ABS_PRESSURE, 0);
+        }
+}
+
+#endif
+
+#endif
diff --git a/usr/src/dkms_source_tree/usbhid.h b/usr/src/dkms_source_tree/usbhid.h
new file mode 100644
index 0000000..1673cac
--- /dev/null
+++ b/usr/src/dkms_source_tree/usbhid.h
@@ -0,0 +1,106 @@
+#ifndef __USBHID_H
+#define __USBHID_H
+
+/*
+ *  Copyright (c) 1999 Andreas Gal
+ *  Copyright (c) 2000-2001 Vojtech Pavlik
+ *  Copyright (c) 2006 Jiri Kosina
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/timer.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
+#include <linux/input.h>
+
+/*  API provided by hid-core.c for USB HID drivers */
+int usbhid_wait_io(struct hid_device* hid);
+void usbhid_close(struct hid_device *hid);
+int usbhid_open(struct hid_device *hid);
+void usbhid_init_reports(struct hid_device *hid);
+void usbhid_submit_report
+(struct hid_device *hid, struct hid_report *report, unsigned char dir);
+int usbhid_get_power(struct hid_device *hid);
+void usbhid_put_power(struct hid_device *hid);
+struct usb_interface *usbhid_find_interface(int minor);
+
+/* iofl flags */
+#define HID_CTRL_RUNNING        1
+#define HID_OUT_RUNNING         2
+#define HID_IN_RUNNING          3
+#define HID_RESET_PENDING       4
+#define HID_SUSPENDED           5
+#define HID_CLEAR_HALT          6
+#define HID_DISCONNECTED        7
+#define HID_STARTED             8
+#define HID_REPORTED_IDLE       9
+#define HID_KEYS_PRESSED        10
+#define HID_LED_ON              11
+
+/*
+ * USB-specific HID struct, to be pointed to
+ * from struct hid_device->driver_data
+ */
+
+struct usbhid_device {
+        struct hid_device *hid;                                         /* pointer to corresponding HID dev */
+
+        struct usb_interface *intf;                                     /* USB interface */
+        int ifnum;                                                      /* USB interface number */
+
+        unsigned int bufsize;                                           /* URB buffer size */
+
+        struct urb *urbin;                                              /* Input URB */
+        char *inbuf;                                                    /* Input buffer */
+        dma_addr_t inbuf_dma;                                           /* Input buffer dma */
+
+        struct urb *urbctrl;                                            /* Control URB */
+        struct usb_ctrlrequest *cr;                                     /* Control request struct */
+        struct hid_control_fifo ctrl[HID_CONTROL_FIFO_SIZE];            /* Control fifo */
+        unsigned char ctrlhead, ctrltail;                               /* Control fifo head & tail */
+        char *ctrlbuf;                                                  /* Control buffer */
+        dma_addr_t ctrlbuf_dma;                                         /* Control buffer dma */
+        unsigned long last_ctrl;                                                /* record of last output for timeouts */
+
+        struct urb *urbout;                                             /* Output URB */
+        struct hid_output_fifo out[HID_CONTROL_FIFO_SIZE];              /* Output pipe fifo */
+        unsigned char outhead, outtail;                                 /* Output pipe fifo head & tail */
+        char *outbuf;                                                   /* Output buffer */
+        dma_addr_t outbuf_dma;                                          /* Output buffer dma */
+        unsigned long last_out;                                                 /* record of last output for timeouts */
+
+        spinlock_t lock;                                                /* fifo spinlock */
+        unsigned long iofl;                                             /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
+        struct timer_list io_retry;                                     /* Retry timer */
+        unsigned long stop_retry;                                       /* Time to give up, in jiffies */
+        unsigned int retry_delay;                                       /* Delay length in ms */
+        struct work_struct reset_work;                                  /* Task context for resets */
+        wait_queue_head_t wait;                                         /* For sleeping */
+        int ledcount;                                                   /* counting the number of active leds */
+};
+
+#define hid_to_usb_dev(hid_dev) \
+        container_of(hid_dev->dev.parent->parent, struct usb_device, dev)
+
+#endif
+