Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f39fdf2a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid 

Pull HID updates from Jiri Kosina:

 - support for new Wacom "MobileStudio Pro" class of tablets from Jason
   Gerecke

 - Microsoft Surface 3 support from Benjamin Tissoires and Microsoft
   Surface 4 support from Daniel Keller

 - uDraw PS3 tablet support from Bastien Nocera

 - timeout scheduling fixes for intel-ish-hid from Even Xu

 - HID_QUIRK_MULTI_INPUT in order to simplify LED handling from Benjamin
   Tissoires

 - support for Sony DS4 dongle and various other fixes to Sony driver
   from Roderick Colenbrander

 - other assorted smaller fixes and device ID additions

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid: (63 commits)
  HID: fix missing irq field
  HID: i2c-hid: fix build
  HID: i2c-hid: Disable IRQ before freeing buffers
  HID: usbhid: fix improper return value
  HID: wacom: generic: Don't sync input on empty input packets
  HID: wacom: generic: Pad supports more than buttons
  HID: wacom: generic: Send data only when the interface is defined
  HID: wacom: generic: Don't return a value for wacom_wac_event
  HID: intel_ish-hid: use %pUL for uuid formatting
  HID: cp2112: explicitly require irqchip support in gpiolib
  HID: asus: Add i2c touchpad support
  HID: intel-ish-hid: Fix potential race condition
  HID: sony: Support DS4 dongle
  HID: sony: Comply to Linux gamepad spec for DS4
  HID: sony: Make the DS4 touchpad a separate device
  HID: sony: Fix memory issue when connecting device using both Bluetooth and USB
  HID: cp2112: add IRQ chip handling
  HID: i2c-hid: force the IRQ level trigger only when not set
  HID: multitouch: do not retrieve all reports for all devices
  HID: multitouch: enable the Surface 3 Type Cover to report multitouch data
  ...
parents 775a2e29 96e132eb

MAINTAINERS

+6 −0
Original line number Diff line number Diff line
@@ -12488,6 +12488,12 @@ S: Maintained 
F:	Documentation/filesystems/udf.txt

F:	fs/udf/



UDRAW TABLET

M:	Bastien Nocera <hadess@hadess.net>

L:	linux-input@vger.kernel.org

S:	Maintained

F:	drivers/hid/hid-udraw.c



UFS FILESYSTEM

M:	Evgeniy Dushistov <dushistov@mail.ru>

S:	Maintained

drivers/hid/Kconfig

+17 −2
Original line number Diff line number Diff line
@@ -138,7 +138,7 @@ config HID_ASUS 
	tristate "Asus"

	depends on I2C_HID

	---help---

	Support for Asus notebook built-in keyboard via i2c.

	Support for Asus notebook built-in keyboard and touchpad via i2c.



	Supported devices:

	- EeeBook X205TA
@@ -214,7 +214,7 @@ config HID_CMEDIA 


config HID_CP2112

	tristate "Silicon Labs CP2112 HID USB-to-SMBus Bridge support"

	depends on USB_HID && I2C && GPIOLIB

	depends on USB_HID && I2C && GPIOLIB && GPIOLIB_IRQCHIP

	---help---

	Support for Silicon Labs CP2112 HID USB to SMBus Master Bridge.

	This is a HID device driver which registers as an i2c adapter
@@ -512,6 +512,14 @@ config HID_MAGICMOUSE 
	Say Y here if you want support for the multi-touch features of the

	Apple Wireless "Magic" Mouse and the Apple Wireless "Magic" Trackpad.



config HID_MAYFLASH

	tristate "Mayflash game controller adapter force feedback"

	depends on HID

	select INPUT_FF_MEMLESS

	---help---

	Say Y here if you have HJZ Mayflash PS3 game controller adapters

	and want to enable force feedback support.



config HID_MICROSOFT

	tristate "Microsoft non-fully HID-compliant devices"

	depends on HID
@@ -861,6 +869,13 @@ config THRUSTMASTER_FF 
	  a THRUSTMASTER Dual Trigger 3-in-1 or a THRUSTMASTER Ferrari GT

	  Rumble Force or Force Feedback Wheel.



config HID_UDRAW_PS3

	tristate "THQ PS3 uDraw tablet"

	depends on HID

	---help---

	  Say Y here if you want to use the THQ uDraw gaming tablet for

	  the PS3.



config HID_WACOM

	tristate "Wacom Intuos/Graphire tablet support (USB)"

	depends on HID

drivers/hid/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -58,6 +58,7 @@ obj-$(CONFIG_HID_LOGITECH) += hid-logitech.o 
obj-$(CONFIG_HID_LOGITECH_DJ)	+= hid-logitech-dj.o

obj-$(CONFIG_HID_LOGITECH_HIDPP)	+= hid-logitech-hidpp.o

obj-$(CONFIG_HID_MAGICMOUSE)	+= hid-magicmouse.o

obj-$(CONFIG_HID_MAYFLASH)	+= hid-mf.o

obj-$(CONFIG_HID_MICROSOFT)	+= hid-microsoft.o

obj-$(CONFIG_HID_MONTEREY)	+= hid-monterey.o

obj-$(CONFIG_HID_MULTITOUCH)	+= hid-multitouch.o
@@ -96,6 +97,7 @@ 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

obj-$(CONFIG_HID_UDRAW_PS3)	+= hid-udraw-ps3.o

obj-$(CONFIG_HID_LED)		+= hid-led.o

obj-$(CONFIG_HID_XINMO)		+= hid-xinmo.o

obj-$(CONFIG_HID_ZEROPLUS)	+= hid-zpff.o

drivers/hid/hid-asus.c

+293 −6
Original line number Diff line number Diff line
@@ -11,6 +11,12 @@ 
 *  This module based on hid-ortek by

 *  Copyright (c) 2010 Johnathon Harris <jmharris@gmail.com>

 *  Copyright (c) 2011 Jiri Kosina

 *

 *  This module has been updated to add support for Asus i2c touchpad.

 *

 *  Copyright (c) 2016 Brendan McGrath <redmcg@redmandi.dyndns.org>

 *  Copyright (c) 2016 Victor Vlasenko <victor.vlasenko@sysgears.com>

 *  Copyright (c) 2016 Frederik Wenigwieser <frederik.wenigwieser@gmail.com>

 */



/*
@@ -20,16 +26,287 @@ 
 * any later version.

 */



#include <linux/device.h>

#include <linux/hid.h>

#include <linux/module.h>

#include <linux/input/mt.h>



#include "hid-ids.h"



MODULE_AUTHOR("Yusuke Fujimaki <usk.fujimaki@gmail.com>");

MODULE_AUTHOR("Brendan McGrath <redmcg@redmandi.dyndns.org>");

MODULE_AUTHOR("Victor Vlasenko <victor.vlasenko@sysgears.com>");

MODULE_AUTHOR("Frederik Wenigwieser <frederik.wenigwieser@gmail.com>");

MODULE_DESCRIPTION("Asus HID Keyboard and TouchPad");



#define FEATURE_REPORT_ID 0x0d

#define INPUT_REPORT_ID 0x5d



#define INPUT_REPORT_SIZE 28



#define MAX_CONTACTS 5



#define MAX_X 2794

#define MAX_Y 1758

#define MAX_TOUCH_MAJOR 8

#define MAX_PRESSURE 128



#define CONTACT_DATA_SIZE 5



#define BTN_LEFT_MASK 0x01

#define CONTACT_TOOL_TYPE_MASK 0x80

#define CONTACT_X_MSB_MASK 0xf0

#define CONTACT_Y_MSB_MASK 0x0f

#define CONTACT_TOUCH_MAJOR_MASK 0x07

#define CONTACT_PRESSURE_MASK 0x7f



#define QUIRK_FIX_NOTEBOOK_REPORT	BIT(0)

#define QUIRK_NO_INIT_REPORTS		BIT(1)

#define QUIRK_SKIP_INPUT_MAPPING	BIT(2)

#define QUIRK_IS_MULTITOUCH		BIT(3)



#define NOTEBOOK_QUIRKS			QUIRK_FIX_NOTEBOOK_REPORT

#define TOUCHPAD_QUIRKS			(QUIRK_NO_INIT_REPORTS | \

						 QUIRK_SKIP_INPUT_MAPPING | \

						 QUIRK_IS_MULTITOUCH)



#define TRKID_SGN       ((TRKID_MAX + 1) >> 1)



struct asus_drvdata {

	unsigned long quirks;

	struct input_dev *input;

};



static void asus_report_contact_down(struct input_dev *input,

		int toolType, u8 *data)

{

	int touch_major, pressure;

	int x = (data[0] & CONTACT_X_MSB_MASK) << 4 | data[1];

	int y = MAX_Y - ((data[0] & CONTACT_Y_MSB_MASK) << 8 | data[2]);



	if (toolType == MT_TOOL_PALM) {

		touch_major = MAX_TOUCH_MAJOR;

		pressure = MAX_PRESSURE;

	} else {

		touch_major = (data[3] >> 4) & CONTACT_TOUCH_MAJOR_MASK;

		pressure = data[4] & CONTACT_PRESSURE_MASK;

	}



	input_report_abs(input, ABS_MT_POSITION_X, x);

	input_report_abs(input, ABS_MT_POSITION_Y, y);

	input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major);

	input_report_abs(input, ABS_MT_PRESSURE, pressure);

}



/* Required for Synaptics Palm Detection */

static void asus_report_tool_width(struct input_dev *input)

{

	struct input_mt *mt = input->mt;

	struct input_mt_slot *oldest;

	int oldid, count, i;



	oldest = NULL;

	oldid = mt->trkid;

	count = 0;



	for (i = 0; i < mt->num_slots; ++i) {

		struct input_mt_slot *ps = &mt->slots[i];

		int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);



		if (id < 0)

			continue;

		if ((id - oldid) & TRKID_SGN) {

			oldest = ps;

			oldid = id;

		}

		count++;

	}



	if (oldest) {

		input_report_abs(input, ABS_TOOL_WIDTH,

			input_mt_get_value(oldest, ABS_MT_TOUCH_MAJOR));

	}

}



static void asus_report_input(struct input_dev *input, u8 *data)

{

	int i;

	u8 *contactData = data + 2;



	for (i = 0; i < MAX_CONTACTS; i++) {

		bool down = !!(data[1] & BIT(i+3));

		int toolType = contactData[3] & CONTACT_TOOL_TYPE_MASK ?

						MT_TOOL_PALM : MT_TOOL_FINGER;



		input_mt_slot(input, i);

		input_mt_report_slot_state(input, toolType, down);



		if (down) {

			asus_report_contact_down(input, toolType, contactData);

			contactData += CONTACT_DATA_SIZE;

		}

	}



	input_report_key(input, BTN_LEFT, data[1] & BTN_LEFT_MASK);

	asus_report_tool_width(input);



	input_mt_sync_frame(input);

	input_sync(input);

}



static int asus_raw_event(struct hid_device *hdev,

		struct hid_report *report, u8 *data, int size)

{

	struct asus_drvdata *drvdata = hid_get_drvdata(hdev);



	if (drvdata->quirks & QUIRK_IS_MULTITOUCH &&

					 data[0] == INPUT_REPORT_ID &&

						size == INPUT_REPORT_SIZE) {

		asus_report_input(drvdata->input, data);

		return 1;

	}



	return 0;

}



static int asus_input_configured(struct hid_device *hdev, struct hid_input *hi)

{

	struct asus_drvdata *drvdata = hid_get_drvdata(hdev);



	if (drvdata->quirks & QUIRK_IS_MULTITOUCH) {

		int ret;

		struct input_dev *input = hi->input;



		input_set_abs_params(input, ABS_MT_POSITION_X, 0, MAX_X, 0, 0);

		input_set_abs_params(input, ABS_MT_POSITION_Y, 0, MAX_Y, 0, 0);

		input_set_abs_params(input, ABS_TOOL_WIDTH, 0, MAX_TOUCH_MAJOR, 0, 0);

		input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, MAX_TOUCH_MAJOR, 0, 0);

		input_set_abs_params(input, ABS_MT_PRESSURE, 0, MAX_PRESSURE, 0, 0);



		__set_bit(BTN_LEFT, input->keybit);

		__set_bit(INPUT_PROP_BUTTONPAD, input->propbit);



		ret = input_mt_init_slots(input, MAX_CONTACTS, INPUT_MT_POINTER);



		if (ret) {

			hid_err(hdev, "Asus input mt init slots failed: %d\n", ret);

			return ret;

		}



		drvdata->input = input;

	}



	return 0;

}



static int asus_input_mapping(struct hid_device *hdev,

		struct hid_input *hi, struct hid_field *field,

		struct hid_usage *usage, unsigned long **bit,

		int *max)

{

	struct asus_drvdata *drvdata = hid_get_drvdata(hdev);



	if (drvdata->quirks & QUIRK_SKIP_INPUT_MAPPING) {

		/* Don't map anything from the HID report.

		 * We do it all manually in asus_input_configured

		 */

		return -1;

	}



	return 0;

}



static int asus_start_multitouch(struct hid_device *hdev)

{

	int ret;

	const unsigned char buf[] = { FEATURE_REPORT_ID, 0x00, 0x03, 0x01, 0x00 };

	unsigned char *dmabuf = kmemdup(buf, sizeof(buf), GFP_KERNEL);



	if (!dmabuf) {

		ret = -ENOMEM;

		hid_err(hdev, "Asus failed to alloc dma buf: %d\n", ret);

		return ret;

	}



	ret = hid_hw_raw_request(hdev, dmabuf[0], dmabuf, sizeof(buf),

					HID_FEATURE_REPORT, HID_REQ_SET_REPORT);



	kfree(dmabuf);



	if (ret != sizeof(buf)) {

		hid_err(hdev, "Asus failed to start multitouch: %d\n", ret);

		return ret;

	}



	return 0;

}



static int __maybe_unused asus_reset_resume(struct hid_device *hdev)

{

	struct asus_drvdata *drvdata = hid_get_drvdata(hdev);



	if (drvdata->quirks & QUIRK_IS_MULTITOUCH)

		return asus_start_multitouch(hdev);



	return 0;

}



static int asus_probe(struct hid_device *hdev, const struct hid_device_id *id)

{

	int ret;

	struct asus_drvdata *drvdata;



	drvdata = devm_kzalloc(&hdev->dev, sizeof(*drvdata), GFP_KERNEL);

	if (drvdata == NULL) {

		hid_err(hdev, "Can't alloc Asus descriptor\n");

		return -ENOMEM;

	}



	hid_set_drvdata(hdev, drvdata);



	drvdata->quirks = id->driver_data;



	if (drvdata->quirks & QUIRK_NO_INIT_REPORTS)

		hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;



	ret = hid_parse(hdev);

	if (ret) {

		hid_err(hdev, "Asus hid parse failed: %d\n", ret);

		return ret;

	}



	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);

	if (ret) {

		hid_err(hdev, "Asus hw start failed: %d\n", ret);

		return ret;

	}



	if (!drvdata->input) {

		hid_err(hdev, "Asus input not registered\n");

		ret = -ENOMEM;

		goto err_stop_hw;

	}



	drvdata->input->name = "Asus TouchPad";



	if (drvdata->quirks & QUIRK_IS_MULTITOUCH) {

		ret = asus_start_multitouch(hdev);

		if (ret)

			goto err_stop_hw;

	}



	return 0;

err_stop_hw:

	hid_hw_stop(hdev);

	return ret;

}



static __u8 *asus_report_fixup(struct hid_device *hdev, __u8 *rdesc,

		unsigned int *rsize)

{

	if (*rsize >= 56 && rdesc[54] == 0x25 && rdesc[55] == 0x65) {

	struct asus_drvdata *drvdata = hid_get_drvdata(hdev);



	if (drvdata->quirks & QUIRK_FIX_NOTEBOOK_REPORT &&

			*rsize >= 56 && rdesc[54] == 0x25 && rdesc[55] == 0x65) {

		hid_info(hdev, "Fixing up Asus notebook report descriptor\n");

		rdesc[55] = 0xdd;

	}
@@ -37,7 +314,10 @@ static __u8 *asus_report_fixup(struct hid_device *hdev, __u8 *rdesc, 
}



static const struct hid_device_id asus_devices[] = {

	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_NOTEBOOK_KEYBOARD) },

	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK,

		 USB_DEVICE_ID_ASUSTEK_NOTEBOOK_KEYBOARD), NOTEBOOK_QUIRKS},

	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK,

			 USB_DEVICE_ID_ASUSTEK_TOUCHPAD), TOUCHPAD_QUIRKS },

	{ }

};

MODULE_DEVICE_TABLE(hid, asus_devices);
@@ -45,7 +325,14 @@ MODULE_DEVICE_TABLE(hid, asus_devices); 
static struct hid_driver asus_driver = {

	.name			= "asus",

	.id_table		= asus_devices,

	.report_fixup = asus_report_fixup

	.report_fixup		= asus_report_fixup,

	.probe                  = asus_probe,

	.input_mapping          = asus_input_mapping,

	.input_configured       = asus_input_configured,

#ifdef CONFIG_PM

	.reset_resume           = asus_reset_resume,

#endif

	.raw_event		= asus_raw_event

};

module_hid_driver(asus_driver);

drivers/hid/hid-core.c

+12 −2
Original line number Diff line number Diff line
@@ -727,8 +727,9 @@ static void hid_scan_collection(struct hid_parser *parser, unsigned type) 
	    (hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3 ||

	     hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2 ||

	     hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP ||

	     hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4 ||

	     hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2 ||

	     hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP ||

	     hid->product == USB_DEVICE_ID_MS_TYPE_COVER_3 ||

	     hid->product == USB_DEVICE_ID_MS_POWER_COVER) &&

	    hid->group == HID_GROUP_MULTITOUCH)

		hid->group = HID_GROUP_GENERIC;
@@ -1857,6 +1858,7 @@ static const struct hid_device_id hid_have_special_driver[] = { 
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },

	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_NOTEBOOK_KEYBOARD) },

	{ HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_TOUCHPAD) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185BFM, 0x2208) },
@@ -1883,6 +1885,9 @@ static const struct hid_device_id hid_have_special_driver[] = { 
	{ HID_USB_DEVICE(USB_VENDOR_ID_DELCOM, USB_DEVICE_ID_DELCOM_VISUAL_IND) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },

#if IS_ENABLED(CONFIG_HID_MAYFLASH)

	{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3) },

#endif

	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_WN) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_FA) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
@@ -1983,8 +1988,9 @@ static const struct hid_device_id hid_have_special_driver[] = { 
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_3) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1) },
@@ -2059,6 +2065,9 @@ static const struct hid_device_id hid_have_special_driver[] = { 
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER) },
@@ -2086,6 +2095,7 @@ static const struct hid_device_id hid_have_special_driver[] = { 
	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_THQ, USB_DEVICE_ID_THQ_PS3_UDRAW) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_YIYNOVA_TABLET) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_81) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_45) },