If unsure, say Y.
+++ +++config HID_BATTERY_STRENGTH
+++ +++ bool
+++ +++ depends on HID && POWER_SUPPLY && HID = POWER_SUPPLY
+++ +++ default y
+++ +++
config HIDRAW
bool "/dev/hidraw raw HID device support"
depends on HID
Say Y here if you have one of the following devices:
- 3M PCT touch screens
- ActionStar dual touch panels
+ +++++ - Atmel panels
- Cando dual touch panels
- Chunghwa panels
- CVTouch panels
- Lumio CrystalTouch panels
- MosArt dual-touch panels
- PenMount dual touch panels
+ +++++ - PixArt optical touch screen
- Pixcir dual touch panels
+ +++++ - Quanta panels
- eGalax dual-touch panels, including the Joojoo and Wetab tablets
- Stantum multitouch panels
- Touch International Panels
- Unitec Panels
- XAT optical touch panels
+ +++++ - Xiroku optical touch panels
If unsure, say N.
Support for Primax devices that are not fully compliant with the
HID standard.
- -----config HID_QUANTA
- ----- tristate "Quanta Optical Touch panels"
- ----- depends on USB_HID
- ----- ---help---
- ----- Support for Quanta Optical Touch dual-touch panels.
- -----
config HID_ROCCAT
tristate "Roccat special event support"
depends on USB_HID
---help---
Support for Roccat Arvo keyboard.
++ ++++config HID_ROCCAT_ISKU
++ ++++ tristate "Roccat Isku keyboard support"
++ ++++ depends on USB_HID
++ ++++ depends on HID_ROCCAT
++ ++++ ---help---
++ ++++ Support for Roccat Isku keyboard.
++ ++++
config HID_ROCCAT_KONE
tristate "Roccat Kone Mouse support"
depends on USB_HID
(like MANTA Warrior MM816 and SpeedLink Strike2 SL-6635) or adapter
and want to enable force feedback support for it.
++++++config HID_HYPERV_MOUSE
++++++ tristate "Microsoft Hyper-V mouse driver"
++++++ depends on HYPERV
++++++ ---help---
++++++ Select this option to enable the Hyper-V mouse driver.
++++++
config HID_SMARTJOYPLUS
tristate "SmartJoy PLUS PS2/USB adapter support"
depends on USB_HID
depends on BT_HIDP
depends on LEDS_CLASS
select POWER_SUPPLY
++++ ++ select INPUT_FF_MEMLESS
---help---
Support for the Nintendo Wii Remote bluetooth device.
++++++ config HID_WIIMOTE_EXT
++++++ bool "Nintendo Wii Remote Extension support"
++++++ depends on HID_WIIMOTE
++++++ default HID_WIIMOTE
++++++ ---help---
++++++ Support for extension controllers of the Nintendo Wii Remote. Say yes
++++++ here if you want to use the Nintendo Motion+, Nunchuck or Classic
++++++ extension controllers with your Wii Remote.
++++++
config HID_ZEROPLUS
tristate "Zeroplus based game controller support"
depends on USB_HID
hid-logitech-y += hid-lg4ff.o
endif
++++++ hid-wiimote-y := hid-wiimote-core.o
++++++ ifdef CONFIG_HID_WIIMOTE_EXT
++++++ hid-wiimote-y += hid-wiimote-ext.o
++++++ endif
++++++ ifdef CONFIG_DEBUG_FS
++++++ hid-wiimote-y += hid-wiimote-debug.o
++++++ endif
++++++
obj-$(CONFIG_HID_A4TECH) += hid-a4tech.o
obj-$(CONFIG_HID_ACRUX) += hid-axff.o
obj-$(CONFIG_HID_APPLE) += hid-apple.o
obj-$(CONFIG_HID_EZKEY) += hid-ezkey.o
obj-$(CONFIG_HID_GYRATION) += hid-gyration.o
obj-$(CONFIG_HID_HOLTEK) += hid-holtekff.o
++++++obj-$(CONFIG_HID_HYPERV_MOUSE) += hid-hyperv.o
obj-$(CONFIG_HID_KENSINGTON) += hid-kensington.o
obj-$(CONFIG_HID_KEYTOUCH) += hid-keytouch.o
obj-$(CONFIG_HID_KYE) += hid-kye.o
obj-$(CONFIG_HID_NTRIG) += hid-ntrig.o
obj-$(CONFIG_HID_ORTEK) += hid-ortek.o
obj-$(CONFIG_HID_PRODIKEYS) += hid-prodikeys.o
- -----obj-$(CONFIG_HID_QUANTA) += hid-quanta.o
obj-$(CONFIG_HID_PANTHERLORD) += hid-pl.o
obj-$(CONFIG_HID_PETALYNX) += hid-petalynx.o
obj-$(CONFIG_HID_PICOLCD) += hid-picolcd.o
obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o
obj-$(CONFIG_HID_ROCCAT_COMMON) += hid-roccat-common.o
obj-$(CONFIG_HID_ROCCAT_ARVO) += hid-roccat-arvo.o
++ ++++obj-$(CONFIG_HID_ROCCAT_ISKU) += hid-roccat-isku.o
obj-$(CONFIG_HID_ROCCAT_KONE) += hid-roccat-kone.o
obj-$(CONFIG_HID_ROCCAT_KONEPLUS) += hid-roccat-koneplus.o
obj-$(CONFIG_HID_ROCCAT_KOVAPLUS) += hid-roccat-kovaplus.o
struct hid_field *field;
if (report->maxfield == HID_MAX_FIELDS) {
--- --- dbg_hid("too many fields in report\n");
+++ +++ hid_err(report->device, "too many fields in report\n");
return NULL;
}
usage = parser->local.usage[0];
if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
--- --- dbg_hid("collection stack overflow\n");
+++ +++ hid_err(parser->device, "collection stack overflow\n");
return -1;
}
collection = kmalloc(sizeof(struct hid_collection) *
parser->device->collection_size * 2, GFP_KERNEL);
if (collection == NULL) {
--- --- dbg_hid("failed to reallocate collection array\n");
+++ +++ hid_err(parser->device, "failed to reallocate collection array\n");
return -1;
}
memcpy(collection, parser->device->collection,
static int close_collection(struct hid_parser *parser)
{
if (!parser->collection_stack_ptr) {
--- --- dbg_hid("collection stack underflow\n");
+++ +++ hid_err(parser->device, "collection stack underflow\n");
return -1;
}
parser->collection_stack_ptr--;
static int hid_add_usage(struct hid_parser *parser, unsigned usage)
{
if (parser->local.usage_index >= HID_MAX_USAGES) {
--- --- dbg_hid("usage index exceeded\n");
+++ +++ hid_err(parser->device, "usage index exceeded\n");
return -1;
}
parser->local.usage[parser->local.usage_index] = usage;
report = hid_register_report(parser->device, report_type, parser->global.report_id);
if (!report) {
--- --- dbg_hid("hid_register_report failed\n");
+++ +++ hid_err(parser->device, "hid_register_report failed\n");
return -1;
}
if (parser->global.logical_maximum < parser->global.logical_minimum) {
--- --- dbg_hid("logical range invalid %d %d\n", parser->global.logical_minimum, parser->global.logical_maximum);
+++ +++ hid_err(parser->device, "logical range invalid %d %d\n",
+++ +++ parser->global.logical_minimum, parser->global.logical_maximum);
return -1;
}
case HID_GLOBAL_ITEM_TAG_PUSH:
if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
--- --- dbg_hid("global environment stack overflow\n");
+++ +++ hid_err(parser->device, "global environment stack overflow\n");
return -1;
}
case HID_GLOBAL_ITEM_TAG_POP:
if (!parser->global_stack_ptr) {
--- --- dbg_hid("global environment stack underflow\n");
+++ +++ hid_err(parser->device, "global environment stack underflow\n");
return -1;
}
case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
parser->global.report_size = item_udata(item);
--- --- if (parser->global.report_size > 32) {
--- --- dbg_hid("invalid report_size %d\n",
+++ +++ if (parser->global.report_size > 96) {
+++ +++ hid_err(parser->device, "invalid report_size %d\n",
parser->global.report_size);
return -1;
}
case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
parser->global.report_count = item_udata(item);
if (parser->global.report_count > HID_MAX_USAGES) {
--- --- dbg_hid("invalid report_count %d\n",
+++ +++ hid_err(parser->device, "invalid report_count %d\n",
parser->global.report_count);
return -1;
}
case HID_GLOBAL_ITEM_TAG_REPORT_ID:
parser->global.report_id = item_udata(item);
if (parser->global.report_id == 0) {
--- --- dbg_hid("report_id 0 is invalid\n");
+++ +++ hid_err(parser->device, "report_id 0 is invalid\n");
return -1;
}
return 0;
default:
--- --- dbg_hid("unknown global tag 0x%x\n", item->tag);
+++ +++ hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
return -1;
}
}
* items and the first delimiter set.
*/
if (parser->local.delimiter_depth != 0) {
--- --- dbg_hid("nested delimiters\n");
+++ +++ hid_err(parser->device, "nested delimiters\n");
return -1;
}
parser->local.delimiter_depth++;
parser->local.delimiter_branch++;
} else {
if (parser->local.delimiter_depth < 1) {
--- --- dbg_hid("bogus close delimiter\n");
+++ +++ hid_err(parser->device, "bogus close delimiter\n");
return -1;
}
parser->local.delimiter_depth--;
ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
break;
default:
--- --- dbg_hid("unknown main item tag 0x%x\n", item->tag);
+++ +++ hid_err(parser->device, "unknown main item tag 0x%x\n", item->tag);
ret = 0;
}
while ((start = fetch_item(start, end, &item)) != NULL) {
if (item.format != HID_ITEM_FORMAT_SHORT) {
--- --- dbg_hid("unexpected long global item\n");
+++ +++ hid_err(device, "unexpected long global item\n");
goto err;
}
if (dispatch_type[item.type](parser, &item)) {
--- --- dbg_hid("item %u %u %u %u parsing failed\n",
+++ +++ hid_err(device, "item %u %u %u %u parsing failed\n",
item.format, (unsigned)item.size,
(unsigned)item.type, (unsigned)item.tag);
goto err;
if (start == end) {
if (parser->collection_stack_ptr) {
--- --- dbg_hid("unbalanced collection at end of report description\n");
+++ +++ hid_err(device, "unbalanced collection at end of report description\n");
goto err;
}
if (parser->local.delimiter_depth) {
--- --- dbg_hid("unbalanced delimiter at end of report description\n");
+++ +++ hid_err(device, "unbalanced delimiter at end of report description\n");
goto err;
}
vfree(parser);
}
}
--- --- dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
+++ +++ hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));
err:
vfree(parser);
return ret;
ret = hdrv->event(hid, field, usage, value);
if (ret != 0) {
if (ret < 0)
--- --- dbg_hid("%s's event failed with %d\n",
+++ +++ hid_err(hid, "%s's event failed with %d\n",
hdrv->name, ret);
return;
}
hid_dump_input(field->report->device, field->usage + offset, value);
if (offset >= field->report_count) {
--- --- dbg_hid("offset (%d) exceeds report_count (%d)\n", offset, field->report_count);
+++ +++ hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",
+++ +++ offset, field->report_count);
return -1;
}
if (field->logical_minimum < 0) {
if (value != snto32(s32ton(value, size), size)) {
--- --- dbg_hid("value %d is out of range\n", value);
+++ +++ hid_err(field->report->device, "value %d is out of range\n", value);
return -1;
}
}
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
- ----- { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
- ----- { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
- ----- { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
- ----- { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },
- ----- { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2515) },
{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
{ HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, USB_DEVICE_ID_IDEACOM_IDC6650) },
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_PCI) },
{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
++ ++++ { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
+++++ + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_XAT, USB_DEVICE_ID_XAT_CSR) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX1) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX1) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR1) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX2) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX2) },
+ +++++ { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR2) },
{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x0004) },
+++ +++ { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x000a) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
++ + ++ { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
-- - -- { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0003) },
{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30) },
{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30) },
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/sched.h>
++ + ++#include <linux/export.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
{0, 0xbd, "FlareRelease"},
{0, 0xbe, "LandingGear"},
{0, 0xbf, "ToeBrake"},
+++ +++ { 6, 0, "GenericDeviceControls" },
+++ +++ {0, 0x20, "BatteryStrength" },
+++ +++ {0, 0x21, "WirelessChannel" },
+++ +++ {0, 0x22, "WirelessID" },
+++ +++ {0, 0x23, "DiscoverWirelessControl" },
+++ +++ {0, 0x24, "SecurityCodeCharacterEntered" },
+++ +++ {0, 0x25, "SecurityCodeCharactedErased" },
+++ +++ {0, 0x26, "SecurityCodeCleared" },
{ 7, 0, "Keyboard" },
{ 8, 0, "LED" },
{0, 0x01, "NumLock"},
#include <linux/hid.h>
#include <linux/input.h>
#include <linux/usb.h>
++ + ++#include <linux/module.h>
#include "hid-ids.h"
#include "usbhid/usbhid.h"
}
static const struct hid_device_id ems_devices[] = {
--- --- { HID_USB_DEVICE(USB_VENDOR_ID_EMS, 0x118) },
+++ +++ { HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
{ }
};
MODULE_DEVICE_TABLE(hid, ems_devices);
#define USB_VENDOR_ID_3M 0x0596
#define USB_DEVICE_ID_3M1968 0x0500
#define USB_DEVICE_ID_3M2256 0x0502
+ +++++#define USB_DEVICE_ID_3M3266 0x0506
#define USB_VENDOR_ID_A4TECH 0x09da
#define USB_DEVICE_ID_A4TECH_WCP32PU 0x0006
#define USB_DEVICE_ID_ATEN_4PORTKVM 0x2205
#define USB_DEVICE_ID_ATEN_4PORTKVMC 0x2208
+ +++++#define USB_VENDOR_ID_ATMEL 0x03eb
+ +++++#define USB_DEVICE_ID_ATMEL_MULTITOUCH 0x211c
+ +++++
#define USB_VENDOR_ID_AVERMEDIA 0x07ca
#define USB_DEVICE_ID_AVER_FM_MR800 0xb800
#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_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D 0x480d
+ +++++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E 0x480e
+ +++++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C 0x720c
+ +++++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B 0x726b
+ +++++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1 0x72a1
+ +++++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA 0x72fa
+ +++++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302 0x7302
+ +++++#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001 0xa001
#define USB_VENDOR_ID_ELECOM 0x056e
#define USB_DEVICE_ID_ELECOM_BM084 0x0061
#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_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS 0x0003
#define USB_VENDOR_ID_GLAB 0x06c2
#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
#define USB_VENDOR_ID_HANVON 0x20b3
#define USB_DEVICE_ID_HANVON_MULTITOUCH 0x0a18
+ +++++#define USB_VENDOR_ID_HANVON_ALT 0x22ed
+ +++++#define USB_DEVICE_ID_HANVON_ALT_MULTITOUCH 0x1010
+ +++++
#define USB_VENDOR_ID_HAPP 0x078b
#define USB_DEVICE_ID_UGCI_DRIVING 0x0010
#define USB_DEVICE_ID_UGCI_FLYING 0x0020
#define USB_VENDOR_ID_PI_ENGINEERING 0x05f3
#define USB_DEVICE_ID_PI_ENGINEERING_VEC_USB_FOOTPEDAL 0xff
+ +++++#define USB_VENDOR_ID_PIXART 0x093a
+ +++++#define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN 0x8001
+ +++++#define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1 0x8002
+ +++++#define USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2 0x8003
+ +++++
#define USB_VENDOR_ID_PLAYDOTCOM 0x0b43
#define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII 0x0003
#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_QUANTA_OPTICAL_TOUCH 0x3000
+ +++++#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001 0x3001
+ +++++#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008 0x3008
#define USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN 0x3001
#define USB_VENDOR_ID_ROCCAT 0x1e7d
#define USB_DEVICE_ID_ROCCAT_ARVO 0x30d4
++ ++++#define USB_DEVICE_ID_ROCCAT_ISKU 0x319c
#define USB_DEVICE_ID_ROCCAT_KONE 0x2ced
#define USB_DEVICE_ID_ROCCAT_KONEPLUS 0x2d51
#define USB_DEVICE_ID_ROCCAT_KOVAPLUS 0x2d50
#define USB_VENDOR_ID_WACOM 0x056a
#define USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH 0x81
+++++ +#define USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH 0x00BD
#define USB_VENDOR_ID_WALTOP 0x172f
#define USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH 0x0032
#define USB_VENDOR_ID_XAT 0x2505
#define USB_DEVICE_ID_XAT_CSR 0x0220
+ +++++#define USB_VENDOR_ID_XIROKU 0x1477
+ +++++#define USB_DEVICE_ID_XIROKU_SPX 0x1006
+ +++++#define USB_DEVICE_ID_XIROKU_MPX 0x1007
+ +++++#define USB_DEVICE_ID_XIROKU_CSR 0x100e
+ +++++#define USB_DEVICE_ID_XIROKU_SPX1 0x1021
+ +++++#define USB_DEVICE_ID_XIROKU_CSR1 0x1022
+ +++++#define USB_DEVICE_ID_XIROKU_MPX1 0x1023
+ +++++#define USB_DEVICE_ID_XIROKU_SPX2 0x1024
+ +++++#define USB_DEVICE_ID_XIROKU_CSR2 0x1025
+ +++++#define USB_DEVICE_ID_XIROKU_MPX2 0x1026
+ +++++
#define USB_VENDOR_ID_YEALINK 0x6993
#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K 0xb001
#define MT_QUIRK_ALWAYS_VALID (1 << 4)
#define MT_QUIRK_VALID_IS_INRANGE (1 << 5)
#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 6)
- -----#define MT_QUIRK_EGALAX_XYZ_FIXUP (1 << 7)
#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 8)
struct mt_slot {
bool seen_in_this_frame;/* has this slot been updated */
};
+ +++++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;
+ +++++};
+ +++++
struct mt_device {
struct mt_slot curdata; /* placeholder of incoming data */
- ----- struct mt_class *mtclass; /* our mt device class */
+ +++++ 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 */
int last_mt_collection; /* last known mt-related collection */
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 0x0001
#define MT_CLS_SERIAL 0x0002
#define MT_CLS_CONFIDENCE 0x0003
- -----#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0004
- -----#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0005
- -----#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0006
- -----#define MT_CLS_DUAL_NSMU_CONTACTID 0x0007
+ +++++#define MT_CLS_CONFIDENCE_CONTACT_ID 0x0004
+ +++++#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005
+ +++++#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006
+ +++++#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007
+ +++++#define MT_CLS_DUAL_NSMU_CONTACTID 0x0008
+ +++++#define MT_CLS_INRANGE_CONTACTNUMBER 0x0009
/* vendor specific classes */
#define MT_CLS_3M 0x0101
#define MT_CLS_CYPRESS 0x0102
#define MT_CLS_EGALAX 0x0103
+ +++++#define MT_CLS_EGALAX_SERIAL 0x0104
#define MT_DEFAULT_MAXCONTACT 10
return -1;
}
--- ---struct mt_class mt_classes[] = {
+++ +++static struct mt_class mt_classes[] = {
{ .name = MT_CLS_DEFAULT,
.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
{ .name = MT_CLS_SERIAL,
.quirks = MT_QUIRK_ALWAYS_VALID},
{ .name = MT_CLS_CONFIDENCE,
.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
+ +++++ { .name = MT_CLS_CONFIDENCE_CONTACT_ID,
+ +++++ .quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
+ +++++ MT_QUIRK_SLOT_IS_CONTACTID },
{ .name = MT_CLS_CONFIDENCE_MINUS_ONE,
.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE },
.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
MT_QUIRK_SLOT_IS_CONTACTID,
.maxcontacts = 2 },
+ +++++ { .name = MT_CLS_INRANGE_CONTACTNUMBER,
+ +++++ .quirks = MT_QUIRK_VALID_IS_INRANGE |
+ +++++ MT_QUIRK_SLOT_IS_CONTACTNUMBER },
/*
* vendor specific classes
.maxcontacts = 10 },
{ .name = MT_CLS_EGALAX,
.quirks = MT_QUIRK_SLOT_IS_CONTACTID |
- ----- MT_QUIRK_VALID_IS_INRANGE |
- ----- MT_QUIRK_EGALAX_XYZ_FIXUP,
- ----- .maxcontacts = 2,
+ +++++ MT_QUIRK_VALID_IS_INRANGE,
+ +++++ .sn_move = 4096,
+ +++++ .sn_pressure = 32,
+ +++++ },
+ +++++ { .name = MT_CLS_EGALAX_SERIAL,
+ +++++ .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
+ +++++ MT_QUIRK_ALWAYS_VALID,
.sn_move = 4096,
.sn_pressure = 32,
},
{ }
};
+ +++++static ssize_t mt_show_quirks(struct device *dev,
+ +++++ struct device_attribute *attr,
+ +++++ char *buf)
+ +++++{
+ +++++ struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+ +++++ struct mt_device *td = hid_get_drvdata(hdev);
+ +++++
+ +++++ return sprintf(buf, "%u\n", td->mtclass.quirks);
+ +++++}
+ +++++
+ +++++static ssize_t mt_set_quirks(struct device *dev,
+ +++++ struct device_attribute *attr,
+ +++++ const char *buf, size_t count)
+ +++++{
+ +++++ struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+ +++++ struct mt_device *td = hid_get_drvdata(hdev);
+ +++++
+ +++++ unsigned long val;
+ +++++
+ +++++ if (kstrtoul(buf, 0, &val))
+ +++++ return -EINVAL;
+ +++++
+ +++++ td->mtclass.quirks = val;
+ +++++
+ +++++ return count;
+ +++++}
+ +++++
+ +++++static DEVICE_ATTR(quirks, S_IWUSR | S_IRUGO, mt_show_quirks, mt_set_quirks);
+ +++++
+ +++++static struct attribute *sysfs_attrs[] = {
+ +++++ &dev_attr_quirks.attr,
+ +++++ NULL
+ +++++};
+ +++++
+ +++++static struct attribute_group mt_attribute_group = {
+ +++++ .attrs = sysfs_attrs
+ +++++};
+ +++++
static void mt_feature_mapping(struct hid_device *hdev,
struct hid_field *field, struct hid_usage *usage)
{
break;
case HID_DG_CONTACTMAX:
td->maxcontacts = field->value[0];
- ----- if (td->mtclass->maxcontacts)
+ +++++ if (td->mtclass.maxcontacts)
/* check if the maxcontacts is given by the class */
- ----- td->maxcontacts = td->mtclass->maxcontacts;
+ +++++ td->maxcontacts = td->mtclass.maxcontacts;
break;
}
unsigned long **bit, int *max)
{
struct mt_device *td = hid_get_drvdata(hdev);
- ----- struct mt_class *cls = td->mtclass;
- ----- __s32 quirks = cls->quirks;
+ +++++ struct mt_class *cls = &td->mtclass;
/* Only map fields from TouchScreen or TouchPad collections.
* We need to ignore fields that belong to other collections
else
return 0;
+ +++++ /* eGalax devices provide a Digitizer.Stylus input which overrides
+ +++++ * the correct Digitizers.Finger X/Y ranges.
+ +++++ * Let's just ignore this input. */
+ +++++ if (field->physical == HID_DG_STYLUS)
+ +++++ return -1;
+ +++++
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,
}
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,
}
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,
static int mt_compute_slot(struct mt_device *td)
{
- ----- __s32 quirks = td->mtclass->quirks;
+ +++++ __s32 quirks = td->mtclass.quirks;
if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
return td->curdata.contactid;
for (i = 0; i < td->maxcontacts; ++i) {
struct mt_slot *s = &(td->slots[i]);
- ----- if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
+ +++++ if ((td->mtclass.quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
!s->seen_in_this_frame) {
s->touch_state = false;
}
struct hid_usage *usage, __s32 value)
{
struct mt_device *td = hid_get_drvdata(hid);
- ----- __s32 quirks = td->mtclass->quirks;
+ +++++ __s32 quirks = td->mtclass.quirks;
if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
switch (usage->hid) {
dev_err(&hdev->dev, "cannot allocate multitouch data\n");
return -ENOMEM;
}
- ----- td->mtclass = mtclass;
+ +++++ td->mtclass = *mtclass;
td->inputmode = -1;
td->last_mt_collection = -1;
hid_set_drvdata(hdev, td);
goto fail;
}
+ +++++ ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group);
+ +++++
mt_set_input_mode(hdev);
return 0;
static void mt_remove(struct hid_device *hdev)
{
struct mt_device *td = hid_get_drvdata(hdev);
+ +++++ sysfs_remove_group(&hdev->dev.kobj, &mt_attribute_group);
hid_hw_stop(hdev);
kfree(td->slots);
kfree(td);
{ .driver_data = MT_CLS_3M,
HID_USB_DEVICE(USB_VENDOR_ID_3M,
USB_DEVICE_ID_3M2256) },
+ +++++ { .driver_data = MT_CLS_3M,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_3M,
+ +++++ USB_DEVICE_ID_3M3266) },
/* ActionStar panels */
{ .driver_data = MT_CLS_DEFAULT,
HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR,
USB_DEVICE_ID_ACTIONSTAR_1011) },
+ +++++ /* Atmel panels */
+ +++++ { .driver_data = MT_CLS_SERIAL,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_ATMEL,
+ +++++ USB_DEVICE_ID_ATMEL_MULTITOUCH) },
+ +++++
/* Cando panels */
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
/* eGalax devices (resistive) */
- ----- { .driver_data = MT_CLS_EGALAX,
+ +++++ { .driver_data = MT_CLS_EGALAX,
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
- ----- USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
- ----- { .driver_data = MT_CLS_EGALAX,
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
+ +++++ { .driver_data = MT_CLS_EGALAX,
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
- ----- USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
/* eGalax devices (capacitive) */
- ----- { .driver_data = MT_CLS_EGALAX,
+ +++++ { .driver_data = MT_CLS_EGALAX,
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
- ----- USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
- ----- { .driver_data = MT_CLS_EGALAX,
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
+ +++++ { .driver_data = MT_CLS_EGALAX,
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
- ----- USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
- ----- { .driver_data = MT_CLS_EGALAX,
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
+ +++++ { .driver_data = MT_CLS_EGALAX,
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
- ----- USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
+ +++++ { .driver_data = MT_CLS_EGALAX,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
+ +++++ { .driver_data = MT_CLS_EGALAX,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
+ +++++ { .driver_data = MT_CLS_EGALAX_SERIAL,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+ +++++ USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
/* Elo TouchSystems IntelliTouch Plus panel */
{ .driver_data = MT_CLS_DUAL_NSMU_CONTACTID,
HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
USB_DEVICE_ID_GOODTOUCH_000f) },
+ +++++ /* Hanvon panels */
+ +++++ { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
+ +++++ USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
+ +++++
/* Ideacom panel */
{ .driver_data = MT_CLS_SERIAL,
HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
USB_DEVICE_ID_PENMOUNT_PCI) },
+ +++++ /* PixArt optical touch screen */
+ +++++ { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_PIXART,
+ +++++ USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
+ +++++ { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_PIXART,
+ +++++ USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
+ +++++ { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_PIXART,
+ +++++ USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
+ +++++
/* PixCir-based panels */
{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
+ +++++ /* Quanta-based panels */
+ +++++ { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
+ +++++ USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
+ +++++ { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
+ +++++ USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
+ +++++ { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
+ +++++ USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) },
+ +++++
/* Stantum panels */
{ .driver_data = MT_CLS_CONFIDENCE,
HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
HID_USB_DEVICE(USB_VENDOR_ID_XAT,
USB_DEVICE_ID_XAT_CSR) },
+ +++++ /* Xiroku */
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_SPX) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_MPX) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_CSR) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_SPX1) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_MPX1) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_CSR1) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_SPX2) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_MPX2) },
+ +++++ { .driver_data = MT_CLS_DEFAULT,
+ +++++ HID_USB_DEVICE(USB_VENDOR_ID_XIROKU,
+ +++++ USB_DEVICE_ID_XIROKU_CSR2) },
+ +++++
{ }
};
MODULE_DEVICE_TABLE(hid, mt_devices);
#include <linux/completion.h>
#include <linux/uaccess.h>
++ + ++#include <linux/module.h>
#define PICOLCD_NAME "PicoLCD (graphic)"
struct picolcd_fb_cleanup_item *next;
};
static struct picolcd_fb_cleanup_item *fb_pending;
--- ---DEFINE_SPINLOCK(fb_pending_lock);
+++ +++static DEFINE_SPINLOCK(fb_pending_lock);
static void picolcd_fb_do_cleanup(struct work_struct *data)
{
} while (item);
}
--- ---DECLARE_WORK(picolcd_fb_cleanup, picolcd_fb_do_cleanup);
+++ +++static DECLARE_WORK(picolcd_fb_cleanup, picolcd_fb_do_cleanup);
static int picolcd_fb_open(struct fb_info *info, int u)
{
#include <linux/hid.h>
#include <linux/slab.h>
++ + ++#include <linux/module.h>
#include "hid-roccat-common.h"
static inline uint16_t roccat_common_feature_report(uint8_t report_id)
char *buf;
int len;
--- --- buf = kmalloc(size, GFP_KERNEL);
+++ +++ buf = kmemdup(data, size, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
--- --- memcpy(buf, data, size);
--- ---
len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
HID_REQ_SET_REPORT,
USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
*/
#include <linux/hid.h>
++ + ++#include <linux/export.h>
#include <linux/slab.h>
#include "../hid-ids.h"
{ USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
++++ ++ { USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II, HID_QUIRK_MULTI_INPUT },
{ USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT },
{ USB_VENDOR_ID_GREENASIA, USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD, HID_QUIRK_MULTI_INPUT },
{ USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
{ USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_AXIS_295, HID_QUIRK_NOGET },
{ USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
{ USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
+ +++++ { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NO_INIT_REPORTS },
+ +++++ { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1, HID_QUIRK_NO_INIT_REPORTS },
+ +++++ { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2, HID_QUIRK_NO_INIT_REPORTS },
{ USB_VENDOR_ID_PRODIGE, USB_DEVICE_ID_PRODIGE_CORDLESS, HID_QUIRK_NOGET },
{ USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NOGET },
{ USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
#include <linux/workqueue.h>
#include <linux/input.h>
#include <linux/semaphore.h>
+++ +++#include <linux/power_supply.h>
/*
* We parse each description item into this structure. Short items data
#define HID_UP_UNDEFINED 0x00000000
#define HID_UP_GENDESK 0x00010000
#define HID_UP_SIMULATION 0x00020000
+++ +++#define HID_UP_GENDEVCTRLS 0x00060000
#define HID_UP_KEYBOARD 0x00070000
#define HID_UP_LED 0x00080000
#define HID_UP_BUTTON 0x00090000
#define HID_GD_RIGHT 0x00010092
#define HID_GD_LEFT 0x00010093
+++ +++#define HID_DC_BATTERYSTRENGTH 0x00060020
+++ +++
#define HID_DG_DIGITIZER 0x000d0001
#define HID_DG_PEN 0x000d0002
#define HID_DG_LIGHTPEN 0x000d0003
struct hid_driver *driver;
struct hid_ll_driver *ll_driver;
+++ +++#ifdef CONFIG_HID_BATTERY_STRENGTH
+++ +++ /*
+++ +++ * Power supply information for HID devices which report
+++ +++ * battery strength. power_supply is registered iff
+++ +++ * battery.name is non-NULL.
+++ +++ */
+++ +++ struct power_supply battery;
+++ +++ __s32 battery_min;
+++ +++ __s32 battery_max;
+++ +++ __s32 battery_val;
+++ +++#endif
+++ +++
unsigned int status; /* see STAT flags above */
unsigned claimed; /* Claimed by hidinput, hiddev? */
unsigned quirks; /* Various quirks the device can pull on us */
extern int __must_check __hid_register_driver(struct hid_driver *,
struct module *, const char *mod_name);
-- - --static inline int __must_check hid_register_driver(struct hid_driver *driver)
-- - --{
-- - -- return __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
-- - --}
++ + ++
++ + ++/* use a define to avoid include chaining to get THIS_MODULE & friends */
++ + ++#define hid_register_driver(driver) \
++ + ++ __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
++ + ++
extern void hid_unregister_driver(struct hid_driver *);
extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
int hid_set_field(struct hid_field *, unsigned, __s32);
int hid_input_report(struct hid_device *, int type, u8 *, int, int);
int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
+++ +++struct hid_field *hidinput_get_led_field(struct hid_device *hid);
+++ +++unsigned int hidinput_count_leds(struct hid_device *hid);
void hid_output_report(struct hid_report *report, __u8 *data);
struct hid_device *hid_allocate_device(void);
struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id);
projects / karo-tx-linux.git / commitdiff