aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hid
diff options
context:
space:
mode:
authorDmitry Torokhov <dmitry.torokhov@gmail.com>2014-08-07 02:36:12 -0400
committerDmitry Torokhov <dmitry.torokhov@gmail.com>2014-08-07 02:36:12 -0400
commit5e2aa2ed08e2e280121dc7cf5609c87d464f12ef (patch)
treeca7d7b1480285e3b617fecc5b41f0ce150a82c32 /drivers/hid
parentf62d14a8072b9756db36ba394e2b267470a40240 (diff)
parentfc8104bc5a3f6f49d79f45f2706f79f77a9fb2ae (diff)
Merge branch 'next' into for-linus
Prepare first round of input updates for 3.17.
Diffstat (limited to 'drivers/hid')
-rw-r--r--drivers/hid/Kconfig28
-rw-r--r--drivers/hid/Makefile5
-rw-r--r--drivers/hid/hid-core.c36
-rw-r--r--drivers/hid/hid-debug.c91
-rw-r--r--drivers/hid/hid-ids.h12
-rw-r--r--drivers/hid/hid-input.c19
-rw-r--r--drivers/hid/hid-lg4ff.c2
-rw-r--r--drivers/hid/hid-picolcd_fb.c2
-rw-r--r--drivers/hid/hid-rmi.c922
-rw-r--r--drivers/hid/hid-saitek.c154
-rw-r--r--drivers/hid/hid-sensor-hub.c36
-rw-r--r--drivers/hid/hid-sony.c434
-rw-r--r--drivers/hid/hid-thingm.c361
-rw-r--r--drivers/hid/hid-wacom.c973
-rw-r--r--drivers/hid/i2c-hid/i2c-hid.c45
-rw-r--r--drivers/hid/uhid.c5
-rw-r--r--drivers/hid/usbhid/hid-quirks.c4
-rw-r--r--drivers/hid/wacom.h146
-rw-r--r--drivers/hid/wacom_sys.c1456
-rw-r--r--drivers/hid/wacom_wac.c2721
-rw-r--r--drivers/hid/wacom_wac.h179
21 files changed, 6338 insertions, 1293 deletions
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 7af9d0b5dea1..4ed682cd1236 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -608,7 +608,10 @@ config HID_SAITEK
608 Support for Saitek devices that are not fully compliant with the 608 Support for Saitek devices that are not fully compliant with the
609 HID standard. 609 HID standard.
610 610
611 Currently only supports the PS1000 controller. 611 Supported devices:
612 - PS1000 Dual Analog Pad
613 - R.A.T.7 Gaming Mouse
614 - M.M.O.7 Gaming Mouse
612 615
613config HID_SAMSUNG 616config HID_SAMSUNG
614 tristate "Samsung InfraRed remote control or keyboards" 617 tristate "Samsung InfraRed remote control or keyboards"
@@ -657,6 +660,14 @@ config HID_SUNPLUS
657 ---help--- 660 ---help---
658 Support for Sunplus wireless desktop. 661 Support for Sunplus wireless desktop.
659 662
663config HID_RMI
664 tristate "Synaptics RMI4 device support"
665 depends on HID
666 ---help---
667 Support for Synaptics RMI4 touchpads.
668 Say Y here if you have a Synaptics RMI4 touchpads over i2c-hid or usbhid
669 and want support for its special functionalities.
670
660config HID_GREENASIA 671config HID_GREENASIA
661 tristate "GreenAsia (Product ID 0x12) game controller support" 672 tristate "GreenAsia (Product ID 0x12) game controller support"
662 depends on HID 673 depends on HID
@@ -737,12 +748,17 @@ config THRUSTMASTER_FF
737 Rumble Force or Force Feedback Wheel. 748 Rumble Force or Force Feedback Wheel.
738 749
739config HID_WACOM 750config HID_WACOM
740 tristate "Wacom Bluetooth devices support" 751 tristate "Wacom Intuos/Graphire tablet support (USB)"
741 depends on HID 752 depends on HID
742 depends on LEDS_CLASS
743 select POWER_SUPPLY 753 select POWER_SUPPLY
744 ---help--- 754 select NEW_LEDS
745 Support for Wacom Graphire Bluetooth and Intuos4 WL tablets. 755 select LEDS_CLASS
756 help
757 Say Y here if you want to use the USB or BT version of the Wacom Intuos
758 or Graphire tablet.
759
760 To compile this driver as a module, choose M here: the
761 module will be called wacom.
746 762
747config HID_WIIMOTE 763config HID_WIIMOTE
748 tristate "Nintendo Wii / Wii U peripherals" 764 tristate "Nintendo Wii / Wii U peripherals"
@@ -799,7 +815,7 @@ config HID_ZYDACRON
799 815
800config HID_SENSOR_HUB 816config HID_SENSOR_HUB
801 tristate "HID Sensors framework support" 817 tristate "HID Sensors framework support"
802 depends on HID 818 depends on HID && HAS_IOMEM
803 select MFD_CORE 819 select MFD_CORE
804 default n 820 default n
805 ---help--- 821 ---help---
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index fc712dde02a4..e38c772ace76 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -97,6 +97,7 @@ obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o hid-roccat-common.o \
97 hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \ 97 hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \
98 hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \ 98 hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \
99 hid-roccat-lua.o hid-roccat-pyra.o hid-roccat-ryos.o hid-roccat-savu.o 99 hid-roccat-lua.o hid-roccat-pyra.o hid-roccat-ryos.o hid-roccat-savu.o
100obj-$(CONFIG_HID_RMI) += hid-rmi.o
100obj-$(CONFIG_HID_SAITEK) += hid-saitek.o 101obj-$(CONFIG_HID_SAITEK) += hid-saitek.o
101obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o 102obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o
102obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o 103obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o
@@ -114,7 +115,9 @@ obj-$(CONFIG_HID_UCLOGIC) += hid-uclogic.o
114obj-$(CONFIG_HID_XINMO) += hid-xinmo.o 115obj-$(CONFIG_HID_XINMO) += hid-xinmo.o
115obj-$(CONFIG_HID_ZEROPLUS) += hid-zpff.o 116obj-$(CONFIG_HID_ZEROPLUS) += hid-zpff.o
116obj-$(CONFIG_HID_ZYDACRON) += hid-zydacron.o 117obj-$(CONFIG_HID_ZYDACRON) += hid-zydacron.o
117obj-$(CONFIG_HID_WACOM) += hid-wacom.o 118
119wacom-objs := wacom_wac.o wacom_sys.o
120obj-$(CONFIG_HID_WACOM) += wacom.o
118obj-$(CONFIG_HID_WALTOP) += hid-waltop.o 121obj-$(CONFIG_HID_WALTOP) += hid-waltop.o
119obj-$(CONFIG_HID_WIIMOTE) += hid-wiimote.o 122obj-$(CONFIG_HID_WIIMOTE) += hid-wiimote.o
120obj-$(CONFIG_HID_SENSOR_HUB) += hid-sensor-hub.o 123obj-$(CONFIG_HID_SENSOR_HUB) += hid-sensor-hub.o
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index da52279de939..b3181ea8f860 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -779,6 +779,23 @@ static int hid_scan_report(struct hid_device *hid)
779 (hid->group == HID_GROUP_MULTITOUCH)) 779 (hid->group == HID_GROUP_MULTITOUCH))
780 hid->group = HID_GROUP_MULTITOUCH_WIN_8; 780 hid->group = HID_GROUP_MULTITOUCH_WIN_8;
781 781
782 /*
783 * Vendor specific handlings
784 */
785 if ((hid->vendor == USB_VENDOR_ID_SYNAPTICS) &&
786 (hid->group == HID_GROUP_GENERIC))
787 /* hid-rmi should take care of them, not hid-generic */
788 hid->group = HID_GROUP_RMI;
789
790 /*
791 * Vendor specific handlings
792 */
793 switch (hid->vendor) {
794 case USB_VENDOR_ID_WACOM:
795 hid->group = HID_GROUP_WACOM;
796 break;
797 }
798
782 vfree(parser); 799 vfree(parser);
783 return 0; 800 return 0;
784} 801}
@@ -842,7 +859,17 @@ struct hid_report *hid_validate_values(struct hid_device *hid,
842 * ->numbered being checked, which may not always be the case when 859 * ->numbered being checked, which may not always be the case when
843 * drivers go to access report values. 860 * drivers go to access report values.
844 */ 861 */
845 report = hid->report_enum[type].report_id_hash[id]; 862 if (id == 0) {
863 /*
864 * Validating on id 0 means we should examine the first
865 * report in the list.
866 */
867 report = list_entry(
868 hid->report_enum[type].report_list.next,
869 struct hid_report, list);
870 } else {
871 report = hid->report_enum[type].report_id_hash[id];
872 }
846 if (!report) { 873 if (!report) {
847 hid_err(hid, "missing %s %u\n", hid_report_names[type], id); 874 hid_err(hid, "missing %s %u\n", hid_report_names[type], id);
848 return NULL; 875 return NULL;
@@ -1868,7 +1895,11 @@ static const struct hid_device_id hid_have_special_driver[] = {
1868 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO) }, 1895 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO) },
1869 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_SAVU) }, 1896 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_SAVU) },
1870#endif 1897#endif
1898#if IS_ENABLED(CONFIG_HID_SAITEK)
1871 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) }, 1899 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },
1900 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7) },
1901 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7) },
1902#endif
1872 { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) }, 1903 { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
1873 { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) }, 1904 { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
1874 { HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) }, 1905 { HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
@@ -1911,8 +1942,6 @@ static const struct hid_device_id hid_have_special_driver[] = {
1911 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) }, 1942 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
1912 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) }, 1943 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
1913 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) }, 1944 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
1914 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
1915 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },
1916 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) }, 1945 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
1917 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) }, 1946 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
1918 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) }, 1947 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },
@@ -2317,7 +2346,6 @@ static const struct hid_device_id hid_ignore_list[] = {
2317 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) }, 2346 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
2318 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) }, 2347 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
2319 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) }, 2348 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
2320 { HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },
2321 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) }, 2349 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },
2322 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) }, 2350 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },
2323 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) }, 2351 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
index 53b771d5683c..84c3cb15ccdd 100644
--- a/drivers/hid/hid-debug.c
+++ b/drivers/hid/hid-debug.c
@@ -165,6 +165,8 @@ static const struct hid_usage_entry hid_usage_table[] = {
165 {0, 0x53, "DeviceIndex"}, 165 {0, 0x53, "DeviceIndex"},
166 {0, 0x54, "ContactCount"}, 166 {0, 0x54, "ContactCount"},
167 {0, 0x55, "ContactMaximumNumber"}, 167 {0, 0x55, "ContactMaximumNumber"},
168 {0, 0x5A, "SecondaryBarrelSwitch"},
169 {0, 0x5B, "TransducerSerialNumber"},
168 { 15, 0, "PhysicalInterfaceDevice" }, 170 { 15, 0, "PhysicalInterfaceDevice" },
169 {0, 0x00, "Undefined"}, 171 {0, 0x00, "Undefined"},
170 {0, 0x01, "Physical_Interface_Device"}, 172 {0, 0x01, "Physical_Interface_Device"},
@@ -272,6 +274,85 @@ static const struct hid_usage_entry hid_usage_table[] = {
272 {0, 0xAA, "Shared_Parameter_Blocks"}, 274 {0, 0xAA, "Shared_Parameter_Blocks"},
273 {0, 0xAB, "Create_New_Effect_Report"}, 275 {0, 0xAB, "Create_New_Effect_Report"},
274 {0, 0xAC, "RAM_Pool_Available"}, 276 {0, 0xAC, "RAM_Pool_Available"},
277 { 0x20, 0, "Sensor" },
278 { 0x20, 0x01, "Sensor" },
279 { 0x20, 0x10, "Biometric" },
280 { 0x20, 0x11, "BiometricHumanPresence" },
281 { 0x20, 0x12, "BiometricHumanProximity" },
282 { 0x20, 0x13, "BiometricHumanTouch" },
283 { 0x20, 0x20, "Electrical" },
284 { 0x20, 0x21, "ElectricalCapacitance" },
285 { 0x20, 0x22, "ElectricalCurrent" },
286 { 0x20, 0x23, "ElectricalPower" },
287 { 0x20, 0x24, "ElectricalInductance" },
288 { 0x20, 0x25, "ElectricalResistance" },
289 { 0x20, 0x26, "ElectricalVoltage" },
290 { 0x20, 0x27, "ElectricalPoteniometer" },
291 { 0x20, 0x28, "ElectricalFrequency" },
292 { 0x20, 0x29, "ElectricalPeriod" },
293 { 0x20, 0x30, "Environmental" },
294 { 0x20, 0x31, "EnvironmentalAtmosphericPressure" },
295 { 0x20, 0x32, "EnvironmentalHumidity" },
296 { 0x20, 0x33, "EnvironmentalTemperature" },
297 { 0x20, 0x34, "EnvironmentalWindDirection" },
298 { 0x20, 0x35, "EnvironmentalWindSpeed" },
299 { 0x20, 0x40, "Light" },
300 { 0x20, 0x41, "LightAmbientLight" },
301 { 0x20, 0x42, "LightConsumerInfrared" },
302 { 0x20, 0x50, "Location" },
303 { 0x20, 0x51, "LocationBroadcast" },
304 { 0x20, 0x52, "LocationDeadReckoning" },
305 { 0x20, 0x53, "LocationGPS" },
306 { 0x20, 0x54, "LocationLookup" },
307 { 0x20, 0x55, "LocationOther" },
308 { 0x20, 0x56, "LocationStatic" },
309 { 0x20, 0x57, "LocationTriangulation" },
310 { 0x20, 0x60, "Mechanical" },
311 { 0x20, 0x61, "MechanicalBooleanSwitch" },
312 { 0x20, 0x62, "MechanicalBooleanSwitchArray" },
313 { 0x20, 0x63, "MechanicalMultivalueSwitch" },
314 { 0x20, 0x64, "MechanicalForce" },
315 { 0x20, 0x65, "MechanicalPressure" },
316 { 0x20, 0x66, "MechanicalStrain" },
317 { 0x20, 0x67, "MechanicalWeight" },
318 { 0x20, 0x68, "MechanicalHapticVibrator" },
319 { 0x20, 0x69, "MechanicalHallEffectSwitch" },
320 { 0x20, 0x70, "Motion" },
321 { 0x20, 0x71, "MotionAccelerometer1D" },
322 { 0x20, 0x72, "MotionAccelerometer2D" },
323 { 0x20, 0x73, "MotionAccelerometer3D" },
324 { 0x20, 0x74, "MotionGyrometer1D" },
325 { 0x20, 0x75, "MotionGyrometer2D" },
326 { 0x20, 0x76, "MotionGyrometer3D" },
327 { 0x20, 0x77, "MotionMotionDetector" },
328 { 0x20, 0x78, "MotionSpeedometer" },
329 { 0x20, 0x79, "MotionAccelerometer" },
330 { 0x20, 0x7A, "MotionGyrometer" },
331 { 0x20, 0x80, "Orientation" },
332 { 0x20, 0x81, "OrientationCompass1D" },
333 { 0x20, 0x82, "OrientationCompass2D" },
334 { 0x20, 0x83, "OrientationCompass3D" },
335 { 0x20, 0x84, "OrientationInclinometer1D" },
336 { 0x20, 0x85, "OrientationInclinometer2D" },
337 { 0x20, 0x86, "OrientationInclinometer3D" },
338 { 0x20, 0x87, "OrientationDistance1D" },
339 { 0x20, 0x88, "OrientationDistance2D" },
340 { 0x20, 0x89, "OrientationDistance3D" },
341 { 0x20, 0x8A, "OrientationDeviceOrientation" },
342 { 0x20, 0x8B, "OrientationCompass" },
343 { 0x20, 0x8C, "OrientationInclinometer" },
344 { 0x20, 0x8D, "OrientationDistance" },
345 { 0x20, 0x90, "Scanner" },
346 { 0x20, 0x91, "ScannerBarcode" },
347 { 0x20, 0x91, "ScannerRFID" },
348 { 0x20, 0x91, "ScannerNFC" },
349 { 0x20, 0xA0, "Time" },
350 { 0x20, 0xA1, "TimeAlarmTimer" },
351 { 0x20, 0xA2, "TimeRealTimeClock" },
352 { 0x20, 0xE0, "Other" },
353 { 0x20, 0xE1, "OtherCustom" },
354 { 0x20, 0xE2, "OtherGeneric" },
355 { 0x20, 0xE3, "OtherGenericEnumerator" },
275 { 0x84, 0, "Power Device" }, 356 { 0x84, 0, "Power Device" },
276 { 0x84, 0x02, "PresentStatus" }, 357 { 0x84, 0x02, "PresentStatus" },
277 { 0x84, 0x03, "ChangeStatus" }, 358 { 0x84, 0x03, "ChangeStatus" },
@@ -855,6 +936,16 @@ static const char *keys[KEY_MAX + 1] = {
855 [KEY_KBDILLUMDOWN] = "KbdIlluminationDown", 936 [KEY_KBDILLUMDOWN] = "KbdIlluminationDown",
856 [KEY_KBDILLUMUP] = "KbdIlluminationUp", 937 [KEY_KBDILLUMUP] = "KbdIlluminationUp",
857 [KEY_SWITCHVIDEOMODE] = "SwitchVideoMode", 938 [KEY_SWITCHVIDEOMODE] = "SwitchVideoMode",
939 [KEY_BUTTONCONFIG] = "ButtonConfig",
940 [KEY_TASKMANAGER] = "TaskManager",
941 [KEY_JOURNAL] = "Journal",
942 [KEY_CONTROLPANEL] = "ControlPanel",
943 [KEY_APPSELECT] = "AppSelect",
944 [KEY_SCREENSAVER] = "ScreenSaver",
945 [KEY_VOICECOMMAND] = "VoiceCommand",
946 [KEY_BRIGHTNESS_MIN] = "BrightnessMin",
947 [KEY_BRIGHTNESS_MAX] = "BrightnessMax",
948 [KEY_BRIGHTNESS_AUTO] = "BrightnessAuto",
858}; 949};
859 950
860static const char *relatives[REL_MAX + 1] = { 951static const char *relatives[REL_MAX + 1] = {
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 34bb2205d2ea..48b66bbffc94 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -323,6 +323,7 @@
323 323
324#define USB_VENDOR_ID_ETURBOTOUCH 0x22b9 324#define USB_VENDOR_ID_ETURBOTOUCH 0x22b9
325#define USB_DEVICE_ID_ETURBOTOUCH 0x0006 325#define USB_DEVICE_ID_ETURBOTOUCH 0x0006
326#define USB_DEVICE_ID_ETURBOTOUCH_2968 0x2968
326 327
327#define USB_VENDOR_ID_EZKEY 0x0518 328#define USB_VENDOR_ID_EZKEY 0x0518
328#define USB_DEVICE_ID_BTC_8193 0x0002 329#define USB_DEVICE_ID_BTC_8193 0x0002
@@ -463,6 +464,7 @@
463 464
464#define USB_VENDOR_ID_STM_0 0x0483 465#define USB_VENDOR_ID_STM_0 0x0483
465#define USB_DEVICE_ID_STM_HID_SENSOR 0x91d1 466#define USB_DEVICE_ID_STM_HID_SENSOR 0x91d1
467#define USB_DEVICE_ID_STM_HID_SENSOR_1 0x9100
466 468
467#define USB_VENDOR_ID_ION 0x15e4 469#define USB_VENDOR_ID_ION 0x15e4
468#define USB_DEVICE_ID_ICADE 0x0132 470#define USB_DEVICE_ID_ICADE 0x0132
@@ -633,6 +635,9 @@
633#define USB_DEVICE_ID_MS_PRESENTER_8K_USB 0x0713 635#define USB_DEVICE_ID_MS_PRESENTER_8K_USB 0x0713
634#define USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K 0x0730 636#define USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K 0x0730
635#define USB_DEVICE_ID_MS_COMFORT_MOUSE_4500 0x076c 637#define USB_DEVICE_ID_MS_COMFORT_MOUSE_4500 0x076c
638#define USB_DEVICE_ID_MS_SURFACE_PRO_2 0x0799
639#define USB_DEVICE_ID_MS_TOUCH_COVER_2 0x07a7
640#define USB_DEVICE_ID_MS_TYPE_COVER_2 0x07a9
636 641
637#define USB_VENDOR_ID_MOJO 0x8282 642#define USB_VENDOR_ID_MOJO 0x8282
638#define USB_DEVICE_ID_RETRO_ADAPTER 0x3201 643#define USB_DEVICE_ID_RETRO_ADAPTER 0x3201
@@ -711,6 +716,8 @@
711 716
712#define USB_VENDOR_ID_PENMOUNT 0x14e1 717#define USB_VENDOR_ID_PENMOUNT 0x14e1
713#define USB_DEVICE_ID_PENMOUNT_PCI 0x3500 718#define USB_DEVICE_ID_PENMOUNT_PCI 0x3500
719#define USB_DEVICE_ID_PENMOUNT_1610 0x1610
720#define USB_DEVICE_ID_PENMOUNT_1640 0x1640
714 721
715#define USB_VENDOR_ID_PETALYNX 0x18b1 722#define USB_VENDOR_ID_PETALYNX 0x18b1
716#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE 0x0037 723#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE 0x0037
@@ -764,11 +771,16 @@
764#define USB_VENDOR_ID_SAITEK 0x06a3 771#define USB_VENDOR_ID_SAITEK 0x06a3
765#define USB_DEVICE_ID_SAITEK_RUMBLEPAD 0xff17 772#define USB_DEVICE_ID_SAITEK_RUMBLEPAD 0xff17
766#define USB_DEVICE_ID_SAITEK_PS1000 0x0621 773#define USB_DEVICE_ID_SAITEK_PS1000 0x0621
774#define USB_DEVICE_ID_SAITEK_RAT7 0x0cd7
775#define USB_DEVICE_ID_SAITEK_MMO7 0x0cd0
767 776
768#define USB_VENDOR_ID_SAMSUNG 0x0419 777#define USB_VENDOR_ID_SAMSUNG 0x0419
769#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001 778#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
770#define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE 0x0600 779#define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE 0x0600
771 780
781#define USB_VENDOR_ID_SEMICO 0x1a2c
782#define USB_DEVICE_ID_SEMICO_USB_KEYKOARD 0x0023
783
772#define USB_VENDOR_ID_SENNHEISER 0x1395 784#define USB_VENDOR_ID_SENNHEISER 0x1395
773#define USB_DEVICE_ID_SENNHEISER_BTD500USB 0x002c 785#define USB_DEVICE_ID_SENNHEISER_BTD500USB 0x002c
774 786
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index e7e8b19a9284..2619f7f4517a 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -684,9 +684,14 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
684 break; 684 break;
685 685
686 case 0x46: /* TabletPick */ 686 case 0x46: /* TabletPick */
687 case 0x5a: /* SecondaryBarrelSwitch */
687 map_key_clear(BTN_STYLUS2); 688 map_key_clear(BTN_STYLUS2);
688 break; 689 break;
689 690
691 case 0x5b: /* TransducerSerialNumber */
692 set_bit(MSC_SERIAL, input->mscbit);
693 break;
694
690 default: goto unknown; 695 default: goto unknown;
691 } 696 }
692 break; 697 break;
@@ -721,6 +726,13 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
721 case 0x06c: map_key_clear(KEY_YELLOW); break; 726 case 0x06c: map_key_clear(KEY_YELLOW); break;
722 case 0x06d: map_key_clear(KEY_ZOOM); break; 727 case 0x06d: map_key_clear(KEY_ZOOM); break;
723 728
729 case 0x06f: map_key_clear(KEY_BRIGHTNESSUP); break;
730 case 0x070: map_key_clear(KEY_BRIGHTNESSDOWN); break;
731 case 0x072: map_key_clear(KEY_BRIGHTNESS_TOGGLE); break;
732 case 0x073: map_key_clear(KEY_BRIGHTNESS_MIN); break;
733 case 0x074: map_key_clear(KEY_BRIGHTNESS_MAX); break;
734 case 0x075: map_key_clear(KEY_BRIGHTNESS_AUTO); break;
735
724 case 0x082: map_key_clear(KEY_VIDEO_NEXT); break; 736 case 0x082: map_key_clear(KEY_VIDEO_NEXT); break;
725 case 0x083: map_key_clear(KEY_LAST); break; 737 case 0x083: map_key_clear(KEY_LAST); break;
726 case 0x084: map_key_clear(KEY_ENTER); break; 738 case 0x084: map_key_clear(KEY_ENTER); break;
@@ -761,6 +773,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
761 case 0x0bf: map_key_clear(KEY_SLOW); break; 773 case 0x0bf: map_key_clear(KEY_SLOW); break;
762 774
763 case 0x0cd: map_key_clear(KEY_PLAYPAUSE); break; 775 case 0x0cd: map_key_clear(KEY_PLAYPAUSE); break;
776 case 0x0cf: map_key_clear(KEY_VOICECOMMAND); break;
764 case 0x0e0: map_abs_clear(ABS_VOLUME); break; 777 case 0x0e0: map_abs_clear(ABS_VOLUME); break;
765 case 0x0e2: map_key_clear(KEY_MUTE); break; 778 case 0x0e2: map_key_clear(KEY_MUTE); break;
766 case 0x0e5: map_key_clear(KEY_BASSBOOST); break; 779 case 0x0e5: map_key_clear(KEY_BASSBOOST); break;
@@ -768,6 +781,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
768 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN); break; 781 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN); break;
769 case 0x0f5: map_key_clear(KEY_SLOW); break; 782 case 0x0f5: map_key_clear(KEY_SLOW); break;
770 783
784 case 0x181: map_key_clear(KEY_BUTTONCONFIG); break;
771 case 0x182: map_key_clear(KEY_BOOKMARKS); break; 785 case 0x182: map_key_clear(KEY_BOOKMARKS); break;
772 case 0x183: map_key_clear(KEY_CONFIG); break; 786 case 0x183: map_key_clear(KEY_CONFIG); break;
773 case 0x184: map_key_clear(KEY_WORDPROCESSOR); break; 787 case 0x184: map_key_clear(KEY_WORDPROCESSOR); break;
@@ -781,6 +795,8 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
781 case 0x18c: map_key_clear(KEY_VOICEMAIL); break; 795 case 0x18c: map_key_clear(KEY_VOICEMAIL); break;
782 case 0x18d: map_key_clear(KEY_ADDRESSBOOK); break; 796 case 0x18d: map_key_clear(KEY_ADDRESSBOOK); break;
783 case 0x18e: map_key_clear(KEY_CALENDAR); break; 797 case 0x18e: map_key_clear(KEY_CALENDAR); break;
798 case 0x18f: map_key_clear(KEY_TASKMANAGER); break;
799 case 0x190: map_key_clear(KEY_JOURNAL); break;
784 case 0x191: map_key_clear(KEY_FINANCE); break; 800 case 0x191: map_key_clear(KEY_FINANCE); break;
785 case 0x192: map_key_clear(KEY_CALC); break; 801 case 0x192: map_key_clear(KEY_CALC); break;
786 case 0x193: map_key_clear(KEY_PLAYER); break; 802 case 0x193: map_key_clear(KEY_PLAYER); break;
@@ -789,12 +805,15 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
789 case 0x199: map_key_clear(KEY_CHAT); break; 805 case 0x199: map_key_clear(KEY_CHAT); break;
790 case 0x19c: map_key_clear(KEY_LOGOFF); break; 806 case 0x19c: map_key_clear(KEY_LOGOFF); break;
791 case 0x19e: map_key_clear(KEY_COFFEE); break; 807 case 0x19e: map_key_clear(KEY_COFFEE); break;
808 case 0x19f: map_key_clear(KEY_CONTROLPANEL); break;
809 case 0x1a2: map_key_clear(KEY_APPSELECT); break;
792 case 0x1a3: map_key_clear(KEY_NEXT); break; 810 case 0x1a3: map_key_clear(KEY_NEXT); break;
793 case 0x1a4: map_key_clear(KEY_PREVIOUS); break; 811 case 0x1a4: map_key_clear(KEY_PREVIOUS); break;
794 case 0x1a6: map_key_clear(KEY_HELP); break; 812 case 0x1a6: map_key_clear(KEY_HELP); break;
795 case 0x1a7: map_key_clear(KEY_DOCUMENTS); break; 813 case 0x1a7: map_key_clear(KEY_DOCUMENTS); break;
796 case 0x1ab: map_key_clear(KEY_SPELLCHECK); break; 814 case 0x1ab: map_key_clear(KEY_SPELLCHECK); break;
797 case 0x1ae: map_key_clear(KEY_KEYBOARD); break; 815 case 0x1ae: map_key_clear(KEY_KEYBOARD); break;
816 case 0x1b1: map_key_clear(KEY_SCREENSAVER); break;
798 case 0x1b4: map_key_clear(KEY_FILE); break; 817 case 0x1b4: map_key_clear(KEY_FILE); break;
799 case 0x1b6: map_key_clear(KEY_IMAGES); break; 818 case 0x1b6: map_key_clear(KEY_IMAGES); break;
800 case 0x1b7: map_key_clear(KEY_AUDIO); break; 819 case 0x1b7: map_key_clear(KEY_AUDIO); break;
diff --git a/drivers/hid/hid-lg4ff.c b/drivers/hid/hid-lg4ff.c
index 24883b4d1a49..cc2bd2022198 100644
--- a/drivers/hid/hid-lg4ff.c
+++ b/drivers/hid/hid-lg4ff.c
@@ -52,7 +52,7 @@ static void hid_lg4ff_set_range_g25(struct hid_device *hid, u16 range);
52static ssize_t lg4ff_range_show(struct device *dev, struct device_attribute *attr, char *buf); 52static ssize_t lg4ff_range_show(struct device *dev, struct device_attribute *attr, char *buf);
53static ssize_t lg4ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count); 53static ssize_t lg4ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
54 54
55static DEVICE_ATTR(range, S_IRWXU | S_IRWXG | S_IRWXO, lg4ff_range_show, lg4ff_range_store); 55static DEVICE_ATTR(range, S_IRWXU | S_IRWXG | S_IROTH, lg4ff_range_show, lg4ff_range_store);
56 56
57struct lg4ff_device_entry { 57struct lg4ff_device_entry {
58 __u32 product_id; 58 __u32 product_id;
diff --git a/drivers/hid/hid-picolcd_fb.c b/drivers/hid/hid-picolcd_fb.c
index c930ab8554ea..7f965e231433 100644
--- a/drivers/hid/hid-picolcd_fb.c
+++ b/drivers/hid/hid-picolcd_fb.c
@@ -501,7 +501,7 @@ static ssize_t picolcd_fb_update_rate_store(struct device *dev,
501 return count; 501 return count;
502} 502}
503 503
504static DEVICE_ATTR(fb_update_rate, 0666, picolcd_fb_update_rate_show, 504static DEVICE_ATTR(fb_update_rate, 0664, picolcd_fb_update_rate_show,
505 picolcd_fb_update_rate_store); 505 picolcd_fb_update_rate_store);
506 506
507/* initialize Framebuffer device */ 507/* initialize Framebuffer device */
diff --git a/drivers/hid/hid-rmi.c b/drivers/hid/hid-rmi.c
new file mode 100644
index 000000000000..578bbe65902b
--- /dev/null
+++ b/drivers/hid/hid-rmi.c
@@ -0,0 +1,922 @@
1/*
2 * Copyright (c) 2013 Andrew Duggan <aduggan@synaptics.com>
3 * Copyright (c) 2013 Synaptics Incorporated
4 * Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@gmail.com>
5 * Copyright (c) 2014 Red Hat, Inc
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 */
12
13#include <linux/kernel.h>
14#include <linux/hid.h>
15#include <linux/input.h>
16#include <linux/input/mt.h>
17#include <linux/module.h>
18#include <linux/pm.h>
19#include <linux/slab.h>
20#include <linux/wait.h>
21#include <linux/sched.h>
22#include "hid-ids.h"
23
24#define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */
25#define RMI_WRITE_REPORT_ID 0x09 /* Output Report */
26#define RMI_READ_ADDR_REPORT_ID 0x0a /* Output Report */
27#define RMI_READ_DATA_REPORT_ID 0x0b /* Input Report */
28#define RMI_ATTN_REPORT_ID 0x0c /* Input Report */
29#define RMI_SET_RMI_MODE_REPORT_ID 0x0f /* Feature Report */
30
31/* flags */
32#define RMI_READ_REQUEST_PENDING BIT(0)
33#define RMI_READ_DATA_PENDING BIT(1)
34#define RMI_STARTED BIT(2)
35
36enum rmi_mode_type {
37 RMI_MODE_OFF = 0,
38 RMI_MODE_ATTN_REPORTS = 1,
39 RMI_MODE_NO_PACKED_ATTN_REPORTS = 2,
40};
41
42struct rmi_function {
43 unsigned page; /* page of the function */
44 u16 query_base_addr; /* base address for queries */
45 u16 command_base_addr; /* base address for commands */
46 u16 control_base_addr; /* base address for controls */
47 u16 data_base_addr; /* base address for datas */
48 unsigned int interrupt_base; /* cross-function interrupt number
49 * (uniq in the device)*/
50 unsigned int interrupt_count; /* number of interrupts */
51 unsigned int report_size; /* size of a report */
52 unsigned long irq_mask; /* mask of the interrupts
53 * (to be applied against ATTN IRQ) */
54};
55
56/**
57 * struct rmi_data - stores information for hid communication
58 *
59 * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
60 * @page: Keeps track of the current virtual page
61 *
62 * @wait: Used for waiting for read data
63 *
64 * @writeReport: output buffer when writing RMI registers
65 * @readReport: input buffer when reading RMI registers
66 *
67 * @input_report_size: size of an input report (advertised by HID)
68 * @output_report_size: size of an output report (advertised by HID)
69 *
70 * @flags: flags for the current device (started, reading, etc...)
71 *
72 * @f11: placeholder of internal RMI function F11 description
73 * @f30: placeholder of internal RMI function F30 description
74 *
75 * @max_fingers: maximum finger count reported by the device
76 * @max_x: maximum x value reported by the device
77 * @max_y: maximum y value reported by the device
78 *
79 * @gpio_led_count: count of GPIOs + LEDs reported by F30
80 * @button_count: actual physical buttons count
81 * @button_mask: button mask used to decode GPIO ATTN reports
82 * @button_state_mask: pull state of the buttons
83 *
84 * @input: pointer to the kernel input device
85 *
86 * @reset_work: worker which will be called in case of a mouse report
87 * @hdev: pointer to the struct hid_device
88 */
89struct rmi_data {
90 struct mutex page_mutex;
91 int page;
92
93 wait_queue_head_t wait;
94
95 u8 *writeReport;
96 u8 *readReport;
97
98 int input_report_size;
99 int output_report_size;
100
101 unsigned long flags;
102
103 struct rmi_function f11;
104 struct rmi_function f30;
105
106 unsigned int max_fingers;
107 unsigned int max_x;
108 unsigned int max_y;
109 unsigned int x_size_mm;
110 unsigned int y_size_mm;
111
112 unsigned int gpio_led_count;
113 unsigned int button_count;
114 unsigned long button_mask;
115 unsigned long button_state_mask;
116
117 struct input_dev *input;
118
119 struct work_struct reset_work;
120 struct hid_device *hdev;
121};
122
123#define RMI_PAGE(addr) (((addr) >> 8) & 0xff)
124
125static int rmi_write_report(struct hid_device *hdev, u8 *report, int len);
126
127/**
128 * rmi_set_page - Set RMI page
129 * @hdev: The pointer to the hid_device struct
130 * @page: The new page address.
131 *
132 * RMI devices have 16-bit addressing, but some of the physical
133 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
134 * a page address at 0xff of every page so we can reliable page addresses
135 * every 256 registers.
136 *
137 * The page_mutex lock must be held when this function is entered.
138 *
139 * Returns zero on success, non-zero on failure.
140 */
141static int rmi_set_page(struct hid_device *hdev, u8 page)
142{
143 struct rmi_data *data = hid_get_drvdata(hdev);
144 int retval;
145
146 data->writeReport[0] = RMI_WRITE_REPORT_ID;
147 data->writeReport[1] = 1;
148 data->writeReport[2] = 0xFF;
149 data->writeReport[4] = page;
150
151 retval = rmi_write_report(hdev, data->writeReport,
152 data->output_report_size);
153 if (retval != data->output_report_size) {
154 dev_err(&hdev->dev,
155 "%s: set page failed: %d.", __func__, retval);
156 return retval;
157 }
158
159 data->page = page;
160 return 0;
161}
162
163static int rmi_set_mode(struct hid_device *hdev, u8 mode)
164{
165 int ret;
166 u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode};
167
168 ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, txbuf,
169 sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
170 if (ret < 0) {
171 dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode,
172 ret);
173 return ret;
174 }
175
176 return 0;
177}
178
179static int rmi_write_report(struct hid_device *hdev, u8 *report, int len)
180{
181 int ret;
182
183 ret = hid_hw_output_report(hdev, (void *)report, len);
184 if (ret < 0) {
185 dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret);
186 return ret;
187 }
188
189 return ret;
190}
191
192static int rmi_read_block(struct hid_device *hdev, u16 addr, void *buf,
193 const int len)
194{
195 struct rmi_data *data = hid_get_drvdata(hdev);
196 int ret;
197 int bytes_read;
198 int bytes_needed;
199 int retries;
200 int read_input_count;
201
202 mutex_lock(&data->page_mutex);
203
204 if (RMI_PAGE(addr) != data->page) {
205 ret = rmi_set_page(hdev, RMI_PAGE(addr));
206 if (ret < 0)
207 goto exit;
208 }
209
210 for (retries = 5; retries > 0; retries--) {
211 data->writeReport[0] = RMI_READ_ADDR_REPORT_ID;
212 data->writeReport[1] = 0; /* old 1 byte read count */
213 data->writeReport[2] = addr & 0xFF;
214 data->writeReport[3] = (addr >> 8) & 0xFF;
215 data->writeReport[4] = len & 0xFF;
216 data->writeReport[5] = (len >> 8) & 0xFF;
217
218 set_bit(RMI_READ_REQUEST_PENDING, &data->flags);
219
220 ret = rmi_write_report(hdev, data->writeReport,
221 data->output_report_size);
222 if (ret != data->output_report_size) {
223 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
224 dev_err(&hdev->dev,
225 "failed to write request output report (%d)\n",
226 ret);
227 goto exit;
228 }
229
230 bytes_read = 0;
231 bytes_needed = len;
232 while (bytes_read < len) {
233 if (!wait_event_timeout(data->wait,
234 test_bit(RMI_READ_DATA_PENDING, &data->flags),
235 msecs_to_jiffies(1000))) {
236 hid_warn(hdev, "%s: timeout elapsed\n",
237 __func__);
238 ret = -EAGAIN;
239 break;
240 }
241
242 read_input_count = data->readReport[1];
243 memcpy(buf + bytes_read, &data->readReport[2],
244 read_input_count < bytes_needed ?
245 read_input_count : bytes_needed);
246
247 bytes_read += read_input_count;
248 bytes_needed -= read_input_count;
249 clear_bit(RMI_READ_DATA_PENDING, &data->flags);
250 }
251
252 if (ret >= 0) {
253 ret = 0;
254 break;
255 }
256 }
257
258exit:
259 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
260 mutex_unlock(&data->page_mutex);
261 return ret;
262}
263
264static inline int rmi_read(struct hid_device *hdev, u16 addr, void *buf)
265{
266 return rmi_read_block(hdev, addr, buf, 1);
267}
268
269static void rmi_f11_process_touch(struct rmi_data *hdata, int slot,
270 u8 finger_state, u8 *touch_data)
271{
272 int x, y, wx, wy;
273 int wide, major, minor;
274 int z;
275
276 input_mt_slot(hdata->input, slot);
277 input_mt_report_slot_state(hdata->input, MT_TOOL_FINGER,
278 finger_state == 0x01);
279 if (finger_state == 0x01) {
280 x = (touch_data[0] << 4) | (touch_data[2] & 0x0F);
281 y = (touch_data[1] << 4) | (touch_data[2] >> 4);
282 wx = touch_data[3] & 0x0F;
283 wy = touch_data[3] >> 4;
284 wide = (wx > wy);
285 major = max(wx, wy);
286 minor = min(wx, wy);
287 z = touch_data[4];
288
289 /* y is inverted */
290 y = hdata->max_y - y;
291
292 input_event(hdata->input, EV_ABS, ABS_MT_POSITION_X, x);
293 input_event(hdata->input, EV_ABS, ABS_MT_POSITION_Y, y);
294 input_event(hdata->input, EV_ABS, ABS_MT_ORIENTATION, wide);
295 input_event(hdata->input, EV_ABS, ABS_MT_PRESSURE, z);
296 input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
297 input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
298 }
299}
300
301static void rmi_reset_work(struct work_struct *work)
302{
303 struct rmi_data *hdata = container_of(work, struct rmi_data,
304 reset_work);
305
306 /* switch the device to RMI if we receive a generic mouse report */
307 rmi_set_mode(hdata->hdev, RMI_MODE_ATTN_REPORTS);
308}
309
310static inline int rmi_schedule_reset(struct hid_device *hdev)
311{
312 struct rmi_data *hdata = hid_get_drvdata(hdev);
313 return schedule_work(&hdata->reset_work);
314}
315
316static int rmi_f11_input_event(struct hid_device *hdev, u8 irq, u8 *data,
317 int size)
318{
319 struct rmi_data *hdata = hid_get_drvdata(hdev);
320 int offset;
321 int i;
322
323 if (size < hdata->f11.report_size)
324 return 0;
325
326 if (!(irq & hdata->f11.irq_mask))
327 return 0;
328
329 offset = (hdata->max_fingers >> 2) + 1;
330 for (i = 0; i < hdata->max_fingers; i++) {
331 int fs_byte_position = i >> 2;
332 int fs_bit_position = (i & 0x3) << 1;
333 int finger_state = (data[fs_byte_position] >> fs_bit_position) &
334 0x03;
335
336 rmi_f11_process_touch(hdata, i, finger_state,
337 &data[offset + 5 * i]);
338 }
339 input_mt_sync_frame(hdata->input);
340 input_sync(hdata->input);
341 return hdata->f11.report_size;
342}
343
344static int rmi_f30_input_event(struct hid_device *hdev, u8 irq, u8 *data,
345 int size)
346{
347 struct rmi_data *hdata = hid_get_drvdata(hdev);
348 int i;
349 int button = 0;
350 bool value;
351
352 if (!(irq & hdata->f30.irq_mask))
353 return 0;
354
355 for (i = 0; i < hdata->gpio_led_count; i++) {
356 if (test_bit(i, &hdata->button_mask)) {
357 value = (data[i / 8] >> (i & 0x07)) & BIT(0);
358 if (test_bit(i, &hdata->button_state_mask))
359 value = !value;
360 input_event(hdata->input, EV_KEY, BTN_LEFT + button++,
361 value);
362 }
363 }
364 return hdata->f30.report_size;
365}
366
367static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
368{
369 struct rmi_data *hdata = hid_get_drvdata(hdev);
370 unsigned long irq_mask = 0;
371 unsigned index = 2;
372
373 if (!(test_bit(RMI_STARTED, &hdata->flags)))
374 return 0;
375
376 irq_mask |= hdata->f11.irq_mask;
377 irq_mask |= hdata->f30.irq_mask;
378
379 if (data[1] & ~irq_mask)
380 hid_warn(hdev, "unknown intr source:%02lx %s:%d\n",
381 data[1] & ~irq_mask, __FILE__, __LINE__);
382
383 if (hdata->f11.interrupt_base < hdata->f30.interrupt_base) {
384 index += rmi_f11_input_event(hdev, data[1], &data[index],
385 size - index);
386 index += rmi_f30_input_event(hdev, data[1], &data[index],
387 size - index);
388 } else {
389 index += rmi_f30_input_event(hdev, data[1], &data[index],
390 size - index);
391 index += rmi_f11_input_event(hdev, data[1], &data[index],
392 size - index);
393 }
394
395 return 1;
396}
397
398static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size)
399{
400 struct rmi_data *hdata = hid_get_drvdata(hdev);
401
402 if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) {
403 hid_err(hdev, "no read request pending\n");
404 return 0;
405 }
406
407 memcpy(hdata->readReport, data, size < hdata->input_report_size ?
408 size : hdata->input_report_size);
409 set_bit(RMI_READ_DATA_PENDING, &hdata->flags);
410 wake_up(&hdata->wait);
411
412 return 1;
413}
414
415static int rmi_raw_event(struct hid_device *hdev,
416 struct hid_report *report, u8 *data, int size)
417{
418 switch (data[0]) {
419 case RMI_READ_DATA_REPORT_ID:
420 return rmi_read_data_event(hdev, data, size);
421 case RMI_ATTN_REPORT_ID:
422 return rmi_input_event(hdev, data, size);
423 case RMI_MOUSE_REPORT_ID:
424 rmi_schedule_reset(hdev);
425 break;
426 }
427
428 return 0;
429}
430
431#ifdef CONFIG_PM
432static int rmi_post_reset(struct hid_device *hdev)
433{
434 return rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
435}
436
437static int rmi_post_resume(struct hid_device *hdev)
438{
439 return rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
440}
441#endif /* CONFIG_PM */
442
443#define RMI4_MAX_PAGE 0xff
444#define RMI4_PAGE_SIZE 0x0100
445
446#define PDT_START_SCAN_LOCATION 0x00e9
447#define PDT_END_SCAN_LOCATION 0x0005
448#define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff)
449
450struct pdt_entry {
451 u8 query_base_addr:8;
452 u8 command_base_addr:8;
453 u8 control_base_addr:8;
454 u8 data_base_addr:8;
455 u8 interrupt_source_count:3;
456 u8 bits3and4:2;
457 u8 function_version:2;
458 u8 bit7:1;
459 u8 function_number:8;
460} __attribute__((__packed__));
461
462static inline unsigned long rmi_gen_mask(unsigned irq_base, unsigned irq_count)
463{
464 return GENMASK(irq_count + irq_base - 1, irq_base);
465}
466
467static void rmi_register_function(struct rmi_data *data,
468 struct pdt_entry *pdt_entry, int page, unsigned interrupt_count)
469{
470 struct rmi_function *f = NULL;
471 u16 page_base = page << 8;
472
473 switch (pdt_entry->function_number) {
474 case 0x11:
475 f = &data->f11;
476 break;
477 case 0x30:
478 f = &data->f30;
479 break;
480 }
481
482 if (f) {
483 f->page = page;
484 f->query_base_addr = page_base | pdt_entry->query_base_addr;
485 f->command_base_addr = page_base | pdt_entry->command_base_addr;
486 f->control_base_addr = page_base | pdt_entry->control_base_addr;
487 f->data_base_addr = page_base | pdt_entry->data_base_addr;
488 f->interrupt_base = interrupt_count;
489 f->interrupt_count = pdt_entry->interrupt_source_count;
490 f->irq_mask = rmi_gen_mask(f->interrupt_base,
491 f->interrupt_count);
492 }
493}
494
495static int rmi_scan_pdt(struct hid_device *hdev)
496{
497 struct rmi_data *data = hid_get_drvdata(hdev);
498 struct pdt_entry entry;
499 int page;
500 bool page_has_function;
501 int i;
502 int retval;
503 int interrupt = 0;
504 u16 page_start, pdt_start , pdt_end;
505
506 hid_info(hdev, "Scanning PDT...\n");
507
508 for (page = 0; (page <= RMI4_MAX_PAGE); page++) {
509 page_start = RMI4_PAGE_SIZE * page;
510 pdt_start = page_start + PDT_START_SCAN_LOCATION;
511 pdt_end = page_start + PDT_END_SCAN_LOCATION;
512
513 page_has_function = false;
514 for (i = pdt_start; i >= pdt_end; i -= sizeof(entry)) {
515 retval = rmi_read_block(hdev, i, &entry, sizeof(entry));
516 if (retval) {
517 hid_err(hdev,
518 "Read of PDT entry at %#06x failed.\n",
519 i);
520 goto error_exit;
521 }
522
523 if (RMI4_END_OF_PDT(entry.function_number))
524 break;
525
526 page_has_function = true;
527
528 hid_info(hdev, "Found F%02X on page %#04x\n",
529 entry.function_number, page);
530
531 rmi_register_function(data, &entry, page, interrupt);
532 interrupt += entry.interrupt_source_count;
533 }
534
535 if (!page_has_function)
536 break;
537 }
538
539 hid_info(hdev, "%s: Done with PDT scan.\n", __func__);
540 retval = 0;
541
542error_exit:
543 return retval;
544}
545
546static int rmi_populate_f11(struct hid_device *hdev)
547{
548 struct rmi_data *data = hid_get_drvdata(hdev);
549 u8 buf[20];
550 int ret;
551 bool has_query9;
552 bool has_query10;
553 bool has_query11;
554 bool has_query12;
555 bool has_physical_props;
556 unsigned x_size, y_size;
557 u16 query12_offset;
558
559 if (!data->f11.query_base_addr) {
560 hid_err(hdev, "No 2D sensor found, giving up.\n");
561 return -ENODEV;
562 }
563
564 /* query 0 contains some useful information */
565 ret = rmi_read(hdev, data->f11.query_base_addr, buf);
566 if (ret) {
567 hid_err(hdev, "can not get query 0: %d.\n", ret);
568 return ret;
569 }
570 has_query9 = !!(buf[0] & BIT(3));
571 has_query11 = !!(buf[0] & BIT(4));
572 has_query12 = !!(buf[0] & BIT(5));
573
574 /* query 1 to get the max number of fingers */
575 ret = rmi_read(hdev, data->f11.query_base_addr + 1, buf);
576 if (ret) {
577 hid_err(hdev, "can not get NumberOfFingers: %d.\n", ret);
578 return ret;
579 }
580 data->max_fingers = (buf[0] & 0x07) + 1;
581 if (data->max_fingers > 5)
582 data->max_fingers = 10;
583
584 data->f11.report_size = data->max_fingers * 5 +
585 DIV_ROUND_UP(data->max_fingers, 4);
586
587 if (!(buf[0] & BIT(4))) {
588 hid_err(hdev, "No absolute events, giving up.\n");
589 return -ENODEV;
590 }
591
592 /* query 8 to find out if query 10 exists */
593 ret = rmi_read(hdev, data->f11.query_base_addr + 8, buf);
594 if (ret) {
595 hid_err(hdev, "can not read gesture information: %d.\n", ret);
596 return ret;
597 }
598 has_query10 = !!(buf[0] & BIT(2));
599
600 /*
601 * At least 8 queries are guaranteed to be present in F11
602 * +1 for query12.
603 */
604 query12_offset = 9;
605
606 if (has_query9)
607 ++query12_offset;
608
609 if (has_query10)
610 ++query12_offset;
611
612 if (has_query11)
613 ++query12_offset;
614
615 /* query 12 to know if the physical properties are reported */
616 if (has_query12) {
617 ret = rmi_read(hdev, data->f11.query_base_addr
618 + query12_offset, buf);
619 if (ret) {
620 hid_err(hdev, "can not get query 12: %d.\n", ret);
621 return ret;
622 }
623 has_physical_props = !!(buf[0] & BIT(5));
624
625 if (has_physical_props) {
626 ret = rmi_read_block(hdev,
627 data->f11.query_base_addr
628 + query12_offset + 1, buf, 4);
629 if (ret) {
630 hid_err(hdev, "can not read query 15-18: %d.\n",
631 ret);
632 return ret;
633 }
634
635 x_size = buf[0] | (buf[1] << 8);
636 y_size = buf[2] | (buf[3] << 8);
637
638 data->x_size_mm = DIV_ROUND_CLOSEST(x_size, 10);
639 data->y_size_mm = DIV_ROUND_CLOSEST(y_size, 10);
640
641 hid_info(hdev, "%s: size in mm: %d x %d\n",
642 __func__, data->x_size_mm, data->y_size_mm);
643 }
644 }
645
646 /*
647 * retrieve the ctrl registers
648 * the ctrl register has a size of 20 but a fw bug split it into 16 + 4,
649 * and there is no way to know if the first 20 bytes are here or not.
650 * We use only the first 10 bytes, so get only them.
651 */
652 ret = rmi_read_block(hdev, data->f11.control_base_addr, buf, 10);
653 if (ret) {
654 hid_err(hdev, "can not read ctrl block of size 10: %d.\n", ret);
655 return ret;
656 }
657
658 data->max_x = buf[6] | (buf[7] << 8);
659 data->max_y = buf[8] | (buf[9] << 8);
660
661 return 0;
662}
663
664static int rmi_populate_f30(struct hid_device *hdev)
665{
666 struct rmi_data *data = hid_get_drvdata(hdev);
667 u8 buf[20];
668 int ret;
669 bool has_gpio, has_led;
670 unsigned bytes_per_ctrl;
671 u8 ctrl2_addr;
672 int ctrl2_3_length;
673 int i;
674
675 /* function F30 is for physical buttons */
676 if (!data->f30.query_base_addr) {
677 hid_err(hdev, "No GPIO/LEDs found, giving up.\n");
678 return -ENODEV;
679 }
680
681 ret = rmi_read_block(hdev, data->f30.query_base_addr, buf, 2);
682 if (ret) {
683 hid_err(hdev, "can not get F30 query registers: %d.\n", ret);
684 return ret;
685 }
686
687 has_gpio = !!(buf[0] & BIT(3));
688 has_led = !!(buf[0] & BIT(2));
689 data->gpio_led_count = buf[1] & 0x1f;
690
691 /* retrieve ctrl 2 & 3 registers */
692 bytes_per_ctrl = (data->gpio_led_count + 7) / 8;
693 /* Ctrl0 is present only if both has_gpio and has_led are set*/
694 ctrl2_addr = (has_gpio && has_led) ? bytes_per_ctrl : 0;
695 /* Ctrl1 is always be present */
696 ctrl2_addr += bytes_per_ctrl;
697 ctrl2_3_length = 2 * bytes_per_ctrl;
698
699 data->f30.report_size = bytes_per_ctrl;
700
701 ret = rmi_read_block(hdev, data->f30.control_base_addr + ctrl2_addr,
702 buf, ctrl2_3_length);
703 if (ret) {
704 hid_err(hdev, "can not read ctrl 2&3 block of size %d: %d.\n",
705 ctrl2_3_length, ret);
706 return ret;
707 }
708
709 for (i = 0; i < data->gpio_led_count; i++) {
710 int byte_position = i >> 3;
711 int bit_position = i & 0x07;
712 u8 dir_byte = buf[byte_position];
713 u8 data_byte = buf[byte_position + bytes_per_ctrl];
714 bool dir = (dir_byte >> bit_position) & BIT(0);
715 bool dat = (data_byte >> bit_position) & BIT(0);
716
717 if (dir == 0) {
718 /* input mode */
719 if (dat) {
720 /* actual buttons have pull up resistor */
721 data->button_count++;
722 set_bit(i, &data->button_mask);
723 set_bit(i, &data->button_state_mask);
724 }
725 }
726
727 }
728
729 return 0;
730}
731
732static int rmi_populate(struct hid_device *hdev)
733{
734 int ret;
735
736 ret = rmi_scan_pdt(hdev);
737 if (ret) {
738 hid_err(hdev, "PDT scan failed with code %d.\n", ret);
739 return ret;
740 }
741
742 ret = rmi_populate_f11(hdev);
743 if (ret) {
744 hid_err(hdev, "Error while initializing F11 (%d).\n", ret);
745 return ret;
746 }
747
748 ret = rmi_populate_f30(hdev);
749 if (ret)
750 hid_warn(hdev, "Error while initializing F30 (%d).\n", ret);
751
752 return 0;
753}
754
755static void rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
756{
757 struct rmi_data *data = hid_get_drvdata(hdev);
758 struct input_dev *input = hi->input;
759 int ret;
760 int res_x, res_y, i;
761
762 data->input = input;
763
764 hid_dbg(hdev, "Opening low level driver\n");
765 ret = hid_hw_open(hdev);
766 if (ret)
767 return;
768
769 /* Allow incoming hid reports */
770 hid_device_io_start(hdev);
771
772 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
773 if (ret < 0) {
774 dev_err(&hdev->dev, "failed to set rmi mode\n");
775 goto exit;
776 }
777
778 ret = rmi_set_page(hdev, 0);
779 if (ret < 0) {
780 dev_err(&hdev->dev, "failed to set page select to 0.\n");
781 goto exit;
782 }
783
784 ret = rmi_populate(hdev);
785 if (ret)
786 goto exit;
787
788 __set_bit(EV_ABS, input->evbit);
789 input_set_abs_params(input, ABS_MT_POSITION_X, 1, data->max_x, 0, 0);
790 input_set_abs_params(input, ABS_MT_POSITION_Y, 1, data->max_y, 0, 0);
791
792 if (data->x_size_mm && data->y_size_mm) {
793 res_x = (data->max_x - 1) / data->x_size_mm;
794 res_y = (data->max_y - 1) / data->y_size_mm;
795
796 input_abs_set_res(input, ABS_MT_POSITION_X, res_x);
797 input_abs_set_res(input, ABS_MT_POSITION_Y, res_y);
798 }
799
800 input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0);
801 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xff, 0, 0);
802 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 0x0f, 0, 0);
803 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 0x0f, 0, 0);
804
805 input_mt_init_slots(input, data->max_fingers, INPUT_MT_POINTER);
806
807 if (data->button_count) {
808 __set_bit(EV_KEY, input->evbit);
809 for (i = 0; i < data->button_count; i++)
810 __set_bit(BTN_LEFT + i, input->keybit);
811
812 if (data->button_count == 1)
813 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
814 }
815
816 set_bit(RMI_STARTED, &data->flags);
817
818exit:
819 hid_device_io_stop(hdev);
820 hid_hw_close(hdev);
821}
822
823static int rmi_input_mapping(struct hid_device *hdev,
824 struct hid_input *hi, struct hid_field *field,
825 struct hid_usage *usage, unsigned long **bit, int *max)
826{
827 /* we want to make HID ignore the advertised HID collection */
828 return -1;
829}
830
831static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
832{
833 struct rmi_data *data = NULL;
834 int ret;
835 size_t alloc_size;
836
837 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL);
838 if (!data)
839 return -ENOMEM;
840
841 INIT_WORK(&data->reset_work, rmi_reset_work);
842 data->hdev = hdev;
843
844 hid_set_drvdata(hdev, data);
845
846 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
847
848 ret = hid_parse(hdev);
849 if (ret) {
850 hid_err(hdev, "parse failed\n");
851 return ret;
852 }
853
854 data->input_report_size = (hdev->report_enum[HID_INPUT_REPORT]
855 .report_id_hash[RMI_ATTN_REPORT_ID]->size >> 3)
856 + 1 /* report id */;
857 data->output_report_size = (hdev->report_enum[HID_OUTPUT_REPORT]
858 .report_id_hash[RMI_WRITE_REPORT_ID]->size >> 3)
859 + 1 /* report id */;
860
861 alloc_size = data->output_report_size + data->input_report_size;
862
863 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
864 if (!data->writeReport) {
865 ret = -ENOMEM;
866 return ret;
867 }
868
869 data->readReport = data->writeReport + data->output_report_size;
870
871 init_waitqueue_head(&data->wait);
872
873 mutex_init(&data->page_mutex);
874
875 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
876 if (ret) {
877 hid_err(hdev, "hw start failed\n");
878 return ret;
879 }
880
881 if (!test_bit(RMI_STARTED, &data->flags)) {
882 hid_hw_stop(hdev);
883 return -EIO;
884 }
885
886 return 0;
887}
888
889static void rmi_remove(struct hid_device *hdev)
890{
891 struct rmi_data *hdata = hid_get_drvdata(hdev);
892
893 clear_bit(RMI_STARTED, &hdata->flags);
894
895 hid_hw_stop(hdev);
896}
897
898static const struct hid_device_id rmi_id[] = {
899 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
900 { }
901};
902MODULE_DEVICE_TABLE(hid, rmi_id);
903
904static struct hid_driver rmi_driver = {
905 .name = "hid-rmi",
906 .id_table = rmi_id,
907 .probe = rmi_probe,
908 .remove = rmi_remove,
909 .raw_event = rmi_raw_event,
910 .input_mapping = rmi_input_mapping,
911 .input_configured = rmi_input_configured,
912#ifdef CONFIG_PM
913 .resume = rmi_post_resume,
914 .reset_resume = rmi_post_reset,
915#endif
916};
917
918module_hid_driver(rmi_driver);
919
920MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
921MODULE_DESCRIPTION("RMI HID driver");
922MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-saitek.c b/drivers/hid/hid-saitek.c
index 37961c7e397d..69cca1476a0c 100644
--- a/drivers/hid/hid-saitek.c
+++ b/drivers/hid/hid-saitek.c
@@ -1,10 +1,17 @@
1/* 1/*
2 * HID driver for Saitek devices, currently only the PS1000 (USB gamepad). 2 * HID driver for Saitek devices.
3 *
4 * PS1000 (USB gamepad):
3 * Fixes the HID report descriptor by removing a non-existent axis and 5 * Fixes the HID report descriptor by removing a non-existent axis and
4 * clearing the constant bit on the input reports for buttons and d-pad. 6 * clearing the constant bit on the input reports for buttons and d-pad.
5 * (This module is based on "hid-ortek".) 7 * (This module is based on "hid-ortek".)
6 *
7 * Copyright (c) 2012 Andreas Hübner 8 * Copyright (c) 2012 Andreas Hübner
9 *
10 * R.A.T.7, M.M.O.7 (USB gaming mice):
11 * Fixes the mode button which cycles through three constantly pressed
12 * buttons. All three press events are mapped to one button and the
13 * missing release event is generated immediately.
14 *
8 */ 15 */
9 16
10/* 17/*
@@ -21,12 +28,57 @@
21 28
22#include "hid-ids.h" 29#include "hid-ids.h"
23 30
31#define SAITEK_FIX_PS1000 0x0001
32#define SAITEK_RELEASE_MODE_RAT7 0x0002
33#define SAITEK_RELEASE_MODE_MMO7 0x0004
34
35struct saitek_sc {
36 unsigned long quirks;
37 int mode;
38};
39
40static int saitek_probe(struct hid_device *hdev,
41 const struct hid_device_id *id)
42{
43 unsigned long quirks = id->driver_data;
44 struct saitek_sc *ssc;
45 int ret;
46
47 ssc = devm_kzalloc(&hdev->dev, sizeof(*ssc), GFP_KERNEL);
48 if (ssc == NULL) {
49 hid_err(hdev, "can't alloc saitek descriptor\n");
50 return -ENOMEM;
51 }
52
53 ssc->quirks = quirks;
54 ssc->mode = -1;
55
56 hid_set_drvdata(hdev, ssc);
57
58 ret = hid_parse(hdev);
59 if (ret) {
60 hid_err(hdev, "parse failed\n");
61 return ret;
62 }
63
64 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
65 if (ret) {
66 hid_err(hdev, "hw start failed\n");
67 return ret;
68 }
69
70 return 0;
71}
72
24static __u8 *saitek_report_fixup(struct hid_device *hdev, __u8 *rdesc, 73static __u8 *saitek_report_fixup(struct hid_device *hdev, __u8 *rdesc,
25 unsigned int *rsize) 74 unsigned int *rsize)
26{ 75{
27 if (*rsize == 137 && rdesc[20] == 0x09 && rdesc[21] == 0x33 76 struct saitek_sc *ssc = hid_get_drvdata(hdev);
28 && rdesc[94] == 0x81 && rdesc[95] == 0x03 77
29 && rdesc[110] == 0x81 && rdesc[111] == 0x03) { 78 if ((ssc->quirks & SAITEK_FIX_PS1000) && *rsize == 137 &&
79 rdesc[20] == 0x09 && rdesc[21] == 0x33 &&
80 rdesc[94] == 0x81 && rdesc[95] == 0x03 &&
81 rdesc[110] == 0x81 && rdesc[111] == 0x03) {
30 82
31 hid_info(hdev, "Fixing up Saitek PS1000 report descriptor\n"); 83 hid_info(hdev, "Fixing up Saitek PS1000 report descriptor\n");
32 84
@@ -42,8 +94,93 @@ static __u8 *saitek_report_fixup(struct hid_device *hdev, __u8 *rdesc,
42 return rdesc; 94 return rdesc;
43} 95}
44 96
97static int saitek_raw_event(struct hid_device *hdev,
98 struct hid_report *report, u8 *raw_data, int size)
99{
100 struct saitek_sc *ssc = hid_get_drvdata(hdev);
101
102 if (ssc->quirks & SAITEK_RELEASE_MODE_RAT7 && size == 7) {
103 /* R.A.T.7 uses bits 13, 14, 15 for the mode */
104 int mode = -1;
105 if (raw_data[1] & 0x01)
106 mode = 0;
107 else if (raw_data[1] & 0x02)
108 mode = 1;
109 else if (raw_data[1] & 0x04)
110 mode = 2;
111
112 /* clear mode bits */
113 raw_data[1] &= ~0x07;
114
115 if (mode != ssc->mode) {
116 hid_dbg(hdev, "entered mode %d\n", mode);
117 if (ssc->mode != -1) {
118 /* use bit 13 as the mode button */
119 raw_data[1] |= 0x04;
120 }
121 ssc->mode = mode;
122 }
123 } else if (ssc->quirks & SAITEK_RELEASE_MODE_MMO7 && size == 8) {
124
125 /* M.M.O.7 uses bits 8, 22, 23 for the mode */
126 int mode = -1;
127 if (raw_data[1] & 0x80)
128 mode = 0;
129 else if (raw_data[2] & 0x01)
130 mode = 1;
131 else if (raw_data[2] & 0x02)
132 mode = 2;
133
134 /* clear mode bits */
135 raw_data[1] &= ~0x80;
136 raw_data[2] &= ~0x03;
137
138 if (mode != ssc->mode) {
139 hid_dbg(hdev, "entered mode %d\n", mode);
140 if (ssc->mode != -1) {
141 /* use bit 8 as the mode button, bits 22
142 * and 23 do not represent buttons
143 * according to the HID report descriptor
144 */
145 raw_data[1] |= 0x80;
146 }
147 ssc->mode = mode;
148 }
149 }
150
151 return 0;
152}
153
154static int saitek_event(struct hid_device *hdev, struct hid_field *field,
155 struct hid_usage *usage, __s32 value)
156{
157 struct saitek_sc *ssc = hid_get_drvdata(hdev);
158 struct input_dev *input = field->hidinput->input;
159
160 if (usage->type == EV_KEY && value &&
161 (((ssc->quirks & SAITEK_RELEASE_MODE_RAT7) &&
162 usage->code - BTN_MOUSE == 10) ||
163 ((ssc->quirks & SAITEK_RELEASE_MODE_MMO7) &&
164 usage->code - BTN_MOUSE == 15))) {
165
166 input_report_key(input, usage->code, 1);
167
168 /* report missing release event */
169 input_report_key(input, usage->code, 0);
170
171 return 1;
172 }
173
174 return 0;
175}
176
45static const struct hid_device_id saitek_devices[] = { 177static const struct hid_device_id saitek_devices[] = {
46 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000)}, 178 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000),
179 .driver_data = SAITEK_FIX_PS1000 },
180 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7),
181 .driver_data = SAITEK_RELEASE_MODE_RAT7 },
182 { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7),
183 .driver_data = SAITEK_RELEASE_MODE_MMO7 },
47 { } 184 { }
48}; 185};
49 186
@@ -52,7 +189,10 @@ MODULE_DEVICE_TABLE(hid, saitek_devices);
52static struct hid_driver saitek_driver = { 189static struct hid_driver saitek_driver = {
53 .name = "saitek", 190 .name = "saitek",
54 .id_table = saitek_devices, 191 .id_table = saitek_devices,
55 .report_fixup = saitek_report_fixup 192 .probe = saitek_probe,
193 .report_fixup = saitek_report_fixup,
194 .raw_event = saitek_raw_event,
195 .event = saitek_event,
56}; 196};
57module_hid_driver(saitek_driver); 197module_hid_driver(saitek_driver);
58 198
diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c
index be14b5690e94..e244e449cbba 100644
--- a/drivers/hid/hid-sensor-hub.c
+++ b/drivers/hid/hid-sensor-hub.c
@@ -159,17 +159,18 @@ int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev,
159{ 159{
160 struct hid_sensor_hub_callbacks_list *callback; 160 struct hid_sensor_hub_callbacks_list *callback;
161 struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev); 161 struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev);
162 unsigned long flags;
162 163
163 spin_lock(&pdata->dyn_callback_lock); 164 spin_lock_irqsave(&pdata->dyn_callback_lock, flags);
164 list_for_each_entry(callback, &pdata->dyn_callback_list, list) 165 list_for_each_entry(callback, &pdata->dyn_callback_list, list)
165 if (callback->usage_id == usage_id && 166 if (callback->usage_id == usage_id &&
166 callback->hsdev == hsdev) { 167 callback->hsdev == hsdev) {
167 spin_unlock(&pdata->dyn_callback_lock); 168 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
168 return -EINVAL; 169 return -EINVAL;
169 } 170 }
170 callback = kzalloc(sizeof(*callback), GFP_ATOMIC); 171 callback = kzalloc(sizeof(*callback), GFP_ATOMIC);
171 if (!callback) { 172 if (!callback) {
172 spin_unlock(&pdata->dyn_callback_lock); 173 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
173 return -ENOMEM; 174 return -ENOMEM;
174 } 175 }
175 callback->hsdev = hsdev; 176 callback->hsdev = hsdev;
@@ -177,7 +178,7 @@ int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev,
177 callback->usage_id = usage_id; 178 callback->usage_id = usage_id;
178 callback->priv = NULL; 179 callback->priv = NULL;
179 list_add_tail(&callback->list, &pdata->dyn_callback_list); 180 list_add_tail(&callback->list, &pdata->dyn_callback_list);
180 spin_unlock(&pdata->dyn_callback_lock); 181 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
181 182
182 return 0; 183 return 0;
183} 184}
@@ -188,8 +189,9 @@ int sensor_hub_remove_callback(struct hid_sensor_hub_device *hsdev,
188{ 189{
189 struct hid_sensor_hub_callbacks_list *callback; 190 struct hid_sensor_hub_callbacks_list *callback;
190 struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev); 191 struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev);
192 unsigned long flags;
191 193
192 spin_lock(&pdata->dyn_callback_lock); 194 spin_lock_irqsave(&pdata->dyn_callback_lock, flags);
193 list_for_each_entry(callback, &pdata->dyn_callback_list, list) 195 list_for_each_entry(callback, &pdata->dyn_callback_list, list)
194 if (callback->usage_id == usage_id && 196 if (callback->usage_id == usage_id &&
195 callback->hsdev == hsdev) { 197 callback->hsdev == hsdev) {
@@ -197,7 +199,7 @@ int sensor_hub_remove_callback(struct hid_sensor_hub_device *hsdev,
197 kfree(callback); 199 kfree(callback);
198 break; 200 break;
199 } 201 }
200 spin_unlock(&pdata->dyn_callback_lock); 202 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
201 203
202 return 0; 204 return 0;
203} 205}
@@ -378,15 +380,16 @@ static int sensor_hub_suspend(struct hid_device *hdev, pm_message_t message)
378{ 380{
379 struct sensor_hub_data *pdata = hid_get_drvdata(hdev); 381 struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
380 struct hid_sensor_hub_callbacks_list *callback; 382 struct hid_sensor_hub_callbacks_list *callback;
383 unsigned long flags;
381 384
382 hid_dbg(hdev, " sensor_hub_suspend\n"); 385 hid_dbg(hdev, " sensor_hub_suspend\n");
383 spin_lock(&pdata->dyn_callback_lock); 386 spin_lock_irqsave(&pdata->dyn_callback_lock, flags);
384 list_for_each_entry(callback, &pdata->dyn_callback_list, list) { 387 list_for_each_entry(callback, &pdata->dyn_callback_list, list) {
385 if (callback->usage_callback->suspend) 388 if (callback->usage_callback->suspend)
386 callback->usage_callback->suspend( 389 callback->usage_callback->suspend(
387 callback->hsdev, callback->priv); 390 callback->hsdev, callback->priv);
388 } 391 }
389 spin_unlock(&pdata->dyn_callback_lock); 392 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
390 393
391 return 0; 394 return 0;
392} 395}
@@ -395,15 +398,16 @@ static int sensor_hub_resume(struct hid_device *hdev)
395{ 398{
396 struct sensor_hub_data *pdata = hid_get_drvdata(hdev); 399 struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
397 struct hid_sensor_hub_callbacks_list *callback; 400 struct hid_sensor_hub_callbacks_list *callback;
401 unsigned long flags;
398 402
399 hid_dbg(hdev, " sensor_hub_resume\n"); 403 hid_dbg(hdev, " sensor_hub_resume\n");
400 spin_lock(&pdata->dyn_callback_lock); 404 spin_lock_irqsave(&pdata->dyn_callback_lock, flags);
401 list_for_each_entry(callback, &pdata->dyn_callback_list, list) { 405 list_for_each_entry(callback, &pdata->dyn_callback_list, list) {
402 if (callback->usage_callback->resume) 406 if (callback->usage_callback->resume)
403 callback->usage_callback->resume( 407 callback->usage_callback->resume(
404 callback->hsdev, callback->priv); 408 callback->hsdev, callback->priv);
405 } 409 }
406 spin_unlock(&pdata->dyn_callback_lock); 410 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
407 411
408 return 0; 412 return 0;
409} 413}
@@ -632,6 +636,7 @@ static int sensor_hub_probe(struct hid_device *hdev,
632 if (name == NULL) { 636 if (name == NULL) {
633 hid_err(hdev, "Failed MFD device name\n"); 637 hid_err(hdev, "Failed MFD device name\n");
634 ret = -ENOMEM; 638 ret = -ENOMEM;
639 kfree(hsdev);
635 goto err_no_mem; 640 goto err_no_mem;
636 } 641 }
637 sd->hid_sensor_hub_client_devs[ 642 sd->hid_sensor_hub_client_devs[
@@ -705,8 +710,17 @@ static const struct hid_device_id sensor_hub_devices[] = {
705 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_INTEL_1, 710 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_INTEL_1,
706 USB_DEVICE_ID_INTEL_HID_SENSOR_1), 711 USB_DEVICE_ID_INTEL_HID_SENSOR_1),
707 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK}, 712 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
713 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_MICROSOFT,
714 USB_DEVICE_ID_MS_SURFACE_PRO_2),
715 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
716 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_MICROSOFT,
717 USB_DEVICE_ID_MS_TOUCH_COVER_2),
718 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
719 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_MICROSOFT,
720 USB_DEVICE_ID_MS_TYPE_COVER_2),
721 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
708 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_STM_0, 722 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_STM_0,
709 USB_DEVICE_ID_STM_HID_SENSOR), 723 USB_DEVICE_ID_STM_HID_SENSOR_1),
710 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK}, 724 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
711 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_TEXAS_INSTRUMENTS, 725 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_TEXAS_INSTRUMENTS,
712 USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA), 726 USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA),
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
index 908de2789219..2259eaa8b988 100644
--- a/drivers/hid/hid-sony.c
+++ b/drivers/hid/hid-sony.c
@@ -33,6 +33,7 @@
33#include <linux/power_supply.h> 33#include <linux/power_supply.h>
34#include <linux/spinlock.h> 34#include <linux/spinlock.h>
35#include <linux/list.h> 35#include <linux/list.h>
36#include <linux/idr.h>
36#include <linux/input/mt.h> 37#include <linux/input/mt.h>
37 38
38#include "hid-ids.h" 39#include "hid-ids.h"
@@ -717,8 +718,39 @@ static enum power_supply_property sony_battery_props[] = {
717 POWER_SUPPLY_PROP_STATUS, 718 POWER_SUPPLY_PROP_STATUS,
718}; 719};
719 720
721struct sixaxis_led {
722 __u8 time_enabled; /* the total time the led is active (0xff means forever) */
723 __u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
724 __u8 enabled;
725 __u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
726 __u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
727} __packed;
728
729struct sixaxis_rumble {
730 __u8 padding;
731 __u8 right_duration; /* Right motor duration (0xff means forever) */
732 __u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
733 __u8 left_duration; /* Left motor duration (0xff means forever) */
734 __u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
735} __packed;
736
737struct sixaxis_output_report {
738 __u8 report_id;
739 struct sixaxis_rumble rumble;
740 __u8 padding[4];
741 __u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
742 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
743 struct sixaxis_led _reserved; /* LED5, not actually soldered */
744} __packed;
745
746union sixaxis_output_report_01 {
747 struct sixaxis_output_report data;
748 __u8 buf[36];
749};
750
720static spinlock_t sony_dev_list_lock; 751static spinlock_t sony_dev_list_lock;
721static LIST_HEAD(sony_device_list); 752static LIST_HEAD(sony_device_list);
753static DEFINE_IDA(sony_device_id_allocator);
722 754
723struct sony_sc { 755struct sony_sc {
724 spinlock_t lock; 756 spinlock_t lock;
@@ -728,6 +760,7 @@ struct sony_sc {
728 unsigned long quirks; 760 unsigned long quirks;
729 struct work_struct state_worker; 761 struct work_struct state_worker;
730 struct power_supply battery; 762 struct power_supply battery;
763 int device_id;
731 764
732#ifdef CONFIG_SONY_FF 765#ifdef CONFIG_SONY_FF
733 __u8 left; 766 __u8 left;
@@ -740,6 +773,8 @@ struct sony_sc {
740 __u8 battery_charging; 773 __u8 battery_charging;
741 __u8 battery_capacity; 774 __u8 battery_capacity;
742 __u8 led_state[MAX_LEDS]; 775 __u8 led_state[MAX_LEDS];
776 __u8 led_delay_on[MAX_LEDS];
777 __u8 led_delay_off[MAX_LEDS];
743 __u8 led_count; 778 __u8 led_count;
744}; 779};
745 780
@@ -1048,6 +1083,52 @@ static int dualshock4_set_operational_bt(struct hid_device *hdev)
1048 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 1083 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1049} 1084}
1050 1085
1086static void sixaxis_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1087{
1088 static const __u8 sixaxis_leds[10][4] = {
1089 { 0x01, 0x00, 0x00, 0x00 },
1090 { 0x00, 0x01, 0x00, 0x00 },
1091 { 0x00, 0x00, 0x01, 0x00 },
1092 { 0x00, 0x00, 0x00, 0x01 },
1093 { 0x01, 0x00, 0x00, 0x01 },
1094 { 0x00, 0x01, 0x00, 0x01 },
1095 { 0x00, 0x00, 0x01, 0x01 },
1096 { 0x01, 0x00, 0x01, 0x01 },
1097 { 0x00, 0x01, 0x01, 0x01 },
1098 { 0x01, 0x01, 0x01, 0x01 }
1099 };
1100
1101 BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1102
1103 if (id < 0)
1104 return;
1105
1106 id %= 10;
1107 memcpy(values, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1108}
1109
1110static void dualshock4_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1111{
1112 /* The first 4 color/index entries match what the PS4 assigns */
1113 static const __u8 color_code[7][3] = {
1114 /* Blue */ { 0x00, 0x00, 0x01 },
1115 /* Red */ { 0x01, 0x00, 0x00 },
1116 /* Green */ { 0x00, 0x01, 0x00 },
1117 /* Pink */ { 0x02, 0x00, 0x01 },
1118 /* Orange */ { 0x02, 0x01, 0x00 },
1119 /* Teal */ { 0x00, 0x01, 0x01 },
1120 /* White */ { 0x01, 0x01, 0x01 }
1121 };
1122
1123 BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1124
1125 if (id < 0)
1126 return;
1127
1128 id %= 7;
1129 memcpy(values, color_code[id], sizeof(color_code[id]));
1130}
1131
1051static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds) 1132static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1052{ 1133{
1053 struct list_head *report_list = 1134 struct list_head *report_list =
@@ -1066,19 +1147,18 @@ static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1066 hid_hw_request(hdev, report, HID_REQ_SET_REPORT); 1147 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1067} 1148}
1068 1149
1069static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count) 1150static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count)
1070{ 1151{
1071 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1072 int n; 1152 int n;
1073 1153
1074 BUG_ON(count > MAX_LEDS); 1154 BUG_ON(count > MAX_LEDS);
1075 1155
1076 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) { 1156 if (sc->quirks & BUZZ_CONTROLLER && count == 4) {
1077 buzz_set_leds(hdev, leds); 1157 buzz_set_leds(sc->hdev, leds);
1078 } else { 1158 } else {
1079 for (n = 0; n < count; n++) 1159 for (n = 0; n < count; n++)
1080 drv_data->led_state[n] = leds[n]; 1160 sc->led_state[n] = leds[n];
1081 schedule_work(&drv_data->state_worker); 1161 schedule_work(&sc->state_worker);
1082 } 1162 }
1083} 1163}
1084 1164
@@ -1090,6 +1170,7 @@ static void sony_led_set_brightness(struct led_classdev *led,
1090 struct sony_sc *drv_data; 1170 struct sony_sc *drv_data;
1091 1171
1092 int n; 1172 int n;
1173 int force_update;
1093 1174
1094 drv_data = hid_get_drvdata(hdev); 1175 drv_data = hid_get_drvdata(hdev);
1095 if (!drv_data) { 1176 if (!drv_data) {
@@ -1097,12 +1178,29 @@ static void sony_led_set_brightness(struct led_classdev *led,
1097 return; 1178 return;
1098 } 1179 }
1099 1180
1181 /*
1182 * The Sixaxis on USB will override any LED settings sent to it
1183 * and keep flashing all of the LEDs until the PS button is pressed.
1184 * Updates, even if redundant, must be always be sent to the
1185 * controller to avoid having to toggle the state of an LED just to
1186 * stop the flashing later on.
1187 */
1188 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1189
1100 for (n = 0; n < drv_data->led_count; n++) { 1190 for (n = 0; n < drv_data->led_count; n++) {
1101 if (led == drv_data->leds[n]) { 1191 if (led == drv_data->leds[n] && (force_update ||
1102 if (value != drv_data->led_state[n]) { 1192 (value != drv_data->led_state[n] ||
1103 drv_data->led_state[n] = value; 1193 drv_data->led_delay_on[n] ||
1104 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count); 1194 drv_data->led_delay_off[n]))) {
1105 } 1195
1196 drv_data->led_state[n] = value;
1197
1198 /* Setting the brightness stops the blinking */
1199 drv_data->led_delay_on[n] = 0;
1200 drv_data->led_delay_off[n] = 0;
1201
1202 sony_set_leds(drv_data, drv_data->led_state,
1203 drv_data->led_count);
1106 break; 1204 break;
1107 } 1205 }
1108 } 1206 }
@@ -1130,63 +1228,112 @@ static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1130 return LED_OFF; 1228 return LED_OFF;
1131} 1229}
1132 1230
1133static void sony_leds_remove(struct hid_device *hdev) 1231static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1232 unsigned long *delay_off)
1134{ 1233{
1135 struct sony_sc *drv_data; 1234 struct device *dev = led->dev->parent;
1136 struct led_classdev *led; 1235 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1236 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1137 int n; 1237 int n;
1238 __u8 new_on, new_off;
1138 1239
1139 drv_data = hid_get_drvdata(hdev); 1240 if (!drv_data) {
1140 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT)); 1241 hid_err(hdev, "No device data\n");
1242 return -EINVAL;
1243 }
1244
1245 /* Max delay is 255 deciseconds or 2550 milliseconds */
1246 if (*delay_on > 2550)
1247 *delay_on = 2550;
1248 if (*delay_off > 2550)
1249 *delay_off = 2550;
1250
1251 /* Blink at 1 Hz if both values are zero */
1252 if (!*delay_on && !*delay_off)
1253 *delay_on = *delay_off = 500;
1254
1255 new_on = *delay_on / 10;
1256 new_off = *delay_off / 10;
1141 1257
1142 for (n = 0; n < drv_data->led_count; n++) { 1258 for (n = 0; n < drv_data->led_count; n++) {
1143 led = drv_data->leds[n]; 1259 if (led == drv_data->leds[n])
1144 drv_data->leds[n] = NULL; 1260 break;
1261 }
1262
1263 /* This LED is not registered on this device */
1264 if (n >= drv_data->led_count)
1265 return -EINVAL;
1266
1267 /* Don't schedule work if the values didn't change */
1268 if (new_on != drv_data->led_delay_on[n] ||
1269 new_off != drv_data->led_delay_off[n]) {
1270 drv_data->led_delay_on[n] = new_on;
1271 drv_data->led_delay_off[n] = new_off;
1272 schedule_work(&drv_data->state_worker);
1273 }
1274
1275 return 0;
1276}
1277
1278static void sony_leds_remove(struct sony_sc *sc)
1279{
1280 struct led_classdev *led;
1281 int n;
1282
1283 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1284
1285 for (n = 0; n < sc->led_count; n++) {
1286 led = sc->leds[n];
1287 sc->leds[n] = NULL;
1145 if (!led) 1288 if (!led)
1146 continue; 1289 continue;
1147 led_classdev_unregister(led); 1290 led_classdev_unregister(led);
1148 kfree(led); 1291 kfree(led);
1149 } 1292 }
1150 1293
1151 drv_data->led_count = 0; 1294 sc->led_count = 0;
1152} 1295}
1153 1296
1154static int sony_leds_init(struct hid_device *hdev) 1297static int sony_leds_init(struct sony_sc *sc)
1155{ 1298{
1156 struct sony_sc *drv_data; 1299 struct hid_device *hdev = sc->hdev;
1157 int n, ret = 0; 1300 int n, ret = 0;
1158 int max_brightness; 1301 int use_ds4_names;
1159 int use_colors;
1160 struct led_classdev *led; 1302 struct led_classdev *led;
1161 size_t name_sz; 1303 size_t name_sz;
1162 char *name; 1304 char *name;
1163 size_t name_len; 1305 size_t name_len;
1164 const char *name_fmt; 1306 const char *name_fmt;
1165 static const char * const color_str[] = { "red", "green", "blue" }; 1307 static const char * const ds4_name_str[] = { "red", "green", "blue",
1166 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 }; 1308 "global" };
1309 __u8 initial_values[MAX_LEDS] = { 0 };
1310 __u8 max_brightness[MAX_LEDS] = { 1 };
1311 __u8 use_hw_blink[MAX_LEDS] = { 0 };
1167 1312
1168 drv_data = hid_get_drvdata(hdev); 1313 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1169 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
1170 1314
1171 if (drv_data->quirks & BUZZ_CONTROLLER) { 1315 if (sc->quirks & BUZZ_CONTROLLER) {
1172 drv_data->led_count = 4; 1316 sc->led_count = 4;
1173 max_brightness = 1; 1317 use_ds4_names = 0;
1174 use_colors = 0;
1175 name_len = strlen("::buzz#"); 1318 name_len = strlen("::buzz#");
1176 name_fmt = "%s::buzz%d"; 1319 name_fmt = "%s::buzz%d";
1177 /* Validate expected report characteristics. */ 1320 /* Validate expected report characteristics. */
1178 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7)) 1321 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1179 return -ENODEV; 1322 return -ENODEV;
1180 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER) { 1323 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1181 drv_data->led_count = 3; 1324 dualshock4_set_leds_from_id(sc->device_id, initial_values);
1182 max_brightness = 255; 1325 initial_values[3] = 1;
1183 use_colors = 1; 1326 sc->led_count = 4;
1327 memset(max_brightness, 255, 3);
1328 use_hw_blink[3] = 1;
1329 use_ds4_names = 1;
1184 name_len = 0; 1330 name_len = 0;
1185 name_fmt = "%s:%s"; 1331 name_fmt = "%s:%s";
1186 } else { 1332 } else {
1187 drv_data->led_count = 4; 1333 sixaxis_set_leds_from_id(sc->device_id, initial_values);
1188 max_brightness = 1; 1334 sc->led_count = 4;
1189 use_colors = 0; 1335 memset(use_hw_blink, 1, 4);
1336 use_ds4_names = 0;
1190 name_len = strlen("::sony#"); 1337 name_len = strlen("::sony#");
1191 name_fmt = "%s::sony%d"; 1338 name_fmt = "%s::sony%d";
1192 } 1339 }
@@ -1196,14 +1343,14 @@ static int sony_leds_init(struct hid_device *hdev)
1196 * only relevant if the driver is loaded after somebody actively set the 1343 * only relevant if the driver is loaded after somebody actively set the
1197 * LEDs to on 1344 * LEDs to on
1198 */ 1345 */
1199 sony_set_leds(hdev, initial_values, drv_data->led_count); 1346 sony_set_leds(sc, initial_values, sc->led_count);
1200 1347
1201 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1; 1348 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1202 1349
1203 for (n = 0; n < drv_data->led_count; n++) { 1350 for (n = 0; n < sc->led_count; n++) {
1204 1351
1205 if (use_colors) 1352 if (use_ds4_names)
1206 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2; 1353 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1207 1354
1208 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL); 1355 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1209 if (!led) { 1356 if (!led) {
@@ -1213,30 +1360,35 @@ static int sony_leds_init(struct hid_device *hdev)
1213 } 1360 }
1214 1361
1215 name = (void *)(&led[1]); 1362 name = (void *)(&led[1]);
1216 if (use_colors) 1363 if (use_ds4_names)
1217 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]); 1364 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1365 ds4_name_str[n]);
1218 else 1366 else
1219 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1); 1367 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1220 led->name = name; 1368 led->name = name;
1221 led->brightness = 0; 1369 led->brightness = initial_values[n];
1222 led->max_brightness = max_brightness; 1370 led->max_brightness = max_brightness[n];
1223 led->brightness_get = sony_led_get_brightness; 1371 led->brightness_get = sony_led_get_brightness;
1224 led->brightness_set = sony_led_set_brightness; 1372 led->brightness_set = sony_led_set_brightness;
1225 1373
1374 if (use_hw_blink[n])
1375 led->blink_set = sony_led_blink_set;
1376
1377 sc->leds[n] = led;
1378
1226 ret = led_classdev_register(&hdev->dev, led); 1379 ret = led_classdev_register(&hdev->dev, led);
1227 if (ret) { 1380 if (ret) {
1228 hid_err(hdev, "Failed to register LED %d\n", n); 1381 hid_err(hdev, "Failed to register LED %d\n", n);
1382 sc->leds[n] = NULL;
1229 kfree(led); 1383 kfree(led);
1230 goto error_leds; 1384 goto error_leds;
1231 } 1385 }
1232
1233 drv_data->leds[n] = led;
1234 } 1386 }
1235 1387
1236 return ret; 1388 return ret;
1237 1389
1238error_leds: 1390error_leds:
1239 sony_leds_remove(hdev); 1391 sony_leds_remove(sc);
1240 1392
1241 return ret; 1393 return ret;
1242} 1394}
@@ -1244,29 +1396,52 @@ error_leds:
1244static void sixaxis_state_worker(struct work_struct *work) 1396static void sixaxis_state_worker(struct work_struct *work)
1245{ 1397{
1246 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker); 1398 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1247 unsigned char buf[] = { 1399 int n;
1248 0x01, 1400 union sixaxis_output_report_01 report = {
1249 0x00, 0xff, 0x00, 0xff, 0x00, 1401 .buf = {
1250 0x00, 0x00, 0x00, 0x00, 0x00, 1402 0x01,
1251 0xff, 0x27, 0x10, 0x00, 0x32, 1403 0x00, 0xff, 0x00, 0xff, 0x00,
1252 0xff, 0x27, 0x10, 0x00, 0x32, 1404 0x00, 0x00, 0x00, 0x00, 0x00,
1253 0xff, 0x27, 0x10, 0x00, 0x32, 1405 0xff, 0x27, 0x10, 0x00, 0x32,
1254 0xff, 0x27, 0x10, 0x00, 0x32, 1406 0xff, 0x27, 0x10, 0x00, 0x32,
1255 0x00, 0x00, 0x00, 0x00, 0x00 1407 0xff, 0x27, 0x10, 0x00, 0x32,
1408 0xff, 0x27, 0x10, 0x00, 0x32,
1409 0x00, 0x00, 0x00, 0x00, 0x00
1410 }
1256 }; 1411 };
1257 1412
1258#ifdef CONFIG_SONY_FF 1413#ifdef CONFIG_SONY_FF
1259 buf[3] = sc->right ? 1 : 0; 1414 report.data.rumble.right_motor_on = sc->right ? 1 : 0;
1260 buf[5] = sc->left; 1415 report.data.rumble.left_motor_force = sc->left;
1261#endif 1416#endif
1262 1417
1263 buf[10] |= sc->led_state[0] << 1; 1418 report.data.leds_bitmap |= sc->led_state[0] << 1;
1264 buf[10] |= sc->led_state[1] << 2; 1419 report.data.leds_bitmap |= sc->led_state[1] << 2;
1265 buf[10] |= sc->led_state[2] << 3; 1420 report.data.leds_bitmap |= sc->led_state[2] << 3;
1266 buf[10] |= sc->led_state[3] << 4; 1421 report.data.leds_bitmap |= sc->led_state[3] << 4;
1422
1423 /* Set flag for all leds off, required for 3rd party INTEC controller */
1424 if ((report.data.leds_bitmap & 0x1E) == 0)
1425 report.data.leds_bitmap |= 0x20;
1267 1426
1268 hid_hw_raw_request(sc->hdev, 0x01, buf, sizeof(buf), HID_OUTPUT_REPORT, 1427 /*
1269 HID_REQ_SET_REPORT); 1428 * The LEDs in the report are indexed in reverse order to their
1429 * corresponding light on the controller.
1430 * Index 0 = LED 4, index 1 = LED 3, etc...
1431 *
1432 * In the case of both delay values being zero (blinking disabled) the
1433 * default report values should be used or the controller LED will be
1434 * always off.
1435 */
1436 for (n = 0; n < 4; n++) {
1437 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1438 report.data.led[3 - n].duty_off = sc->led_delay_off[n];
1439 report.data.led[3 - n].duty_on = sc->led_delay_on[n];
1440 }
1441 }
1442
1443 hid_hw_raw_request(sc->hdev, report.data.report_id, report.buf,
1444 sizeof(report), HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1270} 1445}
1271 1446
1272static void dualshock4_state_worker(struct work_struct *work) 1447static void dualshock4_state_worker(struct work_struct *work)
@@ -1279,7 +1454,7 @@ static void dualshock4_state_worker(struct work_struct *work)
1279 1454
1280 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) { 1455 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1281 buf[0] = 0x05; 1456 buf[0] = 0x05;
1282 buf[1] = 0x03; 1457 buf[1] = 0xFF;
1283 offset = 4; 1458 offset = 4;
1284 } else { 1459 } else {
1285 buf[0] = 0x11; 1460 buf[0] = 0x11;
@@ -1295,9 +1470,18 @@ static void dualshock4_state_worker(struct work_struct *work)
1295 offset += 2; 1470 offset += 2;
1296#endif 1471#endif
1297 1472
1298 buf[offset++] = sc->led_state[0]; 1473 /* LED 3 is the global control */
1299 buf[offset++] = sc->led_state[1]; 1474 if (sc->led_state[3]) {
1300 buf[offset++] = sc->led_state[2]; 1475 buf[offset++] = sc->led_state[0];
1476 buf[offset++] = sc->led_state[1];
1477 buf[offset++] = sc->led_state[2];
1478 } else {
1479 offset += 3;
1480 }
1481
1482 /* If both delay values are zero the DualShock 4 disables blinking. */
1483 buf[offset++] = sc->led_delay_on[3];
1484 buf[offset++] = sc->led_delay_off[3];
1301 1485
1302 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) 1486 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1303 hid_hw_output_report(hdev, buf, 32); 1487 hid_hw_output_report(hdev, buf, 32);
@@ -1323,9 +1507,9 @@ static int sony_play_effect(struct input_dev *dev, void *data,
1323 return 0; 1507 return 0;
1324} 1508}
1325 1509
1326static int sony_init_ff(struct hid_device *hdev) 1510static int sony_init_ff(struct sony_sc *sc)
1327{ 1511{
1328 struct hid_input *hidinput = list_entry(hdev->inputs.next, 1512 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1329 struct hid_input, list); 1513 struct hid_input, list);
1330 struct input_dev *input_dev = hidinput->input; 1514 struct input_dev *input_dev = hidinput->input;
1331 1515
@@ -1334,7 +1518,7 @@ static int sony_init_ff(struct hid_device *hdev)
1334} 1518}
1335 1519
1336#else 1520#else
1337static int sony_init_ff(struct hid_device *hdev) 1521static int sony_init_ff(struct sony_sc *sc)
1338{ 1522{
1339 return 0; 1523 return 0;
1340} 1524}
@@ -1384,8 +1568,6 @@ static int sony_battery_get_property(struct power_supply *psy,
1384 1568
1385static int sony_battery_probe(struct sony_sc *sc) 1569static int sony_battery_probe(struct sony_sc *sc)
1386{ 1570{
1387 static atomic_t power_id_seq = ATOMIC_INIT(0);
1388 unsigned long power_id;
1389 struct hid_device *hdev = sc->hdev; 1571 struct hid_device *hdev = sc->hdev;
1390 int ret; 1572 int ret;
1391 1573
@@ -1395,15 +1577,13 @@ static int sony_battery_probe(struct sony_sc *sc)
1395 */ 1577 */
1396 sc->battery_capacity = 100; 1578 sc->battery_capacity = 100;
1397 1579
1398 power_id = (unsigned long)atomic_inc_return(&power_id_seq);
1399
1400 sc->battery.properties = sony_battery_props; 1580 sc->battery.properties = sony_battery_props;
1401 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props); 1581 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1402 sc->battery.get_property = sony_battery_get_property; 1582 sc->battery.get_property = sony_battery_get_property;
1403 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY; 1583 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1404 sc->battery.use_for_apm = 0; 1584 sc->battery.use_for_apm = 0;
1405 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%lu", 1585 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR",
1406 power_id); 1586 sc->mac_address);
1407 if (!sc->battery.name) 1587 if (!sc->battery.name)
1408 return -ENOMEM; 1588 return -ENOMEM;
1409 1589
@@ -1578,6 +1758,52 @@ static int sony_check_add(struct sony_sc *sc)
1578 return sony_check_add_dev_list(sc); 1758 return sony_check_add_dev_list(sc);
1579} 1759}
1580 1760
1761static int sony_set_device_id(struct sony_sc *sc)
1762{
1763 int ret;
1764
1765 /*
1766 * Only DualShock 4 or Sixaxis controllers get an id.
1767 * All others are set to -1.
1768 */
1769 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1770 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
1771 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1772 GFP_KERNEL);
1773 if (ret < 0) {
1774 sc->device_id = -1;
1775 return ret;
1776 }
1777 sc->device_id = ret;
1778 } else {
1779 sc->device_id = -1;
1780 }
1781
1782 return 0;
1783}
1784
1785static void sony_release_device_id(struct sony_sc *sc)
1786{
1787 if (sc->device_id >= 0) {
1788 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1789 sc->device_id = -1;
1790 }
1791}
1792
1793static inline void sony_init_work(struct sony_sc *sc,
1794 void (*worker)(struct work_struct *))
1795{
1796 if (!sc->worker_initialized)
1797 INIT_WORK(&sc->state_worker, worker);
1798
1799 sc->worker_initialized = 1;
1800}
1801
1802static inline void sony_cancel_work_sync(struct sony_sc *sc)
1803{
1804 if (sc->worker_initialized)
1805 cancel_work_sync(&sc->state_worker);
1806}
1581 1807
1582static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) 1808static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1583{ 1809{
@@ -1615,6 +1841,12 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1615 return ret; 1841 return ret;
1616 } 1842 }
1617 1843
1844 ret = sony_set_device_id(sc);
1845 if (ret < 0) {
1846 hid_err(hdev, "failed to allocate the device id\n");
1847 goto err_stop;
1848 }
1849
1618 if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 1850 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1619 /* 1851 /*
1620 * The Sony Sixaxis does not handle HID Output Reports on the 1852 * The Sony Sixaxis does not handle HID Output Reports on the
@@ -1629,8 +1861,7 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1629 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1861 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1630 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID; 1862 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1631 ret = sixaxis_set_operational_usb(hdev); 1863 ret = sixaxis_set_operational_usb(hdev);
1632 sc->worker_initialized = 1; 1864 sony_init_work(sc, sixaxis_state_worker);
1633 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1634 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) { 1865 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1635 /* 1866 /*
1636 * The Sixaxis wants output reports sent on the ctrl endpoint 1867 * The Sixaxis wants output reports sent on the ctrl endpoint
@@ -1638,8 +1869,7 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1638 */ 1869 */
1639 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP; 1870 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1640 ret = sixaxis_set_operational_bt(hdev); 1871 ret = sixaxis_set_operational_bt(hdev);
1641 sc->worker_initialized = 1; 1872 sony_init_work(sc, sixaxis_state_worker);
1642 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1643 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) { 1873 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1644 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) { 1874 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1645 /* 1875 /*
@@ -1661,8 +1891,7 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1661 if (ret < 0) 1891 if (ret < 0)
1662 goto err_stop; 1892 goto err_stop;
1663 1893
1664 sc->worker_initialized = 1; 1894 sony_init_work(sc, dualshock4_state_worker);
1665 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1666 } else { 1895 } else {
1667 ret = 0; 1896 ret = 0;
1668 } 1897 }
@@ -1675,7 +1904,7 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1675 goto err_stop; 1904 goto err_stop;
1676 1905
1677 if (sc->quirks & SONY_LED_SUPPORT) { 1906 if (sc->quirks & SONY_LED_SUPPORT) {
1678 ret = sony_leds_init(hdev); 1907 ret = sony_leds_init(sc);
1679 if (ret < 0) 1908 if (ret < 0)
1680 goto err_stop; 1909 goto err_stop;
1681 } 1910 }
@@ -1694,7 +1923,7 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1694 } 1923 }
1695 1924
1696 if (sc->quirks & SONY_FF_SUPPORT) { 1925 if (sc->quirks & SONY_FF_SUPPORT) {
1697 ret = sony_init_ff(hdev); 1926 ret = sony_init_ff(sc);
1698 if (ret < 0) 1927 if (ret < 0)
1699 goto err_close; 1928 goto err_close;
1700 } 1929 }
@@ -1704,12 +1933,12 @@ err_close:
1704 hid_hw_close(hdev); 1933 hid_hw_close(hdev);
1705err_stop: 1934err_stop:
1706 if (sc->quirks & SONY_LED_SUPPORT) 1935 if (sc->quirks & SONY_LED_SUPPORT)
1707 sony_leds_remove(hdev); 1936 sony_leds_remove(sc);
1708 if (sc->quirks & SONY_BATTERY_SUPPORT) 1937 if (sc->quirks & SONY_BATTERY_SUPPORT)
1709 sony_battery_remove(sc); 1938 sony_battery_remove(sc);
1710 if (sc->worker_initialized) 1939 sony_cancel_work_sync(sc);
1711 cancel_work_sync(&sc->state_worker);
1712 sony_remove_dev_list(sc); 1940 sony_remove_dev_list(sc);
1941 sony_release_device_id(sc);
1713 hid_hw_stop(hdev); 1942 hid_hw_stop(hdev);
1714 return ret; 1943 return ret;
1715} 1944}
@@ -1719,18 +1948,19 @@ static void sony_remove(struct hid_device *hdev)
1719 struct sony_sc *sc = hid_get_drvdata(hdev); 1948 struct sony_sc *sc = hid_get_drvdata(hdev);
1720 1949
1721 if (sc->quirks & SONY_LED_SUPPORT) 1950 if (sc->quirks & SONY_LED_SUPPORT)
1722 sony_leds_remove(hdev); 1951 sony_leds_remove(sc);
1723 1952
1724 if (sc->quirks & SONY_BATTERY_SUPPORT) { 1953 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1725 hid_hw_close(hdev); 1954 hid_hw_close(hdev);
1726 sony_battery_remove(sc); 1955 sony_battery_remove(sc);
1727 } 1956 }
1728 1957
1729 if (sc->worker_initialized) 1958 sony_cancel_work_sync(sc);
1730 cancel_work_sync(&sc->state_worker);
1731 1959
1732 sony_remove_dev_list(sc); 1960 sony_remove_dev_list(sc);
1733 1961
1962 sony_release_device_id(sc);
1963
1734 hid_hw_stop(hdev); 1964 hid_hw_stop(hdev);
1735} 1965}
1736 1966
@@ -1775,6 +2005,22 @@ static struct hid_driver sony_driver = {
1775 .report_fixup = sony_report_fixup, 2005 .report_fixup = sony_report_fixup,
1776 .raw_event = sony_raw_event 2006 .raw_event = sony_raw_event
1777}; 2007};
1778module_hid_driver(sony_driver); 2008
2009static int __init sony_init(void)
2010{
2011 dbg_hid("Sony:%s\n", __func__);
2012
2013 return hid_register_driver(&sony_driver);
2014}
2015
2016static void __exit sony_exit(void)
2017{
2018 dbg_hid("Sony:%s\n", __func__);
2019
2020 ida_destroy(&sony_device_id_allocator);
2021 hid_unregister_driver(&sony_driver);
2022}
2023module_init(sony_init);
2024module_exit(sony_exit);
1779 2025
1780MODULE_LICENSE("GPL"); 2026MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-thingm.c b/drivers/hid/hid-thingm.c
index a97c78845f7b..134be89b15ea 100644
--- a/drivers/hid/hid-thingm.c
+++ b/drivers/hid/hid-thingm.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * ThingM blink(1) USB RGB LED driver 2 * ThingM blink(1) USB RGB LED driver
3 * 3 *
4 * Copyright 2013 Savoir-faire Linux Inc. 4 * Copyright 2013-2014 Savoir-faire Linux Inc.
5 * Vivien Didelot <vivien.didelot@savoirfairelinux.com> 5 * Vivien Didelot <vivien.didelot@savoirfairelinux.com>
6 * 6 *
7 * This program is free software; you can redistribute it and/or 7 * This program is free software; you can redistribute it and/or
@@ -10,244 +10,285 @@
10 */ 10 */
11 11
12#include <linux/hid.h> 12#include <linux/hid.h>
13#include <linux/hidraw.h>
13#include <linux/leds.h> 14#include <linux/leds.h>
14#include <linux/module.h> 15#include <linux/module.h>
16#include <linux/mutex.h>
17#include <linux/workqueue.h>
15 18
16#include "hid-ids.h" 19#include "hid-ids.h"
17 20
18#define BLINK1_CMD_SIZE 9 21#define REPORT_ID 1
22#define REPORT_SIZE 9
19 23
20#define blink1_rgb_to_r(rgb) ((rgb & 0xFF0000) >> 16) 24/* Firmware major number of supported devices */
21#define blink1_rgb_to_g(rgb) ((rgb & 0x00FF00) >> 8) 25#define THINGM_MAJOR_MK1 '1'
22#define blink1_rgb_to_b(rgb) ((rgb & 0x0000FF) >> 0) 26#define THINGM_MAJOR_MK2 '2'
23 27
24/** 28struct thingm_fwinfo {
25 * struct blink1_data - blink(1) device specific data 29 char major;
26 * @hdev: HID device. 30 unsigned numrgb;
27 * @led_cdev: LED class instance. 31 unsigned first;
28 * @rgb: 8-bit per channel RGB notation. 32};
29 * @fade: fade time in hundredths of a second. 33
30 * @brightness: brightness coefficient. 34static const struct thingm_fwinfo thingm_fwinfo[] = {
31 * @play: play/pause in-memory patterns. 35 {
32 */ 36 .major = THINGM_MAJOR_MK1,
33struct blink1_data { 37 .numrgb = 1,
38 .first = 0,
39 }, {
40 .major = THINGM_MAJOR_MK2,
41 .numrgb = 2,
42 .first = 1,
43 }
44};
45
46/* A red, green or blue channel, part of an RGB chip */
47struct thingm_led {
48 struct thingm_rgb *rgb;
49 struct led_classdev ldev;
50 char name[32];
51};
52
53/* Basically a WS2812 5050 RGB LED chip */
54struct thingm_rgb {
55 struct thingm_device *tdev;
56 struct thingm_led red;
57 struct thingm_led green;
58 struct thingm_led blue;
59 struct work_struct work;
60 u8 num;
61};
62
63struct thingm_device {
34 struct hid_device *hdev; 64 struct hid_device *hdev;
35 struct led_classdev led_cdev; 65 struct {
36 u32 rgb; 66 char major;
37 u16 fade; 67 char minor;
38 u8 brightness; 68 } version;
39 bool play; 69 const struct thingm_fwinfo *fwinfo;
70 struct mutex lock;
71 struct thingm_rgb *rgb;
40}; 72};
41 73
42static int blink1_send_command(struct blink1_data *data, 74static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
43 u8 buf[BLINK1_CMD_SIZE])
44{ 75{
45 int ret; 76 int ret;
46 77
47 hid_dbg(data->hdev, "command: %d%c%.2x%.2x%.2x%.2x%.2x%.2x%.2x\n", 78 hid_dbg(tdev->hdev, "-> %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
48 buf[0], buf[1], buf[2], buf[3], buf[4], 79 buf[0], buf[1], buf[2], buf[3], buf[4],
49 buf[5], buf[6], buf[7], buf[8]); 80 buf[5], buf[6], buf[7], buf[8]);
50 81
51 ret = hid_hw_raw_request(data->hdev, buf[0], buf, BLINK1_CMD_SIZE, 82 ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
52 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 83 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
53 84
54 return ret < 0 ? ret : 0; 85 return ret < 0 ? ret : 0;
55} 86}
56 87
57static int blink1_update_color(struct blink1_data *data) 88static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
58{ 89{
59 u8 buf[BLINK1_CMD_SIZE] = { 1, 'n', 0, 0, 0, 0, 0, 0, 0 }; 90 int ret;
60
61 if (data->brightness) {
62 unsigned int coef = DIV_ROUND_CLOSEST(255, data->brightness);
63 91
64 buf[2] = DIV_ROUND_CLOSEST(blink1_rgb_to_r(data->rgb), coef); 92 ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
65 buf[3] = DIV_ROUND_CLOSEST(blink1_rgb_to_g(data->rgb), coef); 93 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
66 buf[4] = DIV_ROUND_CLOSEST(blink1_rgb_to_b(data->rgb), coef); 94 if (ret < 0)
67 } 95 return ret;
68 96
69 if (data->fade) { 97 hid_dbg(tdev->hdev, "<- %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
70 buf[1] = 'c'; 98 buf[0], buf[1], buf[2], buf[3], buf[4],
71 buf[5] = (data->fade & 0xFF00) >> 8; 99 buf[5], buf[6], buf[7], buf[8]);
72 buf[6] = (data->fade & 0x00FF);
73 }
74 100
75 return blink1_send_command(data, buf); 101 return 0;
76} 102}
77 103
78static void blink1_led_set(struct led_classdev *led_cdev, 104static int thingm_version(struct thingm_device *tdev)
79 enum led_brightness brightness)
80{ 105{
81 struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent); 106 u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
107 int err;
82 108
83 data->brightness = brightness; 109 err = thingm_send(tdev, buf);
84 if (blink1_update_color(data)) 110 if (err)
85 hid_err(data->hdev, "failed to update color\n"); 111 return err;
86}
87 112
88static enum led_brightness blink1_led_get(struct led_classdev *led_cdev) 113 err = thingm_recv(tdev, buf);
89{ 114 if (err)
90 struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent); 115 return err;
91 116
92 return data->brightness; 117 tdev->version.major = buf[3];
118 tdev->version.minor = buf[4];
119
120 return 0;
93} 121}
94 122
95static ssize_t blink1_show_rgb(struct device *dev, 123static int thingm_write_color(struct thingm_rgb *rgb)
96 struct device_attribute *attr, char *buf)
97{ 124{
98 struct blink1_data *data = dev_get_drvdata(dev->parent); 125 u8 buf[REPORT_SIZE] = { REPORT_ID, 'c', 0, 0, 0, 0, 0, rgb->num, 0 };
99 126
100 return sprintf(buf, "%.6X\n", data->rgb); 127 buf[2] = rgb->red.ldev.brightness;
128 buf[3] = rgb->green.ldev.brightness;
129 buf[4] = rgb->blue.ldev.brightness;
130
131 return thingm_send(rgb->tdev, buf);
101} 132}
102 133
103static ssize_t blink1_store_rgb(struct device *dev, 134static void thingm_work(struct work_struct *work)
104 struct device_attribute *attr, const char *buf, size_t count)
105{ 135{
106 struct blink1_data *data = dev_get_drvdata(dev->parent); 136 struct thingm_rgb *rgb = container_of(work, struct thingm_rgb, work);
107 long unsigned int rgb;
108 int ret;
109 137
110 ret = kstrtoul(buf, 16, &rgb); 138 mutex_lock(&rgb->tdev->lock);
111 if (ret)
112 return ret;
113
114 /* RGB triplet notation is 24-bit hexadecimal */
115 if (rgb > 0xFFFFFF)
116 return -EINVAL;
117 139
118 data->rgb = rgb; 140 if (thingm_write_color(rgb))
119 ret = blink1_update_color(data); 141 hid_err(rgb->tdev->hdev, "failed to write color\n");
120 142
121 return ret ? ret : count; 143 mutex_unlock(&rgb->tdev->lock);
122} 144}
123 145
124static DEVICE_ATTR(rgb, S_IRUGO | S_IWUSR, blink1_show_rgb, blink1_store_rgb); 146static void thingm_led_set(struct led_classdev *ldev,
125 147 enum led_brightness brightness)
126static ssize_t blink1_show_fade(struct device *dev,
127 struct device_attribute *attr, char *buf)
128{ 148{
129 struct blink1_data *data = dev_get_drvdata(dev->parent); 149 struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
130 150
131 return sprintf(buf, "%d\n", data->fade * 10); 151 /* the ledclass has already stored the brightness value */
152 schedule_work(&led->rgb->work);
132} 153}
133 154
134static ssize_t blink1_store_fade(struct device *dev, 155static int thingm_init_rgb(struct thingm_rgb *rgb)
135 struct device_attribute *attr, const char *buf, size_t count)
136{ 156{
137 struct blink1_data *data = dev_get_drvdata(dev->parent); 157 const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor;
138 long unsigned int fade; 158 int err;
139 int ret; 159
160 /* Register the red diode */
161 snprintf(rgb->red.name, sizeof(rgb->red.name),
162 "thingm%d:red:led%d", minor, rgb->num);
163 rgb->red.ldev.name = rgb->red.name;
164 rgb->red.ldev.max_brightness = 255;
165 rgb->red.ldev.brightness_set = thingm_led_set;
166 rgb->red.rgb = rgb;
167
168 err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->red.ldev);
169 if (err)
170 return err;
171
172 /* Register the green diode */
173 snprintf(rgb->green.name, sizeof(rgb->green.name),
174 "thingm%d:green:led%d", minor, rgb->num);
175 rgb->green.ldev.name = rgb->green.name;
176 rgb->green.ldev.max_brightness = 255;
177 rgb->green.ldev.brightness_set = thingm_led_set;
178 rgb->green.rgb = rgb;
179
180 err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->green.ldev);
181 if (err)
182 goto unregister_red;
183
184 /* Register the blue diode */
185 snprintf(rgb->blue.name, sizeof(rgb->blue.name),
186 "thingm%d:blue:led%d", minor, rgb->num);
187 rgb->blue.ldev.name = rgb->blue.name;
188 rgb->blue.ldev.max_brightness = 255;
189 rgb->blue.ldev.brightness_set = thingm_led_set;
190 rgb->blue.rgb = rgb;
191
192 err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->blue.ldev);
193 if (err)
194 goto unregister_green;
195
196 INIT_WORK(&rgb->work, thingm_work);
140 197
141 ret = kstrtoul(buf, 10, &fade); 198 return 0;
142 if (ret)
143 return ret;
144 199
145 /* blink(1) accepts 16-bit fade time, number of 10ms ticks */ 200unregister_green:
146 fade = DIV_ROUND_CLOSEST(fade, 10); 201 led_classdev_unregister(&rgb->green.ldev);
147 if (fade > 65535)
148 return -EINVAL;
149 202
150 data->fade = fade; 203unregister_red:
204 led_classdev_unregister(&rgb->red.ldev);
151 205
152 return count; 206 return err;
153} 207}
154 208
155static DEVICE_ATTR(fade, S_IRUGO | S_IWUSR, 209static void thingm_remove_rgb(struct thingm_rgb *rgb)
156 blink1_show_fade, blink1_store_fade);
157
158static ssize_t blink1_show_play(struct device *dev,
159 struct device_attribute *attr, char *buf)
160{ 210{
161 struct blink1_data *data = dev_get_drvdata(dev->parent); 211 flush_work(&rgb->work);
162 212 led_classdev_unregister(&rgb->red.ldev);
163 return sprintf(buf, "%d\n", data->play); 213 led_classdev_unregister(&rgb->green.ldev);
214 led_classdev_unregister(&rgb->blue.ldev);
164} 215}
165 216
166static ssize_t blink1_store_play(struct device *dev, 217static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
167 struct device_attribute *attr, const char *buf, size_t count)
168{ 218{
169 struct blink1_data *data = dev_get_drvdata(dev->parent); 219 struct thingm_device *tdev;
170 u8 cmd[BLINK1_CMD_SIZE] = { 1, 'p', 0, 0, 0, 0, 0, 0, 0 }; 220 int i, err;
171 long unsigned int play;
172 int ret;
173 221
174 ret = kstrtoul(buf, 10, &play); 222 tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
175 if (ret) 223 GFP_KERNEL);
176 return ret; 224 if (!tdev)
225 return -ENOMEM;
177 226
178 data->play = !!play; 227 tdev->hdev = hdev;
179 cmd[2] = data->play; 228 hid_set_drvdata(hdev, tdev);
180 ret = blink1_send_command(data, cmd);
181 229
182 return ret ? ret : count; 230 err = hid_parse(hdev);
183} 231 if (err)
184 232 goto error;
185static DEVICE_ATTR(play, S_IRUGO | S_IWUSR,
186 blink1_show_play, blink1_store_play);
187 233
188static const struct attribute_group blink1_sysfs_group = { 234 err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
189 .attrs = (struct attribute *[]) { 235 if (err)
190 &dev_attr_rgb.attr, 236 goto error;
191 &dev_attr_fade.attr,
192 &dev_attr_play.attr,
193 NULL
194 },
195};
196 237
197static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id) 238 mutex_init(&tdev->lock);
198{
199 struct blink1_data *data;
200 struct led_classdev *led;
201 char led_name[13];
202 int ret;
203 239
204 data = devm_kzalloc(&hdev->dev, sizeof(struct blink1_data), GFP_KERNEL); 240 err = thingm_version(tdev);
205 if (!data) 241 if (err)
206 return -ENOMEM; 242 goto stop;
207 243
208 hid_set_drvdata(hdev, data); 244 hid_dbg(hdev, "firmware version: %c.%c\n",
209 data->hdev = hdev; 245 tdev->version.major, tdev->version.minor);
210 data->rgb = 0xFFFFFF; /* set a default white color */
211 246
212 ret = hid_parse(hdev); 247 for (i = 0; i < ARRAY_SIZE(thingm_fwinfo) && !tdev->fwinfo; ++i)
213 if (ret) 248 if (thingm_fwinfo[i].major == tdev->version.major)
214 goto error; 249 tdev->fwinfo = &thingm_fwinfo[i];
215 250
216 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); 251 if (!tdev->fwinfo) {
217 if (ret) 252 hid_err(hdev, "unsupported firmware %c\n", tdev->version.major);
218 goto error; 253 goto stop;
254 }
219 255
220 /* blink(1) serial numbers range is 0x1A001000 to 0x1A002FFF */ 256 tdev->rgb = devm_kzalloc(&hdev->dev,
221 led = &data->led_cdev; 257 sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
222 snprintf(led_name, sizeof(led_name), "blink1::%s", hdev->uniq + 4); 258 GFP_KERNEL);
223 led->name = led_name; 259 if (!tdev->rgb) {
224 led->brightness_set = blink1_led_set; 260 err = -ENOMEM;
225 led->brightness_get = blink1_led_get;
226 ret = led_classdev_register(&hdev->dev, led);
227 if (ret)
228 goto stop; 261 goto stop;
262 }
229 263
230 ret = sysfs_create_group(&led->dev->kobj, &blink1_sysfs_group); 264 for (i = 0; i < tdev->fwinfo->numrgb; ++i) {
231 if (ret) 265 struct thingm_rgb *rgb = tdev->rgb + i;
232 goto remove_led; 266
267 rgb->tdev = tdev;
268 rgb->num = tdev->fwinfo->first + i;
269 err = thingm_init_rgb(rgb);
270 if (err) {
271 while (--i >= 0)
272 thingm_remove_rgb(tdev->rgb + i);
273 goto stop;
274 }
275 }
233 276
234 return 0; 277 return 0;
235
236remove_led:
237 led_classdev_unregister(led);
238stop: 278stop:
239 hid_hw_stop(hdev); 279 hid_hw_stop(hdev);
240error: 280error:
241 return ret; 281 return err;
242} 282}
243 283
244static void thingm_remove(struct hid_device *hdev) 284static void thingm_remove(struct hid_device *hdev)
245{ 285{
246 struct blink1_data *data = hid_get_drvdata(hdev); 286 struct thingm_device *tdev = hid_get_drvdata(hdev);
247 struct led_classdev *led = &data->led_cdev; 287 int i;
288
289 for (i = 0; i < tdev->fwinfo->numrgb; ++i)
290 thingm_remove_rgb(tdev->rgb + i);
248 291
249 sysfs_remove_group(&led->dev->kobj, &blink1_sysfs_group);
250 led_classdev_unregister(led);
251 hid_hw_stop(hdev); 292 hid_hw_stop(hdev);
252} 293}
253 294
diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c
deleted file mode 100644
index 902013ec041b..000000000000
--- a/drivers/hid/hid-wacom.c
+++ /dev/null
@@ -1,973 +0,0 @@
1/*
2 * Bluetooth Wacom Tablet support
3 *
4 * Copyright (c) 1999 Andreas Gal
5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7 * Copyright (c) 2006-2007 Jiri Kosina
8 * Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
9 * Copyright (c) 2006 Andrew Zabolotny <zap@homelink.ru>
10 * Copyright (c) 2009 Bastien Nocera <hadess@hadess.net>
11 * Copyright (c) 2011 Przemysław Firszt <przemo@firszt.eu>
12 */
13
14/*
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the Free
17 * Software Foundation; either version 2 of the License, or (at your option)
18 * any later version.
19 */
20
21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23#include <linux/device.h>
24#include <linux/hid.h>
25#include <linux/module.h>
26#include <linux/leds.h>
27#include <linux/slab.h>
28#include <linux/power_supply.h>
29
30#include "hid-ids.h"
31
32#define PAD_DEVICE_ID 0x0F
33
34#define WAC_CMD_LED_CONTROL 0x20
35#define WAC_CMD_ICON_START_STOP 0x21
36#define WAC_CMD_ICON_TRANSFER 0x26
37
38struct wacom_data {
39 __u16 tool;
40 __u16 butstate;
41 __u8 whlstate;
42 __u8 features;
43 __u32 id;
44 __u32 serial;
45 unsigned char high_speed;
46 __u8 battery_capacity;
47 __u8 power_raw;
48 __u8 ps_connected;
49 __u8 bat_charging;
50 struct power_supply battery;
51 struct power_supply ac;
52 __u8 led_selector;
53 struct led_classdev *leds[4];
54};
55
56/*percent of battery capacity for Graphire
57 8th value means AC online and show 100% capacity */
58static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
59/*percent of battery capacity for Intuos4 WL, AC has a separate bit*/
60static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
61
62static enum power_supply_property wacom_battery_props[] = {
63 POWER_SUPPLY_PROP_PRESENT,
64 POWER_SUPPLY_PROP_CAPACITY,
65 POWER_SUPPLY_PROP_SCOPE,
66 POWER_SUPPLY_PROP_STATUS,
67};
68
69static enum power_supply_property wacom_ac_props[] = {
70 POWER_SUPPLY_PROP_PRESENT,
71 POWER_SUPPLY_PROP_ONLINE,
72 POWER_SUPPLY_PROP_SCOPE,
73};
74
75static void wacom_scramble(__u8 *image)
76{
77 __u16 mask;
78 __u16 s1;
79 __u16 s2;
80 __u16 r1 ;
81 __u16 r2 ;
82 __u16 r;
83 __u8 buf[256];
84 int i, w, x, y, z;
85
86 for (x = 0; x < 32; x++) {
87 for (y = 0; y < 8; y++)
88 buf[(8 * x) + (7 - y)] = image[(8 * x) + y];
89 }
90
91 /* Change 76543210 into GECA6420 as required by Intuos4 WL
92 * HGFEDCBA HFDB7531
93 */
94 for (x = 0; x < 4; x++) {
95 for (y = 0; y < 4; y++) {
96 for (z = 0; z < 8; z++) {
97 mask = 0x0001;
98 r1 = 0;
99 r2 = 0;
100 i = (x << 6) + (y << 4) + z;
101 s1 = buf[i];
102 s2 = buf[i+8];
103 for (w = 0; w < 8; w++) {
104 r1 |= (s1 & mask);
105 r2 |= (s2 & mask);
106 s1 <<= 1;
107 s2 <<= 1;
108 mask <<= 2;
109 }
110 r = r1 | (r2 << 1);
111 i = (x << 6) + (y << 4) + (z << 1);
112 image[i] = 0xFF & r;
113 image[i+1] = (0xFF00 & r) >> 8;
114 }
115 }
116 }
117}
118
119static void wacom_set_image(struct hid_device *hdev, const char *image,
120 __u8 icon_no)
121{
122 __u8 rep_data[68];
123 __u8 p[256];
124 int ret, i, j;
125
126 for (i = 0; i < 256; i++)
127 p[i] = image[i];
128
129 rep_data[0] = WAC_CMD_ICON_START_STOP;
130 rep_data[1] = 0;
131 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
132 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
133 if (ret < 0)
134 goto err;
135
136 rep_data[0] = WAC_CMD_ICON_TRANSFER;
137 rep_data[1] = icon_no & 0x07;
138
139 wacom_scramble(p);
140
141 for (i = 0; i < 4; i++) {
142 for (j = 0; j < 64; j++)
143 rep_data[j + 3] = p[(i << 6) + j];
144
145 rep_data[2] = i;
146 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 67,
147 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
148 }
149
150 rep_data[0] = WAC_CMD_ICON_START_STOP;
151 rep_data[1] = 0;
152
153 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
154 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
155
156err:
157 return;
158}
159
160static void wacom_leds_set_brightness(struct led_classdev *led_dev,
161 enum led_brightness value)
162{
163 struct device *dev = led_dev->dev->parent;
164 struct hid_device *hdev;
165 struct wacom_data *wdata;
166 unsigned char *buf;
167 __u8 led = 0;
168 int i;
169
170 hdev = container_of(dev, struct hid_device, dev);
171 wdata = hid_get_drvdata(hdev);
172 for (i = 0; i < 4; ++i) {
173 if (wdata->leds[i] == led_dev)
174 wdata->led_selector = i;
175 }
176
177 led = wdata->led_selector | 0x04;
178 buf = kzalloc(9, GFP_KERNEL);
179 if (buf) {
180 buf[0] = WAC_CMD_LED_CONTROL;
181 buf[1] = led;
182 buf[2] = value >> 2;
183 buf[3] = value;
184 /* use fixed brightness for OLEDs */
185 buf[4] = 0x08;
186 hid_hw_raw_request(hdev, buf[0], buf, 9, HID_FEATURE_REPORT,
187 HID_REQ_SET_REPORT);
188 kfree(buf);
189 }
190
191 return;
192}
193
194static enum led_brightness wacom_leds_get_brightness(struct led_classdev *led_dev)
195{
196 struct wacom_data *wdata;
197 struct device *dev = led_dev->dev->parent;
198 int value = 0;
199 int i;
200
201 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
202
203 for (i = 0; i < 4; ++i) {
204 if (wdata->leds[i] == led_dev) {
205 value = wdata->leds[i]->brightness;
206 break;
207 }
208 }
209
210 return value;
211}
212
213
214static int wacom_initialize_leds(struct hid_device *hdev)
215{
216 struct wacom_data *wdata = hid_get_drvdata(hdev);
217 struct led_classdev *led;
218 struct device *dev = &hdev->dev;
219 size_t namesz = strlen(dev_name(dev)) + 12;
220 char *name;
221 int i, ret;
222
223 wdata->led_selector = 0;
224
225 for (i = 0; i < 4; i++) {
226 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
227 if (!led) {
228 hid_warn(hdev,
229 "can't allocate memory for LED selector\n");
230 ret = -ENOMEM;
231 goto err;
232 }
233
234 name = (void *)&led[1];
235 snprintf(name, namesz, "%s:selector:%d", dev_name(dev), i);
236 led->name = name;
237 led->brightness = 0;
238 led->max_brightness = 127;
239 led->brightness_get = wacom_leds_get_brightness;
240 led->brightness_set = wacom_leds_set_brightness;
241
242 wdata->leds[i] = led;
243
244 ret = led_classdev_register(dev, wdata->leds[i]);
245
246 if (ret) {
247 wdata->leds[i] = NULL;
248 kfree(led);
249 hid_warn(hdev, "can't register LED\n");
250 goto err;
251 }
252 }
253
254err:
255 return ret;
256}
257
258static void wacom_destroy_leds(struct hid_device *hdev)
259{
260 struct wacom_data *wdata = hid_get_drvdata(hdev);
261 struct led_classdev *led;
262 int i;
263
264 for (i = 0; i < 4; ++i) {
265 if (wdata->leds[i]) {
266 led = wdata->leds[i];
267 wdata->leds[i] = NULL;
268 led_classdev_unregister(led);
269 kfree(led);
270 }
271 }
272
273}
274
275static int wacom_battery_get_property(struct power_supply *psy,
276 enum power_supply_property psp,
277 union power_supply_propval *val)
278{
279 struct wacom_data *wdata = container_of(psy,
280 struct wacom_data, battery);
281 int ret = 0;
282
283 switch (psp) {
284 case POWER_SUPPLY_PROP_PRESENT:
285 val->intval = 1;
286 break;
287 case POWER_SUPPLY_PROP_SCOPE:
288 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
289 break;
290 case POWER_SUPPLY_PROP_CAPACITY:
291 val->intval = wdata->battery_capacity;
292 break;
293 case POWER_SUPPLY_PROP_STATUS:
294 if (wdata->bat_charging)
295 val->intval = POWER_SUPPLY_STATUS_CHARGING;
296 else
297 if (wdata->battery_capacity == 100 && wdata->ps_connected)
298 val->intval = POWER_SUPPLY_STATUS_FULL;
299 else
300 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
301 break;
302 default:
303 ret = -EINVAL;
304 break;
305 }
306 return ret;
307}
308
309static int wacom_ac_get_property(struct power_supply *psy,
310 enum power_supply_property psp,
311 union power_supply_propval *val)
312{
313 struct wacom_data *wdata = container_of(psy, struct wacom_data, ac);
314 int ret = 0;
315
316 switch (psp) {
317 case POWER_SUPPLY_PROP_PRESENT:
318 /* fall through */
319 case POWER_SUPPLY_PROP_ONLINE:
320 val->intval = wdata->ps_connected;
321 break;
322 case POWER_SUPPLY_PROP_SCOPE:
323 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
324 break;
325 default:
326 ret = -EINVAL;
327 break;
328 }
329 return ret;
330}
331
332static void wacom_set_features(struct hid_device *hdev, u8 speed)
333{
334 struct wacom_data *wdata = hid_get_drvdata(hdev);
335 int limit, ret;
336 __u8 rep_data[2];
337
338 switch (hdev->product) {
339 case USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH:
340 rep_data[0] = 0x03 ; rep_data[1] = 0x00;
341 limit = 3;
342 do {
343 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
344 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
345 } while (ret < 0 && limit-- > 0);
346
347 if (ret >= 0) {
348 if (speed == 0)
349 rep_data[0] = 0x05;
350 else
351 rep_data[0] = 0x06;
352
353 rep_data[1] = 0x00;
354 limit = 3;
355 do {
356 ret = hid_hw_raw_request(hdev, rep_data[0],
357 rep_data, 2, HID_FEATURE_REPORT,
358 HID_REQ_SET_REPORT);
359 } while (ret < 0 && limit-- > 0);
360
361 if (ret >= 0) {
362 wdata->high_speed = speed;
363 return;
364 }
365 }
366
367 /*
368 * Note that if the raw queries fail, it's not a hard failure
369 * and it is safe to continue
370 */
371 hid_warn(hdev, "failed to poke device, command %d, err %d\n",
372 rep_data[0], ret);
373 break;
374 case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH:
375 if (speed == 1)
376 wdata->features &= ~0x20;
377 else
378 wdata->features |= 0x20;
379
380 rep_data[0] = 0x03;
381 rep_data[1] = wdata->features;
382
383 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
384 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
385 if (ret >= 0)
386 wdata->high_speed = speed;
387 break;
388 }
389
390 return;
391}
392
393static ssize_t wacom_show_speed(struct device *dev,
394 struct device_attribute
395 *attr, char *buf)
396{
397 struct wacom_data *wdata = dev_get_drvdata(dev);
398
399 return snprintf(buf, PAGE_SIZE, "%i\n", wdata->high_speed);
400}
401
402static ssize_t wacom_store_speed(struct device *dev,
403 struct device_attribute *attr,
404 const char *buf, size_t count)
405{
406 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
407 int new_speed;
408
409 if (sscanf(buf, "%1d", &new_speed ) != 1)
410 return -EINVAL;
411
412 if (new_speed == 0 || new_speed == 1) {
413 wacom_set_features(hdev, new_speed);
414 return strnlen(buf, PAGE_SIZE);
415 } else
416 return -EINVAL;
417}
418
419static DEVICE_ATTR(speed, S_IRUGO | S_IWUSR | S_IWGRP,
420 wacom_show_speed, wacom_store_speed);
421
422#define WACOM_STORE(OLED_ID) \
423static ssize_t wacom_oled##OLED_ID##_store(struct device *dev, \
424 struct device_attribute *attr, \
425 const char *buf, size_t count) \
426{ \
427 struct hid_device *hdev = container_of(dev, struct hid_device, \
428 dev); \
429 \
430 if (count != 256) \
431 return -EINVAL; \
432 \
433 wacom_set_image(hdev, buf, OLED_ID); \
434 \
435 return count; \
436} \
437 \
438static DEVICE_ATTR(oled##OLED_ID##_img, S_IWUSR | S_IWGRP, NULL, \
439 wacom_oled##OLED_ID##_store)
440
441WACOM_STORE(0);
442WACOM_STORE(1);
443WACOM_STORE(2);
444WACOM_STORE(3);
445WACOM_STORE(4);
446WACOM_STORE(5);
447WACOM_STORE(6);
448WACOM_STORE(7);
449
450static int wacom_gr_parse_report(struct hid_device *hdev,
451 struct wacom_data *wdata,
452 struct input_dev *input, unsigned char *data)
453{
454 int tool, x, y, rw;
455
456 tool = 0;
457 /* Get X & Y positions */
458 x = le16_to_cpu(*(__le16 *) &data[2]);
459 y = le16_to_cpu(*(__le16 *) &data[4]);
460
461 /* Get current tool identifier */
462 if (data[1] & 0x90) { /* If pen is in the in/active area */
463 switch ((data[1] >> 5) & 3) {
464 case 0: /* Pen */
465 tool = BTN_TOOL_PEN;
466 break;
467
468 case 1: /* Rubber */
469 tool = BTN_TOOL_RUBBER;
470 break;
471
472 case 2: /* Mouse with wheel */
473 case 3: /* Mouse without wheel */
474 tool = BTN_TOOL_MOUSE;
475 break;
476 }
477
478 /* Reset tool if out of active tablet area */
479 if (!(data[1] & 0x10))
480 tool = 0;
481 }
482
483 /* If tool changed, notify input subsystem */
484 if (wdata->tool != tool) {
485 if (wdata->tool) {
486 /* Completely reset old tool state */
487 if (wdata->tool == BTN_TOOL_MOUSE) {
488 input_report_key(input, BTN_LEFT, 0);
489 input_report_key(input, BTN_RIGHT, 0);
490 input_report_key(input, BTN_MIDDLE, 0);
491 input_report_abs(input, ABS_DISTANCE,
492 input_abs_get_max(input, ABS_DISTANCE));
493 } else {
494 input_report_key(input, BTN_TOUCH, 0);
495 input_report_key(input, BTN_STYLUS, 0);
496 input_report_key(input, BTN_STYLUS2, 0);
497 input_report_abs(input, ABS_PRESSURE, 0);
498 }
499 input_report_key(input, wdata->tool, 0);
500 input_sync(input);
501 }
502 wdata->tool = tool;
503 if (tool)
504 input_report_key(input, tool, 1);
505 }
506
507 if (tool) {
508 input_report_abs(input, ABS_X, x);
509 input_report_abs(input, ABS_Y, y);
510
511 switch ((data[1] >> 5) & 3) {
512 case 2: /* Mouse with wheel */
513 input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
514 rw = (data[6] & 0x01) ? -1 :
515 (data[6] & 0x02) ? 1 : 0;
516 input_report_rel(input, REL_WHEEL, rw);
517 /* fall through */
518
519 case 3: /* Mouse without wheel */
520 input_report_key(input, BTN_LEFT, data[1] & 0x01);
521 input_report_key(input, BTN_RIGHT, data[1] & 0x02);
522 /* Compute distance between mouse and tablet */
523 rw = 44 - (data[6] >> 2);
524 if (rw < 0)
525 rw = 0;
526 else if (rw > 31)
527 rw = 31;
528 input_report_abs(input, ABS_DISTANCE, rw);
529 break;
530
531 default:
532 input_report_abs(input, ABS_PRESSURE,
533 data[6] | (((__u16) (data[1] & 0x08)) << 5));
534 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
535 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
536 input_report_key(input, BTN_STYLUS2, (tool == BTN_TOOL_PEN) && data[1] & 0x04);
537 break;
538 }
539
540 input_sync(input);
541 }
542
543 /* Report the state of the two buttons at the top of the tablet
544 * as two extra fingerpad keys (buttons 4 & 5). */
545 rw = data[7] & 0x03;
546 if (rw != wdata->butstate) {
547 wdata->butstate = rw;
548 input_report_key(input, BTN_0, rw & 0x02);
549 input_report_key(input, BTN_1, rw & 0x01);
550 input_report_key(input, BTN_TOOL_FINGER, 0xf0);
551 input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
552 input_sync(input);
553 }
554
555 /* Store current battery capacity and power supply state*/
556 rw = (data[7] >> 2 & 0x07);
557 if (rw != wdata->power_raw) {
558 wdata->power_raw = rw;
559 wdata->battery_capacity = batcap_gr[rw];
560 if (rw == 7)
561 wdata->ps_connected = 1;
562 else
563 wdata->ps_connected = 0;
564 }
565 return 1;
566}
567
568static void wacom_i4_parse_button_report(struct wacom_data *wdata,
569 struct input_dev *input, unsigned char *data)
570{
571 __u16 new_butstate;
572 __u8 new_whlstate;
573 __u8 sync = 0;
574
575 new_whlstate = data[1];
576 if (new_whlstate != wdata->whlstate) {
577 wdata->whlstate = new_whlstate;
578 if (new_whlstate & 0x80) {
579 input_report_key(input, BTN_TOUCH, 1);
580 input_report_abs(input, ABS_WHEEL, (new_whlstate & 0x7f));
581 input_report_key(input, BTN_TOOL_FINGER, 1);
582 } else {
583 input_report_key(input, BTN_TOUCH, 0);
584 input_report_abs(input, ABS_WHEEL, 0);
585 input_report_key(input, BTN_TOOL_FINGER, 0);
586 }
587 sync = 1;
588 }
589
590 new_butstate = (data[3] << 1) | (data[2] & 0x01);
591 if (new_butstate != wdata->butstate) {
592 wdata->butstate = new_butstate;
593 input_report_key(input, BTN_0, new_butstate & 0x001);
594 input_report_key(input, BTN_1, new_butstate & 0x002);
595 input_report_key(input, BTN_2, new_butstate & 0x004);
596 input_report_key(input, BTN_3, new_butstate & 0x008);
597 input_report_key(input, BTN_4, new_butstate & 0x010);
598 input_report_key(input, BTN_5, new_butstate & 0x020);
599 input_report_key(input, BTN_6, new_butstate & 0x040);
600 input_report_key(input, BTN_7, new_butstate & 0x080);
601 input_report_key(input, BTN_8, new_butstate & 0x100);
602 input_report_key(input, BTN_TOOL_FINGER, 1);
603 sync = 1;
604 }
605
606 if (sync) {
607 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
608 input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
609 input_sync(input);
610 }
611}
612
613static void wacom_i4_parse_pen_report(struct wacom_data *wdata,
614 struct input_dev *input, unsigned char *data)
615{
616 __u16 x, y, pressure;
617 __u8 distance;
618 __u8 tilt_x, tilt_y;
619
620 switch (data[1]) {
621 case 0x80: /* Out of proximity report */
622 input_report_key(input, BTN_TOUCH, 0);
623 input_report_abs(input, ABS_PRESSURE, 0);
624 input_report_key(input, BTN_STYLUS, 0);
625 input_report_key(input, BTN_STYLUS2, 0);
626 input_report_key(input, wdata->tool, 0);
627 input_report_abs(input, ABS_MISC, 0);
628 input_event(input, EV_MSC, MSC_SERIAL, wdata->serial);
629 wdata->tool = 0;
630 input_sync(input);
631 break;
632 case 0xC2: /* Tool report */
633 wdata->id = ((data[2] << 4) | (data[3] >> 4) |
634 ((data[7] & 0x0f) << 20) |
635 ((data[8] & 0xf0) << 12));
636 wdata->serial = ((data[3] & 0x0f) << 28) +
637 (data[4] << 20) + (data[5] << 12) +
638 (data[6] << 4) + (data[7] >> 4);
639
640 switch (wdata->id) {
641 case 0x100802:
642 wdata->tool = BTN_TOOL_PEN;
643 break;
644 case 0x10080A:
645 wdata->tool = BTN_TOOL_RUBBER;
646 break;
647 }
648 break;
649 default: /* Position/pressure report */
650 x = data[2] << 9 | data[3] << 1 | ((data[9] & 0x02) >> 1);
651 y = data[4] << 9 | data[5] << 1 | (data[9] & 0x01);
652 pressure = (data[6] << 3) | ((data[7] & 0xC0) >> 5)
653 | (data[1] & 0x01);
654 distance = (data[9] >> 2) & 0x3f;
655 tilt_x = ((data[7] << 1) & 0x7e) | (data[8] >> 7);
656 tilt_y = data[8] & 0x7f;
657
658 input_report_key(input, BTN_TOUCH, pressure > 1);
659
660 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
661 input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
662 input_report_key(input, wdata->tool, 1);
663 input_report_abs(input, ABS_X, x);
664 input_report_abs(input, ABS_Y, y);
665 input_report_abs(input, ABS_PRESSURE, pressure);
666 input_report_abs(input, ABS_DISTANCE, distance);
667 input_report_abs(input, ABS_TILT_X, tilt_x);
668 input_report_abs(input, ABS_TILT_Y, tilt_y);
669 input_report_abs(input, ABS_MISC, wdata->id);
670 input_event(input, EV_MSC, MSC_SERIAL, wdata->serial);
671 input_report_key(input, wdata->tool, 1);
672 input_sync(input);
673 break;
674 }
675
676 return;
677}
678
679static void wacom_i4_parse_report(struct hid_device *hdev,
680 struct wacom_data *wdata,
681 struct input_dev *input, unsigned char *data)
682{
683 switch (data[0]) {
684 case 0x00: /* Empty report */
685 break;
686 case 0x02: /* Pen report */
687 wacom_i4_parse_pen_report(wdata, input, data);
688 break;
689 case 0x03: /* Features Report */
690 wdata->features = data[2];
691 break;
692 case 0x0C: /* Button report */
693 wacom_i4_parse_button_report(wdata, input, data);
694 break;
695 default:
696 hid_err(hdev, "Unknown report: %d,%d\n", data[0], data[1]);
697 break;
698 }
699}
700
701static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
702 u8 *raw_data, int size)
703{
704 struct wacom_data *wdata = hid_get_drvdata(hdev);
705 struct hid_input *hidinput;
706 struct input_dev *input;
707 unsigned char *data = (unsigned char *) raw_data;
708 int i;
709 __u8 power_raw;
710
711 if (!(hdev->claimed & HID_CLAIMED_INPUT))
712 return 0;
713
714 hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
715 input = hidinput->input;
716
717 switch (hdev->product) {
718 case USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH:
719 if (data[0] == 0x03) {
720 return wacom_gr_parse_report(hdev, wdata, input, data);
721 } else {
722 hid_err(hdev, "Unknown report: %d,%d size:%d\n",
723 data[0], data[1], size);
724 return 0;
725 }
726 break;
727 case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH:
728 i = 1;
729
730 switch (data[0]) {
731 case 0x04:
732 wacom_i4_parse_report(hdev, wdata, input, data + i);
733 i += 10;
734 /* fall through */
735 case 0x03:
736 wacom_i4_parse_report(hdev, wdata, input, data + i);
737 i += 10;
738 wacom_i4_parse_report(hdev, wdata, input, data + i);
739 power_raw = data[i+10];
740 if (power_raw != wdata->power_raw) {
741 wdata->power_raw = power_raw;
742 wdata->battery_capacity = batcap_i4[power_raw & 0x07];
743 wdata->bat_charging = (power_raw & 0x08) ? 1 : 0;
744 wdata->ps_connected = (power_raw & 0x10) ? 1 : 0;
745 }
746
747 break;
748 default:
749 hid_err(hdev, "Unknown report: %d,%d size:%d\n",
750 data[0], data[1], size);
751 return 0;
752 }
753 }
754 return 1;
755}
756
757static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi,
758 struct hid_field *field, struct hid_usage *usage, unsigned long **bit,
759 int *max)
760{
761 struct input_dev *input = hi->input;
762
763 __set_bit(INPUT_PROP_POINTER, input->propbit);
764
765 /* Basics */
766 input->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL);
767
768 __set_bit(REL_WHEEL, input->relbit);
769
770 __set_bit(BTN_TOOL_PEN, input->keybit);
771 __set_bit(BTN_TOUCH, input->keybit);
772 __set_bit(BTN_STYLUS, input->keybit);
773 __set_bit(BTN_STYLUS2, input->keybit);
774 __set_bit(BTN_LEFT, input->keybit);
775 __set_bit(BTN_RIGHT, input->keybit);
776 __set_bit(BTN_MIDDLE, input->keybit);
777
778 /* Pad */
779 input_set_capability(input, EV_MSC, MSC_SERIAL);
780
781 __set_bit(BTN_0, input->keybit);
782 __set_bit(BTN_1, input->keybit);
783 __set_bit(BTN_TOOL_FINGER, input->keybit);
784
785 /* Distance, rubber and mouse */
786 __set_bit(BTN_TOOL_RUBBER, input->keybit);
787 __set_bit(BTN_TOOL_MOUSE, input->keybit);
788
789 switch (hdev->product) {
790 case USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH:
791 input_set_abs_params(input, ABS_X, 0, 16704, 4, 0);
792 input_set_abs_params(input, ABS_Y, 0, 12064, 4, 0);
793 input_set_abs_params(input, ABS_PRESSURE, 0, 511, 0, 0);
794 input_set_abs_params(input, ABS_DISTANCE, 0, 32, 0, 0);
795 break;
796 case USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH:
797 __set_bit(ABS_WHEEL, input->absbit);
798 __set_bit(ABS_MISC, input->absbit);
799 __set_bit(BTN_2, input->keybit);
800 __set_bit(BTN_3, input->keybit);
801 __set_bit(BTN_4, input->keybit);
802 __set_bit(BTN_5, input->keybit);
803 __set_bit(BTN_6, input->keybit);
804 __set_bit(BTN_7, input->keybit);
805 __set_bit(BTN_8, input->keybit);
806 input_set_abs_params(input, ABS_WHEEL, 0, 71, 0, 0);
807 input_set_abs_params(input, ABS_X, 0, 40640, 4, 0);
808 input_set_abs_params(input, ABS_Y, 0, 25400, 4, 0);
809 input_set_abs_params(input, ABS_PRESSURE, 0, 2047, 0, 0);
810 input_set_abs_params(input, ABS_DISTANCE, 0, 63, 0, 0);
811 input_set_abs_params(input, ABS_TILT_X, 0, 127, 0, 0);
812 input_set_abs_params(input, ABS_TILT_Y, 0, 127, 0, 0);
813 break;
814 }
815
816 return 0;
817}
818
819static int wacom_probe(struct hid_device *hdev,
820 const struct hid_device_id *id)
821{
822 struct wacom_data *wdata;
823 int ret;
824
825 wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
826 if (wdata == NULL) {
827 hid_err(hdev, "can't alloc wacom descriptor\n");
828 return -ENOMEM;
829 }
830
831 hid_set_drvdata(hdev, wdata);
832
833 /* Parse the HID report now */
834 ret = hid_parse(hdev);
835 if (ret) {
836 hid_err(hdev, "parse failed\n");
837 goto err_free;
838 }
839
840 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
841 if (ret) {
842 hid_err(hdev, "hw start failed\n");
843 goto err_free;
844 }
845
846 ret = device_create_file(&hdev->dev, &dev_attr_speed);
847 if (ret)
848 hid_warn(hdev,
849 "can't create sysfs speed attribute err: %d\n", ret);
850
851#define OLED_INIT(OLED_ID) \
852 do { \
853 ret = device_create_file(&hdev->dev, \
854 &dev_attr_oled##OLED_ID##_img); \
855 if (ret) \
856 hid_warn(hdev, \
857 "can't create sysfs oled attribute, err: %d\n", ret);\
858 } while (0)
859
860OLED_INIT(0);
861OLED_INIT(1);
862OLED_INIT(2);
863OLED_INIT(3);
864OLED_INIT(4);
865OLED_INIT(5);
866OLED_INIT(6);
867OLED_INIT(7);
868
869 wdata->features = 0;
870 wacom_set_features(hdev, 1);
871
872 if (hdev->product == USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) {
873 sprintf(hdev->name, "%s", "Wacom Intuos4 WL");
874 ret = wacom_initialize_leds(hdev);
875 if (ret)
876 hid_warn(hdev,
877 "can't create led attribute, err: %d\n", ret);
878 }
879
880 wdata->battery.properties = wacom_battery_props;
881 wdata->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
882 wdata->battery.get_property = wacom_battery_get_property;
883 wdata->battery.name = "wacom_battery";
884 wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
885 wdata->battery.use_for_apm = 0;
886
887
888 ret = power_supply_register(&hdev->dev, &wdata->battery);
889 if (ret) {
890 hid_err(hdev, "can't create sysfs battery attribute, err: %d\n",
891 ret);
892 goto err_battery;
893 }
894
895 power_supply_powers(&wdata->battery, &hdev->dev);
896
897 wdata->ac.properties = wacom_ac_props;
898 wdata->ac.num_properties = ARRAY_SIZE(wacom_ac_props);
899 wdata->ac.get_property = wacom_ac_get_property;
900 wdata->ac.name = "wacom_ac";
901 wdata->ac.type = POWER_SUPPLY_TYPE_MAINS;
902 wdata->ac.use_for_apm = 0;
903
904 ret = power_supply_register(&hdev->dev, &wdata->ac);
905 if (ret) {
906 hid_err(hdev,
907 "can't create ac battery attribute, err: %d\n", ret);
908 goto err_ac;
909 }
910
911 power_supply_powers(&wdata->ac, &hdev->dev);
912 return 0;
913
914err_ac:
915 power_supply_unregister(&wdata->battery);
916err_battery:
917 wacom_destroy_leds(hdev);
918 device_remove_file(&hdev->dev, &dev_attr_oled0_img);
919 device_remove_file(&hdev->dev, &dev_attr_oled1_img);
920 device_remove_file(&hdev->dev, &dev_attr_oled2_img);
921 device_remove_file(&hdev->dev, &dev_attr_oled3_img);
922 device_remove_file(&hdev->dev, &dev_attr_oled4_img);
923 device_remove_file(&hdev->dev, &dev_attr_oled5_img);
924 device_remove_file(&hdev->dev, &dev_attr_oled6_img);
925 device_remove_file(&hdev->dev, &dev_attr_oled7_img);
926 device_remove_file(&hdev->dev, &dev_attr_speed);
927 hid_hw_stop(hdev);
928err_free:
929 kfree(wdata);
930 return ret;
931}
932
933static void wacom_remove(struct hid_device *hdev)
934{
935 struct wacom_data *wdata = hid_get_drvdata(hdev);
936
937 wacom_destroy_leds(hdev);
938 device_remove_file(&hdev->dev, &dev_attr_oled0_img);
939 device_remove_file(&hdev->dev, &dev_attr_oled1_img);
940 device_remove_file(&hdev->dev, &dev_attr_oled2_img);
941 device_remove_file(&hdev->dev, &dev_attr_oled3_img);
942 device_remove_file(&hdev->dev, &dev_attr_oled4_img);
943 device_remove_file(&hdev->dev, &dev_attr_oled5_img);
944 device_remove_file(&hdev->dev, &dev_attr_oled6_img);
945 device_remove_file(&hdev->dev, &dev_attr_oled7_img);
946 device_remove_file(&hdev->dev, &dev_attr_speed);
947 hid_hw_stop(hdev);
948
949 power_supply_unregister(&wdata->battery);
950 power_supply_unregister(&wdata->ac);
951 kfree(hid_get_drvdata(hdev));
952}
953
954static const struct hid_device_id wacom_devices[] = {
955 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
956 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },
957
958 { }
959};
960MODULE_DEVICE_TABLE(hid, wacom_devices);
961
962static struct hid_driver wacom_driver = {
963 .name = "wacom",
964 .id_table = wacom_devices,
965 .probe = wacom_probe,
966 .remove = wacom_remove,
967 .raw_event = wacom_raw_event,
968 .input_mapped = wacom_input_mapped,
969};
970module_hid_driver(wacom_driver);
971
972MODULE_DESCRIPTION("Driver for Wacom Graphire Bluetooth and Wacom Intuos4 WL");
973MODULE_LICENSE("GPL");
diff --git a/drivers/hid/i2c-hid/i2c-hid.c b/drivers/hid/i2c-hid/i2c-hid.c
index b50860db92f1..21aafc8f48c8 100644
--- a/drivers/hid/i2c-hid/i2c-hid.c
+++ b/drivers/hid/i2c-hid/i2c-hid.c
@@ -807,34 +807,18 @@ static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
807 unsigned int dsize; 807 unsigned int dsize;
808 int ret; 808 int ret;
809 809
810 /* Fetch the length of HID description, retrieve the 4 first bytes: 810 /* i2c hid fetch using a fixed descriptor size (30 bytes) */
811 * bytes 0-1 -> length 811 i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
812 * bytes 2-3 -> bcdVersion (has to be 1.00) */ 812 ret = i2c_hid_command(client, &hid_descr_cmd, ihid->hdesc_buffer,
813 ret = i2c_hid_command(client, &hid_descr_cmd, ihid->hdesc_buffer, 4); 813 sizeof(struct i2c_hid_desc));
814
815 i2c_hid_dbg(ihid, "%s, ihid->hdesc_buffer: %4ph\n", __func__,
816 ihid->hdesc_buffer);
817
818 if (ret) { 814 if (ret) {
819 dev_err(&client->dev, 815 dev_err(&client->dev, "hid_descr_cmd failed\n");
820 "unable to fetch the size of HID descriptor (ret=%d)\n",
821 ret);
822 return -ENODEV;
823 }
824
825 dsize = le16_to_cpu(hdesc->wHIDDescLength);
826 /*
827 * the size of the HID descriptor should at least contain
828 * its size and the bcdVersion (4 bytes), and should not be greater
829 * than sizeof(struct i2c_hid_desc) as we directly fill this struct
830 * through i2c_hid_command.
831 */
832 if (dsize < 4 || dsize > sizeof(struct i2c_hid_desc)) {
833 dev_err(&client->dev, "weird size of HID descriptor (%u)\n",
834 dsize);
835 return -ENODEV; 816 return -ENODEV;
836 } 817 }
837 818
819 /* Validate the length of HID descriptor, the 4 first bytes:
820 * bytes 0-1 -> length
821 * bytes 2-3 -> bcdVersion (has to be 1.00) */
838 /* check bcdVersion == 1.0 */ 822 /* check bcdVersion == 1.0 */
839 if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) { 823 if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) {
840 dev_err(&client->dev, 824 dev_err(&client->dev,
@@ -843,17 +827,14 @@ static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
843 return -ENODEV; 827 return -ENODEV;
844 } 828 }
845 829
846 i2c_hid_dbg(ihid, "Fetching the HID descriptor\n"); 830 /* Descriptor length should be 30 bytes as per the specification */
847 831 dsize = le16_to_cpu(hdesc->wHIDDescLength);
848 ret = i2c_hid_command(client, &hid_descr_cmd, ihid->hdesc_buffer, 832 if (dsize != sizeof(struct i2c_hid_desc)) {
849 dsize); 833 dev_err(&client->dev, "weird size of HID descriptor (%u)\n",
850 if (ret) { 834 dsize);
851 dev_err(&client->dev, "hid_descr_cmd Fail\n");
852 return -ENODEV; 835 return -ENODEV;
853 } 836 }
854
855 i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, ihid->hdesc_buffer); 837 i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, ihid->hdesc_buffer);
856
857 return 0; 838 return 0;
858} 839}
859 840
diff --git a/drivers/hid/uhid.c b/drivers/hid/uhid.c
index 0d078c32db4f..0cb92e347258 100644
--- a/drivers/hid/uhid.c
+++ b/drivers/hid/uhid.c
@@ -441,12 +441,11 @@ static int uhid_dev_create2(struct uhid_device *uhid,
441 if (uhid->rd_size <= 0 || uhid->rd_size > HID_MAX_DESCRIPTOR_SIZE) 441 if (uhid->rd_size <= 0 || uhid->rd_size > HID_MAX_DESCRIPTOR_SIZE)
442 return -EINVAL; 442 return -EINVAL;
443 443
444 uhid->rd_data = kmalloc(uhid->rd_size, GFP_KERNEL); 444 uhid->rd_data = kmemdup(ev->u.create2.rd_data, uhid->rd_size,
445 GFP_KERNEL);
445 if (!uhid->rd_data) 446 if (!uhid->rd_data)
446 return -ENOMEM; 447 return -ENOMEM;
447 448
448 memcpy(uhid->rd_data, ev->u.create2.rd_data, uhid->rd_size);
449
450 hid = hid_allocate_device(); 449 hid = hid_allocate_device();
451 if (IS_ERR(hid)) { 450 if (IS_ERR(hid)) {
452 ret = PTR_ERR(hid); 451 ret = PTR_ERR(hid);
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 8e4ddb369883..31e6727cd009 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -49,6 +49,7 @@ static const struct hid_blacklist {
49 49
50 { USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II, HID_QUIRK_MULTI_INPUT }, 50 { USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II, HID_QUIRK_MULTI_INPUT },
51 { USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT }, 51 { USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT },
52 { USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH_2968, HID_QUIRK_MULTI_INPUT },
52 { USB_VENDOR_ID_GREENASIA, USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD, HID_QUIRK_MULTI_INPUT }, 53 { USB_VENDOR_ID_GREENASIA, USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD, HID_QUIRK_MULTI_INPUT },
53 { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS }, 54 { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
54 { USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT }, 55 { USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT },
@@ -76,6 +77,8 @@ static const struct hid_blacklist {
76 { USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GX680R_LED_PANEL, HID_QUIRK_NO_INIT_REPORTS }, 77 { USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GX680R_LED_PANEL, HID_QUIRK_NO_INIT_REPORTS },
77 { USB_VENDOR_ID_NEXIO, USB_DEVICE_ID_NEXIO_MULTITOUCH_PTI0750, HID_QUIRK_NO_INIT_REPORTS }, 78 { USB_VENDOR_ID_NEXIO, USB_DEVICE_ID_NEXIO_MULTITOUCH_PTI0750, HID_QUIRK_NO_INIT_REPORTS },
78 { USB_VENDOR_ID_NOVATEK, USB_DEVICE_ID_NOVATEK_MOUSE, HID_QUIRK_NO_INIT_REPORTS }, 79 { USB_VENDOR_ID_NOVATEK, USB_DEVICE_ID_NOVATEK_MOUSE, HID_QUIRK_NO_INIT_REPORTS },
80 { USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_1610, HID_QUIRK_NOGET },
81 { USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_1640, HID_QUIRK_NOGET },
79 { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NO_INIT_REPORTS }, 82 { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NO_INIT_REPORTS },
80 { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1, HID_QUIRK_NO_INIT_REPORTS }, 83 { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1, HID_QUIRK_NO_INIT_REPORTS },
81 { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2, HID_QUIRK_NO_INIT_REPORTS }, 84 { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2, HID_QUIRK_NO_INIT_REPORTS },
@@ -115,6 +118,7 @@ static const struct hid_blacklist {
115 { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X, HID_QUIRK_MULTI_INPUT }, 118 { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X, HID_QUIRK_MULTI_INPUT },
116 { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X, HID_QUIRK_MULTI_INPUT }, 119 { USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X, HID_QUIRK_MULTI_INPUT },
117 { USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_DUOSENSE, HID_QUIRK_NO_INIT_REPORTS }, 120 { USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_DUOSENSE, HID_QUIRK_NO_INIT_REPORTS },
121 { USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD, HID_QUIRK_NO_INIT_REPORTS },
118 { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS1, HID_QUIRK_NO_INIT_REPORTS }, 122 { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS1, HID_QUIRK_NO_INIT_REPORTS },
119 { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS2, HID_QUIRK_NO_INIT_REPORTS }, 123 { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_LTS2, HID_QUIRK_NO_INIT_REPORTS },
120 { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_HD, HID_QUIRK_NO_INIT_REPORTS }, 124 { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_HD, HID_QUIRK_NO_INIT_REPORTS },
diff --git a/drivers/hid/wacom.h b/drivers/hid/wacom.h
new file mode 100644
index 000000000000..64bc1b296d91
--- /dev/null
+++ b/drivers/hid/wacom.h
@@ -0,0 +1,146 @@
1/*
2 * drivers/input/tablet/wacom.h
3 *
4 * USB Wacom tablet support
5 *
6 * Copyright (c) 2000-2004 Vojtech Pavlik <vojtech@ucw.cz>
7 * Copyright (c) 2000 Andreas Bach Aaen <abach@stofanet.dk>
8 * Copyright (c) 2000 Clifford Wolf <clifford@clifford.at>
9 * Copyright (c) 2000 Sam Mosel <sam.mosel@computer.org>
10 * Copyright (c) 2000 James E. Blair <corvus@gnu.org>
11 * Copyright (c) 2000 Daniel Egger <egger@suse.de>
12 * Copyright (c) 2001 Frederic Lepied <flepied@mandrakesoft.com>
13 * Copyright (c) 2004 Panagiotis Issaris <panagiotis.issaris@mech.kuleuven.ac.be>
14 * Copyright (c) 2002-2011 Ping Cheng <pingc@wacom.com>
15 * Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@redhat.com>
16 *
17 * ChangeLog:
18 * v0.1 (vp) - Initial release
19 * v0.2 (aba) - Support for all buttons / combinations
20 * v0.3 (vp) - Support for Intuos added
21 * v0.4 (sm) - Support for more Intuos models, menustrip
22 * relative mode, proximity.
23 * v0.5 (vp) - Big cleanup, nifty features removed,
24 * they belong in userspace
25 * v1.8 (vp) - Submit URB only when operating, moved to CVS,
26 * use input_report_key instead of report_btn and
27 * other cleanups
28 * v1.11 (vp) - Add URB ->dev setting for new kernels
29 * v1.11 (jb) - Add support for the 4D Mouse & Lens
30 * v1.12 (de) - Add support for two more inking pen IDs
31 * v1.14 (vp) - Use new USB device id probing scheme.
32 * Fix Wacom Graphire mouse wheel
33 * v1.18 (vp) - Fix mouse wheel direction
34 * Make mouse relative
35 * v1.20 (fl) - Report tool id for Intuos devices
36 * - Multi tools support
37 * - Corrected Intuos protocol decoding (airbrush, 4D mouse, lens cursor...)
38 * - Add PL models support
39 * - Fix Wacom Graphire mouse wheel again
40 * v1.21 (vp) - Removed protocol descriptions
41 * - Added MISC_SERIAL for tool serial numbers
42 * (gb) - Identify version on module load.
43 * v1.21.1 (fl) - added Graphire2 support
44 * v1.21.2 (fl) - added Intuos2 support
45 * - added all the PL ids
46 * v1.21.3 (fl) - added another eraser id from Neil Okamoto
47 * - added smooth filter for Graphire from Peri Hankey
48 * - added PenPartner support from Olaf van Es
49 * - new tool ids from Ole Martin Bjoerndalen
50 * v1.29 (pc) - Add support for more tablets
51 * - Fix pressure reporting
52 * v1.30 (vp) - Merge 2.4 and 2.5 drivers
53 * - Since 2.5 now has input_sync(), remove MSC_SERIAL abuse
54 * - Cleanups here and there
55 * v1.30.1 (pi) - Added Graphire3 support
56 * v1.40 (pc) - Add support for several new devices, fix eraser reporting, ...
57 * v1.43 (pc) - Added support for Cintiq 21UX
58 * - Fixed a Graphire bug
59 * - Merged wacom_intuos3_irq into wacom_intuos_irq
60 * v1.44 (pc) - Added support for Graphire4, Cintiq 710, Intuos3 6x11, etc.
61 * - Report Device IDs
62 * v1.45 (pc) - Added support for DTF 521, Intuos3 12x12 and 12x19
63 * - Minor data report fix
64 * v1.46 (pc) - Split wacom.c into wacom_sys.c and wacom_wac.c,
65 * - where wacom_sys.c deals with system specific code,
66 * - and wacom_wac.c deals with Wacom specific code
67 * - Support Intuos3 4x6
68 * v1.47 (pc) - Added support for Bamboo
69 * v1.48 (pc) - Added support for Bamboo1, BambooFun, and Cintiq 12WX
70 * v1.49 (pc) - Added support for USB Tablet PC (0x90, 0x93, and 0x9A)
71 * v1.50 (pc) - Fixed a TabletPC touch bug in 2.6.28
72 * v1.51 (pc) - Added support for Intuos4
73 * v1.52 (pc) - Query Wacom data upon system resume
74 * - add defines for features->type
75 * - add new devices (0x9F, 0xE2, and 0XE3)
76 * v2.00 (bt) - conversion to a HID driver
77 * - integration of the Bluetooth devices
78 */
79
80/*
81 * This program is free software; you can redistribute it and/or modify
82 * it under the terms of the GNU General Public License as published by
83 * the Free Software Foundation; either version 2 of the License, or
84 * (at your option) any later version.
85 */
86#ifndef WACOM_H
87#define WACOM_H
88#include <linux/kernel.h>
89#include <linux/slab.h>
90#include <linux/module.h>
91#include <linux/mod_devicetable.h>
92#include <linux/usb/input.h>
93#include <linux/power_supply.h>
94#include <asm/unaligned.h>
95
96/*
97 * Version Information
98 */
99#define DRIVER_VERSION "v2.00"
100#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
101#define DRIVER_DESC "USB Wacom tablet driver"
102#define DRIVER_LICENSE "GPL"
103
104#define USB_VENDOR_ID_WACOM 0x056a
105#define USB_VENDOR_ID_LENOVO 0x17ef
106
107struct wacom {
108 struct usb_device *usbdev;
109 struct usb_interface *intf;
110 struct wacom_wac wacom_wac;
111 struct hid_device *hdev;
112 struct mutex lock;
113 struct work_struct work;
114 struct wacom_led {
115 u8 select[2]; /* status led selector (0..3) */
116 u8 llv; /* status led brightness no button (1..127) */
117 u8 hlv; /* status led brightness button pressed (1..127) */
118 u8 img_lum; /* OLED matrix display brightness */
119 } led;
120 bool led_initialized;
121 struct power_supply battery;
122 struct power_supply ac;
123};
124
125static inline void wacom_schedule_work(struct wacom_wac *wacom_wac)
126{
127 struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
128 schedule_work(&wacom->work);
129}
130
131static inline void wacom_notify_battery(struct wacom_wac *wacom_wac)
132{
133 struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
134
135 power_supply_changed(&wacom->battery);
136}
137
138extern const struct hid_device_id wacom_ids[];
139
140void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len);
141void wacom_setup_device_quirks(struct wacom_features *features);
142int wacom_setup_input_capabilities(struct input_dev *input_dev,
143 struct wacom_wac *wacom_wac);
144int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
145 struct wacom_wac *wacom_wac);
146#endif
diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c
new file mode 100644
index 000000000000..3e388ec31da8
--- /dev/null
+++ b/drivers/hid/wacom_sys.c
@@ -0,0 +1,1456 @@
1/*
2 * drivers/input/tablet/wacom_sys.c
3 *
4 * USB Wacom tablet support - system specific code
5 */
6
7/*
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 */
13
14#include "wacom_wac.h"
15#include "wacom.h"
16#include <linux/hid.h>
17
18#define WAC_MSG_RETRIES 5
19
20#define WAC_CMD_LED_CONTROL 0x20
21#define WAC_CMD_ICON_START 0x21
22#define WAC_CMD_ICON_XFER 0x23
23#define WAC_CMD_ICON_BT_XFER 0x26
24#define WAC_CMD_RETRIES 10
25
26static int wacom_get_report(struct hid_device *hdev, u8 type, u8 id,
27 void *buf, size_t size, unsigned int retries)
28{
29 int retval;
30
31 do {
32 retval = hid_hw_raw_request(hdev, id, buf, size, type,
33 HID_REQ_GET_REPORT);
34 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
35
36 return retval;
37}
38
39static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf,
40 size_t size, unsigned int retries)
41{
42 int retval;
43
44 do {
45 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
46 HID_REQ_SET_REPORT);
47 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
48
49 return retval;
50}
51
52static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
53 u8 *raw_data, int size)
54{
55 struct wacom *wacom = hid_get_drvdata(hdev);
56
57 if (size > WACOM_PKGLEN_MAX)
58 return 1;
59
60 memcpy(wacom->wacom_wac.data, raw_data, size);
61
62 wacom_wac_irq(&wacom->wacom_wac, size);
63
64 return 0;
65}
66
67static int wacom_open(struct input_dev *dev)
68{
69 struct wacom *wacom = input_get_drvdata(dev);
70 int retval;
71
72 mutex_lock(&wacom->lock);
73 retval = hid_hw_open(wacom->hdev);
74 mutex_unlock(&wacom->lock);
75
76 return retval;
77}
78
79static void wacom_close(struct input_dev *dev)
80{
81 struct wacom *wacom = input_get_drvdata(dev);
82
83 mutex_lock(&wacom->lock);
84 hid_hw_close(wacom->hdev);
85 mutex_unlock(&wacom->lock);
86}
87
88/*
89 * Calculate the resolution of the X or Y axis using hidinput_calc_abs_res.
90 */
91static int wacom_calc_hid_res(int logical_extents, int physical_extents,
92 unsigned unit, int exponent)
93{
94 struct hid_field field = {
95 .logical_maximum = logical_extents,
96 .physical_maximum = physical_extents,
97 .unit = unit,
98 .unit_exponent = exponent,
99 };
100
101 return hidinput_calc_abs_res(&field, ABS_X);
102}
103
104static void wacom_feature_mapping(struct hid_device *hdev,
105 struct hid_field *field, struct hid_usage *usage)
106{
107 struct wacom *wacom = hid_get_drvdata(hdev);
108 struct wacom_features *features = &wacom->wacom_wac.features;
109
110 switch (usage->hid) {
111 case HID_DG_CONTACTMAX:
112 /* leave touch_max as is if predefined */
113 if (!features->touch_max)
114 features->touch_max = field->value[0];
115 break;
116 }
117}
118
119/*
120 * Interface Descriptor of wacom devices can be incomplete and
121 * inconsistent so wacom_features table is used to store stylus
122 * device's packet lengths, various maximum values, and tablet
123 * resolution based on product ID's.
124 *
125 * For devices that contain 2 interfaces, wacom_features table is
126 * inaccurate for the touch interface. Since the Interface Descriptor
127 * for touch interfaces has pretty complete data, this function exists
128 * to query tablet for this missing information instead of hard coding in
129 * an additional table.
130 *
131 * A typical Interface Descriptor for a stylus will contain a
132 * boot mouse application collection that is not of interest and this
133 * function will ignore it.
134 *
135 * It also contains a digitizer application collection that also is not
136 * of interest since any information it contains would be duplicate
137 * of what is in wacom_features. Usually it defines a report of an array
138 * of bytes that could be used as max length of the stylus packet returned.
139 * If it happens to define a Digitizer-Stylus Physical Collection then
140 * the X and Y logical values contain valid data but it is ignored.
141 *
142 * A typical Interface Descriptor for a touch interface will contain a
143 * Digitizer-Finger Physical Collection which will define both logical
144 * X/Y maximum as well as the physical size of tablet. Since touch
145 * interfaces haven't supported pressure or distance, this is enough
146 * information to override invalid values in the wacom_features table.
147 *
148 * Intuos5 touch interface and 3rd gen Bamboo Touch do not contain useful
149 * data. We deal with them after returning from this function.
150 */
151static void wacom_usage_mapping(struct hid_device *hdev,
152 struct hid_field *field, struct hid_usage *usage)
153{
154 struct wacom *wacom = hid_get_drvdata(hdev);
155 struct wacom_features *features = &wacom->wacom_wac.features;
156 bool finger = (field->logical == HID_DG_FINGER) ||
157 (field->physical == HID_DG_FINGER);
158 bool pen = (field->logical == HID_DG_STYLUS) ||
159 (field->physical == HID_DG_STYLUS);
160
161 /*
162 * Requiring Stylus Usage will ignore boot mouse
163 * X/Y values and some cases of invalid Digitizer X/Y
164 * values commonly reported.
165 */
166 if (!pen && !finger)
167 return;
168
169 if (finger && !features->touch_max)
170 /* touch device at least supports one touch point */
171 features->touch_max = 1;
172
173 switch (usage->hid) {
174 case HID_GD_X:
175 features->x_max = field->logical_maximum;
176 if (finger) {
177 features->device_type = BTN_TOOL_FINGER;
178 features->x_phy = field->physical_maximum;
179 if (features->type != BAMBOO_PT) {
180 features->unit = field->unit;
181 features->unitExpo = field->unit_exponent;
182 }
183 } else {
184 features->device_type = BTN_TOOL_PEN;
185 }
186 break;
187 case HID_GD_Y:
188 features->y_max = field->logical_maximum;
189 if (finger) {
190 features->y_phy = field->physical_maximum;
191 if (features->type != BAMBOO_PT) {
192 features->unit = field->unit;
193 features->unitExpo = field->unit_exponent;
194 }
195 }
196 break;
197 case HID_DG_TIPPRESSURE:
198 if (pen)
199 features->pressure_max = field->logical_maximum;
200 break;
201 }
202}
203
204static void wacom_parse_hid(struct hid_device *hdev,
205 struct wacom_features *features)
206{
207 struct hid_report_enum *rep_enum;
208 struct hid_report *hreport;
209 int i, j;
210
211 /* check features first */
212 rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
213 list_for_each_entry(hreport, &rep_enum->report_list, list) {
214 for (i = 0; i < hreport->maxfield; i++) {
215 /* Ignore if report count is out of bounds. */
216 if (hreport->field[i]->report_count < 1)
217 continue;
218
219 for (j = 0; j < hreport->field[i]->maxusage; j++) {
220 wacom_feature_mapping(hdev, hreport->field[i],
221 hreport->field[i]->usage + j);
222 }
223 }
224 }
225
226 /* now check the input usages */
227 rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
228 list_for_each_entry(hreport, &rep_enum->report_list, list) {
229
230 if (!hreport->maxfield)
231 continue;
232
233 for (i = 0; i < hreport->maxfield; i++)
234 for (j = 0; j < hreport->field[i]->maxusage; j++)
235 wacom_usage_mapping(hdev, hreport->field[i],
236 hreport->field[i]->usage + j);
237 }
238}
239
240static int wacom_set_device_mode(struct hid_device *hdev, int report_id,
241 int length, int mode)
242{
243 unsigned char *rep_data;
244 int error = -ENOMEM, limit = 0;
245
246 rep_data = kzalloc(length, GFP_KERNEL);
247 if (!rep_data)
248 return error;
249
250 do {
251 rep_data[0] = report_id;
252 rep_data[1] = mode;
253
254 error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
255 length, 1);
256 if (error >= 0)
257 error = wacom_get_report(hdev, HID_FEATURE_REPORT,
258 report_id, rep_data, length, 1);
259 } while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);
260
261 kfree(rep_data);
262
263 return error < 0 ? error : 0;
264}
265
266static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
267 struct wacom_features *features)
268{
269 struct wacom *wacom = hid_get_drvdata(hdev);
270 int ret;
271 u8 rep_data[2];
272
273 switch (features->type) {
274 case GRAPHIRE_BT:
275 rep_data[0] = 0x03;
276 rep_data[1] = 0x00;
277 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
278 3);
279
280 if (ret >= 0) {
281 rep_data[0] = speed == 0 ? 0x05 : 0x06;
282 rep_data[1] = 0x00;
283
284 ret = wacom_set_report(hdev, HID_FEATURE_REPORT,
285 rep_data, 2, 3);
286
287 if (ret >= 0) {
288 wacom->wacom_wac.bt_high_speed = speed;
289 return 0;
290 }
291 }
292
293 /*
294 * Note that if the raw queries fail, it's not a hard failure
295 * and it is safe to continue
296 */
297 hid_warn(hdev, "failed to poke device, command %d, err %d\n",
298 rep_data[0], ret);
299 break;
300 case INTUOS4WL:
301 if (speed == 1)
302 wacom->wacom_wac.bt_features &= ~0x20;
303 else
304 wacom->wacom_wac.bt_features |= 0x20;
305
306 rep_data[0] = 0x03;
307 rep_data[1] = wacom->wacom_wac.bt_features;
308
309 ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
310 1);
311 if (ret >= 0)
312 wacom->wacom_wac.bt_high_speed = speed;
313 break;
314 }
315
316 return 0;
317}
318
319/*
320 * Switch the tablet into its most-capable mode. Wacom tablets are
321 * typically configured to power-up in a mode which sends mouse-like
322 * reports to the OS. To get absolute position, pressure data, etc.
323 * from the tablet, it is necessary to switch the tablet out of this
324 * mode and into one which sends the full range of tablet data.
325 */
326static int wacom_query_tablet_data(struct hid_device *hdev,
327 struct wacom_features *features)
328{
329 if (hdev->bus == BUS_BLUETOOTH)
330 return wacom_bt_query_tablet_data(hdev, 1, features);
331
332 if (features->device_type == BTN_TOOL_FINGER) {
333 if (features->type > TABLETPC) {
334 /* MT Tablet PC touch */
335 return wacom_set_device_mode(hdev, 3, 4, 4);
336 }
337 else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
338 return wacom_set_device_mode(hdev, 18, 3, 2);
339 }
340 } else if (features->device_type == BTN_TOOL_PEN) {
341 if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
342 return wacom_set_device_mode(hdev, 2, 2, 2);
343 }
344 }
345
346 return 0;
347}
348
349static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
350 struct wacom_features *features)
351{
352 struct wacom *wacom = hid_get_drvdata(hdev);
353 struct usb_interface *intf = wacom->intf;
354
355 /* default features */
356 features->device_type = BTN_TOOL_PEN;
357 features->x_fuzz = 4;
358 features->y_fuzz = 4;
359 features->pressure_fuzz = 0;
360 features->distance_fuzz = 0;
361
362 /*
363 * The wireless device HID is basic and layout conflicts with
364 * other tablets (monitor and touch interface can look like pen).
365 * Skip the query for this type and modify defaults based on
366 * interface number.
367 */
368 if (features->type == WIRELESS) {
369 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
370 features->device_type = 0;
371 } else if (intf->cur_altsetting->desc.bInterfaceNumber == 2) {
372 features->device_type = BTN_TOOL_FINGER;
373 features->pktlen = WACOM_PKGLEN_BBTOUCH3;
374 }
375 }
376
377 /* only devices that support touch need to retrieve the info */
378 if (features->type < BAMBOO_PT)
379 return;
380
381 wacom_parse_hid(hdev, features);
382}
383
384struct wacom_hdev_data {
385 struct list_head list;
386 struct kref kref;
387 struct hid_device *dev;
388 struct wacom_shared shared;
389};
390
391static LIST_HEAD(wacom_udev_list);
392static DEFINE_MUTEX(wacom_udev_list_lock);
393
394static bool wacom_are_sibling(struct hid_device *hdev,
395 struct hid_device *sibling)
396{
397 struct wacom *wacom = hid_get_drvdata(hdev);
398 struct wacom_features *features = &wacom->wacom_wac.features;
399 int vid = features->oVid;
400 int pid = features->oPid;
401 int n1,n2;
402
403 if (vid == 0 && pid == 0) {
404 vid = hdev->vendor;
405 pid = hdev->product;
406 }
407
408 if (vid != sibling->vendor || pid != sibling->product)
409 return false;
410
411 /* Compare the physical path. */
412 n1 = strrchr(hdev->phys, '.') - hdev->phys;
413 n2 = strrchr(sibling->phys, '.') - sibling->phys;
414 if (n1 != n2 || n1 <= 0 || n2 <= 0)
415 return false;
416
417 return !strncmp(hdev->phys, sibling->phys, n1);
418}
419
420static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
421{
422 struct wacom_hdev_data *data;
423
424 list_for_each_entry(data, &wacom_udev_list, list) {
425 if (wacom_are_sibling(hdev, data->dev)) {
426 kref_get(&data->kref);
427 return data;
428 }
429 }
430
431 return NULL;
432}
433
434static int wacom_add_shared_data(struct hid_device *hdev)
435{
436 struct wacom *wacom = hid_get_drvdata(hdev);
437 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
438 struct wacom_hdev_data *data;
439 int retval = 0;
440
441 mutex_lock(&wacom_udev_list_lock);
442
443 data = wacom_get_hdev_data(hdev);
444 if (!data) {
445 data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
446 if (!data) {
447 retval = -ENOMEM;
448 goto out;
449 }
450
451 kref_init(&data->kref);
452 data->dev = hdev;
453 list_add_tail(&data->list, &wacom_udev_list);
454 }
455
456 wacom_wac->shared = &data->shared;
457
458out:
459 mutex_unlock(&wacom_udev_list_lock);
460 return retval;
461}
462
463static void wacom_release_shared_data(struct kref *kref)
464{
465 struct wacom_hdev_data *data =
466 container_of(kref, struct wacom_hdev_data, kref);
467
468 mutex_lock(&wacom_udev_list_lock);
469 list_del(&data->list);
470 mutex_unlock(&wacom_udev_list_lock);
471
472 kfree(data);
473}
474
475static void wacom_remove_shared_data(struct wacom_wac *wacom)
476{
477 struct wacom_hdev_data *data;
478
479 if (wacom->shared) {
480 data = container_of(wacom->shared, struct wacom_hdev_data, shared);
481 kref_put(&data->kref, wacom_release_shared_data);
482 wacom->shared = NULL;
483 }
484}
485
486static int wacom_led_control(struct wacom *wacom)
487{
488 unsigned char *buf;
489 int retval;
490
491 buf = kzalloc(9, GFP_KERNEL);
492 if (!buf)
493 return -ENOMEM;
494
495 if (wacom->wacom_wac.features.type >= INTUOS5S &&
496 wacom->wacom_wac.features.type <= INTUOSPL) {
497 /*
498 * Touch Ring and crop mark LED luminance may take on
499 * one of four values:
500 * 0 = Low; 1 = Medium; 2 = High; 3 = Off
501 */
502 int ring_led = wacom->led.select[0] & 0x03;
503 int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03;
504 int crop_lum = 0;
505
506 buf[0] = WAC_CMD_LED_CONTROL;
507 buf[1] = (crop_lum << 4) | (ring_lum << 2) | (ring_led);
508 }
509 else {
510 int led = wacom->led.select[0] | 0x4;
511
512 if (wacom->wacom_wac.features.type == WACOM_21UX2 ||
513 wacom->wacom_wac.features.type == WACOM_24HD)
514 led |= (wacom->led.select[1] << 4) | 0x40;
515
516 buf[0] = WAC_CMD_LED_CONTROL;
517 buf[1] = led;
518 buf[2] = wacom->led.llv;
519 buf[3] = wacom->led.hlv;
520 buf[4] = wacom->led.img_lum;
521 }
522
523 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 9,
524 WAC_CMD_RETRIES);
525 kfree(buf);
526
527 return retval;
528}
529
530static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id,
531 const unsigned len, const void *img)
532{
533 unsigned char *buf;
534 int i, retval;
535 const unsigned chunk_len = len / 4; /* 4 chunks are needed to be sent */
536
537 buf = kzalloc(chunk_len + 3 , GFP_KERNEL);
538 if (!buf)
539 return -ENOMEM;
540
541 /* Send 'start' command */
542 buf[0] = WAC_CMD_ICON_START;
543 buf[1] = 1;
544 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
545 WAC_CMD_RETRIES);
546 if (retval < 0)
547 goto out;
548
549 buf[0] = xfer_id;
550 buf[1] = button_id & 0x07;
551 for (i = 0; i < 4; i++) {
552 buf[2] = i;
553 memcpy(buf + 3, img + i * chunk_len, chunk_len);
554
555 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
556 buf, chunk_len + 3, WAC_CMD_RETRIES);
557 if (retval < 0)
558 break;
559 }
560
561 /* Send 'stop' */
562 buf[0] = WAC_CMD_ICON_START;
563 buf[1] = 0;
564 wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
565 WAC_CMD_RETRIES);
566
567out:
568 kfree(buf);
569 return retval;
570}
571
572static ssize_t wacom_led_select_store(struct device *dev, int set_id,
573 const char *buf, size_t count)
574{
575 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
576 struct wacom *wacom = hid_get_drvdata(hdev);
577 unsigned int id;
578 int err;
579
580 err = kstrtouint(buf, 10, &id);
581 if (err)
582 return err;
583
584 mutex_lock(&wacom->lock);
585
586 wacom->led.select[set_id] = id & 0x3;
587 err = wacom_led_control(wacom);
588
589 mutex_unlock(&wacom->lock);
590
591 return err < 0 ? err : count;
592}
593
594#define DEVICE_LED_SELECT_ATTR(SET_ID) \
595static ssize_t wacom_led##SET_ID##_select_store(struct device *dev, \
596 struct device_attribute *attr, const char *buf, size_t count) \
597{ \
598 return wacom_led_select_store(dev, SET_ID, buf, count); \
599} \
600static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \
601 struct device_attribute *attr, char *buf) \
602{ \
603 struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
604 struct wacom *wacom = hid_get_drvdata(hdev); \
605 return snprintf(buf, 2, "%d\n", wacom->led.select[SET_ID]); \
606} \
607static DEVICE_ATTR(status_led##SET_ID##_select, S_IWUSR | S_IRUSR, \
608 wacom_led##SET_ID##_select_show, \
609 wacom_led##SET_ID##_select_store)
610
611DEVICE_LED_SELECT_ATTR(0);
612DEVICE_LED_SELECT_ATTR(1);
613
614static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest,
615 const char *buf, size_t count)
616{
617 unsigned int value;
618 int err;
619
620 err = kstrtouint(buf, 10, &value);
621 if (err)
622 return err;
623
624 mutex_lock(&wacom->lock);
625
626 *dest = value & 0x7f;
627 err = wacom_led_control(wacom);
628
629 mutex_unlock(&wacom->lock);
630
631 return err < 0 ? err : count;
632}
633
634#define DEVICE_LUMINANCE_ATTR(name, field) \
635static ssize_t wacom_##name##_luminance_store(struct device *dev, \
636 struct device_attribute *attr, const char *buf, size_t count) \
637{ \
638 struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
639 struct wacom *wacom = hid_get_drvdata(hdev); \
640 \
641 return wacom_luminance_store(wacom, &wacom->led.field, \
642 buf, count); \
643} \
644static DEVICE_ATTR(name##_luminance, S_IWUSR, \
645 NULL, wacom_##name##_luminance_store)
646
647DEVICE_LUMINANCE_ATTR(status0, llv);
648DEVICE_LUMINANCE_ATTR(status1, hlv);
649DEVICE_LUMINANCE_ATTR(buttons, img_lum);
650
651static ssize_t wacom_button_image_store(struct device *dev, int button_id,
652 const char *buf, size_t count)
653{
654 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
655 struct wacom *wacom = hid_get_drvdata(hdev);
656 int err;
657 unsigned len;
658 u8 xfer_id;
659
660 if (hdev->bus == BUS_BLUETOOTH) {
661 len = 256;
662 xfer_id = WAC_CMD_ICON_BT_XFER;
663 } else {
664 len = 1024;
665 xfer_id = WAC_CMD_ICON_XFER;
666 }
667
668 if (count != len)
669 return -EINVAL;
670
671 mutex_lock(&wacom->lock);
672
673 err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf);
674
675 mutex_unlock(&wacom->lock);
676
677 return err < 0 ? err : count;
678}
679
680#define DEVICE_BTNIMG_ATTR(BUTTON_ID) \
681static ssize_t wacom_btnimg##BUTTON_ID##_store(struct device *dev, \
682 struct device_attribute *attr, const char *buf, size_t count) \
683{ \
684 return wacom_button_image_store(dev, BUTTON_ID, buf, count); \
685} \
686static DEVICE_ATTR(button##BUTTON_ID##_rawimg, S_IWUSR, \
687 NULL, wacom_btnimg##BUTTON_ID##_store)
688
689DEVICE_BTNIMG_ATTR(0);
690DEVICE_BTNIMG_ATTR(1);
691DEVICE_BTNIMG_ATTR(2);
692DEVICE_BTNIMG_ATTR(3);
693DEVICE_BTNIMG_ATTR(4);
694DEVICE_BTNIMG_ATTR(5);
695DEVICE_BTNIMG_ATTR(6);
696DEVICE_BTNIMG_ATTR(7);
697
698static struct attribute *cintiq_led_attrs[] = {
699 &dev_attr_status_led0_select.attr,
700 &dev_attr_status_led1_select.attr,
701 NULL
702};
703
704static struct attribute_group cintiq_led_attr_group = {
705 .name = "wacom_led",
706 .attrs = cintiq_led_attrs,
707};
708
709static struct attribute *intuos4_led_attrs[] = {
710 &dev_attr_status0_luminance.attr,
711 &dev_attr_status1_luminance.attr,
712 &dev_attr_status_led0_select.attr,
713 &dev_attr_buttons_luminance.attr,
714 &dev_attr_button0_rawimg.attr,
715 &dev_attr_button1_rawimg.attr,
716 &dev_attr_button2_rawimg.attr,
717 &dev_attr_button3_rawimg.attr,
718 &dev_attr_button4_rawimg.attr,
719 &dev_attr_button5_rawimg.attr,
720 &dev_attr_button6_rawimg.attr,
721 &dev_attr_button7_rawimg.attr,
722 NULL
723};
724
725static struct attribute_group intuos4_led_attr_group = {
726 .name = "wacom_led",
727 .attrs = intuos4_led_attrs,
728};
729
730static struct attribute *intuos5_led_attrs[] = {
731 &dev_attr_status0_luminance.attr,
732 &dev_attr_status_led0_select.attr,
733 NULL
734};
735
736static struct attribute_group intuos5_led_attr_group = {
737 .name = "wacom_led",
738 .attrs = intuos5_led_attrs,
739};
740
741static int wacom_initialize_leds(struct wacom *wacom)
742{
743 int error;
744
745 /* Initialize default values */
746 switch (wacom->wacom_wac.features.type) {
747 case INTUOS4S:
748 case INTUOS4:
749 case INTUOS4WL:
750 case INTUOS4L:
751 wacom->led.select[0] = 0;
752 wacom->led.select[1] = 0;
753 wacom->led.llv = 10;
754 wacom->led.hlv = 20;
755 wacom->led.img_lum = 10;
756 error = sysfs_create_group(&wacom->hdev->dev.kobj,
757 &intuos4_led_attr_group);
758 break;
759
760 case WACOM_24HD:
761 case WACOM_21UX2:
762 wacom->led.select[0] = 0;
763 wacom->led.select[1] = 0;
764 wacom->led.llv = 0;
765 wacom->led.hlv = 0;
766 wacom->led.img_lum = 0;
767
768 error = sysfs_create_group(&wacom->hdev->dev.kobj,
769 &cintiq_led_attr_group);
770 break;
771
772 case INTUOS5S:
773 case INTUOS5:
774 case INTUOS5L:
775 case INTUOSPS:
776 case INTUOSPM:
777 case INTUOSPL:
778 if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN) {
779 wacom->led.select[0] = 0;
780 wacom->led.select[1] = 0;
781 wacom->led.llv = 32;
782 wacom->led.hlv = 0;
783 wacom->led.img_lum = 0;
784
785 error = sysfs_create_group(&wacom->hdev->dev.kobj,
786 &intuos5_led_attr_group);
787 } else
788 return 0;
789 break;
790
791 default:
792 return 0;
793 }
794
795 if (error) {
796 hid_err(wacom->hdev,
797 "cannot create sysfs group err: %d\n", error);
798 return error;
799 }
800 wacom_led_control(wacom);
801 wacom->led_initialized = true;
802
803 return 0;
804}
805
806static void wacom_destroy_leds(struct wacom *wacom)
807{
808 if (!wacom->led_initialized)
809 return;
810
811 wacom->led_initialized = false;
812
813 switch (wacom->wacom_wac.features.type) {
814 case INTUOS4S:
815 case INTUOS4:
816 case INTUOS4WL:
817 case INTUOS4L:
818 sysfs_remove_group(&wacom->hdev->dev.kobj,
819 &intuos4_led_attr_group);
820 break;
821
822 case WACOM_24HD:
823 case WACOM_21UX2:
824 sysfs_remove_group(&wacom->hdev->dev.kobj,
825 &cintiq_led_attr_group);
826 break;
827
828 case INTUOS5S:
829 case INTUOS5:
830 case INTUOS5L:
831 case INTUOSPS:
832 case INTUOSPM:
833 case INTUOSPL:
834 if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN)
835 sysfs_remove_group(&wacom->hdev->dev.kobj,
836 &intuos5_led_attr_group);
837 break;
838 }
839}
840
841static enum power_supply_property wacom_battery_props[] = {
842 POWER_SUPPLY_PROP_STATUS,
843 POWER_SUPPLY_PROP_SCOPE,
844 POWER_SUPPLY_PROP_CAPACITY
845};
846
847static enum power_supply_property wacom_ac_props[] = {
848 POWER_SUPPLY_PROP_PRESENT,
849 POWER_SUPPLY_PROP_ONLINE,
850 POWER_SUPPLY_PROP_SCOPE,
851};
852
853static int wacom_battery_get_property(struct power_supply *psy,
854 enum power_supply_property psp,
855 union power_supply_propval *val)
856{
857 struct wacom *wacom = container_of(psy, struct wacom, battery);
858 int ret = 0;
859
860 switch (psp) {
861 case POWER_SUPPLY_PROP_SCOPE:
862 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
863 break;
864 case POWER_SUPPLY_PROP_CAPACITY:
865 val->intval =
866 wacom->wacom_wac.battery_capacity;
867 break;
868 case POWER_SUPPLY_PROP_STATUS:
869 if (wacom->wacom_wac.bat_charging)
870 val->intval = POWER_SUPPLY_STATUS_CHARGING;
871 else if (wacom->wacom_wac.battery_capacity == 100 &&
872 wacom->wacom_wac.ps_connected)
873 val->intval = POWER_SUPPLY_STATUS_FULL;
874 else
875 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
876 break;
877 default:
878 ret = -EINVAL;
879 break;
880 }
881
882 return ret;
883}
884
885static int wacom_ac_get_property(struct power_supply *psy,
886 enum power_supply_property psp,
887 union power_supply_propval *val)
888{
889 struct wacom *wacom = container_of(psy, struct wacom, ac);
890 int ret = 0;
891
892 switch (psp) {
893 case POWER_SUPPLY_PROP_PRESENT:
894 /* fall through */
895 case POWER_SUPPLY_PROP_ONLINE:
896 val->intval = wacom->wacom_wac.ps_connected;
897 break;
898 case POWER_SUPPLY_PROP_SCOPE:
899 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
900 break;
901 default:
902 ret = -EINVAL;
903 break;
904 }
905 return ret;
906}
907
908static int wacom_initialize_battery(struct wacom *wacom)
909{
910 static atomic_t battery_no = ATOMIC_INIT(0);
911 int error;
912 unsigned long n;
913
914 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) {
915 n = atomic_inc_return(&battery_no) - 1;
916
917 wacom->battery.properties = wacom_battery_props;
918 wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
919 wacom->battery.get_property = wacom_battery_get_property;
920 sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
921 wacom->battery.name = wacom->wacom_wac.bat_name;
922 wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
923 wacom->battery.use_for_apm = 0;
924
925 wacom->ac.properties = wacom_ac_props;
926 wacom->ac.num_properties = ARRAY_SIZE(wacom_ac_props);
927 wacom->ac.get_property = wacom_ac_get_property;
928 sprintf(wacom->wacom_wac.ac_name, "wacom_ac_%ld", n);
929 wacom->ac.name = wacom->wacom_wac.ac_name;
930 wacom->ac.type = POWER_SUPPLY_TYPE_MAINS;
931 wacom->ac.use_for_apm = 0;
932
933 error = power_supply_register(&wacom->hdev->dev,
934 &wacom->battery);
935 if (error)
936 return error;
937
938 power_supply_powers(&wacom->battery, &wacom->hdev->dev);
939
940 error = power_supply_register(&wacom->hdev->dev, &wacom->ac);
941 if (error) {
942 power_supply_unregister(&wacom->battery);
943 return error;
944 }
945
946 power_supply_powers(&wacom->ac, &wacom->hdev->dev);
947 }
948
949 return 0;
950}
951
952static void wacom_destroy_battery(struct wacom *wacom)
953{
954 if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
955 wacom->battery.dev) {
956 power_supply_unregister(&wacom->battery);
957 wacom->battery.dev = NULL;
958 power_supply_unregister(&wacom->ac);
959 wacom->ac.dev = NULL;
960 }
961}
962
963static ssize_t wacom_show_speed(struct device *dev,
964 struct device_attribute
965 *attr, char *buf)
966{
967 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
968 struct wacom *wacom = hid_get_drvdata(hdev);
969
970 return snprintf(buf, PAGE_SIZE, "%i\n", wacom->wacom_wac.bt_high_speed);
971}
972
973static ssize_t wacom_store_speed(struct device *dev,
974 struct device_attribute *attr,
975 const char *buf, size_t count)
976{
977 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
978 struct wacom *wacom = hid_get_drvdata(hdev);
979 u8 new_speed;
980
981 if (kstrtou8(buf, 0, &new_speed))
982 return -EINVAL;
983
984 if (new_speed != 0 && new_speed != 1)
985 return -EINVAL;
986
987 wacom_bt_query_tablet_data(hdev, new_speed, &wacom->wacom_wac.features);
988
989 return count;
990}
991
992static DEVICE_ATTR(speed, S_IRUGO | S_IWUSR | S_IWGRP,
993 wacom_show_speed, wacom_store_speed);
994
995static struct input_dev *wacom_allocate_input(struct wacom *wacom)
996{
997 struct input_dev *input_dev;
998 struct hid_device *hdev = wacom->hdev;
999 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1000
1001 input_dev = input_allocate_device();
1002 if (!input_dev)
1003 return NULL;
1004
1005 input_dev->name = wacom_wac->name;
1006 input_dev->phys = hdev->phys;
1007 input_dev->dev.parent = &hdev->dev;
1008 input_dev->open = wacom_open;
1009 input_dev->close = wacom_close;
1010 input_dev->uniq = hdev->uniq;
1011 input_dev->id.bustype = hdev->bus;
1012 input_dev->id.vendor = hdev->vendor;
1013 input_dev->id.product = hdev->product;
1014 input_dev->id.version = hdev->version;
1015 input_set_drvdata(input_dev, wacom);
1016
1017 return input_dev;
1018}
1019
1020static void wacom_unregister_inputs(struct wacom *wacom)
1021{
1022 if (wacom->wacom_wac.input)
1023 input_unregister_device(wacom->wacom_wac.input);
1024 if (wacom->wacom_wac.pad_input)
1025 input_unregister_device(wacom->wacom_wac.pad_input);
1026 wacom->wacom_wac.input = NULL;
1027 wacom->wacom_wac.pad_input = NULL;
1028}
1029
1030static int wacom_register_inputs(struct wacom *wacom)
1031{
1032 struct input_dev *input_dev, *pad_input_dev;
1033 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1034 int error;
1035
1036 input_dev = wacom_allocate_input(wacom);
1037 pad_input_dev = wacom_allocate_input(wacom);
1038 if (!input_dev || !pad_input_dev) {
1039 error = -ENOMEM;
1040 goto fail1;
1041 }
1042
1043 wacom_wac->input = input_dev;
1044 wacom_wac->pad_input = pad_input_dev;
1045 wacom_wac->pad_input->name = wacom_wac->pad_name;
1046
1047 error = wacom_setup_input_capabilities(input_dev, wacom_wac);
1048 if (error)
1049 goto fail2;
1050
1051 error = input_register_device(input_dev);
1052 if (error)
1053 goto fail2;
1054
1055 error = wacom_setup_pad_input_capabilities(pad_input_dev, wacom_wac);
1056 if (error) {
1057 /* no pad in use on this interface */
1058 input_free_device(pad_input_dev);
1059 wacom_wac->pad_input = NULL;
1060 pad_input_dev = NULL;
1061 } else {
1062 error = input_register_device(pad_input_dev);
1063 if (error)
1064 goto fail3;
1065 }
1066
1067 return 0;
1068
1069fail3:
1070 input_unregister_device(input_dev);
1071 input_dev = NULL;
1072fail2:
1073 wacom_wac->input = NULL;
1074 wacom_wac->pad_input = NULL;
1075fail1:
1076 if (input_dev)
1077 input_free_device(input_dev);
1078 if (pad_input_dev)
1079 input_free_device(pad_input_dev);
1080 return error;
1081}
1082
1083static void wacom_wireless_work(struct work_struct *work)
1084{
1085 struct wacom *wacom = container_of(work, struct wacom, work);
1086 struct usb_device *usbdev = wacom->usbdev;
1087 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1088 struct hid_device *hdev1, *hdev2;
1089 struct wacom *wacom1, *wacom2;
1090 struct wacom_wac *wacom_wac1, *wacom_wac2;
1091 int error;
1092
1093 /*
1094 * Regardless if this is a disconnect or a new tablet,
1095 * remove any existing input and battery devices.
1096 */
1097
1098 wacom_destroy_battery(wacom);
1099
1100 /* Stylus interface */
1101 hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
1102 wacom1 = hid_get_drvdata(hdev1);
1103 wacom_wac1 = &(wacom1->wacom_wac);
1104 wacom_unregister_inputs(wacom1);
1105
1106 /* Touch interface */
1107 hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
1108 wacom2 = hid_get_drvdata(hdev2);
1109 wacom_wac2 = &(wacom2->wacom_wac);
1110 wacom_unregister_inputs(wacom2);
1111
1112 if (wacom_wac->pid == 0) {
1113 hid_info(wacom->hdev, "wireless tablet disconnected\n");
1114 wacom_wac1->shared->type = 0;
1115 } else {
1116 const struct hid_device_id *id = wacom_ids;
1117
1118 hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
1119 wacom_wac->pid);
1120
1121 while (id->bus) {
1122 if (id->vendor == USB_VENDOR_ID_WACOM &&
1123 id->product == wacom_wac->pid)
1124 break;
1125 id++;
1126 }
1127
1128 if (!id->bus) {
1129 hid_info(wacom->hdev, "ignoring unknown PID.\n");
1130 return;
1131 }
1132
1133 /* Stylus interface */
1134 wacom_wac1->features =
1135 *((struct wacom_features *)id->driver_data);
1136 wacom_wac1->features.device_type = BTN_TOOL_PEN;
1137 snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen",
1138 wacom_wac1->features.name);
1139 snprintf(wacom_wac1->pad_name, WACOM_NAME_MAX, "%s (WL) Pad",
1140 wacom_wac1->features.name);
1141 wacom_wac1->shared->touch_max = wacom_wac1->features.touch_max;
1142 wacom_wac1->shared->type = wacom_wac1->features.type;
1143 error = wacom_register_inputs(wacom1);
1144 if (error)
1145 goto fail;
1146
1147 /* Touch interface */
1148 if (wacom_wac1->features.touch_max ||
1149 wacom_wac1->features.type == INTUOSHT) {
1150 wacom_wac2->features =
1151 *((struct wacom_features *)id->driver_data);
1152 wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3;
1153 wacom_wac2->features.device_type = BTN_TOOL_FINGER;
1154 wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096;
1155 if (wacom_wac2->features.touch_max)
1156 snprintf(wacom_wac2->name, WACOM_NAME_MAX,
1157 "%s (WL) Finger",wacom_wac2->features.name);
1158 else
1159 snprintf(wacom_wac2->name, WACOM_NAME_MAX,
1160 "%s (WL) Pad",wacom_wac2->features.name);
1161 snprintf(wacom_wac2->pad_name, WACOM_NAME_MAX,
1162 "%s (WL) Pad", wacom_wac2->features.name);
1163 error = wacom_register_inputs(wacom2);
1164 if (error)
1165 goto fail;
1166
1167 if (wacom_wac1->features.type == INTUOSHT &&
1168 wacom_wac1->features.touch_max)
1169 wacom_wac->shared->touch_input = wacom_wac2->input;
1170 }
1171
1172 error = wacom_initialize_battery(wacom);
1173 if (error)
1174 goto fail;
1175 }
1176
1177 return;
1178
1179fail:
1180 wacom_unregister_inputs(wacom1);
1181 wacom_unregister_inputs(wacom2);
1182 return;
1183}
1184
1185/*
1186 * Not all devices report physical dimensions from HID.
1187 * Compute the default from hardcoded logical dimension
1188 * and resolution before driver overwrites them.
1189 */
1190static void wacom_set_default_phy(struct wacom_features *features)
1191{
1192 if (features->x_resolution) {
1193 features->x_phy = (features->x_max * 100) /
1194 features->x_resolution;
1195 features->y_phy = (features->y_max * 100) /
1196 features->y_resolution;
1197 }
1198}
1199
1200static void wacom_calculate_res(struct wacom_features *features)
1201{
1202 features->x_resolution = wacom_calc_hid_res(features->x_max,
1203 features->x_phy,
1204 features->unit,
1205 features->unitExpo);
1206 features->y_resolution = wacom_calc_hid_res(features->y_max,
1207 features->y_phy,
1208 features->unit,
1209 features->unitExpo);
1210}
1211
1212static int wacom_hid_report_len(struct hid_report *report)
1213{
1214 /* equivalent to DIV_ROUND_UP(report->size, 8) + !!(report->id > 0) */
1215 return ((report->size - 1) >> 3) + 1 + (report->id > 0);
1216}
1217
1218static size_t wacom_compute_pktlen(struct hid_device *hdev)
1219{
1220 struct hid_report_enum *report_enum;
1221 struct hid_report *report;
1222 size_t size = 0;
1223
1224 report_enum = hdev->report_enum + HID_INPUT_REPORT;
1225
1226 list_for_each_entry(report, &report_enum->report_list, list) {
1227 size_t report_size = wacom_hid_report_len(report);
1228 if (report_size > size)
1229 size = report_size;
1230 }
1231
1232 return size;
1233}
1234
1235static int wacom_probe(struct hid_device *hdev,
1236 const struct hid_device_id *id)
1237{
1238 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
1239 struct usb_device *dev = interface_to_usbdev(intf);
1240 struct wacom *wacom;
1241 struct wacom_wac *wacom_wac;
1242 struct wacom_features *features;
1243 int error;
1244
1245 if (!id->driver_data)
1246 return -EINVAL;
1247
1248 wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
1249 if (!wacom)
1250 return -ENOMEM;
1251
1252 hid_set_drvdata(hdev, wacom);
1253 wacom->hdev = hdev;
1254
1255 /* ask for the report descriptor to be loaded by HID */
1256 error = hid_parse(hdev);
1257 if (error) {
1258 hid_err(hdev, "parse failed\n");
1259 goto fail1;
1260 }
1261
1262 wacom_wac = &wacom->wacom_wac;
1263 wacom_wac->features = *((struct wacom_features *)id->driver_data);
1264 features = &wacom_wac->features;
1265 features->pktlen = wacom_compute_pktlen(hdev);
1266 if (features->pktlen > WACOM_PKGLEN_MAX) {
1267 error = -EINVAL;
1268 goto fail1;
1269 }
1270
1271 if (features->check_for_hid_type && features->hid_type != hdev->type) {
1272 error = -ENODEV;
1273 goto fail1;
1274 }
1275
1276 wacom->usbdev = dev;
1277 wacom->intf = intf;
1278 mutex_init(&wacom->lock);
1279 INIT_WORK(&wacom->work, wacom_wireless_work);
1280
1281 /* set the default size in case we do not get them from hid */
1282 wacom_set_default_phy(features);
1283
1284 /* Retrieve the physical and logical size for touch devices */
1285 wacom_retrieve_hid_descriptor(hdev, features);
1286
1287 /*
1288 * Intuos5 has no useful data about its touch interface in its
1289 * HID descriptor. If this is the touch interface (PacketSize
1290 * of WACOM_PKGLEN_BBTOUCH3), override the table values.
1291 */
1292 if (features->type >= INTUOS5S && features->type <= INTUOSHT) {
1293 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1294 features->device_type = BTN_TOOL_FINGER;
1295
1296 features->x_max = 4096;
1297 features->y_max = 4096;
1298 } else {
1299 features->device_type = BTN_TOOL_PEN;
1300 }
1301 }
1302
1303 /*
1304 * Same thing for Bamboo 3rd gen.
1305 */
1306 if ((features->type == BAMBOO_PT) &&
1307 (features->pktlen == WACOM_PKGLEN_BBTOUCH3) &&
1308 (features->device_type == BTN_TOOL_PEN)) {
1309 features->device_type = BTN_TOOL_FINGER;
1310
1311 features->x_max = 4096;
1312 features->y_max = 4096;
1313 }
1314
1315 if (hdev->bus == BUS_BLUETOOTH)
1316 features->quirks |= WACOM_QUIRK_BATTERY;
1317
1318 wacom_setup_device_quirks(features);
1319
1320 /* set unit to "100th of a mm" for devices not reported by HID */
1321 if (!features->unit) {
1322 features->unit = 0x11;
1323 features->unitExpo = -3;
1324 }
1325 wacom_calculate_res(features);
1326
1327 strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
1328 snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name),
1329 "%s Pad", features->name);
1330
1331 if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
1332 /* Append the device type to the name */
1333 if (features->device_type != BTN_TOOL_FINGER)
1334 strlcat(wacom_wac->name, " Pen", WACOM_NAME_MAX);
1335 else if (features->touch_max)
1336 strlcat(wacom_wac->name, " Finger", WACOM_NAME_MAX);
1337 else
1338 strlcat(wacom_wac->name, " Pad", WACOM_NAME_MAX);
1339
1340 error = wacom_add_shared_data(hdev);
1341 if (error)
1342 goto fail1;
1343 }
1344
1345 error = wacom_initialize_leds(wacom);
1346 if (error)
1347 goto fail2;
1348
1349 if (!(features->quirks & WACOM_QUIRK_MONITOR) &&
1350 (features->quirks & WACOM_QUIRK_BATTERY)) {
1351 error = wacom_initialize_battery(wacom);
1352 if (error)
1353 goto fail3;
1354 }
1355
1356 if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
1357 error = wacom_register_inputs(wacom);
1358 if (error)
1359 goto fail4;
1360 }
1361
1362 if (hdev->bus == BUS_BLUETOOTH) {
1363 error = device_create_file(&hdev->dev, &dev_attr_speed);
1364 if (error)
1365 hid_warn(hdev,
1366 "can't create sysfs speed attribute err: %d\n",
1367 error);
1368 }
1369
1370 /* Note that if query fails it is not a hard failure */
1371 wacom_query_tablet_data(hdev, features);
1372
1373 /* Regular HID work starts now */
1374 error = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1375 if (error) {
1376 hid_err(hdev, "hw start failed\n");
1377 goto fail5;
1378 }
1379
1380 if (features->quirks & WACOM_QUIRK_MONITOR)
1381 error = hid_hw_open(hdev);
1382
1383 if (wacom_wac->features.type == INTUOSHT && wacom_wac->features.touch_max) {
1384 if (wacom_wac->features.device_type == BTN_TOOL_FINGER)
1385 wacom_wac->shared->touch_input = wacom_wac->input;
1386 }
1387
1388 return 0;
1389
1390 fail5: if (hdev->bus == BUS_BLUETOOTH)
1391 device_remove_file(&hdev->dev, &dev_attr_speed);
1392 wacom_unregister_inputs(wacom);
1393 fail4: wacom_destroy_battery(wacom);
1394 fail3: wacom_destroy_leds(wacom);
1395 fail2: wacom_remove_shared_data(wacom_wac);
1396 fail1: kfree(wacom);
1397 hid_set_drvdata(hdev, NULL);
1398 return error;
1399}
1400
1401static void wacom_remove(struct hid_device *hdev)
1402{
1403 struct wacom *wacom = hid_get_drvdata(hdev);
1404
1405 hid_hw_stop(hdev);
1406
1407 cancel_work_sync(&wacom->work);
1408 wacom_unregister_inputs(wacom);
1409 if (hdev->bus == BUS_BLUETOOTH)
1410 device_remove_file(&hdev->dev, &dev_attr_speed);
1411 wacom_destroy_battery(wacom);
1412 wacom_destroy_leds(wacom);
1413 wacom_remove_shared_data(&wacom->wacom_wac);
1414
1415 hid_set_drvdata(hdev, NULL);
1416 kfree(wacom);
1417}
1418
1419static int wacom_resume(struct hid_device *hdev)
1420{
1421 struct wacom *wacom = hid_get_drvdata(hdev);
1422 struct wacom_features *features = &wacom->wacom_wac.features;
1423
1424 mutex_lock(&wacom->lock);
1425
1426 /* switch to wacom mode first */
1427 wacom_query_tablet_data(hdev, features);
1428 wacom_led_control(wacom);
1429
1430 mutex_unlock(&wacom->lock);
1431
1432 return 0;
1433}
1434
1435static int wacom_reset_resume(struct hid_device *hdev)
1436{
1437 return wacom_resume(hdev);
1438}
1439
1440static struct hid_driver wacom_driver = {
1441 .name = "wacom",
1442 .id_table = wacom_ids,
1443 .probe = wacom_probe,
1444 .remove = wacom_remove,
1445#ifdef CONFIG_PM
1446 .resume = wacom_resume,
1447 .reset_resume = wacom_reset_resume,
1448#endif
1449 .raw_event = wacom_raw_event,
1450};
1451module_hid_driver(wacom_driver);
1452
1453MODULE_VERSION(DRIVER_VERSION);
1454MODULE_AUTHOR(DRIVER_AUTHOR);
1455MODULE_DESCRIPTION(DRIVER_DESC);
1456MODULE_LICENSE(DRIVER_LICENSE);
diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c
new file mode 100644
index 000000000000..aa6a08eb7ad6
--- /dev/null
+++ b/drivers/hid/wacom_wac.c
@@ -0,0 +1,2721 @@
1/*
2 * drivers/input/tablet/wacom_wac.c
3 *
4 * USB Wacom tablet support - Wacom specific code
5 *
6 */
7
8/*
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 */
14
15#include "wacom_wac.h"
16#include "wacom.h"
17#include <linux/input/mt.h>
18#include <linux/hid.h>
19
20/* resolution for penabled devices */
21#define WACOM_PL_RES 20
22#define WACOM_PENPRTN_RES 40
23#define WACOM_VOLITO_RES 50
24#define WACOM_GRAPHIRE_RES 80
25#define WACOM_INTUOS_RES 100
26#define WACOM_INTUOS3_RES 200
27
28/*
29 * Scale factor relating reported contact size to logical contact area.
30 * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
31 */
32#define WACOM_CONTACT_AREA_SCALE 2607
33
34/*
35 * Percent of battery capacity for Graphire.
36 * 8th value means AC online and show 100% capacity.
37 */
38static unsigned short batcap_gr[8] = { 1, 15, 25, 35, 50, 70, 100, 100 };
39
40/*
41 * Percent of battery capacity for Intuos4 WL, AC has a separate bit.
42 */
43static unsigned short batcap_i4[8] = { 1, 15, 30, 45, 60, 70, 85, 100 };
44
45static int wacom_penpartner_irq(struct wacom_wac *wacom)
46{
47 unsigned char *data = wacom->data;
48 struct input_dev *input = wacom->input;
49
50 switch (data[0]) {
51 case 1:
52 if (data[5] & 0x80) {
53 wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
54 wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
55 input_report_key(input, wacom->tool[0], 1);
56 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
57 input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
58 input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
59 input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
60 input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
61 input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
62 } else {
63 input_report_key(input, wacom->tool[0], 0);
64 input_report_abs(input, ABS_MISC, 0); /* report tool id */
65 input_report_abs(input, ABS_PRESSURE, -1);
66 input_report_key(input, BTN_TOUCH, 0);
67 }
68 break;
69
70 case 2:
71 input_report_key(input, BTN_TOOL_PEN, 1);
72 input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
73 input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
74 input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
75 input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
76 input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
77 input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
78 break;
79
80 default:
81 dev_dbg(input->dev.parent,
82 "%s: received unknown report #%d\n", __func__, data[0]);
83 return 0;
84 }
85
86 return 1;
87}
88
89static int wacom_pl_irq(struct wacom_wac *wacom)
90{
91 struct wacom_features *features = &wacom->features;
92 unsigned char *data = wacom->data;
93 struct input_dev *input = wacom->input;
94 int prox, pressure;
95
96 if (data[0] != WACOM_REPORT_PENABLED) {
97 dev_dbg(input->dev.parent,
98 "%s: received unknown report #%d\n", __func__, data[0]);
99 return 0;
100 }
101
102 prox = data[1] & 0x40;
103
104 if (prox) {
105 wacom->id[0] = ERASER_DEVICE_ID;
106 pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
107 if (features->pressure_max > 255)
108 pressure = (pressure << 1) | ((data[4] >> 6) & 1);
109 pressure += (features->pressure_max + 1) / 2;
110
111 /*
112 * if going from out of proximity into proximity select between the eraser
113 * and the pen based on the state of the stylus2 button, choose eraser if
114 * pressed else choose pen. if not a proximity change from out to in, send
115 * an out of proximity for previous tool then a in for new tool.
116 */
117 if (!wacom->tool[0]) {
118 /* Eraser bit set for DTF */
119 if (data[1] & 0x10)
120 wacom->tool[1] = BTN_TOOL_RUBBER;
121 else
122 /* Going into proximity select tool */
123 wacom->tool[1] = (data[4] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
124 } else {
125 /* was entered with stylus2 pressed */
126 if (wacom->tool[1] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
127 /* report out proximity for previous tool */
128 input_report_key(input, wacom->tool[1], 0);
129 input_sync(input);
130 wacom->tool[1] = BTN_TOOL_PEN;
131 return 0;
132 }
133 }
134 if (wacom->tool[1] != BTN_TOOL_RUBBER) {
135 /* Unknown tool selected default to pen tool */
136 wacom->tool[1] = BTN_TOOL_PEN;
137 wacom->id[0] = STYLUS_DEVICE_ID;
138 }
139 input_report_key(input, wacom->tool[1], prox); /* report in proximity for tool */
140 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
141 input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
142 input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
143 input_report_abs(input, ABS_PRESSURE, pressure);
144
145 input_report_key(input, BTN_TOUCH, data[4] & 0x08);
146 input_report_key(input, BTN_STYLUS, data[4] & 0x10);
147 /* Only allow the stylus2 button to be reported for the pen tool. */
148 input_report_key(input, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
149 } else {
150 /* report proximity-out of a (valid) tool */
151 if (wacom->tool[1] != BTN_TOOL_RUBBER) {
152 /* Unknown tool selected default to pen tool */
153 wacom->tool[1] = BTN_TOOL_PEN;
154 }
155 input_report_key(input, wacom->tool[1], prox);
156 }
157
158 wacom->tool[0] = prox; /* Save proximity state */
159 return 1;
160}
161
162static int wacom_ptu_irq(struct wacom_wac *wacom)
163{
164 unsigned char *data = wacom->data;
165 struct input_dev *input = wacom->input;
166
167 if (data[0] != WACOM_REPORT_PENABLED) {
168 dev_dbg(input->dev.parent,
169 "%s: received unknown report #%d\n", __func__, data[0]);
170 return 0;
171 }
172
173 if (data[1] & 0x04) {
174 input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
175 input_report_key(input, BTN_TOUCH, data[1] & 0x08);
176 wacom->id[0] = ERASER_DEVICE_ID;
177 } else {
178 input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
179 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
180 wacom->id[0] = STYLUS_DEVICE_ID;
181 }
182 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
183 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
184 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
185 input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
186 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
187 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
188 return 1;
189}
190
191static int wacom_dtu_irq(struct wacom_wac *wacom)
192{
193 unsigned char *data = wacom->data;
194 struct input_dev *input = wacom->input;
195 int prox = data[1] & 0x20;
196
197 dev_dbg(input->dev.parent,
198 "%s: received report #%d", __func__, data[0]);
199
200 if (prox) {
201 /* Going into proximity select tool */
202 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
203 if (wacom->tool[0] == BTN_TOOL_PEN)
204 wacom->id[0] = STYLUS_DEVICE_ID;
205 else
206 wacom->id[0] = ERASER_DEVICE_ID;
207 }
208 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
209 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
210 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
211 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
212 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x01) << 8) | data[6]);
213 input_report_key(input, BTN_TOUCH, data[1] & 0x05);
214 if (!prox) /* out-prox */
215 wacom->id[0] = 0;
216 input_report_key(input, wacom->tool[0], prox);
217 input_report_abs(input, ABS_MISC, wacom->id[0]);
218 return 1;
219}
220
221static int wacom_dtus_irq(struct wacom_wac *wacom)
222{
223 char *data = wacom->data;
224 struct input_dev *input = wacom->input;
225 unsigned short prox, pressure = 0;
226
227 if (data[0] != WACOM_REPORT_DTUS && data[0] != WACOM_REPORT_DTUSPAD) {
228 dev_dbg(input->dev.parent,
229 "%s: received unknown report #%d", __func__, data[0]);
230 return 0;
231 } else if (data[0] == WACOM_REPORT_DTUSPAD) {
232 input = wacom->pad_input;
233 input_report_key(input, BTN_0, (data[1] & 0x01));
234 input_report_key(input, BTN_1, (data[1] & 0x02));
235 input_report_key(input, BTN_2, (data[1] & 0x04));
236 input_report_key(input, BTN_3, (data[1] & 0x08));
237 input_report_abs(input, ABS_MISC,
238 data[1] & 0x0f ? PAD_DEVICE_ID : 0);
239 return 1;
240 } else {
241 prox = data[1] & 0x80;
242 if (prox) {
243 switch ((data[1] >> 3) & 3) {
244 case 1: /* Rubber */
245 wacom->tool[0] = BTN_TOOL_RUBBER;
246 wacom->id[0] = ERASER_DEVICE_ID;
247 break;
248
249 case 2: /* Pen */
250 wacom->tool[0] = BTN_TOOL_PEN;
251 wacom->id[0] = STYLUS_DEVICE_ID;
252 break;
253 }
254 }
255
256 input_report_key(input, BTN_STYLUS, data[1] & 0x20);
257 input_report_key(input, BTN_STYLUS2, data[1] & 0x40);
258 input_report_abs(input, ABS_X, get_unaligned_be16(&data[3]));
259 input_report_abs(input, ABS_Y, get_unaligned_be16(&data[5]));
260 pressure = ((data[1] & 0x03) << 8) | (data[2] & 0xff);
261 input_report_abs(input, ABS_PRESSURE, pressure);
262 input_report_key(input, BTN_TOUCH, pressure > 10);
263
264 if (!prox) /* out-prox */
265 wacom->id[0] = 0;
266 input_report_key(input, wacom->tool[0], prox);
267 input_report_abs(input, ABS_MISC, wacom->id[0]);
268 return 1;
269 }
270}
271
272static int wacom_graphire_irq(struct wacom_wac *wacom)
273{
274 struct wacom_features *features = &wacom->features;
275 unsigned char *data = wacom->data;
276 struct input_dev *input = wacom->input;
277 struct input_dev *pad_input = wacom->pad_input;
278 int battery_capacity, ps_connected;
279 int prox;
280 int rw = 0;
281 int retval = 0;
282
283 if (features->type == GRAPHIRE_BT) {
284 if (data[0] != WACOM_REPORT_PENABLED_BT) {
285 dev_dbg(input->dev.parent,
286 "%s: received unknown report #%d\n", __func__,
287 data[0]);
288 goto exit;
289 }
290 } else if (data[0] != WACOM_REPORT_PENABLED) {
291 dev_dbg(input->dev.parent,
292 "%s: received unknown report #%d\n", __func__, data[0]);
293 goto exit;
294 }
295
296 prox = data[1] & 0x80;
297 if (prox || wacom->id[0]) {
298 if (prox) {
299 switch ((data[1] >> 5) & 3) {
300
301 case 0: /* Pen */
302 wacom->tool[0] = BTN_TOOL_PEN;
303 wacom->id[0] = STYLUS_DEVICE_ID;
304 break;
305
306 case 1: /* Rubber */
307 wacom->tool[0] = BTN_TOOL_RUBBER;
308 wacom->id[0] = ERASER_DEVICE_ID;
309 break;
310
311 case 2: /* Mouse with wheel */
312 input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
313 /* fall through */
314
315 case 3: /* Mouse without wheel */
316 wacom->tool[0] = BTN_TOOL_MOUSE;
317 wacom->id[0] = CURSOR_DEVICE_ID;
318 break;
319 }
320 }
321 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
322 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
323 if (wacom->tool[0] != BTN_TOOL_MOUSE) {
324 if (features->type == GRAPHIRE_BT)
325 input_report_abs(input, ABS_PRESSURE, data[6] |
326 (((__u16) (data[1] & 0x08)) << 5));
327 else
328 input_report_abs(input, ABS_PRESSURE, data[6] |
329 ((data[7] & 0x03) << 8));
330 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
331 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
332 input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
333 } else {
334 input_report_key(input, BTN_LEFT, data[1] & 0x01);
335 input_report_key(input, BTN_RIGHT, data[1] & 0x02);
336 if (features->type == WACOM_G4 ||
337 features->type == WACOM_MO) {
338 input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
339 rw = (data[7] & 0x04) - (data[7] & 0x03);
340 } else if (features->type == GRAPHIRE_BT) {
341 /* Compute distance between mouse and tablet */
342 rw = 44 - (data[6] >> 2);
343 rw = clamp_val(rw, 0, 31);
344 input_report_abs(input, ABS_DISTANCE, rw);
345 if (((data[1] >> 5) & 3) == 2) {
346 /* Mouse with wheel */
347 input_report_key(input, BTN_MIDDLE,
348 data[1] & 0x04);
349 rw = (data[6] & 0x01) ? -1 :
350 (data[6] & 0x02) ? 1 : 0;
351 } else {
352 rw = 0;
353 }
354 } else {
355 input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
356 rw = -(signed char)data[6];
357 }
358 input_report_rel(input, REL_WHEEL, rw);
359 }
360
361 if (!prox)
362 wacom->id[0] = 0;
363 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
364 input_report_key(input, wacom->tool[0], prox);
365 input_sync(input); /* sync last event */
366 }
367
368 /* send pad data */
369 switch (features->type) {
370 case WACOM_G4:
371 prox = data[7] & 0xf8;
372 if (prox || wacom->id[1]) {
373 wacom->id[1] = PAD_DEVICE_ID;
374 input_report_key(pad_input, BTN_BACK, (data[7] & 0x40));
375 input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x80));
376 rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
377 input_report_rel(pad_input, REL_WHEEL, rw);
378 if (!prox)
379 wacom->id[1] = 0;
380 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
381 retval = 1;
382 }
383 break;
384
385 case WACOM_MO:
386 prox = (data[7] & 0xf8) || data[8];
387 if (prox || wacom->id[1]) {
388 wacom->id[1] = PAD_DEVICE_ID;
389 input_report_key(pad_input, BTN_BACK, (data[7] & 0x08));
390 input_report_key(pad_input, BTN_LEFT, (data[7] & 0x20));
391 input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x10));
392 input_report_key(pad_input, BTN_RIGHT, (data[7] & 0x40));
393 input_report_abs(pad_input, ABS_WHEEL, (data[8] & 0x7f));
394 if (!prox)
395 wacom->id[1] = 0;
396 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
397 retval = 1;
398 }
399 break;
400 case GRAPHIRE_BT:
401 prox = data[7] & 0x03;
402 if (prox || wacom->id[1]) {
403 wacom->id[1] = PAD_DEVICE_ID;
404 input_report_key(pad_input, BTN_0, (data[7] & 0x02));
405 input_report_key(pad_input, BTN_1, (data[7] & 0x01));
406 if (!prox)
407 wacom->id[1] = 0;
408 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
409 retval = 1;
410 }
411 break;
412 }
413
414 /* Store current battery capacity and power supply state */
415 if (features->type == GRAPHIRE_BT) {
416 rw = (data[7] >> 2 & 0x07);
417 battery_capacity = batcap_gr[rw];
418 ps_connected = rw == 7;
419 if ((wacom->battery_capacity != battery_capacity) ||
420 (wacom->ps_connected != ps_connected)) {
421 wacom->battery_capacity = battery_capacity;
422 wacom->ps_connected = ps_connected;
423 wacom_notify_battery(wacom);
424 }
425 }
426exit:
427 return retval;
428}
429
430static int wacom_intuos_inout(struct wacom_wac *wacom)
431{
432 struct wacom_features *features = &wacom->features;
433 unsigned char *data = wacom->data;
434 struct input_dev *input = wacom->input;
435 int idx = 0;
436
437 /* tool number */
438 if (features->type == INTUOS)
439 idx = data[1] & 0x01;
440
441 /* Enter report */
442 if ((data[1] & 0xfc) == 0xc0) {
443 if (features->quirks & WACOM_QUIRK_MULTI_INPUT)
444 wacom->shared->stylus_in_proximity = true;
445
446 /* serial number of the tool */
447 wacom->serial[idx] = ((data[3] & 0x0f) << 28) +
448 (data[4] << 20) + (data[5] << 12) +
449 (data[6] << 4) + (data[7] >> 4);
450
451 wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
452 ((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
453
454 switch (wacom->id[idx]) {
455 case 0x812: /* Inking pen */
456 case 0x801: /* Intuos3 Inking pen */
457 case 0x120802: /* Intuos4/5 Inking Pen */
458 case 0x012:
459 wacom->tool[idx] = BTN_TOOL_PENCIL;
460 break;
461
462 case 0x822: /* Pen */
463 case 0x842:
464 case 0x852:
465 case 0x823: /* Intuos3 Grip Pen */
466 case 0x813: /* Intuos3 Classic Pen */
467 case 0x885: /* Intuos3 Marker Pen */
468 case 0x802: /* Intuos4/5 13HD/24HD General Pen */
469 case 0x804: /* Intuos4/5 13HD/24HD Marker Pen */
470 case 0x022:
471 case 0x100804: /* Intuos4/5 13HD/24HD Art Pen */
472 case 0x140802: /* Intuos4/5 13HD/24HD Classic Pen */
473 case 0x160802: /* Cintiq 13HD Pro Pen */
474 case 0x180802: /* DTH2242 Pen */
475 case 0x100802: /* Intuos4/5 13HD/24HD General Pen */
476 wacom->tool[idx] = BTN_TOOL_PEN;
477 break;
478
479 case 0x832: /* Stroke pen */
480 case 0x032:
481 wacom->tool[idx] = BTN_TOOL_BRUSH;
482 break;
483
484 case 0x007: /* Mouse 4D and 2D */
485 case 0x09c:
486 case 0x094:
487 case 0x017: /* Intuos3 2D Mouse */
488 case 0x806: /* Intuos4 Mouse */
489 wacom->tool[idx] = BTN_TOOL_MOUSE;
490 break;
491
492 case 0x096: /* Lens cursor */
493 case 0x097: /* Intuos3 Lens cursor */
494 case 0x006: /* Intuos4 Lens cursor */
495 wacom->tool[idx] = BTN_TOOL_LENS;
496 break;
497
498 case 0x82a: /* Eraser */
499 case 0x85a:
500 case 0x91a:
501 case 0xd1a:
502 case 0x0fa:
503 case 0x82b: /* Intuos3 Grip Pen Eraser */
504 case 0x81b: /* Intuos3 Classic Pen Eraser */
505 case 0x91b: /* Intuos3 Airbrush Eraser */
506 case 0x80c: /* Intuos4/5 13HD/24HD Marker Pen Eraser */
507 case 0x80a: /* Intuos4/5 13HD/24HD General Pen Eraser */
508 case 0x90a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
509 case 0x14080a: /* Intuos4/5 13HD/24HD Classic Pen Eraser */
510 case 0x10090a: /* Intuos4/5 13HD/24HD Airbrush Eraser */
511 case 0x10080c: /* Intuos4/5 13HD/24HD Art Pen Eraser */
512 case 0x16080a: /* Cintiq 13HD Pro Pen Eraser */
513 case 0x18080a: /* DTH2242 Eraser */
514 case 0x10080a: /* Intuos4/5 13HD/24HD General Pen Eraser */
515 wacom->tool[idx] = BTN_TOOL_RUBBER;
516 break;
517
518 case 0xd12:
519 case 0x912:
520 case 0x112:
521 case 0x913: /* Intuos3 Airbrush */
522 case 0x902: /* Intuos4/5 13HD/24HD Airbrush */
523 case 0x100902: /* Intuos4/5 13HD/24HD Airbrush */
524 wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
525 break;
526
527 default: /* Unknown tool */
528 wacom->tool[idx] = BTN_TOOL_PEN;
529 break;
530 }
531 return 1;
532 }
533
534 /* older I4 styli don't work with new Cintiqs */
535 if (!((wacom->id[idx] >> 20) & 0x01) &&
536 (features->type == WACOM_21UX2))
537 return 1;
538
539 /* Range Report */
540 if ((data[1] & 0xfe) == 0x20) {
541 input_report_key(input, BTN_TOUCH, 0);
542 input_report_abs(input, ABS_PRESSURE, 0);
543 input_report_abs(input, ABS_DISTANCE, wacom->features.distance_max);
544 if (features->quirks & WACOM_QUIRK_MULTI_INPUT)
545 wacom->shared->stylus_in_proximity = true;
546 }
547
548 /* Exit report */
549 if ((data[1] & 0xfe) == 0x80) {
550 if (features->quirks & WACOM_QUIRK_MULTI_INPUT)
551 wacom->shared->stylus_in_proximity = false;
552
553 /*
554 * Reset all states otherwise we lose the initial states
555 * when in-prox next time
556 */
557 input_report_abs(input, ABS_X, 0);
558 input_report_abs(input, ABS_Y, 0);
559 input_report_abs(input, ABS_DISTANCE, 0);
560 input_report_abs(input, ABS_TILT_X, 0);
561 input_report_abs(input, ABS_TILT_Y, 0);
562 if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
563 input_report_key(input, BTN_LEFT, 0);
564 input_report_key(input, BTN_MIDDLE, 0);
565 input_report_key(input, BTN_RIGHT, 0);
566 input_report_key(input, BTN_SIDE, 0);
567 input_report_key(input, BTN_EXTRA, 0);
568 input_report_abs(input, ABS_THROTTLE, 0);
569 input_report_abs(input, ABS_RZ, 0);
570 } else {
571 input_report_abs(input, ABS_PRESSURE, 0);
572 input_report_key(input, BTN_STYLUS, 0);
573 input_report_key(input, BTN_STYLUS2, 0);
574 input_report_key(input, BTN_TOUCH, 0);
575 input_report_abs(input, ABS_WHEEL, 0);
576 if (features->type >= INTUOS3S)
577 input_report_abs(input, ABS_Z, 0);
578 }
579 input_report_key(input, wacom->tool[idx], 0);
580 input_report_abs(input, ABS_MISC, 0); /* reset tool id */
581 input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
582 wacom->id[idx] = 0;
583 return 2;
584 }
585 return 0;
586}
587
588static void wacom_intuos_general(struct wacom_wac *wacom)
589{
590 struct wacom_features *features = &wacom->features;
591 unsigned char *data = wacom->data;
592 struct input_dev *input = wacom->input;
593 unsigned int t;
594
595 /* general pen packet */
596 if ((data[1] & 0xb8) == 0xa0) {
597 t = (data[6] << 2) | ((data[7] >> 6) & 3);
598 if (features->type >= INTUOS4S && features->type <= CINTIQ_HYBRID) {
599 t = (t << 1) | (data[1] & 1);
600 }
601 input_report_abs(input, ABS_PRESSURE, t);
602 input_report_abs(input, ABS_TILT_X,
603 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
604 input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
605 input_report_key(input, BTN_STYLUS, data[1] & 2);
606 input_report_key(input, BTN_STYLUS2, data[1] & 4);
607 input_report_key(input, BTN_TOUCH, t > 10);
608 }
609
610 /* airbrush second packet */
611 if ((data[1] & 0xbc) == 0xb4) {
612 input_report_abs(input, ABS_WHEEL,
613 (data[6] << 2) | ((data[7] >> 6) & 3));
614 input_report_abs(input, ABS_TILT_X,
615 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
616 input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
617 }
618}
619
620static int wacom_intuos_irq(struct wacom_wac *wacom)
621{
622 struct wacom_features *features = &wacom->features;
623 unsigned char *data = wacom->data;
624 struct input_dev *input = wacom->input;
625 unsigned int t;
626 int idx = 0, result;
627
628 if (data[0] != WACOM_REPORT_PENABLED &&
629 data[0] != WACOM_REPORT_INTUOSREAD &&
630 data[0] != WACOM_REPORT_INTUOSWRITE &&
631 data[0] != WACOM_REPORT_INTUOSPAD &&
632 data[0] != WACOM_REPORT_INTUOS5PAD) {
633 dev_dbg(input->dev.parent,
634 "%s: received unknown report #%d\n", __func__, data[0]);
635 return 0;
636 }
637
638 /* tool number */
639 if (features->type == INTUOS)
640 idx = data[1] & 0x01;
641
642 /* pad packets. Works as a second tool and is always in prox */
643 if (data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD) {
644 input = wacom->pad_input;
645 if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
646 input_report_key(input, BTN_0, (data[2] & 0x01));
647 input_report_key(input, BTN_1, (data[3] & 0x01));
648 input_report_key(input, BTN_2, (data[3] & 0x02));
649 input_report_key(input, BTN_3, (data[3] & 0x04));
650 input_report_key(input, BTN_4, (data[3] & 0x08));
651 input_report_key(input, BTN_5, (data[3] & 0x10));
652 input_report_key(input, BTN_6, (data[3] & 0x20));
653 if (data[1] & 0x80) {
654 input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
655 } else {
656 /* Out of proximity, clear wheel value. */
657 input_report_abs(input, ABS_WHEEL, 0);
658 }
659 if (features->type != INTUOS4S) {
660 input_report_key(input, BTN_7, (data[3] & 0x40));
661 input_report_key(input, BTN_8, (data[3] & 0x80));
662 }
663 if (data[1] | (data[2] & 0x01) | data[3]) {
664 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
665 } else {
666 input_report_abs(input, ABS_MISC, 0);
667 }
668 } else if (features->type == DTK) {
669 input_report_key(input, BTN_0, (data[6] & 0x01));
670 input_report_key(input, BTN_1, (data[6] & 0x02));
671 input_report_key(input, BTN_2, (data[6] & 0x04));
672 input_report_key(input, BTN_3, (data[6] & 0x08));
673 input_report_key(input, BTN_4, (data[6] & 0x10));
674 input_report_key(input, BTN_5, (data[6] & 0x20));
675 if (data[6] & 0x3f) {
676 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
677 } else {
678 input_report_abs(input, ABS_MISC, 0);
679 }
680 } else if (features->type == WACOM_13HD) {
681 input_report_key(input, BTN_0, (data[3] & 0x01));
682 input_report_key(input, BTN_1, (data[4] & 0x01));
683 input_report_key(input, BTN_2, (data[4] & 0x02));
684 input_report_key(input, BTN_3, (data[4] & 0x04));
685 input_report_key(input, BTN_4, (data[4] & 0x08));
686 input_report_key(input, BTN_5, (data[4] & 0x10));
687 input_report_key(input, BTN_6, (data[4] & 0x20));
688 input_report_key(input, BTN_7, (data[4] & 0x40));
689 input_report_key(input, BTN_8, (data[4] & 0x80));
690 if ((data[3] & 0x01) | data[4]) {
691 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
692 } else {
693 input_report_abs(input, ABS_MISC, 0);
694 }
695 } else if (features->type == WACOM_24HD) {
696 input_report_key(input, BTN_0, (data[6] & 0x01));
697 input_report_key(input, BTN_1, (data[6] & 0x02));
698 input_report_key(input, BTN_2, (data[6] & 0x04));
699 input_report_key(input, BTN_3, (data[6] & 0x08));
700 input_report_key(input, BTN_4, (data[6] & 0x10));
701 input_report_key(input, BTN_5, (data[6] & 0x20));
702 input_report_key(input, BTN_6, (data[6] & 0x40));
703 input_report_key(input, BTN_7, (data[6] & 0x80));
704 input_report_key(input, BTN_8, (data[8] & 0x01));
705 input_report_key(input, BTN_9, (data[8] & 0x02));
706 input_report_key(input, BTN_A, (data[8] & 0x04));
707 input_report_key(input, BTN_B, (data[8] & 0x08));
708 input_report_key(input, BTN_C, (data[8] & 0x10));
709 input_report_key(input, BTN_X, (data[8] & 0x20));
710 input_report_key(input, BTN_Y, (data[8] & 0x40));
711 input_report_key(input, BTN_Z, (data[8] & 0x80));
712
713 /*
714 * Three "buttons" are available on the 24HD which are
715 * physically implemented as a touchstrip. Each button
716 * is approximately 3 bits wide with a 2 bit spacing.
717 * The raw touchstrip bits are stored at:
718 * ((data[3] & 0x1f) << 8) | data[4])
719 */
720 input_report_key(input, KEY_PROG1, data[4] & 0x07);
721 input_report_key(input, KEY_PROG2, data[4] & 0xE0);
722 input_report_key(input, KEY_PROG3, data[3] & 0x1C);
723
724 if (data[1] & 0x80) {
725 input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
726 } else {
727 /* Out of proximity, clear wheel value. */
728 input_report_abs(input, ABS_WHEEL, 0);
729 }
730
731 if (data[2] & 0x80) {
732 input_report_abs(input, ABS_THROTTLE, (data[2] & 0x7f));
733 } else {
734 /* Out of proximity, clear second wheel value. */
735 input_report_abs(input, ABS_THROTTLE, 0);
736 }
737
738 if (data[1] | data[2] | (data[3] & 0x1f) | data[4] | data[6] | data[8]) {
739 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
740 } else {
741 input_report_abs(input, ABS_MISC, 0);
742 }
743 } else if (features->type == CINTIQ_HYBRID) {
744 /*
745 * Do not send hardware buttons under Android. They
746 * are already sent to the system through GPIO (and
747 * have different meaning).
748 */
749 input_report_key(input, BTN_1, (data[4] & 0x01));
750 input_report_key(input, BTN_2, (data[4] & 0x02));
751 input_report_key(input, BTN_3, (data[4] & 0x04));
752 input_report_key(input, BTN_4, (data[4] & 0x08));
753
754 input_report_key(input, BTN_5, (data[4] & 0x10)); /* Right */
755 input_report_key(input, BTN_6, (data[4] & 0x20)); /* Up */
756 input_report_key(input, BTN_7, (data[4] & 0x40)); /* Left */
757 input_report_key(input, BTN_8, (data[4] & 0x80)); /* Down */
758 input_report_key(input, BTN_0, (data[3] & 0x01)); /* Center */
759 } else if (features->type >= INTUOS5S && features->type <= INTUOSPL) {
760 int i;
761
762 /* Touch ring mode switch has no capacitive sensor */
763 input_report_key(input, BTN_0, (data[3] & 0x01));
764
765 /*
766 * ExpressKeys on Intuos5/Intuos Pro have a capacitive sensor in
767 * addition to the mechanical switch. Switch data is
768 * stored in data[4], capacitive data in data[5].
769 */
770 for (i = 0; i < 8; i++)
771 input_report_key(input, BTN_1 + i, data[4] & (1 << i));
772
773 if (data[2] & 0x80) {
774 input_report_abs(input, ABS_WHEEL, (data[2] & 0x7f));
775 } else {
776 /* Out of proximity, clear wheel value. */
777 input_report_abs(input, ABS_WHEEL, 0);
778 }
779
780 if (data[2] | (data[3] & 0x01) | data[4] | data[5]) {
781 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
782 } else {
783 input_report_abs(input, ABS_MISC, 0);
784 }
785 } else {
786 if (features->type == WACOM_21UX2 || features->type == WACOM_22HD) {
787 input_report_key(input, BTN_0, (data[5] & 0x01));
788 input_report_key(input, BTN_1, (data[6] & 0x01));
789 input_report_key(input, BTN_2, (data[6] & 0x02));
790 input_report_key(input, BTN_3, (data[6] & 0x04));
791 input_report_key(input, BTN_4, (data[6] & 0x08));
792 input_report_key(input, BTN_5, (data[6] & 0x10));
793 input_report_key(input, BTN_6, (data[6] & 0x20));
794 input_report_key(input, BTN_7, (data[6] & 0x40));
795 input_report_key(input, BTN_8, (data[6] & 0x80));
796 input_report_key(input, BTN_9, (data[7] & 0x01));
797 input_report_key(input, BTN_A, (data[8] & 0x01));
798 input_report_key(input, BTN_B, (data[8] & 0x02));
799 input_report_key(input, BTN_C, (data[8] & 0x04));
800 input_report_key(input, BTN_X, (data[8] & 0x08));
801 input_report_key(input, BTN_Y, (data[8] & 0x10));
802 input_report_key(input, BTN_Z, (data[8] & 0x20));
803 input_report_key(input, BTN_BASE, (data[8] & 0x40));
804 input_report_key(input, BTN_BASE2, (data[8] & 0x80));
805
806 if (features->type == WACOM_22HD) {
807 input_report_key(input, KEY_PROG1, data[9] & 0x01);
808 input_report_key(input, KEY_PROG2, data[9] & 0x02);
809 input_report_key(input, KEY_PROG3, data[9] & 0x04);
810 }
811 } else {
812 input_report_key(input, BTN_0, (data[5] & 0x01));
813 input_report_key(input, BTN_1, (data[5] & 0x02));
814 input_report_key(input, BTN_2, (data[5] & 0x04));
815 input_report_key(input, BTN_3, (data[5] & 0x08));
816 input_report_key(input, BTN_4, (data[6] & 0x01));
817 input_report_key(input, BTN_5, (data[6] & 0x02));
818 input_report_key(input, BTN_6, (data[6] & 0x04));
819 input_report_key(input, BTN_7, (data[6] & 0x08));
820 input_report_key(input, BTN_8, (data[5] & 0x10));
821 input_report_key(input, BTN_9, (data[6] & 0x10));
822 }
823 input_report_abs(input, ABS_RX, ((data[1] & 0x1f) << 8) | data[2]);
824 input_report_abs(input, ABS_RY, ((data[3] & 0x1f) << 8) | data[4]);
825
826 if ((data[5] & 0x1f) | data[6] | (data[1] & 0x1f) |
827 data[2] | (data[3] & 0x1f) | data[4] | data[8] |
828 (data[7] & 0x01)) {
829 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
830 } else {
831 input_report_abs(input, ABS_MISC, 0);
832 }
833 }
834 return 1;
835 }
836
837 /* process in/out prox events */
838 result = wacom_intuos_inout(wacom);
839 if (result)
840 return result - 1;
841
842 /* don't proceed if we don't know the ID */
843 if (!wacom->id[idx])
844 return 0;
845
846 /* Only large Intuos support Lense Cursor */
847 if (wacom->tool[idx] == BTN_TOOL_LENS &&
848 (features->type == INTUOS3 ||
849 features->type == INTUOS3S ||
850 features->type == INTUOS4 ||
851 features->type == INTUOS4S ||
852 features->type == INTUOS5 ||
853 features->type == INTUOS5S ||
854 features->type == INTUOSPM ||
855 features->type == INTUOSPS)) {
856
857 return 0;
858 }
859
860 /* Cintiq doesn't send data when RDY bit isn't set */
861 if (features->type == CINTIQ && !(data[1] & 0x40))
862 return 0;
863
864 if (features->type >= INTUOS3S) {
865 input_report_abs(input, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
866 input_report_abs(input, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
867 input_report_abs(input, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
868 } else {
869 input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[2]));
870 input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[4]));
871 input_report_abs(input, ABS_DISTANCE, ((data[9] >> 3) & 0x1f));
872 }
873
874 /* process general packets */
875 wacom_intuos_general(wacom);
876
877 /* 4D mouse, 2D mouse, marker pen rotation, tilt mouse, or Lens cursor packets */
878 if ((data[1] & 0xbc) == 0xa8 || (data[1] & 0xbe) == 0xb0 || (data[1] & 0xbc) == 0xac) {
879
880 if (data[1] & 0x02) {
881 /* Rotation packet */
882 if (features->type >= INTUOS3S) {
883 /* I3 marker pen rotation */
884 t = (data[6] << 3) | ((data[7] >> 5) & 7);
885 t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
886 ((t-1) / 2 + 450)) : (450 - t / 2) ;
887 input_report_abs(input, ABS_Z, t);
888 } else {
889 /* 4D mouse rotation packet */
890 t = (data[6] << 3) | ((data[7] >> 5) & 7);
891 input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
892 ((t - 1) / 2) : -t / 2);
893 }
894
895 } else if (!(data[1] & 0x10) && features->type < INTUOS3S) {
896 /* 4D mouse packet */
897 input_report_key(input, BTN_LEFT, data[8] & 0x01);
898 input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
899 input_report_key(input, BTN_RIGHT, data[8] & 0x04);
900
901 input_report_key(input, BTN_SIDE, data[8] & 0x20);
902 input_report_key(input, BTN_EXTRA, data[8] & 0x10);
903 t = (data[6] << 2) | ((data[7] >> 6) & 3);
904 input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
905
906 } else if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
907 /* I4 mouse */
908 if (features->type >= INTUOS4S && features->type <= INTUOSPL) {
909 input_report_key(input, BTN_LEFT, data[6] & 0x01);
910 input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
911 input_report_key(input, BTN_RIGHT, data[6] & 0x04);
912 input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
913 - ((data[7] & 0x40) >> 6));
914 input_report_key(input, BTN_SIDE, data[6] & 0x08);
915 input_report_key(input, BTN_EXTRA, data[6] & 0x10);
916
917 input_report_abs(input, ABS_TILT_X,
918 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
919 input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
920 } else {
921 /* 2D mouse packet */
922 input_report_key(input, BTN_LEFT, data[8] & 0x04);
923 input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
924 input_report_key(input, BTN_RIGHT, data[8] & 0x10);
925 input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
926 - ((data[8] & 0x02) >> 1));
927
928 /* I3 2D mouse side buttons */
929 if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
930 input_report_key(input, BTN_SIDE, data[8] & 0x40);
931 input_report_key(input, BTN_EXTRA, data[8] & 0x20);
932 }
933 }
934 } else if ((features->type < INTUOS3S || features->type == INTUOS3L ||
935 features->type == INTUOS4L || features->type == INTUOS5L ||
936 features->type == INTUOSPL) &&
937 wacom->tool[idx] == BTN_TOOL_LENS) {
938 /* Lens cursor packets */
939 input_report_key(input, BTN_LEFT, data[8] & 0x01);
940 input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
941 input_report_key(input, BTN_RIGHT, data[8] & 0x04);
942 input_report_key(input, BTN_SIDE, data[8] & 0x10);
943 input_report_key(input, BTN_EXTRA, data[8] & 0x08);
944 }
945 }
946
947 input_report_abs(input, ABS_MISC, wacom->id[idx]); /* report tool id */
948 input_report_key(input, wacom->tool[idx], 1);
949 input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
950 return 1;
951}
952
953static int int_dist(int x1, int y1, int x2, int y2)
954{
955 int x = x2 - x1;
956 int y = y2 - y1;
957
958 return int_sqrt(x*x + y*y);
959}
960
961static void wacom_intuos_bt_process_data(struct wacom_wac *wacom,
962 unsigned char *data)
963{
964 memcpy(wacom->data, data, 10);
965 wacom_intuos_irq(wacom);
966
967 input_sync(wacom->input);
968 if (wacom->pad_input)
969 input_sync(wacom->pad_input);
970}
971
972static int wacom_intuos_bt_irq(struct wacom_wac *wacom, size_t len)
973{
974 unsigned char data[WACOM_PKGLEN_MAX];
975 int i = 1;
976 unsigned power_raw, battery_capacity, bat_charging, ps_connected;
977
978 memcpy(data, wacom->data, len);
979
980 switch (data[0]) {
981 case 0x04:
982 wacom_intuos_bt_process_data(wacom, data + i);
983 i += 10;
984 /* fall through */
985 case 0x03:
986 wacom_intuos_bt_process_data(wacom, data + i);
987 i += 10;
988 wacom_intuos_bt_process_data(wacom, data + i);
989 i += 10;
990 power_raw = data[i];
991 bat_charging = (power_raw & 0x08) ? 1 : 0;
992 ps_connected = (power_raw & 0x10) ? 1 : 0;
993 battery_capacity = batcap_i4[power_raw & 0x07];
994 if ((wacom->battery_capacity != battery_capacity) ||
995 (wacom->bat_charging != bat_charging) ||
996 (wacom->ps_connected != ps_connected)) {
997 wacom->battery_capacity = battery_capacity;
998 wacom->bat_charging = bat_charging;
999 wacom->ps_connected = ps_connected;
1000 wacom_notify_battery(wacom);
1001 }
1002
1003 break;
1004 default:
1005 dev_dbg(wacom->input->dev.parent,
1006 "Unknown report: %d,%d size:%zu\n",
1007 data[0], data[1], len);
1008 return 0;
1009 }
1010 return 0;
1011}
1012
1013static int wacom_24hdt_irq(struct wacom_wac *wacom)
1014{
1015 struct input_dev *input = wacom->input;
1016 unsigned char *data = wacom->data;
1017 int i;
1018 int current_num_contacts = data[61];
1019 int contacts_to_send = 0;
1020
1021 /*
1022 * First packet resets the counter since only the first
1023 * packet in series will have non-zero current_num_contacts.
1024 */
1025 if (current_num_contacts)
1026 wacom->num_contacts_left = current_num_contacts;
1027
1028 /* There are at most 4 contacts per packet */
1029 contacts_to_send = min(4, wacom->num_contacts_left);
1030
1031 for (i = 0; i < contacts_to_send; i++) {
1032 int offset = (WACOM_BYTES_PER_24HDT_PACKET * i) + 1;
1033 bool touch = data[offset] & 0x1 && !wacom->shared->stylus_in_proximity;
1034 int slot = input_mt_get_slot_by_key(input, data[offset + 1]);
1035
1036 if (slot < 0)
1037 continue;
1038 input_mt_slot(input, slot);
1039 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1040
1041 if (touch) {
1042 int t_x = get_unaligned_le16(&data[offset + 2]);
1043 int c_x = get_unaligned_le16(&data[offset + 4]);
1044 int t_y = get_unaligned_le16(&data[offset + 6]);
1045 int c_y = get_unaligned_le16(&data[offset + 8]);
1046 int w = get_unaligned_le16(&data[offset + 10]);
1047 int h = get_unaligned_le16(&data[offset + 12]);
1048
1049 input_report_abs(input, ABS_MT_POSITION_X, t_x);
1050 input_report_abs(input, ABS_MT_POSITION_Y, t_y);
1051 input_report_abs(input, ABS_MT_TOUCH_MAJOR, min(w,h));
1052 input_report_abs(input, ABS_MT_WIDTH_MAJOR, min(w, h) + int_dist(t_x, t_y, c_x, c_y));
1053 input_report_abs(input, ABS_MT_WIDTH_MINOR, min(w, h));
1054 input_report_abs(input, ABS_MT_ORIENTATION, w > h);
1055 }
1056 }
1057 input_mt_report_pointer_emulation(input, true);
1058
1059 wacom->num_contacts_left -= contacts_to_send;
1060 if (wacom->num_contacts_left <= 0)
1061 wacom->num_contacts_left = 0;
1062
1063 return 1;
1064}
1065
1066static int wacom_mt_touch(struct wacom_wac *wacom)
1067{
1068 struct input_dev *input = wacom->input;
1069 unsigned char *data = wacom->data;
1070 int i;
1071 int current_num_contacts = data[2];
1072 int contacts_to_send = 0;
1073 int x_offset = 0;
1074
1075 /* MTTPC does not support Height and Width */
1076 if (wacom->features.type == MTTPC || wacom->features.type == MTTPC_B)
1077 x_offset = -4;
1078
1079 /*
1080 * First packet resets the counter since only the first
1081 * packet in series will have non-zero current_num_contacts.
1082 */
1083 if (current_num_contacts)
1084 wacom->num_contacts_left = current_num_contacts;
1085
1086 /* There are at most 5 contacts per packet */
1087 contacts_to_send = min(5, wacom->num_contacts_left);
1088
1089 for (i = 0; i < contacts_to_send; i++) {
1090 int offset = (WACOM_BYTES_PER_MT_PACKET + x_offset) * i + 3;
1091 bool touch = data[offset] & 0x1;
1092 int id = get_unaligned_le16(&data[offset + 1]);
1093 int slot = input_mt_get_slot_by_key(input, id);
1094
1095 if (slot < 0)
1096 continue;
1097
1098 input_mt_slot(input, slot);
1099 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1100 if (touch) {
1101 int x = get_unaligned_le16(&data[offset + x_offset + 7]);
1102 int y = get_unaligned_le16(&data[offset + x_offset + 9]);
1103 input_report_abs(input, ABS_MT_POSITION_X, x);
1104 input_report_abs(input, ABS_MT_POSITION_Y, y);
1105 }
1106 }
1107 input_mt_report_pointer_emulation(input, true);
1108
1109 wacom->num_contacts_left -= contacts_to_send;
1110 if (wacom->num_contacts_left < 0)
1111 wacom->num_contacts_left = 0;
1112
1113 return 1;
1114}
1115
1116static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
1117{
1118 struct input_dev *input = wacom->input;
1119 unsigned char *data = wacom->data;
1120 int contact_with_no_pen_down_count = 0;
1121 int i;
1122
1123 for (i = 0; i < 2; i++) {
1124 int p = data[1] & (1 << i);
1125 bool touch = p && !wacom->shared->stylus_in_proximity;
1126
1127 input_mt_slot(input, i);
1128 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1129 if (touch) {
1130 int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
1131 int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
1132
1133 input_report_abs(input, ABS_MT_POSITION_X, x);
1134 input_report_abs(input, ABS_MT_POSITION_Y, y);
1135 contact_with_no_pen_down_count++;
1136 }
1137 }
1138 input_mt_report_pointer_emulation(input, true);
1139
1140 /* keep touch state for pen event */
1141 wacom->shared->touch_down = (contact_with_no_pen_down_count > 0);
1142
1143 return 1;
1144}
1145
1146static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
1147{
1148 unsigned char *data = wacom->data;
1149 struct input_dev *input = wacom->input;
1150 bool prox;
1151 int x = 0, y = 0;
1152
1153 if (wacom->features.touch_max > 1 || len > WACOM_PKGLEN_TPC2FG)
1154 return 0;
1155
1156 if (!wacom->shared->stylus_in_proximity) {
1157 if (len == WACOM_PKGLEN_TPC1FG) {
1158 prox = data[0] & 0x01;
1159 x = get_unaligned_le16(&data[1]);
1160 y = get_unaligned_le16(&data[3]);
1161 } else if (len == WACOM_PKGLEN_TPC1FG_B) {
1162 prox = data[2] & 0x01;
1163 x = get_unaligned_le16(&data[3]);
1164 y = get_unaligned_le16(&data[5]);
1165 } else {
1166 prox = data[1] & 0x01;
1167 x = le16_to_cpup((__le16 *)&data[2]);
1168 y = le16_to_cpup((__le16 *)&data[4]);
1169 }
1170 } else
1171 /* force touch out when pen is in prox */
1172 prox = 0;
1173
1174 if (prox) {
1175 input_report_abs(input, ABS_X, x);
1176 input_report_abs(input, ABS_Y, y);
1177 }
1178 input_report_key(input, BTN_TOUCH, prox);
1179
1180 /* keep touch state for pen events */
1181 wacom->shared->touch_down = prox;
1182
1183 return 1;
1184}
1185
1186static int wacom_tpc_pen(struct wacom_wac *wacom)
1187{
1188 unsigned char *data = wacom->data;
1189 struct input_dev *input = wacom->input;
1190 bool prox = data[1] & 0x20;
1191
1192 if (!wacom->shared->stylus_in_proximity) /* first in prox */
1193 /* Going into proximity select tool */
1194 wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
1195
1196 /* keep pen state for touch events */
1197 wacom->shared->stylus_in_proximity = prox;
1198
1199 /* send pen events only when touch is up or forced out */
1200 if (!wacom->shared->touch_down) {
1201 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
1202 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
1203 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
1204 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
1205 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x07) << 8) | data[6]);
1206 input_report_key(input, BTN_TOUCH, data[1] & 0x05);
1207 input_report_key(input, wacom->tool[0], prox);
1208 return 1;
1209 }
1210
1211 return 0;
1212}
1213
1214static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
1215{
1216 unsigned char *data = wacom->data;
1217
1218 dev_dbg(wacom->input->dev.parent,
1219 "%s: received report #%d\n", __func__, data[0]);
1220
1221 switch (len) {
1222 case WACOM_PKGLEN_TPC1FG:
1223 return wacom_tpc_single_touch(wacom, len);
1224
1225 case WACOM_PKGLEN_TPC2FG:
1226 return wacom_tpc_mt_touch(wacom);
1227
1228 case WACOM_PKGLEN_PENABLED:
1229 return wacom_tpc_pen(wacom);
1230
1231 default:
1232 switch (data[0]) {
1233 case WACOM_REPORT_TPC1FG:
1234 case WACOM_REPORT_TPCHID:
1235 case WACOM_REPORT_TPCST:
1236 case WACOM_REPORT_TPC1FGE:
1237 return wacom_tpc_single_touch(wacom, len);
1238
1239 case WACOM_REPORT_TPCMT:
1240 case WACOM_REPORT_TPCMT2:
1241 return wacom_mt_touch(wacom);
1242
1243 case WACOM_REPORT_PENABLED:
1244 return wacom_tpc_pen(wacom);
1245 }
1246 }
1247
1248 return 0;
1249}
1250
1251static int wacom_bpt_touch(struct wacom_wac *wacom)
1252{
1253 struct wacom_features *features = &wacom->features;
1254 struct input_dev *input = wacom->input;
1255 struct input_dev *pad_input = wacom->pad_input;
1256 unsigned char *data = wacom->data;
1257 int i;
1258
1259 if (data[0] != 0x02)
1260 return 0;
1261
1262 for (i = 0; i < 2; i++) {
1263 int offset = (data[1] & 0x80) ? (8 * i) : (9 * i);
1264 bool touch = data[offset + 3] & 0x80;
1265
1266 /*
1267 * Touch events need to be disabled while stylus is
1268 * in proximity because user's hand is resting on touchpad
1269 * and sending unwanted events. User expects tablet buttons
1270 * to continue working though.
1271 */
1272 touch = touch && !wacom->shared->stylus_in_proximity;
1273
1274 input_mt_slot(input, i);
1275 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1276 if (touch) {
1277 int x = get_unaligned_be16(&data[offset + 3]) & 0x7ff;
1278 int y = get_unaligned_be16(&data[offset + 5]) & 0x7ff;
1279 if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
1280 x <<= 5;
1281 y <<= 5;
1282 }
1283 input_report_abs(input, ABS_MT_POSITION_X, x);
1284 input_report_abs(input, ABS_MT_POSITION_Y, y);
1285 }
1286 }
1287
1288 input_mt_report_pointer_emulation(input, true);
1289
1290 input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
1291 input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
1292 input_report_key(pad_input, BTN_BACK, (data[1] & 0x02) != 0);
1293 input_report_key(pad_input, BTN_RIGHT, (data[1] & 0x01) != 0);
1294
1295 return 1;
1296}
1297
1298static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
1299{
1300 struct wacom_features *features = &wacom->features;
1301 struct input_dev *input = wacom->input;
1302 bool touch = data[1] & 0x80;
1303 int slot = input_mt_get_slot_by_key(input, data[0]);
1304
1305 if (slot < 0)
1306 return;
1307
1308 touch = touch && !wacom->shared->stylus_in_proximity;
1309
1310 input_mt_slot(input, slot);
1311 input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
1312
1313 if (touch) {
1314 int x = (data[2] << 4) | (data[4] >> 4);
1315 int y = (data[3] << 4) | (data[4] & 0x0f);
1316 int width, height;
1317
1318 if (features->type >= INTUOSPS && features->type <= INTUOSPL) {
1319 width = data[5] * 100;
1320 height = data[6] * 100;
1321 } else {
1322 /*
1323 * "a" is a scaled-down area which we assume is
1324 * roughly circular and which can be described as:
1325 * a=(pi*r^2)/C.
1326 */
1327 int a = data[5];
1328 int x_res = input_abs_get_res(input, ABS_MT_POSITION_X);
1329 int y_res = input_abs_get_res(input, ABS_MT_POSITION_Y);
1330 width = 2 * int_sqrt(a * WACOM_CONTACT_AREA_SCALE);
1331 height = width * y_res / x_res;
1332 }
1333
1334 input_report_abs(input, ABS_MT_POSITION_X, x);
1335 input_report_abs(input, ABS_MT_POSITION_Y, y);
1336 input_report_abs(input, ABS_MT_TOUCH_MAJOR, width);
1337 input_report_abs(input, ABS_MT_TOUCH_MINOR, height);
1338 }
1339}
1340
1341static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
1342{
1343 struct input_dev *input = wacom->pad_input;
1344 struct wacom_features *features = &wacom->features;
1345
1346 if (features->type == INTUOSHT) {
1347 input_report_key(input, BTN_LEFT, (data[1] & 0x02) != 0);
1348 input_report_key(input, BTN_BACK, (data[1] & 0x08) != 0);
1349 } else {
1350 input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
1351 input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
1352 }
1353 input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
1354 input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
1355}
1356
1357static int wacom_bpt3_touch(struct wacom_wac *wacom)
1358{
1359 struct input_dev *input = wacom->input;
1360 unsigned char *data = wacom->data;
1361 int count = data[1] & 0x07;
1362 int i;
1363
1364 if (data[0] != 0x02)
1365 return 0;
1366
1367 /* data has up to 7 fixed sized 8-byte messages starting at data[2] */
1368 for (i = 0; i < count; i++) {
1369 int offset = (8 * i) + 2;
1370 int msg_id = data[offset];
1371
1372 if (msg_id >= 2 && msg_id <= 17)
1373 wacom_bpt3_touch_msg(wacom, data + offset);
1374 else if (msg_id == 128)
1375 wacom_bpt3_button_msg(wacom, data + offset);
1376
1377 }
1378 input_mt_report_pointer_emulation(input, true);
1379
1380 return 1;
1381}
1382
1383static int wacom_bpt_pen(struct wacom_wac *wacom)
1384{
1385 struct wacom_features *features = &wacom->features;
1386 struct input_dev *input = wacom->input;
1387 unsigned char *data = wacom->data;
1388 int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;
1389
1390 if (data[0] != WACOM_REPORT_PENABLED && data[0] != WACOM_REPORT_USB)
1391 return 0;
1392
1393 if (data[0] == WACOM_REPORT_USB) {
1394 if (features->type == INTUOSHT && features->touch_max) {
1395 input_report_switch(wacom->shared->touch_input,
1396 SW_MUTE_DEVICE, data[8] & 0x40);
1397 input_sync(wacom->shared->touch_input);
1398 }
1399 return 0;
1400 }
1401
1402 prox = (data[1] & 0x20) == 0x20;
1403
1404 /*
1405 * All reports shared between PEN and RUBBER tool must be
1406 * forced to a known starting value (zero) when transitioning to
1407 * out-of-prox.
1408 *
1409 * If not reset then, to userspace, it will look like lost events
1410 * if new tool comes in-prox with same values as previous tool sent.
1411 *
1412 * Hardware does report zero in most out-of-prox cases but not all.
1413 */
1414 if (prox) {
1415 if (!wacom->shared->stylus_in_proximity) {
1416 if (data[1] & 0x08) {
1417 wacom->tool[0] = BTN_TOOL_RUBBER;
1418 wacom->id[0] = ERASER_DEVICE_ID;
1419 } else {
1420 wacom->tool[0] = BTN_TOOL_PEN;
1421 wacom->id[0] = STYLUS_DEVICE_ID;
1422 }
1423 wacom->shared->stylus_in_proximity = true;
1424 }
1425 x = le16_to_cpup((__le16 *)&data[2]);
1426 y = le16_to_cpup((__le16 *)&data[4]);
1427 p = le16_to_cpup((__le16 *)&data[6]);
1428 /*
1429 * Convert distance from out prox to distance from tablet.
1430 * distance will be greater than distance_max once
1431 * touching and applying pressure; do not report negative
1432 * distance.
1433 */
1434 if (data[8] <= features->distance_max)
1435 d = features->distance_max - data[8];
1436
1437 pen = data[1] & 0x01;
1438 btn1 = data[1] & 0x02;
1439 btn2 = data[1] & 0x04;
1440 }
1441
1442 input_report_key(input, BTN_TOUCH, pen);
1443 input_report_key(input, BTN_STYLUS, btn1);
1444 input_report_key(input, BTN_STYLUS2, btn2);
1445
1446 input_report_abs(input, ABS_X, x);
1447 input_report_abs(input, ABS_Y, y);
1448 input_report_abs(input, ABS_PRESSURE, p);
1449 input_report_abs(input, ABS_DISTANCE, d);
1450
1451 if (!prox) {
1452 wacom->id[0] = 0;
1453 wacom->shared->stylus_in_proximity = false;
1454 }
1455
1456 input_report_key(input, wacom->tool[0], prox); /* PEN or RUBBER */
1457 input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
1458
1459 return 1;
1460}
1461
1462static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
1463{
1464 if (len == WACOM_PKGLEN_BBTOUCH)
1465 return wacom_bpt_touch(wacom);
1466 else if (len == WACOM_PKGLEN_BBTOUCH3)
1467 return wacom_bpt3_touch(wacom);
1468 else if (len == WACOM_PKGLEN_BBFUN || len == WACOM_PKGLEN_BBPEN)
1469 return wacom_bpt_pen(wacom);
1470
1471 return 0;
1472}
1473
1474static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
1475{
1476 unsigned char *data = wacom->data;
1477 int connected;
1478
1479 if (len != WACOM_PKGLEN_WIRELESS || data[0] != WACOM_REPORT_WL)
1480 return 0;
1481
1482 connected = data[1] & 0x01;
1483 if (connected) {
1484 int pid, battery, ps_connected;
1485
1486 if ((wacom->shared->type == INTUOSHT) &&
1487 wacom->shared->touch_max) {
1488 input_report_switch(wacom->shared->touch_input,
1489 SW_MUTE_DEVICE, data[5] & 0x40);
1490 input_sync(wacom->shared->touch_input);
1491 }
1492
1493 pid = get_unaligned_be16(&data[6]);
1494 battery = (data[5] & 0x3f) * 100 / 31;
1495 ps_connected = !!(data[5] & 0x80);
1496 if (wacom->pid != pid) {
1497 wacom->pid = pid;
1498 wacom_schedule_work(wacom);
1499 }
1500
1501 if (wacom->shared->type &&
1502 (battery != wacom->battery_capacity ||
1503 ps_connected != wacom->ps_connected)) {
1504 wacom->battery_capacity = battery;
1505 wacom->ps_connected = ps_connected;
1506 wacom->bat_charging = ps_connected &&
1507 wacom->battery_capacity < 100;
1508 wacom_notify_battery(wacom);
1509 }
1510 } else if (wacom->pid != 0) {
1511 /* disconnected while previously connected */
1512 wacom->pid = 0;
1513 wacom_schedule_work(wacom);
1514 wacom->battery_capacity = 0;
1515 wacom->bat_charging = 0;
1516 wacom->ps_connected = 0;
1517 }
1518
1519 return 0;
1520}
1521
1522void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
1523{
1524 bool sync;
1525
1526 switch (wacom_wac->features.type) {
1527 case PENPARTNER:
1528 sync = wacom_penpartner_irq(wacom_wac);
1529 break;
1530
1531 case PL:
1532 sync = wacom_pl_irq(wacom_wac);
1533 break;
1534
1535 case WACOM_G4:
1536 case GRAPHIRE:
1537 case GRAPHIRE_BT:
1538 case WACOM_MO:
1539 sync = wacom_graphire_irq(wacom_wac);
1540 break;
1541
1542 case PTU:
1543 sync = wacom_ptu_irq(wacom_wac);
1544 break;
1545
1546 case DTU:
1547 sync = wacom_dtu_irq(wacom_wac);
1548 break;
1549
1550 case DTUS:
1551 sync = wacom_dtus_irq(wacom_wac);
1552 break;
1553
1554 case INTUOS:
1555 case INTUOS3S:
1556 case INTUOS3:
1557 case INTUOS3L:
1558 case INTUOS4S:
1559 case INTUOS4:
1560 case INTUOS4L:
1561 case CINTIQ:
1562 case WACOM_BEE:
1563 case WACOM_13HD:
1564 case WACOM_21UX2:
1565 case WACOM_22HD:
1566 case WACOM_24HD:
1567 case DTK:
1568 case CINTIQ_HYBRID:
1569 sync = wacom_intuos_irq(wacom_wac);
1570 break;
1571
1572 case INTUOS4WL:
1573 sync = wacom_intuos_bt_irq(wacom_wac, len);
1574 break;
1575
1576 case WACOM_24HDT:
1577 sync = wacom_24hdt_irq(wacom_wac);
1578 break;
1579
1580 case INTUOS5S:
1581 case INTUOS5:
1582 case INTUOS5L:
1583 case INTUOSPS:
1584 case INTUOSPM:
1585 case INTUOSPL:
1586 if (len == WACOM_PKGLEN_BBTOUCH3)
1587 sync = wacom_bpt3_touch(wacom_wac);
1588 else
1589 sync = wacom_intuos_irq(wacom_wac);
1590 break;
1591
1592 case TABLETPC:
1593 case TABLETPCE:
1594 case TABLETPC2FG:
1595 case MTSCREEN:
1596 case MTTPC:
1597 case MTTPC_B:
1598 sync = wacom_tpc_irq(wacom_wac, len);
1599 break;
1600
1601 case BAMBOO_PT:
1602 case INTUOSHT:
1603 sync = wacom_bpt_irq(wacom_wac, len);
1604 break;
1605
1606 case WIRELESS:
1607 sync = wacom_wireless_irq(wacom_wac, len);
1608 break;
1609
1610 default:
1611 sync = false;
1612 break;
1613 }
1614
1615 if (sync) {
1616 input_sync(wacom_wac->input);
1617 if (wacom_wac->pad_input)
1618 input_sync(wacom_wac->pad_input);
1619 }
1620}
1621
1622static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
1623{
1624 struct input_dev *input_dev = wacom_wac->input;
1625
1626 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
1627
1628 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1629 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1630 __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
1631 __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
1632 __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
1633 __set_bit(BTN_STYLUS, input_dev->keybit);
1634 __set_bit(BTN_STYLUS2, input_dev->keybit);
1635
1636 input_set_abs_params(input_dev, ABS_DISTANCE,
1637 0, wacom_wac->features.distance_max, 0, 0);
1638 input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
1639 input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
1640 input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
1641}
1642
1643static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
1644{
1645 struct input_dev *input_dev = wacom_wac->input;
1646
1647 input_set_capability(input_dev, EV_REL, REL_WHEEL);
1648
1649 wacom_setup_cintiq(wacom_wac);
1650
1651 __set_bit(BTN_LEFT, input_dev->keybit);
1652 __set_bit(BTN_RIGHT, input_dev->keybit);
1653 __set_bit(BTN_MIDDLE, input_dev->keybit);
1654 __set_bit(BTN_SIDE, input_dev->keybit);
1655 __set_bit(BTN_EXTRA, input_dev->keybit);
1656 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
1657 __set_bit(BTN_TOOL_LENS, input_dev->keybit);
1658
1659 input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
1660 input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
1661}
1662
1663void wacom_setup_device_quirks(struct wacom_features *features)
1664{
1665
1666 /* touch device found but size is not defined. use default */
1667 if (features->device_type == BTN_TOOL_FINGER && !features->x_max) {
1668 features->x_max = 1023;
1669 features->y_max = 1023;
1670 }
1671
1672 /* these device have multiple inputs */
1673 if (features->type >= WIRELESS ||
1674 (features->type >= INTUOS5S && features->type <= INTUOSHT) ||
1675 (features->oVid && features->oPid))
1676 features->quirks |= WACOM_QUIRK_MULTI_INPUT;
1677
1678 /* quirk for bamboo touch with 2 low res touches */
1679 if (features->type == BAMBOO_PT &&
1680 features->pktlen == WACOM_PKGLEN_BBTOUCH) {
1681 features->x_max <<= 5;
1682 features->y_max <<= 5;
1683 features->x_fuzz <<= 5;
1684 features->y_fuzz <<= 5;
1685 features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
1686 }
1687
1688 if (features->type == WIRELESS) {
1689
1690 /* monitor never has input and pen/touch have delayed create */
1691 features->quirks |= WACOM_QUIRK_NO_INPUT;
1692
1693 /* must be monitor interface if no device_type set */
1694 if (!features->device_type) {
1695 features->quirks |= WACOM_QUIRK_MONITOR;
1696 features->quirks |= WACOM_QUIRK_BATTERY;
1697 }
1698 }
1699}
1700
1701static void wacom_abs_set_axis(struct input_dev *input_dev,
1702 struct wacom_wac *wacom_wac)
1703{
1704 struct wacom_features *features = &wacom_wac->features;
1705
1706 if (features->device_type == BTN_TOOL_PEN) {
1707 input_set_abs_params(input_dev, ABS_X, features->x_min,
1708 features->x_max, features->x_fuzz, 0);
1709 input_set_abs_params(input_dev, ABS_Y, features->y_min,
1710 features->y_max, features->y_fuzz, 0);
1711 input_set_abs_params(input_dev, ABS_PRESSURE, 0,
1712 features->pressure_max, features->pressure_fuzz, 0);
1713
1714 /* penabled devices have fixed resolution for each model */
1715 input_abs_set_res(input_dev, ABS_X, features->x_resolution);
1716 input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
1717 } else {
1718 if (features->touch_max == 1) {
1719 input_set_abs_params(input_dev, ABS_X, 0,
1720 features->x_max, features->x_fuzz, 0);
1721 input_set_abs_params(input_dev, ABS_Y, 0,
1722 features->y_max, features->y_fuzz, 0);
1723 input_abs_set_res(input_dev, ABS_X,
1724 features->x_resolution);
1725 input_abs_set_res(input_dev, ABS_Y,
1726 features->y_resolution);
1727 }
1728
1729 if (features->touch_max > 1) {
1730 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
1731 features->x_max, features->x_fuzz, 0);
1732 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
1733 features->y_max, features->y_fuzz, 0);
1734 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1735 features->x_resolution);
1736 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1737 features->y_resolution);
1738 }
1739 }
1740}
1741
1742int wacom_setup_input_capabilities(struct input_dev *input_dev,
1743 struct wacom_wac *wacom_wac)
1744{
1745 struct wacom_features *features = &wacom_wac->features;
1746
1747 input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1748
1749 __set_bit(BTN_TOUCH, input_dev->keybit);
1750 __set_bit(ABS_MISC, input_dev->absbit);
1751
1752 wacom_abs_set_axis(input_dev, wacom_wac);
1753
1754 switch (features->type) {
1755 case WACOM_MO:
1756 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
1757 /* fall through */
1758
1759 case WACOM_G4:
1760 /* fall through */
1761
1762 case GRAPHIRE:
1763 input_set_capability(input_dev, EV_REL, REL_WHEEL);
1764
1765 __set_bit(BTN_LEFT, input_dev->keybit);
1766 __set_bit(BTN_RIGHT, input_dev->keybit);
1767 __set_bit(BTN_MIDDLE, input_dev->keybit);
1768
1769 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1770 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1771 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
1772 __set_bit(BTN_STYLUS, input_dev->keybit);
1773 __set_bit(BTN_STYLUS2, input_dev->keybit);
1774
1775 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1776 break;
1777
1778 case GRAPHIRE_BT:
1779 __clear_bit(ABS_MISC, input_dev->absbit);
1780 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
1781 features->distance_max,
1782 0, 0);
1783
1784 input_set_capability(input_dev, EV_REL, REL_WHEEL);
1785
1786 __set_bit(BTN_LEFT, input_dev->keybit);
1787 __set_bit(BTN_RIGHT, input_dev->keybit);
1788 __set_bit(BTN_MIDDLE, input_dev->keybit);
1789
1790 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1791 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1792 __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
1793 __set_bit(BTN_STYLUS, input_dev->keybit);
1794 __set_bit(BTN_STYLUS2, input_dev->keybit);
1795
1796 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1797 break;
1798
1799 case WACOM_24HD:
1800 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1801 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
1802 /* fall through */
1803
1804 case DTK:
1805 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1806
1807 wacom_setup_cintiq(wacom_wac);
1808 break;
1809
1810 case WACOM_22HD:
1811 case WACOM_21UX2:
1812 case WACOM_BEE:
1813 case CINTIQ:
1814 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1815
1816 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1817
1818 wacom_setup_cintiq(wacom_wac);
1819 break;
1820
1821 case WACOM_13HD:
1822 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1823 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1824 wacom_setup_cintiq(wacom_wac);
1825 break;
1826
1827 case INTUOS3:
1828 case INTUOS3L:
1829 case INTUOS3S:
1830 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1831 /* fall through */
1832
1833 case INTUOS:
1834 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1835
1836 wacom_setup_intuos(wacom_wac);
1837 break;
1838
1839 case INTUOS5:
1840 case INTUOS5L:
1841 case INTUOSPM:
1842 case INTUOSPL:
1843 case INTUOS5S:
1844 case INTUOSPS:
1845 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1846
1847 if (features->device_type == BTN_TOOL_PEN) {
1848 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
1849 features->distance_max,
1850 0, 0);
1851
1852 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1853
1854 wacom_setup_intuos(wacom_wac);
1855 } else if (features->device_type == BTN_TOOL_FINGER) {
1856 __clear_bit(ABS_MISC, input_dev->absbit);
1857
1858 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1859 0, features->x_max, 0, 0);
1860 input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
1861 0, features->y_max, 0, 0);
1862 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
1863 }
1864 break;
1865
1866 case INTUOS4:
1867 case INTUOS4WL:
1868 case INTUOS4L:
1869 case INTUOS4S:
1870 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1871 wacom_setup_intuos(wacom_wac);
1872
1873 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1874 break;
1875
1876 case WACOM_24HDT:
1877 if (features->device_type == BTN_TOOL_FINGER) {
1878 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, features->x_max, 0, 0);
1879 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, features->x_max, 0, 0);
1880 input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR, 0, features->y_max, 0, 0);
1881 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
1882 }
1883 /* fall through */
1884
1885 case MTSCREEN:
1886 case MTTPC:
1887 case MTTPC_B:
1888 case TABLETPC2FG:
1889 if (features->device_type == BTN_TOOL_FINGER && features->touch_max > 1)
1890 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_DIRECT);
1891 /* fall through */
1892
1893 case TABLETPC:
1894 case TABLETPCE:
1895 __clear_bit(ABS_MISC, input_dev->absbit);
1896
1897 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1898
1899 if (features->device_type != BTN_TOOL_PEN)
1900 break; /* no need to process stylus stuff */
1901
1902 /* fall through */
1903
1904 case DTUS:
1905 case PL:
1906 case DTU:
1907 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1908 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1909 __set_bit(BTN_STYLUS, input_dev->keybit);
1910 __set_bit(BTN_STYLUS2, input_dev->keybit);
1911
1912 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1913 break;
1914
1915 case PTU:
1916 __set_bit(BTN_STYLUS2, input_dev->keybit);
1917 /* fall through */
1918
1919 case PENPARTNER:
1920 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1921 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1922 __set_bit(BTN_STYLUS, input_dev->keybit);
1923
1924 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1925 break;
1926
1927 case INTUOSHT:
1928 if (features->touch_max &&
1929 features->device_type == BTN_TOOL_FINGER) {
1930 input_dev->evbit[0] |= BIT_MASK(EV_SW);
1931 __set_bit(SW_MUTE_DEVICE, input_dev->swbit);
1932 }
1933 /* fall through */
1934
1935 case BAMBOO_PT:
1936 __clear_bit(ABS_MISC, input_dev->absbit);
1937
1938 if (features->device_type == BTN_TOOL_FINGER) {
1939
1940 if (features->touch_max) {
1941 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1942 input_set_abs_params(input_dev,
1943 ABS_MT_TOUCH_MAJOR,
1944 0, features->x_max, 0, 0);
1945 input_set_abs_params(input_dev,
1946 ABS_MT_TOUCH_MINOR,
1947 0, features->y_max, 0, 0);
1948 }
1949 input_mt_init_slots(input_dev, features->touch_max, INPUT_MT_POINTER);
1950 } else {
1951 /* buttons/keys only interface */
1952 __clear_bit(ABS_X, input_dev->absbit);
1953 __clear_bit(ABS_Y, input_dev->absbit);
1954 __clear_bit(BTN_TOUCH, input_dev->keybit);
1955 }
1956 } else if (features->device_type == BTN_TOOL_PEN) {
1957 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1958 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1959 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1960 __set_bit(BTN_STYLUS, input_dev->keybit);
1961 __set_bit(BTN_STYLUS2, input_dev->keybit);
1962 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
1963 features->distance_max,
1964 0, 0);
1965 }
1966 break;
1967
1968 case CINTIQ_HYBRID:
1969 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1970 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1971
1972 wacom_setup_cintiq(wacom_wac);
1973 break;
1974 }
1975 return 0;
1976}
1977
1978int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
1979 struct wacom_wac *wacom_wac)
1980{
1981 struct wacom_features *features = &wacom_wac->features;
1982 int i;
1983
1984 input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1985
1986 /* kept for making legacy xf86-input-wacom working with the wheels */
1987 __set_bit(ABS_MISC, input_dev->absbit);
1988
1989 /* kept for making legacy xf86-input-wacom accepting the pad */
1990 input_set_abs_params(input_dev, ABS_X, 0, 1, 0, 0);
1991 input_set_abs_params(input_dev, ABS_Y, 0, 1, 0, 0);
1992
1993 switch (features->type) {
1994 case GRAPHIRE_BT:
1995 __set_bit(BTN_0, input_dev->keybit);
1996 __set_bit(BTN_1, input_dev->keybit);
1997 break;
1998
1999 case WACOM_MO:
2000 __set_bit(BTN_BACK, input_dev->keybit);
2001 __set_bit(BTN_LEFT, input_dev->keybit);
2002 __set_bit(BTN_FORWARD, input_dev->keybit);
2003 __set_bit(BTN_RIGHT, input_dev->keybit);
2004 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2005 break;
2006
2007 case WACOM_G4:
2008 __set_bit(BTN_BACK, input_dev->keybit);
2009 __set_bit(BTN_LEFT, input_dev->keybit);
2010 __set_bit(BTN_FORWARD, input_dev->keybit);
2011 __set_bit(BTN_RIGHT, input_dev->keybit);
2012 input_set_capability(input_dev, EV_REL, REL_WHEEL);
2013 break;
2014
2015 case WACOM_24HD:
2016 __set_bit(BTN_A, input_dev->keybit);
2017 __set_bit(BTN_B, input_dev->keybit);
2018 __set_bit(BTN_C, input_dev->keybit);
2019 __set_bit(BTN_X, input_dev->keybit);
2020 __set_bit(BTN_Y, input_dev->keybit);
2021 __set_bit(BTN_Z, input_dev->keybit);
2022
2023 for (i = 0; i < 10; i++)
2024 __set_bit(BTN_0 + i, input_dev->keybit);
2025
2026 __set_bit(KEY_PROG1, input_dev->keybit);
2027 __set_bit(KEY_PROG2, input_dev->keybit);
2028 __set_bit(KEY_PROG3, input_dev->keybit);
2029
2030 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2031 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
2032 break;
2033
2034 case DTK:
2035 for (i = 0; i < 6; i++)
2036 __set_bit(BTN_0 + i, input_dev->keybit);
2037
2038 break;
2039
2040 case WACOM_22HD:
2041 __set_bit(KEY_PROG1, input_dev->keybit);
2042 __set_bit(KEY_PROG2, input_dev->keybit);
2043 __set_bit(KEY_PROG3, input_dev->keybit);
2044 /* fall through */
2045
2046 case WACOM_21UX2:
2047 __set_bit(BTN_A, input_dev->keybit);
2048 __set_bit(BTN_B, input_dev->keybit);
2049 __set_bit(BTN_C, input_dev->keybit);
2050 __set_bit(BTN_X, input_dev->keybit);
2051 __set_bit(BTN_Y, input_dev->keybit);
2052 __set_bit(BTN_Z, input_dev->keybit);
2053 __set_bit(BTN_BASE, input_dev->keybit);
2054 __set_bit(BTN_BASE2, input_dev->keybit);
2055 /* fall through */
2056
2057 case WACOM_BEE:
2058 __set_bit(BTN_8, input_dev->keybit);
2059 __set_bit(BTN_9, input_dev->keybit);
2060 /* fall through */
2061
2062 case CINTIQ:
2063 for (i = 0; i < 8; i++)
2064 __set_bit(BTN_0 + i, input_dev->keybit);
2065
2066 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2067 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2068 break;
2069
2070 case WACOM_13HD:
2071 for (i = 0; i < 9; i++)
2072 __set_bit(BTN_0 + i, input_dev->keybit);
2073
2074 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2075 break;
2076
2077 case INTUOS3:
2078 case INTUOS3L:
2079 __set_bit(BTN_4, input_dev->keybit);
2080 __set_bit(BTN_5, input_dev->keybit);
2081 __set_bit(BTN_6, input_dev->keybit);
2082 __set_bit(BTN_7, input_dev->keybit);
2083
2084 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2085 /* fall through */
2086
2087 case INTUOS3S:
2088 __set_bit(BTN_0, input_dev->keybit);
2089 __set_bit(BTN_1, input_dev->keybit);
2090 __set_bit(BTN_2, input_dev->keybit);
2091 __set_bit(BTN_3, input_dev->keybit);
2092
2093 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
2094 break;
2095
2096 case INTUOS5:
2097 case INTUOS5L:
2098 case INTUOSPM:
2099 case INTUOSPL:
2100 __set_bit(BTN_7, input_dev->keybit);
2101 __set_bit(BTN_8, input_dev->keybit);
2102 /* fall through */
2103
2104 case INTUOS5S:
2105 case INTUOSPS:
2106 /* touch interface does not have the pad device */
2107 if (features->device_type != BTN_TOOL_PEN)
2108 return 1;
2109
2110 for (i = 0; i < 7; i++)
2111 __set_bit(BTN_0 + i, input_dev->keybit);
2112
2113 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2114 break;
2115
2116 case INTUOS4WL:
2117 /*
2118 * For Bluetooth devices, the udev rule does not work correctly
2119 * for pads unless we add a stylus capability, which forces
2120 * ID_INPUT_TABLET to be set.
2121 */
2122 __set_bit(BTN_STYLUS, input_dev->keybit);
2123 /* fall through */
2124
2125 case INTUOS4:
2126 case INTUOS4L:
2127 __set_bit(BTN_7, input_dev->keybit);
2128 __set_bit(BTN_8, input_dev->keybit);
2129 /* fall through */
2130
2131 case INTUOS4S:
2132 for (i = 0; i < 7; i++)
2133 __set_bit(BTN_0 + i, input_dev->keybit);
2134
2135 input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
2136 break;
2137
2138 case CINTIQ_HYBRID:
2139 for (i = 0; i < 9; i++)
2140 __set_bit(BTN_0 + i, input_dev->keybit);
2141
2142 break;
2143
2144 case DTUS:
2145 for (i = 0; i < 4; i++)
2146 __set_bit(BTN_0 + i, input_dev->keybit);
2147 break;
2148
2149 case INTUOSHT:
2150 case BAMBOO_PT:
2151 /* pad device is on the touch interface */
2152 if (features->device_type != BTN_TOOL_FINGER)
2153 return 1;
2154
2155 __clear_bit(ABS_MISC, input_dev->absbit);
2156
2157 __set_bit(BTN_LEFT, input_dev->keybit);
2158 __set_bit(BTN_FORWARD, input_dev->keybit);
2159 __set_bit(BTN_BACK, input_dev->keybit);
2160 __set_bit(BTN_RIGHT, input_dev->keybit);
2161
2162 break;
2163
2164 default:
2165 /* no pad supported */
2166 return 1;
2167 }
2168 return 0;
2169}
2170
2171static const struct wacom_features wacom_features_0x00 =
2172 { "Wacom Penpartner", 5040, 3780, 255, 0,
2173 PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
2174static const struct wacom_features wacom_features_0x10 =
2175 { "Wacom Graphire", 10206, 7422, 511, 63,
2176 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2177static const struct wacom_features wacom_features_0x81 =
2178 { "Wacom Graphire BT", 16704, 12064, 511, 32,
2179 GRAPHIRE_BT, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2180static const struct wacom_features wacom_features_0x11 =
2181 { "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
2182 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2183static const struct wacom_features wacom_features_0x12 =
2184 { "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
2185 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2186static const struct wacom_features wacom_features_0x13 =
2187 { "Wacom Graphire3", 10208, 7424, 511, 63,
2188 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2189static const struct wacom_features wacom_features_0x14 =
2190 { "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
2191 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2192static const struct wacom_features wacom_features_0x15 =
2193 { "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
2194 WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2195static const struct wacom_features wacom_features_0x16 =
2196 { "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
2197 WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2198static const struct wacom_features wacom_features_0x17 =
2199 { "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
2200 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2201static const struct wacom_features wacom_features_0x18 =
2202 { "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
2203 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2204static const struct wacom_features wacom_features_0x19 =
2205 { "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
2206 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
2207static const struct wacom_features wacom_features_0x60 =
2208 { "Wacom Volito", 5104, 3712, 511, 63,
2209 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2210static const struct wacom_features wacom_features_0x61 =
2211 { "Wacom PenStation2", 3250, 2320, 255, 63,
2212 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2213static const struct wacom_features wacom_features_0x62 =
2214 { "Wacom Volito2 4x5", 5104, 3712, 511, 63,
2215 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2216static const struct wacom_features wacom_features_0x63 =
2217 { "Wacom Volito2 2x3", 3248, 2320, 511, 63,
2218 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2219static const struct wacom_features wacom_features_0x64 =
2220 { "Wacom PenPartner2", 3250, 2320, 511, 63,
2221 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
2222static const struct wacom_features wacom_features_0x65 =
2223 { "Wacom Bamboo", 14760, 9225, 511, 63,
2224 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2225static const struct wacom_features wacom_features_0x69 =
2226 { "Wacom Bamboo1", 5104, 3712, 511, 63,
2227 GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
2228static const struct wacom_features wacom_features_0x6A =
2229 { "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
2230 GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2231static const struct wacom_features wacom_features_0x6B =
2232 { "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
2233 GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2234static const struct wacom_features wacom_features_0x20 =
2235 { "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
2236 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2237static const struct wacom_features wacom_features_0x21 =
2238 { "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
2239 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2240static const struct wacom_features wacom_features_0x22 =
2241 { "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
2242 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2243static const struct wacom_features wacom_features_0x23 =
2244 { "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
2245 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2246static const struct wacom_features wacom_features_0x24 =
2247 { "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
2248 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2249static const struct wacom_features wacom_features_0x30 =
2250 { "Wacom PL400", 5408, 4056, 255, 0,
2251 PL, WACOM_PL_RES, WACOM_PL_RES };
2252static const struct wacom_features wacom_features_0x31 =
2253 { "Wacom PL500", 6144, 4608, 255, 0,
2254 PL, WACOM_PL_RES, WACOM_PL_RES };
2255static const struct wacom_features wacom_features_0x32 =
2256 { "Wacom PL600", 6126, 4604, 255, 0,
2257 PL, WACOM_PL_RES, WACOM_PL_RES };
2258static const struct wacom_features wacom_features_0x33 =
2259 { "Wacom PL600SX", 6260, 5016, 255, 0,
2260 PL, WACOM_PL_RES, WACOM_PL_RES };
2261static const struct wacom_features wacom_features_0x34 =
2262 { "Wacom PL550", 6144, 4608, 511, 0,
2263 PL, WACOM_PL_RES, WACOM_PL_RES };
2264static const struct wacom_features wacom_features_0x35 =
2265 { "Wacom PL800", 7220, 5780, 511, 0,
2266 PL, WACOM_PL_RES, WACOM_PL_RES };
2267static const struct wacom_features wacom_features_0x37 =
2268 { "Wacom PL700", 6758, 5406, 511, 0,
2269 PL, WACOM_PL_RES, WACOM_PL_RES };
2270static const struct wacom_features wacom_features_0x38 =
2271 { "Wacom PL510", 6282, 4762, 511, 0,
2272 PL, WACOM_PL_RES, WACOM_PL_RES };
2273static const struct wacom_features wacom_features_0x39 =
2274 { "Wacom DTU710", 34080, 27660, 511, 0,
2275 PL, WACOM_PL_RES, WACOM_PL_RES };
2276static const struct wacom_features wacom_features_0xC4 =
2277 { "Wacom DTF521", 6282, 4762, 511, 0,
2278 PL, WACOM_PL_RES, WACOM_PL_RES };
2279static const struct wacom_features wacom_features_0xC0 =
2280 { "Wacom DTF720", 6858, 5506, 511, 0,
2281 PL, WACOM_PL_RES, WACOM_PL_RES };
2282static const struct wacom_features wacom_features_0xC2 =
2283 { "Wacom DTF720a", 6858, 5506, 511, 0,
2284 PL, WACOM_PL_RES, WACOM_PL_RES };
2285static const struct wacom_features wacom_features_0x03 =
2286 { "Wacom Cintiq Partner", 20480, 15360, 511, 0,
2287 PTU, WACOM_PL_RES, WACOM_PL_RES };
2288static const struct wacom_features wacom_features_0x41 =
2289 { "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
2290 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2291static const struct wacom_features wacom_features_0x42 =
2292 { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
2293 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2294static const struct wacom_features wacom_features_0x43 =
2295 { "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
2296 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2297static const struct wacom_features wacom_features_0x44 =
2298 { "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
2299 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2300static const struct wacom_features wacom_features_0x45 =
2301 { "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
2302 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2303static const struct wacom_features wacom_features_0xB0 =
2304 { "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
2305 INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2306static const struct wacom_features wacom_features_0xB1 =
2307 { "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
2308 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2309static const struct wacom_features wacom_features_0xB2 =
2310 { "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
2311 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2312static const struct wacom_features wacom_features_0xB3 =
2313 { "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
2314 INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2315static const struct wacom_features wacom_features_0xB4 =
2316 { "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
2317 INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2318static const struct wacom_features wacom_features_0xB5 =
2319 { "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
2320 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2321static const struct wacom_features wacom_features_0xB7 =
2322 { "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
2323 INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2324static const struct wacom_features wacom_features_0xB8 =
2325 { "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
2326 INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2327static const struct wacom_features wacom_features_0xB9 =
2328 { "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
2329 INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2330static const struct wacom_features wacom_features_0xBA =
2331 { "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
2332 INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2333static const struct wacom_features wacom_features_0xBB =
2334 { "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
2335 INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2336static const struct wacom_features wacom_features_0xBC =
2337 { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
2338 INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2339static const struct wacom_features wacom_features_0xBD =
2340 { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
2341 INTUOS4WL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2342static const struct wacom_features wacom_features_0x26 =
2343 { "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
2344 INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
2345static const struct wacom_features wacom_features_0x27 =
2346 { "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
2347 INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
2348static const struct wacom_features wacom_features_0x28 =
2349 { "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
2350 INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
2351static const struct wacom_features wacom_features_0x29 =
2352 { "Wacom Intuos5 S", 31496, 19685, 2047, 63,
2353 INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2354static const struct wacom_features wacom_features_0x2A =
2355 { "Wacom Intuos5 M", 44704, 27940, 2047, 63,
2356 INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2357static const struct wacom_features wacom_features_0x314 =
2358 { "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
2359 INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
2360 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2361static const struct wacom_features wacom_features_0x315 =
2362 { "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
2363 INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
2364 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2365static const struct wacom_features wacom_features_0x317 =
2366 { "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
2367 INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
2368 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2369static const struct wacom_features wacom_features_0xF4 =
2370 { "Wacom Cintiq 24HD", 104280, 65400, 2047, 63,
2371 WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2372static const struct wacom_features wacom_features_0xF8 =
2373 { "Wacom Cintiq 24HD touch", 104280, 65400, 2047, 63, /* Pen */
2374 WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2375 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
2376static const struct wacom_features wacom_features_0xF6 =
2377 { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
2378 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
2379 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2380static const struct wacom_features wacom_features_0x3F =
2381 { "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
2382 CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2383static const struct wacom_features wacom_features_0xC5 =
2384 { "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
2385 WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2386static const struct wacom_features wacom_features_0xC6 =
2387 { "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
2388 WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2389static const struct wacom_features wacom_features_0x304 =
2390 { "Wacom Cintiq 13HD", 59352, 33648, 1023, 63,
2391 WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2392static const struct wacom_features wacom_features_0xC7 =
2393 { "Wacom DTU1931", 37832, 30305, 511, 0,
2394 PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2395static const struct wacom_features wacom_features_0xCE =
2396 { "Wacom DTU2231", 47864, 27011, 511, 0,
2397 DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2398 .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
2399static const struct wacom_features wacom_features_0xF0 =
2400 { "Wacom DTU1631", 34623, 19553, 511, 0,
2401 DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2402static const struct wacom_features wacom_features_0xFB =
2403 { "Wacom DTU1031", 22096, 13960, 511, 0,
2404 DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2405static const struct wacom_features wacom_features_0x57 =
2406 { "Wacom DTK2241", 95640, 54060, 2047, 63,
2407 DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2408static const struct wacom_features wacom_features_0x59 = /* Pen */
2409 { "Wacom DTH2242", 95640, 54060, 2047, 63,
2410 DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2411 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
2412static const struct wacom_features wacom_features_0x5D = /* Touch */
2413 { "Wacom DTH2242", .type = WACOM_24HDT,
2414 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
2415 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2416static const struct wacom_features wacom_features_0xCC =
2417 { "Wacom Cintiq 21UX2", 87000, 65400, 2047, 63,
2418 WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2419static const struct wacom_features wacom_features_0xFA =
2420 { "Wacom Cintiq 22HD", 95640, 54060, 2047, 63,
2421 WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2422static const struct wacom_features wacom_features_0x5B =
2423 { "Wacom Cintiq 22HDT", 95640, 54060, 2047, 63,
2424 WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2425 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
2426static const struct wacom_features wacom_features_0x5E =
2427 { "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
2428 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
2429 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2430static const struct wacom_features wacom_features_0x90 =
2431 { "Wacom ISDv4 90", 26202, 16325, 255, 0,
2432 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2433static const struct wacom_features wacom_features_0x93 =
2434 { "Wacom ISDv4 93", 26202, 16325, 255, 0,
2435 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2436static const struct wacom_features wacom_features_0x97 =
2437 { "Wacom ISDv4 97", 26202, 16325, 511, 0,
2438 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2439static const struct wacom_features wacom_features_0x9A =
2440 { "Wacom ISDv4 9A", 26202, 16325, 255, 0,
2441 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2442static const struct wacom_features wacom_features_0x9F =
2443 { "Wacom ISDv4 9F", 26202, 16325, 255, 0,
2444 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2445static const struct wacom_features wacom_features_0xE2 =
2446 { "Wacom ISDv4 E2", 26202, 16325, 255, 0,
2447 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2448static const struct wacom_features wacom_features_0xE3 =
2449 { "Wacom ISDv4 E3", 26202, 16325, 255, 0,
2450 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2451static const struct wacom_features wacom_features_0xE5 =
2452 { "Wacom ISDv4 E5", 26202, 16325, 255, 0,
2453 MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2454static const struct wacom_features wacom_features_0xE6 =
2455 { "Wacom ISDv4 E6", 27760, 15694, 255, 0,
2456 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2457static const struct wacom_features wacom_features_0xEC =
2458 { "Wacom ISDv4 EC", 25710, 14500, 255, 0,
2459 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2460static const struct wacom_features wacom_features_0xED =
2461 { "Wacom ISDv4 ED", 26202, 16325, 255, 0,
2462 TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2463static const struct wacom_features wacom_features_0xEF =
2464 { "Wacom ISDv4 EF", 26202, 16325, 255, 0,
2465 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2466static const struct wacom_features wacom_features_0x100 =
2467 { "Wacom ISDv4 100", 26202, 16325, 255, 0,
2468 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2469static const struct wacom_features wacom_features_0x101 =
2470 { "Wacom ISDv4 101", 26202, 16325, 255, 0,
2471 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2472static const struct wacom_features wacom_features_0x10D =
2473 { "Wacom ISDv4 10D", 26202, 16325, 255, 0,
2474 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2475static const struct wacom_features wacom_features_0x10E =
2476 { "Wacom ISDv4 10E", 27760, 15694, 255, 0,
2477 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2478static const struct wacom_features wacom_features_0x10F =
2479 { "Wacom ISDv4 10F", 27760, 15694, 255, 0,
2480 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2481static const struct wacom_features wacom_features_0x116 =
2482 { "Wacom ISDv4 116", 26202, 16325, 255, 0,
2483 TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2484static const struct wacom_features wacom_features_0x12C =
2485 { "Wacom ISDv4 12C", 27848, 15752, 2047, 0,
2486 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2487static const struct wacom_features wacom_features_0x4001 =
2488 { "Wacom ISDv4 4001", 26202, 16325, 255, 0,
2489 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2490static const struct wacom_features wacom_features_0x4004 =
2491 { "Wacom ISDv4 4004", 11060, 6220, 255, 0,
2492 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2493static const struct wacom_features wacom_features_0x5000 =
2494 { "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
2495 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2496static const struct wacom_features wacom_features_0x5002 =
2497 { "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
2498 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2499static const struct wacom_features wacom_features_0x47 =
2500 { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
2501 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2502static const struct wacom_features wacom_features_0x84 =
2503 { "Wacom Wireless Receiver", 0, 0, 0, 0,
2504 WIRELESS, 0, 0, .touch_max = 16 };
2505static const struct wacom_features wacom_features_0xD0 =
2506 { "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
2507 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2508static const struct wacom_features wacom_features_0xD1 =
2509 { "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
2510 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2511static const struct wacom_features wacom_features_0xD2 =
2512 { "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
2513 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2514static const struct wacom_features wacom_features_0xD3 =
2515 { "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
2516 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2517static const struct wacom_features wacom_features_0xD4 =
2518 { "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
2519 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2520static const struct wacom_features wacom_features_0xD5 =
2521 { "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
2522 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2523static const struct wacom_features wacom_features_0xD6 =
2524 { "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
2525 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2526static const struct wacom_features wacom_features_0xD7 =
2527 { "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
2528 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2529static const struct wacom_features wacom_features_0xD8 =
2530 { "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
2531 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2532static const struct wacom_features wacom_features_0xDA =
2533 { "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
2534 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2535static const struct wacom_features wacom_features_0xDB =
2536 { "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
2537 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2538static const struct wacom_features wacom_features_0xDD =
2539 { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
2540 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2541static const struct wacom_features wacom_features_0xDE =
2542 { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
2543 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
2544static const struct wacom_features wacom_features_0xDF =
2545 { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
2546 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
2547static const struct wacom_features wacom_features_0x300 =
2548 { "Wacom Bamboo One S", 14720, 9225, 1023, 31,
2549 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2550static const struct wacom_features wacom_features_0x301 =
2551 { "Wacom Bamboo One M", 21648, 13530, 1023, 31,
2552 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2553static const struct wacom_features wacom_features_0x302 =
2554 { "Wacom Intuos PT S", 15200, 9500, 1023, 31,
2555 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
2556 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2557static const struct wacom_features wacom_features_0x303 =
2558 { "Wacom Intuos PT M", 21600, 13500, 1023, 31,
2559 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
2560 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2561static const struct wacom_features wacom_features_0x30E =
2562 { "Wacom Intuos S", 15200, 9500, 1023, 31,
2563 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2564 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2565static const struct wacom_features wacom_features_0x6004 =
2566 { "ISD-V4", 12800, 8000, 255, 0,
2567 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2568static const struct wacom_features wacom_features_0x307 =
2569 { "Wacom ISDv5 307", 59352, 33648, 2047, 63,
2570 CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2571 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
2572static const struct wacom_features wacom_features_0x309 =
2573 { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
2574 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
2575 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2576
2577#define USB_DEVICE_WACOM(prod) \
2578 HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
2579 .driver_data = (kernel_ulong_t)&wacom_features_##prod
2580
2581#define BT_DEVICE_WACOM(prod) \
2582 HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
2583 .driver_data = (kernel_ulong_t)&wacom_features_##prod
2584
2585#define USB_DEVICE_LENOVO(prod) \
2586 HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod), \
2587 .driver_data = (kernel_ulong_t)&wacom_features_##prod
2588
2589const struct hid_device_id wacom_ids[] = {
2590 { USB_DEVICE_WACOM(0x00) },
2591 { USB_DEVICE_WACOM(0x03) },
2592 { USB_DEVICE_WACOM(0x10) },
2593 { USB_DEVICE_WACOM(0x11) },
2594 { USB_DEVICE_WACOM(0x12) },
2595 { USB_DEVICE_WACOM(0x13) },
2596 { USB_DEVICE_WACOM(0x14) },
2597 { USB_DEVICE_WACOM(0x15) },
2598 { USB_DEVICE_WACOM(0x16) },
2599 { USB_DEVICE_WACOM(0x17) },
2600 { USB_DEVICE_WACOM(0x18) },
2601 { USB_DEVICE_WACOM(0x19) },
2602 { USB_DEVICE_WACOM(0x20) },
2603 { USB_DEVICE_WACOM(0x21) },
2604 { USB_DEVICE_WACOM(0x22) },
2605 { USB_DEVICE_WACOM(0x23) },
2606 { USB_DEVICE_WACOM(0x24) },
2607 { USB_DEVICE_WACOM(0x26) },
2608 { USB_DEVICE_WACOM(0x27) },
2609 { USB_DEVICE_WACOM(0x28) },
2610 { USB_DEVICE_WACOM(0x29) },
2611 { USB_DEVICE_WACOM(0x2A) },
2612 { USB_DEVICE_WACOM(0x30) },
2613 { USB_DEVICE_WACOM(0x31) },
2614 { USB_DEVICE_WACOM(0x32) },
2615 { USB_DEVICE_WACOM(0x33) },
2616 { USB_DEVICE_WACOM(0x34) },
2617 { USB_DEVICE_WACOM(0x35) },
2618 { USB_DEVICE_WACOM(0x37) },
2619 { USB_DEVICE_WACOM(0x38) },
2620 { USB_DEVICE_WACOM(0x39) },
2621 { USB_DEVICE_WACOM(0x3F) },
2622 { USB_DEVICE_WACOM(0x41) },
2623 { USB_DEVICE_WACOM(0x42) },
2624 { USB_DEVICE_WACOM(0x43) },
2625 { USB_DEVICE_WACOM(0x44) },
2626 { USB_DEVICE_WACOM(0x45) },
2627 { USB_DEVICE_WACOM(0x47) },
2628 { USB_DEVICE_WACOM(0x57) },
2629 { USB_DEVICE_WACOM(0x59) },
2630 { USB_DEVICE_WACOM(0x5B) },
2631 { USB_DEVICE_WACOM(0x5D) },
2632 { USB_DEVICE_WACOM(0x5E) },
2633 { USB_DEVICE_WACOM(0x60) },
2634 { USB_DEVICE_WACOM(0x61) },
2635 { USB_DEVICE_WACOM(0x62) },
2636 { USB_DEVICE_WACOM(0x63) },
2637 { USB_DEVICE_WACOM(0x64) },
2638 { USB_DEVICE_WACOM(0x65) },
2639 { USB_DEVICE_WACOM(0x69) },
2640 { USB_DEVICE_WACOM(0x6A) },
2641 { USB_DEVICE_WACOM(0x6B) },
2642 { BT_DEVICE_WACOM(0x81) },
2643 { USB_DEVICE_WACOM(0x84) },
2644 { USB_DEVICE_WACOM(0x90) },
2645 { USB_DEVICE_WACOM(0x93) },
2646 { USB_DEVICE_WACOM(0x97) },
2647 { USB_DEVICE_WACOM(0x9A) },
2648 { USB_DEVICE_WACOM(0x9F) },
2649 { USB_DEVICE_WACOM(0xB0) },
2650 { USB_DEVICE_WACOM(0xB1) },
2651 { USB_DEVICE_WACOM(0xB2) },
2652 { USB_DEVICE_WACOM(0xB3) },
2653 { USB_DEVICE_WACOM(0xB4) },
2654 { USB_DEVICE_WACOM(0xB5) },
2655 { USB_DEVICE_WACOM(0xB7) },
2656 { USB_DEVICE_WACOM(0xB8) },
2657 { USB_DEVICE_WACOM(0xB9) },
2658 { USB_DEVICE_WACOM(0xBA) },
2659 { USB_DEVICE_WACOM(0xBB) },
2660 { USB_DEVICE_WACOM(0xBC) },
2661 { BT_DEVICE_WACOM(0xBD) },
2662 { USB_DEVICE_WACOM(0xC0) },
2663 { USB_DEVICE_WACOM(0xC2) },
2664 { USB_DEVICE_WACOM(0xC4) },
2665 { USB_DEVICE_WACOM(0xC5) },
2666 { USB_DEVICE_WACOM(0xC6) },
2667 { USB_DEVICE_WACOM(0xC7) },
2668 { USB_DEVICE_WACOM(0xCC) },
2669 { USB_DEVICE_WACOM(0xCE) },
2670 { USB_DEVICE_WACOM(0xD0) },
2671 { USB_DEVICE_WACOM(0xD1) },
2672 { USB_DEVICE_WACOM(0xD2) },
2673 { USB_DEVICE_WACOM(0xD3) },
2674 { USB_DEVICE_WACOM(0xD4) },
2675 { USB_DEVICE_WACOM(0xD5) },
2676 { USB_DEVICE_WACOM(0xD6) },
2677 { USB_DEVICE_WACOM(0xD7) },
2678 { USB_DEVICE_WACOM(0xD8) },
2679 { USB_DEVICE_WACOM(0xDA) },
2680 { USB_DEVICE_WACOM(0xDB) },
2681 { USB_DEVICE_WACOM(0xDD) },
2682 { USB_DEVICE_WACOM(0xDE) },
2683 { USB_DEVICE_WACOM(0xDF) },
2684 { USB_DEVICE_WACOM(0xE2) },
2685 { USB_DEVICE_WACOM(0xE3) },
2686 { USB_DEVICE_WACOM(0xE5) },
2687 { USB_DEVICE_WACOM(0xE6) },
2688 { USB_DEVICE_WACOM(0xEC) },
2689 { USB_DEVICE_WACOM(0xED) },
2690 { USB_DEVICE_WACOM(0xEF) },
2691 { USB_DEVICE_WACOM(0xF0) },
2692 { USB_DEVICE_WACOM(0xF4) },
2693 { USB_DEVICE_WACOM(0xF6) },
2694 { USB_DEVICE_WACOM(0xF8) },
2695 { USB_DEVICE_WACOM(0xFA) },
2696 { USB_DEVICE_WACOM(0xFB) },
2697 { USB_DEVICE_WACOM(0x100) },
2698 { USB_DEVICE_WACOM(0x101) },
2699 { USB_DEVICE_WACOM(0x10D) },
2700 { USB_DEVICE_WACOM(0x10E) },
2701 { USB_DEVICE_WACOM(0x10F) },
2702 { USB_DEVICE_WACOM(0x116) },
2703 { USB_DEVICE_WACOM(0x12C) },
2704 { USB_DEVICE_WACOM(0x300) },
2705 { USB_DEVICE_WACOM(0x301) },
2706 { USB_DEVICE_WACOM(0x302) },
2707 { USB_DEVICE_WACOM(0x303) },
2708 { USB_DEVICE_WACOM(0x304) },
2709 { USB_DEVICE_WACOM(0x307) },
2710 { USB_DEVICE_WACOM(0x309) },
2711 { USB_DEVICE_WACOM(0x30E) },
2712 { USB_DEVICE_WACOM(0x314) },
2713 { USB_DEVICE_WACOM(0x315) },
2714 { USB_DEVICE_WACOM(0x317) },
2715 { USB_DEVICE_WACOM(0x4001) },
2716 { USB_DEVICE_WACOM(0x4004) },
2717 { USB_DEVICE_WACOM(0x5000) },
2718 { USB_DEVICE_WACOM(0x5002) },
2719 { }
2720};
2721MODULE_DEVICE_TABLE(hid, wacom_ids);
diff --git a/drivers/hid/wacom_wac.h b/drivers/hid/wacom_wac.h
new file mode 100644
index 000000000000..339ab5d81a2d
--- /dev/null
+++ b/drivers/hid/wacom_wac.h
@@ -0,0 +1,179 @@
1/*
2 * drivers/input/tablet/wacom_wac.h
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9#ifndef WACOM_WAC_H
10#define WACOM_WAC_H
11
12#include <linux/types.h>
13
14/* maximum packet length for USB devices */
15#define WACOM_PKGLEN_MAX 68
16
17#define WACOM_NAME_MAX 64
18
19/* packet length for individual models */
20#define WACOM_PKGLEN_PENPRTN 7
21#define WACOM_PKGLEN_GRAPHIRE 8
22#define WACOM_PKGLEN_BBFUN 9
23#define WACOM_PKGLEN_INTUOS 10
24#define WACOM_PKGLEN_TPC1FG 5
25#define WACOM_PKGLEN_TPC1FG_B 10
26#define WACOM_PKGLEN_TPC2FG 14
27#define WACOM_PKGLEN_BBTOUCH 20
28#define WACOM_PKGLEN_BBTOUCH3 64
29#define WACOM_PKGLEN_BBPEN 10
30#define WACOM_PKGLEN_WIRELESS 32
31#define WACOM_PKGLEN_MTOUCH 62
32#define WACOM_PKGLEN_MTTPC 40
33#define WACOM_PKGLEN_DTUS 68
34#define WACOM_PKGLEN_PENABLED 8
35
36/* wacom data size per MT contact */
37#define WACOM_BYTES_PER_MT_PACKET 11
38#define WACOM_BYTES_PER_24HDT_PACKET 14
39
40/* device IDs */
41#define STYLUS_DEVICE_ID 0x02
42#define TOUCH_DEVICE_ID 0x03
43#define CURSOR_DEVICE_ID 0x06
44#define ERASER_DEVICE_ID 0x0A
45#define PAD_DEVICE_ID 0x0F
46
47/* wacom data packet report IDs */
48#define WACOM_REPORT_PENABLED 2
49#define WACOM_REPORT_PENABLED_BT 3
50#define WACOM_REPORT_INTUOSREAD 5
51#define WACOM_REPORT_INTUOSWRITE 6
52#define WACOM_REPORT_INTUOSPAD 12
53#define WACOM_REPORT_INTUOS5PAD 3
54#define WACOM_REPORT_DTUSPAD 21
55#define WACOM_REPORT_TPC1FG 6
56#define WACOM_REPORT_TPC2FG 13
57#define WACOM_REPORT_TPCMT 13
58#define WACOM_REPORT_TPCMT2 3
59#define WACOM_REPORT_TPCHID 15
60#define WACOM_REPORT_TPCST 16
61#define WACOM_REPORT_DTUS 17
62#define WACOM_REPORT_TPC1FGE 18
63#define WACOM_REPORT_24HDT 1
64#define WACOM_REPORT_WL 128
65#define WACOM_REPORT_USB 192
66
67/* device quirks */
68#define WACOM_QUIRK_MULTI_INPUT 0x0001
69#define WACOM_QUIRK_BBTOUCH_LOWRES 0x0002
70#define WACOM_QUIRK_NO_INPUT 0x0004
71#define WACOM_QUIRK_MONITOR 0x0008
72#define WACOM_QUIRK_BATTERY 0x0010
73
74enum {
75 PENPARTNER = 0,
76 GRAPHIRE,
77 GRAPHIRE_BT,
78 WACOM_G4,
79 PTU,
80 PL,
81 DTU,
82 DTUS,
83 INTUOS,
84 INTUOS3S,
85 INTUOS3,
86 INTUOS3L,
87 INTUOS4S,
88 INTUOS4,
89 INTUOS4WL,
90 INTUOS4L,
91 INTUOS5S,
92 INTUOS5,
93 INTUOS5L,
94 INTUOSPS,
95 INTUOSPM,
96 INTUOSPL,
97 INTUOSHT,
98 WACOM_21UX2,
99 WACOM_22HD,
100 DTK,
101 WACOM_24HD,
102 CINTIQ_HYBRID,
103 CINTIQ,
104 WACOM_BEE,
105 WACOM_13HD,
106 WACOM_MO,
107 WIRELESS,
108 BAMBOO_PT,
109 WACOM_24HDT,
110 TABLETPC, /* add new TPC below */
111 TABLETPCE,
112 TABLETPC2FG,
113 MTSCREEN,
114 MTTPC,
115 MTTPC_B,
116 MAX_TYPE
117};
118
119struct wacom_features {
120 const char *name;
121 int x_max;
122 int y_max;
123 int pressure_max;
124 int distance_max;
125 int type;
126 int x_resolution;
127 int y_resolution;
128 int x_min;
129 int y_min;
130 int device_type;
131 int x_phy;
132 int y_phy;
133 unsigned unit;
134 int unitExpo;
135 int x_fuzz;
136 int y_fuzz;
137 int pressure_fuzz;
138 int distance_fuzz;
139 unsigned quirks;
140 unsigned touch_max;
141 int oVid;
142 int oPid;
143 int pktlen;
144 bool check_for_hid_type;
145 int hid_type;
146};
147
148struct wacom_shared {
149 bool stylus_in_proximity;
150 bool touch_down;
151 /* for wireless device to access USB interfaces */
152 unsigned touch_max;
153 int type;
154 struct input_dev *touch_input;
155};
156
157struct wacom_wac {
158 char name[WACOM_NAME_MAX];
159 char pad_name[WACOM_NAME_MAX];
160 char bat_name[WACOM_NAME_MAX];
161 char ac_name[WACOM_NAME_MAX];
162 unsigned char data[WACOM_PKGLEN_MAX];
163 int tool[2];
164 int id[2];
165 __u32 serial[2];
166 struct wacom_features features;
167 struct wacom_shared *shared;
168 struct input_dev *input;
169 struct input_dev *pad_input;
170 int pid;
171 int battery_capacity;
172 int num_contacts_left;
173 int bat_charging;
174 int ps_connected;
175 u8 bt_features;
176 u8 bt_high_speed;
177};
178
179#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-10 00:02:07 -0500