aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/ABI/testing/sysfs-driver-wacom70
-rw-r--r--Documentation/devicetree/bindings/input/atmel,maxtouch.txt25
-rw-r--r--Documentation/devicetree/bindings/input/cap1106.txt53
-rw-r--r--Documentation/devicetree/bindings/input/touchscreen/pixcir_i2c_ts.txt26
-rw-r--r--Documentation/devicetree/bindings/input/touchscreen/zforce_ts.txt4
-rw-r--r--Documentation/devicetree/bindings/vendor-prefixes.txt1
-rw-r--r--MAINTAINERS7
-rw-r--r--arch/arm/boot/dts/am437x-gp-evm.dts4
-rw-r--r--arch/arm/boot/dts/am43x-epos-evm.dts4
-rw-r--r--drivers/hid/Kconfig13
-rw-r--r--drivers/hid/Makefile4
-rw-r--r--drivers/hid/hid-core.c12
-rw-r--r--drivers/hid/hid-wacom.c973
-rw-r--r--drivers/hid/wacom.h (renamed from drivers/input/tablet/wacom.h)27
-rw-r--r--drivers/hid/wacom_sys.c (renamed from drivers/input/tablet/wacom_sys.c)1229
-rw-r--r--drivers/hid/wacom_wac.c (renamed from drivers/input/tablet/wacom_wac.c)1176
-rw-r--r--drivers/hid/wacom_wac.h (renamed from drivers/input/tablet/wacom_wac.h)22
-rw-r--r--drivers/input/keyboard/Kconfig10
-rw-r--r--drivers/input/keyboard/Makefile1
-rw-r--r--drivers/input/keyboard/cap1106.c335
-rw-r--r--drivers/input/keyboard/imx_keypad.c6
-rw-r--r--drivers/input/keyboard/max7359_keypad.c45
-rw-r--r--drivers/input/misc/keyspan_remote.c1
-rw-r--r--drivers/input/misc/soc_button_array.c3
-rw-r--r--drivers/input/misc/uinput.c47
-rw-r--r--drivers/input/mouse/alps.c691
-rw-r--r--drivers/input/mouse/alps.h60
-rw-r--r--drivers/input/serio/hyperv-keyboard.c13
-rw-r--r--drivers/input/tablet/Kconfig18
-rw-r--r--drivers/input/tablet/Makefile4
-rw-r--r--drivers/input/tablet/wacom_serial4.c620
-rw-r--r--drivers/input/touchscreen/Kconfig12
-rw-r--r--drivers/input/touchscreen/Makefile1
-rw-r--r--drivers/input/touchscreen/ads7846.c6
-rw-r--r--drivers/input/touchscreen/atmel_mxt_ts.c1313
-rw-r--r--drivers/input/touchscreen/edt-ft5x06.c3
-rw-r--r--drivers/input/touchscreen/ipaq-micro-ts.c166
-rw-r--r--drivers/input/touchscreen/jornada720_ts.c70
-rw-r--r--drivers/input/touchscreen/mcs5000_ts.c6
-rw-r--r--drivers/input/touchscreen/pixcir_i2c_ts.c250
-rw-r--r--drivers/input/touchscreen/s3c2410_ts.c4
-rw-r--r--drivers/input/touchscreen/zforce_ts.c31
-rw-r--r--drivers/platform/chrome/chromeos_laptop.c4
-rw-r--r--include/linux/hid.h5
-rw-r--r--include/linux/i2c/atmel_mxt_ts.h3
-rw-r--r--include/linux/input/pixcir_ts.h12
-rw-r--r--include/uapi/linux/serio.h1
-rw-r--r--include/uapi/linux/uinput.h9
48 files changed, 4515 insertions, 2885 deletions
diff --git a/Documentation/ABI/testing/sysfs-driver-wacom b/Documentation/ABI/testing/sysfs-driver-wacom
index 7fc781048b79..c4f0fed64a6e 100644
--- a/Documentation/ABI/testing/sysfs-driver-wacom
+++ b/Documentation/ABI/testing/sysfs-driver-wacom
@@ -1,48 +1,27 @@
1WWhat: /sys/class/hidraw/hidraw*/device/oled*_img 1What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/speed
2Date: June 2012
3Contact: linux-bluetooth@vger.kernel.org
4Description:
5 The /sys/class/hidraw/hidraw*/device/oled*_img files control
6 OLED mocro displays on Intuos4 Wireless tablet. Accepted image
7 has to contain 256 bytes (64x32 px 1 bit colour). The format
8 is the same as PBM image 62x32px without header (64 bits per
9 horizontal line, 32 lines). An example of setting OLED No. 0:
10 dd bs=256 count=1 if=img_file of=[path to oled0_img]/oled0_img
11 The attribute is read only and no local copy of the image is
12 stored.
13
14What: /sys/class/hidraw/hidraw*/device/speed
15Date: April 2010 2Date: April 2010
16Kernel Version: 2.6.35 3Kernel Version: 2.6.35
17Contact: linux-bluetooth@vger.kernel.org 4Contact: linux-bluetooth@vger.kernel.org
18Description: 5Description:
19 The /sys/class/hidraw/hidraw*/device/speed file controls 6 The /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/speed file
20 reporting speed of Wacom bluetooth tablet. Reading from 7 controls reporting speed of Wacom bluetooth tablet. Reading
21 this file returns 1 if tablet reports in high speed mode 8 from this file returns 1 if tablet reports in high speed mode
22 or 0 otherwise. Writing to this file one of these values 9 or 0 otherwise. Writing to this file one of these values
23 switches reporting speed. 10 switches reporting speed.
24 11
25What: /sys/class/leds/0005\:056A\:00BD.0001\:selector\:*/ 12What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/wacom_led/led
26Date: May 2012 13Date: August 2014
27Kernel Version: 3.5
28Contact: linux-bluetooth@vger.kernel.org
29Description:
30 LED selector for Intuos4 WL. There are 4 leds, but only one LED
31 can be lit at a time. Max brightness is 127.
32
33What: /sys/bus/usb/devices/<busnum>-<devnum>:<cfg>.<intf>/wacom_led/led
34Date: August 2011
35Contact: linux-input@vger.kernel.org 14Contact: linux-input@vger.kernel.org
36Description: 15Description:
37 Attribute group for control of the status LEDs and the OLEDs. 16 Attribute group for control of the status LEDs and the OLEDs.
38 This attribute group is only available for Intuos 4 M, L, 17 This attribute group is only available for Intuos 4 M, L,
39 and XL (with LEDs and OLEDs), Intuos 5 (LEDs only), and Cintiq 18 and XL (with LEDs and OLEDs), Intuos 4 WL, Intuos 5 (LEDs only),
40 21UX2 and Cintiq 24HD (LEDs only). Therefore its presence 19 Intuos Pro (LEDs only) and Cintiq 21UX2 and Cintiq 24HD
41 implicitly signifies the presence of said LEDs and OLEDs on the 20 (LEDs only). Therefore its presence implicitly signifies the
42 tablet device. 21 presence of said LEDs and OLEDs on the tablet device.
43 22
44What: /sys/bus/usb/devices/<busnum>-<devnum>:<cfg>.<intf>/wacom_led/status0_luminance 23What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/wacom_led/status0_luminance
45Date: August 2011 24Date: August 2014
46Contact: linux-input@vger.kernel.org 25Contact: linux-input@vger.kernel.org
47Description: 26Description:
48 Writing to this file sets the status LED luminance (1..127) 27 Writing to this file sets the status LED luminance (1..127)
@@ -50,16 +29,16 @@ Description:
50 button is pressed on the stylus. This luminance level is 29 button is pressed on the stylus. This luminance level is
51 normally lower than the level when a button is pressed. 30 normally lower than the level when a button is pressed.
52 31
53What: /sys/bus/usb/devices/<busnum>-<devnum>:<cfg>.<intf>/wacom_led/status1_luminance 32What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/wacom_led/status1_luminance
54Date: August 2011 33Date: August 2014
55Contact: linux-input@vger.kernel.org 34Contact: linux-input@vger.kernel.org
56Description: 35Description:
57 Writing to this file sets the status LED luminance (1..127) 36 Writing to this file sets the status LED luminance (1..127)
58 when the stylus touches the tablet surface, or any button is 37 when the stylus touches the tablet surface, or any button is
59 pressed on the stylus. 38 pressed on the stylus.
60 39
61What: /sys/bus/usb/devices/<busnum>-<devnum>:<cfg>.<intf>/wacom_led/status_led0_select 40What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/wacom_led/status_led0_select
62Date: August 2011 41Date: August 2014
63Contact: linux-input@vger.kernel.org 42Contact: linux-input@vger.kernel.org
64Description: 43Description:
65 Writing to this file sets which one of the four (for Intuos 4 44 Writing to this file sets which one of the four (for Intuos 4
@@ -67,23 +46,23 @@ Description:
67 24HD) status LEDs is active (0..3). The other three LEDs on the 46 24HD) status LEDs is active (0..3). The other three LEDs on the
68 same side are always inactive. 47 same side are always inactive.
69 48
70What: /sys/bus/usb/devices/<busnum>-<devnum>:<cfg>.<intf>/wacom_led/status_led1_select 49What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/wacom_led/status_led1_select
71Date: September 2011 50Date: August 2014
72Contact: linux-input@vger.kernel.org 51Contact: linux-input@vger.kernel.org
73Description: 52Description:
74 Writing to this file sets which one of the left four (for Cintiq 21UX2 53 Writing to this file sets which one of the left four (for Cintiq 21UX2
75 and Cintiq 24HD) status LEDs is active (0..3). The other three LEDs on 54 and Cintiq 24HD) status LEDs is active (0..3). The other three LEDs on
76 the left are always inactive. 55 the left are always inactive.
77 56
78What: /sys/bus/usb/devices/<busnum>-<devnum>:<cfg>.<intf>/wacom_led/buttons_luminance 57What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/wacom_led/buttons_luminance
79Date: August 2011 58Date: August 2014
80Contact: linux-input@vger.kernel.org 59Contact: linux-input@vger.kernel.org
81Description: 60Description:
82 Writing to this file sets the overall luminance level (0..15) 61 Writing to this file sets the overall luminance level (0..15)
83 of all eight button OLED displays. 62 of all eight button OLED displays.
84 63
85What: /sys/bus/usb/devices/<busnum>-<devnum>:<cfg>.<intf>/wacom_led/button<n>_rawimg 64What: /sys/bus/hid/devices/<bus>:<vid>:<pid>.<n>/wacom_led/button<n>_rawimg
86Date: August 2011 65Date: August 2014
87Contact: linux-input@vger.kernel.org 66Contact: linux-input@vger.kernel.org
88Description: 67Description:
89 When writing a 1024 byte raw image in Wacom Intuos 4 68 When writing a 1024 byte raw image in Wacom Intuos 4
@@ -93,3 +72,8 @@ Description:
93 byte chunk encodes the image data for two consecutive lines on 72 byte chunk encodes the image data for two consecutive lines on
94 the display. The low nibble of each byte contains the first 73 the display. The low nibble of each byte contains the first
95 line, and the high nibble contains the second line. 74 line, and the high nibble contains the second line.
75 When the Wacom Intuos 4 is connected over Bluetooth, the
76 image has to contain 256 bytes (64x32 px 1 bit colour).
77 The format is also scrambled, like in the USB mode, and it can
78 be summarized by converting 76543210 into GECA6420.
79 HGFEDCBA HFDB7531
diff --git a/Documentation/devicetree/bindings/input/atmel,maxtouch.txt b/Documentation/devicetree/bindings/input/atmel,maxtouch.txt
new file mode 100644
index 000000000000..baef432e8369
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/atmel,maxtouch.txt
@@ -0,0 +1,25 @@
1Atmel maXTouch touchscreen/touchpad
2
3Required properties:
4- compatible:
5 atmel,maxtouch
6
7- reg: The I2C address of the device
8
9- interrupts: The sink for the touchpad's IRQ output
10 See ../interrupt-controller/interrupts.txt
11
12Optional properties for main touchpad device:
13
14- linux,gpio-keymap: An array of up to 4 entries indicating the Linux
15 keycode generated by each GPIO. Linux keycodes are defined in
16 <dt-bindings/input/input.h>.
17
18Example:
19
20 touch@4b {
21 compatible = "atmel,maxtouch";
22 reg = <0x4b>;
23 interrupt-parent = <&gpio>;
24 interrupts = <TEGRA_GPIO(W, 3) IRQ_TYPE_LEVEL_LOW>;
25 };
diff --git a/Documentation/devicetree/bindings/input/cap1106.txt b/Documentation/devicetree/bindings/input/cap1106.txt
new file mode 100644
index 000000000000..4b463904cba0
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/cap1106.txt
@@ -0,0 +1,53 @@
1Device tree bindings for Microchip CAP1106, 6 channel capacitive touch sensor
2
3The node for this driver must be a child of a I2C controller node, as the
4device communication via I2C only.
5
6Required properties:
7
8 compatible: Must be "microchip,cap1106"
9
10 reg: The I2C slave address of the device.
11 Only 0x28 is valid.
12
13 interrupts: Property describing the interrupt line the
14 device's ALERT#/CM_IRQ# pin is connected to.
15 The device only has one interrupt source.
16
17Optional properties:
18
19 autorepeat: Enables the Linux input system's autorepeat
20 feature on the input device.
21
22 microchip,sensor-gain: Defines the gain of the sensor circuitry. This
23 effectively controls the sensitivity, as a
24 smaller delta capacitance is required to
25 generate the same delta count values.
26 Valid values are 1, 2, 4, and 8.
27 By default, a gain of 1 is set.
28
29 linux,keycodes: Specifies an array of numeric keycode values to
30 be used for the channels. If this property is
31 omitted, KEY_A, KEY_B, etc are used as
32 defaults. The array must have exactly six
33 entries.
34
35Example:
36
37i2c_controller {
38 cap1106@28 {
39 compatible = "microchip,cap1106";
40 interrupt-parent = <&gpio1>;
41 interrupts = <0 0>;
42 reg = <0x28>;
43 autorepeat;
44 microchip,sensor-gain = <2>;
45
46 linux,keycodes = <103 /* KEY_UP */
47 106 /* KEY_RIGHT */
48 108 /* KEY_DOWN */
49 105 /* KEY_LEFT */
50 109 /* KEY_PAGEDOWN */
51 104>; /* KEY_PAGEUP */
52 };
53}
diff --git a/Documentation/devicetree/bindings/input/touchscreen/pixcir_i2c_ts.txt b/Documentation/devicetree/bindings/input/touchscreen/pixcir_i2c_ts.txt
new file mode 100644
index 000000000000..6e551090f465
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/touchscreen/pixcir_i2c_ts.txt
@@ -0,0 +1,26 @@
1* Pixcir I2C touchscreen controllers
2
3Required properties:
4- compatible: must be "pixcir,pixcir_ts" or "pixcir,pixcir_tangoc"
5- reg: I2C address of the chip
6- interrupts: interrupt to which the chip is connected
7- attb-gpio: GPIO connected to the ATTB line of the chip
8- touchscreen-size-x: horizontal resolution of touchscreen (in pixels)
9- touchscreen-size-y: vertical resolution of touchscreen (in pixels)
10
11Example:
12
13 i2c@00000000 {
14 /* ... */
15
16 pixcir_ts@5c {
17 compatible = "pixcir,pixcir_ts";
18 reg = <0x5c>;
19 interrupts = <2 0>;
20 attb-gpio = <&gpf 2 0 2>;
21 touchscreen-size-x = <800>;
22 touchscreen-size-y = <600>;
23 };
24
25 /* ... */
26 };
diff --git a/Documentation/devicetree/bindings/input/touchscreen/zforce_ts.txt b/Documentation/devicetree/bindings/input/touchscreen/zforce_ts.txt
index 2faf1f1fa39e..80c37df940a7 100644
--- a/Documentation/devicetree/bindings/input/touchscreen/zforce_ts.txt
+++ b/Documentation/devicetree/bindings/input/touchscreen/zforce_ts.txt
@@ -9,6 +9,9 @@ Required properties:
9- x-size: horizontal resolution of touchscreen 9- x-size: horizontal resolution of touchscreen
10- y-size: vertical resolution of touchscreen 10- y-size: vertical resolution of touchscreen
11 11
12Optional properties:
13- vdd-supply: Regulator controlling the controller supply
14
12Example: 15Example:
13 16
14 i2c@00000000 { 17 i2c@00000000 {
@@ -18,6 +21,7 @@ Example:
18 compatible = "neonode,zforce"; 21 compatible = "neonode,zforce";
19 reg = <0x50>; 22 reg = <0x50>;
20 interrupts = <2 0>; 23 interrupts = <2 0>;
24 vdd-supply = <&reg_zforce_vdd>;
21 25
22 gpios = <&gpio5 6 0>, /* INT */ 26 gpios = <&gpio5 6 0>, /* INT */
23 <&gpio5 9 0>; /* RST */ 27 <&gpio5 9 0>; /* RST */
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index 3dc9188ce023..ac7269f90764 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -103,6 +103,7 @@ panasonic Panasonic Corporation
103phytec PHYTEC Messtechnik GmbH 103phytec PHYTEC Messtechnik GmbH
104picochip Picochip Ltd 104picochip Picochip Ltd
105plathome Plat'Home Co., Ltd. 105plathome Plat'Home Co., Ltd.
106pixcir PIXCIR MICROELECTRONICS Co., Ltd
106powervr PowerVR (deprecated, use img) 107powervr PowerVR (deprecated, use img)
107qca Qualcomm Atheros, Inc. 108qca Qualcomm Atheros, Inc.
108qcom Qualcomm Technologies, Inc 109qcom Qualcomm Technologies, Inc
diff --git a/MAINTAINERS b/MAINTAINERS
index 30873e781dfa..3bb6df5d9094 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9877,6 +9877,13 @@ M: Pierre Ossman <pierre@ossman.eu>
9877S: Maintained 9877S: Maintained
9878F: drivers/mmc/host/wbsd.* 9878F: drivers/mmc/host/wbsd.*
9879 9879
9880WACOM PROTOCOL 4 SERIAL TABLETS
9881M: Julian Squires <julian@cipht.net>
9882M: Hans de Goede <hdegoede@redhat.com>
9883L: linux-input@vger.kernel.org
9884S: Maintained
9885F: drivers/input/tablet/wacom_serial4.c
9886
9880WATCHDOG DEVICE DRIVERS 9887WATCHDOG DEVICE DRIVERS
9881M: Wim Van Sebroeck <wim@iguana.be> 9888M: Wim Van Sebroeck <wim@iguana.be>
9882L: linux-watchdog@vger.kernel.org 9889L: linux-watchdog@vger.kernel.org
diff --git a/arch/arm/boot/dts/am437x-gp-evm.dts b/arch/arm/boot/dts/am437x-gp-evm.dts
index f0422c2a7468..646a6eade788 100644
--- a/arch/arm/boot/dts/am437x-gp-evm.dts
+++ b/arch/arm/boot/dts/am437x-gp-evm.dts
@@ -334,8 +334,8 @@
334 334
335 attb-gpio = <&gpio3 22 GPIO_ACTIVE_HIGH>; 335 attb-gpio = <&gpio3 22 GPIO_ACTIVE_HIGH>;
336 336
337 x-size = <1024>; 337 touchscreen-size-x = <1024>;
338 y-size = <600>; 338 touchscreen-size-y = <600>;
339 }; 339 };
340}; 340};
341 341
diff --git a/arch/arm/boot/dts/am43x-epos-evm.dts b/arch/arm/boot/dts/am43x-epos-evm.dts
index f1ee74957512..ed7dd2395915 100644
--- a/arch/arm/boot/dts/am43x-epos-evm.dts
+++ b/arch/arm/boot/dts/am43x-epos-evm.dts
@@ -403,8 +403,8 @@
403 403
404 attb-gpio = <&gpio1 17 GPIO_ACTIVE_HIGH>; 404 attb-gpio = <&gpio1 17 GPIO_ACTIVE_HIGH>;
405 405
406 x-size = <1024>; 406 touchscreen-size-x = <1024>;
407 y-size = <600>; 407 touchscreen-size-y = <600>;
408 }; 408 };
409}; 409};
410 410
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index ec48c823b157..c18d5d71062d 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -764,12 +764,17 @@ config THRUSTMASTER_FF
764 Rumble Force or Force Feedback Wheel. 764 Rumble Force or Force Feedback Wheel.
765 765
766config HID_WACOM 766config HID_WACOM
767 tristate "Wacom Bluetooth devices support" 767 tristate "Wacom Intuos/Graphire tablet support (USB)"
768 depends on HID 768 depends on HID
769 depends on LEDS_CLASS
770 select POWER_SUPPLY 769 select POWER_SUPPLY
771 ---help--- 770 select NEW_LEDS
772 Support for Wacom Graphire Bluetooth and Intuos4 WL tablets. 771 select LEDS_CLASS
772 help
773 Say Y here if you want to use the USB or BT version of the Wacom Intuos
774 or Graphire tablet.
775
776 To compile this driver as a module, choose M here: the
777 module will be called wacom.
773 778
774config HID_WIIMOTE 779config HID_WIIMOTE
775 tristate "Nintendo Wii / Wii U peripherals" 780 tristate "Nintendo Wii / Wii U peripherals"
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index a69f0adb5c76..4dbac7f8530c 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -116,7 +116,9 @@ obj-$(CONFIG_HID_UCLOGIC) += hid-uclogic.o
116obj-$(CONFIG_HID_XINMO) += hid-xinmo.o 116obj-$(CONFIG_HID_XINMO) += hid-xinmo.o
117obj-$(CONFIG_HID_ZEROPLUS) += hid-zpff.o 117obj-$(CONFIG_HID_ZEROPLUS) += hid-zpff.o
118obj-$(CONFIG_HID_ZYDACRON) += hid-zydacron.o 118obj-$(CONFIG_HID_ZYDACRON) += hid-zydacron.o
119obj-$(CONFIG_HID_WACOM) += hid-wacom.o 119
120wacom-objs := wacom_wac.o wacom_sys.o
121obj-$(CONFIG_HID_WACOM) += wacom.o
120obj-$(CONFIG_HID_WALTOP) += hid-waltop.o 122obj-$(CONFIG_HID_WALTOP) += hid-waltop.o
121obj-$(CONFIG_HID_WIIMOTE) += hid-wiimote.o 123obj-$(CONFIG_HID_WIIMOTE) += hid-wiimote.o
122obj-$(CONFIG_HID_SENSOR_HUB) += hid-sensor-hub.o 124obj-$(CONFIG_HID_SENSOR_HUB) += hid-sensor-hub.o
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index b52baa120ffa..12b6e67d9de0 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -789,6 +789,15 @@ static int hid_scan_report(struct hid_device *hid)
789 /* hid-rmi should take care of them, not hid-generic */ 789 /* hid-rmi should take care of them, not hid-generic */
790 hid->group = HID_GROUP_RMI; 790 hid->group = HID_GROUP_RMI;
791 791
792 /*
793 * Vendor specific handlings
794 */
795 switch (hid->vendor) {
796 case USB_VENDOR_ID_WACOM:
797 hid->group = HID_GROUP_WACOM;
798 break;
799 }
800
792 vfree(parser); 801 vfree(parser);
793 return 0; 802 return 0;
794} 803}
@@ -1938,8 +1947,6 @@ static const struct hid_device_id hid_have_special_driver[] = {
1938 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) }, 1947 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
1939 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) }, 1948 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
1940 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) }, 1949 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
1941 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
1942 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },
1943 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) }, 1950 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
1944 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) }, 1951 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
1945 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) }, 1952 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },
@@ -2345,7 +2352,6 @@ static const struct hid_device_id hid_ignore_list[] = {
2345 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) }, 2352 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
2346 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) }, 2353 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
2347 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) }, 2354 { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
2348 { HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },
2349 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) }, 2355 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },
2350 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) }, 2356 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },
2351 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) }, 2357 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },
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/input/tablet/wacom.h b/drivers/hid/wacom.h
index 9ebf0ed3b3b3..64bc1b296d91 100644
--- a/drivers/input/tablet/wacom.h
+++ b/drivers/hid/wacom.h
@@ -12,6 +12,7 @@
12 * Copyright (c) 2001 Frederic Lepied <flepied@mandrakesoft.com> 12 * Copyright (c) 2001 Frederic Lepied <flepied@mandrakesoft.com>
13 * Copyright (c) 2004 Panagiotis Issaris <panagiotis.issaris@mech.kuleuven.ac.be> 13 * Copyright (c) 2004 Panagiotis Issaris <panagiotis.issaris@mech.kuleuven.ac.be>
14 * Copyright (c) 2002-2011 Ping Cheng <pingc@wacom.com> 14 * Copyright (c) 2002-2011 Ping Cheng <pingc@wacom.com>
15 * Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@redhat.com>
15 * 16 *
16 * ChangeLog: 17 * ChangeLog:
17 * v0.1 (vp) - Initial release 18 * v0.1 (vp) - Initial release
@@ -72,6 +73,8 @@
72 * v1.52 (pc) - Query Wacom data upon system resume 73 * v1.52 (pc) - Query Wacom data upon system resume
73 * - add defines for features->type 74 * - add defines for features->type
74 * - add new devices (0x9F, 0xE2, and 0XE3) 75 * - add new devices (0x9F, 0xE2, and 0XE3)
76 * v2.00 (bt) - conversion to a HID driver
77 * - integration of the Bluetooth devices
75 */ 78 */
76 79
77/* 80/*
@@ -93,35 +96,30 @@
93/* 96/*
94 * Version Information 97 * Version Information
95 */ 98 */
96#define DRIVER_VERSION "v1.53" 99#define DRIVER_VERSION "v2.00"
97#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>" 100#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
98#define DRIVER_DESC "USB Wacom tablet driver" 101#define DRIVER_DESC "USB Wacom tablet driver"
99#define DRIVER_LICENSE "GPL" 102#define DRIVER_LICENSE "GPL"
100 103
101MODULE_AUTHOR(DRIVER_AUTHOR);
102MODULE_DESCRIPTION(DRIVER_DESC);
103MODULE_LICENSE(DRIVER_LICENSE);
104
105#define USB_VENDOR_ID_WACOM 0x056a 104#define USB_VENDOR_ID_WACOM 0x056a
106#define USB_VENDOR_ID_LENOVO 0x17ef 105#define USB_VENDOR_ID_LENOVO 0x17ef
107 106
108struct wacom { 107struct wacom {
109 dma_addr_t data_dma;
110 struct usb_device *usbdev; 108 struct usb_device *usbdev;
111 struct usb_interface *intf; 109 struct usb_interface *intf;
112 struct urb *irq;
113 struct wacom_wac wacom_wac; 110 struct wacom_wac wacom_wac;
111 struct hid_device *hdev;
114 struct mutex lock; 112 struct mutex lock;
115 struct work_struct work; 113 struct work_struct work;
116 bool open;
117 char phys[32];
118 struct wacom_led { 114 struct wacom_led {
119 u8 select[2]; /* status led selector (0..3) */ 115 u8 select[2]; /* status led selector (0..3) */
120 u8 llv; /* status led brightness no button (1..127) */ 116 u8 llv; /* status led brightness no button (1..127) */
121 u8 hlv; /* status led brightness button pressed (1..127) */ 117 u8 hlv; /* status led brightness button pressed (1..127) */
122 u8 img_lum; /* OLED matrix display brightness */ 118 u8 img_lum; /* OLED matrix display brightness */
123 } led; 119 } led;
120 bool led_initialized;
124 struct power_supply battery; 121 struct power_supply battery;
122 struct power_supply ac;
125}; 123};
126 124
127static inline void wacom_schedule_work(struct wacom_wac *wacom_wac) 125static inline void wacom_schedule_work(struct wacom_wac *wacom_wac)
@@ -130,10 +128,19 @@ static inline void wacom_schedule_work(struct wacom_wac *wacom_wac)
130 schedule_work(&wacom->work); 128 schedule_work(&wacom->work);
131} 129}
132 130
133extern const struct usb_device_id wacom_ids[]; 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[];
134 139
135void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len); 140void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len);
136void wacom_setup_device_quirks(struct wacom_features *features); 141void wacom_setup_device_quirks(struct wacom_features *features);
137int wacom_setup_input_capabilities(struct input_dev *input_dev, 142int wacom_setup_input_capabilities(struct input_dev *input_dev,
138 struct wacom_wac *wacom_wac); 143 struct wacom_wac *wacom_wac);
144int wacom_setup_pad_input_capabilities(struct input_dev *input_dev,
145 struct wacom_wac *wacom_wac);
139#endif 146#endif
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/hid/wacom_sys.c
index 2c613cd41dd6..3e388ec31da8 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/hid/wacom_sys.c
@@ -13,246 +13,106 @@
13 13
14#include "wacom_wac.h" 14#include "wacom_wac.h"
15#include "wacom.h" 15#include "wacom.h"
16#include <linux/hid.h>
16 17
17/* defines to get HID report descriptor */
18#define HID_DEVICET_HID (USB_TYPE_CLASS | 0x01)
19#define HID_DEVICET_REPORT (USB_TYPE_CLASS | 0x02)
20#define HID_USAGE_UNDEFINED 0x00
21#define HID_USAGE_PAGE 0x05
22#define HID_USAGE_PAGE_DIGITIZER 0x0d
23#define HID_USAGE_PAGE_DESKTOP 0x01
24#define HID_USAGE 0x09
25#define HID_USAGE_X ((HID_USAGE_PAGE_DESKTOP << 16) | 0x30)
26#define HID_USAGE_Y ((HID_USAGE_PAGE_DESKTOP << 16) | 0x31)
27#define HID_USAGE_PRESSURE ((HID_USAGE_PAGE_DIGITIZER << 16) | 0x30)
28#define HID_USAGE_X_TILT ((HID_USAGE_PAGE_DIGITIZER << 16) | 0x3d)
29#define HID_USAGE_Y_TILT ((HID_USAGE_PAGE_DIGITIZER << 16) | 0x3e)
30#define HID_USAGE_FINGER ((HID_USAGE_PAGE_DIGITIZER << 16) | 0x22)
31#define HID_USAGE_STYLUS ((HID_USAGE_PAGE_DIGITIZER << 16) | 0x20)
32#define HID_USAGE_CONTACTMAX ((HID_USAGE_PAGE_DIGITIZER << 16) | 0x55)
33#define HID_COLLECTION 0xa1
34#define HID_COLLECTION_LOGICAL 0x02
35#define HID_COLLECTION_END 0xc0
36
37struct hid_descriptor {
38 struct usb_descriptor_header header;
39 __le16 bcdHID;
40 u8 bCountryCode;
41 u8 bNumDescriptors;
42 u8 bDescriptorType;
43 __le16 wDescriptorLength;
44} __attribute__ ((packed));
45
46/* defines to get/set USB message */
47#define USB_REQ_GET_REPORT 0x01
48#define USB_REQ_SET_REPORT 0x09
49
50#define WAC_HID_FEATURE_REPORT 0x03
51#define WAC_MSG_RETRIES 5 18#define WAC_MSG_RETRIES 5
52 19
53#define WAC_CMD_LED_CONTROL 0x20 20#define WAC_CMD_LED_CONTROL 0x20
54#define WAC_CMD_ICON_START 0x21 21#define WAC_CMD_ICON_START 0x21
55#define WAC_CMD_ICON_XFER 0x23 22#define WAC_CMD_ICON_XFER 0x23
23#define WAC_CMD_ICON_BT_XFER 0x26
56#define WAC_CMD_RETRIES 10 24#define WAC_CMD_RETRIES 10
57 25
58static int wacom_get_report(struct usb_interface *intf, u8 type, u8 id, 26static int wacom_get_report(struct hid_device *hdev, u8 type, u8 id,
59 void *buf, size_t size, unsigned int retries) 27 void *buf, size_t size, unsigned int retries)
60{ 28{
61 struct usb_device *dev = interface_to_usbdev(intf);
62 int retval; 29 int retval;
63 30
64 do { 31 do {
65 retval = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 32 retval = hid_hw_raw_request(hdev, id, buf, size, type,
66 USB_REQ_GET_REPORT, 33 HID_REQ_GET_REPORT);
67 USB_DIR_IN | USB_TYPE_CLASS |
68 USB_RECIP_INTERFACE,
69 (type << 8) + id,
70 intf->altsetting[0].desc.bInterfaceNumber,
71 buf, size, 100);
72 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries); 34 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
73 35
74 return retval; 36 return retval;
75} 37}
76 38
77static int wacom_set_report(struct usb_interface *intf, u8 type, u8 id, 39static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf,
78 void *buf, size_t size, unsigned int retries) 40 size_t size, unsigned int retries)
79{ 41{
80 struct usb_device *dev = interface_to_usbdev(intf);
81 int retval; 42 int retval;
82 43
83 do { 44 do {
84 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 45 retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
85 USB_REQ_SET_REPORT, 46 HID_REQ_SET_REPORT);
86 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
87 (type << 8) + id,
88 intf->altsetting[0].desc.bInterfaceNumber,
89 buf, size, 1000);
90 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries); 47 } while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
91 48
92 return retval; 49 return retval;
93} 50}
94 51
95static void wacom_sys_irq(struct urb *urb) 52static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
53 u8 *raw_data, int size)
96{ 54{
97 struct wacom *wacom = urb->context; 55 struct wacom *wacom = hid_get_drvdata(hdev);
98 struct device *dev = &wacom->intf->dev;
99 int retval;
100 56
101 switch (urb->status) { 57 if (size > WACOM_PKGLEN_MAX)
102 case 0: 58 return 1;
103 /* success */ 59
104 break; 60 memcpy(wacom->wacom_wac.data, raw_data, size);
105 case -ECONNRESET:
106 case -ENOENT:
107 case -ESHUTDOWN:
108 /* this urb is terminated, clean up */
109 dev_dbg(dev, "%s - urb shutting down with status: %d\n",
110 __func__, urb->status);
111 return;
112 default:
113 dev_dbg(dev, "%s - nonzero urb status received: %d\n",
114 __func__, urb->status);
115 goto exit;
116 }
117 61
118 wacom_wac_irq(&wacom->wacom_wac, urb->actual_length); 62 wacom_wac_irq(&wacom->wacom_wac, size);
119 63
120 exit: 64 return 0;
121 usb_mark_last_busy(wacom->usbdev);
122 retval = usb_submit_urb(urb, GFP_ATOMIC);
123 if (retval)
124 dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
125 __func__, retval);
126} 65}
127 66
128static int wacom_open(struct input_dev *dev) 67static int wacom_open(struct input_dev *dev)
129{ 68{
130 struct wacom *wacom = input_get_drvdata(dev); 69 struct wacom *wacom = input_get_drvdata(dev);
131 int retval = 0; 70 int retval;
132
133 if (usb_autopm_get_interface(wacom->intf) < 0)
134 return -EIO;
135 71
136 mutex_lock(&wacom->lock); 72 mutex_lock(&wacom->lock);
137 73 retval = hid_hw_open(wacom->hdev);
138 if (usb_submit_urb(wacom->irq, GFP_KERNEL)) {
139 retval = -EIO;
140 goto out;
141 }
142
143 wacom->open = true;
144 wacom->intf->needs_remote_wakeup = 1;
145
146out:
147 mutex_unlock(&wacom->lock); 74 mutex_unlock(&wacom->lock);
148 usb_autopm_put_interface(wacom->intf); 75
149 return retval; 76 return retval;
150} 77}
151 78
152static void wacom_close(struct input_dev *dev) 79static void wacom_close(struct input_dev *dev)
153{ 80{
154 struct wacom *wacom = input_get_drvdata(dev); 81 struct wacom *wacom = input_get_drvdata(dev);
155 int autopm_error;
156
157 autopm_error = usb_autopm_get_interface(wacom->intf);
158 82
159 mutex_lock(&wacom->lock); 83 mutex_lock(&wacom->lock);
160 usb_kill_urb(wacom->irq); 84 hid_hw_close(wacom->hdev);
161 wacom->open = false;
162 wacom->intf->needs_remote_wakeup = 0;
163 mutex_unlock(&wacom->lock); 85 mutex_unlock(&wacom->lock);
164
165 if (!autopm_error)
166 usb_autopm_put_interface(wacom->intf);
167} 86}
168 87
169/* 88/*
170 * Calculate the resolution of the X or Y axis, given appropriate HID data. 89 * Calculate the resolution of the X or Y axis using hidinput_calc_abs_res.
171 * This function is little more than hidinput_calc_abs_res stripped down.
172 */ 90 */
173static int wacom_calc_hid_res(int logical_extents, int physical_extents, 91static int wacom_calc_hid_res(int logical_extents, int physical_extents,
174 unsigned char unit, unsigned char exponent) 92 unsigned unit, int exponent)
175{
176 int prev, unit_exponent;
177
178 /* Check if the extents are sane */
179 if (logical_extents <= 0 || physical_extents <= 0)
180 return 0;
181
182 /* Get signed value of nybble-sized twos-compliment exponent */
183 unit_exponent = exponent;
184 if (unit_exponent > 7)
185 unit_exponent -= 16;
186
187 /* Convert physical_extents to millimeters */
188 if (unit == 0x11) { /* If centimeters */
189 unit_exponent += 1;
190 } else if (unit == 0x13) { /* If inches */
191 prev = physical_extents;
192 physical_extents *= 254;
193 if (physical_extents < prev)
194 return 0;
195 unit_exponent -= 1;
196 } else {
197 return 0;
198 }
199
200 /* Apply negative unit exponent */
201 for (; unit_exponent < 0; unit_exponent++) {
202 prev = logical_extents;
203 logical_extents *= 10;
204 if (logical_extents < prev)
205 return 0;
206 }
207 /* Apply positive unit exponent */
208 for (; unit_exponent > 0; unit_exponent--) {
209 prev = physical_extents;
210 physical_extents *= 10;
211 if (physical_extents < prev)
212 return 0;
213 }
214
215 /* Calculate resolution */
216 return logical_extents / physical_extents;
217}
218
219static int wacom_parse_logical_collection(unsigned char *report,
220 struct wacom_features *features)
221{ 93{
222 int length = 0; 94 struct hid_field field = {
223 95 .logical_maximum = logical_extents,
224 if (features->type == BAMBOO_PT) { 96 .physical_maximum = physical_extents,
225 97 .unit = unit,
226 /* Logical collection is only used by 3rd gen Bamboo Touch */ 98 .unit_exponent = exponent,
227 features->pktlen = WACOM_PKGLEN_BBTOUCH3; 99 };
228 features->device_type = BTN_TOOL_FINGER; 100
229 101 return hidinput_calc_abs_res(&field, ABS_X);
230 features->x_max = features->y_max =
231 get_unaligned_le16(&report[10]);
232
233 length = 11;
234 }
235 return length;
236} 102}
237 103
238static void wacom_retrieve_report_data(struct usb_interface *intf, 104static void wacom_feature_mapping(struct hid_device *hdev,
239 struct wacom_features *features) 105 struct hid_field *field, struct hid_usage *usage)
240{ 106{
241 int result = 0; 107 struct wacom *wacom = hid_get_drvdata(hdev);
242 unsigned char *rep_data; 108 struct wacom_features *features = &wacom->wacom_wac.features;
243
244 rep_data = kmalloc(2, GFP_KERNEL);
245 if (rep_data) {
246
247 rep_data[0] = 12;
248 result = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
249 rep_data[0], rep_data, 2,
250 WAC_MSG_RETRIES);
251
252 if (result >= 0 && rep_data[1] > 2)
253 features->touch_max = rep_data[1];
254 109
255 kfree(rep_data); 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;
256 } 116 }
257} 117}
258 118
@@ -285,243 +145,100 @@ static void wacom_retrieve_report_data(struct usb_interface *intf,
285 * interfaces haven't supported pressure or distance, this is enough 145 * interfaces haven't supported pressure or distance, this is enough
286 * information to override invalid values in the wacom_features table. 146 * information to override invalid values in the wacom_features table.
287 * 147 *
288 * 3rd gen Bamboo Touch no longer define a Digitizer-Finger Pysical 148 * Intuos5 touch interface and 3rd gen Bamboo Touch do not contain useful
289 * Collection. Instead they define a Logical Collection with a single 149 * data. We deal with them after returning from this function.
290 * Logical Maximum for both X and Y.
291 *
292 * Intuos5 touch interface does not contain useful data. We deal with
293 * this after returning from this function.
294 */ 150 */
295static int wacom_parse_hid(struct usb_interface *intf, 151static void wacom_usage_mapping(struct hid_device *hdev,
296 struct hid_descriptor *hid_desc, 152 struct hid_field *field, struct hid_usage *usage)
297 struct wacom_features *features)
298{ 153{
299 struct usb_device *dev = interface_to_usbdev(intf); 154 struct wacom *wacom = hid_get_drvdata(hdev);
300 char limit = 0; 155 struct wacom_features *features = &wacom->wacom_wac.features;
301 /* result has to be defined as int for some devices */ 156 bool finger = (field->logical == HID_DG_FINGER) ||
302 int result = 0, touch_max = 0; 157 (field->physical == HID_DG_FINGER);
303 int i = 0, page = 0, finger = 0, pen = 0; 158 bool pen = (field->logical == HID_DG_STYLUS) ||
304 unsigned char *report; 159 (field->physical == HID_DG_STYLUS);
305
306 report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
307 if (!report)
308 return -ENOMEM;
309
310 /* retrive report descriptors */
311 do {
312 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
313 USB_REQ_GET_DESCRIPTOR,
314 USB_RECIP_INTERFACE | USB_DIR_IN,
315 HID_DEVICET_REPORT << 8,
316 intf->altsetting[0].desc.bInterfaceNumber, /* interface */
317 report,
318 hid_desc->wDescriptorLength,
319 5000); /* 5 secs */
320 } while (result < 0 && limit++ < WAC_MSG_RETRIES);
321
322 /* No need to parse the Descriptor. It isn't an error though */
323 if (result < 0)
324 goto out;
325
326 for (i = 0; i < hid_desc->wDescriptorLength; i++) {
327
328 switch (report[i]) {
329 case HID_USAGE_PAGE:
330 page = report[i + 1];
331 i++;
332 break;
333
334 case HID_USAGE:
335 switch (page << 16 | report[i + 1]) {
336 case HID_USAGE_X:
337 if (finger) {
338 features->device_type = BTN_TOOL_FINGER;
339 /* touch device at least supports one touch point */
340 touch_max = 1;
341 switch (features->type) {
342 case TABLETPC2FG:
343 features->pktlen = WACOM_PKGLEN_TPC2FG;
344 break;
345
346 case MTSCREEN:
347 case WACOM_24HDT:
348 features->pktlen = WACOM_PKGLEN_MTOUCH;
349 break;
350
351 case MTTPC:
352 case MTTPC_B:
353 features->pktlen = WACOM_PKGLEN_MTTPC;
354 break;
355
356 case BAMBOO_PT:
357 features->pktlen = WACOM_PKGLEN_BBTOUCH;
358 break;
359
360 default:
361 features->pktlen = WACOM_PKGLEN_GRAPHIRE;
362 break;
363 }
364
365 switch (features->type) {
366 case BAMBOO_PT:
367 features->x_phy =
368 get_unaligned_le16(&report[i + 5]);
369 features->x_max =
370 get_unaligned_le16(&report[i + 8]);
371 i += 15;
372 break;
373
374 case WACOM_24HDT:
375 features->x_max =
376 get_unaligned_le16(&report[i + 3]);
377 features->x_phy =
378 get_unaligned_le16(&report[i + 8]);
379 features->unit = report[i - 1];
380 features->unitExpo = report[i - 3];
381 i += 12;
382 break;
383
384 case MTTPC_B:
385 features->x_max =
386 get_unaligned_le16(&report[i + 3]);
387 features->x_phy =
388 get_unaligned_le16(&report[i + 6]);
389 features->unit = report[i - 5];
390 features->unitExpo = report[i - 3];
391 i += 9;
392 break;
393
394 default:
395 features->x_max =
396 get_unaligned_le16(&report[i + 3]);
397 features->x_phy =
398 get_unaligned_le16(&report[i + 6]);
399 features->unit = report[i + 9];
400 features->unitExpo = report[i + 11];
401 i += 12;
402 break;
403 }
404 } else if (pen) {
405 /* penabled only accepts exact bytes of data */
406 if (features->type >= TABLETPC)
407 features->pktlen = WACOM_PKGLEN_GRAPHIRE;
408 features->device_type = BTN_TOOL_PEN;
409 features->x_max =
410 get_unaligned_le16(&report[i + 3]);
411 i += 4;
412 }
413 break;
414
415 case HID_USAGE_Y:
416 if (finger) {
417 switch (features->type) {
418 case TABLETPC2FG:
419 case MTSCREEN:
420 case MTTPC:
421 features->y_max =
422 get_unaligned_le16(&report[i + 3]);
423 features->y_phy =
424 get_unaligned_le16(&report[i + 6]);
425 i += 7;
426 break;
427
428 case WACOM_24HDT:
429 features->y_max =
430 get_unaligned_le16(&report[i + 3]);
431 features->y_phy =
432 get_unaligned_le16(&report[i - 2]);
433 i += 7;
434 break;
435
436 case BAMBOO_PT:
437 features->y_phy =
438 get_unaligned_le16(&report[i + 3]);
439 features->y_max =
440 get_unaligned_le16(&report[i + 6]);
441 i += 12;
442 break;
443
444 case MTTPC_B:
445 features->y_max =
446 get_unaligned_le16(&report[i + 3]);
447 features->y_phy =
448 get_unaligned_le16(&report[i + 6]);
449 i += 9;
450 break;
451
452 default:
453 features->y_max =
454 features->x_max;
455 features->y_phy =
456 get_unaligned_le16(&report[i + 3]);
457 i += 4;
458 break;
459 }
460 } else if (pen) {
461 features->y_max =
462 get_unaligned_le16(&report[i + 3]);
463 i += 4;
464 }
465 break;
466
467 case HID_USAGE_FINGER:
468 finger = 1;
469 i++;
470 break;
471 160
472 /* 161 /*
473 * Requiring Stylus Usage will ignore boot mouse 162 * Requiring Stylus Usage will ignore boot mouse
474 * X/Y values and some cases of invalid Digitizer X/Y 163 * X/Y values and some cases of invalid Digitizer X/Y
475 * values commonly reported. 164 * values commonly reported.
476 */ 165 */
477 case HID_USAGE_STYLUS: 166 if (!pen && !finger)
478 pen = 1; 167 return;
479 i++;
480 break;
481 168
482 case HID_USAGE_CONTACTMAX: 169 if (finger && !features->touch_max)
483 /* leave touch_max as is if predefined */ 170 /* touch device at least supports one touch point */
484 if (!features->touch_max) 171 features->touch_max = 1;
485 wacom_retrieve_report_data(intf, features);
486 i++;
487 break;
488 172
489 case HID_USAGE_PRESSURE: 173 switch (usage->hid) {
490 if (pen) { 174 case HID_GD_X:
491 features->pressure_max = 175 features->x_max = field->logical_maximum;
492 get_unaligned_le16(&report[i + 3]); 176 if (finger) {
493 i += 4; 177 features->device_type = BTN_TOOL_FINGER;
494 } 178 features->x_phy = field->physical_maximum;
495 break; 179 if (features->type != BAMBOO_PT) {
180 features->unit = field->unit;
181 features->unitExpo = field->unit_exponent;
496 } 182 }
497 break; 183 } else {
498 184 features->device_type = BTN_TOOL_PEN;
499 case HID_COLLECTION_END: 185 }
500 /* reset UsagePage and Finger */ 186 break;
501 finger = page = 0; 187 case HID_GD_Y:
502 break; 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}
503 203
504 case HID_COLLECTION: 204static void wacom_parse_hid(struct hid_device *hdev,
505 i++; 205 struct wacom_features *features)
506 switch (report[i]) { 206{
507 case HID_COLLECTION_LOGICAL: 207 struct hid_report_enum *rep_enum;
508 i += wacom_parse_logical_collection(&report[i], 208 struct hid_report *hreport;
509 features); 209 int i, j;
510 break; 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);
511 } 222 }
512 break;
513 } 223 }
514 } 224 }
515 225
516 out: 226 /* now check the input usages */
517 if (!features->touch_max && touch_max) 227 rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
518 features->touch_max = touch_max; 228 list_for_each_entry(hreport, &rep_enum->report_list, list) {
519 result = 0; 229
520 kfree(report); 230 if (!hreport->maxfield)
521 return result; 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 }
522} 238}
523 239
524static int wacom_set_device_mode(struct usb_interface *intf, int report_id, int length, int mode) 240static int wacom_set_device_mode(struct hid_device *hdev, int report_id,
241 int length, int mode)
525{ 242{
526 unsigned char *rep_data; 243 unsigned char *rep_data;
527 int error = -ENOMEM, limit = 0; 244 int error = -ENOMEM, limit = 0;
@@ -534,8 +251,11 @@ static int wacom_set_device_mode(struct usb_interface *intf, int report_id, int
534 rep_data[0] = report_id; 251 rep_data[0] = report_id;
535 rep_data[1] = mode; 252 rep_data[1] = mode;
536 253
537 error = wacom_set_report(intf, WAC_HID_FEATURE_REPORT, 254 error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
538 report_id, rep_data, length, 1); 255 length, 1);
256 if (error >= 0)
257 error = wacom_get_report(hdev, HID_FEATURE_REPORT,
258 report_id, rep_data, length, 1);
539 } while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES); 259 } while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);
540 260
541 kfree(rep_data); 261 kfree(rep_data);
@@ -543,6 +263,59 @@ static int wacom_set_device_mode(struct usb_interface *intf, int report_id, int
543 return error < 0 ? error : 0; 263 return error < 0 ? error : 0;
544} 264}
545 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
546/* 319/*
547 * Switch the tablet into its most-capable mode. Wacom tablets are 320 * Switch the tablet into its most-capable mode. Wacom tablets are
548 * typically configured to power-up in a mode which sends mouse-like 321 * typically configured to power-up in a mode which sends mouse-like
@@ -550,31 +323,34 @@ static int wacom_set_device_mode(struct usb_interface *intf, int report_id, int
550 * from the tablet, it is necessary to switch the tablet out of this 323 * from the tablet, it is necessary to switch the tablet out of this
551 * mode and into one which sends the full range of tablet data. 324 * mode and into one which sends the full range of tablet data.
552 */ 325 */
553static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_features *features) 326static int wacom_query_tablet_data(struct hid_device *hdev,
327 struct wacom_features *features)
554{ 328{
329 if (hdev->bus == BUS_BLUETOOTH)
330 return wacom_bt_query_tablet_data(hdev, 1, features);
331
555 if (features->device_type == BTN_TOOL_FINGER) { 332 if (features->device_type == BTN_TOOL_FINGER) {
556 if (features->type > TABLETPC) { 333 if (features->type > TABLETPC) {
557 /* MT Tablet PC touch */ 334 /* MT Tablet PC touch */
558 return wacom_set_device_mode(intf, 3, 4, 4); 335 return wacom_set_device_mode(hdev, 3, 4, 4);
559 } 336 }
560 else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) { 337 else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
561 return wacom_set_device_mode(intf, 18, 3, 2); 338 return wacom_set_device_mode(hdev, 18, 3, 2);
562 } 339 }
563 } else if (features->device_type == BTN_TOOL_PEN) { 340 } else if (features->device_type == BTN_TOOL_PEN) {
564 if (features->type <= BAMBOO_PT && features->type != WIRELESS) { 341 if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
565 return wacom_set_device_mode(intf, 2, 2, 2); 342 return wacom_set_device_mode(hdev, 2, 2, 2);
566 } 343 }
567 } 344 }
568 345
569 return 0; 346 return 0;
570} 347}
571 348
572static int wacom_retrieve_hid_descriptor(struct usb_interface *intf, 349static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
573 struct wacom_features *features) 350 struct wacom_features *features)
574{ 351{
575 int error = 0; 352 struct wacom *wacom = hid_get_drvdata(hdev);
576 struct usb_host_interface *interface = intf->cur_altsetting; 353 struct usb_interface *intf = wacom->intf;
577 struct hid_descriptor *hid_desc;
578 354
579 /* default features */ 355 /* default features */
580 features->device_type = BTN_TOOL_PEN; 356 features->device_type = BTN_TOOL_PEN;
@@ -599,66 +375,54 @@ static int wacom_retrieve_hid_descriptor(struct usb_interface *intf,
599 } 375 }
600 376
601 /* only devices that support touch need to retrieve the info */ 377 /* only devices that support touch need to retrieve the info */
602 if (features->type < BAMBOO_PT) { 378 if (features->type < BAMBOO_PT)
603 goto out; 379 return;
604 }
605
606 error = usb_get_extra_descriptor(interface, HID_DEVICET_HID, &hid_desc);
607 if (error) {
608 error = usb_get_extra_descriptor(&interface->endpoint[0],
609 HID_DEVICET_REPORT, &hid_desc);
610 if (error) {
611 dev_err(&intf->dev,
612 "can not retrieve extra class descriptor\n");
613 goto out;
614 }
615 }
616 error = wacom_parse_hid(intf, hid_desc, features);
617 380
618 out: 381 wacom_parse_hid(hdev, features);
619 return error;
620} 382}
621 383
622struct wacom_usbdev_data { 384struct wacom_hdev_data {
623 struct list_head list; 385 struct list_head list;
624 struct kref kref; 386 struct kref kref;
625 struct usb_device *dev; 387 struct hid_device *dev;
626 struct wacom_shared shared; 388 struct wacom_shared shared;
627}; 389};
628 390
629static LIST_HEAD(wacom_udev_list); 391static LIST_HEAD(wacom_udev_list);
630static DEFINE_MUTEX(wacom_udev_list_lock); 392static DEFINE_MUTEX(wacom_udev_list_lock);
631 393
632static struct usb_device *wacom_get_sibling(struct usb_device *dev, int vendor, int product) 394static bool wacom_are_sibling(struct hid_device *hdev,
395 struct hid_device *sibling)
633{ 396{
634 int port1; 397 struct wacom *wacom = hid_get_drvdata(hdev);
635 struct usb_device *sibling; 398 struct wacom_features *features = &wacom->wacom_wac.features;
636 399 int vid = features->oVid;
637 if (vendor == 0 && product == 0) 400 int pid = features->oPid;
638 return dev; 401 int n1,n2;
639 402
640 if (dev->parent == NULL) 403 if (vid == 0 && pid == 0) {
641 return NULL; 404 vid = hdev->vendor;
405 pid = hdev->product;
406 }
642 407
643 usb_hub_for_each_child(dev->parent, port1, sibling) { 408 if (vid != sibling->vendor || pid != sibling->product)
644 struct usb_device_descriptor *d; 409 return false;
645 if (sibling == NULL)
646 continue;
647 410
648 d = &sibling->descriptor; 411 /* Compare the physical path. */
649 if (d->idVendor == vendor && d->idProduct == product) 412 n1 = strrchr(hdev->phys, '.') - hdev->phys;
650 return sibling; 413 n2 = strrchr(sibling->phys, '.') - sibling->phys;
651 } 414 if (n1 != n2 || n1 <= 0 || n2 <= 0)
415 return false;
652 416
653 return NULL; 417 return !strncmp(hdev->phys, sibling->phys, n1);
654} 418}
655 419
656static struct wacom_usbdev_data *wacom_get_usbdev_data(struct usb_device *dev) 420static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
657{ 421{
658 struct wacom_usbdev_data *data; 422 struct wacom_hdev_data *data;
659 423
660 list_for_each_entry(data, &wacom_udev_list, list) { 424 list_for_each_entry(data, &wacom_udev_list, list) {
661 if (data->dev == dev) { 425 if (wacom_are_sibling(hdev, data->dev)) {
662 kref_get(&data->kref); 426 kref_get(&data->kref);
663 return data; 427 return data;
664 } 428 }
@@ -667,28 +431,29 @@ static struct wacom_usbdev_data *wacom_get_usbdev_data(struct usb_device *dev)
667 return NULL; 431 return NULL;
668} 432}
669 433
670static int wacom_add_shared_data(struct wacom_wac *wacom, 434static int wacom_add_shared_data(struct hid_device *hdev)
671 struct usb_device *dev)
672{ 435{
673 struct wacom_usbdev_data *data; 436 struct wacom *wacom = hid_get_drvdata(hdev);
437 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
438 struct wacom_hdev_data *data;
674 int retval = 0; 439 int retval = 0;
675 440
676 mutex_lock(&wacom_udev_list_lock); 441 mutex_lock(&wacom_udev_list_lock);
677 442
678 data = wacom_get_usbdev_data(dev); 443 data = wacom_get_hdev_data(hdev);
679 if (!data) { 444 if (!data) {
680 data = kzalloc(sizeof(struct wacom_usbdev_data), GFP_KERNEL); 445 data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
681 if (!data) { 446 if (!data) {
682 retval = -ENOMEM; 447 retval = -ENOMEM;
683 goto out; 448 goto out;
684 } 449 }
685 450
686 kref_init(&data->kref); 451 kref_init(&data->kref);
687 data->dev = dev; 452 data->dev = hdev;
688 list_add_tail(&data->list, &wacom_udev_list); 453 list_add_tail(&data->list, &wacom_udev_list);
689 } 454 }
690 455
691 wacom->shared = &data->shared; 456 wacom_wac->shared = &data->shared;
692 457
693out: 458out:
694 mutex_unlock(&wacom_udev_list_lock); 459 mutex_unlock(&wacom_udev_list_lock);
@@ -697,8 +462,8 @@ out:
697 462
698static void wacom_release_shared_data(struct kref *kref) 463static void wacom_release_shared_data(struct kref *kref)
699{ 464{
700 struct wacom_usbdev_data *data = 465 struct wacom_hdev_data *data =
701 container_of(kref, struct wacom_usbdev_data, kref); 466 container_of(kref, struct wacom_hdev_data, kref);
702 467
703 mutex_lock(&wacom_udev_list_lock); 468 mutex_lock(&wacom_udev_list_lock);
704 list_del(&data->list); 469 list_del(&data->list);
@@ -709,10 +474,10 @@ static void wacom_release_shared_data(struct kref *kref)
709 474
710static void wacom_remove_shared_data(struct wacom_wac *wacom) 475static void wacom_remove_shared_data(struct wacom_wac *wacom)
711{ 476{
712 struct wacom_usbdev_data *data; 477 struct wacom_hdev_data *data;
713 478
714 if (wacom->shared) { 479 if (wacom->shared) {
715 data = container_of(wacom->shared, struct wacom_usbdev_data, shared); 480 data = container_of(wacom->shared, struct wacom_hdev_data, shared);
716 kref_put(&data->kref, wacom_release_shared_data); 481 kref_put(&data->kref, wacom_release_shared_data);
717 wacom->shared = NULL; 482 wacom->shared = NULL;
718 } 483 }
@@ -755,38 +520,40 @@ static int wacom_led_control(struct wacom *wacom)
755 buf[4] = wacom->led.img_lum; 520 buf[4] = wacom->led.img_lum;
756 } 521 }
757 522
758 retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_LED_CONTROL, 523 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 9,
759 buf, 9, WAC_CMD_RETRIES); 524 WAC_CMD_RETRIES);
760 kfree(buf); 525 kfree(buf);
761 526
762 return retval; 527 return retval;
763} 528}
764 529
765static int wacom_led_putimage(struct wacom *wacom, int button_id, const void *img) 530static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id,
531 const unsigned len, const void *img)
766{ 532{
767 unsigned char *buf; 533 unsigned char *buf;
768 int i, retval; 534 int i, retval;
535 const unsigned chunk_len = len / 4; /* 4 chunks are needed to be sent */
769 536
770 buf = kzalloc(259, GFP_KERNEL); 537 buf = kzalloc(chunk_len + 3 , GFP_KERNEL);
771 if (!buf) 538 if (!buf)
772 return -ENOMEM; 539 return -ENOMEM;
773 540
774 /* Send 'start' command */ 541 /* Send 'start' command */
775 buf[0] = WAC_CMD_ICON_START; 542 buf[0] = WAC_CMD_ICON_START;
776 buf[1] = 1; 543 buf[1] = 1;
777 retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_START, 544 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
778 buf, 2, WAC_CMD_RETRIES); 545 WAC_CMD_RETRIES);
779 if (retval < 0) 546 if (retval < 0)
780 goto out; 547 goto out;
781 548
782 buf[0] = WAC_CMD_ICON_XFER; 549 buf[0] = xfer_id;
783 buf[1] = button_id & 0x07; 550 buf[1] = button_id & 0x07;
784 for (i = 0; i < 4; i++) { 551 for (i = 0; i < 4; i++) {
785 buf[2] = i; 552 buf[2] = i;
786 memcpy(buf + 3, img + i * 256, 256); 553 memcpy(buf + 3, img + i * chunk_len, chunk_len);
787 554
788 retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_XFER, 555 retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
789 buf, 259, WAC_CMD_RETRIES); 556 buf, chunk_len + 3, WAC_CMD_RETRIES);
790 if (retval < 0) 557 if (retval < 0)
791 break; 558 break;
792 } 559 }
@@ -794,8 +561,8 @@ static int wacom_led_putimage(struct wacom *wacom, int button_id, const void *im
794 /* Send 'stop' */ 561 /* Send 'stop' */
795 buf[0] = WAC_CMD_ICON_START; 562 buf[0] = WAC_CMD_ICON_START;
796 buf[1] = 0; 563 buf[1] = 0;
797 wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_START, 564 wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
798 buf, 2, WAC_CMD_RETRIES); 565 WAC_CMD_RETRIES);
799 566
800out: 567out:
801 kfree(buf); 568 kfree(buf);
@@ -805,7 +572,8 @@ out:
805static ssize_t wacom_led_select_store(struct device *dev, int set_id, 572static ssize_t wacom_led_select_store(struct device *dev, int set_id,
806 const char *buf, size_t count) 573 const char *buf, size_t count)
807{ 574{
808 struct wacom *wacom = dev_get_drvdata(dev); 575 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
576 struct wacom *wacom = hid_get_drvdata(hdev);
809 unsigned int id; 577 unsigned int id;
810 int err; 578 int err;
811 579
@@ -832,7 +600,8 @@ static ssize_t wacom_led##SET_ID##_select_store(struct device *dev, \
832static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \ 600static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \
833 struct device_attribute *attr, char *buf) \ 601 struct device_attribute *attr, char *buf) \
834{ \ 602{ \
835 struct wacom *wacom = dev_get_drvdata(dev); \ 603 struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
604 struct wacom *wacom = hid_get_drvdata(hdev); \
836 return snprintf(buf, 2, "%d\n", wacom->led.select[SET_ID]); \ 605 return snprintf(buf, 2, "%d\n", wacom->led.select[SET_ID]); \
837} \ 606} \
838static DEVICE_ATTR(status_led##SET_ID##_select, S_IWUSR | S_IRUSR, \ 607static DEVICE_ATTR(status_led##SET_ID##_select, S_IWUSR | S_IRUSR, \
@@ -866,7 +635,8 @@ static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest,
866static ssize_t wacom_##name##_luminance_store(struct device *dev, \ 635static ssize_t wacom_##name##_luminance_store(struct device *dev, \
867 struct device_attribute *attr, const char *buf, size_t count) \ 636 struct device_attribute *attr, const char *buf, size_t count) \
868{ \ 637{ \
869 struct wacom *wacom = dev_get_drvdata(dev); \ 638 struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
639 struct wacom *wacom = hid_get_drvdata(hdev); \
870 \ 640 \
871 return wacom_luminance_store(wacom, &wacom->led.field, \ 641 return wacom_luminance_store(wacom, &wacom->led.field, \
872 buf, count); \ 642 buf, count); \
@@ -881,15 +651,26 @@ DEVICE_LUMINANCE_ATTR(buttons, img_lum);
881static ssize_t wacom_button_image_store(struct device *dev, int button_id, 651static ssize_t wacom_button_image_store(struct device *dev, int button_id,
882 const char *buf, size_t count) 652 const char *buf, size_t count)
883{ 653{
884 struct wacom *wacom = dev_get_drvdata(dev); 654 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
655 struct wacom *wacom = hid_get_drvdata(hdev);
885 int err; 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 }
886 667
887 if (count != 1024) 668 if (count != len)
888 return -EINVAL; 669 return -EINVAL;
889 670
890 mutex_lock(&wacom->lock); 671 mutex_lock(&wacom->lock);
891 672
892 err = wacom_led_putimage(wacom, button_id, buf); 673 err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf);
893 674
894 mutex_unlock(&wacom->lock); 675 mutex_unlock(&wacom->lock);
895 676
@@ -965,13 +746,14 @@ static int wacom_initialize_leds(struct wacom *wacom)
965 switch (wacom->wacom_wac.features.type) { 746 switch (wacom->wacom_wac.features.type) {
966 case INTUOS4S: 747 case INTUOS4S:
967 case INTUOS4: 748 case INTUOS4:
749 case INTUOS4WL:
968 case INTUOS4L: 750 case INTUOS4L:
969 wacom->led.select[0] = 0; 751 wacom->led.select[0] = 0;
970 wacom->led.select[1] = 0; 752 wacom->led.select[1] = 0;
971 wacom->led.llv = 10; 753 wacom->led.llv = 10;
972 wacom->led.hlv = 20; 754 wacom->led.hlv = 20;
973 wacom->led.img_lum = 10; 755 wacom->led.img_lum = 10;
974 error = sysfs_create_group(&wacom->intf->dev.kobj, 756 error = sysfs_create_group(&wacom->hdev->dev.kobj,
975 &intuos4_led_attr_group); 757 &intuos4_led_attr_group);
976 break; 758 break;
977 759
@@ -983,7 +765,7 @@ static int wacom_initialize_leds(struct wacom *wacom)
983 wacom->led.hlv = 0; 765 wacom->led.hlv = 0;
984 wacom->led.img_lum = 0; 766 wacom->led.img_lum = 0;
985 767
986 error = sysfs_create_group(&wacom->intf->dev.kobj, 768 error = sysfs_create_group(&wacom->hdev->dev.kobj,
987 &cintiq_led_attr_group); 769 &cintiq_led_attr_group);
988 break; 770 break;
989 771
@@ -1000,7 +782,7 @@ static int wacom_initialize_leds(struct wacom *wacom)
1000 wacom->led.hlv = 0; 782 wacom->led.hlv = 0;
1001 wacom->led.img_lum = 0; 783 wacom->led.img_lum = 0;
1002 784
1003 error = sysfs_create_group(&wacom->intf->dev.kobj, 785 error = sysfs_create_group(&wacom->hdev->dev.kobj,
1004 &intuos5_led_attr_group); 786 &intuos5_led_attr_group);
1005 } else 787 } else
1006 return 0; 788 return 0;
@@ -1011,28 +793,35 @@ static int wacom_initialize_leds(struct wacom *wacom)
1011 } 793 }
1012 794
1013 if (error) { 795 if (error) {
1014 dev_err(&wacom->intf->dev, 796 hid_err(wacom->hdev,
1015 "cannot create sysfs group err: %d\n", error); 797 "cannot create sysfs group err: %d\n", error);
1016 return error; 798 return error;
1017 } 799 }
1018 wacom_led_control(wacom); 800 wacom_led_control(wacom);
801 wacom->led_initialized = true;
1019 802
1020 return 0; 803 return 0;
1021} 804}
1022 805
1023static void wacom_destroy_leds(struct wacom *wacom) 806static void wacom_destroy_leds(struct wacom *wacom)
1024{ 807{
808 if (!wacom->led_initialized)
809 return;
810
811 wacom->led_initialized = false;
812
1025 switch (wacom->wacom_wac.features.type) { 813 switch (wacom->wacom_wac.features.type) {
1026 case INTUOS4S: 814 case INTUOS4S:
1027 case INTUOS4: 815 case INTUOS4:
816 case INTUOS4WL:
1028 case INTUOS4L: 817 case INTUOS4L:
1029 sysfs_remove_group(&wacom->intf->dev.kobj, 818 sysfs_remove_group(&wacom->hdev->dev.kobj,
1030 &intuos4_led_attr_group); 819 &intuos4_led_attr_group);
1031 break; 820 break;
1032 821
1033 case WACOM_24HD: 822 case WACOM_24HD:
1034 case WACOM_21UX2: 823 case WACOM_21UX2:
1035 sysfs_remove_group(&wacom->intf->dev.kobj, 824 sysfs_remove_group(&wacom->hdev->dev.kobj,
1036 &cintiq_led_attr_group); 825 &cintiq_led_attr_group);
1037 break; 826 break;
1038 827
@@ -1043,17 +832,24 @@ static void wacom_destroy_leds(struct wacom *wacom)
1043 case INTUOSPM: 832 case INTUOSPM:
1044 case INTUOSPL: 833 case INTUOSPL:
1045 if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN) 834 if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN)
1046 sysfs_remove_group(&wacom->intf->dev.kobj, 835 sysfs_remove_group(&wacom->hdev->dev.kobj,
1047 &intuos5_led_attr_group); 836 &intuos5_led_attr_group);
1048 break; 837 break;
1049 } 838 }
1050} 839}
1051 840
1052static enum power_supply_property wacom_battery_props[] = { 841static enum power_supply_property wacom_battery_props[] = {
842 POWER_SUPPLY_PROP_STATUS,
1053 POWER_SUPPLY_PROP_SCOPE, 843 POWER_SUPPLY_PROP_SCOPE,
1054 POWER_SUPPLY_PROP_CAPACITY 844 POWER_SUPPLY_PROP_CAPACITY
1055}; 845};
1056 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
1057static int wacom_battery_get_property(struct power_supply *psy, 853static int wacom_battery_get_property(struct power_supply *psy,
1058 enum power_supply_property psp, 854 enum power_supply_property psp,
1059 union power_supply_propval *val) 855 union power_supply_propval *val)
@@ -1067,7 +863,16 @@ static int wacom_battery_get_property(struct power_supply *psy,
1067 break; 863 break;
1068 case POWER_SUPPLY_PROP_CAPACITY: 864 case POWER_SUPPLY_PROP_CAPACITY:
1069 val->intval = 865 val->intval =
1070 wacom->wacom_wac.battery_capacity * 100 / 31; 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;
1071 break; 876 break;
1072 default: 877 default:
1073 ret = -EINVAL; 878 ret = -EINVAL;
@@ -1077,74 +882,201 @@ static int wacom_battery_get_property(struct power_supply *psy,
1077 return ret; 882 return ret;
1078} 883}
1079 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
1080static int wacom_initialize_battery(struct wacom *wacom) 908static int wacom_initialize_battery(struct wacom *wacom)
1081{ 909{
1082 int error = 0; 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;
1083 916
1084 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_MONITOR) {
1085 wacom->battery.properties = wacom_battery_props; 917 wacom->battery.properties = wacom_battery_props;
1086 wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props); 918 wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
1087 wacom->battery.get_property = wacom_battery_get_property; 919 wacom->battery.get_property = wacom_battery_get_property;
1088 wacom->battery.name = "wacom_battery"; 920 sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
921 wacom->battery.name = wacom->wacom_wac.bat_name;
1089 wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY; 922 wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1090 wacom->battery.use_for_apm = 0; 923 wacom->battery.use_for_apm = 0;
1091 924
1092 error = power_supply_register(&wacom->usbdev->dev, 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,
1093 &wacom->battery); 934 &wacom->battery);
935 if (error)
936 return error;
937
938 power_supply_powers(&wacom->battery, &wacom->hdev->dev);
1094 939
1095 if (!error) 940 error = power_supply_register(&wacom->hdev->dev, &wacom->ac);
1096 power_supply_powers(&wacom->battery, 941 if (error) {
1097 &wacom->usbdev->dev); 942 power_supply_unregister(&wacom->battery);
943 return error;
944 }
945
946 power_supply_powers(&wacom->ac, &wacom->hdev->dev);
1098 } 947 }
1099 948
1100 return error; 949 return 0;
1101} 950}
1102 951
1103static void wacom_destroy_battery(struct wacom *wacom) 952static void wacom_destroy_battery(struct wacom *wacom)
1104{ 953{
1105 if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_MONITOR && 954 if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
1106 wacom->battery.dev) { 955 wacom->battery.dev) {
1107 power_supply_unregister(&wacom->battery); 956 power_supply_unregister(&wacom->battery);
1108 wacom->battery.dev = NULL; 957 wacom->battery.dev = NULL;
958 power_supply_unregister(&wacom->ac);
959 wacom->ac.dev = NULL;
1109 } 960 }
1110} 961}
1111 962
1112static int wacom_register_input(struct wacom *wacom) 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)
1113{ 996{
1114 struct input_dev *input_dev; 997 struct input_dev *input_dev;
1115 struct usb_interface *intf = wacom->intf; 998 struct hid_device *hdev = wacom->hdev;
1116 struct usb_device *dev = interface_to_usbdev(intf);
1117 struct wacom_wac *wacom_wac = &(wacom->wacom_wac); 999 struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
1118 int error;
1119 1000
1120 input_dev = input_allocate_device(); 1001 input_dev = input_allocate_device();
1121 if (!input_dev) { 1002 if (!input_dev)
1122 error = -ENOMEM; 1003 return NULL;
1123 goto fail1;
1124 }
1125 1004
1126 input_dev->name = wacom_wac->name; 1005 input_dev->name = wacom_wac->name;
1127 input_dev->dev.parent = &intf->dev; 1006 input_dev->phys = hdev->phys;
1007 input_dev->dev.parent = &hdev->dev;
1128 input_dev->open = wacom_open; 1008 input_dev->open = wacom_open;
1129 input_dev->close = wacom_close; 1009 input_dev->close = wacom_close;
1130 usb_to_input_id(dev, &input_dev->id); 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;
1131 input_set_drvdata(input_dev, wacom); 1015 input_set_drvdata(input_dev, wacom);
1132 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
1133 wacom_wac->input = input_dev; 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
1134 error = wacom_setup_input_capabilities(input_dev, wacom_wac); 1047 error = wacom_setup_input_capabilities(input_dev, wacom_wac);
1135 if (error) 1048 if (error)
1136 goto fail1; 1049 goto fail2;
1137 1050
1138 error = input_register_device(input_dev); 1051 error = input_register_device(input_dev);
1139 if (error) 1052 if (error)
1140 goto fail2; 1053 goto fail2;
1141 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
1142 return 0; 1067 return 0;
1143 1068
1069fail3:
1070 input_unregister_device(input_dev);
1071 input_dev = NULL;
1144fail2: 1072fail2:
1145 input_free_device(input_dev);
1146 wacom_wac->input = NULL; 1073 wacom_wac->input = NULL;
1074 wacom_wac->pad_input = NULL;
1147fail1: 1075fail1:
1076 if (input_dev)
1077 input_free_device(input_dev);
1078 if (pad_input_dev)
1079 input_free_device(pad_input_dev);
1148 return error; 1080 return error;
1149} 1081}
1150 1082
@@ -1153,6 +1085,7 @@ static void wacom_wireless_work(struct work_struct *work)
1153 struct wacom *wacom = container_of(work, struct wacom, work); 1085 struct wacom *wacom = container_of(work, struct wacom, work);
1154 struct usb_device *usbdev = wacom->usbdev; 1086 struct usb_device *usbdev = wacom->usbdev;
1155 struct wacom_wac *wacom_wac = &wacom->wacom_wac; 1087 struct wacom_wac *wacom_wac = &wacom->wacom_wac;
1088 struct hid_device *hdev1, *hdev2;
1156 struct wacom *wacom1, *wacom2; 1089 struct wacom *wacom1, *wacom2;
1157 struct wacom_wac *wacom_wac1, *wacom_wac2; 1090 struct wacom_wac *wacom_wac1, *wacom_wac2;
1158 int error; 1091 int error;
@@ -1165,50 +1098,49 @@ static void wacom_wireless_work(struct work_struct *work)
1165 wacom_destroy_battery(wacom); 1098 wacom_destroy_battery(wacom);
1166 1099
1167 /* Stylus interface */ 1100 /* Stylus interface */
1168 wacom1 = usb_get_intfdata(usbdev->config->interface[1]); 1101 hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
1102 wacom1 = hid_get_drvdata(hdev1);
1169 wacom_wac1 = &(wacom1->wacom_wac); 1103 wacom_wac1 = &(wacom1->wacom_wac);
1170 if (wacom_wac1->input) 1104 wacom_unregister_inputs(wacom1);
1171 input_unregister_device(wacom_wac1->input);
1172 wacom_wac1->input = NULL;
1173 1105
1174 /* Touch interface */ 1106 /* Touch interface */
1175 wacom2 = usb_get_intfdata(usbdev->config->interface[2]); 1107 hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
1108 wacom2 = hid_get_drvdata(hdev2);
1176 wacom_wac2 = &(wacom2->wacom_wac); 1109 wacom_wac2 = &(wacom2->wacom_wac);
1177 if (wacom_wac2->input) 1110 wacom_unregister_inputs(wacom2);
1178 input_unregister_device(wacom_wac2->input);
1179 wacom_wac2->input = NULL;
1180 1111
1181 if (wacom_wac->pid == 0) { 1112 if (wacom_wac->pid == 0) {
1182 dev_info(&wacom->intf->dev, "wireless tablet disconnected\n"); 1113 hid_info(wacom->hdev, "wireless tablet disconnected\n");
1114 wacom_wac1->shared->type = 0;
1183 } else { 1115 } else {
1184 const struct usb_device_id *id = wacom_ids; 1116 const struct hid_device_id *id = wacom_ids;
1185 1117
1186 dev_info(&wacom->intf->dev, 1118 hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
1187 "wireless tablet connected with PID %x\n",
1188 wacom_wac->pid); 1119 wacom_wac->pid);
1189 1120
1190 while (id->match_flags) { 1121 while (id->bus) {
1191 if (id->idVendor == USB_VENDOR_ID_WACOM && 1122 if (id->vendor == USB_VENDOR_ID_WACOM &&
1192 id->idProduct == wacom_wac->pid) 1123 id->product == wacom_wac->pid)
1193 break; 1124 break;
1194 id++; 1125 id++;
1195 } 1126 }
1196 1127
1197 if (!id->match_flags) { 1128 if (!id->bus) {
1198 dev_info(&wacom->intf->dev, 1129 hid_info(wacom->hdev, "ignoring unknown PID.\n");
1199 "ignoring unknown PID.\n");
1200 return; 1130 return;
1201 } 1131 }
1202 1132
1203 /* Stylus interface */ 1133 /* Stylus interface */
1204 wacom_wac1->features = 1134 wacom_wac1->features =
1205 *((struct wacom_features *)id->driver_info); 1135 *((struct wacom_features *)id->driver_data);
1206 wacom_wac1->features.device_type = BTN_TOOL_PEN; 1136 wacom_wac1->features.device_type = BTN_TOOL_PEN;
1207 snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen", 1137 snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen",
1208 wacom_wac1->features.name); 1138 wacom_wac1->features.name);
1139 snprintf(wacom_wac1->pad_name, WACOM_NAME_MAX, "%s (WL) Pad",
1140 wacom_wac1->features.name);
1209 wacom_wac1->shared->touch_max = wacom_wac1->features.touch_max; 1141 wacom_wac1->shared->touch_max = wacom_wac1->features.touch_max;
1210 wacom_wac1->shared->type = wacom_wac1->features.type; 1142 wacom_wac1->shared->type = wacom_wac1->features.type;
1211 error = wacom_register_input(wacom1); 1143 error = wacom_register_inputs(wacom1);
1212 if (error) 1144 if (error)
1213 goto fail; 1145 goto fail;
1214 1146
@@ -1216,7 +1148,7 @@ static void wacom_wireless_work(struct work_struct *work)
1216 if (wacom_wac1->features.touch_max || 1148 if (wacom_wac1->features.touch_max ||
1217 wacom_wac1->features.type == INTUOSHT) { 1149 wacom_wac1->features.type == INTUOSHT) {
1218 wacom_wac2->features = 1150 wacom_wac2->features =
1219 *((struct wacom_features *)id->driver_info); 1151 *((struct wacom_features *)id->driver_data);
1220 wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3; 1152 wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3;
1221 wacom_wac2->features.device_type = BTN_TOOL_FINGER; 1153 wacom_wac2->features.device_type = BTN_TOOL_FINGER;
1222 wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096; 1154 wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096;
@@ -1226,7 +1158,9 @@ static void wacom_wireless_work(struct work_struct *work)
1226 else 1158 else
1227 snprintf(wacom_wac2->name, WACOM_NAME_MAX, 1159 snprintf(wacom_wac2->name, WACOM_NAME_MAX,
1228 "%s (WL) Pad",wacom_wac2->features.name); 1160 "%s (WL) Pad",wacom_wac2->features.name);
1229 error = wacom_register_input(wacom2); 1161 snprintf(wacom_wac2->pad_name, WACOM_NAME_MAX,
1162 "%s (WL) Pad", wacom_wac2->features.name);
1163 error = wacom_register_inputs(wacom2);
1230 if (error) 1164 if (error)
1231 goto fail; 1165 goto fail;
1232 1166
@@ -1243,15 +1177,8 @@ static void wacom_wireless_work(struct work_struct *work)
1243 return; 1177 return;
1244 1178
1245fail: 1179fail:
1246 if (wacom_wac2->input) { 1180 wacom_unregister_inputs(wacom1);
1247 input_unregister_device(wacom_wac2->input); 1181 wacom_unregister_inputs(wacom2);
1248 wacom_wac2->input = NULL;
1249 }
1250
1251 if (wacom_wac1->input) {
1252 input_unregister_device(wacom_wac1->input);
1253 wacom_wac1->input = NULL;
1254 }
1255 return; 1182 return;
1256} 1183}
1257 1184
@@ -1282,69 +1209,89 @@ static void wacom_calculate_res(struct wacom_features *features)
1282 features->unitExpo); 1209 features->unitExpo);
1283} 1210}
1284 1211
1285static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *id) 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)
1286{ 1237{
1238 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
1287 struct usb_device *dev = interface_to_usbdev(intf); 1239 struct usb_device *dev = interface_to_usbdev(intf);
1288 struct usb_endpoint_descriptor *endpoint;
1289 struct wacom *wacom; 1240 struct wacom *wacom;
1290 struct wacom_wac *wacom_wac; 1241 struct wacom_wac *wacom_wac;
1291 struct wacom_features *features; 1242 struct wacom_features *features;
1292 int error; 1243 int error;
1293 1244
1294 if (!id->driver_info) 1245 if (!id->driver_data)
1295 return -EINVAL; 1246 return -EINVAL;
1296 1247
1297 wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL); 1248 wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
1298 if (!wacom) 1249 if (!wacom)
1299 return -ENOMEM; 1250 return -ENOMEM;
1300 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
1301 wacom_wac = &wacom->wacom_wac; 1262 wacom_wac = &wacom->wacom_wac;
1302 wacom_wac->features = *((struct wacom_features *)id->driver_info); 1263 wacom_wac->features = *((struct wacom_features *)id->driver_data);
1303 features = &wacom_wac->features; 1264 features = &wacom_wac->features;
1265 features->pktlen = wacom_compute_pktlen(hdev);
1304 if (features->pktlen > WACOM_PKGLEN_MAX) { 1266 if (features->pktlen > WACOM_PKGLEN_MAX) {
1305 error = -EINVAL; 1267 error = -EINVAL;
1306 goto fail1; 1268 goto fail1;
1307 } 1269 }
1308 1270
1309 wacom_wac->data = usb_alloc_coherent(dev, WACOM_PKGLEN_MAX, 1271 if (features->check_for_hid_type && features->hid_type != hdev->type) {
1310 GFP_KERNEL, &wacom->data_dma); 1272 error = -ENODEV;
1311 if (!wacom_wac->data) {
1312 error = -ENOMEM;
1313 goto fail1; 1273 goto fail1;
1314 } 1274 }
1315 1275
1316 wacom->irq = usb_alloc_urb(0, GFP_KERNEL);
1317 if (!wacom->irq) {
1318 error = -ENOMEM;
1319 goto fail2;
1320 }
1321
1322 wacom->usbdev = dev; 1276 wacom->usbdev = dev;
1323 wacom->intf = intf; 1277 wacom->intf = intf;
1324 mutex_init(&wacom->lock); 1278 mutex_init(&wacom->lock);
1325 INIT_WORK(&wacom->work, wacom_wireless_work); 1279 INIT_WORK(&wacom->work, wacom_wireless_work);
1326 usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
1327 strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
1328
1329 endpoint = &intf->cur_altsetting->endpoint[0].desc;
1330 1280
1331 /* set the default size in case we do not get them from hid */ 1281 /* set the default size in case we do not get them from hid */
1332 wacom_set_default_phy(features); 1282 wacom_set_default_phy(features);
1333 1283
1334 /* Retrieve the physical and logical size for touch devices */ 1284 /* Retrieve the physical and logical size for touch devices */
1335 error = wacom_retrieve_hid_descriptor(intf, features); 1285 wacom_retrieve_hid_descriptor(hdev, features);
1336 if (error)
1337 goto fail3;
1338 1286
1339 /* 1287 /*
1340 * Intuos5 has no useful data about its touch interface in its 1288 * Intuos5 has no useful data about its touch interface in its
1341 * HID descriptor. If this is the touch interface (wMaxPacketSize 1289 * HID descriptor. If this is the touch interface (PacketSize
1342 * of WACOM_PKGLEN_BBTOUCH3), override the table values. 1290 * of WACOM_PKGLEN_BBTOUCH3), override the table values.
1343 */ 1291 */
1344 if (features->type >= INTUOS5S && features->type <= INTUOSHT) { 1292 if (features->type >= INTUOS5S && features->type <= INTUOSHT) {
1345 if (endpoint->wMaxPacketSize == WACOM_PKGLEN_BBTOUCH3) { 1293 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1346 features->device_type = BTN_TOOL_FINGER; 1294 features->device_type = BTN_TOOL_FINGER;
1347 features->pktlen = WACOM_PKGLEN_BBTOUCH3;
1348 1295
1349 features->x_max = 4096; 1296 features->x_max = 4096;
1350 features->y_max = 4096; 1297 features->y_max = 4096;
@@ -1353,20 +1300,35 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
1353 } 1300 }
1354 } 1301 }
1355 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
1356 wacom_setup_device_quirks(features); 1318 wacom_setup_device_quirks(features);
1357 1319
1358 /* set unit to "100th of a mm" for devices not reported by HID */ 1320 /* set unit to "100th of a mm" for devices not reported by HID */
1359 if (!features->unit) { 1321 if (!features->unit) {
1360 features->unit = 0x11; 1322 features->unit = 0x11;
1361 features->unitExpo = 16 - 3; 1323 features->unitExpo = -3;
1362 } 1324 }
1363 wacom_calculate_res(features); 1325 wacom_calculate_res(features);
1364 1326
1365 strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name)); 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);
1366 1330
1367 if (features->quirks & WACOM_QUIRK_MULTI_INPUT) { 1331 if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
1368 struct usb_device *other_dev;
1369
1370 /* Append the device type to the name */ 1332 /* Append the device type to the name */
1371 if (features->device_type != BTN_TOOL_FINGER) 1333 if (features->device_type != BTN_TOOL_FINGER)
1372 strlcat(wacom_wac->name, " Pen", WACOM_NAME_MAX); 1334 strlcat(wacom_wac->name, " Pen", WACOM_NAME_MAX);
@@ -1375,43 +1337,49 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
1375 else 1337 else
1376 strlcat(wacom_wac->name, " Pad", WACOM_NAME_MAX); 1338 strlcat(wacom_wac->name, " Pad", WACOM_NAME_MAX);
1377 1339
1378 other_dev = wacom_get_sibling(dev, features->oVid, features->oPid); 1340 error = wacom_add_shared_data(hdev);
1379 if (other_dev == NULL || wacom_get_usbdev_data(other_dev) == NULL)
1380 other_dev = dev;
1381 error = wacom_add_shared_data(wacom_wac, other_dev);
1382 if (error) 1341 if (error)
1383 goto fail3; 1342 goto fail1;
1384 } 1343 }
1385 1344
1386 usb_fill_int_urb(wacom->irq, dev,
1387 usb_rcvintpipe(dev, endpoint->bEndpointAddress),
1388 wacom_wac->data, features->pktlen,
1389 wacom_sys_irq, wacom, endpoint->bInterval);
1390 wacom->irq->transfer_dma = wacom->data_dma;
1391 wacom->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1392
1393 error = wacom_initialize_leds(wacom); 1345 error = wacom_initialize_leds(wacom);
1394 if (error) 1346 if (error)
1395 goto fail4; 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 }
1396 1355
1397 if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) { 1356 if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
1398 error = wacom_register_input(wacom); 1357 error = wacom_register_inputs(wacom);
1399 if (error) 1358 if (error)
1400 goto fail5; 1359 goto fail4;
1401 } 1360 }
1402 1361
1403 /* Note that if query fails it is not a hard failure */ 1362 if (hdev->bus == BUS_BLUETOOTH) {
1404 wacom_query_tablet_data(intf, features); 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 }
1405 1369
1406 usb_set_intfdata(intf, wacom); 1370 /* Note that if query fails it is not a hard failure */
1371 wacom_query_tablet_data(hdev, features);
1407 1372
1408 if (features->quirks & WACOM_QUIRK_MONITOR) { 1373 /* Regular HID work starts now */
1409 if (usb_submit_urb(wacom->irq, GFP_KERNEL)) { 1374 error = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1410 error = -EIO; 1375 if (error) {
1411 goto fail5; 1376 hid_err(hdev, "hw start failed\n");
1412 } 1377 goto fail5;
1413 } 1378 }
1414 1379
1380 if (features->quirks & WACOM_QUIRK_MONITOR)
1381 error = hid_hw_open(hdev);
1382
1415 if (wacom_wac->features.type == INTUOSHT && wacom_wac->features.touch_max) { 1383 if (wacom_wac->features.type == INTUOSHT && wacom_wac->features.touch_max) {
1416 if (wacom_wac->features.device_type == BTN_TOOL_FINGER) 1384 if (wacom_wac->features.device_type == BTN_TOOL_FINGER)
1417 wacom_wac->shared->touch_input = wacom_wac->input; 1385 wacom_wac->shared->touch_input = wacom_wac->input;
@@ -1419,79 +1387,70 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
1419 1387
1420 return 0; 1388 return 0;
1421 1389
1422 fail5: wacom_destroy_leds(wacom); 1390 fail5: if (hdev->bus == BUS_BLUETOOTH)
1423 fail4: wacom_remove_shared_data(wacom_wac); 1391 device_remove_file(&hdev->dev, &dev_attr_speed);
1424 fail3: usb_free_urb(wacom->irq); 1392 wacom_unregister_inputs(wacom);
1425 fail2: usb_free_coherent(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma); 1393 fail4: wacom_destroy_battery(wacom);
1394 fail3: wacom_destroy_leds(wacom);
1395 fail2: wacom_remove_shared_data(wacom_wac);
1426 fail1: kfree(wacom); 1396 fail1: kfree(wacom);
1397 hid_set_drvdata(hdev, NULL);
1427 return error; 1398 return error;
1428} 1399}
1429 1400
1430static void wacom_disconnect(struct usb_interface *intf) 1401static void wacom_remove(struct hid_device *hdev)
1431{ 1402{
1432 struct wacom *wacom = usb_get_intfdata(intf); 1403 struct wacom *wacom = hid_get_drvdata(hdev);
1433 1404
1434 usb_set_intfdata(intf, NULL); 1405 hid_hw_stop(hdev);
1435 1406
1436 usb_kill_urb(wacom->irq);
1437 cancel_work_sync(&wacom->work); 1407 cancel_work_sync(&wacom->work);
1438 if (wacom->wacom_wac.input) 1408 wacom_unregister_inputs(wacom);
1439 input_unregister_device(wacom->wacom_wac.input); 1409 if (hdev->bus == BUS_BLUETOOTH)
1410 device_remove_file(&hdev->dev, &dev_attr_speed);
1440 wacom_destroy_battery(wacom); 1411 wacom_destroy_battery(wacom);
1441 wacom_destroy_leds(wacom); 1412 wacom_destroy_leds(wacom);
1442 usb_free_urb(wacom->irq);
1443 usb_free_coherent(interface_to_usbdev(intf), WACOM_PKGLEN_MAX,
1444 wacom->wacom_wac.data, wacom->data_dma);
1445 wacom_remove_shared_data(&wacom->wacom_wac); 1413 wacom_remove_shared_data(&wacom->wacom_wac);
1446 kfree(wacom);
1447}
1448
1449static int wacom_suspend(struct usb_interface *intf, pm_message_t message)
1450{
1451 struct wacom *wacom = usb_get_intfdata(intf);
1452
1453 mutex_lock(&wacom->lock);
1454 usb_kill_urb(wacom->irq);
1455 mutex_unlock(&wacom->lock);
1456 1414
1457 return 0; 1415 hid_set_drvdata(hdev, NULL);
1416 kfree(wacom);
1458} 1417}
1459 1418
1460static int wacom_resume(struct usb_interface *intf) 1419static int wacom_resume(struct hid_device *hdev)
1461{ 1420{
1462 struct wacom *wacom = usb_get_intfdata(intf); 1421 struct wacom *wacom = hid_get_drvdata(hdev);
1463 struct wacom_features *features = &wacom->wacom_wac.features; 1422 struct wacom_features *features = &wacom->wacom_wac.features;
1464 int rv = 0;
1465 1423
1466 mutex_lock(&wacom->lock); 1424 mutex_lock(&wacom->lock);
1467 1425
1468 /* switch to wacom mode first */ 1426 /* switch to wacom mode first */
1469 wacom_query_tablet_data(intf, features); 1427 wacom_query_tablet_data(hdev, features);
1470 wacom_led_control(wacom); 1428 wacom_led_control(wacom);
1471 1429
1472 if ((wacom->open || (features->quirks & WACOM_QUIRK_MONITOR)) &&
1473 usb_submit_urb(wacom->irq, GFP_NOIO) < 0)
1474 rv = -EIO;
1475
1476 mutex_unlock(&wacom->lock); 1430 mutex_unlock(&wacom->lock);
1477 1431
1478 return rv; 1432 return 0;
1479} 1433}
1480 1434
1481static int wacom_reset_resume(struct usb_interface *intf) 1435static int wacom_reset_resume(struct hid_device *hdev)
1482{ 1436{
1483 return wacom_resume(intf); 1437 return wacom_resume(hdev);
1484} 1438}
1485 1439
1486static struct usb_driver wacom_driver = { 1440static struct hid_driver wacom_driver = {
1487 .name = "wacom", 1441 .name = "wacom",
1488 .id_table = wacom_ids, 1442 .id_table = wacom_ids,
1489 .probe = wacom_probe, 1443 .probe = wacom_probe,
1490 .disconnect = wacom_disconnect, 1444 .remove = wacom_remove,
1491 .suspend = wacom_suspend, 1445#ifdef CONFIG_PM
1492 .resume = wacom_resume, 1446 .resume = wacom_resume,
1493 .reset_resume = wacom_reset_resume, 1447 .reset_resume = wacom_reset_resume,
1494 .supports_autosuspend = 1, 1448#endif
1449 .raw_event = wacom_raw_event,
1495}; 1450};
1451module_hid_driver(wacom_driver);
1496 1452
1497module_usb_driver(wacom_driver); 1453MODULE_VERSION(DRIVER_VERSION);
1454MODULE_AUTHOR(DRIVER_AUTHOR);
1455MODULE_DESCRIPTION(DRIVER_DESC);
1456MODULE_LICENSE(DRIVER_LICENSE);
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/hid/wacom_wac.c
index e73cf2c71f35..aa6a08eb7ad6 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/hid/wacom_wac.c
@@ -25,11 +25,23 @@
25#define WACOM_INTUOS_RES 100 25#define WACOM_INTUOS_RES 100
26#define WACOM_INTUOS3_RES 200 26#define WACOM_INTUOS3_RES 200
27 27
28/* Scale factor relating reported contact size to logical contact area. 28/*
29 * Scale factor relating reported contact size to logical contact area.
29 * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo 30 * 2^14/pi is a good approximation on Intuos5 and 3rd-gen Bamboo
30 */ 31 */
31#define WACOM_CONTACT_AREA_SCALE 2607 32#define WACOM_CONTACT_AREA_SCALE 2607
32 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
33static int wacom_penpartner_irq(struct wacom_wac *wacom) 45static int wacom_penpartner_irq(struct wacom_wac *wacom)
34{ 46{
35 unsigned char *data = wacom->data; 47 unsigned char *data = wacom->data;
@@ -217,17 +229,13 @@ static int wacom_dtus_irq(struct wacom_wac *wacom)
217 "%s: received unknown report #%d", __func__, data[0]); 229 "%s: received unknown report #%d", __func__, data[0]);
218 return 0; 230 return 0;
219 } else if (data[0] == WACOM_REPORT_DTUSPAD) { 231 } else if (data[0] == WACOM_REPORT_DTUSPAD) {
232 input = wacom->pad_input;
220 input_report_key(input, BTN_0, (data[1] & 0x01)); 233 input_report_key(input, BTN_0, (data[1] & 0x01));
221 input_report_key(input, BTN_1, (data[1] & 0x02)); 234 input_report_key(input, BTN_1, (data[1] & 0x02));
222 input_report_key(input, BTN_2, (data[1] & 0x04)); 235 input_report_key(input, BTN_2, (data[1] & 0x04));
223 input_report_key(input, BTN_3, (data[1] & 0x08)); 236 input_report_key(input, BTN_3, (data[1] & 0x08));
224 input_report_abs(input, ABS_MISC, 237 input_report_abs(input, ABS_MISC,
225 data[1] & 0x0f ? PAD_DEVICE_ID : 0); 238 data[1] & 0x0f ? PAD_DEVICE_ID : 0);
226 /*
227 * Serial number is required when expresskeys are
228 * reported through pen interface.
229 */
230 input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
231 return 1; 239 return 1;
232 } else { 240 } else {
233 prox = data[1] & 0x80; 241 prox = data[1] & 0x80;
@@ -257,7 +265,6 @@ static int wacom_dtus_irq(struct wacom_wac *wacom)
257 wacom->id[0] = 0; 265 wacom->id[0] = 0;
258 input_report_key(input, wacom->tool[0], prox); 266 input_report_key(input, wacom->tool[0], prox);
259 input_report_abs(input, ABS_MISC, wacom->id[0]); 267 input_report_abs(input, ABS_MISC, wacom->id[0]);
260 input_event(input, EV_MSC, MSC_SERIAL, 1);
261 return 1; 268 return 1;
262 } 269 }
263} 270}
@@ -267,11 +274,20 @@ static int wacom_graphire_irq(struct wacom_wac *wacom)
267 struct wacom_features *features = &wacom->features; 274 struct wacom_features *features = &wacom->features;
268 unsigned char *data = wacom->data; 275 unsigned char *data = wacom->data;
269 struct input_dev *input = wacom->input; 276 struct input_dev *input = wacom->input;
277 struct input_dev *pad_input = wacom->pad_input;
278 int battery_capacity, ps_connected;
270 int prox; 279 int prox;
271 int rw = 0; 280 int rw = 0;
272 int retval = 0; 281 int retval = 0;
273 282
274 if (data[0] != WACOM_REPORT_PENABLED) { 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) {
275 dev_dbg(input->dev.parent, 291 dev_dbg(input->dev.parent,
276 "%s: received unknown report #%d\n", __func__, data[0]); 292 "%s: received unknown report #%d\n", __func__, data[0]);
277 goto exit; 293 goto exit;
@@ -305,7 +321,12 @@ static int wacom_graphire_irq(struct wacom_wac *wacom)
305 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2])); 321 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
306 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4])); 322 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
307 if (wacom->tool[0] != BTN_TOOL_MOUSE) { 323 if (wacom->tool[0] != BTN_TOOL_MOUSE) {
308 input_report_abs(input, ABS_PRESSURE, data[6] | ((data[7] & 0x03) << 8)); 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));
309 input_report_key(input, BTN_TOUCH, data[1] & 0x01); 330 input_report_key(input, BTN_TOUCH, data[1] & 0x01);
310 input_report_key(input, BTN_STYLUS, data[1] & 0x02); 331 input_report_key(input, BTN_STYLUS, data[1] & 0x02);
311 input_report_key(input, BTN_STYLUS2, data[1] & 0x04); 332 input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
@@ -316,6 +337,20 @@ static int wacom_graphire_irq(struct wacom_wac *wacom)
316 features->type == WACOM_MO) { 337 features->type == WACOM_MO) {
317 input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f); 338 input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
318 rw = (data[7] & 0x04) - (data[7] & 0x03); 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 }
319 } else { 354 } else {
320 input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f); 355 input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
321 rw = -(signed char)data[6]; 356 rw = -(signed char)data[6];
@@ -327,7 +362,6 @@ static int wacom_graphire_irq(struct wacom_wac *wacom)
327 wacom->id[0] = 0; 362 wacom->id[0] = 0;
328 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */ 363 input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
329 input_report_key(input, wacom->tool[0], prox); 364 input_report_key(input, wacom->tool[0], prox);
330 input_event(input, EV_MSC, MSC_SERIAL, 1);
331 input_sync(input); /* sync last event */ 365 input_sync(input); /* sync last event */
332 } 366 }
333 367
@@ -337,14 +371,13 @@ static int wacom_graphire_irq(struct wacom_wac *wacom)
337 prox = data[7] & 0xf8; 371 prox = data[7] & 0xf8;
338 if (prox || wacom->id[1]) { 372 if (prox || wacom->id[1]) {
339 wacom->id[1] = PAD_DEVICE_ID; 373 wacom->id[1] = PAD_DEVICE_ID;
340 input_report_key(input, BTN_BACK, (data[7] & 0x40)); 374 input_report_key(pad_input, BTN_BACK, (data[7] & 0x40));
341 input_report_key(input, BTN_FORWARD, (data[7] & 0x80)); 375 input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x80));
342 rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3); 376 rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
343 input_report_rel(input, REL_WHEEL, rw); 377 input_report_rel(pad_input, REL_WHEEL, rw);
344 if (!prox) 378 if (!prox)
345 wacom->id[1] = 0; 379 wacom->id[1] = 0;
346 input_report_abs(input, ABS_MISC, wacom->id[1]); 380 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
347 input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
348 retval = 1; 381 retval = 1;
349 } 382 }
350 break; 383 break;
@@ -353,19 +386,43 @@ static int wacom_graphire_irq(struct wacom_wac *wacom)
353 prox = (data[7] & 0xf8) || data[8]; 386 prox = (data[7] & 0xf8) || data[8];
354 if (prox || wacom->id[1]) { 387 if (prox || wacom->id[1]) {
355 wacom->id[1] = PAD_DEVICE_ID; 388 wacom->id[1] = PAD_DEVICE_ID;
356 input_report_key(input, BTN_BACK, (data[7] & 0x08)); 389 input_report_key(pad_input, BTN_BACK, (data[7] & 0x08));
357 input_report_key(input, BTN_LEFT, (data[7] & 0x20)); 390 input_report_key(pad_input, BTN_LEFT, (data[7] & 0x20));
358 input_report_key(input, BTN_FORWARD, (data[7] & 0x10)); 391 input_report_key(pad_input, BTN_FORWARD, (data[7] & 0x10));
359 input_report_key(input, BTN_RIGHT, (data[7] & 0x40)); 392 input_report_key(pad_input, BTN_RIGHT, (data[7] & 0x40));
360 input_report_abs(input, ABS_WHEEL, (data[8] & 0x7f)); 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));
361 if (!prox) 406 if (!prox)
362 wacom->id[1] = 0; 407 wacom->id[1] = 0;
363 input_report_abs(input, ABS_MISC, wacom->id[1]); 408 input_report_abs(pad_input, ABS_MISC, wacom->id[1]);
364 input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
365 retval = 1; 409 retval = 1;
366 } 410 }
367 break; 411 break;
368 } 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 }
369exit: 426exit:
370 return retval; 427 return retval;
371} 428}
@@ -584,6 +641,7 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
584 641
585 /* pad packets. Works as a second tool and is always in prox */ 642 /* pad packets. Works as a second tool and is always in prox */
586 if (data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD) { 643 if (data[0] == WACOM_REPORT_INTUOSPAD || data[0] == WACOM_REPORT_INTUOS5PAD) {
644 input = wacom->pad_input;
587 if (features->type >= INTUOS4S && features->type <= INTUOS4L) { 645 if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
588 input_report_key(input, BTN_0, (data[2] & 0x01)); 646 input_report_key(input, BTN_0, (data[2] & 0x01));
589 input_report_key(input, BTN_1, (data[3] & 0x01)); 647 input_report_key(input, BTN_1, (data[3] & 0x01));
@@ -773,7 +831,6 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
773 input_report_abs(input, ABS_MISC, 0); 831 input_report_abs(input, ABS_MISC, 0);
774 } 832 }
775 } 833 }
776 input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
777 return 1; 834 return 1;
778 } 835 }
779 836
@@ -901,6 +958,58 @@ static int int_dist(int x1, int y1, int x2, int y2)
901 return int_sqrt(x*x + y*y); 958 return int_sqrt(x*x + y*y);
902} 959}
903 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
904static int wacom_24hdt_irq(struct wacom_wac *wacom) 1013static int wacom_24hdt_irq(struct wacom_wac *wacom)
905{ 1014{
906 struct input_dev *input = wacom->input; 1015 struct input_dev *input = wacom->input;
@@ -1093,7 +1202,7 @@ static int wacom_tpc_pen(struct wacom_wac *wacom)
1093 input_report_key(input, BTN_STYLUS2, data[1] & 0x10); 1202 input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
1094 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2])); 1203 input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
1095 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4])); 1204 input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
1096 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x03) << 8) | data[6]); 1205 input_report_abs(input, ABS_PRESSURE, ((data[7] & 0x07) << 8) | data[6]);
1097 input_report_key(input, BTN_TOUCH, data[1] & 0x05); 1206 input_report_key(input, BTN_TOUCH, data[1] & 0x05);
1098 input_report_key(input, wacom->tool[0], prox); 1207 input_report_key(input, wacom->tool[0], prox);
1099 return 1; 1208 return 1;
@@ -1143,6 +1252,7 @@ static int wacom_bpt_touch(struct wacom_wac *wacom)
1143{ 1252{
1144 struct wacom_features *features = &wacom->features; 1253 struct wacom_features *features = &wacom->features;
1145 struct input_dev *input = wacom->input; 1254 struct input_dev *input = wacom->input;
1255 struct input_dev *pad_input = wacom->pad_input;
1146 unsigned char *data = wacom->data; 1256 unsigned char *data = wacom->data;
1147 int i; 1257 int i;
1148 1258
@@ -1177,14 +1287,12 @@ static int wacom_bpt_touch(struct wacom_wac *wacom)
1177 1287
1178 input_mt_report_pointer_emulation(input, true); 1288 input_mt_report_pointer_emulation(input, true);
1179 1289
1180 input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0); 1290 input_report_key(pad_input, BTN_LEFT, (data[1] & 0x08) != 0);
1181 input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0); 1291 input_report_key(pad_input, BTN_FORWARD, (data[1] & 0x04) != 0);
1182 input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0); 1292 input_report_key(pad_input, BTN_BACK, (data[1] & 0x02) != 0);
1183 input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0); 1293 input_report_key(pad_input, BTN_RIGHT, (data[1] & 0x01) != 0);
1184
1185 input_sync(input);
1186 1294
1187 return 0; 1295 return 1;
1188} 1296}
1189 1297
1190static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data) 1298static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
@@ -1232,7 +1340,7 @@ static void wacom_bpt3_touch_msg(struct wacom_wac *wacom, unsigned char *data)
1232 1340
1233static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data) 1341static void wacom_bpt3_button_msg(struct wacom_wac *wacom, unsigned char *data)
1234{ 1342{
1235 struct input_dev *input = wacom->input; 1343 struct input_dev *input = wacom->pad_input;
1236 struct wacom_features *features = &wacom->features; 1344 struct wacom_features *features = &wacom->features;
1237 1345
1238 if (features->type == INTUOSHT) { 1346 if (features->type == INTUOSHT) {
@@ -1269,9 +1377,7 @@ static int wacom_bpt3_touch(struct wacom_wac *wacom)
1269 } 1377 }
1270 input_mt_report_pointer_emulation(input, true); 1378 input_mt_report_pointer_emulation(input, true);
1271 1379
1272 input_sync(input); 1380 return 1;
1273
1274 return 0;
1275} 1381}
1276 1382
1277static int wacom_bpt_pen(struct wacom_wac *wacom) 1383static int wacom_bpt_pen(struct wacom_wac *wacom)
@@ -1375,7 +1481,7 @@ static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
1375 1481
1376 connected = data[1] & 0x01; 1482 connected = data[1] & 0x01;
1377 if (connected) { 1483 if (connected) {
1378 int pid, battery; 1484 int pid, battery, ps_connected;
1379 1485
1380 if ((wacom->shared->type == INTUOSHT) && 1486 if ((wacom->shared->type == INTUOSHT) &&
1381 wacom->shared->touch_max) { 1487 wacom->shared->touch_max) {
@@ -1385,17 +1491,29 @@ static int wacom_wireless_irq(struct wacom_wac *wacom, size_t len)
1385 } 1491 }
1386 1492
1387 pid = get_unaligned_be16(&data[6]); 1493 pid = get_unaligned_be16(&data[6]);
1388 battery = data[5] & 0x3f; 1494 battery = (data[5] & 0x3f) * 100 / 31;
1495 ps_connected = !!(data[5] & 0x80);
1389 if (wacom->pid != pid) { 1496 if (wacom->pid != pid) {
1390 wacom->pid = pid; 1497 wacom->pid = pid;
1391 wacom_schedule_work(wacom); 1498 wacom_schedule_work(wacom);
1392 } 1499 }
1393 wacom->battery_capacity = battery; 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 }
1394 } else if (wacom->pid != 0) { 1510 } else if (wacom->pid != 0) {
1395 /* disconnected while previously connected */ 1511 /* disconnected while previously connected */
1396 wacom->pid = 0; 1512 wacom->pid = 0;
1397 wacom_schedule_work(wacom); 1513 wacom_schedule_work(wacom);
1398 wacom->battery_capacity = 0; 1514 wacom->battery_capacity = 0;
1515 wacom->bat_charging = 0;
1516 wacom->ps_connected = 0;
1399 } 1517 }
1400 1518
1401 return 0; 1519 return 0;
@@ -1416,6 +1534,7 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
1416 1534
1417 case WACOM_G4: 1535 case WACOM_G4:
1418 case GRAPHIRE: 1536 case GRAPHIRE:
1537 case GRAPHIRE_BT:
1419 case WACOM_MO: 1538 case WACOM_MO:
1420 sync = wacom_graphire_irq(wacom_wac); 1539 sync = wacom_graphire_irq(wacom_wac);
1421 break; 1540 break;
@@ -1450,6 +1569,10 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
1450 sync = wacom_intuos_irq(wacom_wac); 1569 sync = wacom_intuos_irq(wacom_wac);
1451 break; 1570 break;
1452 1571
1572 case INTUOS4WL:
1573 sync = wacom_intuos_bt_irq(wacom_wac, len);
1574 break;
1575
1453 case WACOM_24HDT: 1576 case WACOM_24HDT:
1454 sync = wacom_24hdt_irq(wacom_wac); 1577 sync = wacom_24hdt_irq(wacom_wac);
1455 break; 1578 break;
@@ -1489,8 +1612,11 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
1489 break; 1612 break;
1490 } 1613 }
1491 1614
1492 if (sync) 1615 if (sync) {
1493 input_sync(wacom_wac->input); 1616 input_sync(wacom_wac->input);
1617 if (wacom_wac->pad_input)
1618 input_sync(wacom_wac->pad_input);
1619 }
1494} 1620}
1495 1621
1496static void wacom_setup_cintiq(struct wacom_wac *wacom_wac) 1622static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
@@ -1565,8 +1691,10 @@ void wacom_setup_device_quirks(struct wacom_features *features)
1565 features->quirks |= WACOM_QUIRK_NO_INPUT; 1691 features->quirks |= WACOM_QUIRK_NO_INPUT;
1566 1692
1567 /* must be monitor interface if no device_type set */ 1693 /* must be monitor interface if no device_type set */
1568 if (!features->device_type) 1694 if (!features->device_type) {
1569 features->quirks |= WACOM_QUIRK_MONITOR; 1695 features->quirks |= WACOM_QUIRK_MONITOR;
1696 features->quirks |= WACOM_QUIRK_BATTERY;
1697 }
1570 } 1698 }
1571} 1699}
1572 1700
@@ -1615,7 +1743,6 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1615 struct wacom_wac *wacom_wac) 1743 struct wacom_wac *wacom_wac)
1616{ 1744{
1617 struct wacom_features *features = &wacom_wac->features; 1745 struct wacom_features *features = &wacom_wac->features;
1618 int i;
1619 1746
1620 input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1747 input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1621 1748
@@ -1630,10 +1757,6 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1630 /* fall through */ 1757 /* fall through */
1631 1758
1632 case WACOM_G4: 1759 case WACOM_G4:
1633 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
1634
1635 __set_bit(BTN_BACK, input_dev->keybit);
1636 __set_bit(BTN_FORWARD, input_dev->keybit);
1637 /* fall through */ 1760 /* fall through */
1638 1761
1639 case GRAPHIRE: 1762 case GRAPHIRE:
@@ -1652,62 +1775,42 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1652 __set_bit(INPUT_PROP_POINTER, input_dev->propbit); 1775 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1653 break; 1776 break;
1654 1777
1655 case WACOM_24HD: 1778 case GRAPHIRE_BT:
1656 __set_bit(BTN_A, input_dev->keybit); 1779 __clear_bit(ABS_MISC, input_dev->absbit);
1657 __set_bit(BTN_B, input_dev->keybit); 1780 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
1658 __set_bit(BTN_C, input_dev->keybit); 1781 features->distance_max,
1659 __set_bit(BTN_X, input_dev->keybit); 1782 0, 0);
1660 __set_bit(BTN_Y, input_dev->keybit);
1661 __set_bit(BTN_Z, input_dev->keybit);
1662 1783
1663 for (i = 6; i < 10; i++) 1784 input_set_capability(input_dev, EV_REL, REL_WHEEL);
1664 __set_bit(BTN_0 + i, input_dev->keybit);
1665 1785
1666 __set_bit(KEY_PROG1, input_dev->keybit); 1786 __set_bit(BTN_LEFT, input_dev->keybit);
1667 __set_bit(KEY_PROG2, input_dev->keybit); 1787 __set_bit(BTN_RIGHT, input_dev->keybit);
1668 __set_bit(KEY_PROG3, 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;
1669 1798
1799 case WACOM_24HD:
1670 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0); 1800 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1671 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0); 1801 input_set_abs_params(input_dev, ABS_THROTTLE, 0, 71, 0, 0);
1672 /* fall through */ 1802 /* fall through */
1673 1803
1674 case DTK: 1804 case DTK:
1675 for (i = 0; i < 6; i++)
1676 __set_bit(BTN_0 + i, input_dev->keybit);
1677
1678 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit); 1805 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1679 1806
1680 wacom_setup_cintiq(wacom_wac); 1807 wacom_setup_cintiq(wacom_wac);
1681 break; 1808 break;
1682 1809
1683 case WACOM_22HD: 1810 case WACOM_22HD:
1684 __set_bit(KEY_PROG1, input_dev->keybit);
1685 __set_bit(KEY_PROG2, input_dev->keybit);
1686 __set_bit(KEY_PROG3, input_dev->keybit);
1687 /* fall through */
1688
1689 case WACOM_21UX2: 1811 case WACOM_21UX2:
1690 __set_bit(BTN_A, input_dev->keybit);
1691 __set_bit(BTN_B, input_dev->keybit);
1692 __set_bit(BTN_C, input_dev->keybit);
1693 __set_bit(BTN_X, input_dev->keybit);
1694 __set_bit(BTN_Y, input_dev->keybit);
1695 __set_bit(BTN_Z, input_dev->keybit);
1696 __set_bit(BTN_BASE, input_dev->keybit);
1697 __set_bit(BTN_BASE2, input_dev->keybit);
1698 /* fall through */
1699
1700 case WACOM_BEE: 1812 case WACOM_BEE:
1701 __set_bit(BTN_8, input_dev->keybit);
1702 __set_bit(BTN_9, input_dev->keybit);
1703 /* fall through */
1704
1705 case CINTIQ: 1813 case CINTIQ:
1706 for (i = 0; i < 8; i++)
1707 __set_bit(BTN_0 + i, input_dev->keybit);
1708
1709 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
1710 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
1711 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0); 1814 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1712 1815
1713 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit); 1816 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
@@ -1716,9 +1819,6 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1716 break; 1819 break;
1717 1820
1718 case WACOM_13HD: 1821 case WACOM_13HD:
1719 for (i = 0; i < 9; i++)
1720 __set_bit(BTN_0 + i, input_dev->keybit);
1721
1722 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0); 1822 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1723 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit); 1823 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
1724 wacom_setup_cintiq(wacom_wac); 1824 wacom_setup_cintiq(wacom_wac);
@@ -1726,21 +1826,7 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1726 1826
1727 case INTUOS3: 1827 case INTUOS3:
1728 case INTUOS3L: 1828 case INTUOS3L:
1729 __set_bit(BTN_4, input_dev->keybit);
1730 __set_bit(BTN_5, input_dev->keybit);
1731 __set_bit(BTN_6, input_dev->keybit);
1732 __set_bit(BTN_7, input_dev->keybit);
1733
1734 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
1735 /* fall through */
1736
1737 case INTUOS3S: 1829 case INTUOS3S:
1738 __set_bit(BTN_0, input_dev->keybit);
1739 __set_bit(BTN_1, input_dev->keybit);
1740 __set_bit(BTN_2, input_dev->keybit);
1741 __set_bit(BTN_3, input_dev->keybit);
1742
1743 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
1744 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0); 1830 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1745 /* fall through */ 1831 /* fall through */
1746 1832
@@ -1754,20 +1840,11 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1754 case INTUOS5L: 1840 case INTUOS5L:
1755 case INTUOSPM: 1841 case INTUOSPM:
1756 case INTUOSPL: 1842 case INTUOSPL:
1757 if (features->device_type == BTN_TOOL_PEN) {
1758 __set_bit(BTN_7, input_dev->keybit);
1759 __set_bit(BTN_8, input_dev->keybit);
1760 }
1761 /* fall through */
1762
1763 case INTUOS5S: 1843 case INTUOS5S:
1764 case INTUOSPS: 1844 case INTUOSPS:
1765 __set_bit(INPUT_PROP_POINTER, input_dev->propbit); 1845 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
1766 1846
1767 if (features->device_type == BTN_TOOL_PEN) { 1847 if (features->device_type == BTN_TOOL_PEN) {
1768 for (i = 0; i < 7; i++)
1769 __set_bit(BTN_0 + i, input_dev->keybit);
1770
1771 input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1848 input_set_abs_params(input_dev, ABS_DISTANCE, 0,
1772 features->distance_max, 1849 features->distance_max,
1773 0, 0); 1850 0, 0);
@@ -1787,15 +1864,9 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1787 break; 1864 break;
1788 1865
1789 case INTUOS4: 1866 case INTUOS4:
1867 case INTUOS4WL:
1790 case INTUOS4L: 1868 case INTUOS4L:
1791 __set_bit(BTN_7, input_dev->keybit);
1792 __set_bit(BTN_8, input_dev->keybit);
1793 /* fall through */
1794
1795 case INTUOS4S: 1869 case INTUOS4S:
1796 for (i = 0; i < 7; i++)
1797 __set_bit(BTN_0 + i, input_dev->keybit);
1798
1799 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0); 1870 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
1800 wacom_setup_intuos(wacom_wac); 1871 wacom_setup_intuos(wacom_wac);
1801 1872
@@ -1833,11 +1904,6 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1833 case DTUS: 1904 case DTUS:
1834 case PL: 1905 case PL:
1835 case DTU: 1906 case DTU:
1836 if (features->type == DTUS) {
1837 input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
1838 for (i = 0; i < 4; i++)
1839 __set_bit(BTN_0 + i, input_dev->keybit);
1840 }
1841 __set_bit(BTN_TOOL_PEN, input_dev->keybit); 1907 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
1842 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit); 1908 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
1843 __set_bit(BTN_STYLUS, input_dev->keybit); 1909 __set_bit(BTN_STYLUS, input_dev->keybit);
@@ -1871,11 +1937,6 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1871 1937
1872 if (features->device_type == BTN_TOOL_FINGER) { 1938 if (features->device_type == BTN_TOOL_FINGER) {
1873 1939
1874 __set_bit(BTN_LEFT, input_dev->keybit);
1875 __set_bit(BTN_FORWARD, input_dev->keybit);
1876 __set_bit(BTN_BACK, input_dev->keybit);
1877 __set_bit(BTN_RIGHT, input_dev->keybit);
1878
1879 if (features->touch_max) { 1940 if (features->touch_max) {
1880 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) { 1941 if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
1881 input_set_abs_params(input_dev, 1942 input_set_abs_params(input_dev,
@@ -1905,449 +1966,629 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
1905 break; 1966 break;
1906 1967
1907 case CINTIQ_HYBRID: 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);
1908 __set_bit(BTN_1, input_dev->keybit); 1996 __set_bit(BTN_1, input_dev->keybit);
1909 __set_bit(BTN_2, input_dev->keybit); 1997 break;
1910 __set_bit(BTN_3, input_dev->keybit); 1998
1911 __set_bit(BTN_4, input_dev->keybit); 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);
1912 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);
1913 __set_bit(BTN_5, input_dev->keybit); 2080 __set_bit(BTN_5, input_dev->keybit);
1914 __set_bit(BTN_6, input_dev->keybit); 2081 __set_bit(BTN_6, input_dev->keybit);
1915 __set_bit(BTN_7, input_dev->keybit); 2082 __set_bit(BTN_7, input_dev->keybit);
1916 __set_bit(BTN_8, input_dev->keybit); 2083
2084 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
2085 /* fall through */
2086
2087 case INTUOS3S:
1917 __set_bit(BTN_0, input_dev->keybit); 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);
1918 2092
1919 input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0); 2093 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
1920 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit); 2094 break;
1921 2095
1922 wacom_setup_cintiq(wacom_wac); 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);
1923 break; 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;
1924 } 2167 }
1925 return 0; 2168 return 0;
1926} 2169}
1927 2170
1928static const struct wacom_features wacom_features_0x00 = 2171static const struct wacom_features wacom_features_0x00 =
1929 { "Wacom Penpartner", WACOM_PKGLEN_PENPRTN, 5040, 3780, 255, 2172 { "Wacom Penpartner", 5040, 3780, 255, 0,
1930 0, PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES }; 2173 PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
1931static const struct wacom_features wacom_features_0x10 = 2174static const struct wacom_features wacom_features_0x10 =
1932 { "Wacom Graphire", WACOM_PKGLEN_GRAPHIRE, 10206, 7422, 511, 2175 { "Wacom Graphire", 10206, 7422, 511, 63,
1933 63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 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 };
1934static const struct wacom_features wacom_features_0x11 = 2180static const struct wacom_features wacom_features_0x11 =
1935 { "Wacom Graphire2 4x5", WACOM_PKGLEN_GRAPHIRE, 10206, 7422, 511, 2181 { "Wacom Graphire2 4x5", 10206, 7422, 511, 63,
1936 63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 2182 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1937static const struct wacom_features wacom_features_0x12 = 2183static const struct wacom_features wacom_features_0x12 =
1938 { "Wacom Graphire2 5x7", WACOM_PKGLEN_GRAPHIRE, 13918, 10206, 511, 2184 { "Wacom Graphire2 5x7", 13918, 10206, 511, 63,
1939 63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 2185 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1940static const struct wacom_features wacom_features_0x13 = 2186static const struct wacom_features wacom_features_0x13 =
1941 { "Wacom Graphire3", WACOM_PKGLEN_GRAPHIRE, 10208, 7424, 511, 2187 { "Wacom Graphire3", 10208, 7424, 511, 63,
1942 63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 2188 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1943static const struct wacom_features wacom_features_0x14 = 2189static const struct wacom_features wacom_features_0x14 =
1944 { "Wacom Graphire3 6x8", WACOM_PKGLEN_GRAPHIRE, 16704, 12064, 511, 2190 { "Wacom Graphire3 6x8", 16704, 12064, 511, 63,
1945 63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 2191 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1946static const struct wacom_features wacom_features_0x15 = 2192static const struct wacom_features wacom_features_0x15 =
1947 { "Wacom Graphire4 4x5", WACOM_PKGLEN_GRAPHIRE, 10208, 7424, 511, 2193 { "Wacom Graphire4 4x5", 10208, 7424, 511, 63,
1948 63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 2194 WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1949static const struct wacom_features wacom_features_0x16 = 2195static const struct wacom_features wacom_features_0x16 =
1950 { "Wacom Graphire4 6x8", WACOM_PKGLEN_GRAPHIRE, 16704, 12064, 511, 2196 { "Wacom Graphire4 6x8", 16704, 12064, 511, 63,
1951 63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 2197 WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1952static const struct wacom_features wacom_features_0x17 = 2198static const struct wacom_features wacom_features_0x17 =
1953 { "Wacom BambooFun 4x5", WACOM_PKGLEN_BBFUN, 14760, 9225, 511, 2199 { "Wacom BambooFun 4x5", 14760, 9225, 511, 63,
1954 63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2200 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1955static const struct wacom_features wacom_features_0x18 = 2201static const struct wacom_features wacom_features_0x18 =
1956 { "Wacom BambooFun 6x8", WACOM_PKGLEN_BBFUN, 21648, 13530, 511, 2202 { "Wacom BambooFun 6x8", 21648, 13530, 511, 63,
1957 63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2203 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1958static const struct wacom_features wacom_features_0x19 = 2204static const struct wacom_features wacom_features_0x19 =
1959 { "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE, 16704, 12064, 511, 2205 { "Wacom Bamboo1 Medium", 16704, 12064, 511, 63,
1960 63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES }; 2206 GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
1961static const struct wacom_features wacom_features_0x60 = 2207static const struct wacom_features wacom_features_0x60 =
1962 { "Wacom Volito", WACOM_PKGLEN_GRAPHIRE, 5104, 3712, 511, 2208 { "Wacom Volito", 5104, 3712, 511, 63,
1963 63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES }; 2209 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1964static const struct wacom_features wacom_features_0x61 = 2210static const struct wacom_features wacom_features_0x61 =
1965 { "Wacom PenStation2", WACOM_PKGLEN_GRAPHIRE, 3250, 2320, 255, 2211 { "Wacom PenStation2", 3250, 2320, 255, 63,
1966 63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES }; 2212 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1967static const struct wacom_features wacom_features_0x62 = 2213static const struct wacom_features wacom_features_0x62 =
1968 { "Wacom Volito2 4x5", WACOM_PKGLEN_GRAPHIRE, 5104, 3712, 511, 2214 { "Wacom Volito2 4x5", 5104, 3712, 511, 63,
1969 63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES }; 2215 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1970static const struct wacom_features wacom_features_0x63 = 2216static const struct wacom_features wacom_features_0x63 =
1971 { "Wacom Volito2 2x3", WACOM_PKGLEN_GRAPHIRE, 3248, 2320, 511, 2217 { "Wacom Volito2 2x3", 3248, 2320, 511, 63,
1972 63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES }; 2218 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1973static const struct wacom_features wacom_features_0x64 = 2219static const struct wacom_features wacom_features_0x64 =
1974 { "Wacom PenPartner2", WACOM_PKGLEN_GRAPHIRE, 3250, 2320, 511, 2220 { "Wacom PenPartner2", 3250, 2320, 511, 63,
1975 63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES }; 2221 GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
1976static const struct wacom_features wacom_features_0x65 = 2222static const struct wacom_features wacom_features_0x65 =
1977 { "Wacom Bamboo", WACOM_PKGLEN_BBFUN, 14760, 9225, 511, 2223 { "Wacom Bamboo", 14760, 9225, 511, 63,
1978 63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2224 WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1979static const struct wacom_features wacom_features_0x69 = 2225static const struct wacom_features wacom_features_0x69 =
1980 { "Wacom Bamboo1", WACOM_PKGLEN_GRAPHIRE, 5104, 3712, 511, 2226 { "Wacom Bamboo1", 5104, 3712, 511, 63,
1981 63, GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES }; 2227 GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
1982static const struct wacom_features wacom_features_0x6A = 2228static const struct wacom_features wacom_features_0x6A =
1983 { "Wacom Bamboo1 4x6", WACOM_PKGLEN_GRAPHIRE, 14760, 9225, 1023, 2229 { "Wacom Bamboo1 4x6", 14760, 9225, 1023, 63,
1984 63, GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2230 GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1985static const struct wacom_features wacom_features_0x6B = 2231static const struct wacom_features wacom_features_0x6B =
1986 { "Wacom Bamboo1 5x8", WACOM_PKGLEN_GRAPHIRE, 21648, 13530, 1023, 2232 { "Wacom Bamboo1 5x8", 21648, 13530, 1023, 63,
1987 63, GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2233 GRAPHIRE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1988static const struct wacom_features wacom_features_0x20 = 2234static const struct wacom_features wacom_features_0x20 =
1989 { "Wacom Intuos 4x5", WACOM_PKGLEN_INTUOS, 12700, 10600, 1023, 2235 { "Wacom Intuos 4x5", 12700, 10600, 1023, 31,
1990 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2236 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1991static const struct wacom_features wacom_features_0x21 = 2237static const struct wacom_features wacom_features_0x21 =
1992 { "Wacom Intuos 6x8", WACOM_PKGLEN_INTUOS, 20320, 16240, 1023, 2238 { "Wacom Intuos 6x8", 20320, 16240, 1023, 31,
1993 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2239 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1994static const struct wacom_features wacom_features_0x22 = 2240static const struct wacom_features wacom_features_0x22 =
1995 { "Wacom Intuos 9x12", WACOM_PKGLEN_INTUOS, 30480, 24060, 1023, 2241 { "Wacom Intuos 9x12", 30480, 24060, 1023, 31,
1996 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2242 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
1997static const struct wacom_features wacom_features_0x23 = 2243static const struct wacom_features wacom_features_0x23 =
1998 { "Wacom Intuos 12x12", WACOM_PKGLEN_INTUOS, 30480, 31680, 1023, 2244 { "Wacom Intuos 12x12", 30480, 31680, 1023, 31,
1999 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2245 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2000static const struct wacom_features wacom_features_0x24 = 2246static const struct wacom_features wacom_features_0x24 =
2001 { "Wacom Intuos 12x18", WACOM_PKGLEN_INTUOS, 45720, 31680, 1023, 2247 { "Wacom Intuos 12x18", 45720, 31680, 1023, 31,
2002 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2248 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2003static const struct wacom_features wacom_features_0x30 = 2249static const struct wacom_features wacom_features_0x30 =
2004 { "Wacom PL400", WACOM_PKGLEN_GRAPHIRE, 5408, 4056, 255, 2250 { "Wacom PL400", 5408, 4056, 255, 0,
2005 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2251 PL, WACOM_PL_RES, WACOM_PL_RES };
2006static const struct wacom_features wacom_features_0x31 = 2252static const struct wacom_features wacom_features_0x31 =
2007 { "Wacom PL500", WACOM_PKGLEN_GRAPHIRE, 6144, 4608, 255, 2253 { "Wacom PL500", 6144, 4608, 255, 0,
2008 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2254 PL, WACOM_PL_RES, WACOM_PL_RES };
2009static const struct wacom_features wacom_features_0x32 = 2255static const struct wacom_features wacom_features_0x32 =
2010 { "Wacom PL600", WACOM_PKGLEN_GRAPHIRE, 6126, 4604, 255, 2256 { "Wacom PL600", 6126, 4604, 255, 0,
2011 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2257 PL, WACOM_PL_RES, WACOM_PL_RES };
2012static const struct wacom_features wacom_features_0x33 = 2258static const struct wacom_features wacom_features_0x33 =
2013 { "Wacom PL600SX", WACOM_PKGLEN_GRAPHIRE, 6260, 5016, 255, 2259 { "Wacom PL600SX", 6260, 5016, 255, 0,
2014 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2260 PL, WACOM_PL_RES, WACOM_PL_RES };
2015static const struct wacom_features wacom_features_0x34 = 2261static const struct wacom_features wacom_features_0x34 =
2016 { "Wacom PL550", WACOM_PKGLEN_GRAPHIRE, 6144, 4608, 511, 2262 { "Wacom PL550", 6144, 4608, 511, 0,
2017 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2263 PL, WACOM_PL_RES, WACOM_PL_RES };
2018static const struct wacom_features wacom_features_0x35 = 2264static const struct wacom_features wacom_features_0x35 =
2019 { "Wacom PL800", WACOM_PKGLEN_GRAPHIRE, 7220, 5780, 511, 2265 { "Wacom PL800", 7220, 5780, 511, 0,
2020 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2266 PL, WACOM_PL_RES, WACOM_PL_RES };
2021static const struct wacom_features wacom_features_0x37 = 2267static const struct wacom_features wacom_features_0x37 =
2022 { "Wacom PL700", WACOM_PKGLEN_GRAPHIRE, 6758, 5406, 511, 2268 { "Wacom PL700", 6758, 5406, 511, 0,
2023 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2269 PL, WACOM_PL_RES, WACOM_PL_RES };
2024static const struct wacom_features wacom_features_0x38 = 2270static const struct wacom_features wacom_features_0x38 =
2025 { "Wacom PL510", WACOM_PKGLEN_GRAPHIRE, 6282, 4762, 511, 2271 { "Wacom PL510", 6282, 4762, 511, 0,
2026 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2272 PL, WACOM_PL_RES, WACOM_PL_RES };
2027static const struct wacom_features wacom_features_0x39 = 2273static const struct wacom_features wacom_features_0x39 =
2028 { "Wacom DTU710", WACOM_PKGLEN_GRAPHIRE, 34080, 27660, 511, 2274 { "Wacom DTU710", 34080, 27660, 511, 0,
2029 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2275 PL, WACOM_PL_RES, WACOM_PL_RES };
2030static const struct wacom_features wacom_features_0xC4 = 2276static const struct wacom_features wacom_features_0xC4 =
2031 { "Wacom DTF521", WACOM_PKGLEN_GRAPHIRE, 6282, 4762, 511, 2277 { "Wacom DTF521", 6282, 4762, 511, 0,
2032 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2278 PL, WACOM_PL_RES, WACOM_PL_RES };
2033static const struct wacom_features wacom_features_0xC0 = 2279static const struct wacom_features wacom_features_0xC0 =
2034 { "Wacom DTF720", WACOM_PKGLEN_GRAPHIRE, 6858, 5506, 511, 2280 { "Wacom DTF720", 6858, 5506, 511, 0,
2035 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2281 PL, WACOM_PL_RES, WACOM_PL_RES };
2036static const struct wacom_features wacom_features_0xC2 = 2282static const struct wacom_features wacom_features_0xC2 =
2037 { "Wacom DTF720a", WACOM_PKGLEN_GRAPHIRE, 6858, 5506, 511, 2283 { "Wacom DTF720a", 6858, 5506, 511, 0,
2038 0, PL, WACOM_PL_RES, WACOM_PL_RES }; 2284 PL, WACOM_PL_RES, WACOM_PL_RES };
2039static const struct wacom_features wacom_features_0x03 = 2285static const struct wacom_features wacom_features_0x03 =
2040 { "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE, 20480, 15360, 511, 2286 { "Wacom Cintiq Partner", 20480, 15360, 511, 0,
2041 0, PTU, WACOM_PL_RES, WACOM_PL_RES }; 2287 PTU, WACOM_PL_RES, WACOM_PL_RES };
2042static const struct wacom_features wacom_features_0x41 = 2288static const struct wacom_features wacom_features_0x41 =
2043 { "Wacom Intuos2 4x5", WACOM_PKGLEN_INTUOS, 12700, 10600, 1023, 2289 { "Wacom Intuos2 4x5", 12700, 10600, 1023, 31,
2044 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2290 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2045static const struct wacom_features wacom_features_0x42 = 2291static const struct wacom_features wacom_features_0x42 =
2046 { "Wacom Intuos2 6x8", WACOM_PKGLEN_INTUOS, 20320, 16240, 1023, 2292 { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
2047 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2293 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2048static const struct wacom_features wacom_features_0x43 = 2294static const struct wacom_features wacom_features_0x43 =
2049 { "Wacom Intuos2 9x12", WACOM_PKGLEN_INTUOS, 30480, 24060, 1023, 2295 { "Wacom Intuos2 9x12", 30480, 24060, 1023, 31,
2050 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2296 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2051static const struct wacom_features wacom_features_0x44 = 2297static const struct wacom_features wacom_features_0x44 =
2052 { "Wacom Intuos2 12x12", WACOM_PKGLEN_INTUOS, 30480, 31680, 1023, 2298 { "Wacom Intuos2 12x12", 30480, 31680, 1023, 31,
2053 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2299 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2054static const struct wacom_features wacom_features_0x45 = 2300static const struct wacom_features wacom_features_0x45 =
2055 { "Wacom Intuos2 12x18", WACOM_PKGLEN_INTUOS, 45720, 31680, 1023, 2301 { "Wacom Intuos2 12x18", 45720, 31680, 1023, 31,
2056 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2302 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2057static const struct wacom_features wacom_features_0xB0 = 2303static const struct wacom_features wacom_features_0xB0 =
2058 { "Wacom Intuos3 4x5", WACOM_PKGLEN_INTUOS, 25400, 20320, 1023, 2304 { "Wacom Intuos3 4x5", 25400, 20320, 1023, 63,
2059 63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2305 INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2060static const struct wacom_features wacom_features_0xB1 = 2306static const struct wacom_features wacom_features_0xB1 =
2061 { "Wacom Intuos3 6x8", WACOM_PKGLEN_INTUOS, 40640, 30480, 1023, 2307 { "Wacom Intuos3 6x8", 40640, 30480, 1023, 63,
2062 63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2308 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2063static const struct wacom_features wacom_features_0xB2 = 2309static const struct wacom_features wacom_features_0xB2 =
2064 { "Wacom Intuos3 9x12", WACOM_PKGLEN_INTUOS, 60960, 45720, 1023, 2310 { "Wacom Intuos3 9x12", 60960, 45720, 1023, 63,
2065 63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2311 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2066static const struct wacom_features wacom_features_0xB3 = 2312static const struct wacom_features wacom_features_0xB3 =
2067 { "Wacom Intuos3 12x12", WACOM_PKGLEN_INTUOS, 60960, 60960, 1023, 2313 { "Wacom Intuos3 12x12", 60960, 60960, 1023, 63,
2068 63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2314 INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2069static const struct wacom_features wacom_features_0xB4 = 2315static const struct wacom_features wacom_features_0xB4 =
2070 { "Wacom Intuos3 12x19", WACOM_PKGLEN_INTUOS, 97536, 60960, 1023, 2316 { "Wacom Intuos3 12x19", 97536, 60960, 1023, 63,
2071 63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2317 INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2072static const struct wacom_features wacom_features_0xB5 = 2318static const struct wacom_features wacom_features_0xB5 =
2073 { "Wacom Intuos3 6x11", WACOM_PKGLEN_INTUOS, 54204, 31750, 1023, 2319 { "Wacom Intuos3 6x11", 54204, 31750, 1023, 63,
2074 63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2320 INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2075static const struct wacom_features wacom_features_0xB7 = 2321static const struct wacom_features wacom_features_0xB7 =
2076 { "Wacom Intuos3 4x6", WACOM_PKGLEN_INTUOS, 31496, 19685, 1023, 2322 { "Wacom Intuos3 4x6", 31496, 19685, 1023, 63,
2077 63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2323 INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2078static const struct wacom_features wacom_features_0xB8 = 2324static const struct wacom_features wacom_features_0xB8 =
2079 { "Wacom Intuos4 4x6", WACOM_PKGLEN_INTUOS, 31496, 19685, 2047, 2325 { "Wacom Intuos4 4x6", 31496, 19685, 2047, 63,
2080 63, INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2326 INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2081static const struct wacom_features wacom_features_0xB9 = 2327static const struct wacom_features wacom_features_0xB9 =
2082 { "Wacom Intuos4 6x9", WACOM_PKGLEN_INTUOS, 44704, 27940, 2047, 2328 { "Wacom Intuos4 6x9", 44704, 27940, 2047, 63,
2083 63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2329 INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2084static const struct wacom_features wacom_features_0xBA = 2330static const struct wacom_features wacom_features_0xBA =
2085 { "Wacom Intuos4 8x13", WACOM_PKGLEN_INTUOS, 65024, 40640, 2047, 2331 { "Wacom Intuos4 8x13", 65024, 40640, 2047, 63,
2086 63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2332 INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2087static const struct wacom_features wacom_features_0xBB = 2333static const struct wacom_features wacom_features_0xBB =
2088 { "Wacom Intuos4 12x19", WACOM_PKGLEN_INTUOS, 97536, 60960, 2047, 2334 { "Wacom Intuos4 12x19", 97536, 60960, 2047, 63,
2089 63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2335 INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2090static const struct wacom_features wacom_features_0xBC = 2336static const struct wacom_features wacom_features_0xBC =
2091 { "Wacom Intuos4 WL", WACOM_PKGLEN_INTUOS, 40640, 25400, 2047, 2337 { "Wacom Intuos4 WL", 40640, 25400, 2047, 63,
2092 63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 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 };
2093static const struct wacom_features wacom_features_0x26 = 2342static const struct wacom_features wacom_features_0x26 =
2094 { "Wacom Intuos5 touch S", WACOM_PKGLEN_INTUOS, 31496, 19685, 2047, 2343 { "Wacom Intuos5 touch S", 31496, 19685, 2047, 63,
2095 63, INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 2344 INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
2096 .touch_max = 16 };
2097static const struct wacom_features wacom_features_0x27 = 2345static const struct wacom_features wacom_features_0x27 =
2098 { "Wacom Intuos5 touch M", WACOM_PKGLEN_INTUOS, 44704, 27940, 2047, 2346 { "Wacom Intuos5 touch M", 44704, 27940, 2047, 63,
2099 63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 2347 INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
2100 .touch_max = 16 };
2101static const struct wacom_features wacom_features_0x28 = 2348static const struct wacom_features wacom_features_0x28 =
2102 { "Wacom Intuos5 touch L", WACOM_PKGLEN_INTUOS, 65024, 40640, 2047, 2349 { "Wacom Intuos5 touch L", 65024, 40640, 2047, 63,
2103 63, INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 2350 INTUOS5L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16 };
2104 .touch_max = 16 };
2105static const struct wacom_features wacom_features_0x29 = 2351static const struct wacom_features wacom_features_0x29 =
2106 { "Wacom Intuos5 S", WACOM_PKGLEN_INTUOS, 31496, 19685, 2047, 2352 { "Wacom Intuos5 S", 31496, 19685, 2047, 63,
2107 63, INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2353 INTUOS5S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2108static const struct wacom_features wacom_features_0x2A = 2354static const struct wacom_features wacom_features_0x2A =
2109 { "Wacom Intuos5 M", WACOM_PKGLEN_INTUOS, 44704, 27940, 2047, 2355 { "Wacom Intuos5 M", 44704, 27940, 2047, 63,
2110 63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2356 INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2111static const struct wacom_features wacom_features_0x314 = 2357static const struct wacom_features wacom_features_0x314 =
2112 { "Wacom Intuos Pro S", WACOM_PKGLEN_INTUOS, 31496, 19685, 2047, 2358 { "Wacom Intuos Pro S", 31496, 19685, 2047, 63,
2113 63, INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 2359 INTUOSPS, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
2114 .touch_max = 16 }; 2360 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2115static const struct wacom_features wacom_features_0x315 = 2361static const struct wacom_features wacom_features_0x315 =
2116 { "Wacom Intuos Pro M", WACOM_PKGLEN_INTUOS, 44704, 27940, 2047, 2362 { "Wacom Intuos Pro M", 44704, 27940, 2047, 63,
2117 63, INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 2363 INTUOSPM, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
2118 .touch_max = 16 }; 2364 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2119static const struct wacom_features wacom_features_0x317 = 2365static const struct wacom_features wacom_features_0x317 =
2120 { "Wacom Intuos Pro L", WACOM_PKGLEN_INTUOS, 65024, 40640, 2047, 2366 { "Wacom Intuos Pro L", 65024, 40640, 2047, 63,
2121 63, INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 2367 INTUOSPL, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, .touch_max = 16,
2122 .touch_max = 16 }; 2368 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2123static const struct wacom_features wacom_features_0xF4 = 2369static const struct wacom_features wacom_features_0xF4 =
2124 { "Wacom Cintiq 24HD", WACOM_PKGLEN_INTUOS, 104280, 65400, 2047, 2370 { "Wacom Cintiq 24HD", 104280, 65400, 2047, 63,
2125 63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 }; 2371 WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2126static const struct wacom_features wacom_features_0xF8 = 2372static const struct wacom_features wacom_features_0xF8 =
2127 { "Wacom Cintiq 24HD touch", WACOM_PKGLEN_INTUOS, 104280, 65400, 2047, /* Pen */ 2373 { "Wacom Cintiq 24HD touch", 104280, 65400, 2047, 63, /* Pen */
2128 63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200, 2374 WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2129 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 }; 2375 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf6 };
2130static const struct wacom_features wacom_features_0xF6 = 2376static const struct wacom_features wacom_features_0xF6 =
2131 { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */ 2377 { "Wacom Cintiq 24HD touch", .type = WACOM_24HDT, /* Touch */
2132 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10 }; 2378 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0xf8, .touch_max = 10,
2379 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2133static const struct wacom_features wacom_features_0x3F = 2380static const struct wacom_features wacom_features_0x3F =
2134 { "Wacom Cintiq 21UX", WACOM_PKGLEN_INTUOS, 87200, 65600, 1023, 2381 { "Wacom Cintiq 21UX", 87200, 65600, 1023, 63,
2135 63, CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2382 CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2136static const struct wacom_features wacom_features_0xC5 = 2383static const struct wacom_features wacom_features_0xC5 =
2137 { "Wacom Cintiq 20WSX", WACOM_PKGLEN_INTUOS, 86680, 54180, 1023, 2384 { "Wacom Cintiq 20WSX", 86680, 54180, 1023, 63,
2138 63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2385 WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2139static const struct wacom_features wacom_features_0xC6 = 2386static const struct wacom_features wacom_features_0xC6 =
2140 { "Wacom Cintiq 12WX", WACOM_PKGLEN_INTUOS, 53020, 33440, 1023, 2387 { "Wacom Cintiq 12WX", 53020, 33440, 1023, 63,
2141 63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES }; 2388 WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
2142static const struct wacom_features wacom_features_0x304 = 2389static const struct wacom_features wacom_features_0x304 =
2143 { "Wacom Cintiq 13HD", WACOM_PKGLEN_INTUOS, 59352, 33648, 1023, 2390 { "Wacom Cintiq 13HD", 59352, 33648, 1023, 63,
2144 63, WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 }; 2391 WACOM_13HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2145static const struct wacom_features wacom_features_0xC7 = 2392static const struct wacom_features wacom_features_0xC7 =
2146 { "Wacom DTU1931", WACOM_PKGLEN_GRAPHIRE, 37832, 30305, 511, 2393 { "Wacom DTU1931", 37832, 30305, 511, 0,
2147 0, PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2394 PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2148static const struct wacom_features wacom_features_0xCE = 2395static const struct wacom_features wacom_features_0xCE =
2149 { "Wacom DTU2231", WACOM_PKGLEN_GRAPHIRE, 47864, 27011, 511, 2396 { "Wacom DTU2231", 47864, 27011, 511, 0,
2150 0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2397 DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2398 .check_for_hid_type = true, .hid_type = HID_TYPE_USBMOUSE };
2151static const struct wacom_features wacom_features_0xF0 = 2399static const struct wacom_features wacom_features_0xF0 =
2152 { "Wacom DTU1631", WACOM_PKGLEN_GRAPHIRE, 34623, 19553, 511, 2400 { "Wacom DTU1631", 34623, 19553, 511, 0,
2153 0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2401 DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2154static const struct wacom_features wacom_features_0xFB = 2402static const struct wacom_features wacom_features_0xFB =
2155 { "Wacom DTU1031", WACOM_PKGLEN_DTUS, 22096, 13960, 511, 2403 { "Wacom DTU1031", 22096, 13960, 511, 0,
2156 0, DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2404 DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2157static const struct wacom_features wacom_features_0x57 = 2405static const struct wacom_features wacom_features_0x57 =
2158 { "Wacom DTK2241", WACOM_PKGLEN_INTUOS, 95640, 54060, 2047, 2406 { "Wacom DTK2241", 95640, 54060, 2047, 63,
2159 63, DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 }; 2407 DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2160static const struct wacom_features wacom_features_0x59 = /* Pen */ 2408static const struct wacom_features wacom_features_0x59 = /* Pen */
2161 { "Wacom DTH2242", WACOM_PKGLEN_INTUOS, 95640, 54060, 2047, 2409 { "Wacom DTH2242", 95640, 54060, 2047, 63,
2162 63, DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200, 2410 DTK, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2163 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D }; 2411 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5D };
2164static const struct wacom_features wacom_features_0x5D = /* Touch */ 2412static const struct wacom_features wacom_features_0x5D = /* Touch */
2165 { "Wacom DTH2242", .type = WACOM_24HDT, 2413 { "Wacom DTH2242", .type = WACOM_24HDT,
2166 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10 }; 2414 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x59, .touch_max = 10,
2415 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2167static const struct wacom_features wacom_features_0xCC = 2416static const struct wacom_features wacom_features_0xCC =
2168 { "Wacom Cintiq 21UX2", WACOM_PKGLEN_INTUOS, 87000, 65400, 2047, 2417 { "Wacom Cintiq 21UX2", 87000, 65400, 2047, 63,
2169 63, WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 }; 2418 WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2170static const struct wacom_features wacom_features_0xFA = 2419static const struct wacom_features wacom_features_0xFA =
2171 { "Wacom Cintiq 22HD", WACOM_PKGLEN_INTUOS, 95640, 54060, 2047, 2420 { "Wacom Cintiq 22HD", 95640, 54060, 2047, 63,
2172 63, WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 }; 2421 WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200 };
2173static const struct wacom_features wacom_features_0x5B = 2422static const struct wacom_features wacom_features_0x5B =
2174 { "Wacom Cintiq 22HDT", WACOM_PKGLEN_INTUOS, 95640, 54060, 2047, 2423 { "Wacom Cintiq 22HDT", 95640, 54060, 2047, 63,
2175 63, WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200, 2424 WACOM_22HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2176 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e }; 2425 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5e };
2177static const struct wacom_features wacom_features_0x5E = 2426static const struct wacom_features wacom_features_0x5E =
2178 { "Wacom Cintiq 22HDT", .type = WACOM_24HDT, 2427 { "Wacom Cintiq 22HDT", .type = WACOM_24HDT,
2179 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10 }; 2428 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x5b, .touch_max = 10,
2429 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2180static const struct wacom_features wacom_features_0x90 = 2430static const struct wacom_features wacom_features_0x90 =
2181 { "Wacom ISDv4 90", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 255, 2431 { "Wacom ISDv4 90", 26202, 16325, 255, 0,
2182 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2432 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2183static const struct wacom_features wacom_features_0x93 = 2433static const struct wacom_features wacom_features_0x93 =
2184 { "Wacom ISDv4 93", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 255, 2434 { "Wacom ISDv4 93", 26202, 16325, 255, 0,
2185 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2435 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2186static const struct wacom_features wacom_features_0x97 = 2436static const struct wacom_features wacom_features_0x97 =
2187 { "Wacom ISDv4 97", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 511, 2437 { "Wacom ISDv4 97", 26202, 16325, 511, 0,
2188 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2438 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2189static const struct wacom_features wacom_features_0x9A = 2439static const struct wacom_features wacom_features_0x9A =
2190 { "Wacom ISDv4 9A", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 255, 2440 { "Wacom ISDv4 9A", 26202, 16325, 255, 0,
2191 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2441 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2192static const struct wacom_features wacom_features_0x9F = 2442static const struct wacom_features wacom_features_0x9F =
2193 { "Wacom ISDv4 9F", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 255, 2443 { "Wacom ISDv4 9F", 26202, 16325, 255, 0,
2194 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2444 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2195static const struct wacom_features wacom_features_0xE2 = 2445static const struct wacom_features wacom_features_0xE2 =
2196 { "Wacom ISDv4 E2", WACOM_PKGLEN_TPC2FG, 26202, 16325, 255, 2446 { "Wacom ISDv4 E2", 26202, 16325, 255, 0,
2197 0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2447 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2198 .touch_max = 2 };
2199static const struct wacom_features wacom_features_0xE3 = 2448static const struct wacom_features wacom_features_0xE3 =
2200 { "Wacom ISDv4 E3", WACOM_PKGLEN_TPC2FG, 26202, 16325, 255, 2449 { "Wacom ISDv4 E3", 26202, 16325, 255, 0,
2201 0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2450 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2202 .touch_max = 2 };
2203static const struct wacom_features wacom_features_0xE5 = 2451static const struct wacom_features wacom_features_0xE5 =
2204 { "Wacom ISDv4 E5", WACOM_PKGLEN_MTOUCH, 26202, 16325, 255, 2452 { "Wacom ISDv4 E5", 26202, 16325, 255, 0,
2205 0, MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2453 MTSCREEN, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2206static const struct wacom_features wacom_features_0xE6 = 2454static const struct wacom_features wacom_features_0xE6 =
2207 { "Wacom ISDv4 E6", WACOM_PKGLEN_TPC2FG, 27760, 15694, 255, 2455 { "Wacom ISDv4 E6", 27760, 15694, 255, 0,
2208 0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2456 TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2209 .touch_max = 2 };
2210static const struct wacom_features wacom_features_0xEC = 2457static const struct wacom_features wacom_features_0xEC =
2211 { "Wacom ISDv4 EC", WACOM_PKGLEN_GRAPHIRE, 25710, 14500, 255, 2458 { "Wacom ISDv4 EC", 25710, 14500, 255, 0,
2212 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2459 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2213static const struct wacom_features wacom_features_0xED = 2460static const struct wacom_features wacom_features_0xED =
2214 { "Wacom ISDv4 ED", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 255, 2461 { "Wacom ISDv4 ED", 26202, 16325, 255, 0,
2215 0, TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2462 TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2216static const struct wacom_features wacom_features_0xEF = 2463static const struct wacom_features wacom_features_0xEF =
2217 { "Wacom ISDv4 EF", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 255, 2464 { "Wacom ISDv4 EF", 26202, 16325, 255, 0,
2218 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2465 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2219static const struct wacom_features wacom_features_0x100 = 2466static const struct wacom_features wacom_features_0x100 =
2220 { "Wacom ISDv4 100", WACOM_PKGLEN_MTTPC, 26202, 16325, 255, 2467 { "Wacom ISDv4 100", 26202, 16325, 255, 0,
2221 0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2468 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2222static const struct wacom_features wacom_features_0x101 = 2469static const struct wacom_features wacom_features_0x101 =
2223 { "Wacom ISDv4 101", WACOM_PKGLEN_MTTPC, 26202, 16325, 255, 2470 { "Wacom ISDv4 101", 26202, 16325, 255, 0,
2224 0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2471 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2225static const struct wacom_features wacom_features_0x10D = 2472static const struct wacom_features wacom_features_0x10D =
2226 { "Wacom ISDv4 10D", WACOM_PKGLEN_MTTPC, 26202, 16325, 255, 2473 { "Wacom ISDv4 10D", 26202, 16325, 255, 0,
2227 0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2474 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2228static const struct wacom_features wacom_features_0x10E = 2475static const struct wacom_features wacom_features_0x10E =
2229 { "Wacom ISDv4 10E", WACOM_PKGLEN_MTTPC, 27760, 15694, 255, 2476 { "Wacom ISDv4 10E", 27760, 15694, 255, 0,
2230 0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2477 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2231static const struct wacom_features wacom_features_0x10F = 2478static const struct wacom_features wacom_features_0x10F =
2232 { "Wacom ISDv4 10F", WACOM_PKGLEN_MTTPC, 27760, 15694, 255, 2479 { "Wacom ISDv4 10F", 27760, 15694, 255, 0,
2233 0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2480 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2234static const struct wacom_features wacom_features_0x116 = 2481static const struct wacom_features wacom_features_0x116 =
2235 { "Wacom ISDv4 116", WACOM_PKGLEN_GRAPHIRE, 26202, 16325, 255, 2482 { "Wacom ISDv4 116", 26202, 16325, 255, 0,
2236 0, TABLETPCE, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 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 };
2237static const struct wacom_features wacom_features_0x4001 = 2487static const struct wacom_features wacom_features_0x4001 =
2238 { "Wacom ISDv4 4001", WACOM_PKGLEN_MTTPC, 26202, 16325, 255, 2488 { "Wacom ISDv4 4001", 26202, 16325, 255, 0,
2239 0, MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2489 MTTPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2240static const struct wacom_features wacom_features_0x4004 = 2490static const struct wacom_features wacom_features_0x4004 =
2241 { "Wacom ISDv4 4004", WACOM_PKGLEN_MTTPC, 11060, 6220, 255, 2491 { "Wacom ISDv4 4004", 11060, 6220, 255, 0,
2242 0, MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2492 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2243static const struct wacom_features wacom_features_0x5000 = 2493static const struct wacom_features wacom_features_0x5000 =
2244 { "Wacom ISDv4 5000", WACOM_PKGLEN_MTTPC, 27848, 15752, 1023, 2494 { "Wacom ISDv4 5000", 27848, 15752, 1023, 0,
2245 0, MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2495 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2246static const struct wacom_features wacom_features_0x5002 = 2496static const struct wacom_features wacom_features_0x5002 =
2247 { "Wacom ISDv4 5002", WACOM_PKGLEN_MTTPC, 29576, 16724, 1023, 2497 { "Wacom ISDv4 5002", 29576, 16724, 1023, 0,
2248 0, MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2498 MTTPC_B, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2249static const struct wacom_features wacom_features_0x47 = 2499static const struct wacom_features wacom_features_0x47 =
2250 { "Wacom Intuos2 6x8", WACOM_PKGLEN_INTUOS, 20320, 16240, 1023, 2500 { "Wacom Intuos2 6x8", 20320, 16240, 1023, 31,
2251 31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2501 INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2252static const struct wacom_features wacom_features_0x84 = 2502static const struct wacom_features wacom_features_0x84 =
2253 { "Wacom Wireless Receiver", WACOM_PKGLEN_WIRELESS, 0, 0, 0, 2503 { "Wacom Wireless Receiver", 0, 0, 0, 0,
2254 0, WIRELESS, 0, 0, .touch_max = 16 }; 2504 WIRELESS, 0, 0, .touch_max = 16 };
2255static const struct wacom_features wacom_features_0xD0 = 2505static const struct wacom_features wacom_features_0xD0 =
2256 { "Wacom Bamboo 2FG", WACOM_PKGLEN_BBFUN, 14720, 9200, 1023, 2506 { "Wacom Bamboo 2FG", 14720, 9200, 1023, 31,
2257 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2507 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2258 .touch_max = 2 };
2259static const struct wacom_features wacom_features_0xD1 = 2508static const struct wacom_features wacom_features_0xD1 =
2260 { "Wacom Bamboo 2FG 4x5", WACOM_PKGLEN_BBFUN, 14720, 9200, 1023, 2509 { "Wacom Bamboo 2FG 4x5", 14720, 9200, 1023, 31,
2261 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2510 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2262 .touch_max = 2 };
2263static const struct wacom_features wacom_features_0xD2 = 2511static const struct wacom_features wacom_features_0xD2 =
2264 { "Wacom Bamboo Craft", WACOM_PKGLEN_BBFUN, 14720, 9200, 1023, 2512 { "Wacom Bamboo Craft", 14720, 9200, 1023, 31,
2265 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2513 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2266 .touch_max = 2 };
2267static const struct wacom_features wacom_features_0xD3 = 2514static const struct wacom_features wacom_features_0xD3 =
2268 { "Wacom Bamboo 2FG 6x8", WACOM_PKGLEN_BBFUN, 21648, 13700, 1023, 2515 { "Wacom Bamboo 2FG 6x8", 21648, 13700, 1023, 31,
2269 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2516 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2270 .touch_max = 2 };
2271static const struct wacom_features wacom_features_0xD4 = 2517static const struct wacom_features wacom_features_0xD4 =
2272 { "Wacom Bamboo Pen", WACOM_PKGLEN_BBFUN, 14720, 9200, 1023, 2518 { "Wacom Bamboo Pen", 14720, 9200, 1023, 31,
2273 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2519 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2274static const struct wacom_features wacom_features_0xD5 = 2520static const struct wacom_features wacom_features_0xD5 =
2275 { "Wacom Bamboo Pen 6x8", WACOM_PKGLEN_BBFUN, 21648, 13700, 1023, 2521 { "Wacom Bamboo Pen 6x8", 21648, 13700, 1023, 31,
2276 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2522 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2277static const struct wacom_features wacom_features_0xD6 = 2523static const struct wacom_features wacom_features_0xD6 =
2278 { "Wacom BambooPT 2FG 4x5", WACOM_PKGLEN_BBFUN, 14720, 9200, 1023, 2524 { "Wacom BambooPT 2FG 4x5", 14720, 9200, 1023, 31,
2279 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2525 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2280 .touch_max = 2 };
2281static const struct wacom_features wacom_features_0xD7 = 2526static const struct wacom_features wacom_features_0xD7 =
2282 { "Wacom BambooPT 2FG Small", WACOM_PKGLEN_BBFUN, 14720, 9200, 1023, 2527 { "Wacom BambooPT 2FG Small", 14720, 9200, 1023, 31,
2283 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2528 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2284 .touch_max = 2 };
2285static const struct wacom_features wacom_features_0xD8 = 2529static const struct wacom_features wacom_features_0xD8 =
2286 { "Wacom Bamboo Comic 2FG", WACOM_PKGLEN_BBFUN, 21648, 13700, 1023, 2530 { "Wacom Bamboo Comic 2FG", 21648, 13700, 1023, 31,
2287 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2531 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2288 .touch_max = 2 };
2289static const struct wacom_features wacom_features_0xDA = 2532static const struct wacom_features wacom_features_0xDA =
2290 { "Wacom Bamboo 2FG 4x5 SE", WACOM_PKGLEN_BBFUN, 14720, 9200, 1023, 2533 { "Wacom Bamboo 2FG 4x5 SE", 14720, 9200, 1023, 31,
2291 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2534 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2292 .touch_max = 2 };
2293static const struct wacom_features wacom_features_0xDB = 2535static const struct wacom_features wacom_features_0xDB =
2294 { "Wacom Bamboo 2FG 6x8 SE", WACOM_PKGLEN_BBFUN, 21648, 13700, 1023, 2536 { "Wacom Bamboo 2FG 6x8 SE", 21648, 13700, 1023, 31,
2295 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2537 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 2 };
2296 .touch_max = 2 };
2297static const struct wacom_features wacom_features_0xDD = 2538static const struct wacom_features wacom_features_0xDD =
2298 { "Wacom Bamboo Connect", WACOM_PKGLEN_BBPEN, 14720, 9200, 1023, 2539 { "Wacom Bamboo Connect", 14720, 9200, 1023, 31,
2299 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2540 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2300static const struct wacom_features wacom_features_0xDE = 2541static const struct wacom_features wacom_features_0xDE =
2301 { "Wacom Bamboo 16FG 4x5", WACOM_PKGLEN_BBPEN, 14720, 9200, 1023, 2542 { "Wacom Bamboo 16FG 4x5", 14720, 9200, 1023, 31,
2302 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2543 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
2303 .touch_max = 16 };
2304static const struct wacom_features wacom_features_0xDF = 2544static const struct wacom_features wacom_features_0xDF =
2305 { "Wacom Bamboo 16FG 6x8", WACOM_PKGLEN_BBPEN, 21648, 13700, 1023, 2545 { "Wacom Bamboo 16FG 6x8", 21648, 13700, 1023, 31,
2306 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2546 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16 };
2307 .touch_max = 16 };
2308static const struct wacom_features wacom_features_0x300 = 2547static const struct wacom_features wacom_features_0x300 =
2309 { "Wacom Bamboo One S", WACOM_PKGLEN_BBPEN, 14720, 9225, 1023, 2548 { "Wacom Bamboo One S", 14720, 9225, 1023, 31,
2310 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2549 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2311static const struct wacom_features wacom_features_0x301 = 2550static const struct wacom_features wacom_features_0x301 =
2312 { "Wacom Bamboo One M", WACOM_PKGLEN_BBPEN, 21648, 13530, 1023, 2551 { "Wacom Bamboo One M", 21648, 13530, 1023, 31,
2313 31, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2552 BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2314static const struct wacom_features wacom_features_0x302 = 2553static const struct wacom_features wacom_features_0x302 =
2315 { "Wacom Intuos PT S", WACOM_PKGLEN_BBPEN, 15200, 9500, 1023, 2554 { "Wacom Intuos PT S", 15200, 9500, 1023, 31,
2316 31, INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2555 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
2317 .touch_max = 16 }; 2556 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2318static const struct wacom_features wacom_features_0x303 = 2557static const struct wacom_features wacom_features_0x303 =
2319 { "Wacom Intuos PT M", WACOM_PKGLEN_BBPEN, 21600, 13500, 1023, 2558 { "Wacom Intuos PT M", 21600, 13500, 1023, 31,
2320 31, INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 2559 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
2321 .touch_max = 16 }; 2560 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2322static const struct wacom_features wacom_features_0x30E = 2561static const struct wacom_features wacom_features_0x30E =
2323 { "Wacom Intuos S", WACOM_PKGLEN_BBPEN, 15200, 9500, 1023, 2562 { "Wacom Intuos S", 15200, 9500, 1023, 31,
2324 31, INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2563 INTUOSHT, WACOM_INTUOS_RES, WACOM_INTUOS_RES,
2564 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2325static const struct wacom_features wacom_features_0x6004 = 2565static const struct wacom_features wacom_features_0x6004 =
2326 { "ISD-V4", WACOM_PKGLEN_GRAPHIRE, 12800, 8000, 255, 2566 { "ISD-V4", 12800, 8000, 255, 0,
2327 0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES }; 2567 TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
2328static const struct wacom_features wacom_features_0x0307 = 2568static const struct wacom_features wacom_features_0x307 =
2329 { "Wacom ISDv5 307", WACOM_PKGLEN_INTUOS, 59352, 33648, 2047, 2569 { "Wacom ISDv5 307", 59352, 33648, 2047, 63,
2330 63, CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200, 2570 CINTIQ_HYBRID, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES, 200, 200,
2331 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 }; 2571 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x309 };
2332static const struct wacom_features wacom_features_0x0309 = 2572static const struct wacom_features wacom_features_0x309 =
2333 { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */ 2573 { "Wacom ISDv5 309", .type = WACOM_24HDT, /* Touch */
2334 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10 }; 2574 .oVid = USB_VENDOR_ID_WACOM, .oPid = 0x0307, .touch_max = 10,
2575 .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
2335 2576
2336#define USB_DEVICE_WACOM(prod) \ 2577#define USB_DEVICE_WACOM(prod) \
2337 USB_DEVICE(USB_VENDOR_ID_WACOM, prod), \ 2578 HID_DEVICE(BUS_USB, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
2338 .driver_info = (kernel_ulong_t)&wacom_features_##prod 2579 .driver_data = (kernel_ulong_t)&wacom_features_##prod
2339 2580
2340#define USB_DEVICE_DETAILED(prod, class, sub, proto) \ 2581#define BT_DEVICE_WACOM(prod) \
2341 USB_DEVICE_AND_INTERFACE_INFO(USB_VENDOR_ID_WACOM, prod, class, \ 2582 HID_DEVICE(BUS_BLUETOOTH, HID_GROUP_WACOM, USB_VENDOR_ID_WACOM, prod),\
2342 sub, proto), \ 2583 .driver_data = (kernel_ulong_t)&wacom_features_##prod
2343 .driver_info = (kernel_ulong_t)&wacom_features_##prod
2344 2584
2345#define USB_DEVICE_LENOVO(prod) \ 2585#define USB_DEVICE_LENOVO(prod) \
2346 USB_DEVICE(USB_VENDOR_ID_LENOVO, prod), \ 2586 HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, prod), \
2347 .driver_info = (kernel_ulong_t)&wacom_features_##prod 2587 .driver_data = (kernel_ulong_t)&wacom_features_##prod
2348 2588
2349const struct usb_device_id wacom_ids[] = { 2589const struct hid_device_id wacom_ids[] = {
2350 { USB_DEVICE_WACOM(0x00) }, 2590 { USB_DEVICE_WACOM(0x00) },
2591 { USB_DEVICE_WACOM(0x03) },
2351 { USB_DEVICE_WACOM(0x10) }, 2592 { USB_DEVICE_WACOM(0x10) },
2352 { USB_DEVICE_WACOM(0x11) }, 2593 { USB_DEVICE_WACOM(0x11) },
2353 { USB_DEVICE_WACOM(0x12) }, 2594 { USB_DEVICE_WACOM(0x12) },
@@ -2358,20 +2599,16 @@ const struct usb_device_id wacom_ids[] = {
2358 { USB_DEVICE_WACOM(0x17) }, 2599 { USB_DEVICE_WACOM(0x17) },
2359 { USB_DEVICE_WACOM(0x18) }, 2600 { USB_DEVICE_WACOM(0x18) },
2360 { USB_DEVICE_WACOM(0x19) }, 2601 { USB_DEVICE_WACOM(0x19) },
2361 { USB_DEVICE_WACOM(0x60) },
2362 { USB_DEVICE_WACOM(0x61) },
2363 { USB_DEVICE_WACOM(0x62) },
2364 { USB_DEVICE_WACOM(0x63) },
2365 { USB_DEVICE_WACOM(0x64) },
2366 { USB_DEVICE_WACOM(0x65) },
2367 { USB_DEVICE_WACOM(0x69) },
2368 { USB_DEVICE_WACOM(0x6A) },
2369 { USB_DEVICE_WACOM(0x6B) },
2370 { USB_DEVICE_WACOM(0x20) }, 2602 { USB_DEVICE_WACOM(0x20) },
2371 { USB_DEVICE_WACOM(0x21) }, 2603 { USB_DEVICE_WACOM(0x21) },
2372 { USB_DEVICE_WACOM(0x22) }, 2604 { USB_DEVICE_WACOM(0x22) },
2373 { USB_DEVICE_WACOM(0x23) }, 2605 { USB_DEVICE_WACOM(0x23) },
2374 { USB_DEVICE_WACOM(0x24) }, 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) },
2375 { USB_DEVICE_WACOM(0x30) }, 2612 { USB_DEVICE_WACOM(0x30) },
2376 { USB_DEVICE_WACOM(0x31) }, 2613 { USB_DEVICE_WACOM(0x31) },
2377 { USB_DEVICE_WACOM(0x32) }, 2614 { USB_DEVICE_WACOM(0x32) },
@@ -2381,20 +2618,34 @@ const struct usb_device_id wacom_ids[] = {
2381 { USB_DEVICE_WACOM(0x37) }, 2618 { USB_DEVICE_WACOM(0x37) },
2382 { USB_DEVICE_WACOM(0x38) }, 2619 { USB_DEVICE_WACOM(0x38) },
2383 { USB_DEVICE_WACOM(0x39) }, 2620 { USB_DEVICE_WACOM(0x39) },
2384 { USB_DEVICE_WACOM(0xC4) }, 2621 { USB_DEVICE_WACOM(0x3F) },
2385 { USB_DEVICE_WACOM(0xC0) },
2386 { USB_DEVICE_WACOM(0xC2) },
2387 { USB_DEVICE_WACOM(0x03) },
2388 { USB_DEVICE_WACOM(0x41) }, 2622 { USB_DEVICE_WACOM(0x41) },
2389 { USB_DEVICE_WACOM(0x42) }, 2623 { USB_DEVICE_WACOM(0x42) },
2390 { USB_DEVICE_WACOM(0x43) }, 2624 { USB_DEVICE_WACOM(0x43) },
2391 { USB_DEVICE_WACOM(0x44) }, 2625 { USB_DEVICE_WACOM(0x44) },
2392 { USB_DEVICE_WACOM(0x45) }, 2626 { USB_DEVICE_WACOM(0x45) },
2627 { USB_DEVICE_WACOM(0x47) },
2393 { USB_DEVICE_WACOM(0x57) }, 2628 { USB_DEVICE_WACOM(0x57) },
2394 { USB_DEVICE_WACOM(0x59) }, 2629 { USB_DEVICE_WACOM(0x59) },
2395 { USB_DEVICE_DETAILED(0x5D, USB_CLASS_HID, 0, 0) },
2396 { USB_DEVICE_WACOM(0x5B) }, 2630 { USB_DEVICE_WACOM(0x5B) },
2397 { USB_DEVICE_DETAILED(0x5E, USB_CLASS_HID, 0, 0) }, 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) },
2398 { USB_DEVICE_WACOM(0xB0) }, 2649 { USB_DEVICE_WACOM(0xB0) },
2399 { USB_DEVICE_WACOM(0xB1) }, 2650 { USB_DEVICE_WACOM(0xB1) },
2400 { USB_DEVICE_WACOM(0xB2) }, 2651 { USB_DEVICE_WACOM(0xB2) },
@@ -2407,23 +2658,15 @@ const struct usb_device_id wacom_ids[] = {
2407 { USB_DEVICE_WACOM(0xBA) }, 2658 { USB_DEVICE_WACOM(0xBA) },
2408 { USB_DEVICE_WACOM(0xBB) }, 2659 { USB_DEVICE_WACOM(0xBB) },
2409 { USB_DEVICE_WACOM(0xBC) }, 2660 { USB_DEVICE_WACOM(0xBC) },
2410 { USB_DEVICE_WACOM(0x26) }, 2661 { BT_DEVICE_WACOM(0xBD) },
2411 { USB_DEVICE_WACOM(0x27) }, 2662 { USB_DEVICE_WACOM(0xC0) },
2412 { USB_DEVICE_WACOM(0x28) }, 2663 { USB_DEVICE_WACOM(0xC2) },
2413 { USB_DEVICE_WACOM(0x29) }, 2664 { USB_DEVICE_WACOM(0xC4) },
2414 { USB_DEVICE_WACOM(0x2A) },
2415 { USB_DEVICE_WACOM(0x3F) },
2416 { USB_DEVICE_WACOM(0xC5) }, 2665 { USB_DEVICE_WACOM(0xC5) },
2417 { USB_DEVICE_WACOM(0xC6) }, 2666 { USB_DEVICE_WACOM(0xC6) },
2418 { USB_DEVICE_WACOM(0xC7) }, 2667 { USB_DEVICE_WACOM(0xC7) },
2419 /* 2668 { USB_DEVICE_WACOM(0xCC) },
2420 * DTU-2231 has two interfaces on the same configuration, 2669 { USB_DEVICE_WACOM(0xCE) },
2421 * only one is used.
2422 */
2423 { USB_DEVICE_DETAILED(0xCE, USB_CLASS_HID,
2424 USB_INTERFACE_SUBCLASS_BOOT,
2425 USB_INTERFACE_PROTOCOL_MOUSE) },
2426 { USB_DEVICE_WACOM(0x84) },
2427 { USB_DEVICE_WACOM(0xD0) }, 2670 { USB_DEVICE_WACOM(0xD0) },
2428 { USB_DEVICE_WACOM(0xD1) }, 2671 { USB_DEVICE_WACOM(0xD1) },
2429 { USB_DEVICE_WACOM(0xD2) }, 2672 { USB_DEVICE_WACOM(0xD2) },
@@ -2438,13 +2681,6 @@ const struct usb_device_id wacom_ids[] = {
2438 { USB_DEVICE_WACOM(0xDD) }, 2681 { USB_DEVICE_WACOM(0xDD) },
2439 { USB_DEVICE_WACOM(0xDE) }, 2682 { USB_DEVICE_WACOM(0xDE) },
2440 { USB_DEVICE_WACOM(0xDF) }, 2683 { USB_DEVICE_WACOM(0xDF) },
2441 { USB_DEVICE_WACOM(0xF0) },
2442 { USB_DEVICE_WACOM(0xCC) },
2443 { USB_DEVICE_WACOM(0x90) },
2444 { USB_DEVICE_WACOM(0x93) },
2445 { USB_DEVICE_WACOM(0x97) },
2446 { USB_DEVICE_WACOM(0x9A) },
2447 { USB_DEVICE_WACOM(0x9F) },
2448 { USB_DEVICE_WACOM(0xE2) }, 2684 { USB_DEVICE_WACOM(0xE2) },
2449 { USB_DEVICE_WACOM(0xE3) }, 2685 { USB_DEVICE_WACOM(0xE3) },
2450 { USB_DEVICE_WACOM(0xE5) }, 2686 { USB_DEVICE_WACOM(0xE5) },
@@ -2452,34 +2688,34 @@ const struct usb_device_id wacom_ids[] = {
2452 { USB_DEVICE_WACOM(0xEC) }, 2688 { USB_DEVICE_WACOM(0xEC) },
2453 { USB_DEVICE_WACOM(0xED) }, 2689 { USB_DEVICE_WACOM(0xED) },
2454 { USB_DEVICE_WACOM(0xEF) }, 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) },
2455 { USB_DEVICE_WACOM(0x100) }, 2697 { USB_DEVICE_WACOM(0x100) },
2456 { USB_DEVICE_WACOM(0x101) }, 2698 { USB_DEVICE_WACOM(0x101) },
2457 { USB_DEVICE_WACOM(0x10D) }, 2699 { USB_DEVICE_WACOM(0x10D) },
2458 { USB_DEVICE_WACOM(0x10E) }, 2700 { USB_DEVICE_WACOM(0x10E) },
2459 { USB_DEVICE_WACOM(0x10F) }, 2701 { USB_DEVICE_WACOM(0x10F) },
2460 { USB_DEVICE_WACOM(0x116) }, 2702 { USB_DEVICE_WACOM(0x116) },
2703 { USB_DEVICE_WACOM(0x12C) },
2461 { USB_DEVICE_WACOM(0x300) }, 2704 { USB_DEVICE_WACOM(0x300) },
2462 { USB_DEVICE_WACOM(0x301) }, 2705 { USB_DEVICE_WACOM(0x301) },
2463 { USB_DEVICE_DETAILED(0x302, USB_CLASS_HID, 0, 0) }, 2706 { USB_DEVICE_WACOM(0x302) },
2464 { USB_DEVICE_DETAILED(0x303, USB_CLASS_HID, 0, 0) }, 2707 { USB_DEVICE_WACOM(0x303) },
2465 { USB_DEVICE_DETAILED(0x30E, USB_CLASS_HID, 0, 0) },
2466 { USB_DEVICE_WACOM(0x304) }, 2708 { USB_DEVICE_WACOM(0x304) },
2467 { USB_DEVICE_DETAILED(0x314, USB_CLASS_HID, 0, 0) }, 2709 { USB_DEVICE_WACOM(0x307) },
2468 { USB_DEVICE_DETAILED(0x315, USB_CLASS_HID, 0, 0) }, 2710 { USB_DEVICE_WACOM(0x309) },
2469 { USB_DEVICE_DETAILED(0x317, USB_CLASS_HID, 0, 0) }, 2711 { USB_DEVICE_WACOM(0x30E) },
2712 { USB_DEVICE_WACOM(0x314) },
2713 { USB_DEVICE_WACOM(0x315) },
2714 { USB_DEVICE_WACOM(0x317) },
2470 { USB_DEVICE_WACOM(0x4001) }, 2715 { USB_DEVICE_WACOM(0x4001) },
2471 { USB_DEVICE_WACOM(0x4004) }, 2716 { USB_DEVICE_WACOM(0x4004) },
2472 { USB_DEVICE_WACOM(0x5000) }, 2717 { USB_DEVICE_WACOM(0x5000) },
2473 { USB_DEVICE_WACOM(0x5002) }, 2718 { USB_DEVICE_WACOM(0x5002) },
2474 { USB_DEVICE_WACOM(0x47) },
2475 { USB_DEVICE_WACOM(0xF4) },
2476 { USB_DEVICE_WACOM(0xF8) },
2477 { USB_DEVICE_DETAILED(0xF6, USB_CLASS_HID, 0, 0) },
2478 { USB_DEVICE_WACOM(0xFA) },
2479 { USB_DEVICE_WACOM(0xFB) },
2480 { USB_DEVICE_WACOM(0x0307) },
2481 { USB_DEVICE_DETAILED(0x0309, USB_CLASS_HID, 0, 0) },
2482 { USB_DEVICE_LENOVO(0x6004) },
2483 { } 2719 { }
2484}; 2720};
2485MODULE_DEVICE_TABLE(usb, wacom_ids); 2721MODULE_DEVICE_TABLE(hid, wacom_ids);
diff --git a/drivers/input/tablet/wacom_wac.h b/drivers/hid/wacom_wac.h
index b2c9a9c1b551..339ab5d81a2d 100644
--- a/drivers/input/tablet/wacom_wac.h
+++ b/drivers/hid/wacom_wac.h
@@ -46,6 +46,7 @@
46 46
47/* wacom data packet report IDs */ 47/* wacom data packet report IDs */
48#define WACOM_REPORT_PENABLED 2 48#define WACOM_REPORT_PENABLED 2
49#define WACOM_REPORT_PENABLED_BT 3
49#define WACOM_REPORT_INTUOSREAD 5 50#define WACOM_REPORT_INTUOSREAD 5
50#define WACOM_REPORT_INTUOSWRITE 6 51#define WACOM_REPORT_INTUOSWRITE 6
51#define WACOM_REPORT_INTUOSPAD 12 52#define WACOM_REPORT_INTUOSPAD 12
@@ -68,10 +69,12 @@
68#define WACOM_QUIRK_BBTOUCH_LOWRES 0x0002 69#define WACOM_QUIRK_BBTOUCH_LOWRES 0x0002
69#define WACOM_QUIRK_NO_INPUT 0x0004 70#define WACOM_QUIRK_NO_INPUT 0x0004
70#define WACOM_QUIRK_MONITOR 0x0008 71#define WACOM_QUIRK_MONITOR 0x0008
72#define WACOM_QUIRK_BATTERY 0x0010
71 73
72enum { 74enum {
73 PENPARTNER = 0, 75 PENPARTNER = 0,
74 GRAPHIRE, 76 GRAPHIRE,
77 GRAPHIRE_BT,
75 WACOM_G4, 78 WACOM_G4,
76 PTU, 79 PTU,
77 PL, 80 PL,
@@ -83,6 +86,7 @@ enum {
83 INTUOS3L, 86 INTUOS3L,
84 INTUOS4S, 87 INTUOS4S,
85 INTUOS4, 88 INTUOS4,
89 INTUOS4WL,
86 INTUOS4L, 90 INTUOS4L,
87 INTUOS5S, 91 INTUOS5S,
88 INTUOS5, 92 INTUOS5,
@@ -114,7 +118,6 @@ enum {
114 118
115struct wacom_features { 119struct wacom_features {
116 const char *name; 120 const char *name;
117 int pktlen;
118 int x_max; 121 int x_max;
119 int y_max; 122 int y_max;
120 int pressure_max; 123 int pressure_max;
@@ -127,8 +130,8 @@ struct wacom_features {
127 int device_type; 130 int device_type;
128 int x_phy; 131 int x_phy;
129 int y_phy; 132 int y_phy;
130 unsigned char unit; 133 unsigned unit;
131 unsigned char unitExpo; 134 int unitExpo;
132 int x_fuzz; 135 int x_fuzz;
133 int y_fuzz; 136 int y_fuzz;
134 int pressure_fuzz; 137 int pressure_fuzz;
@@ -137,6 +140,9 @@ struct wacom_features {
137 unsigned touch_max; 140 unsigned touch_max;
138 int oVid; 141 int oVid;
139 int oPid; 142 int oPid;
143 int pktlen;
144 bool check_for_hid_type;
145 int hid_type;
140}; 146};
141 147
142struct wacom_shared { 148struct wacom_shared {
@@ -150,16 +156,24 @@ struct wacom_shared {
150 156
151struct wacom_wac { 157struct wacom_wac {
152 char name[WACOM_NAME_MAX]; 158 char name[WACOM_NAME_MAX];
153 unsigned char *data; 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];
154 int tool[2]; 163 int tool[2];
155 int id[2]; 164 int id[2];
156 __u32 serial[2]; 165 __u32 serial[2];
157 struct wacom_features features; 166 struct wacom_features features;
158 struct wacom_shared *shared; 167 struct wacom_shared *shared;
159 struct input_dev *input; 168 struct input_dev *input;
169 struct input_dev *pad_input;
160 int pid; 170 int pid;
161 int battery_capacity; 171 int battery_capacity;
162 int num_contacts_left; 172 int num_contacts_left;
173 int bat_charging;
174 int ps_connected;
175 u8 bt_features;
176 u8 bt_high_speed;
163}; 177};
164 178
165#endif 179#endif
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index f7e79b481349..a3958c63d7d5 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -665,4 +665,14 @@ config KEYBOARD_CROS_EC
665 To compile this driver as a module, choose M here: the 665 To compile this driver as a module, choose M here: the
666 module will be called cros_ec_keyb. 666 module will be called cros_ec_keyb.
667 667
668config KEYBOARD_CAP1106
669 tristate "Microchip CAP1106 touch sensor"
670 depends on OF && I2C
671 select REGMAP_I2C
672 help
673 Say Y here to enable the CAP1106 touch sensor driver.
674
675 To compile this driver as a module, choose M here: the
676 module will be called cap1106.
677
668endif 678endif
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 7504ae19049d..0a3345634d79 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_KEYBOARD_AMIGA) += amikbd.o
11obj-$(CONFIG_KEYBOARD_ATARI) += atakbd.o 11obj-$(CONFIG_KEYBOARD_ATARI) += atakbd.o
12obj-$(CONFIG_KEYBOARD_ATKBD) += atkbd.o 12obj-$(CONFIG_KEYBOARD_ATKBD) += atkbd.o
13obj-$(CONFIG_KEYBOARD_BFIN) += bf54x-keys.o 13obj-$(CONFIG_KEYBOARD_BFIN) += bf54x-keys.o
14obj-$(CONFIG_KEYBOARD_CAP1106) += cap1106.o
14obj-$(CONFIG_KEYBOARD_CLPS711X) += clps711x-keypad.o 15obj-$(CONFIG_KEYBOARD_CLPS711X) += clps711x-keypad.o
15obj-$(CONFIG_KEYBOARD_CROS_EC) += cros_ec_keyb.o 16obj-$(CONFIG_KEYBOARD_CROS_EC) += cros_ec_keyb.o
16obj-$(CONFIG_KEYBOARD_DAVINCI) += davinci_keyscan.o 17obj-$(CONFIG_KEYBOARD_DAVINCI) += davinci_keyscan.o
diff --git a/drivers/input/keyboard/cap1106.c b/drivers/input/keyboard/cap1106.c
new file mode 100644
index 000000000000..f7d7a0d4ab4e
--- /dev/null
+++ b/drivers/input/keyboard/cap1106.c
@@ -0,0 +1,335 @@
1/*
2 * Input driver for Microchip CAP1106, 6 channel capacitive touch sensor
3 *
4 * http://www.microchip.com/wwwproducts/Devices.aspx?product=CAP1106
5 *
6 * (c) 2014 Daniel Mack <linux@zonque.org>
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 version 2 as
10 * published by the Free Software Foundation.
11 */
12
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/interrupt.h>
16#include <linux/input.h>
17#include <linux/of_irq.h>
18#include <linux/regmap.h>
19#include <linux/i2c.h>
20#include <linux/gpio/consumer.h>
21
22#define CAP1106_REG_MAIN_CONTROL 0x00
23#define CAP1106_REG_MAIN_CONTROL_GAIN_SHIFT (6)
24#define CAP1106_REG_MAIN_CONTROL_GAIN_MASK (0xc0)
25#define CAP1106_REG_MAIN_CONTROL_DLSEEP BIT(4)
26#define CAP1106_REG_GENERAL_STATUS 0x02
27#define CAP1106_REG_SENSOR_INPUT 0x03
28#define CAP1106_REG_NOISE_FLAG_STATUS 0x0a
29#define CAP1106_REG_SENOR_DELTA(X) (0x10 + (X))
30#define CAP1106_REG_SENSITIVITY_CONTROL 0x1f
31#define CAP1106_REG_CONFIG 0x20
32#define CAP1106_REG_SENSOR_ENABLE 0x21
33#define CAP1106_REG_SENSOR_CONFIG 0x22
34#define CAP1106_REG_SENSOR_CONFIG2 0x23
35#define CAP1106_REG_SAMPLING_CONFIG 0x24
36#define CAP1106_REG_CALIBRATION 0x25
37#define CAP1106_REG_INT_ENABLE 0x26
38#define CAP1106_REG_REPEAT_RATE 0x28
39#define CAP1106_REG_MT_CONFIG 0x2a
40#define CAP1106_REG_MT_PATTERN_CONFIG 0x2b
41#define CAP1106_REG_MT_PATTERN 0x2d
42#define CAP1106_REG_RECALIB_CONFIG 0x2f
43#define CAP1106_REG_SENSOR_THRESH(X) (0x30 + (X))
44#define CAP1106_REG_SENSOR_NOISE_THRESH 0x38
45#define CAP1106_REG_STANDBY_CHANNEL 0x40
46#define CAP1106_REG_STANDBY_CONFIG 0x41
47#define CAP1106_REG_STANDBY_SENSITIVITY 0x42
48#define CAP1106_REG_STANDBY_THRESH 0x43
49#define CAP1106_REG_CONFIG2 0x44
50#define CAP1106_REG_SENSOR_BASE_CNT(X) (0x50 + (X))
51#define CAP1106_REG_SENSOR_CALIB (0xb1 + (X))
52#define CAP1106_REG_SENSOR_CALIB_LSB1 0xb9
53#define CAP1106_REG_SENSOR_CALIB_LSB2 0xba
54#define CAP1106_REG_PRODUCT_ID 0xfd
55#define CAP1106_REG_MANUFACTURER_ID 0xfe
56#define CAP1106_REG_REVISION 0xff
57
58#define CAP1106_NUM_CHN 6
59#define CAP1106_PRODUCT_ID 0x55
60#define CAP1106_MANUFACTURER_ID 0x5d
61
62struct cap1106_priv {
63 struct regmap *regmap;
64 struct input_dev *idev;
65
66 /* config */
67 unsigned int keycodes[CAP1106_NUM_CHN];
68};
69
70static const struct reg_default cap1106_reg_defaults[] = {
71 { CAP1106_REG_MAIN_CONTROL, 0x00 },
72 { CAP1106_REG_GENERAL_STATUS, 0x00 },
73 { CAP1106_REG_SENSOR_INPUT, 0x00 },
74 { CAP1106_REG_NOISE_FLAG_STATUS, 0x00 },
75 { CAP1106_REG_SENSITIVITY_CONTROL, 0x2f },
76 { CAP1106_REG_CONFIG, 0x20 },
77 { CAP1106_REG_SENSOR_ENABLE, 0x3f },
78 { CAP1106_REG_SENSOR_CONFIG, 0xa4 },
79 { CAP1106_REG_SENSOR_CONFIG2, 0x07 },
80 { CAP1106_REG_SAMPLING_CONFIG, 0x39 },
81 { CAP1106_REG_CALIBRATION, 0x00 },
82 { CAP1106_REG_INT_ENABLE, 0x3f },
83 { CAP1106_REG_REPEAT_RATE, 0x3f },
84 { CAP1106_REG_MT_CONFIG, 0x80 },
85 { CAP1106_REG_MT_PATTERN_CONFIG, 0x00 },
86 { CAP1106_REG_MT_PATTERN, 0x3f },
87 { CAP1106_REG_RECALIB_CONFIG, 0x8a },
88 { CAP1106_REG_SENSOR_THRESH(0), 0x40 },
89 { CAP1106_REG_SENSOR_THRESH(1), 0x40 },
90 { CAP1106_REG_SENSOR_THRESH(2), 0x40 },
91 { CAP1106_REG_SENSOR_THRESH(3), 0x40 },
92 { CAP1106_REG_SENSOR_THRESH(4), 0x40 },
93 { CAP1106_REG_SENSOR_THRESH(5), 0x40 },
94 { CAP1106_REG_SENSOR_NOISE_THRESH, 0x01 },
95 { CAP1106_REG_STANDBY_CHANNEL, 0x00 },
96 { CAP1106_REG_STANDBY_CONFIG, 0x39 },
97 { CAP1106_REG_STANDBY_SENSITIVITY, 0x02 },
98 { CAP1106_REG_STANDBY_THRESH, 0x40 },
99 { CAP1106_REG_CONFIG2, 0x40 },
100 { CAP1106_REG_SENSOR_CALIB_LSB1, 0x00 },
101 { CAP1106_REG_SENSOR_CALIB_LSB2, 0x00 },
102};
103
104static bool cap1106_volatile_reg(struct device *dev, unsigned int reg)
105{
106 switch (reg) {
107 case CAP1106_REG_MAIN_CONTROL:
108 case CAP1106_REG_SENSOR_INPUT:
109 case CAP1106_REG_SENOR_DELTA(0):
110 case CAP1106_REG_SENOR_DELTA(1):
111 case CAP1106_REG_SENOR_DELTA(2):
112 case CAP1106_REG_SENOR_DELTA(3):
113 case CAP1106_REG_SENOR_DELTA(4):
114 case CAP1106_REG_SENOR_DELTA(5):
115 case CAP1106_REG_PRODUCT_ID:
116 case CAP1106_REG_MANUFACTURER_ID:
117 case CAP1106_REG_REVISION:
118 return true;
119 }
120
121 return false;
122}
123
124static const struct regmap_config cap1106_regmap_config = {
125 .reg_bits = 8,
126 .val_bits = 8,
127
128 .max_register = CAP1106_REG_REVISION,
129 .reg_defaults = cap1106_reg_defaults,
130
131 .num_reg_defaults = ARRAY_SIZE(cap1106_reg_defaults),
132 .cache_type = REGCACHE_RBTREE,
133 .volatile_reg = cap1106_volatile_reg,
134};
135
136static irqreturn_t cap1106_thread_func(int irq_num, void *data)
137{
138 struct cap1106_priv *priv = data;
139 unsigned int status;
140 int ret, i;
141
142 /*
143 * Deassert interrupt. This needs to be done before reading the status
144 * registers, which will not carry valid values otherwise.
145 */
146 ret = regmap_update_bits(priv->regmap, CAP1106_REG_MAIN_CONTROL, 1, 0);
147 if (ret < 0)
148 goto out;
149
150 ret = regmap_read(priv->regmap, CAP1106_REG_SENSOR_INPUT, &status);
151 if (ret < 0)
152 goto out;
153
154 for (i = 0; i < CAP1106_NUM_CHN; i++)
155 input_report_key(priv->idev, priv->keycodes[i],
156 status & (1 << i));
157
158 input_sync(priv->idev);
159
160out:
161 return IRQ_HANDLED;
162}
163
164static int cap1106_set_sleep(struct cap1106_priv *priv, bool sleep)
165{
166 return regmap_update_bits(priv->regmap, CAP1106_REG_MAIN_CONTROL,
167 CAP1106_REG_MAIN_CONTROL_DLSEEP,
168 sleep ? CAP1106_REG_MAIN_CONTROL_DLSEEP : 0);
169}
170
171static int cap1106_input_open(struct input_dev *idev)
172{
173 struct cap1106_priv *priv = input_get_drvdata(idev);
174
175 return cap1106_set_sleep(priv, false);
176}
177
178static void cap1106_input_close(struct input_dev *idev)
179{
180 struct cap1106_priv *priv = input_get_drvdata(idev);
181
182 cap1106_set_sleep(priv, true);
183}
184
185static int cap1106_i2c_probe(struct i2c_client *i2c_client,
186 const struct i2c_device_id *id)
187{
188 struct device *dev = &i2c_client->dev;
189 struct cap1106_priv *priv;
190 struct device_node *node;
191 int i, error, irq, gain = 0;
192 unsigned int val, rev;
193 u32 gain32, keycodes[CAP1106_NUM_CHN];
194
195 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
196 if (!priv)
197 return -ENOMEM;
198
199 priv->regmap = devm_regmap_init_i2c(i2c_client, &cap1106_regmap_config);
200 if (IS_ERR(priv->regmap))
201 return PTR_ERR(priv->regmap);
202
203 error = regmap_read(priv->regmap, CAP1106_REG_PRODUCT_ID, &val);
204 if (error)
205 return error;
206
207 if (val != CAP1106_PRODUCT_ID) {
208 dev_err(dev, "Product ID: Got 0x%02x, expected 0x%02x\n",
209 val, CAP1106_PRODUCT_ID);
210 return -ENODEV;
211 }
212
213 error = regmap_read(priv->regmap, CAP1106_REG_MANUFACTURER_ID, &val);
214 if (error)
215 return error;
216
217 if (val != CAP1106_MANUFACTURER_ID) {
218 dev_err(dev, "Manufacturer ID: Got 0x%02x, expected 0x%02x\n",
219 val, CAP1106_MANUFACTURER_ID);
220 return -ENODEV;
221 }
222
223 error = regmap_read(priv->regmap, CAP1106_REG_REVISION, &rev);
224 if (error < 0)
225 return error;
226
227 dev_info(dev, "CAP1106 detected, revision 0x%02x\n", rev);
228 i2c_set_clientdata(i2c_client, priv);
229 node = dev->of_node;
230
231 if (!of_property_read_u32(node, "microchip,sensor-gain", &gain32)) {
232 if (is_power_of_2(gain32) && gain32 <= 8)
233 gain = ilog2(gain32);
234 else
235 dev_err(dev, "Invalid sensor-gain value %d\n", gain32);
236 }
237
238 BUILD_BUG_ON(ARRAY_SIZE(keycodes) != ARRAY_SIZE(priv->keycodes));
239
240 /* Provide some useful defaults */
241 for (i = 0; i < ARRAY_SIZE(keycodes); i++)
242 keycodes[i] = KEY_A + i;
243
244 of_property_read_u32_array(node, "linux,keycodes",
245 keycodes, ARRAY_SIZE(keycodes));
246
247 for (i = 0; i < ARRAY_SIZE(keycodes); i++)
248 priv->keycodes[i] = keycodes[i];
249
250 error = regmap_update_bits(priv->regmap, CAP1106_REG_MAIN_CONTROL,
251 CAP1106_REG_MAIN_CONTROL_GAIN_MASK,
252 gain << CAP1106_REG_MAIN_CONTROL_GAIN_SHIFT);
253 if (error)
254 return error;
255
256 /* Disable autorepeat. The Linux input system has its own handling. */
257 error = regmap_write(priv->regmap, CAP1106_REG_REPEAT_RATE, 0);
258 if (error)
259 return error;
260
261 priv->idev = devm_input_allocate_device(dev);
262 if (!priv->idev)
263 return -ENOMEM;
264
265 priv->idev->name = "CAP1106 capacitive touch sensor";
266 priv->idev->id.bustype = BUS_I2C;
267 priv->idev->evbit[0] = BIT_MASK(EV_KEY);
268
269 if (of_property_read_bool(node, "autorepeat"))
270 __set_bit(EV_REP, priv->idev->evbit);
271
272 for (i = 0; i < CAP1106_NUM_CHN; i++)
273 __set_bit(priv->keycodes[i], priv->idev->keybit);
274
275 priv->idev->id.vendor = CAP1106_MANUFACTURER_ID;
276 priv->idev->id.product = CAP1106_PRODUCT_ID;
277 priv->idev->id.version = rev;
278
279 priv->idev->open = cap1106_input_open;
280 priv->idev->close = cap1106_input_close;
281
282 input_set_drvdata(priv->idev, priv);
283
284 /*
285 * Put the device in deep sleep mode for now.
286 * ->open() will bring it back once the it is actually needed.
287 */
288 cap1106_set_sleep(priv, true);
289
290 error = input_register_device(priv->idev);
291 if (error)
292 return error;
293
294 irq = irq_of_parse_and_map(node, 0);
295 if (!irq) {
296 dev_err(dev, "Unable to parse or map IRQ\n");
297 return -ENXIO;
298 }
299
300 error = devm_request_threaded_irq(dev, irq, NULL, cap1106_thread_func,
301 IRQF_ONESHOT, dev_name(dev), priv);
302 if (error)
303 return error;
304
305 return 0;
306}
307
308static const struct of_device_id cap1106_dt_ids[] = {
309 { .compatible = "microchip,cap1106", },
310 {}
311};
312MODULE_DEVICE_TABLE(of, cap1106_dt_ids);
313
314static const struct i2c_device_id cap1106_i2c_ids[] = {
315 { "cap1106", 0 },
316 {}
317};
318MODULE_DEVICE_TABLE(i2c, cap1106_i2c_ids);
319
320static struct i2c_driver cap1106_i2c_driver = {
321 .driver = {
322 .name = "cap1106",
323 .owner = THIS_MODULE,
324 .of_match_table = cap1106_dt_ids,
325 },
326 .id_table = cap1106_i2c_ids,
327 .probe = cap1106_i2c_probe,
328};
329
330module_i2c_driver(cap1106_i2c_driver);
331
332MODULE_ALIAS("platform:cap1106");
333MODULE_DESCRIPTION("Microchip CAP1106 driver");
334MODULE_AUTHOR("Daniel Mack <linux@zonque.org>");
335MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/keyboard/imx_keypad.c b/drivers/input/keyboard/imx_keypad.c
index 8280cb16260b..20a99c368d16 100644
--- a/drivers/input/keyboard/imx_keypad.c
+++ b/drivers/input/keyboard/imx_keypad.c
@@ -531,8 +531,7 @@ static int imx_keypad_probe(struct platform_device *pdev)
531 return 0; 531 return 0;
532} 532}
533 533
534#ifdef CONFIG_PM_SLEEP 534static int __maybe_unused imx_kbd_suspend(struct device *dev)
535static int imx_kbd_suspend(struct device *dev)
536{ 535{
537 struct platform_device *pdev = to_platform_device(dev); 536 struct platform_device *pdev = to_platform_device(dev);
538 struct imx_keypad *kbd = platform_get_drvdata(pdev); 537 struct imx_keypad *kbd = platform_get_drvdata(pdev);
@@ -552,7 +551,7 @@ static int imx_kbd_suspend(struct device *dev)
552 return 0; 551 return 0;
553} 552}
554 553
555static int imx_kbd_resume(struct device *dev) 554static int __maybe_unused imx_kbd_resume(struct device *dev)
556{ 555{
557 struct platform_device *pdev = to_platform_device(dev); 556 struct platform_device *pdev = to_platform_device(dev);
558 struct imx_keypad *kbd = platform_get_drvdata(pdev); 557 struct imx_keypad *kbd = platform_get_drvdata(pdev);
@@ -575,7 +574,6 @@ err_clk:
575 574
576 return ret; 575 return ret;
577} 576}
578#endif
579 577
580static SIMPLE_DEV_PM_OPS(imx_kbd_pm_ops, imx_kbd_suspend, imx_kbd_resume); 578static SIMPLE_DEV_PM_OPS(imx_kbd_pm_ops, imx_kbd_suspend, imx_kbd_resume);
581 579
diff --git a/drivers/input/keyboard/max7359_keypad.c b/drivers/input/keyboard/max7359_keypad.c
index 430b54539720..faa6da53eba8 100644
--- a/drivers/input/keyboard/max7359_keypad.c
+++ b/drivers/input/keyboard/max7359_keypad.c
@@ -203,12 +203,17 @@ static int max7359_probe(struct i2c_client *client,
203 203
204 dev_dbg(&client->dev, "keys FIFO is 0x%02x\n", ret); 204 dev_dbg(&client->dev, "keys FIFO is 0x%02x\n", ret);
205 205
206 keypad = kzalloc(sizeof(struct max7359_keypad), GFP_KERNEL); 206 keypad = devm_kzalloc(&client->dev, sizeof(struct max7359_keypad),
207 input_dev = input_allocate_device(); 207 GFP_KERNEL);
208 if (!keypad || !input_dev) { 208 if (!keypad) {
209 dev_err(&client->dev, "failed to allocate memory\n"); 209 dev_err(&client->dev, "failed to allocate memory\n");
210 error = -ENOMEM; 210 return -ENOMEM;
211 goto failed_free_mem; 211 }
212
213 input_dev = devm_input_allocate_device(&client->dev);
214 if (!input_dev) {
215 dev_err(&client->dev, "failed to allocate input device\n");
216 return -ENOMEM;
212 } 217 }
213 218
214 keypad->client = client; 219 keypad->client = client;
@@ -230,19 +235,20 @@ static int max7359_probe(struct i2c_client *client,
230 235
231 max7359_build_keycode(keypad, keymap_data); 236 max7359_build_keycode(keypad, keymap_data);
232 237
233 error = request_threaded_irq(client->irq, NULL, max7359_interrupt, 238 error = devm_request_threaded_irq(&client->dev, client->irq, NULL,
234 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 239 max7359_interrupt,
235 client->name, keypad); 240 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
241 client->name, keypad);
236 if (error) { 242 if (error) {
237 dev_err(&client->dev, "failed to register interrupt\n"); 243 dev_err(&client->dev, "failed to register interrupt\n");
238 goto failed_free_mem; 244 return error;
239 } 245 }
240 246
241 /* Register the input device */ 247 /* Register the input device */
242 error = input_register_device(input_dev); 248 error = input_register_device(input_dev);
243 if (error) { 249 if (error) {
244 dev_err(&client->dev, "failed to register input device\n"); 250 dev_err(&client->dev, "failed to register input device\n");
245 goto failed_free_irq; 251 return error;
246 } 252 }
247 253
248 /* Initialize MAX7359 */ 254 /* Initialize MAX7359 */
@@ -252,24 +258,6 @@ static int max7359_probe(struct i2c_client *client,
252 device_init_wakeup(&client->dev, 1); 258 device_init_wakeup(&client->dev, 1);
253 259
254 return 0; 260 return 0;
255
256failed_free_irq:
257 free_irq(client->irq, keypad);
258failed_free_mem:
259 input_free_device(input_dev);
260 kfree(keypad);
261 return error;
262}
263
264static int max7359_remove(struct i2c_client *client)
265{
266 struct max7359_keypad *keypad = i2c_get_clientdata(client);
267
268 free_irq(client->irq, keypad);
269 input_unregister_device(keypad->input_dev);
270 kfree(keypad);
271
272 return 0;
273} 261}
274 262
275#ifdef CONFIG_PM_SLEEP 263#ifdef CONFIG_PM_SLEEP
@@ -313,7 +301,6 @@ static struct i2c_driver max7359_i2c_driver = {
313 .pm = &max7359_pm, 301 .pm = &max7359_pm,
314 }, 302 },
315 .probe = max7359_probe, 303 .probe = max7359_probe,
316 .remove = max7359_remove,
317 .id_table = max7359_ids, 304 .id_table = max7359_ids,
318}; 305};
319 306
diff --git a/drivers/input/misc/keyspan_remote.c b/drivers/input/misc/keyspan_remote.c
index 01f3b5b300f3..a3fe4a990cc9 100644
--- a/drivers/input/misc/keyspan_remote.c
+++ b/drivers/input/misc/keyspan_remote.c
@@ -392,7 +392,6 @@ static void keyspan_irq_recv(struct urb *urb)
392 392
393 default: 393 default:
394 goto resubmit; 394 goto resubmit;
395 break;
396 } 395 }
397 396
398 if (debug) 397 if (debug)
diff --git a/drivers/input/misc/soc_button_array.c b/drivers/input/misc/soc_button_array.c
index 5a6334be30b8..e34dfc29beb3 100644
--- a/drivers/input/misc/soc_button_array.c
+++ b/drivers/input/misc/soc_button_array.c
@@ -83,6 +83,9 @@ soc_button_device_create(struct pnp_dev *pdev,
83 sizeof(*gpio_keys_pdata) + 83 sizeof(*gpio_keys_pdata) +
84 sizeof(*gpio_keys) * MAX_NBUTTONS, 84 sizeof(*gpio_keys) * MAX_NBUTTONS,
85 GFP_KERNEL); 85 GFP_KERNEL);
86 if (!gpio_keys_pdata)
87 return ERR_PTR(-ENOMEM);
88
86 gpio_keys = (void *)(gpio_keys_pdata + 1); 89 gpio_keys = (void *)(gpio_keys_pdata + 1);
87 90
88 for (info = button_info; info->name; info++) { 91 for (info = button_info; info->name; info++) {
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index 856936247500..421e29e4cd81 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -311,7 +311,14 @@ static int uinput_open(struct inode *inode, struct file *file)
311static int uinput_validate_absbits(struct input_dev *dev) 311static int uinput_validate_absbits(struct input_dev *dev)
312{ 312{
313 unsigned int cnt; 313 unsigned int cnt;
314 int retval = 0; 314 int nslot;
315
316 if (!test_bit(EV_ABS, dev->evbit))
317 return 0;
318
319 /*
320 * Check if absmin/absmax/absfuzz/absflat are sane.
321 */
315 322
316 for (cnt = 0; cnt < ABS_CNT; cnt++) { 323 for (cnt = 0; cnt < ABS_CNT; cnt++) {
317 int min, max; 324 int min, max;
@@ -327,8 +334,7 @@ static int uinput_validate_absbits(struct input_dev *dev)
327 UINPUT_NAME, cnt, 334 UINPUT_NAME, cnt,
328 input_abs_get_min(dev, cnt), 335 input_abs_get_min(dev, cnt),
329 input_abs_get_max(dev, cnt)); 336 input_abs_get_max(dev, cnt));
330 retval = -EINVAL; 337 return -EINVAL;
331 break;
332 } 338 }
333 339
334 if (input_abs_get_flat(dev, cnt) > 340 if (input_abs_get_flat(dev, cnt) >
@@ -340,11 +346,18 @@ static int uinput_validate_absbits(struct input_dev *dev)
340 input_abs_get_flat(dev, cnt), 346 input_abs_get_flat(dev, cnt),
341 input_abs_get_min(dev, cnt), 347 input_abs_get_min(dev, cnt),
342 input_abs_get_max(dev, cnt)); 348 input_abs_get_max(dev, cnt));
343 retval = -EINVAL; 349 return -EINVAL;
344 break;
345 } 350 }
346 } 351 }
347 return retval; 352
353 if (test_bit(ABS_MT_SLOT, dev->absbit)) {
354 nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1;
355 input_mt_init_slots(dev, nslot, 0);
356 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
357 input_set_events_per_packet(dev, 60);
358 }
359
360 return 0;
348} 361}
349 362
350static int uinput_allocate_device(struct uinput_device *udev) 363static int uinput_allocate_device(struct uinput_device *udev)
@@ -410,19 +423,9 @@ static int uinput_setup_device(struct uinput_device *udev,
410 input_abs_set_flat(dev, i, user_dev->absflat[i]); 423 input_abs_set_flat(dev, i, user_dev->absflat[i]);
411 } 424 }
412 425
413 /* check if absmin/absmax/absfuzz/absflat are filled as 426 retval = uinput_validate_absbits(dev);
414 * told in Documentation/input/input-programming.txt */ 427 if (retval < 0)
415 if (test_bit(EV_ABS, dev->evbit)) { 428 goto exit;
416 retval = uinput_validate_absbits(dev);
417 if (retval < 0)
418 goto exit;
419 if (test_bit(ABS_MT_SLOT, dev->absbit)) {
420 int nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1;
421 input_mt_init_slots(dev, nslot, 0);
422 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
423 input_set_events_per_packet(dev, 60);
424 }
425 }
426 429
427 udev->state = UIST_SETUP_COMPLETE; 430 udev->state = UIST_SETUP_COMPLETE;
428 retval = count; 431 retval = count;
@@ -720,6 +723,12 @@ static long uinput_ioctl_handler(struct file *file, unsigned int cmd,
720 } 723 }
721 724
722 switch (cmd) { 725 switch (cmd) {
726 case UI_GET_VERSION:
727 if (put_user(UINPUT_VERSION,
728 (unsigned int __user *)p))
729 retval = -EFAULT;
730 goto out;
731
723 case UI_DEV_CREATE: 732 case UI_DEV_CREATE:
724 retval = uinput_create_device(udev); 733 retval = uinput_create_device(udev);
725 goto out; 734 goto out;
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index fb15c64ffb95..a59a1a64b674 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -99,6 +99,8 @@ static const struct alps_nibble_commands alps_v6_nibble_commands[] = {
99#define ALPS_FOUR_BUTTONS 0x40 /* 4 direction button present */ 99#define ALPS_FOUR_BUTTONS 0x40 /* 4 direction button present */
100#define ALPS_PS2_INTERLEAVED 0x80 /* 3-byte PS/2 packet interleaved with 100#define ALPS_PS2_INTERLEAVED 0x80 /* 3-byte PS/2 packet interleaved with
101 6-byte ALPS packet */ 101 6-byte ALPS packet */
102#define ALPS_IS_RUSHMORE 0x100 /* device is a rushmore */
103#define ALPS_BUTTONPAD 0x200 /* device is a clickpad */
102 104
103static const struct alps_model_info alps_model_data[] = { 105static const struct alps_model_info alps_model_data[] = {
104 { { 0x32, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* Toshiba Salellite Pro M10 */ 106 { { 0x32, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* Toshiba Salellite Pro M10 */
@@ -281,11 +283,10 @@ static void alps_process_packet_v1_v2(struct psmouse *psmouse)
281 * 283 *
282 * The bitmaps don't have enough data to track fingers, so this function 284 * The bitmaps don't have enough data to track fingers, so this function
283 * only generates points representing a bounding box of at most two contacts. 285 * only generates points representing a bounding box of at most two contacts.
284 * These two points are returned in x1, y1, x2, and y2. 286 * These two points are returned in fields->mt.
285 */ 287 */
286static void alps_process_bitmap_dolphin(struct alps_data *priv, 288static void alps_process_bitmap_dolphin(struct alps_data *priv,
287 struct alps_fields *fields, 289 struct alps_fields *fields)
288 int *x1, int *y1, int *x2, int *y2)
289{ 290{
290 int box_middle_x, box_middle_y; 291 int box_middle_x, box_middle_y;
291 unsigned int x_map, y_map; 292 unsigned int x_map, y_map;
@@ -308,8 +309,6 @@ static void alps_process_bitmap_dolphin(struct alps_data *priv,
308 if (x_msb > priv->x_bits || y_msb > priv->y_bits) 309 if (x_msb > priv->x_bits || y_msb > priv->y_bits)
309 return; 310 return;
310 311
311 *x1 = *y1 = *x2 = *y2 = 0;
312
313 if (fields->fingers > 1) { 312 if (fields->fingers > 1) {
314 start_bit = priv->x_bits - x_msb; 313 start_bit = priv->x_bits - x_msb;
315 end_bit = priv->x_bits - x_lsb; 314 end_bit = priv->x_bits - x_lsb;
@@ -320,10 +319,35 @@ static void alps_process_bitmap_dolphin(struct alps_data *priv,
320 end_bit = y_msb - 1; 319 end_bit = y_msb - 1;
321 box_middle_y = (priv->y_max * (start_bit + end_bit)) / 320 box_middle_y = (priv->y_max * (start_bit + end_bit)) /
322 (2 * (priv->y_bits - 1)); 321 (2 * (priv->y_bits - 1));
323 *x1 = fields->x; 322 fields->mt[0] = fields->st;
324 *y1 = fields->y; 323 fields->mt[1].x = 2 * box_middle_x - fields->mt[0].x;
325 *x2 = 2 * box_middle_x - *x1; 324 fields->mt[1].y = 2 * box_middle_y - fields->mt[0].y;
326 *y2 = 2 * box_middle_y - *y1; 325 }
326}
327
328static void alps_get_bitmap_points(unsigned int map,
329 struct alps_bitmap_point *low,
330 struct alps_bitmap_point *high,
331 int *fingers)
332{
333 struct alps_bitmap_point *point;
334 int i, bit, prev_bit = 0;
335
336 point = low;
337 for (i = 0; map != 0; i++, map >>= 1) {
338 bit = map & 1;
339 if (bit) {
340 if (!prev_bit) {
341 point->start_bit = i;
342 point->num_bits = 0;
343 (*fingers)++;
344 }
345 point->num_bits++;
346 } else {
347 if (prev_bit)
348 point = high;
349 }
350 prev_bit = bit;
327 } 351 }
328} 352}
329 353
@@ -334,71 +358,21 @@ static void alps_process_bitmap_dolphin(struct alps_data *priv,
334 * 358 *
335 * The bitmaps don't have enough data to track fingers, so this function 359 * The bitmaps don't have enough data to track fingers, so this function
336 * only generates points representing a bounding box of all contacts. 360 * only generates points representing a bounding box of all contacts.
337 * These points are returned in x1, y1, x2, and y2 when the return value 361 * These points are returned in fields->mt when the return value
338 * is greater than 0. 362 * is greater than 0.
339 */ 363 */
340static int alps_process_bitmap(struct alps_data *priv, 364static int alps_process_bitmap(struct alps_data *priv,
341 unsigned int x_map, unsigned int y_map, 365 struct alps_fields *fields)
342 int *x1, int *y1, int *x2, int *y2)
343{ 366{
344 struct alps_bitmap_point { 367 int i, fingers_x = 0, fingers_y = 0, fingers;
345 int start_bit;
346 int num_bits;
347 };
348
349 int fingers_x = 0, fingers_y = 0, fingers;
350 int i, bit, prev_bit;
351 struct alps_bitmap_point x_low = {0,}, x_high = {0,}; 368 struct alps_bitmap_point x_low = {0,}, x_high = {0,};
352 struct alps_bitmap_point y_low = {0,}, y_high = {0,}; 369 struct alps_bitmap_point y_low = {0,}, y_high = {0,};
353 struct alps_bitmap_point *point;
354 370
355 if (!x_map || !y_map) 371 if (!fields->x_map || !fields->y_map)
356 return 0; 372 return 0;
357 373
358 *x1 = *y1 = *x2 = *y2 = 0; 374 alps_get_bitmap_points(fields->x_map, &x_low, &x_high, &fingers_x);
359 375 alps_get_bitmap_points(fields->y_map, &y_low, &y_high, &fingers_y);
360 prev_bit = 0;
361 point = &x_low;
362 for (i = 0; x_map != 0; i++, x_map >>= 1) {
363 bit = x_map & 1;
364 if (bit) {
365 if (!prev_bit) {
366 point->start_bit = i;
367 fingers_x++;
368 }
369 point->num_bits++;
370 } else {
371 if (prev_bit)
372 point = &x_high;
373 else
374 point->num_bits = 0;
375 }
376 prev_bit = bit;
377 }
378
379 /*
380 * y bitmap is reversed for what we need (lower positions are in
381 * higher bits), so we process from the top end.
382 */
383 y_map = y_map << (sizeof(y_map) * BITS_PER_BYTE - priv->y_bits);
384 prev_bit = 0;
385 point = &y_low;
386 for (i = 0; y_map != 0; i++, y_map <<= 1) {
387 bit = y_map & (1 << (sizeof(y_map) * BITS_PER_BYTE - 1));
388 if (bit) {
389 if (!prev_bit) {
390 point->start_bit = i;
391 fingers_y++;
392 }
393 point->num_bits++;
394 } else {
395 if (prev_bit)
396 point = &y_high;
397 else
398 point->num_bits = 0;
399 }
400 prev_bit = bit;
401 }
402 376
403 /* 377 /*
404 * Fingers can overlap, so we use the maximum count of fingers 378 * Fingers can overlap, so we use the maximum count of fingers
@@ -407,58 +381,91 @@ static int alps_process_bitmap(struct alps_data *priv,
407 fingers = max(fingers_x, fingers_y); 381 fingers = max(fingers_x, fingers_y);
408 382
409 /* 383 /*
410 * If total fingers is > 1 but either axis reports only a single 384 * If an axis reports only a single contact, we have overlapping or
411 * contact, we have overlapping or adjacent fingers. For the 385 * adjacent fingers. Divide the single contact between the two points.
412 * purposes of creating a bounding box, divide the single contact
413 * (roughly) equally between the two points.
414 */ 386 */
415 if (fingers > 1) { 387 if (fingers_x == 1) {
416 if (fingers_x == 1) { 388 i = (x_low.num_bits - 1) / 2;
417 i = x_low.num_bits / 2; 389 x_low.num_bits = x_low.num_bits - i;
418 x_low.num_bits = x_low.num_bits - i; 390 x_high.start_bit = x_low.start_bit + i;
419 x_high.start_bit = x_low.start_bit + i; 391 x_high.num_bits = max(i, 1);
420 x_high.num_bits = max(i, 1); 392 }
421 } else if (fingers_y == 1) { 393 if (fingers_y == 1) {
422 i = y_low.num_bits / 2; 394 i = (y_low.num_bits - 1) / 2;
423 y_low.num_bits = y_low.num_bits - i; 395 y_low.num_bits = y_low.num_bits - i;
424 y_high.start_bit = y_low.start_bit + i; 396 y_high.start_bit = y_low.start_bit + i;
425 y_high.num_bits = max(i, 1); 397 y_high.num_bits = max(i, 1);
426 }
427 } 398 }
428 399
429 *x1 = (priv->x_max * (2 * x_low.start_bit + x_low.num_bits - 1)) / 400 fields->mt[0].x =
430 (2 * (priv->x_bits - 1)); 401 (priv->x_max * (2 * x_low.start_bit + x_low.num_bits - 1)) /
431 *y1 = (priv->y_max * (2 * y_low.start_bit + y_low.num_bits - 1)) / 402 (2 * (priv->x_bits - 1));
432 (2 * (priv->y_bits - 1)); 403 fields->mt[0].y =
433 404 (priv->y_max * (2 * y_low.start_bit + y_low.num_bits - 1)) /
434 if (fingers > 1) { 405 (2 * (priv->y_bits - 1));
435 *x2 = (priv->x_max * 406
436 (2 * x_high.start_bit + x_high.num_bits - 1)) / 407 fields->mt[1].x =
437 (2 * (priv->x_bits - 1)); 408 (priv->x_max * (2 * x_high.start_bit + x_high.num_bits - 1)) /
438 *y2 = (priv->y_max * 409 (2 * (priv->x_bits - 1));
439 (2 * y_high.start_bit + y_high.num_bits - 1)) / 410 fields->mt[1].y =
440 (2 * (priv->y_bits - 1)); 411 (priv->y_max * (2 * y_high.start_bit + y_high.num_bits - 1)) /
412 (2 * (priv->y_bits - 1));
413
414 /* y-bitmap order is reversed, except on rushmore */
415 if (!(priv->flags & ALPS_IS_RUSHMORE)) {
416 fields->mt[0].y = priv->y_max - fields->mt[0].y;
417 fields->mt[1].y = priv->y_max - fields->mt[1].y;
441 } 418 }
442 419
443 return fingers; 420 return fingers;
444} 421}
445 422
446static void alps_set_slot(struct input_dev *dev, int slot, bool active, 423static void alps_set_slot(struct input_dev *dev, int slot, int x, int y)
447 int x, int y)
448{ 424{
449 input_mt_slot(dev, slot); 425 input_mt_slot(dev, slot);
450 input_mt_report_slot_state(dev, MT_TOOL_FINGER, active); 426 input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
451 if (active) { 427 input_report_abs(dev, ABS_MT_POSITION_X, x);
452 input_report_abs(dev, ABS_MT_POSITION_X, x); 428 input_report_abs(dev, ABS_MT_POSITION_Y, y);
453 input_report_abs(dev, ABS_MT_POSITION_Y, y);
454 }
455} 429}
456 430
457static void alps_report_semi_mt_data(struct input_dev *dev, int num_fingers, 431static void alps_report_mt_data(struct psmouse *psmouse, int n)
458 int x1, int y1, int x2, int y2)
459{ 432{
460 alps_set_slot(dev, 0, num_fingers != 0, x1, y1); 433 struct alps_data *priv = psmouse->private;
461 alps_set_slot(dev, 1, num_fingers == 2, x2, y2); 434 struct input_dev *dev = psmouse->dev;
435 struct alps_fields *f = &priv->f;
436 int i, slot[MAX_TOUCHES];
437
438 input_mt_assign_slots(dev, slot, f->mt, n);
439 for (i = 0; i < n; i++)
440 alps_set_slot(dev, slot[i], f->mt[i].x, f->mt[i].y);
441
442 input_mt_sync_frame(dev);
443}
444
445static void alps_report_semi_mt_data(struct psmouse *psmouse, int fingers)
446{
447 struct alps_data *priv = psmouse->private;
448 struct input_dev *dev = psmouse->dev;
449 struct alps_fields *f = &priv->f;
450
451 /* Use st data when we don't have mt data */
452 if (fingers < 2) {
453 f->mt[0].x = f->st.x;
454 f->mt[0].y = f->st.y;
455 fingers = f->pressure > 0 ? 1 : 0;
456 }
457
458 alps_report_mt_data(psmouse, (fingers <= 2) ? fingers : 2);
459
460 input_mt_report_finger_count(dev, fingers);
461
462 input_report_key(dev, BTN_LEFT, f->left);
463 input_report_key(dev, BTN_RIGHT, f->right);
464 input_report_key(dev, BTN_MIDDLE, f->middle);
465
466 input_report_abs(dev, ABS_PRESSURE, f->pressure);
467
468 input_sync(dev);
462} 469}
463 470
464static void alps_process_trackstick_packet_v3(struct psmouse *psmouse) 471static void alps_process_trackstick_packet_v3(struct psmouse *psmouse)
@@ -532,7 +539,7 @@ static void alps_decode_buttons_v3(struct alps_fields *f, unsigned char *p)
532 f->ts_middle = !!(p[3] & 0x40); 539 f->ts_middle = !!(p[3] & 0x40);
533} 540}
534 541
535static void alps_decode_pinnacle(struct alps_fields *f, unsigned char *p, 542static int alps_decode_pinnacle(struct alps_fields *f, unsigned char *p,
536 struct psmouse *psmouse) 543 struct psmouse *psmouse)
537{ 544{
538 f->first_mp = !!(p[4] & 0x40); 545 f->first_mp = !!(p[4] & 0x40);
@@ -546,24 +553,31 @@ static void alps_decode_pinnacle(struct alps_fields *f, unsigned char *p,
546 ((p[2] & 0x7f) << 1) | 553 ((p[2] & 0x7f) << 1) |
547 (p[4] & 0x01); 554 (p[4] & 0x01);
548 555
549 f->x = ((p[1] & 0x7f) << 4) | ((p[4] & 0x30) >> 2) | 556 f->st.x = ((p[1] & 0x7f) << 4) | ((p[4] & 0x30) >> 2) |
550 ((p[0] & 0x30) >> 4); 557 ((p[0] & 0x30) >> 4);
551 f->y = ((p[2] & 0x7f) << 4) | (p[4] & 0x0f); 558 f->st.y = ((p[2] & 0x7f) << 4) | (p[4] & 0x0f);
552 f->z = p[5] & 0x7f; 559 f->pressure = p[5] & 0x7f;
553 560
554 alps_decode_buttons_v3(f, p); 561 alps_decode_buttons_v3(f, p);
562
563 return 0;
555} 564}
556 565
557static void alps_decode_rushmore(struct alps_fields *f, unsigned char *p, 566static int alps_decode_rushmore(struct alps_fields *f, unsigned char *p,
558 struct psmouse *psmouse) 567 struct psmouse *psmouse)
559{ 568{
560 alps_decode_pinnacle(f, p, psmouse); 569 alps_decode_pinnacle(f, p, psmouse);
561 570
571 /* Rushmore's packet decode has a bit difference with Pinnacle's */
572 f->is_mp = !!(p[5] & 0x40);
573 f->fingers = max((p[5] & 0x3), ((p[5] >> 2) & 0x3)) + 1;
562 f->x_map |= (p[5] & 0x10) << 11; 574 f->x_map |= (p[5] & 0x10) << 11;
563 f->y_map |= (p[5] & 0x20) << 6; 575 f->y_map |= (p[5] & 0x20) << 6;
576
577 return 0;
564} 578}
565 579
566static void alps_decode_dolphin(struct alps_fields *f, unsigned char *p, 580static int alps_decode_dolphin(struct alps_fields *f, unsigned char *p,
567 struct psmouse *psmouse) 581 struct psmouse *psmouse)
568{ 582{
569 u64 palm_data = 0; 583 u64 palm_data = 0;
@@ -573,9 +587,9 @@ static void alps_decode_dolphin(struct alps_fields *f, unsigned char *p,
573 f->is_mp = !!(p[0] & 0x20); 587 f->is_mp = !!(p[0] & 0x20);
574 588
575 if (!f->is_mp) { 589 if (!f->is_mp) {
576 f->x = ((p[1] & 0x7f) | ((p[4] & 0x0f) << 7)); 590 f->st.x = ((p[1] & 0x7f) | ((p[4] & 0x0f) << 7));
577 f->y = ((p[2] & 0x7f) | ((p[4] & 0xf0) << 3)); 591 f->st.y = ((p[2] & 0x7f) | ((p[4] & 0xf0) << 3));
578 f->z = (p[0] & 4) ? 0 : p[5] & 0x7f; 592 f->pressure = (p[0] & 4) ? 0 : p[5] & 0x7f;
579 alps_decode_buttons_v3(f, p); 593 alps_decode_buttons_v3(f, p);
580 } else { 594 } else {
581 f->fingers = ((p[0] & 0x6) >> 1 | 595 f->fingers = ((p[0] & 0x6) >> 1 |
@@ -596,19 +610,21 @@ static void alps_decode_dolphin(struct alps_fields *f, unsigned char *p,
596 f->x_map = (palm_data >> priv->y_bits) & 610 f->x_map = (palm_data >> priv->y_bits) &
597 (BIT(priv->x_bits) - 1); 611 (BIT(priv->x_bits) - 1);
598 } 612 }
613
614 return 0;
599} 615}
600 616
601static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse) 617static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse)
602{ 618{
603 struct alps_data *priv = psmouse->private; 619 struct alps_data *priv = psmouse->private;
604 unsigned char *packet = psmouse->packet; 620 unsigned char *packet = psmouse->packet;
605 struct input_dev *dev = psmouse->dev;
606 struct input_dev *dev2 = priv->dev2; 621 struct input_dev *dev2 = priv->dev2;
607 int x1 = 0, y1 = 0, x2 = 0, y2 = 0; 622 struct alps_fields *f = &priv->f;
608 int fingers = 0, bmap_fn; 623 int fingers = 0;
609 struct alps_fields f = {0};
610 624
611 priv->decode_fields(&f, packet, psmouse); 625 memset(f, 0, sizeof(*f));
626
627 priv->decode_fields(f, packet, psmouse);
612 628
613 /* 629 /*
614 * There's no single feature of touchpad position and bitmap packets 630 * There's no single feature of touchpad position and bitmap packets
@@ -623,22 +639,14 @@ static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse)
623 * packet. Check for this, and when it happens process the 639 * packet. Check for this, and when it happens process the
624 * position packet as usual. 640 * position packet as usual.
625 */ 641 */
626 if (f.is_mp) { 642 if (f->is_mp) {
627 fingers = f.fingers; 643 fingers = f->fingers;
628 if (priv->proto_version == ALPS_PROTO_V3) { 644 if (priv->proto_version == ALPS_PROTO_V3) {
629 bmap_fn = alps_process_bitmap(priv, f.x_map, 645 if (alps_process_bitmap(priv, f) == 0)
630 f.y_map, &x1, &y1, 646 fingers = 0; /* Use st data */
631 &x2, &y2);
632
633 /*
634 * We shouldn't report more than one finger if
635 * we don't have two coordinates.
636 */
637 if (fingers > 1 && bmap_fn < 2)
638 fingers = bmap_fn;
639 647
640 /* Now process position packet */ 648 /* Now process position packet */
641 priv->decode_fields(&f, priv->multi_data, 649 priv->decode_fields(f, priv->multi_data,
642 psmouse); 650 psmouse);
643 } else { 651 } else {
644 /* 652 /*
@@ -647,15 +655,14 @@ static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse)
647 * calculate Pt2, so we need to do position 655 * calculate Pt2, so we need to do position
648 * packet decode first. 656 * packet decode first.
649 */ 657 */
650 priv->decode_fields(&f, priv->multi_data, 658 priv->decode_fields(f, priv->multi_data,
651 psmouse); 659 psmouse);
652 660
653 /* 661 /*
654 * Since Dolphin's finger number is reliable, 662 * Since Dolphin's finger number is reliable,
655 * there is no need to compare with bmap_fn. 663 * there is no need to compare with bmap_fn.
656 */ 664 */
657 alps_process_bitmap_dolphin(priv, &f, &x1, &y1, 665 alps_process_bitmap_dolphin(priv, f);
658 &x2, &y2);
659 } 666 }
660 } else { 667 } else {
661 priv->multi_packet = 0; 668 priv->multi_packet = 0;
@@ -670,10 +677,10 @@ static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse)
670 * out misidentified bitmap packets, we reject anything with this 677 * out misidentified bitmap packets, we reject anything with this
671 * bit set. 678 * bit set.
672 */ 679 */
673 if (f.is_mp) 680 if (f->is_mp)
674 return; 681 return;
675 682
676 if (!priv->multi_packet && f.first_mp) { 683 if (!priv->multi_packet && f->first_mp) {
677 priv->multi_packet = 1; 684 priv->multi_packet = 1;
678 memcpy(priv->multi_data, packet, sizeof(priv->multi_data)); 685 memcpy(priv->multi_data, packet, sizeof(priv->multi_data));
679 return; 686 return;
@@ -687,44 +694,15 @@ static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse)
687 * with x, y, and z all zero, so these seem to be flukes. 694 * with x, y, and z all zero, so these seem to be flukes.
688 * Ignore them. 695 * Ignore them.
689 */ 696 */
690 if (f.x && f.y && !f.z) 697 if (f->st.x && f->st.y && !f->pressure)
691 return; 698 return;
692 699
693 /* 700 alps_report_semi_mt_data(psmouse, fingers);
694 * If we don't have MT data or the bitmaps were empty, we have
695 * to rely on ST data.
696 */
697 if (!fingers) {
698 x1 = f.x;
699 y1 = f.y;
700 fingers = f.z > 0 ? 1 : 0;
701 }
702
703 if (f.z >= 64)
704 input_report_key(dev, BTN_TOUCH, 1);
705 else
706 input_report_key(dev, BTN_TOUCH, 0);
707
708 alps_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
709
710 input_mt_report_finger_count(dev, fingers);
711
712 input_report_key(dev, BTN_LEFT, f.left);
713 input_report_key(dev, BTN_RIGHT, f.right);
714 input_report_key(dev, BTN_MIDDLE, f.middle);
715
716 if (f.z > 0) {
717 input_report_abs(dev, ABS_X, f.x);
718 input_report_abs(dev, ABS_Y, f.y);
719 }
720 input_report_abs(dev, ABS_PRESSURE, f.z);
721
722 input_sync(dev);
723 701
724 if (!(priv->quirks & ALPS_QUIRK_TRACKSTICK_BUTTONS)) { 702 if (!(priv->quirks & ALPS_QUIRK_TRACKSTICK_BUTTONS)) {
725 input_report_key(dev2, BTN_LEFT, f.ts_left); 703 input_report_key(dev2, BTN_LEFT, f->ts_left);
726 input_report_key(dev2, BTN_RIGHT, f.ts_right); 704 input_report_key(dev2, BTN_RIGHT, f->ts_right);
727 input_report_key(dev2, BTN_MIDDLE, f.ts_middle); 705 input_report_key(dev2, BTN_MIDDLE, f->ts_middle);
728 input_sync(dev2); 706 input_sync(dev2);
729 } 707 }
730} 708}
@@ -823,13 +801,8 @@ static void alps_process_packet_v4(struct psmouse *psmouse)
823{ 801{
824 struct alps_data *priv = psmouse->private; 802 struct alps_data *priv = psmouse->private;
825 unsigned char *packet = psmouse->packet; 803 unsigned char *packet = psmouse->packet;
826 struct input_dev *dev = psmouse->dev; 804 struct alps_fields *f = &priv->f;
827 int offset; 805 int offset;
828 int x, y, z;
829 int left, right;
830 int x1, y1, x2, y2;
831 int fingers = 0;
832 unsigned int x_bitmap, y_bitmap;
833 806
834 /* 807 /*
835 * v4 has a 6-byte encoding for bitmap data, but this data is 808 * v4 has a 6-byte encoding for bitmap data, but this data is
@@ -851,71 +824,207 @@ static void alps_process_packet_v4(struct psmouse *psmouse)
851 if (++priv->multi_packet > 2) { 824 if (++priv->multi_packet > 2) {
852 priv->multi_packet = 0; 825 priv->multi_packet = 0;
853 826
854 x_bitmap = ((priv->multi_data[2] & 0x1f) << 10) | 827 f->x_map = ((priv->multi_data[2] & 0x1f) << 10) |
855 ((priv->multi_data[3] & 0x60) << 3) | 828 ((priv->multi_data[3] & 0x60) << 3) |
856 ((priv->multi_data[0] & 0x3f) << 2) | 829 ((priv->multi_data[0] & 0x3f) << 2) |
857 ((priv->multi_data[1] & 0x60) >> 5); 830 ((priv->multi_data[1] & 0x60) >> 5);
858 y_bitmap = ((priv->multi_data[5] & 0x01) << 10) | 831 f->y_map = ((priv->multi_data[5] & 0x01) << 10) |
859 ((priv->multi_data[3] & 0x1f) << 5) | 832 ((priv->multi_data[3] & 0x1f) << 5) |
860 (priv->multi_data[1] & 0x1f); 833 (priv->multi_data[1] & 0x1f);
861 834
862 fingers = alps_process_bitmap(priv, x_bitmap, y_bitmap, 835 f->fingers = alps_process_bitmap(priv, f);
863 &x1, &y1, &x2, &y2);
864
865 /* Store MT data.*/
866 priv->fingers = fingers;
867 priv->x1 = x1;
868 priv->x2 = x2;
869 priv->y1 = y1;
870 priv->y2 = y2;
871 } 836 }
872 837
873 left = packet[4] & 0x01; 838 f->left = packet[4] & 0x01;
874 right = packet[4] & 0x02; 839 f->right = packet[4] & 0x02;
875 840
876 x = ((packet[1] & 0x7f) << 4) | ((packet[3] & 0x30) >> 2) | 841 f->st.x = ((packet[1] & 0x7f) << 4) | ((packet[3] & 0x30) >> 2) |
877 ((packet[0] & 0x30) >> 4); 842 ((packet[0] & 0x30) >> 4);
878 y = ((packet[2] & 0x7f) << 4) | (packet[3] & 0x0f); 843 f->st.y = ((packet[2] & 0x7f) << 4) | (packet[3] & 0x0f);
879 z = packet[5] & 0x7f; 844 f->pressure = packet[5] & 0x7f;
880 845
881 /* 846 alps_report_semi_mt_data(psmouse, f->fingers);
882 * If there were no contacts in the bitmap, use ST 847}
883 * points in MT reports. 848
884 * If there were two contacts or more, report MT data. 849static bool alps_is_valid_package_v7(struct psmouse *psmouse)
885 */ 850{
886 if (priv->fingers < 2) { 851 switch (psmouse->pktcnt) {
887 x1 = x; 852 case 3:
888 y1 = y; 853 return (psmouse->packet[2] & 0x40) == 0x40;
889 fingers = z > 0 ? 1 : 0; 854 case 4:
890 } else { 855 return (psmouse->packet[3] & 0x48) == 0x48;
891 fingers = priv->fingers; 856 case 6:
892 x1 = priv->x1; 857 return (psmouse->packet[5] & 0x40) == 0x00;
893 x2 = priv->x2;
894 y1 = priv->y1;
895 y2 = priv->y2;
896 } 858 }
859 return true;
860}
897 861
898 if (z >= 64) 862static unsigned char alps_get_packet_id_v7(char *byte)
899 input_report_key(dev, BTN_TOUCH, 1); 863{
864 unsigned char packet_id;
865
866 if (byte[4] & 0x40)
867 packet_id = V7_PACKET_ID_TWO;
868 else if (byte[4] & 0x01)
869 packet_id = V7_PACKET_ID_MULTI;
870 else if ((byte[0] & 0x10) && !(byte[4] & 0x43))
871 packet_id = V7_PACKET_ID_NEW;
872 else if (byte[1] == 0x00 && byte[4] == 0x00)
873 packet_id = V7_PACKET_ID_IDLE;
900 else 874 else
901 input_report_key(dev, BTN_TOUCH, 0); 875 packet_id = V7_PACKET_ID_UNKNOWN;
902 876
903 alps_report_semi_mt_data(dev, fingers, x1, y1, x2, y2); 877 return packet_id;
878}
904 879
905 input_mt_report_finger_count(dev, fingers); 880static void alps_get_finger_coordinate_v7(struct input_mt_pos *mt,
881 unsigned char *pkt,
882 unsigned char pkt_id)
883{
884 mt[0].x = ((pkt[2] & 0x80) << 4);
885 mt[0].x |= ((pkt[2] & 0x3F) << 5);
886 mt[0].x |= ((pkt[3] & 0x30) >> 1);
887 mt[0].x |= (pkt[3] & 0x07);
888 mt[0].y = (pkt[1] << 3) | (pkt[0] & 0x07);
889
890 mt[1].x = ((pkt[3] & 0x80) << 4);
891 mt[1].x |= ((pkt[4] & 0x80) << 3);
892 mt[1].x |= ((pkt[4] & 0x3F) << 4);
893 mt[1].y = ((pkt[5] & 0x80) << 3);
894 mt[1].y |= ((pkt[5] & 0x3F) << 4);
895
896 switch (pkt_id) {
897 case V7_PACKET_ID_TWO:
898 mt[1].x &= ~0x000F;
899 mt[1].y |= 0x000F;
900 break;
906 901
907 input_report_key(dev, BTN_LEFT, left); 902 case V7_PACKET_ID_MULTI:
908 input_report_key(dev, BTN_RIGHT, right); 903 mt[1].x &= ~0x003F;
904 mt[1].y &= ~0x0020;
905 mt[1].y |= ((pkt[4] & 0x02) << 4);
906 mt[1].y |= 0x001F;
907 break;
909 908
910 if (z > 0) { 909 case V7_PACKET_ID_NEW:
911 input_report_abs(dev, ABS_X, x); 910 mt[1].x &= ~0x003F;
912 input_report_abs(dev, ABS_Y, y); 911 mt[1].x |= (pkt[0] & 0x20);
912 mt[1].y |= 0x000F;
913 break;
913 } 914 }
914 input_report_abs(dev, ABS_PRESSURE, z); 915
916 mt[0].y = 0x7FF - mt[0].y;
917 mt[1].y = 0x7FF - mt[1].y;
918}
919
920static int alps_get_mt_count(struct input_mt_pos *mt)
921{
922 int i;
923
924 for (i = 0; i < MAX_TOUCHES && mt[i].x != 0 && mt[i].y != 0; i++)
925 /* empty */;
926
927 return i;
928}
929
930static int alps_decode_packet_v7(struct alps_fields *f,
931 unsigned char *p,
932 struct psmouse *psmouse)
933{
934 unsigned char pkt_id;
935
936 pkt_id = alps_get_packet_id_v7(p);
937 if (pkt_id == V7_PACKET_ID_IDLE)
938 return 0;
939 if (pkt_id == V7_PACKET_ID_UNKNOWN)
940 return -1;
941
942 alps_get_finger_coordinate_v7(f->mt, p, pkt_id);
943
944 if (pkt_id == V7_PACKET_ID_TWO || pkt_id == V7_PACKET_ID_MULTI) {
945 f->left = (p[0] & 0x80) >> 7;
946 f->right = (p[0] & 0x20) >> 5;
947 f->middle = (p[0] & 0x10) >> 4;
948 }
949
950 if (pkt_id == V7_PACKET_ID_TWO)
951 f->fingers = alps_get_mt_count(f->mt);
952 else if (pkt_id == V7_PACKET_ID_MULTI)
953 f->fingers = 3 + (p[5] & 0x03);
954
955 return 0;
956}
957
958static void alps_process_trackstick_packet_v7(struct psmouse *psmouse)
959{
960 struct alps_data *priv = psmouse->private;
961 unsigned char *packet = psmouse->packet;
962 struct input_dev *dev2 = priv->dev2;
963 int x, y, z, left, right, middle;
964
965 /*
966 * b7 b6 b5 b4 b3 b2 b1 b0
967 * Byte0 0 1 0 0 1 0 0 0
968 * Byte1 1 1 * * 1 M R L
969 * Byte2 X7 1 X5 X4 X3 X2 X1 X0
970 * Byte3 Z6 1 Y6 X6 1 Y2 Y1 Y0
971 * Byte4 Y7 0 Y5 Y4 Y3 1 1 0
972 * Byte5 T&P 0 Z5 Z4 Z3 Z2 Z1 Z0
973 * M / R / L: Middle / Right / Left button
974 */
975
976 x = ((packet[2] & 0xbf)) | ((packet[3] & 0x10) << 2);
977 y = (packet[3] & 0x07) | (packet[4] & 0xb8) |
978 ((packet[3] & 0x20) << 1);
979 z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1);
980
981 left = (packet[1] & 0x01);
982 right = (packet[1] & 0x02) >> 1;
983 middle = (packet[1] & 0x04) >> 2;
984
985 /* Divide 2 since trackpoint's speed is too fast */
986 input_report_rel(dev2, REL_X, (char)x / 2);
987 input_report_rel(dev2, REL_Y, -((char)y / 2));
988
989 input_report_key(dev2, BTN_LEFT, left);
990 input_report_key(dev2, BTN_RIGHT, right);
991 input_report_key(dev2, BTN_MIDDLE, middle);
992
993 input_sync(dev2);
994}
995
996static void alps_process_touchpad_packet_v7(struct psmouse *psmouse)
997{
998 struct alps_data *priv = psmouse->private;
999 struct input_dev *dev = psmouse->dev;
1000 struct alps_fields *f = &priv->f;
1001
1002 memset(f, 0, sizeof(*f));
1003
1004 if (priv->decode_fields(f, psmouse->packet, psmouse))
1005 return;
1006
1007 alps_report_mt_data(psmouse, alps_get_mt_count(f->mt));
1008
1009 input_mt_report_finger_count(dev, f->fingers);
1010
1011 input_report_key(dev, BTN_LEFT, f->left);
1012 input_report_key(dev, BTN_RIGHT, f->right);
1013 input_report_key(dev, BTN_MIDDLE, f->middle);
915 1014
916 input_sync(dev); 1015 input_sync(dev);
917} 1016}
918 1017
1018static void alps_process_packet_v7(struct psmouse *psmouse)
1019{
1020 unsigned char *packet = psmouse->packet;
1021
1022 if (packet[0] == 0x48 && (packet[4] & 0x47) == 0x06)
1023 alps_process_trackstick_packet_v7(psmouse);
1024 else
1025 alps_process_touchpad_packet_v7(psmouse);
1026}
1027
919static void alps_report_bare_ps2_packet(struct psmouse *psmouse, 1028static void alps_report_bare_ps2_packet(struct psmouse *psmouse,
920 unsigned char packet[], 1029 unsigned char packet[],
921 bool report_buttons) 1030 bool report_buttons)
@@ -1080,6 +1189,14 @@ static psmouse_ret_t alps_process_byte(struct psmouse *psmouse)
1080 return PSMOUSE_BAD_DATA; 1189 return PSMOUSE_BAD_DATA;
1081 } 1190 }
1082 1191
1192 if (priv->proto_version == ALPS_PROTO_V7 &&
1193 !alps_is_valid_package_v7(psmouse)) {
1194 psmouse_dbg(psmouse, "refusing packet[%i] = %x\n",
1195 psmouse->pktcnt - 1,
1196 psmouse->packet[psmouse->pktcnt - 1]);
1197 return PSMOUSE_BAD_DATA;
1198 }
1199
1083 if (psmouse->pktcnt == psmouse->pktsize) { 1200 if (psmouse->pktcnt == psmouse->pktsize) {
1084 priv->process_packet(psmouse); 1201 priv->process_packet(psmouse);
1085 return PSMOUSE_FULL_PACKET; 1202 return PSMOUSE_FULL_PACKET;
@@ -1192,6 +1309,22 @@ static int alps_rpt_cmd(struct psmouse *psmouse, int init_command,
1192 return 0; 1309 return 0;
1193} 1310}
1194 1311
1312static bool alps_check_valid_firmware_id(unsigned char id[])
1313{
1314 if (id[0] == 0x73)
1315 return true;
1316
1317 if (id[0] == 0x88 &&
1318 (id[1] == 0x07 ||
1319 id[1] == 0x08 ||
1320 (id[1] & 0xf0) == 0xb0 ||
1321 (id[1] & 0xf0) == 0xc0)) {
1322 return true;
1323 }
1324
1325 return false;
1326}
1327
1195static int alps_enter_command_mode(struct psmouse *psmouse) 1328static int alps_enter_command_mode(struct psmouse *psmouse)
1196{ 1329{
1197 unsigned char param[4]; 1330 unsigned char param[4];
@@ -1201,8 +1334,7 @@ static int alps_enter_command_mode(struct psmouse *psmouse)
1201 return -1; 1334 return -1;
1202 } 1335 }
1203 1336
1204 if ((param[0] != 0x88 || (param[1] != 0x07 && param[1] != 0x08)) && 1337 if (!alps_check_valid_firmware_id(param)) {
1205 param[0] != 0x73) {
1206 psmouse_dbg(psmouse, 1338 psmouse_dbg(psmouse,
1207 "unknown response while entering command mode\n"); 1339 "unknown response while entering command mode\n");
1208 return -1; 1340 return -1;
@@ -1660,6 +1792,45 @@ error:
1660 return -1; 1792 return -1;
1661} 1793}
1662 1794
1795static int alps_get_v3_v7_resolution(struct psmouse *psmouse, int reg_pitch)
1796{
1797 int reg, x_pitch, y_pitch, x_electrode, y_electrode, x_phys, y_phys;
1798 struct alps_data *priv = psmouse->private;
1799
1800 reg = alps_command_mode_read_reg(psmouse, reg_pitch);
1801 if (reg < 0)
1802 return reg;
1803
1804 x_pitch = (char)(reg << 4) >> 4; /* sign extend lower 4 bits */
1805 x_pitch = 50 + 2 * x_pitch; /* In 0.1 mm units */
1806
1807 y_pitch = (char)reg >> 4; /* sign extend upper 4 bits */
1808 y_pitch = 36 + 2 * y_pitch; /* In 0.1 mm units */
1809
1810 reg = alps_command_mode_read_reg(psmouse, reg_pitch + 1);
1811 if (reg < 0)
1812 return reg;
1813
1814 x_electrode = (char)(reg << 4) >> 4; /* sign extend lower 4 bits */
1815 x_electrode = 17 + x_electrode;
1816
1817 y_electrode = (char)reg >> 4; /* sign extend upper 4 bits */
1818 y_electrode = 13 + y_electrode;
1819
1820 x_phys = x_pitch * (x_electrode - 1); /* In 0.1 mm units */
1821 y_phys = y_pitch * (y_electrode - 1); /* In 0.1 mm units */
1822
1823 priv->x_res = priv->x_max * 10 / x_phys; /* units / mm */
1824 priv->y_res = priv->y_max * 10 / y_phys; /* units / mm */
1825
1826 psmouse_dbg(psmouse,
1827 "pitch %dx%d num-electrodes %dx%d physical size %dx%d mm res %dx%d\n",
1828 x_pitch, y_pitch, x_electrode, y_electrode,
1829 x_phys / 10, y_phys / 10, priv->x_res, priv->y_res);
1830
1831 return 0;
1832}
1833
1663static int alps_hw_init_rushmore_v3(struct psmouse *psmouse) 1834static int alps_hw_init_rushmore_v3(struct psmouse *psmouse)
1664{ 1835{
1665 struct alps_data *priv = psmouse->private; 1836 struct alps_data *priv = psmouse->private;
@@ -1680,6 +1851,9 @@ static int alps_hw_init_rushmore_v3(struct psmouse *psmouse)
1680 alps_command_mode_write_reg(psmouse, 0xc2cb, 0x00)) 1851 alps_command_mode_write_reg(psmouse, 0xc2cb, 0x00))
1681 goto error; 1852 goto error;
1682 1853
1854 if (alps_get_v3_v7_resolution(psmouse, 0xc2da))
1855 goto error;
1856
1683 reg_val = alps_command_mode_read_reg(psmouse, 0xc2c6); 1857 reg_val = alps_command_mode_read_reg(psmouse, 0xc2c6);
1684 if (reg_val == -1) 1858 if (reg_val == -1)
1685 goto error; 1859 goto error;
@@ -1856,6 +2030,35 @@ static int alps_hw_init_dolphin_v1(struct psmouse *psmouse)
1856 return 0; 2030 return 0;
1857} 2031}
1858 2032
2033static int alps_hw_init_v7(struct psmouse *psmouse)
2034{
2035 struct ps2dev *ps2dev = &psmouse->ps2dev;
2036 int reg_val, ret = -1;
2037
2038 if (alps_enter_command_mode(psmouse) ||
2039 alps_command_mode_read_reg(psmouse, 0xc2d9) == -1)
2040 goto error;
2041
2042 if (alps_get_v3_v7_resolution(psmouse, 0xc397))
2043 goto error;
2044
2045 if (alps_command_mode_write_reg(psmouse, 0xc2c9, 0x64))
2046 goto error;
2047
2048 reg_val = alps_command_mode_read_reg(psmouse, 0xc2c4);
2049 if (reg_val == -1)
2050 goto error;
2051 if (__alps_command_mode_write_reg(psmouse, reg_val | 0x02))
2052 goto error;
2053
2054 alps_exit_command_mode(psmouse);
2055 return ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE);
2056
2057error:
2058 alps_exit_command_mode(psmouse);
2059 return ret;
2060}
2061
1859static void alps_set_defaults(struct alps_data *priv) 2062static void alps_set_defaults(struct alps_data *priv)
1860{ 2063{
1861 priv->byte0 = 0x8f; 2064 priv->byte0 = 0x8f;
@@ -1914,6 +2117,21 @@ static void alps_set_defaults(struct alps_data *priv)
1914 priv->x_max = 2047; 2117 priv->x_max = 2047;
1915 priv->y_max = 1535; 2118 priv->y_max = 1535;
1916 break; 2119 break;
2120 case ALPS_PROTO_V7:
2121 priv->hw_init = alps_hw_init_v7;
2122 priv->process_packet = alps_process_packet_v7;
2123 priv->decode_fields = alps_decode_packet_v7;
2124 priv->set_abs_params = alps_set_abs_params_mt;
2125 priv->nibble_commands = alps_v3_nibble_commands;
2126 priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
2127 priv->x_max = 0xfff;
2128 priv->y_max = 0x7ff;
2129 priv->byte0 = 0x48;
2130 priv->mask0 = 0x48;
2131
2132 if (priv->fw_ver[1] != 0xba)
2133 priv->flags |= ALPS_BUTTONPAD;
2134 break;
1917 } 2135 }
1918} 2136}
1919 2137
@@ -1972,6 +2190,9 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
1972 alps_exit_command_mode(psmouse)) 2190 alps_exit_command_mode(psmouse))
1973 return -EIO; 2191 return -EIO;
1974 2192
2193 /* Save the Firmware version */
2194 memcpy(priv->fw_ver, ec, 3);
2195
1975 if (alps_match_table(psmouse, priv, e7, ec) == 0) { 2196 if (alps_match_table(psmouse, priv, e7, ec) == 0) {
1976 return 0; 2197 return 0;
1977 } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0x50 && 2198 } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0x50 &&
@@ -1982,6 +2203,12 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
1982 return -EIO; 2203 return -EIO;
1983 else 2204 else
1984 return 0; 2205 return 0;
2206 } else if (ec[0] == 0x88 &&
2207 ((ec[1] & 0xf0) == 0xb0 || (ec[1] & 0xf0) == 0xc0)) {
2208 priv->proto_version = ALPS_PROTO_V7;
2209 alps_set_defaults(priv);
2210
2211 return 0;
1985 } else if (ec[0] == 0x88 && ec[1] == 0x08) { 2212 } else if (ec[0] == 0x88 && ec[1] == 0x08) {
1986 priv->proto_version = ALPS_PROTO_V3; 2213 priv->proto_version = ALPS_PROTO_V3;
1987 alps_set_defaults(priv); 2214 alps_set_defaults(priv);
@@ -1990,6 +2217,7 @@ static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
1990 priv->decode_fields = alps_decode_rushmore; 2217 priv->decode_fields = alps_decode_rushmore;
1991 priv->x_bits = 16; 2218 priv->x_bits = 16;
1992 priv->y_bits = 12; 2219 priv->y_bits = 12;
2220 priv->flags |= ALPS_IS_RUSHMORE;
1993 2221
1994 /* hack to make addr_command, nibble_command available */ 2222 /* hack to make addr_command, nibble_command available */
1995 psmouse->private = priv; 2223 psmouse->private = priv;
@@ -2044,17 +2272,21 @@ static void alps_set_abs_params_st(struct alps_data *priv,
2044static void alps_set_abs_params_mt(struct alps_data *priv, 2272static void alps_set_abs_params_mt(struct alps_data *priv,
2045 struct input_dev *dev1) 2273 struct input_dev *dev1)
2046{ 2274{
2047 set_bit(INPUT_PROP_SEMI_MT, dev1->propbit);
2048 input_mt_init_slots(dev1, 2, 0);
2049 input_set_abs_params(dev1, ABS_MT_POSITION_X, 0, priv->x_max, 0, 0); 2275 input_set_abs_params(dev1, ABS_MT_POSITION_X, 0, priv->x_max, 0, 0);
2050 input_set_abs_params(dev1, ABS_MT_POSITION_Y, 0, priv->y_max, 0, 0); 2276 input_set_abs_params(dev1, ABS_MT_POSITION_Y, 0, priv->y_max, 0, 0);
2051 2277
2052 set_bit(BTN_TOOL_DOUBLETAP, dev1->keybit); 2278 input_abs_set_res(dev1, ABS_MT_POSITION_X, priv->x_res);
2279 input_abs_set_res(dev1, ABS_MT_POSITION_Y, priv->y_res);
2280
2281 input_mt_init_slots(dev1, MAX_TOUCHES, INPUT_MT_POINTER |
2282 INPUT_MT_DROP_UNUSED | INPUT_MT_TRACK | INPUT_MT_SEMI_MT);
2283
2053 set_bit(BTN_TOOL_TRIPLETAP, dev1->keybit); 2284 set_bit(BTN_TOOL_TRIPLETAP, dev1->keybit);
2054 set_bit(BTN_TOOL_QUADTAP, dev1->keybit); 2285 set_bit(BTN_TOOL_QUADTAP, dev1->keybit);
2055 2286
2056 input_set_abs_params(dev1, ABS_X, 0, priv->x_max, 0, 0); 2287 /* V7 is real multi-touch */
2057 input_set_abs_params(dev1, ABS_Y, 0, priv->y_max, 0, 0); 2288 if (priv->proto_version == ALPS_PROTO_V7)
2289 clear_bit(INPUT_PROP_SEMI_MT, dev1->propbit);
2058} 2290}
2059 2291
2060int alps_init(struct psmouse *psmouse) 2292int alps_init(struct psmouse *psmouse)
@@ -2100,7 +2332,9 @@ int alps_init(struct psmouse *psmouse)
2100 dev1->evbit[BIT_WORD(EV_ABS)] |= BIT_MASK(EV_ABS); 2332 dev1->evbit[BIT_WORD(EV_ABS)] |= BIT_MASK(EV_ABS);
2101 2333
2102 priv->set_abs_params(priv, dev1); 2334 priv->set_abs_params(priv, dev1);
2103 input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0); 2335 /* No pressure on V7 */
2336 if (priv->proto_version != ALPS_PROTO_V7)
2337 input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0);
2104 2338
2105 if (priv->flags & ALPS_WHEEL) { 2339 if (priv->flags & ALPS_WHEEL) {
2106 dev1->evbit[BIT_WORD(EV_REL)] |= BIT_MASK(EV_REL); 2340 dev1->evbit[BIT_WORD(EV_REL)] |= BIT_MASK(EV_REL);
@@ -2117,6 +2351,9 @@ int alps_init(struct psmouse *psmouse)
2117 dev1->keybit[BIT_WORD(BTN_1)] |= BIT_MASK(BTN_1); 2351 dev1->keybit[BIT_WORD(BTN_1)] |= BIT_MASK(BTN_1);
2118 dev1->keybit[BIT_WORD(BTN_2)] |= BIT_MASK(BTN_2); 2352 dev1->keybit[BIT_WORD(BTN_2)] |= BIT_MASK(BTN_2);
2119 dev1->keybit[BIT_WORD(BTN_3)] |= BIT_MASK(BTN_3); 2353 dev1->keybit[BIT_WORD(BTN_3)] |= BIT_MASK(BTN_3);
2354 } else if (priv->flags & ALPS_BUTTONPAD) {
2355 set_bit(INPUT_PROP_BUTTONPAD, dev1->propbit);
2356 clear_bit(BTN_RIGHT, dev1->keybit);
2120 } else { 2357 } else {
2121 dev1->keybit[BIT_WORD(BTN_MIDDLE)] |= BIT_MASK(BTN_MIDDLE); 2358 dev1->keybit[BIT_WORD(BTN_MIDDLE)] |= BIT_MASK(BTN_MIDDLE);
2122 } 2359 }
diff --git a/drivers/input/mouse/alps.h b/drivers/input/mouse/alps.h
index 03f88b6940c7..66240b47819a 100644
--- a/drivers/input/mouse/alps.h
+++ b/drivers/input/mouse/alps.h
@@ -12,17 +12,39 @@
12#ifndef _ALPS_H 12#ifndef _ALPS_H
13#define _ALPS_H 13#define _ALPS_H
14 14
15#include <linux/input/mt.h>
16
15#define ALPS_PROTO_V1 1 17#define ALPS_PROTO_V1 1
16#define ALPS_PROTO_V2 2 18#define ALPS_PROTO_V2 2
17#define ALPS_PROTO_V3 3 19#define ALPS_PROTO_V3 3
18#define ALPS_PROTO_V4 4 20#define ALPS_PROTO_V4 4
19#define ALPS_PROTO_V5 5 21#define ALPS_PROTO_V5 5
20#define ALPS_PROTO_V6 6 22#define ALPS_PROTO_V6 6
23#define ALPS_PROTO_V7 7 /* t3btl t4s */
24
25#define MAX_TOUCHES 2
21 26
22#define DOLPHIN_COUNT_PER_ELECTRODE 64 27#define DOLPHIN_COUNT_PER_ELECTRODE 64
23#define DOLPHIN_PROFILE_XOFFSET 8 /* x-electrode offset */ 28#define DOLPHIN_PROFILE_XOFFSET 8 /* x-electrode offset */
24#define DOLPHIN_PROFILE_YOFFSET 1 /* y-electrode offset */ 29#define DOLPHIN_PROFILE_YOFFSET 1 /* y-electrode offset */
25 30
31/*
32 * enum V7_PACKET_ID - defines the packet type for V7
33 * V7_PACKET_ID_IDLE: There's no finger and no button activity.
34 * V7_PACKET_ID_TWO: There's one or two non-resting fingers on touchpad
35 * or there's button activities.
36 * V7_PACKET_ID_MULTI: There are at least three non-resting fingers.
37 * V7_PACKET_ID_NEW: The finger position in slot is not continues from
38 * previous packet.
39*/
40enum V7_PACKET_ID {
41 V7_PACKET_ID_IDLE,
42 V7_PACKET_ID_TWO,
43 V7_PACKET_ID_MULTI,
44 V7_PACKET_ID_NEW,
45 V7_PACKET_ID_UNKNOWN,
46};
47
26/** 48/**
27 * struct alps_model_info - touchpad ID table 49 * struct alps_model_info - touchpad ID table
28 * @signature: E7 response string to match. 50 * @signature: E7 response string to match.
@@ -46,7 +68,7 @@ struct alps_model_info {
46 unsigned char command_mode_resp; 68 unsigned char command_mode_resp;
47 unsigned char proto_version; 69 unsigned char proto_version;
48 unsigned char byte0, mask0; 70 unsigned char byte0, mask0;
49 unsigned char flags; 71 int flags;
50}; 72};
51 73
52/** 74/**
@@ -65,14 +87,19 @@ struct alps_nibble_commands {
65 unsigned char data; 87 unsigned char data;
66}; 88};
67 89
90struct alps_bitmap_point {
91 int start_bit;
92 int num_bits;
93};
94
68/** 95/**
69 * struct alps_fields - decoded version of the report packet 96 * struct alps_fields - decoded version of the report packet
70 * @x_map: Bitmap of active X positions for MT. 97 * @x_map: Bitmap of active X positions for MT.
71 * @y_map: Bitmap of active Y positions for MT. 98 * @y_map: Bitmap of active Y positions for MT.
72 * @fingers: Number of fingers for MT. 99 * @fingers: Number of fingers for MT.
73 * @x: X position for ST. 100 * @pressure: Pressure.
74 * @y: Y position for ST. 101 * @st: position for ST.
75 * @z: Z position for ST. 102 * @mt: position for MT.
76 * @first_mp: Packet is the first of a multi-packet report. 103 * @first_mp: Packet is the first of a multi-packet report.
77 * @is_mp: Packet is part of a multi-packet report. 104 * @is_mp: Packet is part of a multi-packet report.
78 * @left: Left touchpad button is active. 105 * @left: Left touchpad button is active.
@@ -86,9 +113,11 @@ struct alps_fields {
86 unsigned int x_map; 113 unsigned int x_map;
87 unsigned int y_map; 114 unsigned int y_map;
88 unsigned int fingers; 115 unsigned int fingers;
89 unsigned int x; 116
90 unsigned int y; 117 int pressure;
91 unsigned int z; 118 struct input_mt_pos st;
119 struct input_mt_pos mt[MAX_TOUCHES];
120
92 unsigned int first_mp:1; 121 unsigned int first_mp:1;
93 unsigned int is_mp:1; 122 unsigned int is_mp:1;
94 123
@@ -113,6 +142,7 @@ struct alps_fields {
113 * known format for this model. The first byte of the report, ANDed with 142 * known format for this model. The first byte of the report, ANDed with
114 * mask0, should match byte0. 143 * mask0, should match byte0.
115 * @mask0: The mask used to check the first byte of the report. 144 * @mask0: The mask used to check the first byte of the report.
145 * @fw_ver: cached copy of firmware version (EC report)
116 * @flags: Additional device capabilities (passthrough port, trackstick, etc.). 146 * @flags: Additional device capabilities (passthrough port, trackstick, etc.).
117 * @x_max: Largest possible X position value. 147 * @x_max: Largest possible X position value.
118 * @y_max: Largest possible Y position value. 148 * @y_max: Largest possible Y position value.
@@ -125,11 +155,7 @@ struct alps_fields {
125 * @prev_fin: Finger bit from previous packet. 155 * @prev_fin: Finger bit from previous packet.
126 * @multi_packet: Multi-packet data in progress. 156 * @multi_packet: Multi-packet data in progress.
127 * @multi_data: Saved multi-packet data. 157 * @multi_data: Saved multi-packet data.
128 * @x1: First X coordinate from last MT report. 158 * @f: Decoded packet data fields.
129 * @x2: Second X coordinate from last MT report.
130 * @y1: First Y coordinate from last MT report.
131 * @y2: Second Y coordinate from last MT report.
132 * @fingers: Number of fingers from last MT report.
133 * @quirks: Bitmap of ALPS_QUIRK_*. 159 * @quirks: Bitmap of ALPS_QUIRK_*.
134 * @timer: Timer for flushing out the final report packet in the stream. 160 * @timer: Timer for flushing out the final report packet in the stream.
135 */ 161 */
@@ -142,23 +168,25 @@ struct alps_data {
142 int addr_command; 168 int addr_command;
143 unsigned char proto_version; 169 unsigned char proto_version;
144 unsigned char byte0, mask0; 170 unsigned char byte0, mask0;
145 unsigned char flags; 171 unsigned char fw_ver[3];
172 int flags;
146 int x_max; 173 int x_max;
147 int y_max; 174 int y_max;
148 int x_bits; 175 int x_bits;
149 int y_bits; 176 int y_bits;
177 unsigned int x_res;
178 unsigned int y_res;
150 179
151 int (*hw_init)(struct psmouse *psmouse); 180 int (*hw_init)(struct psmouse *psmouse);
152 void (*process_packet)(struct psmouse *psmouse); 181 void (*process_packet)(struct psmouse *psmouse);
153 void (*decode_fields)(struct alps_fields *f, unsigned char *p, 182 int (*decode_fields)(struct alps_fields *f, unsigned char *p,
154 struct psmouse *psmouse); 183 struct psmouse *psmouse);
155 void (*set_abs_params)(struct alps_data *priv, struct input_dev *dev1); 184 void (*set_abs_params)(struct alps_data *priv, struct input_dev *dev1);
156 185
157 int prev_fin; 186 int prev_fin;
158 int multi_packet; 187 int multi_packet;
159 unsigned char multi_data[6]; 188 unsigned char multi_data[6];
160 int x1, x2, y1, y2; 189 struct alps_fields f;
161 int fingers;
162 u8 quirks; 190 u8 quirks;
163 struct timer_list timer; 191 struct timer_list timer;
164}; 192};
diff --git a/drivers/input/serio/hyperv-keyboard.c b/drivers/input/serio/hyperv-keyboard.c
index 613261994621..e74e5d6e5f9f 100644
--- a/drivers/input/serio/hyperv-keyboard.c
+++ b/drivers/input/serio/hyperv-keyboard.c
@@ -170,6 +170,15 @@ static void hv_kbd_on_receive(struct hv_device *hv_dev,
170 serio_interrupt(kbd_dev->hv_serio, scan_code, 0); 170 serio_interrupt(kbd_dev->hv_serio, scan_code, 0);
171 } 171 }
172 spin_unlock_irqrestore(&kbd_dev->lock, flags); 172 spin_unlock_irqrestore(&kbd_dev->lock, flags);
173
174 /*
175 * Only trigger a wakeup on key down, otherwise
176 * "echo freeze > /sys/power/state" can't really enter the
177 * state because the Enter-UP can trigger a wakeup at once.
178 */
179 if (!(info & IS_BREAK))
180 pm_wakeup_event(&hv_dev->device, 0);
181
173 break; 182 break;
174 183
175 default: 184 default:
@@ -376,6 +385,9 @@ static int hv_kbd_probe(struct hv_device *hv_dev,
376 goto err_close_vmbus; 385 goto err_close_vmbus;
377 386
378 serio_register_port(kbd_dev->hv_serio); 387 serio_register_port(kbd_dev->hv_serio);
388
389 device_init_wakeup(&hv_dev->device, true);
390
379 return 0; 391 return 0;
380 392
381err_close_vmbus: 393err_close_vmbus:
@@ -390,6 +402,7 @@ static int hv_kbd_remove(struct hv_device *hv_dev)
390{ 402{
391 struct hv_kbd_dev *kbd_dev = hv_get_drvdata(hv_dev); 403 struct hv_kbd_dev *kbd_dev = hv_get_drvdata(hv_dev);
392 404
405 device_init_wakeup(&hv_dev->device, false);
393 serio_unregister_port(kbd_dev->hv_serio); 406 serio_unregister_port(kbd_dev->hv_serio);
394 vmbus_close(hv_dev->channel); 407 vmbus_close(hv_dev->channel);
395 kfree(kbd_dev); 408 kfree(kbd_dev);
diff --git a/drivers/input/tablet/Kconfig b/drivers/input/tablet/Kconfig
index bed7cbf84cfd..623bb9e0d5a4 100644
--- a/drivers/input/tablet/Kconfig
+++ b/drivers/input/tablet/Kconfig
@@ -73,20 +73,14 @@ config TABLET_USB_KBTAB
73 To compile this driver as a module, choose M here: the 73 To compile this driver as a module, choose M here: the
74 module will be called kbtab. 74 module will be called kbtab.
75 75
76config TABLET_USB_WACOM 76config TABLET_SERIAL_WACOM4
77 tristate "Wacom Intuos/Graphire tablet support (USB)" 77 tristate "Wacom protocol 4 serial tablet support"
78 depends on USB_ARCH_HAS_HCD 78 select SERIO
79 select POWER_SUPPLY
80 select USB
81 select NEW_LEDS
82 select LEDS_CLASS
83 help 79 help
84 Say Y here if you want to use the USB version of the Wacom Intuos 80 Say Y here if you want to use Wacom protocol 4 serial tablets.
85 or Graphire tablet. Make sure to say Y to "Mouse support" 81 E.g. serial versions of the Cintiq, Graphire or Penpartner.
86 (CONFIG_INPUT_MOUSEDEV) and/or "Event interface support"
87 (CONFIG_INPUT_EVDEV) as well.
88 82
89 To compile this driver as a module, choose M here: the 83 To compile this driver as a module, choose M here: the
90 module will be called wacom. 84 module will be called wacom_serial4.
91 85
92endif 86endif
diff --git a/drivers/input/tablet/Makefile b/drivers/input/tablet/Makefile
index 3f6c25220638..2e130101cf3c 100644
--- a/drivers/input/tablet/Makefile
+++ b/drivers/input/tablet/Makefile
@@ -2,12 +2,10 @@
2# Makefile for the tablet drivers 2# Makefile for the tablet drivers
3# 3#
4 4
5# Multipart objects.
6wacom-objs := wacom_wac.o wacom_sys.o
7 5
8obj-$(CONFIG_TABLET_USB_ACECAD) += acecad.o 6obj-$(CONFIG_TABLET_USB_ACECAD) += acecad.o
9obj-$(CONFIG_TABLET_USB_AIPTEK) += aiptek.o 7obj-$(CONFIG_TABLET_USB_AIPTEK) += aiptek.o
10obj-$(CONFIG_TABLET_USB_GTCO) += gtco.o 8obj-$(CONFIG_TABLET_USB_GTCO) += gtco.o
11obj-$(CONFIG_TABLET_USB_HANWANG) += hanwang.o 9obj-$(CONFIG_TABLET_USB_HANWANG) += hanwang.o
12obj-$(CONFIG_TABLET_USB_KBTAB) += kbtab.o 10obj-$(CONFIG_TABLET_USB_KBTAB) += kbtab.o
13obj-$(CONFIG_TABLET_USB_WACOM) += wacom.o 11obj-$(CONFIG_TABLET_SERIAL_WACOM4) += wacom_serial4.o
diff --git a/drivers/input/tablet/wacom_serial4.c b/drivers/input/tablet/wacom_serial4.c
new file mode 100644
index 000000000000..20ab802461e7
--- /dev/null
+++ b/drivers/input/tablet/wacom_serial4.c
@@ -0,0 +1,620 @@
1/*
2 * Wacom protocol 4 serial tablet driver
3 *
4 * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
5 * Copyright 2011-2012 Julian Squires <julian@cipht.net>
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
9 * Free Software Foundation; either version of 2 of the License, or (at your
10 * option) any later version. See the file COPYING in the main directory of
11 * this archive for more details.
12 *
13 * Many thanks to Bill Seremetis, without whom PenPartner support
14 * would not have been possible. Thanks to Patrick Mahoney.
15 *
16 * This driver was developed with reference to much code written by others,
17 * particularly:
18 * - elo, gunze drivers by Vojtech Pavlik <vojtech@ucw.cz>;
19 * - wacom_w8001 driver by Jaya Kumar <jayakumar.lkml@gmail.com>;
20 * - the USB wacom input driver, credited to many people
21 * (see drivers/input/tablet/wacom.h);
22 * - new and old versions of linuxwacom / xf86-input-wacom credited to
23 * Frederic Lepied, France. <Lepied@XFree86.org> and
24 * Ping Cheng, Wacom. <pingc@wacom.com>;
25 * - and xf86wacom.c (a presumably ancient version of the linuxwacom code),
26 * by Frederic Lepied and Raph Levien <raph@gtk.org>.
27 *
28 * To do:
29 * - support pad buttons; (requires access to a model with pad buttons)
30 * - support (protocol 4-style) tilt (requires access to a > 1.4 rom model)
31 */
32
33/*
34 * Wacom serial protocol 4 documentation taken from linuxwacom-0.9.9 code,
35 * protocol 4 uses 7 or 9 byte of data in the following format:
36 *
37 * Byte 1
38 * bit 7 Sync bit always 1
39 * bit 6 Pointing device detected
40 * bit 5 Cursor = 0 / Stylus = 1
41 * bit 4 Reserved
42 * bit 3 1 if a button on the pointing device has been pressed
43 * bit 2 P0 (optional)
44 * bit 1 X15
45 * bit 0 X14
46 *
47 * Byte 2
48 * bit 7 Always 0
49 * bits 6-0 = X13 - X7
50 *
51 * Byte 3
52 * bit 7 Always 0
53 * bits 6-0 = X6 - X0
54 *
55 * Byte 4
56 * bit 7 Always 0
57 * bit 6 B3
58 * bit 5 B2
59 * bit 4 B1
60 * bit 3 B0
61 * bit 2 P1 (optional)
62 * bit 1 Y15
63 * bit 0 Y14
64 *
65 * Byte 5
66 * bit 7 Always 0
67 * bits 6-0 = Y13 - Y7
68 *
69 * Byte 6
70 * bit 7 Always 0
71 * bits 6-0 = Y6 - Y0
72 *
73 * Byte 7
74 * bit 7 Always 0
75 * bit 6 Sign of pressure data; or wheel-rel for cursor tool
76 * bit 5 P7; or REL1 for cursor tool
77 * bit 4 P6; or REL0 for cursor tool
78 * bit 3 P5
79 * bit 2 P4
80 * bit 1 P3
81 * bit 0 P2
82 *
83 * byte 8 and 9 are optional and present only
84 * in tilt mode.
85 *
86 * Byte 8
87 * bit 7 Always 0
88 * bit 6 Sign of tilt X
89 * bit 5 Xt6
90 * bit 4 Xt5
91 * bit 3 Xt4
92 * bit 2 Xt3
93 * bit 1 Xt2
94 * bit 0 Xt1
95 *
96 * Byte 9
97 * bit 7 Always 0
98 * bit 6 Sign of tilt Y
99 * bit 5 Yt6
100 * bit 4 Yt5
101 * bit 3 Yt4
102 * bit 2 Yt3
103 * bit 1 Yt2
104 * bit 0 Yt1
105 */
106
107#include <linux/completion.h>
108#include <linux/init.h>
109#include <linux/input.h>
110#include <linux/interrupt.h>
111#include <linux/kernel.h>
112#include <linux/module.h>
113#include <linux/serio.h>
114#include <linux/slab.h>
115#include <linux/string.h>
116
117MODULE_AUTHOR("Julian Squires <julian@cipht.net>, Hans de Goede <hdegoede@redhat.com>");
118MODULE_DESCRIPTION("Wacom protocol 4 serial tablet driver");
119MODULE_LICENSE("GPL");
120
121#define REQUEST_MODEL_AND_ROM_VERSION "~#"
122#define REQUEST_MAX_COORDINATES "~C\r"
123#define REQUEST_CONFIGURATION_STRING "~R\r"
124#define REQUEST_RESET_TO_PROTOCOL_IV "\r#"
125/*
126 * Note: sending "\r$\r" causes at least the Digitizer II to send
127 * packets in ASCII instead of binary. "\r#" seems to undo that.
128 */
129
130#define COMMAND_START_SENDING_PACKETS "ST\r"
131#define COMMAND_STOP_SENDING_PACKETS "SP\r"
132#define COMMAND_MULTI_MODE_INPUT "MU1\r"
133#define COMMAND_ORIGIN_IN_UPPER_LEFT "OC1\r"
134#define COMMAND_ENABLE_ALL_MACRO_BUTTONS "~M0\r"
135#define COMMAND_DISABLE_GROUP_1_MACRO_BUTTONS "~M1\r"
136#define COMMAND_TRANSMIT_AT_MAX_RATE "IT0\r"
137#define COMMAND_DISABLE_INCREMENTAL_MODE "IN0\r"
138#define COMMAND_ENABLE_CONTINUOUS_MODE "SR\r"
139#define COMMAND_ENABLE_PRESSURE_MODE "PH1\r"
140#define COMMAND_Z_FILTER "ZF1\r"
141
142/* Note that this is a protocol 4 packet without tilt information. */
143#define PACKET_LENGTH 7
144#define DATA_SIZE 32
145
146/* flags */
147#define F_COVERS_SCREEN 0x01
148#define F_HAS_STYLUS2 0x02
149#define F_HAS_SCROLLWHEEL 0x04
150
151/* device IDs */
152#define STYLUS_DEVICE_ID 0x02
153#define CURSOR_DEVICE_ID 0x06
154#define ERASER_DEVICE_ID 0x0A
155
156enum { STYLUS = 1, ERASER, CURSOR };
157
158static const struct {
159 int device_id;
160 int input_id;
161} tools[] = {
162 { 0, 0 },
163 { STYLUS_DEVICE_ID, BTN_TOOL_PEN },
164 { ERASER_DEVICE_ID, BTN_TOOL_RUBBER },
165 { CURSOR_DEVICE_ID, BTN_TOOL_MOUSE },
166};
167
168struct wacom {
169 struct input_dev *dev;
170 struct completion cmd_done;
171 int result;
172 u8 expect;
173 u8 eraser_mask;
174 unsigned int extra_z_bits;
175 unsigned int flags;
176 unsigned int res_x, res_y;
177 unsigned int max_x, max_y;
178 unsigned int tool;
179 unsigned int idx;
180 u8 data[DATA_SIZE];
181 char phys[32];
182};
183
184enum {
185 MODEL_CINTIQ = 0x504C, /* PL */
186 MODEL_CINTIQ2 = 0x4454, /* DT */
187 MODEL_DIGITIZER_II = 0x5544, /* UD */
188 MODEL_GRAPHIRE = 0x4554, /* ET */
189 MODEL_PENPARTNER = 0x4354, /* CT */
190};
191
192static void wacom_handle_model_response(struct wacom *wacom)
193{
194 int major_v, minor_v, r = 0;
195 char *p;
196
197 p = strrchr(wacom->data, 'V');
198 if (p)
199 r = sscanf(p + 1, "%u.%u", &major_v, &minor_v);
200 if (r != 2)
201 major_v = minor_v = 0;
202
203 switch (wacom->data[2] << 8 | wacom->data[3]) {
204 case MODEL_CINTIQ: /* UNTESTED */
205 case MODEL_CINTIQ2:
206 if ((wacom->data[2] << 8 | wacom->data[3]) == MODEL_CINTIQ) {
207 wacom->dev->name = "Wacom Cintiq";
208 wacom->dev->id.version = MODEL_CINTIQ;
209 } else {
210 wacom->dev->name = "Wacom Cintiq II";
211 wacom->dev->id.version = MODEL_CINTIQ2;
212 }
213 wacom->res_x = 508;
214 wacom->res_y = 508;
215
216 switch (wacom->data[5] << 8 | wacom->data[6]) {
217 case 0x3731: /* PL-710 */
218 wacom->res_x = 2540;
219 wacom->res_y = 2540;
220 /* fall through */
221 case 0x3535: /* PL-550 */
222 case 0x3830: /* PL-800 */
223 wacom->extra_z_bits = 2;
224 }
225
226 wacom->flags = F_COVERS_SCREEN;
227 break;
228
229 case MODEL_PENPARTNER:
230 wacom->dev->name = "Wacom Penpartner";
231 wacom->dev->id.version = MODEL_PENPARTNER;
232 wacom->res_x = 1000;
233 wacom->res_y = 1000;
234 break;
235
236 case MODEL_GRAPHIRE:
237 wacom->dev->name = "Wacom Graphire";
238 wacom->dev->id.version = MODEL_GRAPHIRE;
239 wacom->res_x = 1016;
240 wacom->res_y = 1016;
241 wacom->max_x = 5103;
242 wacom->max_y = 3711;
243 wacom->extra_z_bits = 2;
244 wacom->eraser_mask = 0x08;
245 wacom->flags = F_HAS_STYLUS2 | F_HAS_SCROLLWHEEL;
246 break;
247
248 case MODEL_DIGITIZER_II:
249 wacom->dev->name = "Wacom Digitizer II";
250 wacom->dev->id.version = MODEL_DIGITIZER_II;
251 if (major_v == 1 && minor_v <= 2)
252 wacom->extra_z_bits = 0; /* UNTESTED */
253 break;
254
255 default:
256 dev_err(&wacom->dev->dev, "Unsupported Wacom model %s\n",
257 wacom->data);
258 wacom->result = -ENODEV;
259 return;
260 }
261
262 dev_info(&wacom->dev->dev, "%s tablet, version %u.%u\n",
263 wacom->dev->name, major_v, minor_v);
264}
265
266static void wacom_handle_configuration_response(struct wacom *wacom)
267{
268 int r, skip;
269
270 dev_dbg(&wacom->dev->dev, "Configuration string: %s\n", wacom->data);
271 r = sscanf(wacom->data, "~R%x,%u,%u,%u,%u", &skip, &skip, &skip,
272 &wacom->res_x, &wacom->res_y);
273 if (r != 5)
274 dev_warn(&wacom->dev->dev, "could not get resolution\n");
275}
276
277static void wacom_handle_coordinates_response(struct wacom *wacom)
278{
279 int r;
280
281 dev_dbg(&wacom->dev->dev, "Coordinates string: %s\n", wacom->data);
282 r = sscanf(wacom->data, "~C%u,%u", &wacom->max_x, &wacom->max_y);
283 if (r != 2)
284 dev_warn(&wacom->dev->dev, "could not get max coordinates\n");
285}
286
287static void wacom_handle_response(struct wacom *wacom)
288{
289 if (wacom->data[0] != '~' || wacom->data[1] != wacom->expect) {
290 dev_err(&wacom->dev->dev,
291 "Wacom got an unexpected response: %s\n", wacom->data);
292 wacom->result = -EIO;
293 } else {
294 wacom->result = 0;
295
296 switch (wacom->data[1]) {
297 case '#':
298 wacom_handle_model_response(wacom);
299 break;
300 case 'R':
301 wacom_handle_configuration_response(wacom);
302 break;
303 case 'C':
304 wacom_handle_coordinates_response(wacom);
305 break;
306 }
307 }
308
309 complete(&wacom->cmd_done);
310}
311
312static void wacom_handle_packet(struct wacom *wacom)
313{
314 u8 in_proximity_p, stylus_p, button;
315 unsigned int tool;
316 int x, y, z;
317
318 in_proximity_p = wacom->data[0] & 0x40;
319 stylus_p = wacom->data[0] & 0x20;
320 button = (wacom->data[3] & 0x78) >> 3;
321 x = (wacom->data[0] & 3) << 14 | wacom->data[1]<<7 | wacom->data[2];
322 y = (wacom->data[3] & 3) << 14 | wacom->data[4]<<7 | wacom->data[5];
323
324 if (in_proximity_p && stylus_p) {
325 z = wacom->data[6] & 0x7f;
326 if (wacom->extra_z_bits >= 1)
327 z = z << 1 | (wacom->data[3] & 0x4) >> 2;
328 if (wacom->extra_z_bits > 1)
329 z = z << 1 | (wacom->data[0] & 0x4) >> 2;
330 z = z ^ (0x40 << wacom->extra_z_bits);
331 } else {
332 z = -1;
333 }
334
335 if (stylus_p)
336 tool = (button & wacom->eraser_mask) ? ERASER : STYLUS;
337 else
338 tool = CURSOR;
339
340 if (tool != wacom->tool && wacom->tool != 0) {
341 input_report_key(wacom->dev, tools[wacom->tool].input_id, 0);
342 input_sync(wacom->dev);
343 }
344 wacom->tool = tool;
345
346 input_report_key(wacom->dev, tools[tool].input_id, in_proximity_p);
347 input_report_abs(wacom->dev, ABS_MISC,
348 in_proximity_p ? tools[tool].device_id : 0);
349 input_report_abs(wacom->dev, ABS_X, x);
350 input_report_abs(wacom->dev, ABS_Y, y);
351 input_report_abs(wacom->dev, ABS_PRESSURE, z);
352 if (stylus_p) {
353 input_report_key(wacom->dev, BTN_TOUCH, button & 1);
354 input_report_key(wacom->dev, BTN_STYLUS, button & 2);
355 input_report_key(wacom->dev, BTN_STYLUS2, button & 4);
356 } else {
357 input_report_key(wacom->dev, BTN_LEFT, button & 1);
358 input_report_key(wacom->dev, BTN_RIGHT, button & 2);
359 input_report_key(wacom->dev, BTN_MIDDLE, button & 4);
360 /* handle relative wheel for non-stylus device */
361 z = (wacom->data[6] & 0x30) >> 4;
362 if (wacom->data[6] & 0x40)
363 z = -z;
364 input_report_rel(wacom->dev, REL_WHEEL, z);
365 }
366 input_sync(wacom->dev);
367}
368
369static void wacom_clear_data_buf(struct wacom *wacom)
370{
371 memset(wacom->data, 0, DATA_SIZE);
372 wacom->idx = 0;
373}
374
375static irqreturn_t wacom_interrupt(struct serio *serio, unsigned char data,
376 unsigned int flags)
377{
378 struct wacom *wacom = serio_get_drvdata(serio);
379
380 if (data & 0x80)
381 wacom->idx = 0;
382
383 /*
384 * We're either expecting a carriage return-terminated ASCII
385 * response string, or a seven-byte packet with the MSB set on
386 * the first byte.
387 *
388 * Note however that some tablets (the PenPartner, for
389 * example) don't send a carriage return at the end of a
390 * command. We handle these by waiting for timeout.
391 */
392 if (data == '\r' && !(wacom->data[0] & 0x80)) {
393 wacom_handle_response(wacom);
394 wacom_clear_data_buf(wacom);
395 return IRQ_HANDLED;
396 }
397
398 /* Leave place for 0 termination */
399 if (wacom->idx > (DATA_SIZE - 2)) {
400 dev_dbg(&wacom->dev->dev,
401 "throwing away %d bytes of garbage\n", wacom->idx);
402 wacom_clear_data_buf(wacom);
403 }
404 wacom->data[wacom->idx++] = data;
405
406 if (wacom->idx == PACKET_LENGTH && (wacom->data[0] & 0x80)) {
407 wacom_handle_packet(wacom);
408 wacom_clear_data_buf(wacom);
409 }
410
411 return IRQ_HANDLED;
412}
413
414static void wacom_disconnect(struct serio *serio)
415{
416 struct wacom *wacom = serio_get_drvdata(serio);
417
418 serio_close(serio);
419 serio_set_drvdata(serio, NULL);
420 input_unregister_device(wacom->dev);
421 kfree(wacom);
422}
423
424static int wacom_send(struct serio *serio, const u8 *command)
425{
426 int err = 0;
427
428 for (; !err && *command; command++)
429 err = serio_write(serio, *command);
430
431 return err;
432}
433
434static int wacom_send_setup_string(struct wacom *wacom, struct serio *serio)
435{
436 const u8 *cmd;
437
438 switch (wacom->dev->id.version) {
439 case MODEL_CINTIQ: /* UNTESTED */
440 cmd = COMMAND_ORIGIN_IN_UPPER_LEFT
441 COMMAND_TRANSMIT_AT_MAX_RATE
442 COMMAND_ENABLE_CONTINUOUS_MODE
443 COMMAND_START_SENDING_PACKETS;
444 break;
445
446 case MODEL_PENPARTNER:
447 cmd = COMMAND_ENABLE_PRESSURE_MODE
448 COMMAND_START_SENDING_PACKETS;
449 break;
450
451 default:
452 cmd = COMMAND_MULTI_MODE_INPUT
453 COMMAND_ORIGIN_IN_UPPER_LEFT
454 COMMAND_ENABLE_ALL_MACRO_BUTTONS
455 COMMAND_DISABLE_GROUP_1_MACRO_BUTTONS
456 COMMAND_TRANSMIT_AT_MAX_RATE
457 COMMAND_DISABLE_INCREMENTAL_MODE
458 COMMAND_ENABLE_CONTINUOUS_MODE
459 COMMAND_Z_FILTER
460 COMMAND_START_SENDING_PACKETS;
461 break;
462 }
463
464 return wacom_send(serio, cmd);
465}
466
467static int wacom_send_and_wait(struct wacom *wacom, struct serio *serio,
468 const u8 *cmd, const char *desc)
469{
470 int err;
471 unsigned long u;
472
473 wacom->expect = cmd[1];
474 init_completion(&wacom->cmd_done);
475
476 err = wacom_send(serio, cmd);
477 if (err)
478 return err;
479
480 u = wait_for_completion_timeout(&wacom->cmd_done, HZ);
481 if (u == 0) {
482 /* Timeout, process what we've received. */
483 wacom_handle_response(wacom);
484 }
485
486 wacom->expect = 0;
487 return wacom->result;
488}
489
490static int wacom_setup(struct wacom *wacom, struct serio *serio)
491{
492 int err;
493
494 /* Note that setting the link speed is the job of inputattach.
495 * We assume that reset negotiation has already happened,
496 * here. */
497 err = wacom_send_and_wait(wacom, serio, REQUEST_MODEL_AND_ROM_VERSION,
498 "model and version");
499 if (err)
500 return err;
501
502 if (!(wacom->res_x && wacom->res_y)) {
503 err = wacom_send_and_wait(wacom, serio,
504 REQUEST_CONFIGURATION_STRING,
505 "configuration string");
506 if (err)
507 return err;
508 }
509
510 if (!(wacom->max_x && wacom->max_y)) {
511 err = wacom_send_and_wait(wacom, serio,
512 REQUEST_MAX_COORDINATES,
513 "coordinates string");
514 if (err)
515 return err;
516 }
517
518 return wacom_send_setup_string(wacom, serio);
519}
520
521static int wacom_connect(struct serio *serio, struct serio_driver *drv)
522{
523 struct wacom *wacom;
524 struct input_dev *input_dev;
525 int err = -ENOMEM;
526
527 wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
528 input_dev = input_allocate_device();
529 if (!wacom || !input_dev)
530 goto free_device;
531
532 wacom->dev = input_dev;
533 wacom->extra_z_bits = 1;
534 wacom->eraser_mask = 0x04;
535 wacom->tool = wacom->idx = 0;
536 snprintf(wacom->phys, sizeof(wacom->phys), "%s/input0", serio->phys);
537 input_dev->phys = wacom->phys;
538 input_dev->id.bustype = BUS_RS232;
539 input_dev->id.vendor = SERIO_WACOM_IV;
540 input_dev->id.product = serio->id.extra;
541 input_dev->dev.parent = &serio->dev;
542
543 input_dev->evbit[0] =
544 BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) | BIT_MASK(EV_REL);
545 set_bit(ABS_MISC, input_dev->absbit);
546 set_bit(BTN_TOOL_PEN, input_dev->keybit);
547 set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
548 set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
549 set_bit(BTN_TOUCH, input_dev->keybit);
550 set_bit(BTN_STYLUS, input_dev->keybit);
551 set_bit(BTN_LEFT, input_dev->keybit);
552 set_bit(BTN_RIGHT, input_dev->keybit);
553 set_bit(BTN_MIDDLE, input_dev->keybit);
554
555 serio_set_drvdata(serio, wacom);
556
557 err = serio_open(serio, drv);
558 if (err)
559 goto free_device;
560
561 err = wacom_setup(wacom, serio);
562 if (err)
563 goto close_serio;
564
565 set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
566 if (!(wacom->flags & F_COVERS_SCREEN))
567 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
568
569 if (wacom->flags & F_HAS_STYLUS2)
570 __set_bit(BTN_STYLUS2, input_dev->keybit);
571
572 if (wacom->flags & F_HAS_SCROLLWHEEL)
573 __set_bit(REL_WHEEL, input_dev->relbit);
574
575 input_abs_set_res(wacom->dev, ABS_X, wacom->res_x);
576 input_abs_set_res(wacom->dev, ABS_Y, wacom->res_y);
577 input_set_abs_params(wacom->dev, ABS_X, 0, wacom->max_x, 0, 0);
578 input_set_abs_params(wacom->dev, ABS_Y, 0, wacom->max_y, 0, 0);
579 input_set_abs_params(wacom->dev, ABS_PRESSURE, -1,
580 (1 << (7 + wacom->extra_z_bits)) - 1, 0, 0);
581
582 err = input_register_device(wacom->dev);
583 if (err)
584 goto close_serio;
585
586 return 0;
587
588close_serio:
589 serio_close(serio);
590free_device:
591 serio_set_drvdata(serio, NULL);
592 input_free_device(input_dev);
593 kfree(wacom);
594 return err;
595}
596
597static struct serio_device_id wacom_serio_ids[] = {
598 {
599 .type = SERIO_RS232,
600 .proto = SERIO_WACOM_IV,
601 .id = SERIO_ANY,
602 .extra = SERIO_ANY,
603 },
604 { 0 }
605};
606
607MODULE_DEVICE_TABLE(serio, wacom_serio_ids);
608
609static struct serio_driver wacom_drv = {
610 .driver = {
611 .name = "wacom_serial4",
612 },
613 .description = "Wacom protocol 4 serial tablet driver",
614 .id_table = wacom_serio_ids,
615 .interrupt = wacom_interrupt,
616 .connect = wacom_connect,
617 .disconnect = wacom_disconnect,
618};
619
620module_serio_driver(wacom_drv);
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index a23a94bb4bcb..6bb9a7dd23b6 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -471,6 +471,18 @@ config TOUCHSCREEN_HP7XX
471 To compile this driver as a module, choose M here: the 471 To compile this driver as a module, choose M here: the
472 module will be called jornada720_ts. 472 module will be called jornada720_ts.
473 473
474config TOUCHSCREEN_IPAQ_MICRO
475 tristate "HP iPAQ Atmel Micro ASIC touchscreen"
476 depends on MFD_IPAQ_MICRO
477 help
478 Say Y here to enable support for the touchscreen attached to
479 the Atmel Micro peripheral controller on iPAQ h3100/h3600/h3700
480
481 If unsure, say N.
482
483 To compile this driver as a module, choose M here: the
484 module will be called ipaq-micro-ts.
485
474config TOUCHSCREEN_HTCPEN 486config TOUCHSCREEN_HTCPEN
475 tristate "HTC Shift X9500 touchscreen" 487 tristate "HTC Shift X9500 touchscreen"
476 depends on ISA 488 depends on ISA
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 126479d8c29a..4be94fce41af 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -46,6 +46,7 @@ obj-$(CONFIG_TOUCHSCREEN_MTOUCH) += mtouch.o
46obj-$(CONFIG_TOUCHSCREEN_MK712) += mk712.o 46obj-$(CONFIG_TOUCHSCREEN_MK712) += mk712.o
47obj-$(CONFIG_TOUCHSCREEN_HP600) += hp680_ts_input.o 47obj-$(CONFIG_TOUCHSCREEN_HP600) += hp680_ts_input.o
48obj-$(CONFIG_TOUCHSCREEN_HP7XX) += jornada720_ts.o 48obj-$(CONFIG_TOUCHSCREEN_HP7XX) += jornada720_ts.o
49obj-$(CONFIG_TOUCHSCREEN_IPAQ_MICRO) += ipaq-micro-ts.o
49obj-$(CONFIG_TOUCHSCREEN_HTCPEN) += htcpen.o 50obj-$(CONFIG_TOUCHSCREEN_HTCPEN) += htcpen.o
50obj-$(CONFIG_TOUCHSCREEN_USB_COMPOSITE) += usbtouchscreen.o 51obj-$(CONFIG_TOUCHSCREEN_USB_COMPOSITE) += usbtouchscreen.o
51obj-$(CONFIG_TOUCHSCREEN_PCAP) += pcap_ts.o 52obj-$(CONFIG_TOUCHSCREEN_PCAP) += pcap_ts.o
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index da201b8e37dc..e57ba52bf484 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -1302,8 +1302,10 @@ static int ads7846_probe(struct spi_device *spi)
1302 pdata = dev_get_platdata(&spi->dev); 1302 pdata = dev_get_platdata(&spi->dev);
1303 if (!pdata) { 1303 if (!pdata) {
1304 pdata = ads7846_probe_dt(&spi->dev); 1304 pdata = ads7846_probe_dt(&spi->dev);
1305 if (IS_ERR(pdata)) 1305 if (IS_ERR(pdata)) {
1306 return PTR_ERR(pdata); 1306 err = PTR_ERR(pdata);
1307 goto err_free_mem;
1308 }
1307 } 1309 }
1308 1310
1309 ts->model = pdata->model ? : 7846; 1311 ts->model = pdata->model ? : 7846;
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 6e0b4a2120d3..03b85711cb70 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -2,6 +2,7 @@
2 * Atmel maXTouch Touchscreen driver 2 * Atmel maXTouch Touchscreen driver
3 * 3 *
4 * Copyright (C) 2010 Samsung Electronics Co.Ltd 4 * Copyright (C) 2010 Samsung Electronics Co.Ltd
5 * Copyright (C) 2011-2014 Atmel Corporation
5 * Copyright (C) 2012 Google, Inc. 6 * Copyright (C) 2012 Google, Inc.
6 * 7 *
7 * Author: Joonyoung Shim <jy0922.shim@samsung.com> 8 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
@@ -22,6 +23,7 @@
22#include <linux/i2c/atmel_mxt_ts.h> 23#include <linux/i2c/atmel_mxt_ts.h>
23#include <linux/input/mt.h> 24#include <linux/input/mt.h>
24#include <linux/interrupt.h> 25#include <linux/interrupt.h>
26#include <linux/of.h>
25#include <linux/slab.h> 27#include <linux/slab.h>
26 28
27/* Version */ 29/* Version */
@@ -29,8 +31,10 @@
29#define MXT_VER_21 21 31#define MXT_VER_21 21
30#define MXT_VER_22 22 32#define MXT_VER_22 22
31 33
32/* Firmware */ 34/* Firmware files */
33#define MXT_FW_NAME "maxtouch.fw" 35#define MXT_FW_NAME "maxtouch.fw"
36#define MXT_CFG_NAME "maxtouch.cfg"
37#define MXT_CFG_MAGIC "OBP_RAW V1"
34 38
35/* Registers */ 39/* Registers */
36#define MXT_INFO 0x00 40#define MXT_INFO 0x00
@@ -44,6 +48,8 @@
44#define MXT_OBJECT_START 0x07 48#define MXT_OBJECT_START 0x07
45 49
46#define MXT_OBJECT_SIZE 6 50#define MXT_OBJECT_SIZE 6
51#define MXT_INFO_CHECKSUM_SIZE 3
52#define MXT_MAX_BLOCK_WRITE 256
47 53
48/* Object types */ 54/* Object types */
49#define MXT_DEBUG_DIAGNOSTIC_T37 37 55#define MXT_DEBUG_DIAGNOSTIC_T37 37
@@ -74,6 +80,9 @@
74#define MXT_SPT_MESSAGECOUNT_T44 44 80#define MXT_SPT_MESSAGECOUNT_T44 44
75#define MXT_SPT_CTECONFIG_T46 46 81#define MXT_SPT_CTECONFIG_T46 46
76 82
83/* MXT_GEN_MESSAGE_T5 object */
84#define MXT_RPTID_NOMSG 0xff
85
77/* MXT_GEN_COMMAND_T6 field */ 86/* MXT_GEN_COMMAND_T6 field */
78#define MXT_COMMAND_RESET 0 87#define MXT_COMMAND_RESET 0
79#define MXT_COMMAND_BACKUPNV 1 88#define MXT_COMMAND_BACKUPNV 1
@@ -83,11 +92,20 @@
83 92
84/* Define for T6 status byte */ 93/* Define for T6 status byte */
85#define MXT_T6_STATUS_RESET (1 << 7) 94#define MXT_T6_STATUS_RESET (1 << 7)
95#define MXT_T6_STATUS_OFL (1 << 6)
96#define MXT_T6_STATUS_SIGERR (1 << 5)
97#define MXT_T6_STATUS_CAL (1 << 4)
98#define MXT_T6_STATUS_CFGERR (1 << 3)
99#define MXT_T6_STATUS_COMSERR (1 << 2)
86 100
87/* MXT_GEN_POWER_T7 field */ 101/* MXT_GEN_POWER_T7 field */
88#define MXT_POWER_IDLEACQINT 0 102struct t7_config {
89#define MXT_POWER_ACTVACQINT 1 103 u8 idle;
90#define MXT_POWER_ACTV2IDLETO 2 104 u8 active;
105} __packed;
106
107#define MXT_POWER_CFG_RUN 0
108#define MXT_POWER_CFG_DEEPSLEEP 1
91 109
92/* MXT_GEN_ACQUIRE_T8 field */ 110/* MXT_GEN_ACQUIRE_T8 field */
93#define MXT_ACQUIRE_CHRGTIME 0 111#define MXT_ACQUIRE_CHRGTIME 0
@@ -99,7 +117,6 @@
99#define MXT_ACQUIRE_ATCHCALSTHR 7 117#define MXT_ACQUIRE_ATCHCALSTHR 7
100 118
101/* MXT_TOUCH_MULTI_T9 field */ 119/* MXT_TOUCH_MULTI_T9 field */
102#define MXT_TOUCH_CTRL 0
103#define MXT_T9_ORIENT 9 120#define MXT_T9_ORIENT 9
104#define MXT_T9_RANGE 18 121#define MXT_T9_RANGE 18
105 122
@@ -217,11 +234,6 @@ struct mxt_object {
217 u8 num_report_ids; 234 u8 num_report_ids;
218} __packed; 235} __packed;
219 236
220struct mxt_message {
221 u8 reportid;
222 u8 message[7];
223};
224
225/* Each client has this additional data */ 237/* Each client has this additional data */
226struct mxt_data { 238struct mxt_data {
227 struct i2c_client *client; 239 struct i2c_client *client;
@@ -234,15 +246,28 @@ struct mxt_data {
234 unsigned int max_x; 246 unsigned int max_x;
235 unsigned int max_y; 247 unsigned int max_y;
236 bool in_bootloader; 248 bool in_bootloader;
249 u16 mem_size;
250 u8 max_reportid;
237 u32 config_crc; 251 u32 config_crc;
252 u32 info_crc;
238 u8 bootloader_addr; 253 u8 bootloader_addr;
254 u8 *msg_buf;
255 u8 t6_status;
256 bool update_input;
257 u8 last_message_count;
258 u8 num_touchids;
259 struct t7_config t7_cfg;
239 260
240 /* Cached parameters from object table */ 261 /* Cached parameters from object table */
262 u16 T5_address;
263 u8 T5_msg_size;
241 u8 T6_reportid; 264 u8 T6_reportid;
242 u16 T6_address; 265 u16 T6_address;
266 u16 T7_address;
243 u8 T9_reportid_min; 267 u8 T9_reportid_min;
244 u8 T9_reportid_max; 268 u8 T9_reportid_max;
245 u8 T19_reportid; 269 u8 T19_reportid;
270 u16 T44_address;
246 271
247 /* for fw update in bootloader */ 272 /* for fw update in bootloader */
248 struct completion bl_completion; 273 struct completion bl_completion;
@@ -297,42 +322,10 @@ static bool mxt_object_readable(unsigned int type)
297 } 322 }
298} 323}
299 324
300static bool mxt_object_writable(unsigned int type) 325static void mxt_dump_message(struct mxt_data *data, u8 *message)
301{
302 switch (type) {
303 case MXT_GEN_COMMAND_T6:
304 case MXT_GEN_POWER_T7:
305 case MXT_GEN_ACQUIRE_T8:
306 case MXT_TOUCH_MULTI_T9:
307 case MXT_TOUCH_KEYARRAY_T15:
308 case MXT_TOUCH_PROXIMITY_T23:
309 case MXT_TOUCH_PROXKEY_T52:
310 case MXT_PROCI_GRIPFACE_T20:
311 case MXT_PROCG_NOISE_T22:
312 case MXT_PROCI_ONETOUCH_T24:
313 case MXT_PROCI_TWOTOUCH_T27:
314 case MXT_PROCI_GRIP_T40:
315 case MXT_PROCI_PALM_T41:
316 case MXT_PROCI_TOUCHSUPPRESSION_T42:
317 case MXT_PROCI_STYLUS_T47:
318 case MXT_PROCG_NOISESUPPRESSION_T48:
319 case MXT_SPT_COMMSCONFIG_T18:
320 case MXT_SPT_GPIOPWM_T19:
321 case MXT_SPT_SELFTEST_T25:
322 case MXT_SPT_CTECONFIG_T28:
323 case MXT_SPT_DIGITIZER_T43:
324 case MXT_SPT_CTECONFIG_T46:
325 return true;
326 default:
327 return false;
328 }
329}
330
331static void mxt_dump_message(struct device *dev,
332 struct mxt_message *message)
333{ 326{
334 dev_dbg(dev, "reportid: %u\tmessage: %*ph\n", 327 dev_dbg(&data->client->dev, "message: %*ph\n",
335 message->reportid, 7, message->message); 328 data->T5_msg_size, message);
336} 329}
337 330
338static int mxt_wait_for_completion(struct mxt_data *data, 331static int mxt_wait_for_completion(struct mxt_data *data,
@@ -401,7 +394,7 @@ static int mxt_bootloader_write(struct mxt_data *data,
401 return ret; 394 return ret;
402} 395}
403 396
404static int mxt_lookup_bootloader_address(struct mxt_data *data) 397static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
405{ 398{
406 u8 appmode = data->client->addr; 399 u8 appmode = data->client->addr;
407 u8 bootloader; 400 u8 bootloader;
@@ -409,6 +402,12 @@ static int mxt_lookup_bootloader_address(struct mxt_data *data)
409 switch (appmode) { 402 switch (appmode) {
410 case 0x4a: 403 case 0x4a:
411 case 0x4b: 404 case 0x4b:
405 /* Chips after 1664S use different scheme */
406 if (retry || data->info.family_id >= 0xa2) {
407 bootloader = appmode - 0x24;
408 break;
409 }
410 /* Fall through for normal case */
412 case 0x4c: 411 case 0x4c:
413 case 0x4d: 412 case 0x4d:
414 case 0x5a: 413 case 0x5a:
@@ -426,6 +425,30 @@ static int mxt_lookup_bootloader_address(struct mxt_data *data)
426 return 0; 425 return 0;
427} 426}
428 427
428static int mxt_probe_bootloader(struct mxt_data *data, bool retry)
429{
430 struct device *dev = &data->client->dev;
431 int ret;
432 u8 val;
433 bool crc_failure;
434
435 ret = mxt_lookup_bootloader_address(data, retry);
436 if (ret)
437 return ret;
438
439 ret = mxt_bootloader_read(data, &val, 1);
440 if (ret)
441 return ret;
442
443 /* Check app crc fail mode */
444 crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
445
446 dev_err(dev, "Detected bootloader, status:%02X%s\n",
447 val, crc_failure ? ", APP_CRC_FAIL" : "");
448
449 return 0;
450}
451
429static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val) 452static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
430{ 453{
431 struct device *dev = &data->client->dev; 454 struct device *dev = &data->client->dev;
@@ -447,14 +470,15 @@ static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
447 } 470 }
448} 471}
449 472
450static int mxt_check_bootloader(struct mxt_data *data, unsigned int state) 473static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
474 bool wait)
451{ 475{
452 struct device *dev = &data->client->dev; 476 struct device *dev = &data->client->dev;
453 u8 val; 477 u8 val;
454 int ret; 478 int ret;
455 479
456recheck: 480recheck:
457 if (state != MXT_WAITING_BOOTLOAD_CMD) { 481 if (wait) {
458 /* 482 /*
459 * In application update mode, the interrupt 483 * In application update mode, the interrupt
460 * line signals state transitions. We must wait for the 484 * line signals state transitions. We must wait for the
@@ -485,6 +509,7 @@ recheck:
485 switch (state) { 509 switch (state) {
486 case MXT_WAITING_BOOTLOAD_CMD: 510 case MXT_WAITING_BOOTLOAD_CMD:
487 case MXT_WAITING_FRAME_DATA: 511 case MXT_WAITING_FRAME_DATA:
512 case MXT_APP_CRC_FAIL:
488 val &= ~MXT_BOOT_STATUS_MASK; 513 val &= ~MXT_BOOT_STATUS_MASK;
489 break; 514 break;
490 case MXT_FRAME_CRC_PASS: 515 case MXT_FRAME_CRC_PASS:
@@ -508,13 +533,18 @@ recheck:
508 return 0; 533 return 0;
509} 534}
510 535
511static int mxt_unlock_bootloader(struct mxt_data *data) 536static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
512{ 537{
513 int ret; 538 int ret;
514 u8 buf[2]; 539 u8 buf[2];
515 540
516 buf[0] = MXT_UNLOCK_CMD_LSB; 541 if (unlock) {
517 buf[1] = MXT_UNLOCK_CMD_MSB; 542 buf[0] = MXT_UNLOCK_CMD_LSB;
543 buf[1] = MXT_UNLOCK_CMD_MSB;
544 } else {
545 buf[0] = 0x01;
546 buf[1] = 0x01;
547 }
518 548
519 ret = mxt_bootloader_write(data, buf, 2); 549 ret = mxt_bootloader_write(data, buf, 2);
520 if (ret) 550 if (ret)
@@ -605,40 +635,44 @@ mxt_get_object(struct mxt_data *data, u8 type)
605 return object; 635 return object;
606 } 636 }
607 637
608 dev_err(&data->client->dev, "Invalid object type T%u\n", type); 638 dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
609 return NULL; 639 return NULL;
610} 640}
611 641
612static int mxt_read_message(struct mxt_data *data, 642static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
613 struct mxt_message *message)
614{ 643{
615 struct mxt_object *object; 644 struct device *dev = &data->client->dev;
616 u16 reg; 645 u8 status = msg[1];
617 646 u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
618 object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
619 if (!object)
620 return -EINVAL;
621
622 reg = object->start_address;
623 return __mxt_read_reg(data->client, reg,
624 sizeof(struct mxt_message), message);
625}
626 647
627static int mxt_write_object(struct mxt_data *data, 648 complete(&data->crc_completion);
628 u8 type, u8 offset, u8 val)
629{
630 struct mxt_object *object;
631 u16 reg;
632 649
633 object = mxt_get_object(data, type); 650 if (crc != data->config_crc) {
634 if (!object || offset >= mxt_obj_size(object)) 651 data->config_crc = crc;
635 return -EINVAL; 652 dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
653 }
636 654
637 reg = object->start_address; 655 /* Detect reset */
638 return mxt_write_reg(data->client, reg + offset, val); 656 if (status & MXT_T6_STATUS_RESET)
657 complete(&data->reset_completion);
658
659 /* Output debug if status has changed */
660 if (status != data->t6_status)
661 dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
662 status,
663 status == 0 ? " OK" : "",
664 status & MXT_T6_STATUS_RESET ? " RESET" : "",
665 status & MXT_T6_STATUS_OFL ? " OFL" : "",
666 status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "",
667 status & MXT_T6_STATUS_CAL ? " CAL" : "",
668 status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "",
669 status & MXT_T6_STATUS_COMSERR ? " COMSERR" : "");
670
671 /* Save current status */
672 data->t6_status = status;
639} 673}
640 674
641static void mxt_input_button(struct mxt_data *data, struct mxt_message *message) 675static void mxt_input_button(struct mxt_data *data, u8 *message)
642{ 676{
643 struct input_dev *input = data->input_dev; 677 struct input_dev *input = data->input_dev;
644 const struct mxt_platform_data *pdata = data->pdata; 678 const struct mxt_platform_data *pdata = data->pdata;
@@ -649,30 +683,33 @@ static void mxt_input_button(struct mxt_data *data, struct mxt_message *message)
649 for (i = 0; i < pdata->t19_num_keys; i++) { 683 for (i = 0; i < pdata->t19_num_keys; i++) {
650 if (pdata->t19_keymap[i] == KEY_RESERVED) 684 if (pdata->t19_keymap[i] == KEY_RESERVED)
651 continue; 685 continue;
652 button = !(message->message[0] & (1 << i)); 686 button = !(message[1] & (1 << i));
653 input_report_key(input, pdata->t19_keymap[i], button); 687 input_report_key(input, pdata->t19_keymap[i], button);
654 } 688 }
655} 689}
656 690
657static void mxt_input_sync(struct input_dev *input_dev) 691static void mxt_input_sync(struct mxt_data *data)
658{ 692{
659 input_mt_report_pointer_emulation(input_dev, false); 693 input_mt_report_pointer_emulation(data->input_dev,
660 input_sync(input_dev); 694 data->pdata->t19_num_keys);
695 input_sync(data->input_dev);
661} 696}
662 697
663static void mxt_input_touchevent(struct mxt_data *data, 698static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
664 struct mxt_message *message, int id)
665{ 699{
666 struct device *dev = &data->client->dev; 700 struct device *dev = &data->client->dev;
667 u8 status = message->message[0];
668 struct input_dev *input_dev = data->input_dev; 701 struct input_dev *input_dev = data->input_dev;
702 int id;
703 u8 status;
669 int x; 704 int x;
670 int y; 705 int y;
671 int area; 706 int area;
672 int amplitude; 707 int amplitude;
673 708
674 x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf); 709 id = message[0] - data->T9_reportid_min;
675 y = (message->message[2] << 4) | ((message->message[3] & 0xf)); 710 status = message[1];
711 x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
712 y = (message[3] << 4) | ((message[4] & 0xf));
676 713
677 /* Handle 10/12 bit switching */ 714 /* Handle 10/12 bit switching */
678 if (data->max_x < 1024) 715 if (data->max_x < 1024)
@@ -680,8 +717,8 @@ static void mxt_input_touchevent(struct mxt_data *data,
680 if (data->max_y < 1024) 717 if (data->max_y < 1024)
681 y >>= 2; 718 y >>= 2;
682 719
683 area = message->message[4]; 720 area = message[5];
684 amplitude = message->message[5]; 721 amplitude = message[6];
685 722
686 dev_dbg(dev, 723 dev_dbg(dev,
687 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n", 724 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
@@ -707,7 +744,7 @@ static void mxt_input_touchevent(struct mxt_data *data,
707 if (status & MXT_T9_RELEASE) { 744 if (status & MXT_T9_RELEASE) {
708 input_mt_report_slot_state(input_dev, 745 input_mt_report_slot_state(input_dev,
709 MT_TOOL_FINGER, 0); 746 MT_TOOL_FINGER, 0);
710 mxt_input_sync(input_dev); 747 mxt_input_sync(data);
711 } 748 }
712 749
713 /* Touch active */ 750 /* Touch active */
@@ -720,64 +757,179 @@ static void mxt_input_touchevent(struct mxt_data *data,
720 /* Touch no longer active, close out slot */ 757 /* Touch no longer active, close out slot */
721 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0); 758 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
722 } 759 }
760
761 data->update_input = true;
762}
763
764static int mxt_proc_message(struct mxt_data *data, u8 *message)
765{
766 u8 report_id = message[0];
767
768 if (report_id == MXT_RPTID_NOMSG)
769 return 0;
770
771 if (report_id == data->T6_reportid) {
772 mxt_proc_t6_messages(data, message);
773 } else if (!data->input_dev) {
774 /*
775 * Do not report events if input device
776 * is not yet registered.
777 */
778 mxt_dump_message(data, message);
779 } else if (report_id >= data->T9_reportid_min
780 && report_id <= data->T9_reportid_max) {
781 mxt_proc_t9_message(data, message);
782 } else if (report_id == data->T19_reportid) {
783 mxt_input_button(data, message);
784 data->update_input = true;
785 } else {
786 mxt_dump_message(data, message);
787 }
788
789 return 1;
723} 790}
724 791
725static u16 mxt_extract_T6_csum(const u8 *csum) 792static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
726{ 793{
727 return csum[0] | (csum[1] << 8) | (csum[2] << 16); 794 struct device *dev = &data->client->dev;
795 int ret;
796 int i;
797 u8 num_valid = 0;
798
799 /* Safety check for msg_buf */
800 if (count > data->max_reportid)
801 return -EINVAL;
802
803 /* Process remaining messages if necessary */
804 ret = __mxt_read_reg(data->client, data->T5_address,
805 data->T5_msg_size * count, data->msg_buf);
806 if (ret) {
807 dev_err(dev, "Failed to read %u messages (%d)\n", count, ret);
808 return ret;
809 }
810
811 for (i = 0; i < count; i++) {
812 ret = mxt_proc_message(data,
813 data->msg_buf + data->T5_msg_size * i);
814
815 if (ret == 1)
816 num_valid++;
817 }
818
819 /* return number of messages read */
820 return num_valid;
728} 821}
729 822
730static bool mxt_is_T9_message(struct mxt_data *data, struct mxt_message *msg) 823static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
731{ 824{
732 u8 id = msg->reportid; 825 struct device *dev = &data->client->dev;
733 return (id >= data->T9_reportid_min && id <= data->T9_reportid_max); 826 int ret;
827 u8 count, num_left;
828
829 /* Read T44 and T5 together */
830 ret = __mxt_read_reg(data->client, data->T44_address,
831 data->T5_msg_size + 1, data->msg_buf);
832 if (ret) {
833 dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret);
834 return IRQ_NONE;
835 }
836
837 count = data->msg_buf[0];
838
839 if (count == 0) {
840 dev_warn(dev, "Interrupt triggered but zero messages\n");
841 return IRQ_NONE;
842 } else if (count > data->max_reportid) {
843 dev_err(dev, "T44 count %d exceeded max report id\n", count);
844 count = data->max_reportid;
845 }
846
847 /* Process first message */
848 ret = mxt_proc_message(data, data->msg_buf + 1);
849 if (ret < 0) {
850 dev_warn(dev, "Unexpected invalid message\n");
851 return IRQ_NONE;
852 }
853
854 num_left = count - 1;
855
856 /* Process remaining messages if necessary */
857 if (num_left) {
858 ret = mxt_read_and_process_messages(data, num_left);
859 if (ret < 0)
860 goto end;
861 else if (ret != num_left)
862 dev_warn(dev, "Unexpected invalid message\n");
863 }
864
865end:
866 if (data->update_input) {
867 mxt_input_sync(data);
868 data->update_input = false;
869 }
870
871 return IRQ_HANDLED;
734} 872}
735 873
736static irqreturn_t mxt_process_messages_until_invalid(struct mxt_data *data) 874static int mxt_process_messages_until_invalid(struct mxt_data *data)
737{ 875{
738 struct mxt_message message;
739 const u8 *payload = &message.message[0];
740 struct device *dev = &data->client->dev; 876 struct device *dev = &data->client->dev;
741 u8 reportid; 877 int count, read;
742 bool update_input = false; 878 u8 tries = 2;
743 u32 crc;
744 879
880 count = data->max_reportid;
881
882 /* Read messages until we force an invalid */
745 do { 883 do {
746 if (mxt_read_message(data, &message)) { 884 read = mxt_read_and_process_messages(data, count);
747 dev_err(dev, "Failed to read message\n"); 885 if (read < count)
748 return IRQ_NONE; 886 return 0;
749 } 887 } while (--tries);
750 888
751 reportid = message.reportid; 889 if (data->update_input) {
890 mxt_input_sync(data);
891 data->update_input = false;
892 }
752 893
753 if (reportid == data->T6_reportid) { 894 dev_err(dev, "CHG pin isn't cleared\n");
754 u8 status = payload[0]; 895 return -EBUSY;
896}
755 897
756 crc = mxt_extract_T6_csum(&payload[1]); 898static irqreturn_t mxt_process_messages(struct mxt_data *data)
757 if (crc != data->config_crc) { 899{
758 data->config_crc = crc; 900 int total_handled, num_handled;
759 complete(&data->crc_completion); 901 u8 count = data->last_message_count;
760 }
761 902
762 dev_dbg(dev, "Status: %02x Config Checksum: %06x\n", 903 if (count < 1 || count > data->max_reportid)
763 status, data->config_crc); 904 count = 1;
764
765 if (status & MXT_T6_STATUS_RESET)
766 complete(&data->reset_completion);
767 } else if (mxt_is_T9_message(data, &message)) {
768 int id = reportid - data->T9_reportid_min;
769 mxt_input_touchevent(data, &message, id);
770 update_input = true;
771 } else if (message.reportid == data->T19_reportid) {
772 mxt_input_button(data, &message);
773 update_input = true;
774 } else {
775 mxt_dump_message(dev, &message);
776 }
777 } while (reportid != 0xff);
778 905
779 if (update_input) 906 /* include final invalid message */
780 mxt_input_sync(data->input_dev); 907 total_handled = mxt_read_and_process_messages(data, count + 1);
908 if (total_handled < 0)
909 return IRQ_NONE;
910 /* if there were invalid messages, then we are done */
911 else if (total_handled <= count)
912 goto update_count;
913
914 /* keep reading two msgs until one is invalid or reportid limit */
915 do {
916 num_handled = mxt_read_and_process_messages(data, 2);
917 if (num_handled < 0)
918 return IRQ_NONE;
919
920 total_handled += num_handled;
921
922 if (num_handled < 2)
923 break;
924 } while (total_handled < data->num_touchids);
925
926update_count:
927 data->last_message_count = total_handled;
928
929 if (data->update_input) {
930 mxt_input_sync(data);
931 data->update_input = false;
932 }
781 933
782 return IRQ_HANDLED; 934 return IRQ_HANDLED;
783} 935}
@@ -792,7 +944,14 @@ static irqreturn_t mxt_interrupt(int irq, void *dev_id)
792 return IRQ_HANDLED; 944 return IRQ_HANDLED;
793 } 945 }
794 946
795 return mxt_process_messages_until_invalid(data); 947 if (!data->object_table)
948 return IRQ_HANDLED;
949
950 if (data->T44_address) {
951 return mxt_process_messages_t44(data);
952 } else {
953 return mxt_process_messages(data);
954 }
796} 955}
797 956
798static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset, 957static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
@@ -866,78 +1025,314 @@ static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
866 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT); 1025 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
867} 1026}
868 1027
869static int mxt_check_reg_init(struct mxt_data *data) 1028static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
1029{
1030 static const unsigned int crcpoly = 0x80001B;
1031 u32 result;
1032 u32 data_word;
1033
1034 data_word = (secondbyte << 8) | firstbyte;
1035 result = ((*crc << 1) ^ data_word);
1036
1037 if (result & 0x1000000)
1038 result ^= crcpoly;
1039
1040 *crc = result;
1041}
1042
1043static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
1044{
1045 u32 crc = 0;
1046 u8 *ptr = base + start_off;
1047 u8 *last_val = base + end_off - 1;
1048
1049 if (end_off < start_off)
1050 return -EINVAL;
1051
1052 while (ptr < last_val) {
1053 mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
1054 ptr += 2;
1055 }
1056
1057 /* if len is odd, fill the last byte with 0 */
1058 if (ptr == last_val)
1059 mxt_calc_crc24(&crc, *ptr, 0);
1060
1061 /* Mask to 24-bit */
1062 crc &= 0x00FFFFFF;
1063
1064 return crc;
1065}
1066
1067/*
1068 * mxt_update_cfg - download configuration to chip
1069 *
1070 * Atmel Raw Config File Format
1071 *
1072 * The first four lines of the raw config file contain:
1073 * 1) Version
1074 * 2) Chip ID Information (first 7 bytes of device memory)
1075 * 3) Chip Information Block 24-bit CRC Checksum
1076 * 4) Chip Configuration 24-bit CRC Checksum
1077 *
1078 * The rest of the file consists of one line per object instance:
1079 * <TYPE> <INSTANCE> <SIZE> <CONTENTS>
1080 *
1081 * <TYPE> - 2-byte object type as hex
1082 * <INSTANCE> - 2-byte object instance number as hex
1083 * <SIZE> - 2-byte object size as hex
1084 * <CONTENTS> - array of <SIZE> 1-byte hex values
1085 */
1086static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
870{ 1087{
871 const struct mxt_platform_data *pdata = data->pdata;
872 struct mxt_object *object;
873 struct device *dev = &data->client->dev; 1088 struct device *dev = &data->client->dev;
874 int index = 0; 1089 struct mxt_info cfg_info;
875 int i, size; 1090 struct mxt_object *object;
876 int ret; 1091 int ret;
1092 int offset;
1093 int data_pos;
1094 int byte_offset;
1095 int i;
1096 int cfg_start_ofs;
1097 u32 info_crc, config_crc, calculated_crc;
1098 u8 *config_mem;
1099 size_t config_mem_size;
1100 unsigned int type, instance, size;
1101 u8 val;
1102 u16 reg;
877 1103
878 if (!pdata->config) { 1104 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
879 dev_dbg(dev, "No cfg data defined, skipping reg init\n"); 1105
880 return 0; 1106 if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
1107 dev_err(dev, "Unrecognised config file\n");
1108 ret = -EINVAL;
1109 goto release;
881 } 1110 }
882 1111
883 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1); 1112 data_pos = strlen(MXT_CFG_MAGIC);
1113
1114 /* Load information block and check */
1115 for (i = 0; i < sizeof(struct mxt_info); i++) {
1116 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1117 (unsigned char *)&cfg_info + i,
1118 &offset);
1119 if (ret != 1) {
1120 dev_err(dev, "Bad format\n");
1121 ret = -EINVAL;
1122 goto release;
1123 }
884 1124
885 if (data->config_crc == pdata->config_crc) { 1125 data_pos += offset;
886 dev_info(dev, "Config CRC 0x%06X: OK\n", data->config_crc);
887 return 0;
888 } 1126 }
889 1127
890 dev_info(dev, "Config CRC 0x%06X: does not match 0x%06X\n", 1128 if (cfg_info.family_id != data->info.family_id) {
891 data->config_crc, pdata->config_crc); 1129 dev_err(dev, "Family ID mismatch!\n");
1130 ret = -EINVAL;
1131 goto release;
1132 }
892 1133
893 for (i = 0; i < data->info.object_num; i++) { 1134 if (cfg_info.variant_id != data->info.variant_id) {
894 object = data->object_table + i; 1135 dev_err(dev, "Variant ID mismatch!\n");
1136 ret = -EINVAL;
1137 goto release;
1138 }
1139
1140 /* Read CRCs */
1141 ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
1142 if (ret != 1) {
1143 dev_err(dev, "Bad format: failed to parse Info CRC\n");
1144 ret = -EINVAL;
1145 goto release;
1146 }
1147 data_pos += offset;
895 1148
896 if (!mxt_object_writable(object->type)) 1149 ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1150 if (ret != 1) {
1151 dev_err(dev, "Bad format: failed to parse Config CRC\n");
1152 ret = -EINVAL;
1153 goto release;
1154 }
1155 data_pos += offset;
1156
1157 /*
1158 * The Info Block CRC is calculated over mxt_info and the object
1159 * table. If it does not match then we are trying to load the
1160 * configuration from a different chip or firmware version, so
1161 * the configuration CRC is invalid anyway.
1162 */
1163 if (info_crc == data->info_crc) {
1164 if (config_crc == 0 || data->config_crc == 0) {
1165 dev_info(dev, "CRC zero, attempting to apply config\n");
1166 } else if (config_crc == data->config_crc) {
1167 dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1168 data->config_crc);
1169 ret = 0;
1170 goto release;
1171 } else {
1172 dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1173 data->config_crc, config_crc);
1174 }
1175 } else {
1176 dev_warn(dev,
1177 "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1178 data->info_crc, info_crc);
1179 }
1180
1181 /* Malloc memory to store configuration */
1182 cfg_start_ofs = MXT_OBJECT_START +
1183 data->info.object_num * sizeof(struct mxt_object) +
1184 MXT_INFO_CHECKSUM_SIZE;
1185 config_mem_size = data->mem_size - cfg_start_ofs;
1186 config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1187 if (!config_mem) {
1188 dev_err(dev, "Failed to allocate memory\n");
1189 ret = -ENOMEM;
1190 goto release;
1191 }
1192
1193 while (data_pos < cfg->size) {
1194 /* Read type, instance, length */
1195 ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
1196 &type, &instance, &size, &offset);
1197 if (ret == 0) {
1198 /* EOF */
1199 break;
1200 } else if (ret != 3) {
1201 dev_err(dev, "Bad format: failed to parse object\n");
1202 ret = -EINVAL;
1203 goto release_mem;
1204 }
1205 data_pos += offset;
1206
1207 object = mxt_get_object(data, type);
1208 if (!object) {
1209 /* Skip object */
1210 for (i = 0; i < size; i++) {
1211 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1212 &val,
1213 &offset);
1214 data_pos += offset;
1215 }
897 continue; 1216 continue;
1217 }
898 1218
899 size = mxt_obj_size(object) * mxt_obj_instances(object); 1219 if (size > mxt_obj_size(object)) {
900 if (index + size > pdata->config_length) { 1220 /*
901 dev_err(dev, "Not enough config data!\n"); 1221 * Either we are in fallback mode due to wrong
902 return -EINVAL; 1222 * config or config from a later fw version,
1223 * or the file is corrupt or hand-edited.
1224 */
1225 dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1226 size - mxt_obj_size(object), type);
1227 } else if (mxt_obj_size(object) > size) {
1228 /*
1229 * If firmware is upgraded, new bytes may be added to
1230 * end of objects. It is generally forward compatible
1231 * to zero these bytes - previous behaviour will be
1232 * retained. However this does invalidate the CRC and
1233 * will force fallback mode until the configuration is
1234 * updated. We warn here but do nothing else - the
1235 * malloc has zeroed the entire configuration.
1236 */
1237 dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1238 mxt_obj_size(object) - size, type);
903 } 1239 }
904 1240
905 ret = __mxt_write_reg(data->client, object->start_address, 1241 if (instance >= mxt_obj_instances(object)) {
906 size, &pdata->config[index]); 1242 dev_err(dev, "Object instances exceeded!\n");
907 if (ret) 1243 ret = -EINVAL;
908 return ret; 1244 goto release_mem;
909 index += size; 1245 }
1246
1247 reg = object->start_address + mxt_obj_size(object) * instance;
1248
1249 for (i = 0; i < size; i++) {
1250 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1251 &val,
1252 &offset);
1253 if (ret != 1) {
1254 dev_err(dev, "Bad format in T%d\n", type);
1255 ret = -EINVAL;
1256 goto release_mem;
1257 }
1258 data_pos += offset;
1259
1260 if (i > mxt_obj_size(object))
1261 continue;
1262
1263 byte_offset = reg + i - cfg_start_ofs;
1264
1265 if ((byte_offset >= 0)
1266 && (byte_offset <= config_mem_size)) {
1267 *(config_mem + byte_offset) = val;
1268 } else {
1269 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1270 reg, object->type, byte_offset);
1271 ret = -EINVAL;
1272 goto release_mem;
1273 }
1274 }
1275 }
1276
1277 /* Calculate crc of the received configs (not the raw config file) */
1278 if (data->T7_address < cfg_start_ofs) {
1279 dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1280 data->T7_address, cfg_start_ofs);
1281 ret = 0;
1282 goto release_mem;
1283 }
1284
1285 calculated_crc = mxt_calculate_crc(config_mem,
1286 data->T7_address - cfg_start_ofs,
1287 config_mem_size);
1288
1289 if (config_crc > 0 && (config_crc != calculated_crc))
1290 dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
1291 calculated_crc, config_crc);
1292
1293 /* Write configuration as blocks */
1294 byte_offset = 0;
1295 while (byte_offset < config_mem_size) {
1296 size = config_mem_size - byte_offset;
1297
1298 if (size > MXT_MAX_BLOCK_WRITE)
1299 size = MXT_MAX_BLOCK_WRITE;
1300
1301 ret = __mxt_write_reg(data->client,
1302 cfg_start_ofs + byte_offset,
1303 size, config_mem + byte_offset);
1304 if (ret != 0) {
1305 dev_err(dev, "Config write error, ret=%d\n", ret);
1306 goto release_mem;
1307 }
1308
1309 byte_offset += size;
910 } 1310 }
911 1311
912 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE); 1312 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
913 1313
914 ret = mxt_soft_reset(data); 1314 ret = mxt_soft_reset(data);
915 if (ret) 1315 if (ret)
916 return ret; 1316 goto release_mem;
917 1317
918 dev_info(dev, "Config successfully updated\n"); 1318 dev_info(dev, "Config successfully updated\n");
919 1319
920 return 0; 1320release_mem:
1321 kfree(config_mem);
1322release:
1323 release_firmware(cfg);
1324 return ret;
921} 1325}
922 1326
923static int mxt_make_highchg(struct mxt_data *data) 1327static int mxt_acquire_irq(struct mxt_data *data)
924{ 1328{
925 struct device *dev = &data->client->dev;
926 struct mxt_message message;
927 int count = 10;
928 int error; 1329 int error;
929 1330
930 /* Read dummy message to make high CHG pin */ 1331 enable_irq(data->irq);
931 do {
932 error = mxt_read_message(data, &message);
933 if (error)
934 return error;
935 } while (message.reportid != 0xff && --count);
936 1332
937 if (!count) { 1333 error = mxt_process_messages_until_invalid(data);
938 dev_err(dev, "CHG pin isn't cleared\n"); 1334 if (error)
939 return -EBUSY; 1335 return error;
940 }
941 1336
942 return 0; 1337 return 0;
943} 1338}
@@ -956,24 +1351,55 @@ static int mxt_get_info(struct mxt_data *data)
956 return 0; 1351 return 0;
957} 1352}
958 1353
1354static void mxt_free_object_table(struct mxt_data *data)
1355{
1356 input_unregister_device(data->input_dev);
1357 data->input_dev = NULL;
1358
1359 kfree(data->object_table);
1360 data->object_table = NULL;
1361 kfree(data->msg_buf);
1362 data->msg_buf = NULL;
1363 data->T5_address = 0;
1364 data->T5_msg_size = 0;
1365 data->T6_reportid = 0;
1366 data->T7_address = 0;
1367 data->T9_reportid_min = 0;
1368 data->T9_reportid_max = 0;
1369 data->T19_reportid = 0;
1370 data->T44_address = 0;
1371 data->max_reportid = 0;
1372}
1373
959static int mxt_get_object_table(struct mxt_data *data) 1374static int mxt_get_object_table(struct mxt_data *data)
960{ 1375{
961 struct i2c_client *client = data->client; 1376 struct i2c_client *client = data->client;
962 size_t table_size; 1377 size_t table_size;
1378 struct mxt_object *object_table;
963 int error; 1379 int error;
964 int i; 1380 int i;
965 u8 reportid; 1381 u8 reportid;
1382 u16 end_address;
966 1383
967 table_size = data->info.object_num * sizeof(struct mxt_object); 1384 table_size = data->info.object_num * sizeof(struct mxt_object);
1385 object_table = kzalloc(table_size, GFP_KERNEL);
1386 if (!object_table) {
1387 dev_err(&data->client->dev, "Failed to allocate memory\n");
1388 return -ENOMEM;
1389 }
1390
968 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size, 1391 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
969 data->object_table); 1392 object_table);
970 if (error) 1393 if (error) {
1394 kfree(object_table);
971 return error; 1395 return error;
1396 }
972 1397
973 /* Valid Report IDs start counting from 1 */ 1398 /* Valid Report IDs start counting from 1 */
974 reportid = 1; 1399 reportid = 1;
1400 data->mem_size = 0;
975 for (i = 0; i < data->info.object_num; i++) { 1401 for (i = 0; i < data->info.object_num; i++) {
976 struct mxt_object *object = data->object_table + i; 1402 struct mxt_object *object = object_table + i;
977 u8 min_id, max_id; 1403 u8 min_id, max_id;
978 1404
979 le16_to_cpus(&object->start_address); 1405 le16_to_cpus(&object->start_address);
@@ -995,31 +1421,71 @@ static int mxt_get_object_table(struct mxt_data *data)
995 min_id, max_id); 1421 min_id, max_id);
996 1422
997 switch (object->type) { 1423 switch (object->type) {
1424 case MXT_GEN_MESSAGE_T5:
1425 if (data->info.family_id == 0x80) {
1426 /*
1427 * On mXT224 read and discard unused CRC byte
1428 * otherwise DMA reads are misaligned
1429 */
1430 data->T5_msg_size = mxt_obj_size(object);
1431 } else {
1432 /* CRC not enabled, so skip last byte */
1433 data->T5_msg_size = mxt_obj_size(object) - 1;
1434 }
1435 data->T5_address = object->start_address;
998 case MXT_GEN_COMMAND_T6: 1436 case MXT_GEN_COMMAND_T6:
999 data->T6_reportid = min_id; 1437 data->T6_reportid = min_id;
1000 data->T6_address = object->start_address; 1438 data->T6_address = object->start_address;
1001 break; 1439 break;
1440 case MXT_GEN_POWER_T7:
1441 data->T7_address = object->start_address;
1442 break;
1002 case MXT_TOUCH_MULTI_T9: 1443 case MXT_TOUCH_MULTI_T9:
1003 data->T9_reportid_min = min_id; 1444 data->T9_reportid_min = min_id;
1004 data->T9_reportid_max = max_id; 1445 data->T9_reportid_max = max_id;
1446 data->num_touchids = object->num_report_ids
1447 * mxt_obj_instances(object);
1448 break;
1449 case MXT_SPT_MESSAGECOUNT_T44:
1450 data->T44_address = object->start_address;
1005 break; 1451 break;
1006 case MXT_SPT_GPIOPWM_T19: 1452 case MXT_SPT_GPIOPWM_T19:
1007 data->T19_reportid = min_id; 1453 data->T19_reportid = min_id;
1008 break; 1454 break;
1009 } 1455 }
1456
1457 end_address = object->start_address
1458 + mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1459
1460 if (end_address >= data->mem_size)
1461 data->mem_size = end_address + 1;
1462 }
1463
1464 /* Store maximum reportid */
1465 data->max_reportid = reportid;
1466
1467 /* If T44 exists, T5 position has to be directly after */
1468 if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1469 dev_err(&client->dev, "Invalid T44 position\n");
1470 error = -EINVAL;
1471 goto free_object_table;
1472 }
1473
1474 data->msg_buf = kcalloc(data->max_reportid,
1475 data->T5_msg_size, GFP_KERNEL);
1476 if (!data->msg_buf) {
1477 dev_err(&client->dev, "Failed to allocate message buffer\n");
1478 error = -ENOMEM;
1479 goto free_object_table;
1010 } 1480 }
1011 1481
1482 data->object_table = object_table;
1483
1012 return 0; 1484 return 0;
1013}
1014 1485
1015static void mxt_free_object_table(struct mxt_data *data) 1486free_object_table:
1016{ 1487 mxt_free_object_table(data);
1017 kfree(data->object_table); 1488 return error;
1018 data->object_table = NULL;
1019 data->T6_reportid = 0;
1020 data->T9_reportid_min = 0;
1021 data->T9_reportid_max = 0;
1022 data->T19_reportid = 0;
1023} 1489}
1024 1490
1025static int mxt_read_t9_resolution(struct mxt_data *data) 1491static int mxt_read_t9_resolution(struct mxt_data *data)
@@ -1070,55 +1536,255 @@ static int mxt_read_t9_resolution(struct mxt_data *data)
1070 return 0; 1536 return 0;
1071} 1537}
1072 1538
1539static int mxt_input_open(struct input_dev *dev);
1540static void mxt_input_close(struct input_dev *dev);
1541
1542static int mxt_initialize_t9_input_device(struct mxt_data *data)
1543{
1544 struct device *dev = &data->client->dev;
1545 const struct mxt_platform_data *pdata = data->pdata;
1546 struct input_dev *input_dev;
1547 int error;
1548 unsigned int num_mt_slots;
1549 unsigned int mt_flags = 0;
1550 int i;
1551
1552 error = mxt_read_t9_resolution(data);
1553 if (error)
1554 dev_warn(dev, "Failed to initialize T9 resolution\n");
1555
1556 input_dev = input_allocate_device();
1557 if (!input_dev) {
1558 dev_err(dev, "Failed to allocate memory\n");
1559 return -ENOMEM;
1560 }
1561
1562 input_dev->name = "Atmel maXTouch Touchscreen";
1563 input_dev->phys = data->phys;
1564 input_dev->id.bustype = BUS_I2C;
1565 input_dev->dev.parent = dev;
1566 input_dev->open = mxt_input_open;
1567 input_dev->close = mxt_input_close;
1568
1569 __set_bit(EV_ABS, input_dev->evbit);
1570 __set_bit(EV_KEY, input_dev->evbit);
1571 __set_bit(BTN_TOUCH, input_dev->keybit);
1572
1573 if (pdata->t19_num_keys) {
1574 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1575
1576 for (i = 0; i < pdata->t19_num_keys; i++)
1577 if (pdata->t19_keymap[i] != KEY_RESERVED)
1578 input_set_capability(input_dev, EV_KEY,
1579 pdata->t19_keymap[i]);
1580
1581 mt_flags |= INPUT_MT_POINTER;
1582
1583 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1584 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1585 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1586 MXT_PIXELS_PER_MM);
1587 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1588 MXT_PIXELS_PER_MM);
1589
1590 input_dev->name = "Atmel maXTouch Touchpad";
1591 }
1592
1593 /* For single touch */
1594 input_set_abs_params(input_dev, ABS_X,
1595 0, data->max_x, 0, 0);
1596 input_set_abs_params(input_dev, ABS_Y,
1597 0, data->max_y, 0, 0);
1598 input_set_abs_params(input_dev, ABS_PRESSURE,
1599 0, 255, 0, 0);
1600
1601 /* For multi touch */
1602 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1603 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1604 if (error) {
1605 dev_err(dev, "Error %d initialising slots\n", error);
1606 goto err_free_mem;
1607 }
1608
1609 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1610 0, MXT_MAX_AREA, 0, 0);
1611 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1612 0, data->max_x, 0, 0);
1613 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1614 0, data->max_y, 0, 0);
1615 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1616 0, 255, 0, 0);
1617
1618 input_set_drvdata(input_dev, data);
1619
1620 error = input_register_device(input_dev);
1621 if (error) {
1622 dev_err(dev, "Error %d registering input device\n", error);
1623 goto err_free_mem;
1624 }
1625
1626 data->input_dev = input_dev;
1627
1628 return 0;
1629
1630err_free_mem:
1631 input_free_device(input_dev);
1632 return error;
1633}
1634
1635static int mxt_configure_objects(struct mxt_data *data,
1636 const struct firmware *cfg);
1637
1638static void mxt_config_cb(const struct firmware *cfg, void *ctx)
1639{
1640 mxt_configure_objects(ctx, cfg);
1641}
1642
1073static int mxt_initialize(struct mxt_data *data) 1643static int mxt_initialize(struct mxt_data *data)
1074{ 1644{
1075 struct i2c_client *client = data->client; 1645 struct i2c_client *client = data->client;
1076 struct mxt_info *info = &data->info;
1077 int error; 1646 int error;
1647 bool alt_bootloader_addr = false;
1648 bool retry = false;
1078 1649
1650retry_info:
1079 error = mxt_get_info(data); 1651 error = mxt_get_info(data);
1080 if (error) 1652 if (error) {
1081 return error; 1653retry_bootloader:
1654 error = mxt_probe_bootloader(data, alt_bootloader_addr);
1655 if (error) {
1656 if (alt_bootloader_addr) {
1657 /* Chip is not in appmode or bootloader mode */
1658 return error;
1659 }
1082 1660
1083 data->object_table = kcalloc(info->object_num, 1661 dev_info(&client->dev, "Trying alternate bootloader address\n");
1084 sizeof(struct mxt_object), 1662 alt_bootloader_addr = true;
1085 GFP_KERNEL); 1663 goto retry_bootloader;
1086 if (!data->object_table) { 1664 } else {
1087 dev_err(&client->dev, "Failed to allocate memory\n"); 1665 if (retry) {
1088 return -ENOMEM; 1666 dev_err(&client->dev, "Could not recover from bootloader mode\n");
1667 /*
1668 * We can reflash from this state, so do not
1669 * abort init
1670 */
1671 data->in_bootloader = true;
1672 return 0;
1673 }
1674
1675 /* Attempt to exit bootloader into app mode */
1676 mxt_send_bootloader_cmd(data, false);
1677 msleep(MXT_FW_RESET_TIME);
1678 retry = true;
1679 goto retry_info;
1680 }
1089 } 1681 }
1090 1682
1091 /* Get object table information */ 1683 /* Get object table information */
1092 error = mxt_get_object_table(data); 1684 error = mxt_get_object_table(data);
1093 if (error) { 1685 if (error) {
1094 dev_err(&client->dev, "Error %d reading object table\n", error); 1686 dev_err(&client->dev, "Error %d reading object table\n", error);
1095 goto err_free_object_table; 1687 return error;
1096 } 1688 }
1097 1689
1098 /* Check register init values */ 1690 mxt_acquire_irq(data);
1099 error = mxt_check_reg_init(data); 1691 if (error)
1100 if (error) {
1101 dev_err(&client->dev, "Error %d initializing configuration\n",
1102 error);
1103 goto err_free_object_table; 1692 goto err_free_object_table;
1693
1694 request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
1695 &data->client->dev, GFP_KERNEL, data,
1696 mxt_config_cb);
1697
1698 return 0;
1699
1700err_free_object_table:
1701 mxt_free_object_table(data);
1702 return error;
1703}
1704
1705static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
1706{
1707 struct device *dev = &data->client->dev;
1708 int error;
1709 struct t7_config *new_config;
1710 struct t7_config deepsleep = { .active = 0, .idle = 0 };
1711
1712 if (sleep == MXT_POWER_CFG_DEEPSLEEP)
1713 new_config = &deepsleep;
1714 else
1715 new_config = &data->t7_cfg;
1716
1717 error = __mxt_write_reg(data->client, data->T7_address,
1718 sizeof(data->t7_cfg), new_config);
1719 if (error)
1720 return error;
1721
1722 dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n",
1723 new_config->active, new_config->idle);
1724
1725 return 0;
1726}
1727
1728static int mxt_init_t7_power_cfg(struct mxt_data *data)
1729{
1730 struct device *dev = &data->client->dev;
1731 int error;
1732 bool retry = false;
1733
1734recheck:
1735 error = __mxt_read_reg(data->client, data->T7_address,
1736 sizeof(data->t7_cfg), &data->t7_cfg);
1737 if (error)
1738 return error;
1739
1740 if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) {
1741 if (!retry) {
1742 dev_dbg(dev, "T7 cfg zero, resetting\n");
1743 mxt_soft_reset(data);
1744 retry = true;
1745 goto recheck;
1746 } else {
1747 dev_dbg(dev, "T7 cfg zero after reset, overriding\n");
1748 data->t7_cfg.active = 20;
1749 data->t7_cfg.idle = 100;
1750 return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
1751 }
1104 } 1752 }
1105 1753
1106 error = mxt_read_t9_resolution(data); 1754 dev_dbg(dev, "Initialized power cfg: ACTV %d, IDLE %d\n",
1755 data->t7_cfg.active, data->t7_cfg.idle);
1756 return 0;
1757}
1758
1759static int mxt_configure_objects(struct mxt_data *data,
1760 const struct firmware *cfg)
1761{
1762 struct device *dev = &data->client->dev;
1763 struct mxt_info *info = &data->info;
1764 int error;
1765
1766 if (cfg) {
1767 error = mxt_update_cfg(data, cfg);
1768 if (error)
1769 dev_warn(dev, "Error %d updating config\n", error);
1770 }
1771
1772 error = mxt_init_t7_power_cfg(data);
1107 if (error) { 1773 if (error) {
1108 dev_err(&client->dev, "Failed to initialize T9 resolution\n"); 1774 dev_err(dev, "Failed to initialize power cfg\n");
1109 goto err_free_object_table; 1775 return error;
1110 } 1776 }
1111 1777
1112 dev_info(&client->dev, 1778 error = mxt_initialize_t9_input_device(data);
1779 if (error)
1780 return error;
1781
1782 dev_info(dev,
1113 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n", 1783 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
1114 info->family_id, info->variant_id, info->version >> 4, 1784 info->family_id, info->variant_id, info->version >> 4,
1115 info->version & 0xf, info->build, info->object_num); 1785 info->version & 0xf, info->build, info->object_num);
1116 1786
1117 return 0; 1787 return 0;
1118
1119err_free_object_table:
1120 mxt_free_object_table(data);
1121 return error;
1122} 1788}
1123 1789
1124/* Firmware Version is returned as Major.Minor.Build */ 1790/* Firmware Version is returned as Major.Minor.Build */
@@ -1246,30 +1912,45 @@ static int mxt_load_fw(struct device *dev, const char *fn)
1246 if (ret) 1912 if (ret)
1247 goto release_firmware; 1913 goto release_firmware;
1248 1914
1249 ret = mxt_lookup_bootloader_address(data); 1915 if (!data->in_bootloader) {
1250 if (ret) 1916 /* Change to the bootloader mode */
1251 goto release_firmware; 1917 data->in_bootloader = true;
1252 1918
1253 /* Change to the bootloader mode */ 1919 ret = mxt_t6_command(data, MXT_COMMAND_RESET,
1254 data->in_bootloader = true; 1920 MXT_BOOT_VALUE, false);
1921 if (ret)
1922 goto release_firmware;
1255 1923
1256 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_BOOT_VALUE, false); 1924 msleep(MXT_RESET_TIME);
1257 if (ret)
1258 goto release_firmware;
1259 1925
1260 msleep(MXT_RESET_TIME); 1926 /* Do not need to scan since we know family ID */
1927 ret = mxt_lookup_bootloader_address(data, 0);
1928 if (ret)
1929 goto release_firmware;
1930 } else {
1931 enable_irq(data->irq);
1932 }
1261 1933
1934 mxt_free_object_table(data);
1262 reinit_completion(&data->bl_completion); 1935 reinit_completion(&data->bl_completion);
1263 1936
1264 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD); 1937 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
1265 if (ret) 1938 if (ret) {
1266 goto disable_irq; 1939 /* Bootloader may still be unlocked from previous attempt */
1940 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
1941 if (ret)
1942 goto disable_irq;
1943 } else {
1944 dev_info(dev, "Unlocking bootloader\n");
1267 1945
1268 /* Unlock bootloader */ 1946 /* Unlock bootloader */
1269 mxt_unlock_bootloader(data); 1947 ret = mxt_send_bootloader_cmd(data, true);
1948 if (ret)
1949 goto disable_irq;
1950 }
1270 1951
1271 while (pos < fw->size) { 1952 while (pos < fw->size) {
1272 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA); 1953 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
1273 if (ret) 1954 if (ret)
1274 goto disable_irq; 1955 goto disable_irq;
1275 1956
@@ -1283,7 +1964,7 @@ static int mxt_load_fw(struct device *dev, const char *fn)
1283 if (ret) 1964 if (ret)
1284 goto disable_irq; 1965 goto disable_irq;
1285 1966
1286 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS); 1967 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
1287 if (ret) { 1968 if (ret) {
1288 retry++; 1969 retry++;
1289 1970
@@ -1343,13 +2024,7 @@ static ssize_t mxt_update_fw_store(struct device *dev,
1343 } else { 2024 } else {
1344 dev_info(dev, "The firmware update succeeded\n"); 2025 dev_info(dev, "The firmware update succeeded\n");
1345 2026
1346 mxt_free_object_table(data); 2027 error = mxt_initialize(data);
1347
1348 mxt_initialize(data);
1349
1350 enable_irq(data->irq);
1351
1352 error = mxt_make_highchg(data);
1353 if (error) 2028 if (error)
1354 return error; 2029 return error;
1355 } 2030 }
@@ -1376,16 +2051,15 @@ static const struct attribute_group mxt_attr_group = {
1376 2051
1377static void mxt_start(struct mxt_data *data) 2052static void mxt_start(struct mxt_data *data)
1378{ 2053{
1379 /* Touch enable */ 2054 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
1380 mxt_write_object(data, 2055
1381 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83); 2056 /* Recalibrate since chip has been in deep sleep */
2057 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
1382} 2058}
1383 2059
1384static void mxt_stop(struct mxt_data *data) 2060static void mxt_stop(struct mxt_data *data)
1385{ 2061{
1386 /* Touch disable */ 2062 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
1387 mxt_write_object(data,
1388 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
1389} 2063}
1390 2064
1391static int mxt_input_open(struct input_dev *dev) 2065static int mxt_input_open(struct input_dev *dev)
@@ -1404,138 +2078,112 @@ static void mxt_input_close(struct input_dev *dev)
1404 mxt_stop(data); 2078 mxt_stop(data);
1405} 2079}
1406 2080
1407static int mxt_probe(struct i2c_client *client, 2081#ifdef CONFIG_OF
1408 const struct i2c_device_id *id) 2082static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2083{
2084 struct mxt_platform_data *pdata;
2085 u32 *keymap;
2086 u32 keycode;
2087 int proplen, i, ret;
2088
2089 if (!client->dev.of_node)
2090 return ERR_PTR(-ENODEV);
2091
2092 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
2093 if (!pdata)
2094 return ERR_PTR(-ENOMEM);
2095
2096 if (of_find_property(client->dev.of_node, "linux,gpio-keymap",
2097 &proplen)) {
2098 pdata->t19_num_keys = proplen / sizeof(u32);
2099
2100 keymap = devm_kzalloc(&client->dev,
2101 pdata->t19_num_keys * sizeof(keymap[0]),
2102 GFP_KERNEL);
2103 if (!keymap)
2104 return ERR_PTR(-ENOMEM);
2105
2106 for (i = 0; i < pdata->t19_num_keys; i++) {
2107 ret = of_property_read_u32_index(client->dev.of_node,
2108 "linux,gpio-keymap", i, &keycode);
2109 if (ret)
2110 keycode = KEY_RESERVED;
2111
2112 keymap[i] = keycode;
2113 }
2114
2115 pdata->t19_keymap = keymap;
2116 }
2117
2118 return pdata;
2119}
2120#else
2121static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2122{
2123 dev_dbg(&client->dev, "No platform data specified\n");
2124 return ERR_PTR(-EINVAL);
2125}
2126#endif
2127
2128static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
1409{ 2129{
1410 const struct mxt_platform_data *pdata = dev_get_platdata(&client->dev);
1411 struct mxt_data *data; 2130 struct mxt_data *data;
1412 struct input_dev *input_dev; 2131 const struct mxt_platform_data *pdata;
1413 int error; 2132 int error;
1414 unsigned int num_mt_slots;
1415 unsigned int mt_flags = 0;
1416 int i;
1417 2133
1418 if (!pdata) 2134 pdata = dev_get_platdata(&client->dev);
1419 return -EINVAL; 2135 if (!pdata) {
2136 pdata = mxt_parse_dt(client);
2137 if (IS_ERR(pdata))
2138 return PTR_ERR(pdata);
2139 }
1420 2140
1421 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL); 2141 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1422 input_dev = input_allocate_device(); 2142 if (!data) {
1423 if (!data || !input_dev) {
1424 dev_err(&client->dev, "Failed to allocate memory\n"); 2143 dev_err(&client->dev, "Failed to allocate memory\n");
1425 error = -ENOMEM; 2144 return -ENOMEM;
1426 goto err_free_mem;
1427 } 2145 }
1428 2146
1429 input_dev->name = "Atmel maXTouch Touchscreen";
1430 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0", 2147 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
1431 client->adapter->nr, client->addr); 2148 client->adapter->nr, client->addr);
1432 2149
1433 input_dev->phys = data->phys;
1434
1435 input_dev->id.bustype = BUS_I2C;
1436 input_dev->dev.parent = &client->dev;
1437 input_dev->open = mxt_input_open;
1438 input_dev->close = mxt_input_close;
1439
1440 data->client = client; 2150 data->client = client;
1441 data->input_dev = input_dev;
1442 data->pdata = pdata; 2151 data->pdata = pdata;
1443 data->irq = client->irq; 2152 data->irq = client->irq;
2153 i2c_set_clientdata(client, data);
1444 2154
1445 init_completion(&data->bl_completion); 2155 init_completion(&data->bl_completion);
1446 init_completion(&data->reset_completion); 2156 init_completion(&data->reset_completion);
1447 init_completion(&data->crc_completion); 2157 init_completion(&data->crc_completion);
1448 2158
1449 error = mxt_initialize(data);
1450 if (error)
1451 goto err_free_mem;
1452
1453 __set_bit(EV_ABS, input_dev->evbit);
1454 __set_bit(EV_KEY, input_dev->evbit);
1455 __set_bit(BTN_TOUCH, input_dev->keybit);
1456
1457 if (pdata->t19_num_keys) {
1458 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1459
1460 for (i = 0; i < pdata->t19_num_keys; i++)
1461 if (pdata->t19_keymap[i] != KEY_RESERVED)
1462 input_set_capability(input_dev, EV_KEY,
1463 pdata->t19_keymap[i]);
1464
1465 mt_flags |= INPUT_MT_POINTER;
1466
1467 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1468 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1469 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1470 MXT_PIXELS_PER_MM);
1471 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1472 MXT_PIXELS_PER_MM);
1473
1474 input_dev->name = "Atmel maXTouch Touchpad";
1475 }
1476
1477 /* For single touch */
1478 input_set_abs_params(input_dev, ABS_X,
1479 0, data->max_x, 0, 0);
1480 input_set_abs_params(input_dev, ABS_Y,
1481 0, data->max_y, 0, 0);
1482 input_set_abs_params(input_dev, ABS_PRESSURE,
1483 0, 255, 0, 0);
1484
1485 /* For multi touch */
1486 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1487 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1488 if (error)
1489 goto err_free_object;
1490 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1491 0, MXT_MAX_AREA, 0, 0);
1492 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1493 0, data->max_x, 0, 0);
1494 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1495 0, data->max_y, 0, 0);
1496 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1497 0, 255, 0, 0);
1498
1499 input_set_drvdata(input_dev, data);
1500 i2c_set_clientdata(client, data);
1501
1502 error = request_threaded_irq(client->irq, NULL, mxt_interrupt, 2159 error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1503 pdata->irqflags | IRQF_ONESHOT, 2160 pdata->irqflags | IRQF_ONESHOT,
1504 client->name, data); 2161 client->name, data);
1505 if (error) { 2162 if (error) {
1506 dev_err(&client->dev, "Failed to register interrupt\n"); 2163 dev_err(&client->dev, "Failed to register interrupt\n");
1507 goto err_free_object; 2164 goto err_free_mem;
1508 } 2165 }
1509 2166
1510 error = mxt_make_highchg(data); 2167 disable_irq(client->irq);
1511 if (error)
1512 goto err_free_irq;
1513 2168
1514 error = input_register_device(input_dev); 2169 error = mxt_initialize(data);
1515 if (error) { 2170 if (error)
1516 dev_err(&client->dev, "Error %d registering input device\n",
1517 error);
1518 goto err_free_irq; 2171 goto err_free_irq;
1519 }
1520 2172
1521 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group); 2173 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1522 if (error) { 2174 if (error) {
1523 dev_err(&client->dev, "Failure %d creating sysfs group\n", 2175 dev_err(&client->dev, "Failure %d creating sysfs group\n",
1524 error); 2176 error);
1525 goto err_unregister_device; 2177 goto err_free_object;
1526 } 2178 }
1527 2179
1528 return 0; 2180 return 0;
1529 2181
1530err_unregister_device: 2182err_free_object:
1531 input_unregister_device(input_dev); 2183 mxt_free_object_table(data);
1532 input_dev = NULL;
1533err_free_irq: 2184err_free_irq:
1534 free_irq(client->irq, data); 2185 free_irq(client->irq, data);
1535err_free_object:
1536 kfree(data->object_table);
1537err_free_mem: 2186err_free_mem:
1538 input_free_device(input_dev);
1539 kfree(data); 2187 kfree(data);
1540 return error; 2188 return error;
1541} 2189}
@@ -1547,7 +2195,7 @@ static int mxt_remove(struct i2c_client *client)
1547 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group); 2195 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1548 free_irq(data->irq, data); 2196 free_irq(data->irq, data);
1549 input_unregister_device(data->input_dev); 2197 input_unregister_device(data->input_dev);
1550 kfree(data->object_table); 2198 mxt_free_object_table(data);
1551 kfree(data); 2199 kfree(data);
1552 2200
1553 return 0; 2201 return 0;
@@ -1576,8 +2224,6 @@ static int mxt_resume(struct device *dev)
1576 struct mxt_data *data = i2c_get_clientdata(client); 2224 struct mxt_data *data = i2c_get_clientdata(client);
1577 struct input_dev *input_dev = data->input_dev; 2225 struct input_dev *input_dev = data->input_dev;
1578 2226
1579 mxt_soft_reset(data);
1580
1581 mutex_lock(&input_dev->mutex); 2227 mutex_lock(&input_dev->mutex);
1582 2228
1583 if (input_dev->users) 2229 if (input_dev->users)
@@ -1591,6 +2237,12 @@ static int mxt_resume(struct device *dev)
1591 2237
1592static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume); 2238static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1593 2239
2240static const struct of_device_id mxt_of_match[] = {
2241 { .compatible = "atmel,maxtouch", },
2242 {},
2243};
2244MODULE_DEVICE_TABLE(of, mxt_of_match);
2245
1594static const struct i2c_device_id mxt_id[] = { 2246static const struct i2c_device_id mxt_id[] = {
1595 { "qt602240_ts", 0 }, 2247 { "qt602240_ts", 0 },
1596 { "atmel_mxt_ts", 0 }, 2248 { "atmel_mxt_ts", 0 },
@@ -1604,6 +2256,7 @@ static struct i2c_driver mxt_driver = {
1604 .driver = { 2256 .driver = {
1605 .name = "atmel_mxt_ts", 2257 .name = "atmel_mxt_ts",
1606 .owner = THIS_MODULE, 2258 .owner = THIS_MODULE,
2259 .of_match_table = of_match_ptr(mxt_of_match),
1607 .pm = &mxt_pm_ops, 2260 .pm = &mxt_pm_ops,
1608 }, 2261 },
1609 .probe = mxt_probe, 2262 .probe = mxt_probe,
diff --git a/drivers/input/touchscreen/edt-ft5x06.c b/drivers/input/touchscreen/edt-ft5x06.c
index d4f33992ad8c..5a6d50c004d7 100644
--- a/drivers/input/touchscreen/edt-ft5x06.c
+++ b/drivers/input/touchscreen/edt-ft5x06.c
@@ -733,8 +733,7 @@ edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
733static void 733static void
734edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata) 734edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
735{ 735{
736 if (tsdata->debug_dir) 736 debugfs_remove_recursive(tsdata->debug_dir);
737 debugfs_remove_recursive(tsdata->debug_dir);
738 kfree(tsdata->raw_buffer); 737 kfree(tsdata->raw_buffer);
739} 738}
740 739
diff --git a/drivers/input/touchscreen/ipaq-micro-ts.c b/drivers/input/touchscreen/ipaq-micro-ts.c
new file mode 100644
index 000000000000..62c8976e616f
--- /dev/null
+++ b/drivers/input/touchscreen/ipaq-micro-ts.c
@@ -0,0 +1,166 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License version 2 as
4 * published by the Free Software Foundation.
5 *
6 * h3600 atmel micro companion support, touchscreen subdevice
7 * Author : Alessandro Gardich <gremlin@gremlin.it>
8 * Author : Dmitry Artamonow <mad_soft@inbox.ru>
9 * Author : Linus Walleij <linus.walleij@linaro.org>
10 *
11 */
12
13#include <asm/byteorder.h>
14#include <linux/module.h>
15#include <linux/init.h>
16#include <linux/interrupt.h>
17#include <linux/pm.h>
18#include <linux/delay.h>
19#include <linux/device.h>
20#include <linux/input.h>
21#include <linux/platform_device.h>
22#include <linux/slab.h>
23#include <linux/mfd/ipaq-micro.h>
24
25struct touchscreen_data {
26 struct input_dev *input;
27 struct ipaq_micro *micro;
28};
29
30static void micro_ts_receive(void *data, int len, unsigned char *msg)
31{
32 struct touchscreen_data *ts = data;
33
34 if (len == 4) {
35 input_report_abs(ts->input, ABS_X,
36 be16_to_cpup((__be16 *) &msg[2]));
37 input_report_abs(ts->input, ABS_Y,
38 be16_to_cpup((__be16 *) &msg[0]));
39 input_report_key(ts->input, BTN_TOUCH, 1);
40 input_sync(ts->input);
41 } else if (len == 0) {
42 input_report_abs(ts->input, ABS_X, 0);
43 input_report_abs(ts->input, ABS_Y, 0);
44 input_report_key(ts->input, BTN_TOUCH, 0);
45 input_sync(ts->input);
46 }
47}
48
49static void micro_ts_toggle_receive(struct touchscreen_data *ts, bool enable)
50{
51 struct ipaq_micro *micro = ts->micro;
52
53 spin_lock_irq(&micro->lock);
54
55 if (enable) {
56 micro->ts = micro_ts_receive;
57 micro->ts_data = ts;
58 } else {
59 micro->ts = NULL;
60 micro->ts_data = NULL;
61 }
62
63 spin_unlock_irq(&ts->micro->lock);
64}
65
66static int micro_ts_open(struct input_dev *input)
67{
68 struct touchscreen_data *ts = input_get_drvdata(input);
69
70 micro_ts_toggle_receive(ts, true);
71
72 return 0;
73}
74
75static void micro_ts_close(struct input_dev *input)
76{
77 struct touchscreen_data *ts = input_get_drvdata(input);
78
79 micro_ts_toggle_receive(ts, false);
80}
81
82static int micro_ts_probe(struct platform_device *pdev)
83{
84 struct ipaq_micro *micro = dev_get_drvdata(pdev->dev.parent);
85 struct touchscreen_data *ts;
86 int error;
87
88 ts = devm_kzalloc(&pdev->dev, sizeof(*ts), GFP_KERNEL);
89 if (!ts)
90 return -ENOMEM;
91
92 ts->micro = micro;
93
94 ts->input = devm_input_allocate_device(&pdev->dev);
95 if (!ts->input) {
96 dev_err(&pdev->dev, "failed to allocate input device\n");
97 return -ENOMEM;
98 }
99
100 ts->input->name = "ipaq micro ts";
101 ts->input->open = micro_ts_open;
102 ts->input->close = micro_ts_close;
103
104 input_set_drvdata(ts->input, ts);
105
106 input_set_capability(ts->input, EV_KEY, BTN_TOUCH);
107 input_set_capability(ts->input, EV_ABS, ABS_X);
108 input_set_capability(ts->input, EV_ABS, ABS_Y);
109 input_set_abs_params(ts->input, ABS_X, 0, 1023, 0, 0);
110 input_set_abs_params(ts->input, ABS_Y, 0, 1023, 0, 0);
111
112 error = input_register_device(ts->input);
113 if (error) {
114 dev_err(&pdev->dev, "error registering touch input\n");
115 return error;
116 }
117
118 platform_set_drvdata(pdev, ts);
119
120 dev_info(&pdev->dev, "iPAQ micro touchscreen\n");
121
122 return 0;
123}
124
125#ifdef CONFIG_PM_SLEEP
126static int micro_ts_suspend(struct device *dev)
127{
128 struct touchscreen_data *ts = dev_get_drvdata(dev);
129
130 micro_ts_toggle_receive(ts, false);
131
132 return 0;
133}
134
135static int micro_ts_resume(struct device *dev)
136{
137 struct touchscreen_data *ts = dev_get_drvdata(dev);
138 struct input_dev *input = ts->input;
139
140 mutex_lock(&input->mutex);
141
142 if (input->users)
143 micro_ts_toggle_receive(ts, true);
144
145 mutex_unlock(&input->mutex);
146
147 return 0;
148}
149#endif
150
151static const struct dev_pm_ops micro_ts_dev_pm_ops = {
152 SET_SYSTEM_SLEEP_PM_OPS(micro_ts_suspend, micro_ts_resume)
153};
154
155static struct platform_driver micro_ts_device_driver = {
156 .driver = {
157 .name = "ipaq-micro-ts",
158 .pm = &micro_ts_dev_pm_ops,
159 },
160 .probe = micro_ts_probe,
161};
162module_platform_driver(micro_ts_device_driver);
163
164MODULE_LICENSE("GPL");
165MODULE_DESCRIPTION("driver for iPAQ Atmel micro touchscreen");
166MODULE_ALIAS("platform:ipaq-micro-ts");
diff --git a/drivers/input/touchscreen/jornada720_ts.c b/drivers/input/touchscreen/jornada720_ts.c
index 7324c5c0fb86..651ec71a5c68 100644
--- a/drivers/input/touchscreen/jornada720_ts.c
+++ b/drivers/input/touchscreen/jornada720_ts.c
@@ -36,22 +36,21 @@ struct jornada_ts {
36 36
37static void jornada720_ts_collect_data(struct jornada_ts *jornada_ts) 37static void jornada720_ts_collect_data(struct jornada_ts *jornada_ts)
38{ 38{
39 /* 3 low word X samples */
40 jornada_ts->x_data[0] = jornada_ssp_byte(TXDUMMY);
41 jornada_ts->x_data[1] = jornada_ssp_byte(TXDUMMY);
42 jornada_ts->x_data[2] = jornada_ssp_byte(TXDUMMY);
39 43
40 /* 3 low word X samples */ 44 /* 3 low word Y samples */
41 jornada_ts->x_data[0] = jornada_ssp_byte(TXDUMMY); 45 jornada_ts->y_data[0] = jornada_ssp_byte(TXDUMMY);
42 jornada_ts->x_data[1] = jornada_ssp_byte(TXDUMMY); 46 jornada_ts->y_data[1] = jornada_ssp_byte(TXDUMMY);
43 jornada_ts->x_data[2] = jornada_ssp_byte(TXDUMMY); 47 jornada_ts->y_data[2] = jornada_ssp_byte(TXDUMMY);
44 48
45 /* 3 low word Y samples */ 49 /* combined x samples bits */
46 jornada_ts->y_data[0] = jornada_ssp_byte(TXDUMMY); 50 jornada_ts->x_data[3] = jornada_ssp_byte(TXDUMMY);
47 jornada_ts->y_data[1] = jornada_ssp_byte(TXDUMMY);
48 jornada_ts->y_data[2] = jornada_ssp_byte(TXDUMMY);
49 51
50 /* combined x samples bits */ 52 /* combined y samples bits */
51 jornada_ts->x_data[3] = jornada_ssp_byte(TXDUMMY); 53 jornada_ts->y_data[3] = jornada_ssp_byte(TXDUMMY);
52
53 /* combined y samples bits */
54 jornada_ts->y_data[3] = jornada_ssp_byte(TXDUMMY);
55} 54}
56 55
57static int jornada720_ts_average(int coords[4]) 56static int jornada720_ts_average(int coords[4])
@@ -104,13 +103,13 @@ static int jornada720_ts_probe(struct platform_device *pdev)
104 struct input_dev *input_dev; 103 struct input_dev *input_dev;
105 int error; 104 int error;
106 105
107 jornada_ts = kzalloc(sizeof(struct jornada_ts), GFP_KERNEL); 106 jornada_ts = devm_kzalloc(&pdev->dev, sizeof(*jornada_ts), GFP_KERNEL);
108 input_dev = input_allocate_device(); 107 if (!jornada_ts)
108 return -ENOMEM;
109 109
110 if (!jornada_ts || !input_dev) { 110 input_dev = devm_input_allocate_device(&pdev->dev);
111 error = -ENOMEM; 111 if (!input_dev)
112 goto fail1; 112 return -ENOMEM;
113 }
114 113
115 platform_set_drvdata(pdev, jornada_ts); 114 platform_set_drvdata(pdev, jornada_ts);
116 115
@@ -126,36 +125,18 @@ static int jornada720_ts_probe(struct platform_device *pdev)
126 input_set_abs_params(input_dev, ABS_X, 270, 3900, 0, 0); 125 input_set_abs_params(input_dev, ABS_X, 270, 3900, 0, 0);
127 input_set_abs_params(input_dev, ABS_Y, 180, 3700, 0, 0); 126 input_set_abs_params(input_dev, ABS_Y, 180, 3700, 0, 0);
128 127
129 error = request_irq(IRQ_GPIO9, 128 error = devm_request_irq(&pdev->dev, IRQ_GPIO9,
130 jornada720_ts_interrupt, 129 jornada720_ts_interrupt,
131 IRQF_TRIGGER_RISING, 130 IRQF_TRIGGER_RISING,
132 "HP7XX Touchscreen driver", pdev); 131 "HP7XX Touchscreen driver", pdev);
133 if (error) { 132 if (error) {
134 printk(KERN_INFO "HP7XX TS : Unable to acquire irq!\n"); 133 dev_err(&pdev->dev, "HP7XX TS : Unable to acquire irq!\n");
135 goto fail1; 134 return error;
136 } 135 }
137 136
138 error = input_register_device(jornada_ts->dev); 137 error = input_register_device(jornada_ts->dev);
139 if (error) 138 if (error)
140 goto fail2; 139 return error;
141
142 return 0;
143
144 fail2:
145 free_irq(IRQ_GPIO9, pdev);
146 fail1:
147 input_free_device(input_dev);
148 kfree(jornada_ts);
149 return error;
150}
151
152static int jornada720_ts_remove(struct platform_device *pdev)
153{
154 struct jornada_ts *jornada_ts = platform_get_drvdata(pdev);
155
156 free_irq(IRQ_GPIO9, pdev);
157 input_unregister_device(jornada_ts->dev);
158 kfree(jornada_ts);
159 140
160 return 0; 141 return 0;
161} 142}
@@ -165,7 +146,6 @@ MODULE_ALIAS("platform:jornada_ts");
165 146
166static struct platform_driver jornada720_ts_driver = { 147static struct platform_driver jornada720_ts_driver = {
167 .probe = jornada720_ts_probe, 148 .probe = jornada720_ts_probe,
168 .remove = jornada720_ts_remove,
169 .driver = { 149 .driver = {
170 .name = "jornada_ts", 150 .name = "jornada_ts",
171 .owner = THIS_MODULE, 151 .owner = THIS_MODULE,
diff --git a/drivers/input/touchscreen/mcs5000_ts.c b/drivers/input/touchscreen/mcs5000_ts.c
index 00510a9836b3..8b47e1fecb25 100644
--- a/drivers/input/touchscreen/mcs5000_ts.c
+++ b/drivers/input/touchscreen/mcs5000_ts.c
@@ -248,8 +248,7 @@ static int mcs5000_ts_probe(struct i2c_client *client,
248 return 0; 248 return 0;
249} 249}
250 250
251#ifdef CONFIG_PM 251static int __maybe_unused mcs5000_ts_suspend(struct device *dev)
252static int mcs5000_ts_suspend(struct device *dev)
253{ 252{
254 struct i2c_client *client = to_i2c_client(dev); 253 struct i2c_client *client = to_i2c_client(dev);
255 254
@@ -259,7 +258,7 @@ static int mcs5000_ts_suspend(struct device *dev)
259 return 0; 258 return 0;
260} 259}
261 260
262static int mcs5000_ts_resume(struct device *dev) 261static int __maybe_unused mcs5000_ts_resume(struct device *dev)
263{ 262{
264 struct i2c_client *client = to_i2c_client(dev); 263 struct i2c_client *client = to_i2c_client(dev);
265 struct mcs5000_ts_data *data = i2c_get_clientdata(client); 264 struct mcs5000_ts_data *data = i2c_get_clientdata(client);
@@ -269,7 +268,6 @@ static int mcs5000_ts_resume(struct device *dev)
269 268
270 return 0; 269 return 0;
271} 270}
272#endif
273 271
274static SIMPLE_DEV_PM_OPS(mcs5000_ts_pm, mcs5000_ts_suspend, mcs5000_ts_resume); 272static SIMPLE_DEV_PM_OPS(mcs5000_ts_pm, mcs5000_ts_suspend, mcs5000_ts_resume);
275 273
diff --git a/drivers/input/touchscreen/pixcir_i2c_ts.c b/drivers/input/touchscreen/pixcir_i2c_ts.c
index 19c6c0fdc94b..fc49c75317d1 100644
--- a/drivers/input/touchscreen/pixcir_i2c_ts.c
+++ b/drivers/input/touchscreen/pixcir_i2c_ts.c
@@ -23,22 +23,51 @@
23#include <linux/slab.h> 23#include <linux/slab.h>
24#include <linux/i2c.h> 24#include <linux/i2c.h>
25#include <linux/input.h> 25#include <linux/input.h>
26#include <linux/input/mt.h>
26#include <linux/input/pixcir_ts.h> 27#include <linux/input/pixcir_ts.h>
27#include <linux/gpio.h> 28#include <linux/gpio.h>
29#include <linux/of.h>
30#include <linux/of_gpio.h>
31#include <linux/of_device.h>
32
33#define PIXCIR_MAX_SLOTS 5 /* Max fingers supported by driver */
28 34
29struct pixcir_i2c_ts_data { 35struct pixcir_i2c_ts_data {
30 struct i2c_client *client; 36 struct i2c_client *client;
31 struct input_dev *input; 37 struct input_dev *input;
32 const struct pixcir_ts_platform_data *chip; 38 const struct pixcir_ts_platform_data *pdata;
33 bool running; 39 bool running;
40 int max_fingers; /* Max fingers supported in this instance */
41};
42
43struct pixcir_touch {
44 int x;
45 int y;
46 int id;
47};
48
49struct pixcir_report_data {
50 int num_touches;
51 struct pixcir_touch touches[PIXCIR_MAX_SLOTS];
34}; 52};
35 53
36static void pixcir_ts_poscheck(struct pixcir_i2c_ts_data *data) 54static void pixcir_ts_parse(struct pixcir_i2c_ts_data *tsdata,
55 struct pixcir_report_data *report)
37{ 56{
38 struct pixcir_i2c_ts_data *tsdata = data; 57 u8 rdbuf[2 + PIXCIR_MAX_SLOTS * 5];
39 u8 rdbuf[10], wrbuf[1] = { 0 }; 58 u8 wrbuf[1] = { 0 };
59 u8 *bufptr;
40 u8 touch; 60 u8 touch;
41 int ret; 61 int ret, i;
62 int readsize;
63 const struct pixcir_i2c_chip_data *chip = &tsdata->pdata->chip;
64
65 memset(report, 0, sizeof(struct pixcir_report_data));
66
67 i = chip->has_hw_ids ? 1 : 0;
68 readsize = 2 + tsdata->max_fingers * (4 + i);
69 if (readsize > sizeof(rdbuf))
70 readsize = sizeof(rdbuf);
42 71
43 ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf)); 72 ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf));
44 if (ret != sizeof(wrbuf)) { 73 if (ret != sizeof(wrbuf)) {
@@ -48,7 +77,7 @@ static void pixcir_ts_poscheck(struct pixcir_i2c_ts_data *data)
48 return; 77 return;
49 } 78 }
50 79
51 ret = i2c_master_recv(tsdata->client, rdbuf, sizeof(rdbuf)); 80 ret = i2c_master_recv(tsdata->client, rdbuf, readsize);
52 if (ret != sizeof(rdbuf)) { 81 if (ret != sizeof(rdbuf)) {
53 dev_err(&tsdata->client->dev, 82 dev_err(&tsdata->client->dev,
54 "%s: i2c_master_recv failed(), ret=%d\n", 83 "%s: i2c_master_recv failed(), ret=%d\n",
@@ -56,45 +85,103 @@ static void pixcir_ts_poscheck(struct pixcir_i2c_ts_data *data)
56 return; 85 return;
57 } 86 }
58 87
59 touch = rdbuf[0]; 88 touch = rdbuf[0] & 0x7;
60 if (touch) { 89 if (touch > tsdata->max_fingers)
61 u16 posx1 = (rdbuf[3] << 8) | rdbuf[2]; 90 touch = tsdata->max_fingers;
62 u16 posy1 = (rdbuf[5] << 8) | rdbuf[4]; 91
63 u16 posx2 = (rdbuf[7] << 8) | rdbuf[6]; 92 report->num_touches = touch;
64 u16 posy2 = (rdbuf[9] << 8) | rdbuf[8]; 93 bufptr = &rdbuf[2];
65 94
66 input_report_key(tsdata->input, BTN_TOUCH, 1); 95 for (i = 0; i < touch; i++) {
67 input_report_abs(tsdata->input, ABS_X, posx1); 96 report->touches[i].x = (bufptr[1] << 8) | bufptr[0];
68 input_report_abs(tsdata->input, ABS_Y, posy1); 97 report->touches[i].y = (bufptr[3] << 8) | bufptr[2];
69 98
70 input_report_abs(tsdata->input, ABS_MT_POSITION_X, posx1); 99 if (chip->has_hw_ids) {
71 input_report_abs(tsdata->input, ABS_MT_POSITION_Y, posy1); 100 report->touches[i].id = bufptr[4];
72 input_mt_sync(tsdata->input); 101 bufptr = bufptr + 5;
73 102 } else {
74 if (touch == 2) { 103 bufptr = bufptr + 4;
75 input_report_abs(tsdata->input, 104 }
76 ABS_MT_POSITION_X, posx2); 105 }
77 input_report_abs(tsdata->input, 106}
78 ABS_MT_POSITION_Y, posy2); 107
79 input_mt_sync(tsdata->input); 108static void pixcir_ts_report(struct pixcir_i2c_ts_data *ts,
109 struct pixcir_report_data *report)
110{
111 struct input_mt_pos pos[PIXCIR_MAX_SLOTS];
112 int slots[PIXCIR_MAX_SLOTS];
113 struct pixcir_touch *touch;
114 int n, i, slot;
115 struct device *dev = &ts->client->dev;
116 const struct pixcir_i2c_chip_data *chip = &ts->pdata->chip;
117
118 n = report->num_touches;
119 if (n > PIXCIR_MAX_SLOTS)
120 n = PIXCIR_MAX_SLOTS;
121
122 if (!chip->has_hw_ids) {
123 for (i = 0; i < n; i++) {
124 touch = &report->touches[i];
125 pos[i].x = touch->x;
126 pos[i].y = touch->y;
127 }
128
129 input_mt_assign_slots(ts->input, slots, pos, n);
130 }
131
132 for (i = 0; i < n; i++) {
133 touch = &report->touches[i];
134
135 if (chip->has_hw_ids) {
136 slot = input_mt_get_slot_by_key(ts->input, touch->id);
137 if (slot < 0) {
138 dev_dbg(dev, "no free slot for id 0x%x\n",
139 touch->id);
140 continue;
141 }
142 } else {
143 slot = slots[i];
80 } 144 }
81 } else { 145
82 input_report_key(tsdata->input, BTN_TOUCH, 0); 146 input_mt_slot(ts->input, slot);
147 input_mt_report_slot_state(ts->input,
148 MT_TOOL_FINGER, true);
149
150 input_event(ts->input, EV_ABS, ABS_MT_POSITION_X, touch->x);
151 input_event(ts->input, EV_ABS, ABS_MT_POSITION_Y, touch->y);
152
153 dev_dbg(dev, "%d: slot %d, x %d, y %d\n",
154 i, slot, touch->x, touch->y);
83 } 155 }
84 156
85 input_sync(tsdata->input); 157 input_mt_sync_frame(ts->input);
158 input_sync(ts->input);
86} 159}
87 160
88static irqreturn_t pixcir_ts_isr(int irq, void *dev_id) 161static irqreturn_t pixcir_ts_isr(int irq, void *dev_id)
89{ 162{
90 struct pixcir_i2c_ts_data *tsdata = dev_id; 163 struct pixcir_i2c_ts_data *tsdata = dev_id;
91 const struct pixcir_ts_platform_data *pdata = tsdata->chip; 164 const struct pixcir_ts_platform_data *pdata = tsdata->pdata;
165 struct pixcir_report_data report;
92 166
93 while (tsdata->running) { 167 while (tsdata->running) {
94 pixcir_ts_poscheck(tsdata); 168 /* parse packet */
95 169 pixcir_ts_parse(tsdata, &report);
96 if (gpio_get_value(pdata->gpio_attb)) 170
171 /* report it */
172 pixcir_ts_report(tsdata, &report);
173
174 if (gpio_get_value(pdata->gpio_attb)) {
175 if (report.num_touches) {
176 /*
177 * Last report with no finger up?
178 * Do it now then.
179 */
180 input_mt_sync_frame(tsdata->input);
181 input_sync(tsdata->input);
182 }
97 break; 183 break;
184 }
98 185
99 msleep(20); 186 msleep(20);
100 } 187 }
@@ -323,16 +410,69 @@ unlock:
323static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops, 410static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops,
324 pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume); 411 pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume);
325 412
413#ifdef CONFIG_OF
414static const struct of_device_id pixcir_of_match[];
415
416static struct pixcir_ts_platform_data *pixcir_parse_dt(struct device *dev)
417{
418 struct pixcir_ts_platform_data *pdata;
419 struct device_node *np = dev->of_node;
420 const struct of_device_id *match;
421
422 match = of_match_device(of_match_ptr(pixcir_of_match), dev);
423 if (!match)
424 return ERR_PTR(-EINVAL);
425
426 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
427 if (!pdata)
428 return ERR_PTR(-ENOMEM);
429
430 pdata->chip = *(const struct pixcir_i2c_chip_data *)match->data;
431
432 pdata->gpio_attb = of_get_named_gpio(np, "attb-gpio", 0);
433 /* gpio_attb validity is checked in probe */
434
435 if (of_property_read_u32(np, "touchscreen-size-x", &pdata->x_max)) {
436 dev_err(dev, "Failed to get touchscreen-size-x property\n");
437 return ERR_PTR(-EINVAL);
438 }
439 pdata->x_max -= 1;
440
441 if (of_property_read_u32(np, "touchscreen-size-y", &pdata->y_max)) {
442 dev_err(dev, "Failed to get touchscreen-size-y property\n");
443 return ERR_PTR(-EINVAL);
444 }
445 pdata->y_max -= 1;
446
447 dev_dbg(dev, "%s: x %d, y %d, gpio %d\n", __func__,
448 pdata->x_max + 1, pdata->y_max + 1, pdata->gpio_attb);
449
450 return pdata;
451}
452#else
453static struct pixcir_ts_platform_data *pixcir_parse_dt(struct device *dev)
454{
455 return ERR_PTR(-EINVAL);
456}
457#endif
458
326static int pixcir_i2c_ts_probe(struct i2c_client *client, 459static int pixcir_i2c_ts_probe(struct i2c_client *client,
327 const struct i2c_device_id *id) 460 const struct i2c_device_id *id)
328{ 461{
329 const struct pixcir_ts_platform_data *pdata = 462 const struct pixcir_ts_platform_data *pdata =
330 dev_get_platdata(&client->dev); 463 dev_get_platdata(&client->dev);
331 struct device *dev = &client->dev; 464 struct device *dev = &client->dev;
465 struct device_node *np = dev->of_node;
332 struct pixcir_i2c_ts_data *tsdata; 466 struct pixcir_i2c_ts_data *tsdata;
333 struct input_dev *input; 467 struct input_dev *input;
334 int error; 468 int error;
335 469
470 if (np && !pdata) {
471 pdata = pixcir_parse_dt(dev);
472 if (IS_ERR(pdata))
473 return PTR_ERR(pdata);
474 }
475
336 if (!pdata) { 476 if (!pdata) {
337 dev_err(&client->dev, "platform data not defined\n"); 477 dev_err(&client->dev, "platform data not defined\n");
338 return -EINVAL; 478 return -EINVAL;
@@ -343,6 +483,11 @@ static int pixcir_i2c_ts_probe(struct i2c_client *client,
343 return -EINVAL; 483 return -EINVAL;
344 } 484 }
345 485
486 if (!pdata->chip.max_fingers) {
487 dev_err(dev, "Invalid max_fingers in pdata\n");
488 return -EINVAL;
489 }
490
346 tsdata = devm_kzalloc(dev, sizeof(*tsdata), GFP_KERNEL); 491 tsdata = devm_kzalloc(dev, sizeof(*tsdata), GFP_KERNEL);
347 if (!tsdata) 492 if (!tsdata)
348 return -ENOMEM; 493 return -ENOMEM;
@@ -355,7 +500,7 @@ static int pixcir_i2c_ts_probe(struct i2c_client *client,
355 500
356 tsdata->client = client; 501 tsdata->client = client;
357 tsdata->input = input; 502 tsdata->input = input;
358 tsdata->chip = pdata; 503 tsdata->pdata = pdata;
359 504
360 input->name = client->name; 505 input->name = client->name;
361 input->id.bustype = BUS_I2C; 506 input->id.bustype = BUS_I2C;
@@ -371,6 +516,20 @@ static int pixcir_i2c_ts_probe(struct i2c_client *client,
371 input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0); 516 input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0);
372 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0); 517 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0);
373 518
519 tsdata->max_fingers = tsdata->pdata->chip.max_fingers;
520 if (tsdata->max_fingers > PIXCIR_MAX_SLOTS) {
521 tsdata->max_fingers = PIXCIR_MAX_SLOTS;
522 dev_info(dev, "Limiting maximum fingers to %d\n",
523 tsdata->max_fingers);
524 }
525
526 error = input_mt_init_slots(input, tsdata->max_fingers,
527 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
528 if (error) {
529 dev_err(dev, "Error initializing Multi-Touch slots\n");
530 return error;
531 }
532
374 input_set_drvdata(input, tsdata); 533 input_set_drvdata(input, tsdata);
375 534
376 error = devm_gpio_request_one(dev, pdata->gpio_attb, 535 error = devm_gpio_request_one(dev, pdata->gpio_attb,
@@ -419,15 +578,36 @@ static int pixcir_i2c_ts_remove(struct i2c_client *client)
419 578
420static const struct i2c_device_id pixcir_i2c_ts_id[] = { 579static const struct i2c_device_id pixcir_i2c_ts_id[] = {
421 { "pixcir_ts", 0 }, 580 { "pixcir_ts", 0 },
581 { "pixcir_tangoc", 0 },
422 { } 582 { }
423}; 583};
424MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id); 584MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id);
425 585
586#ifdef CONFIG_OF
587static const struct pixcir_i2c_chip_data pixcir_ts_data = {
588 .max_fingers = 2,
589 /* no hw id support */
590};
591
592static const struct pixcir_i2c_chip_data pixcir_tangoc_data = {
593 .max_fingers = 5,
594 .has_hw_ids = true,
595};
596
597static const struct of_device_id pixcir_of_match[] = {
598 { .compatible = "pixcir,pixcir_ts", .data = &pixcir_ts_data },
599 { .compatible = "pixcir,pixcir_tangoc", .data = &pixcir_tangoc_data },
600 { }
601};
602MODULE_DEVICE_TABLE(of, pixcir_of_match);
603#endif
604
426static struct i2c_driver pixcir_i2c_ts_driver = { 605static struct i2c_driver pixcir_i2c_ts_driver = {
427 .driver = { 606 .driver = {
428 .owner = THIS_MODULE, 607 .owner = THIS_MODULE,
429 .name = "pixcir_ts", 608 .name = "pixcir_ts",
430 .pm = &pixcir_dev_pm_ops, 609 .pm = &pixcir_dev_pm_ops,
610 .of_match_table = of_match_ptr(pixcir_of_match),
431 }, 611 },
432 .probe = pixcir_i2c_ts_probe, 612 .probe = pixcir_i2c_ts_probe,
433 .remove = pixcir_i2c_ts_remove, 613 .remove = pixcir_i2c_ts_remove,
diff --git a/drivers/input/touchscreen/s3c2410_ts.c b/drivers/input/touchscreen/s3c2410_ts.c
index 19cb247dbb86..5a69ded9b53c 100644
--- a/drivers/input/touchscreen/s3c2410_ts.c
+++ b/drivers/input/touchscreen/s3c2410_ts.c
@@ -264,7 +264,7 @@ static int s3c2410ts_probe(struct platform_device *pdev)
264 return -ENOENT; 264 return -ENOENT;
265 } 265 }
266 266
267 clk_enable(ts.clock); 267 clk_prepare_enable(ts.clock);
268 dev_dbg(dev, "got and enabled clocks\n"); 268 dev_dbg(dev, "got and enabled clocks\n");
269 269
270 ts.irq_tc = ret = platform_get_irq(pdev, 0); 270 ts.irq_tc = ret = platform_get_irq(pdev, 0);
@@ -369,7 +369,7 @@ static int s3c2410ts_remove(struct platform_device *pdev)
369 free_irq(ts.irq_tc, ts.input); 369 free_irq(ts.irq_tc, ts.input);
370 del_timer_sync(&touch_timer); 370 del_timer_sync(&touch_timer);
371 371
372 clk_disable(ts.clock); 372 clk_disable_unprepare(ts.clock);
373 clk_put(ts.clock); 373 clk_put(ts.clock);
374 374
375 input_unregister_device(ts.input); 375 input_unregister_device(ts.input);
diff --git a/drivers/input/touchscreen/zforce_ts.c b/drivers/input/touchscreen/zforce_ts.c
index feea85b52fa8..8ba48f5eff7b 100644
--- a/drivers/input/touchscreen/zforce_ts.c
+++ b/drivers/input/touchscreen/zforce_ts.c
@@ -29,6 +29,8 @@
29#include <linux/sysfs.h> 29#include <linux/sysfs.h>
30#include <linux/input/mt.h> 30#include <linux/input/mt.h>
31#include <linux/platform_data/zforce_ts.h> 31#include <linux/platform_data/zforce_ts.h>
32#include <linux/regulator/consumer.h>
33#include <linux/delay.h>
32#include <linux/of.h> 34#include <linux/of.h>
33#include <linux/of_gpio.h> 35#include <linux/of_gpio.h>
34 36
@@ -117,6 +119,8 @@ struct zforce_ts {
117 const struct zforce_ts_platdata *pdata; 119 const struct zforce_ts_platdata *pdata;
118 char phys[32]; 120 char phys[32];
119 121
122 struct regulator *reg_vdd;
123
120 bool suspending; 124 bool suspending;
121 bool suspended; 125 bool suspended;
122 bool boot_complete; 126 bool boot_complete;
@@ -690,6 +694,11 @@ static void zforce_reset(void *data)
690 struct zforce_ts *ts = data; 694 struct zforce_ts *ts = data;
691 695
692 gpio_set_value(ts->pdata->gpio_rst, 0); 696 gpio_set_value(ts->pdata->gpio_rst, 0);
697
698 udelay(10);
699
700 if (!IS_ERR(ts->reg_vdd))
701 regulator_disable(ts->reg_vdd);
693} 702}
694 703
695static struct zforce_ts_platdata *zforce_parse_dt(struct device *dev) 704static struct zforce_ts_platdata *zforce_parse_dt(struct device *dev)
@@ -765,10 +774,32 @@ static int zforce_probe(struct i2c_client *client,
765 return ret; 774 return ret;
766 } 775 }
767 776
777 ts->reg_vdd = devm_regulator_get_optional(&client->dev, "vdd");
778 if (IS_ERR(ts->reg_vdd)) {
779 ret = PTR_ERR(ts->reg_vdd);
780 if (ret == -EPROBE_DEFER)
781 return ret;
782 } else {
783 ret = regulator_enable(ts->reg_vdd);
784 if (ret)
785 return ret;
786
787 /*
788 * according to datasheet add 100us grace time after regular
789 * regulator enable delay.
790 */
791 udelay(100);
792 }
793
768 ret = devm_add_action(&client->dev, zforce_reset, ts); 794 ret = devm_add_action(&client->dev, zforce_reset, ts);
769 if (ret) { 795 if (ret) {
770 dev_err(&client->dev, "failed to register reset action, %d\n", 796 dev_err(&client->dev, "failed to register reset action, %d\n",
771 ret); 797 ret);
798
799 /* hereafter the regulator will be disabled by the action */
800 if (!IS_ERR(ts->reg_vdd))
801 regulator_disable(ts->reg_vdd);
802
772 return ret; 803 return ret;
773 } 804 }
774 805
diff --git a/drivers/platform/chrome/chromeos_laptop.c b/drivers/platform/chrome/chromeos_laptop.c
index 7f1a2e2711bd..67b316b2a2bd 100644
--- a/drivers/platform/chrome/chromeos_laptop.c
+++ b/drivers/platform/chrome/chromeos_laptop.c
@@ -97,8 +97,6 @@ static struct mxt_platform_data atmel_224s_tp_platform_data = {
97 .irqflags = IRQF_TRIGGER_FALLING, 97 .irqflags = IRQF_TRIGGER_FALLING,
98 .t19_num_keys = ARRAY_SIZE(mxt_t19_keys), 98 .t19_num_keys = ARRAY_SIZE(mxt_t19_keys),
99 .t19_keymap = mxt_t19_keys, 99 .t19_keymap = mxt_t19_keys,
100 .config = NULL,
101 .config_length = 0,
102}; 100};
103 101
104static struct i2c_board_info atmel_224s_tp_device = { 102static struct i2c_board_info atmel_224s_tp_device = {
@@ -109,8 +107,6 @@ static struct i2c_board_info atmel_224s_tp_device = {
109 107
110static struct mxt_platform_data atmel_1664s_platform_data = { 108static struct mxt_platform_data atmel_1664s_platform_data = {
111 .irqflags = IRQF_TRIGGER_FALLING, 109 .irqflags = IRQF_TRIGGER_FALLING,
112 .config = NULL,
113 .config_length = 0,
114}; 110};
115 111
116static struct i2c_board_info atmel_1664s_device = { 112static struct i2c_board_info atmel_1664s_device = {
diff --git a/include/linux/hid.h b/include/linux/hid.h
index fca74f1d5c84..f53c4a9cca1d 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -312,6 +312,11 @@ struct hid_item {
312#define HID_GROUP_RMI 0x0100 312#define HID_GROUP_RMI 0x0100
313 313
314/* 314/*
315 * Vendor specific HID device groups
316 */
317#define HID_GROUP_WACOM 0x0101
318
319/*
315 * This is the global environment of the parser. This information is 320 * This is the global environment of the parser. This information is
316 * persistent for main-items. The global environment can be saved and 321 * persistent for main-items. The global environment can be saved and
317 * restored with PUSH/POP statements. 322 * restored with PUSH/POP statements.
diff --git a/include/linux/i2c/atmel_mxt_ts.h b/include/linux/i2c/atmel_mxt_ts.h
index 3891dc1de21c..02bf6ea31701 100644
--- a/include/linux/i2c/atmel_mxt_ts.h
+++ b/include/linux/i2c/atmel_mxt_ts.h
@@ -17,9 +17,6 @@
17 17
18/* The platform data for the Atmel maXTouch touchscreen driver */ 18/* The platform data for the Atmel maXTouch touchscreen driver */
19struct mxt_platform_data { 19struct mxt_platform_data {
20 const u8 *config;
21 size_t config_length;
22 u32 config_crc;
23 unsigned long irqflags; 20 unsigned long irqflags;
24 u8 t19_num_keys; 21 u8 t19_num_keys;
25 const unsigned int *t19_keymap; 22 const unsigned int *t19_keymap;
diff --git a/include/linux/input/pixcir_ts.h b/include/linux/input/pixcir_ts.h
index 160cf353aa39..7bae83b7c396 100644
--- a/include/linux/input/pixcir_ts.h
+++ b/include/linux/input/pixcir_ts.h
@@ -43,10 +43,22 @@ enum pixcir_int_mode {
43#define PIXCIR_INT_ENABLE (1UL << 3) 43#define PIXCIR_INT_ENABLE (1UL << 3)
44#define PIXCIR_INT_POL_HIGH (1UL << 2) 44#define PIXCIR_INT_POL_HIGH (1UL << 2)
45 45
46/**
47 * struct pixcir_irc_chip_data - chip related data
48 * @max_fingers: Max number of fingers reported simultaneously by h/w
49 * @has_hw_ids: Hardware supports finger tracking IDs
50 *
51 */
52struct pixcir_i2c_chip_data {
53 u8 max_fingers;
54 bool has_hw_ids;
55};
56
46struct pixcir_ts_platform_data { 57struct pixcir_ts_platform_data {
47 int x_max; 58 int x_max;
48 int y_max; 59 int y_max;
49 int gpio_attb; /* GPIO connected to ATTB line */ 60 int gpio_attb; /* GPIO connected to ATTB line */
61 struct pixcir_i2c_chip_data chip;
50}; 62};
51 63
52#endif 64#endif
diff --git a/include/uapi/linux/serio.h b/include/uapi/linux/serio.h
index 9f53fa7fc132..becdd78295cc 100644
--- a/include/uapi/linux/serio.h
+++ b/include/uapi/linux/serio.h
@@ -76,5 +76,6 @@
76#define SERIO_HAMPSHIRE 0x3b 76#define SERIO_HAMPSHIRE 0x3b
77#define SERIO_PS2MULT 0x3c 77#define SERIO_PS2MULT 0x3c
78#define SERIO_TSC40 0x3d 78#define SERIO_TSC40 0x3d
79#define SERIO_WACOM_IV 0x3e
79 80
80#endif /* _UAPI_SERIO_H */ 81#endif /* _UAPI_SERIO_H */
diff --git a/include/uapi/linux/uinput.h b/include/uapi/linux/uinput.h
index 0389b489bbba..baeab83deb64 100644
--- a/include/uapi/linux/uinput.h
+++ b/include/uapi/linux/uinput.h
@@ -84,6 +84,15 @@ struct uinput_ff_erase {
84 */ 84 */
85#define UI_GET_SYSNAME(len) _IOC(_IOC_READ, UINPUT_IOCTL_BASE, 300, len) 85#define UI_GET_SYSNAME(len) _IOC(_IOC_READ, UINPUT_IOCTL_BASE, 300, len)
86 86
87/**
88 * UI_GET_VERSION - Return version of uinput protocol
89 *
90 * This writes uinput protocol version implemented by the kernel into
91 * the integer pointed to by the ioctl argument. The protocol version
92 * is hard-coded in the kernel and is independent of the uinput device.
93 */
94#define UI_GET_VERSION _IOR(UINPUT_IOCTL_BASE, 301, unsigned int)
95
87/* 96/*
88 * To write a force-feedback-capable driver, the upload_effect 97 * To write a force-feedback-capable driver, the upload_effect
89 * and erase_effect callbacks in input_dev must be implemented. 98 * and erase_effect callbacks in input_dev must be implemented.
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-01 06:30:15 -0400