From 3596bb929f2abd3433c2eaa5755fad48ac207af1 Mon Sep 17 00:00:00 2001 From: Keng-Yu Lin Date: Thu, 2 Feb 2012 10:31:26 +0100 Subject: [PATCH 01/42] HID: add extra hotkeys in Asus AIO keyboards The Asus All-In-One PC has a wireless keyboard with wifi toggle, brightness up, brightness down and display off hotkeys. This patch adds suppoort for these hotkeys. Signed-off-by: Keng-Yu Lin Signed-off-by: Jiri Kosina --- drivers/hid/hid-chicony.c | 5 +++++ drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 1 + 3 files changed, 7 insertions(+) diff --git a/drivers/hid/hid-chicony.c b/drivers/hid/hid-chicony.c index 8965ad93d510..4162505793c5 100644 --- a/drivers/hid/hid-chicony.c +++ b/drivers/hid/hid-chicony.c @@ -45,6 +45,10 @@ static int ch_input_mapping(struct hid_device *hdev, struct hid_input *hi, case 0xff09: ch_map_key_clear(BTN_9); break; case 0xff0a: ch_map_key_clear(BTN_A); break; case 0xff0b: ch_map_key_clear(BTN_B); break; + case 0x00f1: ch_map_key_clear(KEY_WLAN); break; + case 0x00f2: ch_map_key_clear(KEY_BRIGHTNESSDOWN); break; + case 0x00f3: ch_map_key_clear(KEY_BRIGHTNESSUP); break; + case 0x00f4: ch_map_key_clear(KEY_DISPLAY_OFF); break; default: return 0; } @@ -53,6 +57,7 @@ static int ch_input_mapping(struct hid_device *hdev, struct hid_input *hi, static const struct hid_device_id ch_devices[] = { { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) }, + { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) }, { } }; MODULE_DEVICE_TABLE(hid, ch_devices); diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index af08ce7207d9..75dbe344cabe 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1396,6 +1396,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) }, { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) }, { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) }, + { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) }, { HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) }, { HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) }, { HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, USB_DEVICE_ID_CVTOUCH_SCREEN) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index b8574cddd953..fb9e61f85666 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -190,6 +190,7 @@ #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_DEVICE_ID_CHICONY_WIRELESS2 0x1123 #define USB_VENDOR_ID_CHUNGHWAT 0x2247 #define USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH 0x0001 From 6c30d5a53229aad22bb675e0bd6eb518ecaa4316 Mon Sep 17 00:00:00 2001 From: Keng-Yu Lin Date: Mon, 30 Jan 2012 14:25:45 +0800 Subject: [PATCH 02/42] HID: add more hotkeys in Asus AIO keyboards Add support for the camera key. The hotkey for Asus S.H.E(Super Hybrid Engine) mode is mapped to KEY_KEY_PROG1 just for notifying the userspace. Signed-off-by: Keng-Yu Lin Signed-off-by: Jiri Kosina --- drivers/hid/hid-chicony.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/drivers/hid/hid-chicony.c b/drivers/hid/hid-chicony.c index 4162505793c5..b99af346fdff 100644 --- a/drivers/hid/hid-chicony.c +++ b/drivers/hid/hid-chicony.c @@ -49,6 +49,8 @@ static int ch_input_mapping(struct hid_device *hdev, struct hid_input *hi, case 0x00f2: ch_map_key_clear(KEY_BRIGHTNESSDOWN); break; case 0x00f3: ch_map_key_clear(KEY_BRIGHTNESSUP); break; case 0x00f4: ch_map_key_clear(KEY_DISPLAY_OFF); break; + case 0x00f7: ch_map_key_clear(KEY_CAMERA); break; + case 0x00f8: ch_map_key_clear(KEY_PROG1); break; default: return 0; } From 765031668fb2b064aebd9a568e5ad794cbe3413a Mon Sep 17 00:00:00 2001 From: Nestor Lopez Casado Date: Thu, 2 Feb 2012 10:54:14 +0100 Subject: [PATCH 03/42] HID: logitech: fix mask to enable DJ mode The user can only experience the bug if she pairs 6 devices to a Unifying receiver. The sixth paired device would not work. The value changed is actually a bitmask that enables reporting from each paired device. As the sixth bit was not set, the sixth device reports are ignored by the receiver and never get to the driver. Signed-off-by: Nestor Lopez Casado drivers/hid/hid-logitech-dj.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) Signed-off-by: Jiri Kosina --- drivers/hid/hid-logitech-dj.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/hid/hid-logitech-dj.c b/drivers/hid/hid-logitech-dj.c index 38b12e45780c..2b56efcbdf61 100644 --- a/drivers/hid/hid-logitech-dj.c +++ b/drivers/hid/hid-logitech-dj.c @@ -445,7 +445,7 @@ static int logi_dj_recv_switch_to_dj_mode(struct dj_receiver_dev *djrcv_dev, dj_report.report_id = REPORT_ID_DJ_SHORT; dj_report.device_index = 0xFF; dj_report.report_type = REPORT_TYPE_CMD_SWITCH; - dj_report.report_params[CMD_SWITCH_PARAM_DEVBITFIELD] = 0x1F; + dj_report.report_params[CMD_SWITCH_PARAM_DEVBITFIELD] = 0x3F; dj_report.report_params[CMD_SWITCH_PARAM_TIMEOUT_SECONDS] = (u8)timeout; return logi_dj_recv_send_report(djrcv_dev, &dj_report); } From 45d9c273b262cde84bb6bb3fc02c01d07da76936 Mon Sep 17 00:00:00 2001 From: Jeremy Fitzhardinge Date: Wed, 7 Dec 2011 17:31:43 -0800 Subject: [PATCH 04/42] HID: hid-input/battery: set scope and powered device for HID battery Set the battery's power supply scope to "Device" and point the power supply to the powered device. Signed-off-by: Jeremy Fitzhardinge Signed-off-by: Jiri Kosina --- drivers/hid/hid-input.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c index 9333d692a786..af0200f061c0 100644 --- a/drivers/hid/hid-input.c +++ b/drivers/hid/hid-input.c @@ -279,7 +279,8 @@ static enum power_supply_property hidinput_battery_props[] = { POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_CAPACITY, POWER_SUPPLY_PROP_MODEL_NAME, - POWER_SUPPLY_PROP_STATUS + POWER_SUPPLY_PROP_STATUS, + POWER_SUPPLY_PROP_SCOPE, }; #define HID_BATTERY_QUIRK_PERCENT (1 << 0) /* always reports percent */ @@ -344,6 +345,10 @@ static int hidinput_get_battery_property(struct power_supply *psy, val->intval = POWER_SUPPLY_STATUS_DISCHARGING; break; + case POWER_SUPPLY_PROP_SCOPE: + val->intval = POWER_SUPPLY_SCOPE_DEVICE; + break; + default: ret = -EINVAL; break; @@ -403,6 +408,8 @@ static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type, battery->name = NULL; } + power_supply_powers(battery, &dev->dev); + out: return true; } From bd393dbd33aeae0bb239f3c69938d37cc55193ca Mon Sep 17 00:00:00 2001 From: Stefan Achatz Date: Thu, 29 Dec 2011 17:20:14 +0100 Subject: [PATCH 05/42] HID: roccat: Only one Kconfig entry for all roccat drivers To cleanup Kconfig space and ease selection for users there is now a single entry that selects all roccat related drivers at once. Signed-off-by: Stefan Achatz Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 55 ++++---------------------------------------- drivers/hid/Makefile | 11 +++------ 2 files changed, 7 insertions(+), 59 deletions(-) diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index a421abdd1ab7..5a763d5a7bf8 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -476,59 +476,12 @@ config HID_PRIMAX HID standard. config HID_ROCCAT - tristate "Roccat special event support" + tristate "Roccat device support" depends on USB_HID - select HID_ROCCAT_COMMON ---help--- - Support for Roccat special events. - Say Y here if you have a Roccat mouse or keyboard and want OSD or - macro execution support. - -config HID_ROCCAT_COMMON - tristate - depends on HID_ROCCAT - -config HID_ROCCAT_ARVO - tristate "Roccat Arvo keyboard support" - depends on USB_HID - depends on HID_ROCCAT - ---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 - depends on HID_ROCCAT - ---help--- - Support for Roccat Kone mouse. - -config HID_ROCCAT_KONEPLUS - tristate "Roccat Kone[+] mouse support" - depends on USB_HID - depends on HID_ROCCAT - ---help--- - Support for Roccat Kone[+] mouse. - -config HID_ROCCAT_KOVAPLUS - tristate "Roccat Kova[+] mouse support" - depends on USB_HID - depends on HID_ROCCAT - ---help--- - Support for Roccat Kova[+] mouse. - -config HID_ROCCAT_PYRA - tristate "Roccat Pyra mouse support" - depends on USB_HID - depends on HID_ROCCAT - ---help--- - Support for Roccat Pyra mouse. + Support for Roccat devices. + Say Y here if you have a Roccat mouse or keyboard and want + support for its special functionalities. config HID_SAMSUNG tristate "Samsung InfraRed remote control or keyboards" diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile index 8aefdc963cce..7d926719e21b 100644 --- a/drivers/hid/Makefile +++ b/drivers/hid/Makefile @@ -64,14 +64,9 @@ obj-$(CONFIG_HID_PANTHERLORD) += hid-pl.o obj-$(CONFIG_HID_PETALYNX) += hid-petalynx.o obj-$(CONFIG_HID_PICOLCD) += hid-picolcd.o obj-$(CONFIG_HID_PRIMAX) += hid-primax.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 -obj-$(CONFIG_HID_ROCCAT_PYRA) += hid-roccat-pyra.o +obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o hid-roccat-common.o \ + hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \ + hid-roccat-koneplus.o hid-roccat-kovaplus.o hid-roccat-pyra.o obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o obj-$(CONFIG_HID_SONY) += hid-sony.o From c2ef8f21ea8f7c34dfa0b569fdee431348205955 Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Sat, 4 Feb 2012 17:08:48 +0100 Subject: [PATCH 06/42] HID: multitouch: add support for trackpads * some multitouch trackpads present the touch usage. This needs to be filtered as it will conflict with mt-implementation. * trackpads send BTN_TOOL_* to notify how many fingers are present (this is used by xorg to use synaptics instead of generic evdev) * trackpads like Perixx 701 are not different from a hid point of view from a touchscreen, and we need to manually set them as touchpad. Signed-off-by: Benjamin Tissoires Acked-by: Henrik Rydberg Signed-off-by: Jiri Kosina --- drivers/hid/hid-multitouch.c | 40 ++++++++++++++++++++++++++++++------ 1 file changed, 34 insertions(+), 6 deletions(-) diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 24fc4423b937..4c697498fcf9 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -1,9 +1,9 @@ /* * HID driver for multitouch panels * - * Copyright (c) 2010-2011 Stephane Chatty - * Copyright (c) 2010-2011 Benjamin Tissoires - * Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France + * Copyright (c) 2010-2012 Stephane Chatty + * Copyright (c) 2010-2012 Benjamin Tissoires + * Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France * * This code is partly based on hid-egalax.c: * @@ -67,6 +67,7 @@ struct mt_class { __s32 sn_height; /* Signal/noise ratio for height events */ __s32 sn_pressure; /* Signal/noise ratio for pressure events */ __u8 maxcontacts; + bool is_indirect; /* true for touchpads */ }; struct mt_device { @@ -265,17 +266,31 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, { struct mt_device *td = hid_get_drvdata(hdev); struct mt_class *cls = &td->mtclass; + int code; /* Only map fields from TouchScreen or TouchPad collections. * We need to ignore fields that belong to other collections * such as Mouse that might have the same GenericDesktop usages. */ if (field->application == HID_DG_TOUCHSCREEN) set_bit(INPUT_PROP_DIRECT, hi->input->propbit); - else if (field->application == HID_DG_TOUCHPAD) - set_bit(INPUT_PROP_POINTER, hi->input->propbit); - else + else if (field->application != HID_DG_TOUCHPAD) return 0; + /* In case of an indirect device (touchpad), we need to add + * specific BTN_TOOL_* to be handled by the synaptics xorg + * driver. + * We also consider that touchscreens providing buttons are touchpads. + */ + if (field->application == HID_DG_TOUCHPAD || + (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON || + cls->is_indirect) { + set_bit(INPUT_PROP_POINTER, hi->input->propbit); + set_bit(BTN_TOOL_FINGER, hi->input->keybit); + set_bit(BTN_TOOL_DOUBLETAP, hi->input->keybit); + set_bit(BTN_TOOL_TRIPLETAP, hi->input->keybit); + set_bit(BTN_TOOL_QUADTAP, hi->input->keybit); + } + /* eGalax devices provide a Digitizer.Stylus input which overrides * the correct Digitizers.Finger X/Y ranges. * Let's just ignore this input. */ @@ -389,9 +404,19 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, td->last_field_index = field->index; return -1; } + case HID_DG_TOUCH: + /* Legacy devices use TIPSWITCH and not TOUCH. + * Let's just ignore this field. */ + return -1; /* let hid-input decide for the others */ return 0; + case HID_UP_BUTTON: + code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE); + hid_map_usage(hi, usage, bit, max, EV_KEY, code); + input_set_capability(hi->input, EV_KEY, code); + return 1; + case 0xff000000: /* we do not want to map these: no input-oriented meaning */ return -1; @@ -538,6 +563,9 @@ static int mt_event(struct hid_device *hid, struct hid_field *field, if (value) td->num_expected = value; break; + case HID_DG_TOUCH: + /* do nothing */ + break; default: /* fallback to the generic hidinput handling */ From 31ae9bddb935c74b51ead08d54948e5bea0f0344 Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Sat, 4 Feb 2012 17:08:49 +0100 Subject: [PATCH 07/42] HID: multitouch: add control of the feature "Maximum Contact Number" Some devices, like Perixx Peripad 701 do not work if the feature "Maximum Contact Number" is not set to the right value. This patch allows hid-multitouch to control this feature. If the programmer fills the field maxcontacts in the mt_class, then the driver will set the feature to this value. It is safe for current drivers as the feature is read/write in the HID norm and all devices should implement the norm. Signed-off-by: Benjamin Tissoires Acked-by: Henrik Rydberg Signed-off-by: Jiri Kosina --- drivers/hid/hid-multitouch.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 4c697498fcf9..d0fa6a7e9bc0 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -77,6 +77,8 @@ struct mt_device { unsigned last_slot_field; /* the last field of a slot */ int last_mt_collection; /* last known mt-related collection */ __s8 inputmode; /* InputMode HID feature, -1 if non-existent */ + __s8 maxcontact_report_id; /* Maximum Contact Number HID feature, + -1 if non-existent */ __u8 num_received; /* how many contacts we received */ __u8 num_expected; /* expected last contact index */ __u8 maxcontacts; @@ -242,6 +244,7 @@ static void mt_feature_mapping(struct hid_device *hdev, td->inputmode = field->report->id; break; case HID_DG_CONTACTMAX: + td->maxcontact_report_id = field->report->id; td->maxcontacts = field->value[0]; if (td->mtclass.maxcontacts) /* check if the maxcontacts is given by the class */ @@ -606,6 +609,32 @@ static void mt_set_input_mode(struct hid_device *hdev) } } +static void mt_set_maxcontacts(struct hid_device *hdev) +{ + struct mt_device *td = hid_get_drvdata(hdev); + struct hid_report *r; + struct hid_report_enum *re; + int fieldmax, max; + + if (td->maxcontact_report_id < 0) + return; + + if (!td->mtclass.maxcontacts) + return; + + re = &hdev->report_enum[HID_FEATURE_REPORT]; + r = re->report_id_hash[td->maxcontact_report_id]; + if (r) { + max = td->mtclass.maxcontacts; + fieldmax = r->field[0]->logical_maximum; + max = min(fieldmax, max); + if (r->field[0]->value[0] != max) { + r->field[0]->value[0] = max; + 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; @@ -631,6 +660,7 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) } td->mtclass = *mtclass; td->inputmode = -1; + td->maxcontact_report_id = -1; td->last_mt_collection = -1; hid_set_drvdata(hdev, td); @@ -653,6 +683,7 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) ret = sysfs_create_group(&hdev->dev.kobj, &mt_attribute_group); + mt_set_maxcontacts(hdev); mt_set_input_mode(hdev); return 0; @@ -665,6 +696,7 @@ fail: #ifdef CONFIG_PM static int mt_reset_resume(struct hid_device *hdev) { + mt_set_maxcontacts(hdev); mt_set_input_mode(hdev); return 0; } From 847672cd141c07db3d5fc1442b4c3e8a702488df Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Sat, 4 Feb 2012 17:08:50 +0100 Subject: [PATCH 08/42] HID: multitouch: support Perixx PERIPAD 701 Perixx Peripad 701 is an hybrid device which presents a touchpad and a keyboard on the same surface. The switch between the two is controlled by a physical switch, and the firmware sends the events on the right interface (mouse, keyboard or multitouch). This patch enables the multitouch interface of this device to work. We need to manually set the device as a trackpad (we cannot infer it from the reports descriptors as the device works under Windows, a system that does not allow multitouch touchpad). We also need to set the hid feature MAX CONTACT NUMBER to 2 or the device stops sending events once it has been pressed by two touches. Signed-off-by: Benjamin Tissoires Acked-by: Henrik Rydberg Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 1 + drivers/hid/hid-ids.h | 1 + drivers/hid/hid-multitouch.c | 11 +++++++++++ 3 files changed, 13 insertions(+) diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index a421abdd1ab7..f7c43b6c3567 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -355,6 +355,7 @@ config HID_MULTITOUCH - Lumio CrystalTouch panels - MosArt dual-touch panels - PenMount dual touch panels + - Perixx Peripad 701 touchpad - PixArt optical touch screen - Pixcir dual touch panels - Quanta panels diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index b8574cddd953..662a0b6a6642 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -659,6 +659,7 @@ #define USB_VENDOR_ID_TOPSEED2 0x1784 #define USB_DEVICE_ID_TOPSEED2_RF_COMBO 0x0004 +#define USB_DEVICE_ID_TOPSEED2_PERIPAD_701 0x0016 #define USB_VENDOR_ID_TOPMAX 0x0663 #define USB_DEVICE_ID_TOPMAX_COBRAPAD 0x0103 diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index d0fa6a7e9bc0..387a72fb1c84 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -103,6 +103,7 @@ struct mt_device { #define MT_CLS_CYPRESS 0x0102 #define MT_CLS_EGALAX 0x0103 #define MT_CLS_EGALAX_SERIAL 0x0104 +#define MT_CLS_TOPSEED 0x0105 #define MT_DEFAULT_MAXCONTACT 10 @@ -192,6 +193,11 @@ static struct mt_class mt_classes[] = { .sn_move = 4096, .sn_pressure = 32, }, + { .name = MT_CLS_TOPSEED, + .quirks = MT_QUIRK_ALWAYS_VALID, + .is_indirect = true, + .maxcontacts = 2, + }, { } }; @@ -897,6 +903,11 @@ static const struct hid_device_id mt_devices[] = { HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX, USB_DEVICE_ID_MTP_SITRONIX)}, + /* TopSeed panels */ + { .driver_data = MT_CLS_TOPSEED, + HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, + USB_DEVICE_ID_TOPSEED2_PERIPAD_701) }, + /* Touch International panels */ { .driver_data = MT_CLS_DEFAULT, HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, From 44ea35c138d400b3aeeb2a5317edd4634e6823e3 Mon Sep 17 00:00:00 2001 From: Jarod Wilson Date: Fri, 14 Oct 2011 16:57:42 -0400 Subject: [PATCH 09/42] HID: add support for tivo slide remote This patch finishes off adding full support for the TiVo Slide remote, which is a mostly pure HID device from the perspective of the kernel. There are a few mappings that use a vendor-specific usage page, and a few keys in the consumer usage page that I think make sense to remap slightly, to better fit their key labels' intended use. Doing this in a stand-alone hid-tivo.c makes the modifications only matter for this specific device. What's actually connected to the computer is a Broadcom-made usb dongle, which has an embedded hub, bluetooth adapter, mouse and keyboard devices. You pair with the dongle, then the remote sends data that its converted into HID on the keyboard interface (the mouse interface doesn't do anything interesting, so far as I can tell). lsusb for this device: Bus 004 Device 005: ID 0a5c:2190 Broadcom Corp. Bus 004 Device 004: ID 0a5c:4503 Broadcom Corp. Bus 004 Device 003: ID 150a:1201 Bus 004 Device 002: ID 0a5c:4500 Broadcom Corp. BCM2046B1 USB 2.0 Hub (part of BCM2046 Bluetooth) Speaking of the keyboard interface, the remote actually does contain a keyboard as well. The top slides away, revealing a reasonably functional qwerty keyboard (not unlike many slide cell phones), thus the product name. CC: Jiri Kosina Signed-off-by: Jarod Wilson Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 6 +++ drivers/hid/Makefile | 1 + drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 3 ++ drivers/hid/hid-tivo.c | 89 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 100 insertions(+) create mode 100644 drivers/hid/hid-tivo.c diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index a421abdd1ab7..1f0b229f7dfc 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -594,6 +594,12 @@ config SMARTJOYPLUS_FF Say Y here if you have a SmartJoy PLUS PS2/USB adapter and want to enable force feedback support for it. +config HID_TIVO_SLIDE + tristate "TiVo Slide Bluetooth remote control support" + depends on USB_HID + ---help--- + Say Y if you have a TiVo Slide Bluetooth remote control. + config HID_TOPSEED tristate "TopSeed Cyberlink, BTC Emprex, Conceptronic remote control support" depends on USB_HID diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile index 8aefdc963cce..c05f448f34a0 100644 --- a/drivers/hid/Makefile +++ b/drivers/hid/Makefile @@ -79,6 +79,7 @@ obj-$(CONFIG_HID_SPEEDLINK) += hid-speedlink.o obj-$(CONFIG_HID_SUNPLUS) += hid-sunplus.o obj-$(CONFIG_HID_GREENASIA) += hid-gaff.o obj-$(CONFIG_HID_THRUSTMASTER) += hid-tmff.o +obj-$(CONFIG_HID_TIVO) += hid-tivo.o obj-$(CONFIG_HID_TOPSEED) += hid-topseed.o obj-$(CONFIG_HID_TWINHAN) += hid-twinhan.o obj-$(CONFIG_HID_UCLOGIC) += hid-uclogic.o diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index 75dbe344cabe..23fa03176ace 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1536,6 +1536,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) }, { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) }, { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) }, + { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) }, { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) }, { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) }, { HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index fb9e61f85666..5f63e361be13 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -655,6 +655,9 @@ #define USB_VENDOR_ID_THRUSTMASTER 0x044f +#define USB_VENDOR_ID_TIVO 0x150a +#define USB_DEVICE_ID_TIVO_SLIDE 0x1201 + #define USB_VENDOR_ID_TOPSEED 0x0766 #define USB_DEVICE_ID_TOPSEED_CYBERLINK 0x0204 diff --git a/drivers/hid/hid-tivo.c b/drivers/hid/hid-tivo.c new file mode 100644 index 000000000000..3d43c06dfffa --- /dev/null +++ b/drivers/hid/hid-tivo.c @@ -0,0 +1,89 @@ +/* + * HID driver for TiVo Slide Bluetooth remote + * + * Copyright (c) 2011 Jarod Wilson + * based on the hid-topseed driver, which is in turn, based on hid-cherry... + */ + +/* + * 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 +#include +#include + +#include "hid-ids.h" + +#define HID_UP_TIVOVENDOR 0xffff0000 +#define tivo_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \ + EV_KEY, (c)) + +static int tivo_input_mapping(struct hid_device *hdev, struct hid_input *hi, + struct hid_field *field, struct hid_usage *usage, + unsigned long **bit, int *max) +{ + switch (usage->hid & HID_USAGE_PAGE) { + case HID_UP_TIVOVENDOR: + switch (usage->hid & HID_USAGE) { + /* TiVo button */ + case 0x3d: tivo_map_key_clear(KEY_MEDIA); break; + /* Live TV */ + case 0x3e: tivo_map_key_clear(KEY_TV); break; + /* Red thumbs down */ + case 0x41: tivo_map_key_clear(KEY_KPMINUS); break; + /* Green thumbs up */ + case 0x42: tivo_map_key_clear(KEY_KPPLUS); break; + default: + return 0; + } + break; + case HID_UP_CONSUMER: + switch (usage->hid & HID_USAGE) { + /* Enter/Last (default mapping: KEY_LAST) */ + case 0x083: tivo_map_key_clear(KEY_ENTER); break; + /* Info (default mapping: KEY_PROPS) */ + case 0x209: tivo_map_key_clear(KEY_INFO); break; + default: + return 0; + } + break; + default: + return 0; + } + + /* This means we found a matching mapping here, else, look in the + * standard hid mappings in hid-input.c */ + return 1; +} + +static const struct hid_device_id tivo_devices[] = { + /* TiVo Slide Bluetooth remote, pairs with a Broadcom dongle */ + { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) }, + { } +}; +MODULE_DEVICE_TABLE(hid, tivo_devices); + +static struct hid_driver tivo_driver = { + .name = "tivo_slide", + .id_table = tivo_devices, + .input_mapping = tivo_input_mapping, +}; + +static int __init tivo_init(void) +{ + return hid_register_driver(&tivo_driver); +} + +static void __exit tivo_exit(void) +{ + hid_unregister_driver(&tivo_driver); +} + +module_init(tivo_init); +module_exit(tivo_exit); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Jarod Wilson "); From 2701eaabd7599a2aebae22caf00869a383d66a05 Mon Sep 17 00:00:00 2001 From: Jiri Kosina Date: Mon, 6 Feb 2012 17:36:38 +0100 Subject: [PATCH 10/42] HID: tivo: fix broken build Fix mismatch between Kconfig name and Makefile expectation. Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index 1f0b229f7dfc..0a55866f1f74 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -594,7 +594,7 @@ config SMARTJOYPLUS_FF Say Y here if you have a SmartJoy PLUS PS2/USB adapter and want to enable force feedback support for it. -config HID_TIVO_SLIDE +config HID_TIVO tristate "TiVo Slide Bluetooth remote control support" depends on USB_HID ---help--- From 4fdc18d15151f3e7cc43070ec8d13570431b5abc Mon Sep 17 00:00:00 2001 From: Nikolai Kondrashov Date: Mon, 6 Feb 2012 22:54:20 +0200 Subject: [PATCH 11/42] HID: waltop: Add support for Waltop Q Pad Add support for Waltop Q Pad by fixing its report descriptor. This tablet is also sold as Aiptek HyperPen Mini. Other possible names include: NGS Flexi Style, VisTablet PenPad, iVistaTablet Q Flex Pad, Bravod Q-PD65-S. Signed-off-by: Nikolai Kondrashov Signed-off-by: Jiri Kosina --- drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 1 + drivers/hid/hid-waltop.c | 192 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 194 insertions(+) diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index 23fa03176ace..162be0955df0 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1558,6 +1558,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { 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_Q_PAD) }, { 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) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 5f63e361be13..1a002201516e 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -707,6 +707,7 @@ #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_Q_PAD 0x0037 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH 0x0501 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH 0x0500 diff --git a/drivers/hid/hid-waltop.c b/drivers/hid/hid-waltop.c index b3a4163f2e67..0ec169646ec7 100644 --- a/drivers/hid/hid-waltop.c +++ b/drivers/hid/hid-waltop.c @@ -423,6 +423,190 @@ static __u8 slim_tablet_12_1_inch_rdesc_fixed[] = { 0xC0 /* End Collection */ }; +/* + * Original Q Pad report descriptor. + * + * The descriptor is similar to the Slim Tablet 5.8 inch descriptor with the + * addition of consumer AC Pan field to the report ID 1, which seems to be + * unused in the default mode. However, this tablet has resolution of 2048 LPI. + * + * Usage Page (Desktop), ; Generic desktop controls (01h) + * Usage (Mouse), ; Mouse (02h, application collection) + * Collection (Application), + * Report ID (1), + * Usage (Pointer), ; Pointer (01h, physical collection) + * Collection (Physical), + * Usage Page (Button), ; Button (09h) + * Usage Minimum (01h), + * Usage Maximum (05h), + * Logical Minimum (0), + * Logical Maximum (1), + * Report Size (1), + * Report Count (5), + * Input (Variable), + * Report Size (3), + * Report Count (1), + * Input (Constant, Variable), + * Usage Page (Desktop), ; Generic desktop controls (01h) + * Usage (X), ; X (30h, dynamic value) + * Usage (Y), ; Y (31h, dynamic value) + * Usage (Wheel), ; Wheel (38h, dynamic value) + * Logical Minimum (-127), + * Logical Maximum (127), + * Report Size (8), + * Report Count (3), + * Input (Variable, Relative), + * Usage Page (Consumer), ; Consumer (0Ch) + * Logical Minimum (-127), + * Logical Maximum (127), + * Report Size (8), + * Report Count (1), + * Usage (AC Pan), ; AC pan (0238h, linear control) + * Input (Variable, Relative), + * End Collection, + * End Collection, + * Usage Page (Digitizer), ; Digitizer (0Dh) + * Usage (Pen), ; Pen (02h, application collection) + * Collection (Application), + * Report ID (2), + * Usage (Stylus), ; Stylus (20h, logical collection) + * Collection (Physical), + * Usage (00h), + * Logical Minimum (0), + * Logical Maximum (255), + * Report Size (8), + * Report Count (7), + * Input (Variable), + * Usage (Azimuth), ; Azimuth (3Fh, dynamic value) + * Usage (Altitude), ; Altitude (40h, dynamic value) + * Logical Minimum (0), + * Logical Maximum (255), + * Report Size (8), + * Report Count (2), + * Feature (Variable), + * End Collection, + * Report ID (5), + * Usage Page (Digitizer), ; Digitizer (0Dh) + * Usage (Stylus), ; Stylus (20h, logical collection) + * Collection (Physical), + * Usage (00h), + * Logical Minimum (0), + * Logical Maximum (255), + * Report Size (8), + * Report Count (7), + * Input (Variable), + * End Collection, + * Report ID (10), + * Usage Page (Digitizer), ; Digitizer (0Dh) + * Usage (Stylus), ; Stylus (20h, logical collection) + * Collection (Physical), + * Usage (00h), + * Logical Minimum (0), + * Logical Maximum (255), + * Report Size (8), + * Report Count (7), + * Input (Variable), + * End Collection, + * Report ID (16), + * Usage (Stylus), ; Stylus (20h, logical collection) + * Collection (Physical), + * Usage (Tip Switch), ; Tip switch (42h, momentary control) + * Usage (Barrel Switch), ; Barrel switch (44h, momentary control) + * Usage (Invert), ; Invert (3Ch, momentary control) + * Usage (Eraser), ; Eraser (45h, momentary control) + * Usage (In Range), ; In range (32h, momentary control) + * Logical Minimum (0), + * Logical Maximum (1), + * Report Size (1), + * Report Count (5), + * Input (Variable), + * Report Count (3), + * Input (Constant, Variable), + * Usage Page (Desktop), ; Generic desktop controls (01h) + * Usage (X), ; X (30h, dynamic value) + * Report Size (16), + * Report Count (1), + * Push, + * Unit Exponent (13), + * Unit (Inch^3), + * Logical Minimum (0), + * Logical Maximum (12288), + * Physical Minimum (0), + * Physical Maximum (12288), + * Input (Variable), + * Usage (Y), ; Y (31h, dynamic value) + * Logical Minimum (0), + * Logical Maximum (9216), + * Physical Minimum (0), + * Physical Maximum (9216), + * Input (Variable), + * Usage Page (Digitizer), ; Digitizer (0Dh) + * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) + * Logical Minimum (0), + * Logical Maximum (1023), + * Physical Minimum (0), + * Physical Maximum (1023), + * Input (Variable), + * End Collection, + * End Collection + */ + +/* Size of the original report descriptor of Q Pad */ +#define Q_PAD_RDESC_ORIG_SIZE 241 + +/* + * Fixed Q Pad descriptor. + * + * All the reports except the stylus report (ID 16) were removed as unused. + * The stylus buttons description was fixed. + */ +static __u8 q_pad_rdesc_fixed[] = { + 0x05, 0x0D, /* Usage Page (Digitizer), */ + 0x09, 0x02, /* Usage (Pen), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x10, /* Report ID (16), */ + 0x09, 0x20, /* Usage (Stylus), */ + 0xA0, /* Collection (Physical), */ + 0x09, 0x42, /* Usage (Tip Switch), */ + 0x09, 0x44, /* Usage (Barrel Switch), */ + 0x09, 0x46, /* Usage (Tablet Pick), */ + 0x15, 0x01, /* Logical Minimum (1), */ + 0x25, 0x03, /* Logical Maximum (3), */ + 0x75, 0x04, /* Report Size (4), */ + 0x95, 0x01, /* Report Count (1), */ + 0x80, /* Input, */ + 0x09, 0x32, /* Usage (In Range), */ + 0x14, /* Logical Minimum (0), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x75, 0x01, /* Report Size (1), */ + 0x95, 0x01, /* Report Count (1), */ + 0x81, 0x02, /* Input (Variable), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x03, /* Input (Constant, Variable), */ + 0x75, 0x10, /* Report Size (16), */ + 0x95, 0x01, /* Report Count (1), */ + 0x14, /* Logical Minimum (0), */ + 0xA4, /* Push, */ + 0x05, 0x01, /* Usage Page (Desktop), */ + 0x65, 0x13, /* Unit (Inch), */ + 0x55, 0xFD, /* Unit Exponent (-3), */ + 0x34, /* Physical Minimum (0), */ + 0x09, 0x30, /* Usage (X), */ + 0x46, 0x70, 0x17, /* Physical Maximum (6000), */ + 0x26, 0x00, 0x30, /* Logical Maximum (12288), */ + 0x81, 0x02, /* Input (Variable), */ + 0x09, 0x31, /* Usage (Y), */ + 0x46, 0x94, 0x11, /* Physical Maximum (4500), */ + 0x26, 0x00, 0x24, /* Logical Maximum (9216), */ + 0x81, 0x02, /* Input (Variable), */ + 0xB4, /* Pop, */ + 0x09, 0x30, /* Usage (Tip Pressure), */ + 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ + 0x81, 0x02, /* Input (Variable), */ + 0xC0, /* End Collection, */ + 0xC0 /* End Collection */ +}; + /* * Original Media Tablet 10.6 inch report descriptor. * @@ -1049,6 +1233,12 @@ static __u8 *waltop_report_fixup(struct hid_device *hdev, __u8 *rdesc, *rsize = sizeof(slim_tablet_12_1_inch_rdesc_fixed); } break; + case USB_DEVICE_ID_WALTOP_Q_PAD: + if (*rsize == Q_PAD_RDESC_ORIG_SIZE) { + rdesc = q_pad_rdesc_fixed; + *rsize = sizeof(q_pad_rdesc_fixed); + } + break; case USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH: if (*rsize == MEDIA_TABLET_10_6_INCH_RDESC_ORIG_SIZE) { rdesc = media_tablet_10_6_inch_rdesc_fixed; @@ -1070,6 +1260,8 @@ static const struct hid_device_id waltop_devices[] = { 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_Q_PAD) }, { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) }, { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, From 503f7d53b368c8e4e13a7756220c0536fcf1a034 Mon Sep 17 00:00:00 2001 From: Chase Douglas Date: Mon, 13 Feb 2012 20:12:31 -0800 Subject: [PATCH 12/42] HID: hid-magicmouse: Add pointer and buttonpad properties for Magic Trackpad Signed-off-by: Chase Douglas Signed-off-by: Jiri Kosina --- drivers/hid/hid-magicmouse.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c index 2ab71758e2e2..7cf3ffe4b7bc 100644 --- a/drivers/hid/hid-magicmouse.c +++ b/drivers/hid/hid-magicmouse.c @@ -418,6 +418,8 @@ static void magicmouse_setup_input(struct input_dev *input, struct hid_device *h __set_bit(BTN_TOOL_TRIPLETAP, input->keybit); __set_bit(BTN_TOOL_QUADTAP, input->keybit); __set_bit(BTN_TOUCH, input->keybit); + __set_bit(INPUT_PROP_POINTER, input->propbit); + __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); } if (report_touches) { From 2258e863b451be319d374f89688000ab858b13c3 Mon Sep 17 00:00:00 2001 From: Denis Kovalev Date: Tue, 14 Feb 2012 00:50:33 -0800 Subject: [PATCH 13/42] HID: multitouch: add support of Panasonic multitouch panels While at it, also fix some minor codingstyle issues. Signed-off-by: Denis Kovalev Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 1 + drivers/hid/hid-core.c | 2 ++ drivers/hid/hid-ids.h | 6 +++++- drivers/hid/hid-multitouch.c | 19 +++++++++++++++---- 4 files changed, 23 insertions(+), 5 deletions(-) diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index f7c43b6c3567..bfac1f79757f 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -354,6 +354,7 @@ config HID_MULTITOUCH - LG Display panels (Dell ST2220Tc) - Lumio CrystalTouch panels - MosArt dual-touch panels + - Panasonic multitouch panels - PenMount dual touch panels - Perixx Peripad 701 touchpad - PixArt optical touch screen diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index af08ce7207d9..bb710a6a079d 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1501,6 +1501,8 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) }, { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) }, { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) }, + { HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT780) }, + { HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT880) }, { 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) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 662a0b6a6642..12b6c49359c8 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -41,7 +41,7 @@ #define USB_VENDOR_ID_ACTIONSTAR 0x2101 #define USB_DEVICE_ID_ACTIONSTAR_1011 0x1011 -#define USB_VENDOR_ID_ADS_TECH 0x06e1 +#define USB_VENDOR_ID_ADS_TECH 0x06e1 #define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X 0xa155 #define USB_VENDOR_ID_AFATECH 0x15a4 @@ -565,6 +565,10 @@ #define USB_DEVICE_ID_ORTEK_PKB1700 0x1700 #define USB_DEVICE_ID_ORTEK_WKB2000 0x2000 +#define USB_VENDOR_ID_PANASONIC 0x04da +#define USB_DEVICE_ID_PANABOARD_UBT780 0x1044 +#define USB_DEVICE_ID_PANABOARD_UBT880 0x104d + #define USB_VENDOR_ID_PANJIT 0x134c #define USB_VENDOR_ID_PANTHERLORD 0x0810 diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 387a72fb1c84..09e42ef60d6e 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -104,6 +104,7 @@ struct mt_device { #define MT_CLS_EGALAX 0x0103 #define MT_CLS_EGALAX_SERIAL 0x0104 #define MT_CLS_TOPSEED 0x0105 +#define MT_CLS_PANASONIC 0x0106 #define MT_DEFAULT_MAXCONTACT 10 @@ -198,6 +199,9 @@ static struct mt_class mt_classes[] = { .is_indirect = true, .maxcontacts = 2, }, + { .name = MT_CLS_PANASONIC, + .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP, + .maxcontacts = 4 }, { } }; @@ -278,8 +282,8 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, int code; /* Only map fields from TouchScreen or TouchPad collections. - * We need to ignore fields that belong to other collections - * such as Mouse that might have the same GenericDesktop usages. */ + * We need to ignore fields that belong to other collections + * such as Mouse that might have the same GenericDesktop usages. */ if (field->application == HID_DG_TOUCHSCREEN) set_bit(INPUT_PROP_DIRECT, hi->input->propbit); else if (field->application != HID_DG_TOUCHPAD) @@ -581,9 +585,8 @@ static int mt_event(struct hid_device *hid, struct hid_field *field, return 0; } - if (usage->hid == td->last_slot_field) { + if (usage->hid == td->last_slot_field) mt_complete_slot(td); - } if (field->index == td->last_field_index && td->num_received >= td->num_expected) @@ -857,6 +860,14 @@ static const struct hid_device_id mt_devices[] = { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) }, + /* Panasonic panels */ + { .driver_data = MT_CLS_PANASONIC, + HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, + USB_DEVICE_ID_PANABOARD_UBT780) }, + { .driver_data = MT_CLS_PANASONIC, + HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, + USB_DEVICE_ID_PANABOARD_UBT880) }, + /* PenMount panels */ { .driver_data = MT_CLS_CONFIDENCE, HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, From 724ed328a18139a7b6fb15536f5afbf9e27b49b2 Mon Sep 17 00:00:00 2001 From: Ville Ranki Date: Tue, 14 Feb 2012 17:42:20 +0200 Subject: [PATCH 14/42] HID: Add quirk for CH Products Fighterstick CH Fighterstick requires HID_QUIRK_NOGET as many other CH devices do. This patch adds device id for Fighterstick and adds necessary line to HID quirk list. Signed-off-by: Ville Ranki Signed-off-by: Jiri Kosina --- drivers/hid/hid-ids.h | 1 + drivers/hid/usbhid/hid-quirks.c | 1 + 2 files changed, 2 insertions(+) diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 1a002201516e..526a8b276338 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -173,6 +173,7 @@ #define USB_VENDOR_ID_CH 0x068e #define USB_DEVICE_ID_CH_PRO_THROTTLE 0x00f1 #define USB_DEVICE_ID_CH_PRO_PEDALS 0x00f2 +#define USB_DEVICE_ID_CH_FIGHTERSTICK 0x00f3 #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 diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c index c831af937481..ae7d28321dc3 100644 --- a/drivers/hid/usbhid/hid-quirks.c +++ b/drivers/hid/usbhid/hid-quirks.c @@ -59,6 +59,7 @@ static const struct hid_blacklist { { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET }, { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET }, { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET }, + { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FIGHTERSTICK, HID_QUIRK_NOGET }, { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_COMBATSTICK, HID_QUIRK_NOGET }, { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE, HID_QUIRK_NOGET }, { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE, HID_QUIRK_NOGET }, From a72c5ddb675f2f0a2fa857f75286d50b7a0c0ba5 Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Fri, 17 Feb 2012 17:47:10 +0000 Subject: [PATCH 15/42] HID: wacom: Force new name for Wacom Intuos4 WL PTK-540WL The name reported by Inutos4 WL connected by bluetooth is "PTK-540WL" and to make it consistent with other Wacom devices it has to be converted to "Wacom Intuos4 WL". It also makes userland applications aware that it's a Wacom device. This aligns naming of device to same used when this device is plugged into USB port and controlled by USB wacom driver; and thus helps align userland logic to route to apps like xf86-input-wacom. Signed-off-by: Przemo Firszt Reviewed-by: Chris Bagwell Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index f2183486a9b6..2d4812e3dbea 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -510,6 +510,7 @@ static int wacom_probe(struct hid_device *hdev, wacom_poke(hdev, 1); break; case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH: + sprintf(hdev->name, "%s", "Wacom Intuos4 WL"); wdata->features = 0; wacom_set_features(hdev); break; From 42fc04e5f8190a6cae7aa5bf5b64fb5bc32a034f Mon Sep 17 00:00:00 2001 From: Sean Young Date: Sat, 18 Feb 2012 12:53:44 +0000 Subject: [PATCH 16/42] HID: sjoy: Add device ID for Super Joy Box 3 Also correct the quirks for the Super Joy Box 3 Pro and Super Dual Box. Signed-off-by: Sean Young Signed-off-by: Jiri Kosina --- drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 1 + drivers/hid/hid-sjoy.c | 6 ++++-- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index 162be0955df0..e89e4c7360c6 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1550,6 +1550,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) }, { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) }, { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) }, + { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) }, { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) }, { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) }, { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 526a8b276338..6de95422586a 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -717,6 +717,7 @@ #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_SUPER_JOY_BOX_3 0x8888 #define USB_DEVICE_ID_QUAD_USB_JOYPAD 0x8800 #define USB_DEVICE_ID_DUAL_USB_JOYPAD 0x8866 diff --git a/drivers/hid/hid-sjoy.c b/drivers/hid/hid-sjoy.c index 4b1448613ea6..42257acfeb73 100644 --- a/drivers/hid/hid-sjoy.c +++ b/drivers/hid/hid-sjoy.c @@ -155,7 +155,8 @@ err: } static const struct hid_device_id sjoy_devices[] = { - { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) }, + { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO), + .driver_data = HID_QUIRK_NOGET }, { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO), .driver_data = HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET | HID_QUIRK_SKIP_OUTPUT_REPORTS }, @@ -163,8 +164,9 @@ static const struct hid_device_id sjoy_devices[] = { .driver_data = HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET | HID_QUIRK_SKIP_OUTPUT_REPORTS }, { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) }, + { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) }, { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD), - .driver_data = HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET | + .driver_data = HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS }, { } }; From 32db737fb2bfe9013362c9dc2c7af998edc758be Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Sun, 19 Feb 2012 20:20:29 +0000 Subject: [PATCH 17/42] HID: wacom: fix proximity tool release Don't zero the current tool before reporting its release to the input subsystem. Signed-off-by: Aristeu Rozanski Tested-by: Przemo Firszt Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index acab74cde727..8b4922924142 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -322,10 +322,10 @@ static void wacom_i4_parse_pen_report(struct wacom_data *wdata, switch (data[1]) { case 0x80: /* Out of proximity report */ - wdata->tool = 0; input_report_key(input, BTN_TOUCH, 0); input_report_abs(input, ABS_PRESSURE, 0); input_report_key(input, wdata->tool, 0); + wdata->tool = 0; input_sync(input); break; case 0xC2: /* Tool report */ From 0944e964b23baee17d40abbd314695289380c2fd Mon Sep 17 00:00:00 2001 From: Konstantin Khlebnikov Date: Mon, 13 Feb 2012 14:13:03 +0400 Subject: [PATCH 18/42] HID: use generic driver for Logitech Unifying receivers if !CONFIG_HID_LOGITECH_DJ Before commit 534a7b8e1 ("HID: Add full support for Logitech Unifying receivers") Logitech Unifying receiver can work as generic device without special driver, after that commit these devices does not works without special driver. After this patch they will use generic driver if special driver is disabled. Signed-off-by: Konstantin Khlebnikov Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 4 +++- drivers/hid/hid-core.c | 2 ++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index 0a55866f1f74..1e6b78ed5ac9 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -257,7 +257,9 @@ config HID_LOGITECH_DJ ---help--- Say Y if you want support for Logitech Unifying receivers and devices. Unifying receivers are capable of pairing up to 6 Logitech compliant - devices to the same receiver. + devices to the same receiver. Without this driver it will be handled by + generic USB_HID driver and all incomming events will be multiplexed + into a single mouse and a single keyboard device. config LOGITECH_FF bool "Logitech force feedback support" diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index e89e4c7360c6..549c7538e57f 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1463,8 +1463,10 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) }, +#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ) { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) }, +#endif { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) }, From 1e93674a8ea169320950c5e6d1fa29a20b534e60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20H=C3=BCbner?= Date: Wed, 22 Feb 2012 02:10:06 +0100 Subject: [PATCH 19/42] HID: add new driver for non-compliant Saitek devices MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The driver currently only supports the PS1000 controller. It fixes the report descriptor by removing a non-existing axis and clearing the constant bit on the d-pad and button input reports. Signed-off-by: Andreas Hübner Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 9 ++++++ drivers/hid/Makefile | 1 + drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 1 + drivers/hid/hid-saitek.c | 70 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 82 insertions(+) create mode 100644 drivers/hid/hid-saitek.c diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index 1e6b78ed5ac9..9398cfce80b6 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -532,6 +532,15 @@ config HID_ROCCAT_PYRA ---help--- Support for Roccat Pyra mouse. +config HID_SAITEK + tristate "Saitek non-fully HID-compliant devices" + depends on USB_HID + ---help--- + Support for Saitek devices that are not fully compliant with the + HID standard. + + Currently only supports the PS1000 controller. + config HID_SAMSUNG tristate "Samsung InfraRed remote control or keyboards" depends on USB_HID diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile index c05f448f34a0..524532b49eaa 100644 --- a/drivers/hid/Makefile +++ b/drivers/hid/Makefile @@ -72,6 +72,7 @@ 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 obj-$(CONFIG_HID_ROCCAT_PYRA) += hid-roccat-pyra.o +obj-$(CONFIG_HID_SAITEK) += hid-saitek.o obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o obj-$(CONFIG_HID_SONY) += hid-sony.o diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index 549c7538e57f..58d8f50649eb 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1519,6 +1519,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { 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_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) }, + { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) }, { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) }, { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) }, { HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 6de95422586a..bc6e2b5862aa 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -615,6 +615,7 @@ #define USB_VENDOR_ID_SAITEK 0x06a3 #define USB_DEVICE_ID_SAITEK_RUMBLEPAD 0xff17 +#define USB_DEVICE_ID_SAITEK_PS1000 0xff17 #define USB_VENDOR_ID_SAMSUNG 0x0419 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001 diff --git a/drivers/hid/hid-saitek.c b/drivers/hid/hid-saitek.c new file mode 100644 index 000000000000..45aea77bb611 --- /dev/null +++ b/drivers/hid/hid-saitek.c @@ -0,0 +1,70 @@ +/* + * HID driver for Saitek devices, currently only the PS1000 (USB gamepad). + * Fixes the HID report descriptor by removing a non-existent axis and + * clearing the constant bit on the input reports for buttons and d-pad. + * (This module is based on "hid-ortek".) + * + * Copyright (c) 2012 Andreas Hübner + */ + +/* + * 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 +#include +#include +#include + +#include "hid-ids.h" + +static __u8 *saitek_report_fixup(struct hid_device *hdev, __u8 *rdesc, + unsigned int *rsize) +{ + if (*rsize == 137 && rdesc[20] == 0x09 && rdesc[21] == 0x33 + && rdesc[94] == 0x81 && rdesc[95] == 0x03 + && rdesc[110] == 0x81 && rdesc[111] == 0x03) { + + hid_info(hdev, "Fixing up Saitek PS1000 report descriptor\n"); + + /* convert spurious axis to a "noop" Logical Minimum (0) */ + rdesc[20] = 0x15; + rdesc[21] = 0x00; + + /* clear constant bit on buttons and d-pad */ + rdesc[95] = 0x02; + rdesc[111] = 0x02; + + } + return rdesc; +} + +static const struct hid_device_id saitek_devices[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000)}, + { } +}; + +MODULE_DEVICE_TABLE(hid, saitek_devices); + +static struct hid_driver saitek_driver = { + .name = "saitek", + .id_table = saitek_devices, + .report_fixup = saitek_report_fixup +}; + +static int __init saitek_init(void) +{ + return hid_register_driver(&saitek_driver); +} + +static void __exit saitek_exit(void) +{ + hid_unregister_driver(&saitek_driver); +} + +module_init(saitek_init); +module_exit(saitek_exit); +MODULE_LICENSE("GPL"); From c7fd7937ba81d1e46b4c4cc3dd06010834b08b98 Mon Sep 17 00:00:00 2001 From: Jiri Kosina Date: Wed, 22 Feb 2012 18:33:43 +0100 Subject: [PATCH 20/42] HID: correct PID for saitek PS1000 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reported-by: Andreas Hübner Signed-off-by: Jiri Kosina --- drivers/hid/hid-ids.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index bc6e2b5862aa..30d1f7ba2723 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -615,7 +615,7 @@ #define USB_VENDOR_ID_SAITEK 0x06a3 #define USB_DEVICE_ID_SAITEK_RUMBLEPAD 0xff17 -#define USB_DEVICE_ID_SAITEK_PS1000 0xff17 +#define USB_DEVICE_ID_SAITEK_PS1000 0x0621 #define USB_VENDOR_ID_SAMSUNG 0x0419 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001 From 2c653e6bac85918ae76ed0199f25fb6a2206b92d Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Fri, 24 Feb 2012 13:47:48 +0000 Subject: [PATCH 21/42] HID: wacom: set ABS_MISC bit for Intuos4 WL ABS_MISC has to be set for Intuos4 WL otherwise xorg driver won't use proper protocol and the information about tool id and serial is lost. Signed-off-by: Przemo Firszt Reviewed-by: Chris Bagwell Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index 8b4922924142..c4a193b6c44e 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -471,6 +471,7 @@ static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi, input_set_abs_params(input, ABS_DISTANCE, 0, 32, 0, 0); break; case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH: + __set_bit(ABS_MISC, input->absbit); input_set_abs_params(input, ABS_X, 0, 40640, 4, 0); input_set_abs_params(input, ABS_Y, 0, 25400, 4, 0); input_set_abs_params(input, ABS_PRESSURE, 0, 2047, 0, 0); From 2470900b68ccfde046d5a20c47ae9abb4e406084 Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Fri, 24 Feb 2012 13:52:32 +0000 Subject: [PATCH 22/42] HID: wacom: Add serial and id reporting for Wacom Intuos4 WL This patch implements reporting id and serial number of used tool. Reported values are the same as for USB on of the driver for wacom Intuos4 WL Signed-off-by: Przemo Firszt Reviewed-by: Chris Bagwell Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index c4a193b6c44e..a3476f9a5103 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -35,6 +35,8 @@ struct wacom_data { __u16 tool; unsigned char butstate; __u8 features; + __u32 id; + __u32 serial; unsigned char high_speed; #ifdef CONFIG_HID_WACOM_POWER_SUPPLY int battery_capacity; @@ -318,26 +320,30 @@ static void wacom_i4_parse_pen_report(struct wacom_data *wdata, struct input_dev *input, unsigned char *data) { __u16 x, y, pressure; - __u32 id; switch (data[1]) { case 0x80: /* Out of proximity report */ input_report_key(input, BTN_TOUCH, 0); input_report_abs(input, ABS_PRESSURE, 0); input_report_key(input, wdata->tool, 0); + input_report_abs(input, ABS_MISC, 0); + input_event(input, EV_MSC, MSC_SERIAL, wdata->serial); wdata->tool = 0; input_sync(input); break; case 0xC2: /* Tool report */ - id = ((data[2] << 4) | (data[3] >> 4) | + wdata->id = ((data[2] << 4) | (data[3] >> 4) | ((data[7] & 0x0f) << 20) | - ((data[8] & 0xf0) << 12)) & 0xfffff; + ((data[8] & 0xf0) << 12)); + wdata->serial = ((data[3] & 0x0f) << 28) + + (data[4] << 20) + (data[5] << 12) + + (data[6] << 4) + (data[7] >> 4); - switch (id) { - case 0x802: + switch (wdata->id) { + case 0x100802: wdata->tool = BTN_TOOL_PEN; break; - case 0x80A: + case 0x10080A: wdata->tool = BTN_TOOL_RUBBER; break; } @@ -356,6 +362,9 @@ static void wacom_i4_parse_pen_report(struct wacom_data *wdata, input_report_abs(input, ABS_X, x); input_report_abs(input, ABS_Y, y); input_report_abs(input, ABS_PRESSURE, pressure); + input_report_abs(input, ABS_MISC, wdata->id); + input_event(input, EV_MSC, MSC_SERIAL, wdata->serial); + input_report_key(input, wdata->tool, 1); input_sync(input); break; } From 22ca20b250f5c9672a53b34f032f43dd2c4a4aaf Mon Sep 17 00:00:00 2001 From: Nikolai Kondrashov Date: Tue, 28 Feb 2012 13:01:46 +0200 Subject: [PATCH 23/42] HID: kye: Add support for 3 tablets Add support for three KYE tablets: EasyPen i405X, MousePen i608X, EasyPen M610X. Update Kconfig entry accordingly, remove EXPERT dependency. Signed-off-by: Nikolai Kondrashov Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 9 +- drivers/hid/hid-core.c | 3 + drivers/hid/hid-ids.h | 3 + drivers/hid/hid-kye.c | 399 ++++++++++++++++++++++++++++++-- drivers/hid/usbhid/hid-quirks.c | 2 + 5 files changed, 396 insertions(+), 20 deletions(-) diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index 9398cfce80b6..838fa6a3a287 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -200,11 +200,14 @@ config HID_KEYTOUCH - Keytouch IEC 60945 config HID_KYE - tristate "Kye/Genius Ergo Mouse" if EXPERT + tristate "KYE/Genius devices" depends on USB_HID - default !EXPERT ---help--- - Support for Kye/Genius Ergo Mouse. + Support for KYE/Genius devices not fully compliant with HID standard: + - Ergo Mouse + - EasyPen i405X tablet + - MousePen i608X tablet + - EasyPen M610X tablet config HID_UCLOGIC tristate "UC-Logic" diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index 58d8f50649eb..ed96333af745 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1436,6 +1436,9 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) }, { HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) }, { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) }, { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) }, { HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) }, { HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MULTITOUCH) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 30d1f7ba2723..6e119a3a755e 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -407,6 +407,9 @@ #define USB_VENDOR_ID_KYE 0x0458 #define USB_DEVICE_ID_KYE_ERGO_525V 0x0087 #define USB_DEVICE_ID_KYE_GPEN_560 0x5003 +#define USB_DEVICE_ID_KYE_EASYPEN_I405X 0x5010 +#define USB_DEVICE_ID_KYE_MOUSEPEN_I608X 0x5011 +#define USB_DEVICE_ID_KYE_EASYPEN_M610X 0x5013 #define USB_VENDOR_ID_LABTEC 0x1020 #define USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD 0x0006 diff --git a/drivers/hid/hid-kye.c b/drivers/hid/hid-kye.c index f2ba9efc3a53..b4f0d8216fd0 100644 --- a/drivers/hid/hid-kye.c +++ b/drivers/hid/hid-kye.c @@ -3,6 +3,7 @@ * * Copyright (c) 2009 Jiri Kosina * Copyright (c) 2009 Tomas Hanak + * Copyright (c) 2012 Nikolai Kondrashov */ /* @@ -15,36 +16,399 @@ #include #include #include +#include +#include "usbhid/usbhid.h" #include "hid-ids.h" -/* the fixups that need to be done: - * - change led usage page to button for extra buttons - * - report size 8 count 1 must be size 1 count 8 for button bitfield - * - change the button usage range to 4-7 for the extra buttons +/* + * See EasyPen i405X description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=KYE_EasyPen_i405X */ + +/* Original EasyPen i405X report descriptor size */ +#define EASYPEN_I405X_RDESC_ORIG_SIZE 476 + +/* Fixed EasyPen i405X report descriptor */ +static __u8 easypen_i405x_rdesc_fixed[] = { + 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ + 0x09, 0x01, /* Usage (01h), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x05, /* Report ID (5), */ + 0x09, 0x01, /* Usage (01h), */ + 0x15, 0x80, /* Logical Minimum (-128), */ + 0x25, 0x7F, /* Logical Maximum (127), */ + 0x75, 0x08, /* Report Size (8), */ + 0x95, 0x07, /* Report Count (7), */ + 0xB1, 0x02, /* Feature (Variable), */ + 0xC0, /* End Collection, */ + 0x05, 0x0D, /* Usage Page (Digitizer), */ + 0x09, 0x02, /* Usage (Pen), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x10, /* Report ID (16), */ + 0x09, 0x20, /* Usage (Stylus), */ + 0xA0, /* Collection (Physical), */ + 0x14, /* Logical Minimum (0), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x75, 0x01, /* Report Size (1), */ + 0x09, 0x42, /* Usage (Tip Switch), */ + 0x09, 0x44, /* Usage (Barrel Switch), */ + 0x09, 0x46, /* Usage (Tablet Pick), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x02, /* Input (Variable), */ + 0x95, 0x04, /* Report Count (4), */ + 0x81, 0x03, /* Input (Constant, Variable), */ + 0x09, 0x32, /* Usage (In Range), */ + 0x95, 0x01, /* Report Count (1), */ + 0x81, 0x02, /* Input (Variable), */ + 0x75, 0x10, /* Report Size (16), */ + 0x95, 0x01, /* Report Count (1), */ + 0xA4, /* Push, */ + 0x05, 0x01, /* Usage Page (Desktop), */ + 0x55, 0xFD, /* Unit Exponent (-3), */ + 0x65, 0x13, /* Unit (Inch), */ + 0x34, /* Physical Minimum (0), */ + 0x09, 0x30, /* Usage (X), */ + 0x46, 0x7C, 0x15, /* Physical Maximum (5500), */ + 0x26, 0x00, 0x37, /* Logical Maximum (14080), */ + 0x81, 0x02, /* Input (Variable), */ + 0x09, 0x31, /* Usage (Y), */ + 0x46, 0xA0, 0x0F, /* Physical Maximum (4000), */ + 0x26, 0x00, 0x28, /* Logical Maximum (10240), */ + 0x81, 0x02, /* Input (Variable), */ + 0xB4, /* Pop, */ + 0x09, 0x30, /* Usage (Tip Pressure), */ + 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ + 0x81, 0x02, /* Input (Variable), */ + 0xC0, /* End Collection, */ + 0xC0 /* End Collection */ +}; + +/* + * See MousePen i608X description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=KYE_MousePen_i608X + */ + +/* Original MousePen i608X report descriptor size */ +#define MOUSEPEN_I608X_RDESC_ORIG_SIZE 476 + +/* Fixed MousePen i608X report descriptor */ +static __u8 mousepen_i608x_rdesc_fixed[] = { + 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ + 0x09, 0x01, /* Usage (01h), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x05, /* Report ID (5), */ + 0x09, 0x01, /* Usage (01h), */ + 0x15, 0x80, /* Logical Minimum (-128), */ + 0x25, 0x7F, /* Logical Maximum (127), */ + 0x75, 0x08, /* Report Size (8), */ + 0x95, 0x07, /* Report Count (7), */ + 0xB1, 0x02, /* Feature (Variable), */ + 0xC0, /* End Collection, */ + 0x05, 0x0D, /* Usage Page (Digitizer), */ + 0x09, 0x02, /* Usage (Pen), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x10, /* Report ID (16), */ + 0x09, 0x20, /* Usage (Stylus), */ + 0xA0, /* Collection (Physical), */ + 0x14, /* Logical Minimum (0), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x75, 0x01, /* Report Size (1), */ + 0x09, 0x42, /* Usage (Tip Switch), */ + 0x09, 0x44, /* Usage (Barrel Switch), */ + 0x09, 0x46, /* Usage (Tablet Pick), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x02, /* Input (Variable), */ + 0x95, 0x04, /* Report Count (4), */ + 0x81, 0x03, /* Input (Constant, Variable), */ + 0x09, 0x32, /* Usage (In Range), */ + 0x95, 0x01, /* Report Count (1), */ + 0x81, 0x02, /* Input (Variable), */ + 0x75, 0x10, /* Report Size (16), */ + 0x95, 0x01, /* Report Count (1), */ + 0xA4, /* Push, */ + 0x05, 0x01, /* Usage Page (Desktop), */ + 0x55, 0xFD, /* Unit Exponent (-3), */ + 0x65, 0x13, /* Unit (Inch), */ + 0x34, /* Physical Minimum (0), */ + 0x09, 0x30, /* Usage (X), */ + 0x46, 0x40, 0x1F, /* Physical Maximum (8000), */ + 0x26, 0x00, 0x50, /* Logical Maximum (20480), */ + 0x81, 0x02, /* Input (Variable), */ + 0x09, 0x31, /* Usage (Y), */ + 0x46, 0x70, 0x17, /* Physical Maximum (6000), */ + 0x26, 0x00, 0x3C, /* Logical Maximum (15360), */ + 0x81, 0x02, /* Input (Variable), */ + 0xB4, /* Pop, */ + 0x09, 0x30, /* Usage (Tip Pressure), */ + 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ + 0x81, 0x02, /* Input (Variable), */ + 0xC0, /* End Collection, */ + 0xC0, /* End Collection, */ + 0x05, 0x01, /* Usage Page (Desktop), */ + 0x09, 0x02, /* Usage (Mouse), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x11, /* Report ID (17), */ + 0x09, 0x01, /* Usage (Pointer), */ + 0xA0, /* Collection (Physical), */ + 0x14, /* Logical Minimum (0), */ + 0xA4, /* Push, */ + 0x05, 0x09, /* Usage Page (Button), */ + 0x75, 0x01, /* Report Size (1), */ + 0x19, 0x01, /* Usage Minimum (01h), */ + 0x29, 0x03, /* Usage Maximum (03h), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x02, /* Input (Variable), */ + 0x95, 0x05, /* Report Count (5), */ + 0x81, 0x01, /* Input (Constant), */ + 0xB4, /* Pop, */ + 0x95, 0x01, /* Report Count (1), */ + 0xA4, /* Push, */ + 0x55, 0xFD, /* Unit Exponent (-3), */ + 0x65, 0x13, /* Unit (Inch), */ + 0x34, /* Physical Minimum (0), */ + 0x75, 0x10, /* Report Size (16), */ + 0x09, 0x30, /* Usage (X), */ + 0x46, 0x40, 0x1F, /* Physical Maximum (8000), */ + 0x26, 0x00, 0x50, /* Logical Maximum (20480), */ + 0x81, 0x02, /* Input (Variable), */ + 0x09, 0x31, /* Usage (Y), */ + 0x46, 0x70, 0x17, /* Physical Maximum (6000), */ + 0x26, 0x00, 0x3C, /* Logical Maximum (15360), */ + 0x81, 0x02, /* Input (Variable), */ + 0xB4, /* Pop, */ + 0x75, 0x08, /* Report Size (8), */ + 0x09, 0x38, /* Usage (Wheel), */ + 0x15, 0xFF, /* Logical Minimum (-1), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x81, 0x06, /* Input (Variable, Relative), */ + 0x81, 0x01, /* Input (Constant), */ + 0xC0, /* End Collection, */ + 0xC0 /* End Collection */ +}; + +/* + * See EasyPen M610X description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=KYE_EasyPen_M610X + */ + +/* Original EasyPen M610X report descriptor size */ +#define EASYPEN_M610X_RDESC_ORIG_SIZE 476 + +/* Fixed EasyPen M610X report descriptor */ +static __u8 easypen_m610x_rdesc_fixed[] = { + 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */ + 0x09, 0x01, /* Usage (01h), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x05, /* Report ID (5), */ + 0x09, 0x01, /* Usage (01h), */ + 0x15, 0x80, /* Logical Minimum (-128), */ + 0x25, 0x7F, /* Logical Maximum (127), */ + 0x75, 0x08, /* Report Size (8), */ + 0x95, 0x07, /* Report Count (7), */ + 0xB1, 0x02, /* Feature (Variable), */ + 0xC0, /* End Collection, */ + 0x05, 0x0D, /* Usage Page (Digitizer), */ + 0x09, 0x02, /* Usage (Pen), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x10, /* Report ID (16), */ + 0x09, 0x20, /* Usage (Stylus), */ + 0xA0, /* Collection (Physical), */ + 0x14, /* Logical Minimum (0), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x75, 0x01, /* Report Size (1), */ + 0x09, 0x42, /* Usage (Tip Switch), */ + 0x09, 0x44, /* Usage (Barrel Switch), */ + 0x09, 0x46, /* Usage (Tablet Pick), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x02, /* Input (Variable), */ + 0x95, 0x04, /* Report Count (4), */ + 0x81, 0x03, /* Input (Constant, Variable), */ + 0x09, 0x32, /* Usage (In Range), */ + 0x95, 0x01, /* Report Count (1), */ + 0x81, 0x02, /* Input (Variable), */ + 0x75, 0x10, /* Report Size (16), */ + 0x95, 0x01, /* Report Count (1), */ + 0xA4, /* Push, */ + 0x05, 0x01, /* Usage Page (Desktop), */ + 0x55, 0xFD, /* Unit Exponent (-3), */ + 0x65, 0x13, /* Unit (Inch), */ + 0x34, /* Physical Minimum (0), */ + 0x09, 0x30, /* Usage (X), */ + 0x46, 0x10, 0x27, /* Physical Maximum (10000), */ + 0x27, 0x00, 0xA0, 0x00, 0x00, /* Logical Maximum (40960), */ + 0x81, 0x02, /* Input (Variable), */ + 0x09, 0x31, /* Usage (Y), */ + 0x46, 0x6A, 0x18, /* Physical Maximum (6250), */ + 0x26, 0x00, 0x64, /* Logical Maximum (25600), */ + 0x81, 0x02, /* Input (Variable), */ + 0xB4, /* Pop, */ + 0x09, 0x30, /* Usage (Tip Pressure), */ + 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ + 0x81, 0x02, /* Input (Variable), */ + 0xC0, /* End Collection, */ + 0xC0, /* End Collection, */ + 0x05, 0x0C, /* Usage Page (Consumer), */ + 0x09, 0x01, /* Usage (Consumer Control), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x12, /* Report ID (18), */ + 0x14, /* Logical Minimum (0), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x75, 0x01, /* Report Size (1), */ + 0x95, 0x04, /* Report Count (4), */ + 0x0A, 0x1A, 0x02, /* Usage (AC Undo), */ + 0x0A, 0x79, 0x02, /* Usage (AC Redo Or Repeat), */ + 0x0A, 0x2D, 0x02, /* Usage (AC Zoom In), */ + 0x0A, 0x2E, 0x02, /* Usage (AC Zoom Out), */ + 0x81, 0x02, /* Input (Variable), */ + 0x95, 0x01, /* Report Count (1), */ + 0x75, 0x14, /* Report Size (20), */ + 0x81, 0x03, /* Input (Constant, Variable), */ + 0x75, 0x20, /* Report Size (32), */ + 0x81, 0x03, /* Input (Constant, Variable), */ + 0xC0 /* End Collection */ +}; + static __u8 *kye_report_fixup(struct hid_device *hdev, __u8 *rdesc, unsigned int *rsize) { - if (*rsize >= 74 && - rdesc[61] == 0x05 && rdesc[62] == 0x08 && - rdesc[63] == 0x19 && rdesc[64] == 0x08 && - rdesc[65] == 0x29 && rdesc[66] == 0x0f && - rdesc[71] == 0x75 && rdesc[72] == 0x08 && - rdesc[73] == 0x95 && rdesc[74] == 0x01) { - hid_info(hdev, - "fixing up Kye/Genius Ergo Mouse report descriptor\n"); - rdesc[62] = 0x09; - rdesc[64] = 0x04; - rdesc[66] = 0x07; - rdesc[72] = 0x01; - rdesc[74] = 0x08; + switch (hdev->product) { + case USB_DEVICE_ID_KYE_ERGO_525V: + /* the fixups that need to be done: + * - change led usage page to button for extra buttons + * - report size 8 count 1 must be size 1 count 8 for button + * bitfield + * - change the button usage range to 4-7 for the extra + * buttons + */ + if (*rsize >= 74 && + rdesc[61] == 0x05 && rdesc[62] == 0x08 && + rdesc[63] == 0x19 && rdesc[64] == 0x08 && + rdesc[65] == 0x29 && rdesc[66] == 0x0f && + rdesc[71] == 0x75 && rdesc[72] == 0x08 && + rdesc[73] == 0x95 && rdesc[74] == 0x01) { + hid_info(hdev, + "fixing up Kye/Genius Ergo Mouse " + "report descriptor\n"); + rdesc[62] = 0x09; + rdesc[64] = 0x04; + rdesc[66] = 0x07; + rdesc[72] = 0x01; + rdesc[74] = 0x08; + } + break; + case USB_DEVICE_ID_KYE_EASYPEN_I405X: + if (*rsize == EASYPEN_I405X_RDESC_ORIG_SIZE) { + rdesc = easypen_i405x_rdesc_fixed; + *rsize = sizeof(easypen_i405x_rdesc_fixed); + } + break; + case USB_DEVICE_ID_KYE_MOUSEPEN_I608X: + if (*rsize == MOUSEPEN_I608X_RDESC_ORIG_SIZE) { + rdesc = mousepen_i608x_rdesc_fixed; + *rsize = sizeof(mousepen_i608x_rdesc_fixed); + } + break; + case USB_DEVICE_ID_KYE_EASYPEN_M610X: + if (*rsize == EASYPEN_M610X_RDESC_ORIG_SIZE) { + rdesc = easypen_m610x_rdesc_fixed; + *rsize = sizeof(easypen_m610x_rdesc_fixed); + } + break; } return rdesc; } +/** + * Enable fully-functional tablet mode by setting a special feature report. + * + * @hdev: HID device + * + * The specific report ID and data were discovered by sniffing the + * Windows driver traffic. + */ +static int kye_tablet_enable(struct hid_device *hdev) +{ + struct list_head *list; + struct list_head *head; + struct hid_report *report; + __s32 *value; + + list = &hdev->report_enum[HID_FEATURE_REPORT].report_list; + list_for_each(head, list) { + report = list_entry(head, struct hid_report, list); + if (report->id == 5) + break; + } + + if (head == list) { + hid_err(hdev, "tablet-enabling feature report not found\n"); + return -ENODEV; + } + + if (report->maxfield < 1 || report->field[0]->report_count < 7) { + hid_err(hdev, "invalid tablet-enabling feature report\n"); + return -ENODEV; + } + + value = report->field[0]->value; + + value[0] = 0x12; + value[1] = 0x10; + value[2] = 0x11; + value[3] = 0x12; + value[4] = 0x00; + value[5] = 0x00; + value[6] = 0x00; + usbhid_submit_report(hdev, report, USB_DIR_OUT); + + return 0; +} + +static int kye_probe(struct hid_device *hdev, const struct hid_device_id *id) +{ + int ret; + + ret = hid_parse(hdev); + if (ret) { + hid_err(hdev, "parse failed\n"); + goto err; + } + + ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); + if (ret) { + hid_err(hdev, "hw start failed\n"); + goto err; + } + + switch (id->product) { + case USB_DEVICE_ID_KYE_EASYPEN_I405X: + case USB_DEVICE_ID_KYE_MOUSEPEN_I608X: + case USB_DEVICE_ID_KYE_EASYPEN_M610X: + ret = kye_tablet_enable(hdev); + if (ret) { + hid_err(hdev, "tablet enabling failed\n"); + goto enabling_err; + } + break; + } + + return 0; +enabling_err: + hid_hw_stop(hdev); +err: + return ret; +} + static const struct hid_device_id kye_devices[] = { { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, + USB_DEVICE_ID_KYE_EASYPEN_I405X) }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, + USB_DEVICE_ID_KYE_MOUSEPEN_I608X) }, + { HID_USB_DEVICE(USB_VENDOR_ID_KYE, + USB_DEVICE_ID_KYE_EASYPEN_M610X) }, { } }; MODULE_DEVICE_TABLE(hid, kye_devices); @@ -52,6 +416,7 @@ MODULE_DEVICE_TABLE(hid, kye_devices); static struct hid_driver kye_driver = { .name = "kye", .id_table = kye_devices, + .probe = kye_probe, .report_fixup = kye_report_fixup, }; diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c index ae7d28321dc3..3cfea61e9792 100644 --- a/drivers/hid/usbhid/hid-quirks.c +++ b/drivers/hid/usbhid/hid-quirks.c @@ -95,6 +95,8 @@ static const struct hid_blacklist { { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_MULTI_TOUCH, HID_QUIRK_MULTI_INPUT }, { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS, HID_QUIRK_MULTI_INPUT }, { USB_VENDOR_ID_SIGMA_MICRO, USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD, HID_QUIRK_NO_INIT_REPORTS }, + { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X, HID_QUIRK_MULTI_INPUT }, + { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X, HID_QUIRK_MULTI_INPUT }, { 0, 0 } }; From e0829e9c1e6981450f11204a4104646ed0f6907a Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Tue, 28 Feb 2012 17:19:04 +0000 Subject: [PATCH 24/42] HID: wacom: report distance for Intuos4 WL This patch adds reporting of distance of tool to the tablet surface. Maximum reported value is 63 (0x3F). Signed-off-by: Przemo Firszt Acked-by: Peter Hutterer Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index a3476f9a5103..5a58db2440fa 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -320,6 +320,7 @@ static void wacom_i4_parse_pen_report(struct wacom_data *wdata, struct input_dev *input, unsigned char *data) { __u16 x, y, pressure; + __u8 distance; switch (data[1]) { case 0x80: /* Out of proximity report */ @@ -353,6 +354,7 @@ static void wacom_i4_parse_pen_report(struct wacom_data *wdata, y = data[4] << 9 | data[5] << 1 | (data[9] & 0x01); pressure = (data[6] << 3) | ((data[7] & 0xC0) >> 5) | (data[1] & 0x01); + distance = (data[9] >> 2) & 0x3f; input_report_key(input, BTN_TOUCH, pressure > 1); @@ -362,6 +364,7 @@ static void wacom_i4_parse_pen_report(struct wacom_data *wdata, input_report_abs(input, ABS_X, x); input_report_abs(input, ABS_Y, y); input_report_abs(input, ABS_PRESSURE, pressure); + input_report_abs(input, ABS_DISTANCE, distance); input_report_abs(input, ABS_MISC, wdata->id); input_event(input, EV_MSC, MSC_SERIAL, wdata->serial); input_report_key(input, wdata->tool, 1); @@ -484,6 +487,7 @@ static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi, input_set_abs_params(input, ABS_X, 0, 40640, 4, 0); input_set_abs_params(input, ABS_Y, 0, 25400, 4, 0); input_set_abs_params(input, ABS_PRESSURE, 0, 2047, 0, 0); + input_set_abs_params(input, ABS_DISTANCE, 0, 63, 0, 0); break; } From 6245bde29dd049300d663516398335be8d451b78 Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Tue, 28 Feb 2012 17:19:05 +0000 Subject: [PATCH 25/42] HID: wacom: Add pad buttons reporting on Intuos4 WL MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This patch adds reporting of 1 wheel button and 8 strip buttons for Intuos4 WL. The buttons are reported as BTN_0 to BTN_9. The change of type butstate variable is required as the old type 'char' couldn't store state of 9 buttons. The change is not affecting Graphire tablet as it only uses first 2 bits of 'butstate'. Signed-off-by: Przemo Firszt Acked-by：Ping Cheng Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 36 +++++++++++++++++++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index 5a58db2440fa..58aedbc80f02 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -31,9 +31,11 @@ #include "hid-ids.h" +#define PAD_DEVICE_ID 0x0F + struct wacom_data { __u16 tool; - unsigned char butstate; + __u16 butstate; __u8 features; __u32 id; __u32 serial; @@ -316,6 +318,30 @@ static int wacom_gr_parse_report(struct hid_device *hdev, return 1; } +static void wacom_i4_parse_button_report(struct wacom_data *wdata, + struct input_dev *input, unsigned char *data) +{ + __u16 new_butstate; + + new_butstate = (data[3] << 1) | (data[2] & 0x01); + if (new_butstate != wdata->butstate) { + wdata->butstate = new_butstate; + input_report_key(input, BTN_0, new_butstate & 0x001); + input_report_key(input, BTN_1, new_butstate & 0x002); + input_report_key(input, BTN_2, new_butstate & 0x004); + input_report_key(input, BTN_3, new_butstate & 0x008); + input_report_key(input, BTN_4, new_butstate & 0x010); + input_report_key(input, BTN_5, new_butstate & 0x020); + input_report_key(input, BTN_6, new_butstate & 0x040); + input_report_key(input, BTN_7, new_butstate & 0x080); + input_report_key(input, BTN_8, new_butstate & 0x100); + input_report_key(input, BTN_TOOL_FINGER, 1); + input_report_abs(input, ABS_MISC, PAD_DEVICE_ID); + input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff); + input_sync(input); + } +} + static void wacom_i4_parse_pen_report(struct wacom_data *wdata, struct input_dev *input, unsigned char *data) { @@ -389,6 +415,7 @@ static void wacom_i4_parse_report(struct hid_device *hdev, wdata->features = data[2]; break; case 0x0C: /* Button report */ + wacom_i4_parse_button_report(wdata, input, data); break; default: hid_err(hdev, "Unknown report: %d,%d\n", data[0], data[1]); @@ -484,6 +511,13 @@ static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi, break; case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH: __set_bit(ABS_MISC, input->absbit); + __set_bit(BTN_2, input->keybit); + __set_bit(BTN_3, input->keybit); + __set_bit(BTN_4, input->keybit); + __set_bit(BTN_5, input->keybit); + __set_bit(BTN_6, input->keybit); + __set_bit(BTN_7, input->keybit); + __set_bit(BTN_8, input->keybit); input_set_abs_params(input, ABS_X, 0, 40640, 4, 0); input_set_abs_params(input, ABS_Y, 0, 25400, 4, 0); input_set_abs_params(input, ABS_PRESSURE, 0, 2047, 0, 0); From 51153a78dfd090529472735ba1a4e7f50ac7542f Mon Sep 17 00:00:00 2001 From: Nikolai Kondrashov Date: Tue, 6 Mar 2012 09:54:22 +0200 Subject: [PATCH 26/42] HID: uclogic: Replace original rdescs with links Replace original report descriptor dumps in the comments with links to tablet descriptions in a wiki, to make code clearer. Signed-off-by: Nikolai Kondrashov Signed-off-by: Jiri Kosina --- drivers/hid/hid-uclogic.c | 413 +------------------------------------- 1 file changed, 11 insertions(+), 402 deletions(-) diff --git a/drivers/hid/hid-uclogic.c b/drivers/hid/hid-uclogic.c index e15732f1a22d..1f1128910337 100644 --- a/drivers/hid/hid-uclogic.c +++ b/drivers/hid/hid-uclogic.c @@ -18,141 +18,16 @@ #include "hid-ids.h" /* - * The original descriptors of WPXXXXU tablets have three report IDs, of - * which only two are used (8 and 9), and the remaining (7) seems to have - * the originally intended pen description which was abandoned for some - * reason. From this unused description it is possible to extract the - * actual physical extents and resolution. All the models use the same - * descriptor with different extents for the unused report ID. - * - * Here it is: - * - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Pen), ; Pen (02h, application collection) - * Collection (Application), - * Report ID (7), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (Tip Switch), ; Tip switch (42h, momentary control) - * Usage (Barrel Switch), ; Barrel switch (44h, momentary control) - * Usage (Eraser), ; Eraser (45h, momentary control) - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (3), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage (In Range), ; In range (32h, momentary control) - * Report Count (1), - * Input (Variable), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch^3), - * Physical Minimum (0), - * Physical Maximum (Xpm), - * Logical Maximum (Xlm), - * Input (Variable), - * Usage (Y), ; Y (31h, dynamic value) - * Physical Maximum (Ypm), - * Logical Maximum (Ylm), - * Input (Variable), - * Pop, - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Maximum (1023), - * Input (Variable), - * Report Size (16), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (8), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (03h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Count (3), - * Report Size (1), - * Input (Variable), - * Report Count (5), - * Input (Constant), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Usage (Wheel), ; Wheel (38h, dynamic value) - * Usage (00h), - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (4), - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (9), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (03h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Count (3), - * Report Size (1), - * Input (Variable), - * Report Count (5), - * Input (Constant), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (32767), - * Physical Minimum (0), - * Physical Maximum (32767), - * Report Count (2), - * Report Size (16), - * Input (Variable), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Maximum (1023), - * Report Count (1), - * Report Size (16), - * Input (Variable), - * End Collection, - * End Collection - * - * Here are the extents values for the WPXXXXU models: - * - * Xpm Xlm Ypm Ylm - * WP4030U 4000 8000 3000 6000 - * WP5540U 5500 11000 4000 8000 - * WP8060U 8000 16000 6000 12000 - * - * This suggests that all of them have 2000 LPI resolution, as advertised. + * See WPXXXXU model descriptions, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=UC-Logic_Tablet_WP4030U + * http://sf.net/apps/mediawiki/digimend/?title=UC-Logic_Tablet_WP5540U + * http://sf.net/apps/mediawiki/digimend/?title=UC-Logic_Tablet_WP8060U */ /* Size of the original descriptor of WPXXXXU tablets */ #define WPXXXXU_RDESC_ORIG_SIZE 212 -/* - * Fixed WP4030U report descriptor. - * Although the hardware might actually support it, the mouse description - * has been removed, since there seems to be no devices having one and it - * wouldn't make much sense because of the working area size. - */ +/* Fixed WP4030U report descriptor */ static __u8 wp4030u_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ @@ -343,148 +218,14 @@ static __u8 wp8060u_rdesc_fixed[] = { }; /* - * Original WP1062 report descriptor. - * - * Only report ID 9 is actually used. - * - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Pen), ; Pen (02h, application collection) - * Collection (Application), - * Report ID (7), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (Tip Switch), ; Tip switch (42h, momentary control) - * Usage (Barrel Switch), ; Barrel switch (44h, momentary control) - * Usage (Eraser), ; Eraser (45h, momentary control) - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (3), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage (In Range), ; In range (32h, momentary control) - * Report Count (1), - * Input (Variable), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch), - * Physical Minimum (0), - * Physical Maximum (10000), - * Logical Maximum (20000), - * Input (Variable), - * Usage (Y), ; Y (31h, dynamic value) - * Physical Maximum (6583), - * Logical Maximum (13166), - * Input (Variable), - * Pop, - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Maximum (1023), - * Input (Variable), - * Report Size (16), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (8), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (03h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Count (3), - * Report Size (1), - * Input (Variable), - * Report Count (5), - * Input (Constant), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Usage (Wheel), ; Wheel (38h, dynamic value) - * Usage (00h), - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (4), - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (9), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (03h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Count (3), - * Report Size (1), - * Input (Variable), - * Report Count (4), - * Input (Constant), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (In Range), ; In range (32h, momentary control) - * Report Count (1), - * Input (Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch), - * Physical Minimum (0), - * Physical Maximum (10000), - * Logical Maximum (20000), - * Input (Variable), - * Usage (Y), ; Y (31h, dynamic value) - * Physical Maximum (6583), - * Logical Maximum (13166), - * Input (Variable), - * Pop, - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Maximum (1023), - * Report Count (1), - * Report Size (16), - * Input (Variable), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (00h), - * Collection (Application), - * Report ID (4), - * Logical Minimum (0), - * Logical Maximum (255), - * Usage (00h), - * Report Size (8), - * Report Count (3), - * Feature (Variable), - * End Collection + * See WP1062 description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=UC-Logic_Tablet_WP1062 */ /* Size of the original descriptor of WP1062 tablet */ #define WP1062_RDESC_ORIG_SIZE 254 -/* - * Fixed WP1062 report descriptor. - * - * Removed unused reports, corrected second barrel button usage code, physical - * units. - */ +/* Fixed WP1062 report descriptor */ static __u8 wp1062_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ @@ -530,146 +271,14 @@ static __u8 wp1062_rdesc_fixed[] = { }; /* - * Original PF1209 report descriptor. - * - * The descriptor is similar to WPXXXXU descriptors, with an addition of a - * feature report (ID 4) of unknown purpose. - * - * Although the advertised resolution is 4000 LPI the unused report ID - * (taken from WPXXXXU, it seems) states 2000 LPI, but it is probably - * incorrect and is a result of blind copying without understanding. Anyway - * the real logical extents are always scaled to 0..32767, which IMHO spoils - * the precision. - * - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Pen), ; Pen (02h, application collection) - * Collection (Application), - * Report ID (7), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (Tip Switch), ; Tip switch (42h, momentary control) - * Usage (Barrel Switch), ; Barrel switch (44h, momentary control) - * Usage (Eraser), ; Eraser (45h, momentary control) - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (3), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage (In Range), ; In range (32h, momentary control) - * Report Count (1), - * Input (Variable), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch^3), - * Physical Minimum (0), - * Physical Maximum (12000), - * Logical Maximum (24000), - * Input (Variable), - * Usage (Y), ; Y (31h, dynamic value) - * Physical Maximum (9000), - * Logical Maximum (18000), - * Input (Variable), - * Pop, - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Maximum (1023), - * Input (Variable), - * Report Size (16), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (8), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (03h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Count (3), - * Report Size (1), - * Input (Variable), - * Report Count (5), - * Input (Constant), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Usage (Wheel), ; Wheel (38h, dynamic value) - * Usage (00h), - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (4), - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (9), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (03h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Count (3), - * Report Size (1), - * Input (Variable), - * Report Count (5), - * Input (Constant), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (32767), - * Physical Minimum (0), - * Physical Maximum (32767), - * Report Count (2), - * Report Size (16), - * Input (Variable), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Maximum (1023), - * Report Count (1), - * Report Size (16), - * Input (Variable), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (00h), - * Collection (Application), - * Report ID (4), - * Logical Minimum (0), - * Logical Maximum (255), - * Usage (00h), - * Report Size (8), - * Report Count (3), - * Feature (Variable), - * End Collection + * See PF1209 description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=UC-Logic_Tablet_PF1209 */ /* Size of the original descriptor of PF1209 tablet */ #define PF1209_RDESC_ORIG_SIZE 234 -/* - * Fixed PF1209 report descriptor - * - * The descriptor is fixed similarly to WP5540U and WP8060U, plus the - * feature report is removed, because its purpose is unknown and it is of no - * use to the generic HID driver anyway for now. - */ +/* Fixed PF1209 report descriptor */ static __u8 pf1209_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ From 56d27dd6ec6e832b3b22b0c0fab960476b9694fc Mon Sep 17 00:00:00 2001 From: Nikolai Kondrashov Date: Tue, 6 Mar 2012 09:54:23 +0200 Subject: [PATCH 27/42] HID: waltop: Replace original rdescs with links Replace original report descriptor dumps in the comments with links to tablet descriptions in a wiki, to make code clearer. Signed-off-by: Nikolai Kondrashov Signed-off-by: Jiri Kosina --- drivers/hid/hid-waltop.c | 803 +-------------------------------------- 1 file changed, 15 insertions(+), 788 deletions(-) diff --git a/drivers/hid/hid-waltop.c b/drivers/hid/hid-waltop.c index 0ec169646ec7..c1dce51b1c1e 100644 --- a/drivers/hid/hid-waltop.c +++ b/drivers/hid/hid-waltop.c @@ -43,139 +43,14 @@ */ /* - * Original Slim Tablet 5.8 inch report descriptor. - * - * All the reports except the report with ID 16 (the stylus) are unused, - * possibly because the tablet is not configured to, or because they were - * just copied from a more capable model. The full purpose of features - * described for report ID 2 is unknown. - * - * The stylus buttons are described as three bit fields, whereas actually - * it's an "array", i.e. they're reported as button numbers (1, 2 and 3). - * The "eraser" field is not used. There is also a "push" without a "pop" in - * the stylus description. - * - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (1), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (05h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Size (3), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Usage (Wheel), ; Wheel (38h, dynamic value) - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (3), - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Pen), ; Pen (02h, application collection) - * Collection (Application), - * Report ID (2), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * Usage (Azimuth), ; Azimuth (3Fh, dynamic value) - * Usage (Altitude), ; Altitude (40h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (2), - * Feature (Variable), - * End Collection, - * Report ID (5), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (10), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (3), - * Input (Variable), - * End Collection, - * Report ID (16), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (Tip Switch), ; Tip switch (42h, momentary control) - * Usage (Barrel Switch), ; Barrel switch (44h, momentary control) - * Usage (Invert), ; Invert (3Ch, momentary control) - * Usage (Eraser), ; Eraser (45h, momentary control) - * Usage (In Range), ; In range (32h, momentary control) - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch^3), - * Logical Minimum (0), - * Logical Maximum (10000), - * Physical Minimum (0), - * Physical Maximum (10000), - * Input (Variable), - * Usage (Y), ; Y (31h, dynamic value) - * Logical Maximum (6000), - * Physical Maximum (6000), - * Input (Variable), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (1023), - * Physical Minimum (0), - * Physical Maximum (1023), - * Input (Variable), - * End Collection, - * End Collection + * See Slim Tablet 5.8 inch description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=Waltop_Slim_Tablet_5.8%22 */ /* Size of the original report descriptor of Slim Tablet 5.8 inch */ #define SLIM_TABLET_5_8_INCH_RDESC_ORIG_SIZE 222 -/* - * Fixed Slim Tablet 5.8 inch descriptor. - * - * All the reports except the stylus report (ID 16) were removed as unused. - * The stylus buttons description was fixed. - */ +/* Fixed Slim Tablet 5.8 inch descriptor */ static __u8 slim_tablet_5_8_inch_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ @@ -224,158 +99,14 @@ static __u8 slim_tablet_5_8_inch_rdesc_fixed[] = { }; /* - * Original Slim Tablet 12.1 inch report descriptor. - * - * The descriptor is similar to the Slim Tablet 5.8 inch descriptor with the - * addition of a keyboard report, seemingly unused. It may have get here - * from a Media Tablet - probably an unimplemented feature. - * - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (1), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (05h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Size (3), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Usage (Wheel), ; Wheel (38h, dynamic value) - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (3), - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Pen), ; Pen (02h, application collection) - * Collection (Application), - * Report ID (2), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * Usage (Azimuth), ; Azimuth (3Fh, dynamic value) - * Usage (Altitude), ; Altitude (40h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (2), - * Feature (Variable), - * End Collection, - * Report ID (5), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (10), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (3), - * Input (Variable), - * End Collection, - * Report ID (16), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (Tip Switch), ; Tip switch (42h, momentary control) - * Usage (Barrel Switch), ; Barrel switch (44h, momentary control) - * Usage (Invert), ; Invert (3Ch, momentary control) - * Usage (Eraser), ; Eraser (45h, momentary control) - * Usage (In Range), ; In range (32h, momentary control) - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch^3), - * Logical Minimum (0), - * Logical Maximum (20000), - * Physical Minimum (0), - * Physical Maximum (20000), - * Input (Variable), - * Usage (Y), ; Y (31h, dynamic value) - * Logical Maximum (12500), - * Physical Maximum (12500), - * Input (Variable), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (1023), - * Physical Minimum (0), - * Physical Maximum (1023), - * Input (Variable), - * End Collection, - * End Collection, - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Keyboard), ; Keyboard (06h, application collection) - * Collection (Application), - * Report ID (13), - * Usage Page (Keyboard), ; Keyboard/keypad (07h) - * Usage Minimum (KB Leftcontrol), ; Keyboard left control - * ; (E0h, dynamic value) - * Usage Maximum (KB Right GUI), ; Keyboard right GUI (E7h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (8), - * Input (Variable), - * Report Size (8), - * Report Count (1), - * Input (Constant), - * Usage Page (Keyboard), ; Keyboard/keypad (07h) - * Usage Minimum (None), ; No event (00h, selector) - * Usage Maximum (KB Application), ; Keyboard Application (65h, selector) - * Logical Minimum (0), - * Logical Maximum (101), - * Report Size (8), - * Report Count (5), - * Input, - * End Collection + * See Slim Tablet 12.1 inch description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=Waltop_Slim_Tablet_12.1%22 */ /* Size of the original report descriptor of Slim Tablet 12.1 inch */ #define SLIM_TABLET_12_1_INCH_RDESC_ORIG_SIZE 269 -/* - * Fixed Slim Tablet 12.1 inch descriptor. - * - * All the reports except the stylus report (ID 16) were removed as unused. - * The stylus buttons description was fixed. - */ +/* Fixed Slim Tablet 12.1 inch descriptor */ static __u8 slim_tablet_12_1_inch_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ @@ -424,142 +155,14 @@ static __u8 slim_tablet_12_1_inch_rdesc_fixed[] = { }; /* - * Original Q Pad report descriptor. - * - * The descriptor is similar to the Slim Tablet 5.8 inch descriptor with the - * addition of consumer AC Pan field to the report ID 1, which seems to be - * unused in the default mode. However, this tablet has resolution of 2048 LPI. - * - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (Mouse), ; Mouse (02h, application collection) - * Collection (Application), - * Report ID (1), - * Usage (Pointer), ; Pointer (01h, physical collection) - * Collection (Physical), - * Usage Page (Button), ; Button (09h) - * Usage Minimum (01h), - * Usage Maximum (05h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Size (3), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Usage (Y), ; Y (31h, dynamic value) - * Usage (Wheel), ; Wheel (38h, dynamic value) - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (3), - * Input (Variable, Relative), - * Usage Page (Consumer), ; Consumer (0Ch) - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (1), - * Usage (AC Pan), ; AC pan (0238h, linear control) - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Pen), ; Pen (02h, application collection) - * Collection (Application), - * Report ID (2), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * Usage (Azimuth), ; Azimuth (3Fh, dynamic value) - * Usage (Altitude), ; Altitude (40h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (2), - * Feature (Variable), - * End Collection, - * Report ID (5), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (10), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (16), - * Usage (Stylus), ; Stylus (20h, logical collection) - * Collection (Physical), - * Usage (Tip Switch), ; Tip switch (42h, momentary control) - * Usage (Barrel Switch), ; Barrel switch (44h, momentary control) - * Usage (Invert), ; Invert (3Ch, momentary control) - * Usage (Eraser), ; Eraser (45h, momentary control) - * Usage (In Range), ; In range (32h, momentary control) - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage Page (Desktop), ; Generic desktop controls (01h) - * Usage (X), ; X (30h, dynamic value) - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch^3), - * Logical Minimum (0), - * Logical Maximum (12288), - * Physical Minimum (0), - * Physical Maximum (12288), - * Input (Variable), - * Usage (Y), ; Y (31h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (9216), - * Physical Minimum (0), - * Physical Maximum (9216), - * Input (Variable), - * Usage Page (Digitizer), ; Digitizer (0Dh) - * Usage (Tip Pressure), ; Tip pressure (30h, dynamic value) - * Logical Minimum (0), - * Logical Maximum (1023), - * Physical Minimum (0), - * Physical Maximum (1023), - * Input (Variable), - * End Collection, - * End Collection + * See Q Pad description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=Waltop_Q_Pad */ /* Size of the original report descriptor of Q Pad */ #define Q_PAD_RDESC_ORIG_SIZE 241 -/* - * Fixed Q Pad descriptor. - * - * All the reports except the stylus report (ID 16) were removed as unused. - * The stylus buttons description was fixed. - */ +/* Fixed Q Pad descriptor */ static __u8 q_pad_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ @@ -608,217 +211,14 @@ static __u8 q_pad_rdesc_fixed[] = { }; /* - * Original Media Tablet 10.6 inch report descriptor. - * - * There are at least two versions of this model in the wild. They are - * represented by Genius G-Pen M609 (older version) and Genius G-Pen M609X - * (newer version). - * - * Both versions have the usual pen with two barrel buttons and two - * identical wheels with center buttons in the top corners of the tablet - * base. They also have buttons on the top, between the wheels, for - * selecting the wheels' functions and wide/standard mode. In the wide mode - * the whole working surface is sensed, in the standard mode a narrower area - * is sensed, but the logical report extents remain the same. These modes - * correspond roughly to 16:9 and 4:3 aspect ratios respectively. - * - * The older version has three wheel function buttons ("scroll", "zoom" and - * "volume") and two separate buttons for wide and standard mode. The newer - * version has four wheel function buttons (plus "brush") and only one - * button is used for selecting wide/standard mode. So, the total number of - * buttons remains the same, but one of the mode buttons is repurposed as a - * wheels' function button in the newer version. - * - * The wheel functions are: - * scroll - the wheels act as scroll wheels, the center buttons switch - * between vertical and horizontal scrolling; - * zoom - the wheels zoom in/out, the buttons supposedly reset to 100%; - * volume - the wheels control the sound volume, the buttons mute; - * brush - the wheels are supposed to control brush width in a graphics - * editor, the buttons do nothing. - * - * Below is the newer version's report descriptor. It may very well be that - * the older version's descriptor is different and thus it won't be - * supported. - * - * The mouse report (ID 1) only uses the wheel field for reporting the tablet - * wheels' scroll mode. The keyboard report (ID 13) is used to report the - * wheels' zoom and brush control functions as key presses. The report ID 12 - * is used to report the wheels' volume control functions. The stylus report - * (ID 16) has the same problems as the Slim Tablet 5.8 inch report has. - * - * The rest of the reports are unused, at least in the default configuration. - * The purpose of the features is unknown. - * - * Usage Page (Desktop), - * Usage (Mouse), - * Collection (Application), - * Report ID (1), - * Usage (Pointer), - * Collection (Physical), - * Usage Page (Button), - * Usage Minimum (01h), - * Usage Maximum (05h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Size (3), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), - * Usage (X), - * Usage (Y), - * Usage (Wheel), - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (3), - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Digitizer), - * Usage (Pen), - * Collection (Application), - * Report ID (2), - * Usage (Stylus), - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * Usage (Azimuth), - * Usage (Altitude), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (2), - * Feature (Variable), - * End Collection, - * Report ID (5), - * Usage Page (Digitizer), - * Usage (Stylus), - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (10), - * Usage Page (Digitizer), - * Usage (Stylus), - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (16), - * Usage (Stylus), - * Collection (Physical), - * Usage (Tip Switch), - * Usage (Barrel Switch), - * Usage (Invert), - * Usage (Eraser), - * Usage (In Range), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage Page (Desktop), - * Usage (X), - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch^3), - * Logical Minimum (0), - * Logical Maximum (18000), - * Physical Minimum (0), - * Physical Maximum (18000), - * Input (Variable), - * Usage (Y), - * Logical Maximum (11000), - * Physical Maximum (11000), - * Input (Variable), - * Usage Page (Digitizer), - * Usage (Tip Pressure), - * Logical Minimum (0), - * Logical Maximum (1023), - * Physical Minimum (0), - * Physical Maximum (1023), - * Input (Variable), - * End Collection, - * End Collection, - * Usage Page (Desktop), - * Usage (Keyboard), - * Collection (Application), - * Report ID (13), - * Usage Page (Keyboard), - * Usage Minimum (KB Leftcontrol), - * Usage Maximum (KB Right GUI), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (8), - * Input (Variable), - * Report Size (8), - * Report Count (1), - * Input (Constant), - * Usage Page (Keyboard), - * Usage Minimum (None), - * Usage Maximum (KB Application), - * Logical Minimum (0), - * Logical Maximum (101), - * Report Size (8), - * Report Count (5), - * Input, - * End Collection, - * Usage Page (Consumer), - * Usage (Consumer Control), - * Collection (Application), - * Report ID (12), - * Usage (Volume Inc), - * Usage (Volume Dec), - * Usage (Mute), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (3), - * Input (Variable, Relative), - * Report Size (5), - * Report Count (1), - * Input (Constant, Variable, Relative), - * End Collection + * See Media Tablet 10.6 inch description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=Waltop_Media_Tablet_10.6%22 */ /* Size of the original report descriptor of Media Tablet 10.6 inch */ #define MEDIA_TABLET_10_6_INCH_RDESC_ORIG_SIZE 300 -/* - * Fixed Media Tablet 10.6 inch descriptor. - * - * The descriptions of reports unused in the default configuration are - * removed. The stylus report (ID 16) is fixed similarly to Slim Tablet 5.8 - * inch. The unused mouse report (ID 1) fields are replaced with constant - * padding. - * - * The keyboard report (ID 13) is hacked to instead have an "array" field - * reporting consumer page controls, and all the unused bits are masked out - * with constant padding. The "brush" wheels' function is represented as "Scan - * Previous/Next Track" controls due to the lack of brush controls in the - * usage tables specification. - */ +/* Fixed Media Tablet 10.6 inch descriptor */ static __u8 media_tablet_10_6_inch_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ @@ -929,187 +329,14 @@ static __u8 media_tablet_10_6_inch_rdesc_fixed[] = { }; /* - * Original Media Tablet 14.1 inch report descriptor. - * - * There are at least two versions of this model in the wild. They are - * represented by Genius G-Pen M712 (older version) and Genius G-Pen M712X - * (newer version). The hardware difference between these versions is the same - * as between older and newer versions of Media Tablet 10.6 inch. The report - * descriptors are identical for both versions. - * - * The function, behavior and report descriptor of this tablet is similar to - * that of Media Tablet 10.6 inch. However, there is one more field (with - * Consumer AC Pan usage) in the mouse description. Then the tablet X and Y - * logical extents both get scaled to 0..16383 range (a hardware limit?), - * which kind of defeats the advertised 4000 LPI resolution, considering the - * physical extents of 12x7.25 inches. Plus, reports 5, 10 and 255 are used - * sometimes (while moving the pen) with unknown purpose. Also, the key codes - * generated for zoom in/out are different. - * - * Usage Page (Desktop), - * Usage (Mouse), - * Collection (Application), - * Report ID (1), - * Usage (Pointer), - * Collection (Physical), - * Usage Page (Button), - * Usage Minimum (01h), - * Usage Maximum (05h), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Size (3), - * Report Count (1), - * Input (Constant, Variable), - * Usage Page (Desktop), - * Usage (X), - * Usage (Y), - * Usage (Wheel), - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (3), - * Input (Variable, Relative), - * Usage Page (Consumer), - * Logical Minimum (-127), - * Logical Maximum (127), - * Report Size (8), - * Report Count (1), - * Usage (AC Pan), - * Input (Variable, Relative), - * End Collection, - * End Collection, - * Usage Page (Digitizer), - * Usage (Pen), - * Collection (Application), - * Report ID (2), - * Usage (Stylus), - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * Usage (Azimuth), - * Usage (Altitude), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (2), - * Feature (Variable), - * End Collection, - * Report ID (5), - * Usage Page (Digitizer), - * Usage (Stylus), - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (10), - * Usage Page (Digitizer), - * Usage (Stylus), - * Collection (Physical), - * Usage (00h), - * Logical Minimum (0), - * Logical Maximum (255), - * Report Size (8), - * Report Count (7), - * Input (Variable), - * End Collection, - * Report ID (16), - * Usage (Stylus), - * Collection (Physical), - * Usage (Tip Switch), - * Usage (Barrel Switch), - * Usage (Invert), - * Usage (Eraser), - * Usage (In Range), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (5), - * Input (Variable), - * Report Count (3), - * Input (Constant, Variable), - * Usage Page (Desktop), - * Usage (X), - * Report Size (16), - * Report Count (1), - * Push, - * Unit Exponent (13), - * Unit (Inch^3), - * Logical Minimum (0), - * Logical Maximum (16383), - * Physical Minimum (0), - * Physical Maximum (16383), - * Input (Variable), - * Usage (Y), - * Input (Variable), - * Usage Page (Digitizer), - * Usage (Tip Pressure), - * Logical Minimum (0), - * Logical Maximum (1023), - * Physical Minimum (0), - * Physical Maximum (1023), - * Input (Variable), - * End Collection, - * End Collection, - * Usage Page (Desktop), - * Usage (Keyboard), - * Collection (Application), - * Report ID (13), - * Usage Page (Keyboard), - * Usage Minimum (KB Leftcontrol), - * Usage Maximum (KB Right GUI), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (8), - * Input (Variable), - * Report Size (8), - * Report Count (1), - * Input (Constant), - * Usage Page (Keyboard), - * Usage Minimum (None), - * Usage Maximum (KB Application), - * Logical Minimum (0), - * Logical Maximum (101), - * Report Size (8), - * Report Count (5), - * Input, - * End Collection, - * Usage Page (Consumer), - * Usage (Consumer Control), - * Collection (Application), - * Report ID (12), - * Usage (Volume Inc), - * Usage (Volume Dec), - * Usage (Mute), - * Logical Minimum (0), - * Logical Maximum (1), - * Report Size (1), - * Report Count (3), - * Input (Variable, Relative), - * Report Size (5), - * Report Count (1), - * Input (Constant, Variable, Relative), - * End Collection + * See Media Tablet 14.1 inch description, device and HID report descriptors at + * http://sf.net/apps/mediawiki/digimend/?title=Waltop_Media_Tablet_14.1%22 */ /* Size of the original report descriptor of Media Tablet 14.1 inch */ #define MEDIA_TABLET_14_1_INCH_RDESC_ORIG_SIZE 309 -/* - * Fixed Media Tablet 14.1 inch descriptor. - * It is fixed similarly to the Media Tablet 10.6 inch descriptor. - */ +/* Fixed Media Tablet 14.1 inch descriptor */ static __u8 media_tablet_14_1_inch_rdesc_fixed[] = { 0x05, 0x0D, /* Usage Page (Digitizer), */ 0x09, 0x02, /* Usage (Pen), */ From a786e83cb088f1afcd1d55e44efd4b89d78c32d1 Mon Sep 17 00:00:00 2001 From: Nikolai Kondrashov Date: Tue, 6 Mar 2012 09:54:24 +0200 Subject: [PATCH 28/42] HID: waltop: Add support for tablet with PID 0038 Add support for unknown Waltop tablet with product ID 0x0038. This tablet is sold as Genius G-Pen F509. Signed-off-by: Nikolai Kondrashov Signed-off-by: Jiri Kosina --- drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 1 + drivers/hid/hid-waltop.c | 148 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 150 insertions(+) diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index ed96333af745..d76d85a41629 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1566,6 +1566,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { 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_Q_PAD) }, + { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) }, { 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) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 6e119a3a755e..afe878f36ec3 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -713,6 +713,7 @@ #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_Q_PAD 0x0037 +#define USB_DEVICE_ID_WALTOP_PID_0038 0x0038 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH 0x0501 #define USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH 0x0500 diff --git a/drivers/hid/hid-waltop.c b/drivers/hid/hid-waltop.c index c1dce51b1c1e..2cfd95c4467b 100644 --- a/drivers/hid/hid-waltop.c +++ b/drivers/hid/hid-waltop.c @@ -210,6 +210,64 @@ static __u8 q_pad_rdesc_fixed[] = { 0xC0 /* End Collection */ }; +/* + * See description, device and HID report descriptors of tablet with PID 0038 at + * http://sf.net/apps/mediawiki/digimend/?title=Waltop_PID_0038 + */ + +/* Size of the original report descriptor of tablet with PID 0038 */ +#define PID_0038_RDESC_ORIG_SIZE 241 + +/* + * Fixed report descriptor for tablet with PID 0038. + */ +static __u8 pid_0038_rdesc_fixed[] = { + 0x05, 0x0D, /* Usage Page (Digitizer), */ + 0x09, 0x02, /* Usage (Pen), */ + 0xA1, 0x01, /* Collection (Application), */ + 0x85, 0x10, /* Report ID (16), */ + 0x09, 0x20, /* Usage (Stylus), */ + 0xA0, /* Collection (Physical), */ + 0x09, 0x42, /* Usage (Tip Switch), */ + 0x09, 0x44, /* Usage (Barrel Switch), */ + 0x09, 0x46, /* Usage (Tablet Pick), */ + 0x15, 0x01, /* Logical Minimum (1), */ + 0x25, 0x03, /* Logical Maximum (3), */ + 0x75, 0x04, /* Report Size (4), */ + 0x95, 0x01, /* Report Count (1), */ + 0x80, /* Input, */ + 0x09, 0x32, /* Usage (In Range), */ + 0x14, /* Logical Minimum (0), */ + 0x25, 0x01, /* Logical Maximum (1), */ + 0x75, 0x01, /* Report Size (1), */ + 0x95, 0x01, /* Report Count (1), */ + 0x81, 0x02, /* Input (Variable), */ + 0x95, 0x03, /* Report Count (3), */ + 0x81, 0x03, /* Input (Constant, Variable), */ + 0x75, 0x10, /* Report Size (16), */ + 0x95, 0x01, /* Report Count (1), */ + 0x14, /* Logical Minimum (0), */ + 0xA4, /* Push, */ + 0x05, 0x01, /* Usage Page (Desktop), */ + 0x65, 0x13, /* Unit (Inch), */ + 0x55, 0xFD, /* Unit Exponent (-3), */ + 0x34, /* Physical Minimum (0), */ + 0x09, 0x30, /* Usage (X), */ + 0x46, 0x2E, 0x22, /* Physical Maximum (8750), */ + 0x26, 0x00, 0x46, /* Logical Maximum (17920), */ + 0x81, 0x02, /* Input (Variable), */ + 0x09, 0x31, /* Usage (Y), */ + 0x46, 0x82, 0x14, /* Physical Maximum (5250), */ + 0x26, 0x00, 0x2A, /* Logical Maximum (10752), */ + 0x81, 0x02, /* Input (Variable), */ + 0xB4, /* Pop, */ + 0x09, 0x30, /* Usage (Tip Pressure), */ + 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */ + 0x81, 0x02, /* Input (Variable), */ + 0xC0, /* End Collection, */ + 0xC0 /* End Collection */ +}; + /* * See Media Tablet 10.6 inch description, device and HID report descriptors at * http://sf.net/apps/mediawiki/digimend/?title=Waltop_Media_Tablet_10.6%22 @@ -444,6 +502,47 @@ static __u8 media_tablet_14_1_inch_rdesc_fixed[] = { 0xC0 /* End Collection */ }; +struct waltop_state { + u8 pressure0; + u8 pressure1; +}; + +static int waltop_probe(struct hid_device *hdev, + const struct hid_device_id *id) +{ + int ret; + struct waltop_state *s; + + s = kzalloc(sizeof(*s), GFP_KERNEL); + if (s == NULL) { + hid_err(hdev, "can't allocate device state\n"); + ret = -ENOMEM; + goto err; + } + + s->pressure0 = 0; + s->pressure1 = 0; + + hid_set_drvdata(hdev, s); + + ret = hid_parse(hdev); + if (ret) { + hid_err(hdev, "parse failed\n"); + goto err; + } + + ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); + if (ret) { + hid_err(hdev, "hw start failed\n"); + goto err; + } + + return 0; +err: + kfree(s); + return ret; +} + static __u8 *waltop_report_fixup(struct hid_device *hdev, __u8 *rdesc, unsigned int *rsize) { @@ -466,6 +565,12 @@ static __u8 *waltop_report_fixup(struct hid_device *hdev, __u8 *rdesc, *rsize = sizeof(q_pad_rdesc_fixed); } break; + case USB_DEVICE_ID_WALTOP_PID_0038: + if (*rsize == PID_0038_RDESC_ORIG_SIZE) { + rdesc = pid_0038_rdesc_fixed; + *rsize = sizeof(pid_0038_rdesc_fixed); + } + break; case USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH: if (*rsize == MEDIA_TABLET_10_6_INCH_RDESC_ORIG_SIZE) { rdesc = media_tablet_10_6_inch_rdesc_fixed; @@ -482,6 +587,44 @@ static __u8 *waltop_report_fixup(struct hid_device *hdev, __u8 *rdesc, return rdesc; } +static int waltop_raw_event(struct hid_device *hdev, struct hid_report *report, + u8 *data, int size) +{ + /* If this is a pen input report of a tablet with PID 0038 */ + if (hdev->product == USB_DEVICE_ID_WALTOP_PID_0038 && + report->type == HID_INPUT_REPORT && + report->id == 16 && + size == 8) { + struct waltop_state *s = hid_get_drvdata(hdev); + + /* + * Ignore maximum pressure reported when a barrel button is + * pressed. + */ + + /* If a barrel button is pressed */ + if ((data[1] & 0xF) > 1) { + /* Use the last known pressure */ + data[6] = s->pressure0; + data[7] = s->pressure1; + } else { + /* Remember reported pressure */ + s->pressure0 = data[6]; + s->pressure1 = data[7]; + } + } + + return 0; +} + +static void waltop_remove(struct hid_device *hdev) +{ + struct waltop_state *s = hid_get_drvdata(hdev); + + hid_hw_stop(hdev); + kfree(s); +} + static const struct hid_device_id waltop_devices[] = { { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) }, @@ -489,6 +632,8 @@ static const struct hid_device_id waltop_devices[] = { USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) }, { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) }, + { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, + USB_DEVICE_ID_WALTOP_PID_0038) }, { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) }, { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, @@ -500,7 +645,10 @@ MODULE_DEVICE_TABLE(hid, waltop_devices); static struct hid_driver waltop_driver = { .name = "waltop", .id_table = waltop_devices, + .probe = waltop_probe, .report_fixup = waltop_report_fixup, + .raw_event = waltop_raw_event, + .remove = waltop_remove, }; static int __init waltop_init(void) From 841cb1570d2c9eed4496ac9ce53c4fd4ae66ebfc Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 10:53:45 +0100 Subject: [PATCH 29/42] HID: multitouch: add support for Atmel maXTouch 03eb:2118 Signed-off-by: Benjamin Tissoires Acked-by: Henrik Rydberg Signed-off-by: Jiri Kosina --- drivers/hid/hid-ids.h | 1 + drivers/hid/hid-multitouch.c | 3 +++ 2 files changed, 4 insertions(+) diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 12b6c49359c8..5cb1d63a2a38 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -149,6 +149,7 @@ #define USB_VENDOR_ID_ATMEL 0x03eb #define USB_DEVICE_ID_ATMEL_MULTITOUCH 0x211c +#define USB_DEVICE_ID_ATMEL_MXT_DIGITIZER 0x2118 #define USB_VENDOR_ID_AVERMEDIA 0x07ca #define USB_DEVICE_ID_AVER_FM_MR800 0xb800 diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 09e42ef60d6e..03990a8bb827 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -743,6 +743,9 @@ static const struct hid_device_id mt_devices[] = { { .driver_data = MT_CLS_SERIAL, HID_USB_DEVICE(USB_VENDOR_ID_ATMEL, USB_DEVICE_ID_ATMEL_MULTITOUCH) }, + { .driver_data = MT_CLS_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_ATMEL, + USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) }, /* Cando panels */ { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, From 71078b0deba8420e00b0c5e39ea359dbcaa11114 Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 10:53:46 +0100 Subject: [PATCH 30/42] HID: multitouch: add new PID from Ideacom Signed-off-by: Benjamin Tissoires Acked-by: Henrik Rydberg Signed-off-by: Jiri Kosina --- drivers/hid/hid-ids.h | 1 + drivers/hid/hid-multitouch.c | 3 +++ 2 files changed, 4 insertions(+) diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 5cb1d63a2a38..10a9ca99e3f8 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -375,6 +375,7 @@ #define USB_VENDOR_ID_IDEACOM 0x1cb6 #define USB_DEVICE_ID_IDEACOM_IDC6650 0x6650 +#define USB_DEVICE_ID_IDEACOM_IDC6651 0x6651 #define USB_VENDOR_ID_ILITEK 0x222a #define USB_DEVICE_ID_ILITEK_MULTITOUCH 0x0001 diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 03990a8bb827..c7ee03503ec7 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -828,6 +828,9 @@ static const struct hid_device_id mt_devices[] = { { .driver_data = MT_CLS_SERIAL, HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, USB_DEVICE_ID_IDEACOM_IDC6650) }, + { .driver_data = MT_CLS_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, + USB_DEVICE_ID_IDEACOM_IDC6651) }, /* Ilitek dual touch panel */ { .driver_data = MT_CLS_DEFAULT, From fd1d152583e6ce02b47cb7315295ab58014aa26d Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 10:53:47 +0100 Subject: [PATCH 31/42] HID: multitouch: add more eGalax devices This is a list of devices that should be handled by hid-multitouch. They all present the HID usage "Contact ID" and won't be handled by hid-input. Some of them have _not_ been tested (though I have their report descriptors), but I've been guaranted by eeti that they follow the same protocol. The tested ones are also blacklisted in hid-core.c. Signed-off-by: Benjamin Tissoires Acked-by: Henrik Rydberg Signed-off-by: Jiri Kosina --- drivers/hid/hid-core.c | 2 ++ drivers/hid/hid-ids.h | 6 ++++++ drivers/hid/hid-multitouch.c | 18 ++++++++++++++++++ 3 files changed, 26 insertions(+) diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index bb710a6a079d..4f4143cc789b 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1409,6 +1409,8 @@ static const struct hid_device_id hid_have_special_driver[] = { { 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_7224) }, + { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) }, { 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) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 10a9ca99e3f8..e5e32864d55d 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -238,11 +238,17 @@ #define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER 0x0001 #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_7207 0x7207 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C 0x720c +#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224 0x7224 +#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E 0x725e +#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262 0x7262 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B 0x726b +#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA 0x72aa #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_7349 0x7349 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001 0xa001 #define USB_VENDOR_ID_ELECOM 0x056e diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index c7ee03503ec7..0eda37f03c30 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -788,18 +788,36 @@ static const struct hid_device_id mt_devices[] = { { .driver_data = MT_CLS_EGALAX, HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) }, + { .driver_data = MT_CLS_EGALAX_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_DWAV, + USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) }, + { .driver_data = MT_CLS_EGALAX_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_DWAV, + USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) }, + { .driver_data = MT_CLS_EGALAX_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_DWAV, + USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, { .driver_data = MT_CLS_EGALAX, HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) }, + { .driver_data = MT_CLS_EGALAX_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_DWAV, + USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) }, { .driver_data = MT_CLS_EGALAX, HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) }, + { .driver_data = MT_CLS_EGALAX_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_DWAV, + USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) }, { .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_7349) }, { .driver_data = MT_CLS_EGALAX_SERIAL, HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, From 8d31321ca5367daf0415ed81f9cbd93adb16e8bc Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 10:53:48 +0100 Subject: [PATCH 32/42] HID: usbhid: add quirk no_get for quanta 3008 devices Some quanta devices do not like to be polled for reports descriptors, thus this quirk. Signed-off-by: Benjamin Tissoires Acked-by: Henrik Rydberg Signed-off-by: Jiri Kosina --- drivers/hid/usbhid/hid-quirks.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c index c831af937481..4d248d5d3783 100644 --- a/drivers/hid/usbhid/hid-quirks.c +++ b/drivers/hid/usbhid/hid-quirks.c @@ -73,6 +73,7 @@ static const struct hid_blacklist { { 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_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008, HID_QUIRK_NOGET }, { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET }, { USB_VENDOR_ID_SYMBOL, USB_DEVICE_ID_SYMBOL_SCANNER_1, HID_QUIRK_NOGET }, { USB_VENDOR_ID_SYMBOL, USB_DEVICE_ID_SYMBOL_SCANNER_2, HID_QUIRK_NOGET }, From 2ce09df47b67f16367272f63f85f4cc991e6009a Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 17:57:02 +0100 Subject: [PATCH 33/42] HID: multitouch: add support for eGalax 0x722a Signed-off-by: Benjamin Tissoires Signed-off-by: Jiri Kosina --- drivers/hid/hid-ids.h | 1 + drivers/hid/hid-multitouch.c | 3 +++ 2 files changed, 4 insertions(+) diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index e5e32864d55d..e0bac4ff04fb 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -241,6 +241,7 @@ #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207 0x7207 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C 0x720c #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224 0x7224 +#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A 0x722A #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E 0x725e #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262 0x7262 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B 0x726b diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 0eda37f03c30..019de83def65 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -797,6 +797,9 @@ static const struct hid_device_id mt_devices[] = { { .driver_data = MT_CLS_EGALAX_SERIAL, HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) }, + { .driver_data = MT_CLS_EGALAX_SERIAL, + HID_USB_DEVICE(USB_VENDOR_ID_DWAV, + USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) }, { .driver_data = MT_CLS_EGALAX, HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) }, From 6b1968d5b6e223237bca98879f31c5616b3b325f Mon Sep 17 00:00:00 2001 From: Jiri Kosina Date: Fri, 9 Mar 2012 13:55:43 +0100 Subject: [PATCH 34/42] HID: make it possible to force hid-core claim the device Introduce 'hid_ignore_special_drivers' module parameter that makes hid-core claim the device even if it's listed in hid_have_special_driver[]. This is useful mostly for debugging purposes and specialized initrds, where all the hid drivers are not avaiable. Signed-off-by: Jiri Kosina --- drivers/hid/hid-core.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index d76d85a41629..fbecdd3e7cd3 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -4,7 +4,7 @@ * Copyright (c) 1999 Andreas Gal * Copyright (c) 2000-2005 Vojtech Pavlik * Copyright (c) 2005 Michael Haboustak for Concept2, Inc - * Copyright (c) 2006-2010 Jiri Kosina + * Copyright (c) 2006-2012 Jiri Kosina */ /* @@ -50,6 +50,10 @@ module_param_named(debug, hid_debug, int, 0600); MODULE_PARM_DESC(debug, "toggle HID debugging messages"); EXPORT_SYMBOL_GPL(hid_debug); +static int hid_ignore_special_drivers = 0; +module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600); +MODULE_PARM_DESC(debug, "Ignore any special drivers and handle all devices by generic driver"); + /* * Register a new report for a device. */ @@ -1678,7 +1682,7 @@ static int hid_bus_match(struct device *dev, struct device_driver *drv) return 0; /* generic wants all that don't have specialized driver */ - if (!strncmp(hdrv->name, "generic-", 8)) + if (!strncmp(hdrv->name, "generic-", 8) && !hid_ignore_special_drivers) return !hid_match_id(hdev, hid_have_special_driver); return 1; From ed9d5c96147b3bed6178252e8e04b27b7d32edd0 Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 17:57:03 +0100 Subject: [PATCH 35/42] HID: multitouch: fix handling of buggy reports descriptors for Dell ST2220T LG multitouch panels, such as the one found in Dell ST2220T, has buggy reports descriptors. With the previous implementation, it was impossible to rely on the reports descriptors to determine how the different touches are emitted from the device. This patch changes the splitting of the different touches in the report in a more robust way. Signed-off-by: Benjamin Tissoires Signed-off-by: Jiri Kosina --- drivers/hid/hid-multitouch.c | 64 ++++++++++++++---------------------- 1 file changed, 25 insertions(+), 39 deletions(-) diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 019de83def65..2088ab4e5db5 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -75,7 +75,6 @@ struct mt_device { 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 */ __s8 inputmode; /* InputMode HID feature, -1 if non-existent */ __s8 maxcontact_report_id; /* Maximum Contact Number HID feature, -1 if non-existent */ @@ -273,6 +272,13 @@ static void set_abs(struct input_dev *input, unsigned int code, input_set_abs_params(input, code, fmin, fmax, fuzz, 0); } +static void set_last_slot_field(struct hid_usage *usage, struct mt_device *td, + struct hid_input *hi) +{ + if (!test_bit(usage->hid, hi->input->absbit)) + td->last_slot_field = usage->hid; +} + 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) @@ -321,10 +327,8 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, cls->sn_move); /* touchscreen emulation */ set_abs(hi->input, ABS_X, field, cls->sn_move); - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; return 1; case HID_GD_Y: hid_map_usage(hi, usage, bit, max, @@ -333,10 +337,8 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, cls->sn_move); /* touchscreen emulation */ set_abs(hi->input, ABS_Y, field, cls->sn_move); - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; return 1; } return 0; @@ -344,24 +346,18 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, case HID_UP_DIGITIZER: switch (usage->hid) { case HID_DG_INRANGE: - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; return 1; case HID_DG_CONFIDENCE: - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; 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); - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; return 1; case HID_DG_CONTACTID: if (!td->maxcontacts) @@ -369,17 +365,14 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, input_mt_init_slots(hi->input, td->maxcontacts); td->last_slot_field = usage->hid; td->last_field_index = field->index; - td->last_mt_collection = usage->collection_index; 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); - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; return 1; case HID_DG_HEIGHT: hid_map_usage(hi, usage, bit, max, @@ -388,10 +381,8 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, cls->sn_height); input_set_abs_params(hi->input, ABS_MT_ORIENTATION, 0, 1, 0, 0); - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; return 1; case HID_DG_TIPPRESSURE: hid_map_usage(hi, usage, bit, max, @@ -401,20 +392,16 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, /* touchscreen emulation */ set_abs(hi->input, ABS_PRESSURE, field, cls->sn_pressure); - if (td->last_mt_collection == usage->collection_index) { - td->last_slot_field = usage->hid; - td->last_field_index = field->index; - } + set_last_slot_field(usage, td, hi); + td->last_field_index = field->index; return 1; case HID_DG_CONTACTCOUNT: - if (td->last_mt_collection == usage->collection_index) - td->last_field_index = field->index; + td->last_field_index = field->index; return 1; case HID_DG_CONTACTMAX: /* we don't set td->last_slot_field as contactcount and * contact max are global to the report */ - if (td->last_mt_collection == usage->collection_index) - td->last_field_index = field->index; + td->last_field_index = field->index; return -1; } case HID_DG_TOUCH: @@ -670,7 +657,6 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) td->mtclass = *mtclass; td->inputmode = -1; td->maxcontact_report_id = -1; - td->last_mt_collection = -1; hid_set_drvdata(hdev, td); ret = hid_parse(hdev); From 8d179a9ef25a64b451e2bbd46f6a6c16c6a72eb1 Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 17:57:04 +0100 Subject: [PATCH 36/42] HID: handle all multitouch devices through hid-multitouch When the quirk HID_QUIRK_MULTITOUCH is present and when hid-multitouch is loaded, let's pass the device to hid-multitouch even if it has not been registered in hid-multitouch. If any other driver wants to take precedence over hid-multitouch, the usual way of adding it to hid_have_special_driver will work as the quirk HID_QUIRK_MULTITOUCH won't be set by the generic hid layer. Signed-off-by: Benjamin Tissoires Signed-off-by: Jiri Kosina --- drivers/hid/hid-core.c | 12 +++++++++--- drivers/hid/hid-multitouch.c | 11 +++++++---- 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index 4f4143cc789b..05a0c9a35bf2 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1232,7 +1232,6 @@ int hid_connect(struct hid_device *hdev, unsigned int connect_mask) hdev->claimed |= HID_CLAIMED_INPUT; if (hdev->quirks & HID_QUIRK_MULTITOUCH) { /* this device should be handled by hid-multitouch, skip it */ - hdev->quirks &= ~HID_QUIRK_MULTITOUCH; return -ENODEV; } @@ -1667,6 +1666,10 @@ static int hid_bus_match(struct device *dev, struct device_driver *drv) struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver); struct hid_device *hdev = container_of(dev, struct hid_device, dev); + if ((hdev->quirks & HID_QUIRK_MULTITOUCH) && + !strncmp(hdrv->name, "hid-multitouch", 14)) + return 1; + if (!hid_match_device(hdev, hdrv)) return 0; @@ -1691,8 +1694,11 @@ static int hid_device_probe(struct device *dev) if (!hdev->driver) { id = hid_match_device(hdev, hdrv); if (id == NULL) { - ret = -ENODEV; - goto unlock; + if (!((hdev->quirks & HID_QUIRK_MULTITOUCH) && + !strncmp(hdrv->name, "hid-multitouch", 14))) { + ret = -ENODEV; + goto unlock; + } } hdev->driver = hdrv; diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 2088ab4e5db5..a61ba42e1bff 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -637,10 +637,12 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) 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; + if (id) { + for (i = 0; mt_classes[i].name ; i++) { + if (id->driver_data == mt_classes[i].name) { + mtclass = &(mt_classes[i]); + break; + } } } @@ -648,6 +650,7 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) * that emit events over several HID messages. */ hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; + hdev->quirks &= ~HID_QUIRK_MULTITOUCH; td = kzalloc(sizeof(struct mt_device), GFP_KERNEL); if (!td) { From 9e87f22ac6353b50425c5da412fe2418a48e25a3 Mon Sep 17 00:00:00 2001 From: Benjamin Tissoires Date: Tue, 6 Mar 2012 17:57:06 +0100 Subject: [PATCH 37/42] HID: multitouch: detect serial protocol Microsoft's documentation about multitouch protocols tells that if a device presents one touch per report, then it should be treated as a serial protocol. Signed-off-by: Benjamin Tissoires Signed-off-by: Jiri Kosina --- drivers/hid/hid-multitouch.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index a61ba42e1bff..6fb46d70f39d 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -81,6 +81,9 @@ struct mt_device { __u8 num_received; /* how many contacts we received */ __u8 num_expected; /* expected last contact index */ __u8 maxcontacts; + __u8 touches_by_report; /* how many touches are present in one report: + * 1 means we should use a serial protocol + * > 1 means hybrid (multitouch) protocol */ bool curvalid; /* is the current contact valid? */ struct mt_slot *slots; }; @@ -365,6 +368,7 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi, input_mt_init_slots(hi->input, td->maxcontacts); td->last_slot_field = usage->hid; td->last_field_index = field->index; + td->touches_by_report++; return 1; case HID_DG_WIDTH: hid_map_usage(hi, usage, bit, max, @@ -670,6 +674,15 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) if (ret) goto fail; + if (!id && td->touches_by_report == 1) { + /* the device has been sent by hid-generic */ + mtclass = &td->mtclass; + mtclass->quirks |= MT_QUIRK_ALWAYS_VALID; + mtclass->quirks &= ~MT_QUIRK_NOT_SEEN_MEANS_UP; + mtclass->quirks &= ~MT_QUIRK_VALID_IS_INRANGE; + mtclass->quirks &= ~MT_QUIRK_VALID_IS_CONFIDENCE; + } + td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot), GFP_KERNEL); if (!td->slots) { From 693f45bb2d6ff5bf8fb3b69ff904b44ef8cffd8d Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Fri, 9 Mar 2012 13:20:51 +0000 Subject: [PATCH 38/42] HID: wacom: Reset stylus buttons - Intuos4 WL Stylus buttons have to be resetted when going out-of-prox. Signed-off-by: Przemo Firszt Reviewed-by: Jason Gerecke Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index 58aedbc80f02..f9af474275db 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -352,6 +352,8 @@ static void wacom_i4_parse_pen_report(struct wacom_data *wdata, case 0x80: /* Out of proximity report */ input_report_key(input, BTN_TOUCH, 0); input_report_abs(input, ABS_PRESSURE, 0); + input_report_key(input, BTN_STYLUS, 0); + input_report_key(input, BTN_STYLUS2, 0); input_report_key(input, wdata->tool, 0); input_report_abs(input, ABS_MISC, 0); input_event(input, EV_MSC, MSC_SERIAL, wdata->serial); From 740363fb75f421f9a00a183f673b477c3029b572 Mon Sep 17 00:00:00 2001 From: Jiri Kosina Date: Tue, 13 Mar 2012 09:36:05 +0100 Subject: [PATCH 39/42] HID: tivo: add support for BT-version (0x1200) Add support for BT-driven configuration of the TiVo remote. Reported-by: Joshua Dillon Signed-off-by: Jiri Kosina --- drivers/hid/Kconfig | 2 +- drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 1 + drivers/hid/hid-tivo.c | 1 + 4 files changed, 4 insertions(+), 1 deletion(-) diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index 838fa6a3a287..3d14e4f6bac1 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -610,7 +610,7 @@ config SMARTJOYPLUS_FF config HID_TIVO tristate "TiVo Slide Bluetooth remote control support" - depends on USB_HID + depends on (USB_HID || BT_HIDP) ---help--- Say Y if you have a TiVo Slide Bluetooth remote control. diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index fbecdd3e7cd3..95095e5568a4 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1546,6 +1546,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) }, { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) }, { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) }, + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) }, { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) }, { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) }, { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index afe878f36ec3..5dcda615da36 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -661,6 +661,7 @@ #define USB_VENDOR_ID_THRUSTMASTER 0x044f #define USB_VENDOR_ID_TIVO 0x150a +#define USB_DEVICE_ID_TIVO_SLIDE_BT 0x1200 #define USB_DEVICE_ID_TIVO_SLIDE 0x1201 #define USB_VENDOR_ID_TOPSEED 0x0766 diff --git a/drivers/hid/hid-tivo.c b/drivers/hid/hid-tivo.c index 3d43c06dfffa..de47039c708c 100644 --- a/drivers/hid/hid-tivo.c +++ b/drivers/hid/hid-tivo.c @@ -62,6 +62,7 @@ static int tivo_input_mapping(struct hid_device *hdev, struct hid_input *hi, static const struct hid_device_id tivo_devices[] = { /* TiVo Slide Bluetooth remote, pairs with a Broadcom dongle */ + { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) }, { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) }, { } }; From 9a911da8d792a2d8f9a1e07eb1c41e0d7f4ec307 Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Wed, 14 Mar 2012 19:55:03 +0000 Subject: [PATCH 40/42] HID: wacom: Replace __set_bit with input_set_capability It's a trivial patch. It's doesn't change the functionality as the helper input_set_capability does the same thing. Signed-off-by: Przemo Firszt Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index f9af474275db..3fc93869024e 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -492,9 +492,7 @@ static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi, __set_bit(BTN_MIDDLE, input->keybit); /* Pad */ - input->evbit[0] |= BIT(EV_MSC); - - __set_bit(MSC_SERIAL, input->mscbit); + input_set_capability(input, EV_MSC, MSC_SERIAL); __set_bit(BTN_0, input->keybit); __set_bit(BTN_1, input->keybit); From 7e503a37deee55cc30d2c8643e704a98556dd367 Mon Sep 17 00:00:00 2001 From: Przemo Firszt Date: Wed, 14 Mar 2012 19:55:04 +0000 Subject: [PATCH 41/42] HID: wacom: Add reporting of wheel for Intuos4 WL This patch adds reporting of ABS_WHEEL event. Raported walues are 0..71 and are related to absolute location of the finger on the wheel. Signed-off-by: Przemo Firszt Reviewed-by: Jason Gerecke Signed-off-by: Jiri Kosina --- drivers/hid/hid-wacom.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c index 3fc93869024e..694545d5bfea 100644 --- a/drivers/hid/hid-wacom.c +++ b/drivers/hid/hid-wacom.c @@ -36,6 +36,7 @@ struct wacom_data { __u16 tool; __u16 butstate; + __u8 whlstate; __u8 features; __u32 id; __u32 serial; @@ -322,6 +323,23 @@ static void wacom_i4_parse_button_report(struct wacom_data *wdata, struct input_dev *input, unsigned char *data) { __u16 new_butstate; + __u8 new_whlstate; + __u8 sync = 0; + + new_whlstate = data[1]; + if (new_whlstate != wdata->whlstate) { + wdata->whlstate = new_whlstate; + if (new_whlstate & 0x80) { + input_report_key(input, BTN_TOUCH, 1); + input_report_abs(input, ABS_WHEEL, (new_whlstate & 0x7f)); + input_report_key(input, BTN_TOOL_FINGER, 1); + } else { + input_report_key(input, BTN_TOUCH, 0); + input_report_abs(input, ABS_WHEEL, 0); + input_report_key(input, BTN_TOOL_FINGER, 0); + } + sync = 1; + } new_butstate = (data[3] << 1) | (data[2] & 0x01); if (new_butstate != wdata->butstate) { @@ -336,6 +354,10 @@ static void wacom_i4_parse_button_report(struct wacom_data *wdata, input_report_key(input, BTN_7, new_butstate & 0x080); input_report_key(input, BTN_8, new_butstate & 0x100); input_report_key(input, BTN_TOOL_FINGER, 1); + sync = 1; + } + + if (sync) { input_report_abs(input, ABS_MISC, PAD_DEVICE_ID); input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff); input_sync(input); @@ -510,6 +532,7 @@ static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi, input_set_abs_params(input, ABS_DISTANCE, 0, 32, 0, 0); break; case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH: + __set_bit(ABS_WHEEL, input->absbit); __set_bit(ABS_MISC, input->absbit); __set_bit(BTN_2, input->keybit); __set_bit(BTN_3, input->keybit); @@ -518,6 +541,7 @@ static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi, __set_bit(BTN_6, input->keybit); __set_bit(BTN_7, input->keybit); __set_bit(BTN_8, input->keybit); + input_set_abs_params(input, ABS_WHEEL, 0, 71, 0, 0); input_set_abs_params(input, ABS_X, 0, 40640, 4, 0); input_set_abs_params(input, ABS_Y, 0, 25400, 4, 0); input_set_abs_params(input, ABS_PRESSURE, 0, 2047, 0, 0); From 4d5df5d11e8027c11c1079205757527cbaade62d Mon Sep 17 00:00:00 2001 From: Andreas Nielsen Date: Mon, 19 Mar 2012 15:41:03 +0100 Subject: [PATCH 42/42] HID: multitouch: add PID for Fructel product Adds multitouch support for the Gametel Android game controller. The multitouch events are emulated by the Gametel device. Each physical button is configured to generate a MT event on a specific coordinate. This seems to be the only way for us to support Android games that doesn't support HID gamepads. It is possible to inject MT events at Android level, but this requires root on the phone. Signed-off-by: Andreas Nielsen Signed-off-by: Jiri Kosina --- drivers/hid/hid-core.c | 1 + drivers/hid/hid-ids.h | 3 +++ drivers/hid/hid-multitouch.c | 5 +++++ 3 files changed, 9 insertions(+) diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index 95095e5568a4..8ea595236d64 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -1422,6 +1422,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { 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_EZKEY, USB_DEVICE_ID_BTC_8193) }, + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_FRUCTEL, USB_DEVICE_ID_GAMETEL_MT_MODE) }, { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) }, { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) }, { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) }, diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 5dcda615da36..5d7ef721f09c 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -271,6 +271,9 @@ #define USB_VENDOR_ID_EZKEY 0x0518 #define USB_DEVICE_ID_BTC_8193 0x0002 +#define USB_VENDOR_ID_FRUCTEL 0x25B6 +#define USB_DEVICE_ID_GAMETEL_MT_MODE 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 diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 24fc4423b937..ddba4c50815b 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -742,6 +742,11 @@ static const struct hid_device_id mt_devices[] = { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) }, + /* Gametel game controller */ + { .driver_data = MT_CLS_DEFAULT, + HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_FRUCTEL, + USB_DEVICE_ID_GAMETEL_MT_MODE) }, + /* GoodTouch panels */ { .driver_data = MT_CLS_DEFAULT, HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,