aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/ABI/testing/sysfs-driver-hid-logitech-lg4ff7
-rw-r--r--MAINTAINERS6
-rw-r--r--drivers/hid/Kconfig42
-rw-r--r--drivers/hid/Makefile4
-rw-r--r--drivers/hid/hid-apple.c15
-rw-r--r--drivers/hid/hid-axff.c36
-rw-r--r--drivers/hid/hid-core.c79
-rw-r--r--drivers/hid/hid-debug.c5
-rw-r--r--drivers/hid/hid-ids.h21
-rw-r--r--drivers/hid/hid-input.c11
-rw-r--r--drivers/hid/hid-lg.c29
-rw-r--r--drivers/hid/hid-lg.h4
-rw-r--r--drivers/hid/hid-lg4ff.c403
-rw-r--r--drivers/hid/hid-lgff.c13
-rw-r--r--drivers/hid/hid-logitech-dj.c922
-rw-r--r--drivers/hid/hid-logitech-dj.h123
-rw-r--r--drivers/hid/hid-magicmouse.c7
-rw-r--r--drivers/hid/hid-multitouch.c93
-rw-r--r--drivers/hid/hid-primax.c117
-rw-r--r--drivers/hid/hid-prodikeys.c8
-rw-r--r--drivers/hid/hid-roccat-kone.c63
-rw-r--r--drivers/hid/hid-roccat-kovaplus.c17
-rw-r--r--drivers/hid/hid-roccat-pyra.c23
-rw-r--r--drivers/hid/hid-sjoy.c75
-rw-r--r--drivers/hid/hid-wacom.c81
-rw-r--r--drivers/hid/hid-wiimote.c800
-rw-r--r--drivers/hid/hid-zydacron.c4
-rw-r--r--drivers/hid/hidraw.c11
-rw-r--r--drivers/hid/usbhid/hid-core.c2
-rw-r--r--drivers/hid/usbhid/hid-quirks.c2
-rw-r--r--drivers/hid/usbhid/hiddev.c2
-rw-r--r--include/linux/hid.h3
32 files changed, 2804 insertions, 224 deletions
diff --git a/Documentation/ABI/testing/sysfs-driver-hid-logitech-lg4ff b/Documentation/ABI/testing/sysfs-driver-hid-logitech-lg4ff
new file mode 100644
index 000000000000..9aec8ef228b0
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-driver-hid-logitech-lg4ff
@@ -0,0 +1,7 @@
1What: /sys/module/hid_logitech/drivers/hid:logitech/<dev>/range.
2Date: July 2011
3KernelVersion: 3.2
4Contact: Michal Malý <madcatxster@gmail.com>
5Description: Display minimum, maximum and current range of the steering
6 wheel. Writing a value within min and max boundaries sets the
7 range of the wheel.
diff --git a/MAINTAINERS b/MAINTAINERS
index 51a8160dc549..914b8bd318ce 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -7147,6 +7147,12 @@ L: linux-scsi@vger.kernel.org
7147S: Maintained 7147S: Maintained
7148F: drivers/scsi/wd7000.c 7148F: drivers/scsi/wd7000.c
7149 7149
7150WIIMOTE HID DRIVER
7151M: David Herrmann <dh.herrmann@googlemail.com>
7152L: linux-input@vger.kernel.org
7153S: Maintained
7154F: drivers/hid/hid-wiimote*
7155
7150WINBOND CIR DRIVER 7156WINBOND CIR DRIVER
7151M: David Härdeman <david@hardeman.nu> 7157M: David Härdeman <david@hardeman.nu>
7152S: Maintained 7158S: Maintained
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 1130a8987125..22a4a051f221 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -69,7 +69,7 @@ config HID_ACRUX
69 Say Y here if you want to enable support for ACRUX game controllers. 69 Say Y here if you want to enable support for ACRUX game controllers.
70 70
71config HID_ACRUX_FF 71config HID_ACRUX_FF
72 tristate "ACRUX force feedback support" 72 bool "ACRUX force feedback support"
73 depends on HID_ACRUX 73 depends on HID_ACRUX
74 select INPUT_FF_MEMLESS 74 select INPUT_FF_MEMLESS
75 ---help--- 75 ---help---
@@ -245,6 +245,15 @@ config HID_LOGITECH
245 ---help--- 245 ---help---
246 Support for Logitech devices that are not fully compliant with HID standard. 246 Support for Logitech devices that are not fully compliant with HID standard.
247 247
248config HID_LOGITECH_DJ
249 tristate "Logitech Unifying receivers full support"
250 depends on HID_LOGITECH
251 default m
252 ---help---
253 Say Y if you want support for Logitech Unifying receivers and devices.
254 Unifying receivers are capable of pairing up to 6 Logitech compliant
255 devices to the same receiver.
256
248config LOGITECH_FF 257config LOGITECH_FF
249 bool "Logitech force feedback support" 258 bool "Logitech force feedback support"
250 depends on HID_LOGITECH 259 depends on HID_LOGITECH
@@ -278,13 +287,21 @@ config LOGIG940_FF
278 Say Y here if you want to enable force feedback support for Logitech 287 Say Y here if you want to enable force feedback support for Logitech
279 Flight System G940 devices. 288 Flight System G940 devices.
280 289
281config LOGIWII_FF 290config LOGIWHEELS_FF
282 bool "Logitech Speed Force Wireless force feedback support" 291 bool "Logitech wheels configuration and force feedback support"
283 depends on HID_LOGITECH 292 depends on HID_LOGITECH
284 select INPUT_FF_MEMLESS 293 select INPUT_FF_MEMLESS
294 default LOGITECH_FF
285 help 295 help
286 Say Y here if you want to enable force feedback support for Logitech 296 Say Y here if you want to enable force feedback and range setting
287 Speed Force Wireless (Wii) devices. 297 support for following Logitech wheels:
298 - Logitech Driving Force
299 - Logitech Driving Force Pro
300 - Logitech Driving Force GT
301 - Logitech G25
302 - Logitech G27
303 - Logitech MOMO/MOMO 2
304 - Logitech Formula Force EX
288 305
289config HID_MAGICMOUSE 306config HID_MAGICMOUSE
290 tristate "Apple MagicMouse multi-touch support" 307 tristate "Apple MagicMouse multi-touch support"
@@ -328,6 +345,7 @@ config HID_MULTITOUCH
328 - Hanvon dual touch panels 345 - Hanvon dual touch panels
329 - Ilitek dual touch panels 346 - Ilitek dual touch panels
330 - IrTouch Infrared USB panels 347 - IrTouch Infrared USB panels
348 - LG Display panels (Dell ST2220Tc)
331 - Lumio CrystalTouch panels 349 - Lumio CrystalTouch panels
332 - MosArt dual-touch panels 350 - MosArt dual-touch panels
333 - PenMount dual touch panels 351 - PenMount dual touch panels
@@ -441,6 +459,13 @@ config HID_PICOLCD_LEDS
441 ---help--- 459 ---help---
442 Provide access to PicoLCD's GPO pins via leds class. 460 Provide access to PicoLCD's GPO pins via leds class.
443 461
462config HID_PRIMAX
463 tristate "Primax non-fully HID-compliant devices"
464 depends on USB_HID
465 ---help---
466 Support for Primax devices that are not fully compliant with the
467 HID standard.
468
444config HID_QUANTA 469config HID_QUANTA
445 tristate "Quanta Optical Touch panels" 470 tristate "Quanta Optical Touch panels"
446 depends on USB_HID 471 depends on USB_HID
@@ -539,7 +564,11 @@ config HID_SMARTJOYPLUS
539 tristate "SmartJoy PLUS PS2/USB adapter support" 564 tristate "SmartJoy PLUS PS2/USB adapter support"
540 depends on USB_HID 565 depends on USB_HID
541 ---help--- 566 ---help---
542 Support for SmartJoy PLUS PS2/USB adapter. 567 Support for SmartJoy PLUS PS2/USB adapter, Super Dual Box,
568 Super Joy Box 3 Pro, Super Dual Box Pro, and Super Joy Box 5 Pro.
569
570 Note that DDR (Dance Dance Revolution) mode is not supported, nor
571 is pressure sensitive buttons on the pro models.
543 572
544config SMARTJOYPLUS_FF 573config SMARTJOYPLUS_FF
545 bool "SmartJoy PLUS PS2/USB adapter force feedback support" 574 bool "SmartJoy PLUS PS2/USB adapter force feedback support"
@@ -590,6 +619,7 @@ config HID_WIIMOTE
590 tristate "Nintendo Wii Remote support" 619 tristate "Nintendo Wii Remote support"
591 depends on BT_HIDP 620 depends on BT_HIDP
592 depends on LEDS_CLASS 621 depends on LEDS_CLASS
622 select POWER_SUPPLY
593 ---help--- 623 ---help---
594 Support for the Nintendo Wii Remote bluetooth device. 624 Support for the Nintendo Wii Remote bluetooth device.
595 625
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 0a0a38e9fd28..1e0d2a638b28 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -21,7 +21,7 @@ endif
21ifdef CONFIG_LOGIG940_FF 21ifdef CONFIG_LOGIG940_FF
22 hid-logitech-y += hid-lg3ff.o 22 hid-logitech-y += hid-lg3ff.o
23endif 23endif
24ifdef CONFIG_LOGIWII_FF 24ifdef CONFIG_LOGIWHEELS_FF
25 hid-logitech-y += hid-lg4ff.o 25 hid-logitech-y += hid-lg4ff.o
26endif 26endif
27 27
@@ -43,6 +43,7 @@ obj-$(CONFIG_HID_KEYTOUCH) += hid-keytouch.o
43obj-$(CONFIG_HID_KYE) += hid-kye.o 43obj-$(CONFIG_HID_KYE) += hid-kye.o
44obj-$(CONFIG_HID_LCPOWER) += hid-lcpower.o 44obj-$(CONFIG_HID_LCPOWER) += hid-lcpower.o
45obj-$(CONFIG_HID_LOGITECH) += hid-logitech.o 45obj-$(CONFIG_HID_LOGITECH) += hid-logitech.o
46obj-$(CONFIG_HID_LOGITECH_DJ) += hid-logitech-dj.o
46obj-$(CONFIG_HID_MAGICMOUSE) += hid-magicmouse.o 47obj-$(CONFIG_HID_MAGICMOUSE) += hid-magicmouse.o
47obj-$(CONFIG_HID_MICROSOFT) += hid-microsoft.o 48obj-$(CONFIG_HID_MICROSOFT) += hid-microsoft.o
48obj-$(CONFIG_HID_MONTEREY) += hid-monterey.o 49obj-$(CONFIG_HID_MONTEREY) += hid-monterey.o
@@ -54,6 +55,7 @@ obj-$(CONFIG_HID_QUANTA) += hid-quanta.o
54obj-$(CONFIG_HID_PANTHERLORD) += hid-pl.o 55obj-$(CONFIG_HID_PANTHERLORD) += hid-pl.o
55obj-$(CONFIG_HID_PETALYNX) += hid-petalynx.o 56obj-$(CONFIG_HID_PETALYNX) += hid-petalynx.o
56obj-$(CONFIG_HID_PICOLCD) += hid-picolcd.o 57obj-$(CONFIG_HID_PICOLCD) += hid-picolcd.o
58obj-$(CONFIG_HID_PRIMAX) += hid-primax.o
57obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o 59obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o
58obj-$(CONFIG_HID_ROCCAT_COMMON) += hid-roccat-common.o 60obj-$(CONFIG_HID_ROCCAT_COMMON) += hid-roccat-common.o
59obj-$(CONFIG_HID_ROCCAT_ARVO) += hid-roccat-arvo.o 61obj-$(CONFIG_HID_ROCCAT_ARVO) += hid-roccat-arvo.o
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
index 18b3bc646bf3..9bc7b03269df 100644
--- a/drivers/hid/hid-apple.c
+++ b/drivers/hid/hid-apple.c
@@ -183,6 +183,9 @@ static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
183 if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI && 183 if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI &&
184 hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) 184 hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS)
185 table = macbookair_fn_keys; 185 table = macbookair_fn_keys;
186 else if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI &&
187 hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING6_JIS)
188 table = macbookair_fn_keys;
186 else if (hid->product < 0x21d || hid->product >= 0x300) 189 else if (hid->product < 0x21d || hid->product >= 0x300)
187 table = powerbook_fn_keys; 190 table = powerbook_fn_keys;
188 else 191 else
@@ -493,6 +496,18 @@ static const struct hid_device_id apple_devices[] = {
493 .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD }, 496 .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
494 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS), 497 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS),
495 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS }, 498 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
499 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI),
500 .driver_data = APPLE_HAS_FN },
501 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO),
502 .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
503 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS),
504 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
505 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI),
506 .driver_data = APPLE_HAS_FN },
507 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO),
508 .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
509 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS),
510 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
496 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI), 511 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
497 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN }, 512 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
498 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO), 513 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
diff --git a/drivers/hid/hid-axff.c b/drivers/hid/hid-axff.c
index 121514149e0b..3bdb4500f95e 100644
--- a/drivers/hid/hid-axff.c
+++ b/drivers/hid/hid-axff.c
@@ -6,7 +6,7 @@
6 * Xbox 360 controller. 6 * Xbox 360 controller.
7 * 7 *
8 * 1a34:0802 "ACRUX USB GAMEPAD 8116" 8 * 1a34:0802 "ACRUX USB GAMEPAD 8116"
9 * - tested with a EXEQ EQ-PCU-02090 game controller. 9 * - tested with an EXEQ EQ-PCU-02090 game controller.
10 * 10 *
11 * Copyright (c) 2010 Sergei Kolzun <x0r@dv-life.ru> 11 * Copyright (c) 2010 Sergei Kolzun <x0r@dv-life.ru>
12 */ 12 */
@@ -45,7 +45,10 @@ static int axff_play(struct input_dev *dev, void *data, struct ff_effect *effect
45{ 45{
46 struct hid_device *hid = input_get_drvdata(dev); 46 struct hid_device *hid = input_get_drvdata(dev);
47 struct axff_device *axff = data; 47 struct axff_device *axff = data;
48 struct hid_report *report = axff->report;
49 int field_count = 0;
48 int left, right; 50 int left, right;
51 int i, j;
49 52
50 left = effect->u.rumble.strong_magnitude; 53 left = effect->u.rumble.strong_magnitude;
51 right = effect->u.rumble.weak_magnitude; 54 right = effect->u.rumble.weak_magnitude;
@@ -55,10 +58,14 @@ static int axff_play(struct input_dev *dev, void *data, struct ff_effect *effect
55 left = left * 0xff / 0xffff; 58 left = left * 0xff / 0xffff;
56 right = right * 0xff / 0xffff; 59 right = right * 0xff / 0xffff;
57 60
58 axff->report->field[0]->value[0] = left; 61 for (i = 0; i < report->maxfield; i++) {
59 axff->report->field[1]->value[0] = right; 62 for (j = 0; j < report->field[i]->report_count; j++) {
60 axff->report->field[2]->value[0] = left; 63 report->field[i]->value[j] =
61 axff->report->field[3]->value[0] = right; 64 field_count % 2 ? right : left;
65 field_count++;
66 }
67 }
68
62 dbg_hid("running with 0x%02x 0x%02x", left, right); 69 dbg_hid("running with 0x%02x 0x%02x", left, right);
63 usbhid_submit_report(hid, axff->report, USB_DIR_OUT); 70 usbhid_submit_report(hid, axff->report, USB_DIR_OUT);
64 71
@@ -72,6 +79,8 @@ static int axff_init(struct hid_device *hid)
72 struct hid_input *hidinput = list_first_entry(&hid->inputs, struct hid_input, list); 79 struct hid_input *hidinput = list_first_entry(&hid->inputs, struct hid_input, list);
73 struct list_head *report_list =&hid->report_enum[HID_OUTPUT_REPORT].report_list; 80 struct list_head *report_list =&hid->report_enum[HID_OUTPUT_REPORT].report_list;
74 struct input_dev *dev = hidinput->input; 81 struct input_dev *dev = hidinput->input;
82 int field_count = 0;
83 int i, j;
75 int error; 84 int error;
76 85
77 if (list_empty(report_list)) { 86 if (list_empty(report_list)) {
@@ -80,9 +89,16 @@ static int axff_init(struct hid_device *hid)
80 } 89 }
81 90
82 report = list_first_entry(report_list, struct hid_report, list); 91 report = list_first_entry(report_list, struct hid_report, list);
92 for (i = 0; i < report->maxfield; i++) {
93 for (j = 0; j < report->field[i]->report_count; j++) {
94 report->field[i]->value[j] = 0x00;
95 field_count++;
96 }
97 }
83 98
84 if (report->maxfield < 4) { 99 if (field_count < 4) {
85 hid_err(hid, "no fields in the report: %d\n", report->maxfield); 100 hid_err(hid, "not enough fields in the report: %d\n",
101 field_count);
86 return -ENODEV; 102 return -ENODEV;
87 } 103 }
88 104
@@ -97,13 +113,9 @@ static int axff_init(struct hid_device *hid)
97 goto err_free_mem; 113 goto err_free_mem;
98 114
99 axff->report = report; 115 axff->report = report;
100 axff->report->field[0]->value[0] = 0x00;
101 axff->report->field[1]->value[0] = 0x00;
102 axff->report->field[2]->value[0] = 0x00;
103 axff->report->field[3]->value[0] = 0x00;
104 usbhid_submit_report(hid, axff->report, USB_DIR_OUT); 116 usbhid_submit_report(hid, axff->report, USB_DIR_OUT);
105 117
106 hid_info(hid, "Force Feedback for ACRUX game controllers by Sergei Kolzun<x0r@dv-life.ru>\n"); 118 hid_info(hid, "Force Feedback for ACRUX game controllers by Sergei Kolzun <x0r@dv-life.ru>\n");
107 119
108 return 0; 120 return 0;
109 121
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 242353df3dc4..91adcc5bad28 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -29,6 +29,7 @@
29#include <linux/wait.h> 29#include <linux/wait.h>
30#include <linux/vmalloc.h> 30#include <linux/vmalloc.h>
31#include <linux/sched.h> 31#include <linux/sched.h>
32#include <linux/semaphore.h>
32 33
33#include <linux/hid.h> 34#include <linux/hid.h>
34#include <linux/hiddev.h> 35#include <linux/hiddev.h>
@@ -1085,16 +1086,25 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
1085 struct hid_report *report; 1086 struct hid_report *report;
1086 char *buf; 1087 char *buf;
1087 unsigned int i; 1088 unsigned int i;
1088 int ret; 1089 int ret = 0;
1089 1090
1090 if (!hid || !hid->driver) 1091 if (!hid)
1091 return -ENODEV; 1092 return -ENODEV;
1093
1094 if (down_trylock(&hid->driver_lock))
1095 return -EBUSY;
1096
1097 if (!hid->driver) {
1098 ret = -ENODEV;
1099 goto unlock;
1100 }
1092 report_enum = hid->report_enum + type; 1101 report_enum = hid->report_enum + type;
1093 hdrv = hid->driver; 1102 hdrv = hid->driver;
1094 1103
1095 if (!size) { 1104 if (!size) {
1096 dbg_hid("empty report\n"); 1105 dbg_hid("empty report\n");
1097 return -1; 1106 ret = -1;
1107 goto unlock;
1098 } 1108 }
1099 1109
1100 buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC); 1110 buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
@@ -1118,18 +1128,24 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
1118nomem: 1128nomem:
1119 report = hid_get_report(report_enum, data); 1129 report = hid_get_report(report_enum, data);
1120 1130
1121 if (!report) 1131 if (!report) {
1122 return -1; 1132 ret = -1;
1133 goto unlock;
1134 }
1123 1135
1124 if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) { 1136 if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
1125 ret = hdrv->raw_event(hid, report, data, size); 1137 ret = hdrv->raw_event(hid, report, data, size);
1126 if (ret != 0) 1138 if (ret != 0) {
1127 return ret < 0 ? ret : 0; 1139 ret = ret < 0 ? ret : 0;
1140 goto unlock;
1141 }
1128 } 1142 }
1129 1143
1130 hid_report_raw_event(hid, type, data, size, interrupt); 1144 hid_report_raw_event(hid, type, data, size, interrupt);
1131 1145
1132 return 0; 1146unlock:
1147 up(&hid->driver_lock);
1148 return ret;
1133} 1149}
1134EXPORT_SYMBOL_GPL(hid_input_report); 1150EXPORT_SYMBOL_GPL(hid_input_report);
1135 1151
@@ -1212,6 +1228,12 @@ int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
1212 if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev, 1228 if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
1213 connect_mask & HID_CONNECT_HIDINPUT_FORCE)) 1229 connect_mask & HID_CONNECT_HIDINPUT_FORCE))
1214 hdev->claimed |= HID_CLAIMED_INPUT; 1230 hdev->claimed |= HID_CLAIMED_INPUT;
1231 if (hdev->quirks & HID_QUIRK_MULTITOUCH) {
1232 /* this device should be handled by hid-multitouch, skip it */
1233 hdev->quirks &= ~HID_QUIRK_MULTITOUCH;
1234 return -ENODEV;
1235 }
1236
1215 if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect && 1237 if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
1216 !hdev->hiddev_connect(hdev, 1238 !hdev->hiddev_connect(hdev,
1217 connect_mask & HID_CONNECT_HIDDEV_FORCE)) 1239 connect_mask & HID_CONNECT_HIDDEV_FORCE))
@@ -1343,6 +1365,12 @@ static const struct hid_device_id hid_have_special_driver[] = {
1343 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) }, 1365 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
1344 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) }, 1366 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
1345 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) }, 1367 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
1368 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
1369 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
1370 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
1371 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
1372 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
1373 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
1346 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) }, 1374 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
1347 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) }, 1375 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
1348 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) }, 1376 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
@@ -1391,6 +1419,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
1391 { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) }, 1419 { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
1392 { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) }, 1420 { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
1393 { HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) }, 1421 { HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },
1422 { HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, USB_DEVICE_ID_IDEACOM_IDC6650) },
1394 { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) }, 1423 { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
1395 { HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) }, 1424 { HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) },
1396 { HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, USB_DEVICE_ID_IRTOUCH_INFRARED_USB) }, 1425 { HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
@@ -1399,6 +1428,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
1399 { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) }, 1428 { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
1400 { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) }, 1429 { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
1401 { HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) }, 1430 { HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },
1431 { HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MULTITOUCH) },
1402 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) }, 1432 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
1403 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) }, 1433 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
1404 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) }, 1434 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
@@ -1420,8 +1450,11 @@ static const struct hid_device_id hid_have_special_driver[] = {
1420 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) }, 1450 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
1421 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) }, 1451 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
1422 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) }, 1452 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },
1453 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },
1423 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) }, 1454 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
1424 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) }, 1455 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },
1456 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
1457 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
1425 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) }, 1458 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },
1426 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) }, 1459 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
1427 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) }, 1460 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
@@ -1461,6 +1494,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
1461 { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) }, 1494 { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
1462 { HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_PCI) }, 1495 { HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_PCI) },
1463 { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) }, 1496 { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
1497 { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
1464 { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) }, 1498 { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
1465 { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) }, 1499 { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
1466 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) }, 1500 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
@@ -1501,6 +1535,10 @@ static const struct hid_device_id hid_have_special_driver[] = {
1501 { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) }, 1535 { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
1502 { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) }, 1536 { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
1503 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) }, 1537 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
1538 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },
1539 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
1540 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
1541 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
1504 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) }, 1542 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
1505 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) }, 1543 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
1506 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) }, 1544 { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
@@ -1620,10 +1658,15 @@ static int hid_device_probe(struct device *dev)
1620 const struct hid_device_id *id; 1658 const struct hid_device_id *id;
1621 int ret = 0; 1659 int ret = 0;
1622 1660
1661 if (down_interruptible(&hdev->driver_lock))
1662 return -EINTR;
1663
1623 if (!hdev->driver) { 1664 if (!hdev->driver) {
1624 id = hid_match_device(hdev, hdrv); 1665 id = hid_match_device(hdev, hdrv);
1625 if (id == NULL) 1666 if (id == NULL) {
1626 return -ENODEV; 1667 ret = -ENODEV;
1668 goto unlock;
1669 }
1627 1670
1628 hdev->driver = hdrv; 1671 hdev->driver = hdrv;
1629 if (hdrv->probe) { 1672 if (hdrv->probe) {
@@ -1636,14 +1679,20 @@ static int hid_device_probe(struct device *dev)
1636 if (ret) 1679 if (ret)
1637 hdev->driver = NULL; 1680 hdev->driver = NULL;
1638 } 1681 }
1682unlock:
1683 up(&hdev->driver_lock);
1639 return ret; 1684 return ret;
1640} 1685}
1641 1686
1642static int hid_device_remove(struct device *dev) 1687static int hid_device_remove(struct device *dev)
1643{ 1688{
1644 struct hid_device *hdev = container_of(dev, struct hid_device, dev); 1689 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1645 struct hid_driver *hdrv = hdev->driver; 1690 struct hid_driver *hdrv;
1691
1692 if (down_interruptible(&hdev->driver_lock))
1693 return -EINTR;
1646 1694
1695 hdrv = hdev->driver;
1647 if (hdrv) { 1696 if (hdrv) {
1648 if (hdrv->remove) 1697 if (hdrv->remove)
1649 hdrv->remove(hdev); 1698 hdrv->remove(hdev);
@@ -1652,6 +1701,7 @@ static int hid_device_remove(struct device *dev)
1652 hdev->driver = NULL; 1701 hdev->driver = NULL;
1653 } 1702 }
1654 1703
1704 up(&hdev->driver_lock);
1655 return 0; 1705 return 0;
1656} 1706}
1657 1707
@@ -1892,6 +1942,12 @@ static const struct hid_device_id hid_mouse_ignore_list[] = {
1892 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) }, 1942 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
1893 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) }, 1943 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
1894 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) }, 1944 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
1945 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
1946 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
1947 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
1948 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
1949 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
1950 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
1895 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) }, 1951 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
1896 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) }, 1952 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
1897 { } 1953 { }
@@ -1999,6 +2055,7 @@ struct hid_device *hid_allocate_device(void)
1999 2055
2000 init_waitqueue_head(&hdev->debug_wait); 2056 init_waitqueue_head(&hdev->debug_wait);
2001 INIT_LIST_HEAD(&hdev->debug_list); 2057 INIT_LIST_HEAD(&hdev->debug_list);
2058 sema_init(&hdev->driver_lock, 1);
2002 2059
2003 return hdev; 2060 return hdev;
2004err: 2061err:
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
index bae48745bb42..9a243ca96e6d 100644
--- a/drivers/hid/hid-debug.c
+++ b/drivers/hid/hid-debug.c
@@ -450,6 +450,11 @@ void hid_dump_field(struct hid_field *field, int n, struct seq_file *f) {
450 seq_printf(f, "Logical("); 450 seq_printf(f, "Logical(");
451 hid_resolv_usage(field->logical, f); seq_printf(f, ")\n"); 451 hid_resolv_usage(field->logical, f); seq_printf(f, ")\n");
452 } 452 }
453 if (field->application) {
454 tab(n, f);
455 seq_printf(f, "Application(");
456 hid_resolv_usage(field->application, f); seq_printf(f, ")\n");
457 }
453 tab(n, f); seq_printf(f, "Usage(%d)\n", field->maxusage); 458 tab(n, f); seq_printf(f, "Usage(%d)\n", field->maxusage);
454 for (j = 0; j < field->maxusage; j++) { 459 for (j = 0; j < field->maxusage; j++) {
455 tab(n+2, f); hid_resolv_usage(field->usage[j].hid, f); seq_printf(f, "\n"); 460 tab(n+2, f); hid_resolv_usage(field->usage[j].hid, f); seq_printf(f, "\n");
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 7484e1b67249..1680e99b4816 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -112,6 +112,12 @@
112#define USB_DEVICE_ID_APPLE_ALU_REVB_ANSI 0x024f 112#define USB_DEVICE_ID_APPLE_ALU_REVB_ANSI 0x024f
113#define USB_DEVICE_ID_APPLE_ALU_REVB_ISO 0x0250 113#define USB_DEVICE_ID_APPLE_ALU_REVB_ISO 0x0250
114#define USB_DEVICE_ID_APPLE_ALU_REVB_JIS 0x0251 114#define USB_DEVICE_ID_APPLE_ALU_REVB_JIS 0x0251
115#define USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI 0x0249
116#define USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO 0x024a
117#define USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS 0x024b
118#define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI 0x024c
119#define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO 0x024d
120#define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS 0x024e
115#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI 0x0239 121#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI 0x0239
116#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO 0x023a 122#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO 0x023a
117#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS 0x023b 123#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS 0x023b
@@ -351,6 +357,9 @@
351#define USB_DEVICE_ID_UGCI_FLYING 0x0020 357#define USB_DEVICE_ID_UGCI_FLYING 0x0020
352#define USB_DEVICE_ID_UGCI_FIGHTING 0x0030 358#define USB_DEVICE_ID_UGCI_FIGHTING 0x0030
353 359
360#define USB_VENDOR_ID_IDEACOM 0x1cb6
361#define USB_DEVICE_ID_IDEACOM_IDC6650 0x6650
362
354#define USB_VENDOR_ID_ILITEK 0x222a 363#define USB_VENDOR_ID_ILITEK 0x222a
355#define USB_DEVICE_ID_ILITEK_MULTITOUCH 0x0001 364#define USB_DEVICE_ID_ILITEK_MULTITOUCH 0x0001
356 365
@@ -423,6 +432,9 @@
423#define USB_DEVICE_ID_LD_HYBRID 0x2090 432#define USB_DEVICE_ID_LD_HYBRID 0x2090
424#define USB_DEVICE_ID_LD_HEATCONTROL 0x20A0 433#define USB_DEVICE_ID_LD_HEATCONTROL 0x20A0
425 434
435#define USB_VENDOR_ID_LG 0x1fd2
436#define USB_DEVICE_ID_LG_MULTITOUCH 0x0064
437
426#define USB_VENDOR_ID_LOGITECH 0x046d 438#define USB_VENDOR_ID_LOGITECH 0x046d
427#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101 439#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
428#define USB_DEVICE_ID_LOGITECH_HARMONY_FIRST 0xc110 440#define USB_DEVICE_ID_LOGITECH_HARMONY_FIRST 0xc110
@@ -440,6 +452,7 @@
440#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL 0xc295 452#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL 0xc295
441#define USB_DEVICE_ID_LOGITECH_DFP_WHEEL 0xc298 453#define USB_DEVICE_ID_LOGITECH_DFP_WHEEL 0xc298
442#define USB_DEVICE_ID_LOGITECH_G25_WHEEL 0xc299 454#define USB_DEVICE_ID_LOGITECH_G25_WHEEL 0xc299
455#define USB_DEVICE_ID_LOGITECH_DFGT_WHEEL 0xc29a
443#define USB_DEVICE_ID_LOGITECH_G27_WHEEL 0xc29b 456#define USB_DEVICE_ID_LOGITECH_G27_WHEEL 0xc29b
444#define USB_DEVICE_ID_LOGITECH_WII_WHEEL 0xc29c 457#define USB_DEVICE_ID_LOGITECH_WII_WHEEL 0xc29c
445#define USB_DEVICE_ID_LOGITECH_ELITE_KBD 0xc30a 458#define USB_DEVICE_ID_LOGITECH_ELITE_KBD 0xc30a
@@ -447,6 +460,8 @@
447#define USB_DEVICE_ID_S510_RECEIVER_2 0xc517 460#define USB_DEVICE_ID_S510_RECEIVER_2 0xc517
448#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500 0xc512 461#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500 0xc512
449#define USB_DEVICE_ID_MX3000_RECEIVER 0xc513 462#define USB_DEVICE_ID_MX3000_RECEIVER 0xc513
463#define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER 0xc52b
464#define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2 0xc532
450#define USB_DEVICE_ID_SPACETRAVELLER 0xc623 465#define USB_DEVICE_ID_SPACETRAVELLER 0xc623
451#define USB_DEVICE_ID_SPACENAVIGATOR 0xc626 466#define USB_DEVICE_ID_SPACENAVIGATOR 0xc626
452#define USB_DEVICE_ID_DINOVO_DESKTOP 0xc704 467#define USB_DEVICE_ID_DINOVO_DESKTOP 0xc704
@@ -678,6 +693,9 @@
678#define USB_VENDOR_ID_WISEGROUP_LTD 0x6666 693#define USB_VENDOR_ID_WISEGROUP_LTD 0x6666
679#define USB_VENDOR_ID_WISEGROUP_LTD2 0x6677 694#define USB_VENDOR_ID_WISEGROUP_LTD2 0x6677
680#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802 695#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
696#define USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO 0x8801
697#define USB_DEVICE_ID_SUPER_DUAL_BOX_PRO 0x8802
698#define USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO 0x8804
681 699
682#define USB_VENDOR_ID_X_TENSIONS 0x1ae7 700#define USB_VENDOR_ID_X_TENSIONS 0x1ae7
683#define USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE 0x9001 701#define USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE 0x9001
@@ -693,4 +711,7 @@
693#define USB_VENDOR_ID_ZYDACRON 0x13EC 711#define USB_VENDOR_ID_ZYDACRON 0x13EC
694#define USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL 0x0006 712#define USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL 0x0006
695 713
714#define USB_VENDOR_ID_PRIMAX 0x0461
715#define USB_DEVICE_ID_PRIMAX_KEYBOARD 0x4e05
716
696#endif 717#endif
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 6559e2e3364e..f333139d1a48 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -474,6 +474,10 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
474 map_key_clear(BTN_STYLUS2); 474 map_key_clear(BTN_STYLUS2);
475 break; 475 break;
476 476
477 case 0x51: /* ContactID */
478 device->quirks |= HID_QUIRK_MULTITOUCH;
479 goto unknown;
480
477 default: goto unknown; 481 default: goto unknown;
478 } 482 }
479 break; 483 break;
@@ -978,6 +982,13 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
978 } 982 }
979 } 983 }
980 984
985 if (hid->quirks & HID_QUIRK_MULTITOUCH) {
986 /* generic hid does not know how to handle multitouch devices */
987 if (hidinput)
988 goto out_cleanup;
989 goto out_unwind;
990 }
991
981 if (hidinput && input_register_device(hidinput->input)) 992 if (hidinput && input_register_device(hidinput->input))
982 goto out_cleanup; 993 goto out_cleanup;
983 994
diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c
index a7f916e8fc32..e7a7bd1eb34a 100644
--- a/drivers/hid/hid-lg.c
+++ b/drivers/hid/hid-lg.c
@@ -363,7 +363,7 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
363 goto err_free; 363 goto err_free;
364 } 364 }
365 365
366 if (quirks & (LG_FF | LG_FF2 | LG_FF3)) 366 if (quirks & (LG_FF | LG_FF2 | LG_FF3 | LG_FF4))
367 connect_mask &= ~HID_CONNECT_FF; 367 connect_mask &= ~HID_CONNECT_FF;
368 368
369 ret = hid_hw_start(hdev, connect_mask); 369 ret = hid_hw_start(hdev, connect_mask);
@@ -372,7 +372,8 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
372 goto err_free; 372 goto err_free;
373 } 373 }
374 374
375 if (quirks & LG_FF4) { 375 /* Setup wireless link with Logitech Wii wheel */
376 if(hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
376 unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 377 unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
377 378
378 ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); 379 ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
@@ -405,6 +406,15 @@ err_free:
405 return ret; 406 return ret;
406} 407}
407 408
409static void lg_remove(struct hid_device *hdev)
410{
411 unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
412 if(quirks & LG_FF4)
413 lg4ff_deinit(hdev);
414
415 hid_hw_stop(hdev);
416}
417
408static const struct hid_device_id lg_devices[] = { 418static const struct hid_device_id lg_devices[] = {
409 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER), 419 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER),
410 .driver_data = LG_RDESC | LG_WIRELESS }, 420 .driver_data = LG_RDESC | LG_WIRELESS },
@@ -431,7 +441,7 @@ static const struct hid_device_id lg_devices[] = {
431 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D), 441 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D),
432 .driver_data = LG_NOGET }, 442 .driver_data = LG_NOGET },
433 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL), 443 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL),
434 .driver_data = LG_NOGET | LG_FF }, 444 .driver_data = LG_NOGET | LG_FF4 },
435 445
436 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD), 446 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD),
437 .driver_data = LG_FF2 }, 447 .driver_data = LG_FF2 },
@@ -444,15 +454,17 @@ static const struct hid_device_id lg_devices[] = {
444 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO), 454 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO),
445 .driver_data = LG_FF }, 455 .driver_data = LG_FF },
446 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL), 456 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL),
447 .driver_data = LG_FF }, 457 .driver_data = LG_FF4 },
448 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2), 458 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2),
449 .driver_data = LG_FF }, 459 .driver_data = LG_FF4 },
450 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL), 460 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL),
451 .driver_data = LG_FF }, 461 .driver_data = LG_FF4 },
462 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL),
463 .driver_data = LG_FF4 },
452 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL), 464 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL),
453 .driver_data = LG_FF }, 465 .driver_data = LG_FF4 },
454 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL), 466 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL),
455 .driver_data = LG_NOGET | LG_FF }, 467 .driver_data = LG_NOGET | LG_FF4 },
456 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL), 468 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL),
457 .driver_data = LG_FF4 }, 469 .driver_data = LG_FF4 },
458 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ), 470 { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ),
@@ -478,6 +490,7 @@ static struct hid_driver lg_driver = {
478 .input_mapped = lg_input_mapped, 490 .input_mapped = lg_input_mapped,
479 .event = lg_event, 491 .event = lg_event,
480 .probe = lg_probe, 492 .probe = lg_probe,
493 .remove = lg_remove,
481}; 494};
482 495
483static int __init lg_init(void) 496static int __init lg_init(void)
diff --git a/drivers/hid/hid-lg.h b/drivers/hid/hid-lg.h
index b0100ba2ae0b..4b097286dc78 100644
--- a/drivers/hid/hid-lg.h
+++ b/drivers/hid/hid-lg.h
@@ -19,10 +19,12 @@ int lg3ff_init(struct hid_device *hdev);
19static inline int lg3ff_init(struct hid_device *hdev) { return -1; } 19static inline int lg3ff_init(struct hid_device *hdev) { return -1; }
20#endif 20#endif
21 21
22#ifdef CONFIG_LOGIWII_FF 22#ifdef CONFIG_LOGIWHEELS_FF
23int lg4ff_init(struct hid_device *hdev); 23int lg4ff_init(struct hid_device *hdev);
24int lg4ff_deinit(struct hid_device *hdev);
24#else 25#else
25static inline int lg4ff_init(struct hid_device *hdev) { return -1; } 26static inline int lg4ff_init(struct hid_device *hdev) { return -1; }
27static inline int lg4ff_deinit(struct hid_device *hdev) { return -1; }
26#endif 28#endif
27 29
28#endif 30#endif
diff --git a/drivers/hid/hid-lg4ff.c b/drivers/hid/hid-lg4ff.c
index fa550c8e1d1b..103f30d93f76 100644
--- a/drivers/hid/hid-lg4ff.c
+++ b/drivers/hid/hid-lg4ff.c
@@ -29,19 +29,108 @@
29 29
30#include "usbhid/usbhid.h" 30#include "usbhid/usbhid.h"
31#include "hid-lg.h" 31#include "hid-lg.h"
32#include "hid-ids.h"
32 33
33struct lg4ff_device { 34#define DFGT_REV_MAJ 0x13
34 struct hid_report *report; 35#define DFGT_REV_MIN 0x22
36#define DFP_REV_MAJ 0x11
37#define DFP_REV_MIN 0x06
38#define FFEX_REV_MAJ 0x21
39#define FFEX_REV_MIN 0x00
40#define G25_REV_MAJ 0x12
41#define G25_REV_MIN 0x22
42#define G27_REV_MAJ 0x12
43#define G27_REV_MIN 0x38
44
45#define to_hid_device(pdev) container_of(pdev, struct hid_device, dev)
46
47static void hid_lg4ff_set_range_dfp(struct hid_device *hid, u16 range);
48static void hid_lg4ff_set_range_g25(struct hid_device *hid, u16 range);
49static ssize_t lg4ff_range_show(struct device *dev, struct device_attribute *attr, char *buf);
50static ssize_t lg4ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
51
52static DEVICE_ATTR(range, S_IRWXU | S_IRWXG | S_IRWXO, lg4ff_range_show, lg4ff_range_store);
53
54static bool list_inited;
55
56struct lg4ff_device_entry {
57 char *device_id; /* Use name in respective kobject structure's address as the ID */
58 __u16 range;
59 __u16 min_range;
60 __u16 max_range;
61 __u8 leds;
62 struct list_head list;
63 void (*set_range)(struct hid_device *hid, u16 range);
35}; 64};
36 65
37static const signed short ff4_wheel_ac[] = { 66static struct lg4ff_device_entry device_list;
67
68static const signed short lg4ff_wheel_effects[] = {
38 FF_CONSTANT, 69 FF_CONSTANT,
39 FF_AUTOCENTER, 70 FF_AUTOCENTER,
40 -1 71 -1
41}; 72};
42 73
43static int hid_lg4ff_play(struct input_dev *dev, void *data, 74struct lg4ff_wheel {
44 struct ff_effect *effect) 75 const __u32 product_id;
76 const signed short *ff_effects;
77 const __u16 min_range;
78 const __u16 max_range;
79 void (*set_range)(struct hid_device *hid, u16 range);
80};
81
82static const struct lg4ff_wheel lg4ff_devices[] = {
83 {USB_DEVICE_ID_LOGITECH_WHEEL, lg4ff_wheel_effects, 40, 270, NULL},
84 {USB_DEVICE_ID_LOGITECH_MOMO_WHEEL, lg4ff_wheel_effects, 40, 270, NULL},
85 {USB_DEVICE_ID_LOGITECH_DFP_WHEEL, lg4ff_wheel_effects, 40, 900, hid_lg4ff_set_range_dfp},
86 {USB_DEVICE_ID_LOGITECH_G25_WHEEL, lg4ff_wheel_effects, 40, 900, hid_lg4ff_set_range_g25},
87 {USB_DEVICE_ID_LOGITECH_DFGT_WHEEL, lg4ff_wheel_effects, 40, 900, hid_lg4ff_set_range_g25},
88 {USB_DEVICE_ID_LOGITECH_G27_WHEEL, lg4ff_wheel_effects, 40, 900, hid_lg4ff_set_range_g25},
89 {USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2, lg4ff_wheel_effects, 40, 270, NULL},
90 {USB_DEVICE_ID_LOGITECH_WII_WHEEL, lg4ff_wheel_effects, 40, 270, NULL}
91};
92
93struct lg4ff_native_cmd {
94 const __u8 cmd_num; /* Number of commands to send */
95 const __u8 cmd[];
96};
97
98struct lg4ff_usb_revision {
99 const __u16 rev_maj;
100 const __u16 rev_min;
101 const struct lg4ff_native_cmd *command;
102};
103
104static const struct lg4ff_native_cmd native_dfp = {
105 1,
106 {0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}
107};
108
109static const struct lg4ff_native_cmd native_dfgt = {
110 2,
111 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1st command */
112 0xf8, 0x09, 0x03, 0x01, 0x00, 0x00, 0x00} /* 2nd command */
113};
114
115static const struct lg4ff_native_cmd native_g25 = {
116 1,
117 {0xf8, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00}
118};
119
120static const struct lg4ff_native_cmd native_g27 = {
121 2,
122 {0xf8, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1st command */
123 0xf8, 0x09, 0x04, 0x01, 0x00, 0x00, 0x00} /* 2nd command */
124};
125
126static const struct lg4ff_usb_revision lg4ff_revs[] = {
127 {DFGT_REV_MAJ, DFGT_REV_MIN, &native_dfgt}, /* Driving Force GT */
128 {DFP_REV_MAJ, DFP_REV_MIN, &native_dfp}, /* Driving Force Pro */
129 {G25_REV_MAJ, G25_REV_MIN, &native_g25}, /* G25 */
130 {G27_REV_MAJ, G27_REV_MIN, &native_g27}, /* G27 */
131};
132
133static int hid_lg4ff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
45{ 134{
46 struct hid_device *hid = input_get_drvdata(dev); 135 struct hid_device *hid = input_get_drvdata(dev);
47 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; 136 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
@@ -55,13 +144,12 @@ static int hid_lg4ff_play(struct input_dev *dev, void *data,
55 x = effect->u.ramp.start_level + 0x80; /* 0x80 is no force */ 144 x = effect->u.ramp.start_level + 0x80; /* 0x80 is no force */
56 CLAMP(x); 145 CLAMP(x);
57 report->field[0]->value[0] = 0x11; /* Slot 1 */ 146 report->field[0]->value[0] = 0x11; /* Slot 1 */
58 report->field[0]->value[1] = 0x10; 147 report->field[0]->value[1] = 0x08;
59 report->field[0]->value[2] = x; 148 report->field[0]->value[2] = x;
60 report->field[0]->value[3] = 0x00; 149 report->field[0]->value[3] = 0x80;
61 report->field[0]->value[4] = 0x00; 150 report->field[0]->value[4] = 0x00;
62 report->field[0]->value[5] = 0x08; 151 report->field[0]->value[5] = 0x00;
63 report->field[0]->value[6] = 0x00; 152 report->field[0]->value[6] = 0x00;
64 dbg_hid("Autocenter, x=0x%02X\n", x);
65 153
66 usbhid_submit_report(hid, report, USB_DIR_OUT); 154 usbhid_submit_report(hid, report, USB_DIR_OUT);
67 break; 155 break;
@@ -69,24 +157,184 @@ static int hid_lg4ff_play(struct input_dev *dev, void *data,
69 return 0; 157 return 0;
70} 158}
71 159
72static void hid_lg4ff_set_autocenter(struct input_dev *dev, u16 magnitude) 160/* Sends default autocentering command compatible with
161 * all wheels except Formula Force EX */
162static void hid_lg4ff_set_autocenter_default(struct input_dev *dev, u16 magnitude)
73{ 163{
74 struct hid_device *hid = input_get_drvdata(dev); 164 struct hid_device *hid = input_get_drvdata(dev);
75 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; 165 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
76 struct hid_report *report = list_entry(report_list->next, struct hid_report, list); 166 struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
77 __s32 *value = report->field[0]->value;
78 167
79 *value++ = 0xfe; 168 report->field[0]->value[0] = 0xfe;
80 *value++ = 0x0d; 169 report->field[0]->value[1] = 0x0d;
81 *value++ = 0x07; 170 report->field[0]->value[2] = magnitude >> 13;
82 *value++ = 0x07; 171 report->field[0]->value[3] = magnitude >> 13;
83 *value++ = (magnitude >> 8) & 0xff; 172 report->field[0]->value[4] = magnitude >> 8;
84 *value++ = 0x00; 173 report->field[0]->value[5] = 0x00;
85 *value = 0x00; 174 report->field[0]->value[6] = 0x00;
175
176 usbhid_submit_report(hid, report, USB_DIR_OUT);
177}
178
179/* Sends autocentering command compatible with Formula Force EX */
180static void hid_lg4ff_set_autocenter_ffex(struct input_dev *dev, u16 magnitude)
181{
182 struct hid_device *hid = input_get_drvdata(dev);
183 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
184 struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
185 magnitude = magnitude * 90 / 65535;
186
187
188 report->field[0]->value[0] = 0xfe;
189 report->field[0]->value[1] = 0x03;
190 report->field[0]->value[2] = magnitude >> 14;
191 report->field[0]->value[3] = magnitude >> 14;
192 report->field[0]->value[4] = magnitude;
193 report->field[0]->value[5] = 0x00;
194 report->field[0]->value[6] = 0x00;
195
196 usbhid_submit_report(hid, report, USB_DIR_OUT);
197}
198
199/* Sends command to set range compatible with G25/G27/Driving Force GT */
200static void hid_lg4ff_set_range_g25(struct hid_device *hid, u16 range)
201{
202 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
203 struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
204 dbg_hid("G25/G27/DFGT: setting range to %u\n", range);
205
206 report->field[0]->value[0] = 0xf8;
207 report->field[0]->value[1] = 0x81;
208 report->field[0]->value[2] = range & 0x00ff;
209 report->field[0]->value[3] = (range & 0xff00) >> 8;
210 report->field[0]->value[4] = 0x00;
211 report->field[0]->value[5] = 0x00;
212 report->field[0]->value[6] = 0x00;
213
214 usbhid_submit_report(hid, report, USB_DIR_OUT);
215}
216
217/* Sends commands to set range compatible with Driving Force Pro wheel */
218static void hid_lg4ff_set_range_dfp(struct hid_device *hid, __u16 range)
219{
220 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
221 struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
222 int start_left, start_right, full_range;
223 dbg_hid("Driving Force Pro: setting range to %u\n", range);
224
225 /* Prepare "coarse" limit command */
226 report->field[0]->value[0] = 0xf8;
227 report->field[0]->value[1] = 0x00; /* Set later */
228 report->field[0]->value[2] = 0x00;
229 report->field[0]->value[3] = 0x00;
230 report->field[0]->value[4] = 0x00;
231 report->field[0]->value[5] = 0x00;
232 report->field[0]->value[6] = 0x00;
233
234 if (range > 200) {
235 report->field[0]->value[1] = 0x03;
236 full_range = 900;
237 } else {
238 report->field[0]->value[1] = 0x02;
239 full_range = 200;
240 }
241 usbhid_submit_report(hid, report, USB_DIR_OUT);
242
243 /* Prepare "fine" limit command */
244 report->field[0]->value[0] = 0x81;
245 report->field[0]->value[1] = 0x0b;
246 report->field[0]->value[2] = 0x00;
247 report->field[0]->value[3] = 0x00;
248 report->field[0]->value[4] = 0x00;
249 report->field[0]->value[5] = 0x00;
250 report->field[0]->value[6] = 0x00;
251
252 if (range == 200 || range == 900) { /* Do not apply any fine limit */
253 usbhid_submit_report(hid, report, USB_DIR_OUT);
254 return;
255 }
256
257 /* Construct fine limit command */
258 start_left = (((full_range - range + 1) * 2047) / full_range);
259 start_right = 0xfff - start_left;
260
261 report->field[0]->value[2] = start_left >> 4;
262 report->field[0]->value[3] = start_right >> 4;
263 report->field[0]->value[4] = 0xff;
264 report->field[0]->value[5] = (start_right & 0xe) << 4 | (start_left & 0xe);
265 report->field[0]->value[6] = 0xff;
86 266
87 usbhid_submit_report(hid, report, USB_DIR_OUT); 267 usbhid_submit_report(hid, report, USB_DIR_OUT);
88} 268}
89 269
270static void hid_lg4ff_switch_native(struct hid_device *hid, const struct lg4ff_native_cmd *cmd)
271{
272 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
273 struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
274 __u8 i, j;
275
276 j = 0;
277 while (j < 7*cmd->cmd_num) {
278 for (i = 0; i < 7; i++)
279 report->field[0]->value[i] = cmd->cmd[j++];
280
281 usbhid_submit_report(hid, report, USB_DIR_OUT);
282 }
283}
284
285/* Read current range and display it in terminal */
286static ssize_t lg4ff_range_show(struct device *dev, struct device_attribute *attr, char *buf)
287{
288 struct lg4ff_device_entry *uninitialized_var(entry);
289 struct list_head *h;
290 struct hid_device *hid = to_hid_device(dev);
291 size_t count;
292
293 list_for_each(h, &device_list.list) {
294 entry = list_entry(h, struct lg4ff_device_entry, list);
295 if (strcmp(entry->device_id, (&hid->dev)->kobj.name) == 0)
296 break;
297 }
298 if (h == &device_list.list) {
299 dbg_hid("Device not found!");
300 return 0;
301 }
302
303 count = scnprintf(buf, PAGE_SIZE, "%u\n", entry->range);
304 return count;
305}
306
307/* Set range to user specified value, call appropriate function
308 * according to the type of the wheel */
309static ssize_t lg4ff_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
310{
311 struct lg4ff_device_entry *uninitialized_var(entry);
312 struct list_head *h;
313 struct hid_device *hid = to_hid_device(dev);
314 __u16 range = simple_strtoul(buf, NULL, 10);
315
316 list_for_each(h, &device_list.list) {
317 entry = list_entry(h, struct lg4ff_device_entry, list);
318 if (strcmp(entry->device_id, (&hid->dev)->kobj.name) == 0)
319 break;
320 }
321 if (h == &device_list.list) {
322 dbg_hid("Device not found!");
323 return count;
324 }
325
326 if (range == 0)
327 range = entry->max_range;
328
329 /* Check if the wheel supports range setting
330 * and that the range is within limits for the wheel */
331 if (entry->set_range != NULL && range >= entry->min_range && range <= entry->max_range) {
332 entry->set_range(hid, range);
333 entry->range = range;
334 }
335
336 return count;
337}
90 338
91int lg4ff_init(struct hid_device *hid) 339int lg4ff_init(struct hid_device *hid)
92{ 340{
@@ -95,9 +343,10 @@ int lg4ff_init(struct hid_device *hid)
95 struct input_dev *dev = hidinput->input; 343 struct input_dev *dev = hidinput->input;
96 struct hid_report *report; 344 struct hid_report *report;
97 struct hid_field *field; 345 struct hid_field *field;
98 const signed short *ff_bits = ff4_wheel_ac; 346 struct lg4ff_device_entry *entry;
99 int error; 347 struct usb_device_descriptor *udesc;
100 int i; 348 int error, i, j;
349 __u16 bcdDevice, rev_maj, rev_min;
101 350
102 /* Find the report to use */ 351 /* Find the report to use */
103 if (list_empty(report_list)) { 352 if (list_empty(report_list)) {
@@ -118,18 +367,122 @@ int lg4ff_init(struct hid_device *hid)
118 return -1; 367 return -1;
119 } 368 }
120 369
121 for (i = 0; ff_bits[i] >= 0; i++) 370 /* Check what wheel has been connected */
122 set_bit(ff_bits[i], dev->ffbit); 371 for (i = 0; i < ARRAY_SIZE(lg4ff_devices); i++) {
372 if (hid->product == lg4ff_devices[i].product_id) {
373 dbg_hid("Found compatible device, product ID %04X\n", lg4ff_devices[i].product_id);
374 break;
375 }
376 }
377
378 if (i == ARRAY_SIZE(lg4ff_devices)) {
379 hid_err(hid, "Device is not supported by lg4ff driver. If you think it should be, consider reporting a bug to"
380 "LKML, Simon Wood <simon@mungewell.org> or Michal Maly <madcatxster@gmail.com>\n");
381 return -1;
382 }
383
384 /* Attempt to switch wheel to native mode when applicable */
385 udesc = &(hid_to_usb_dev(hid)->descriptor);
386 if (!udesc) {
387 hid_err(hid, "NULL USB device descriptor\n");
388 return -1;
389 }
390 bcdDevice = le16_to_cpu(udesc->bcdDevice);
391 rev_maj = bcdDevice >> 8;
392 rev_min = bcdDevice & 0xff;
393
394 if (lg4ff_devices[i].product_id == USB_DEVICE_ID_LOGITECH_WHEEL) {
395 dbg_hid("Generic wheel detected, can it do native?\n");
396 dbg_hid("USB revision: %2x.%02x\n", rev_maj, rev_min);
397
398 for (j = 0; j < ARRAY_SIZE(lg4ff_revs); j++) {
399 if (lg4ff_revs[j].rev_maj == rev_maj && lg4ff_revs[j].rev_min == rev_min) {
400 hid_lg4ff_switch_native(hid, lg4ff_revs[j].command);
401 hid_info(hid, "Switched to native mode\n");
402 }
403 }
404 }
405
406 /* Set supported force feedback capabilities */
407 for (j = 0; lg4ff_devices[i].ff_effects[j] >= 0; j++)
408 set_bit(lg4ff_devices[i].ff_effects[j], dev->ffbit);
123 409
124 error = input_ff_create_memless(dev, NULL, hid_lg4ff_play); 410 error = input_ff_create_memless(dev, NULL, hid_lg4ff_play);
125 411
126 if (error) 412 if (error)
127 return error; 413 return error;
128 414
129 if (test_bit(FF_AUTOCENTER, dev->ffbit)) 415 /* Check if autocentering is available and
130 dev->ff->set_autocenter = hid_lg4ff_set_autocenter; 416 * set the centering force to zero by default */
417 if (test_bit(FF_AUTOCENTER, dev->ffbit)) {
418 if(rev_maj == FFEX_REV_MAJ && rev_min == FFEX_REV_MIN) /* Formula Force EX expects different autocentering command */
419 dev->ff->set_autocenter = hid_lg4ff_set_autocenter_ffex;
420 else
421 dev->ff->set_autocenter = hid_lg4ff_set_autocenter_default;
422
423 dev->ff->set_autocenter(dev, 0);
424 }
425
426 /* Initialize device_list if this is the first device to handle by lg4ff */
427 if (!list_inited) {
428 INIT_LIST_HEAD(&device_list.list);
429 list_inited = 1;
430 }
431
432 /* Add the device to device_list */
433 entry = (struct lg4ff_device_entry *)kzalloc(sizeof(struct lg4ff_device_entry), GFP_KERNEL);
434 if (!entry) {
435 hid_err(hid, "Cannot add device, insufficient memory.\n");
436 return -ENOMEM;
437 }
438 entry->device_id = kstrdup((&hid->dev)->kobj.name, GFP_KERNEL);
439 if (!entry->device_id) {
440 hid_err(hid, "Cannot set device_id, insufficient memory.\n");
441 kfree(entry);
442 return -ENOMEM;
443 }
444 entry->min_range = lg4ff_devices[i].min_range;
445 entry->max_range = lg4ff_devices[i].max_range;
446 entry->set_range = lg4ff_devices[i].set_range;
447 list_add(&entry->list, &device_list.list);
448
449 /* Create sysfs interface */
450 error = device_create_file(&hid->dev, &dev_attr_range);
451 if (error)
452 return error;
453 dbg_hid("sysfs interface created\n");
454
455 /* Set the maximum range to start with */
456 entry->range = entry->max_range;
457 if (entry->set_range != NULL)
458 entry->set_range(hid, entry->range);
131 459
132 hid_info(hid, "Force feedback for Logitech Speed Force Wireless by Simon Wood <simon@mungewell.org>\n"); 460 hid_info(hid, "Force feedback for Logitech Speed Force Wireless by Simon Wood <simon@mungewell.org>\n");
133 return 0; 461 return 0;
134} 462}
135 463
464int lg4ff_deinit(struct hid_device *hid)
465{
466 bool found = 0;
467 struct lg4ff_device_entry *entry;
468 struct list_head *h, *g;
469 list_for_each_safe(h, g, &device_list.list) {
470 entry = list_entry(h, struct lg4ff_device_entry, list);
471 if (strcmp(entry->device_id, (&hid->dev)->kobj.name) == 0) {
472 list_del(h);
473 kfree(entry->device_id);
474 kfree(entry);
475 found = 1;
476 break;
477 }
478 }
479
480 if (!found) {
481 dbg_hid("Device entry not found!\n");
482 return -1;
483 }
484
485 device_remove_file(&hid->dev, &dev_attr_range);
486 dbg_hid("Device successfully unregistered\n");
487 return 0;
488}
diff --git a/drivers/hid/hid-lgff.c b/drivers/hid/hid-lgff.c
index 088f85049290..27bc54f92f44 100644
--- a/drivers/hid/hid-lgff.c
+++ b/drivers/hid/hid-lgff.c
@@ -58,12 +58,6 @@ static const signed short ff_joystick_ac[] = {
58 -1 58 -1
59}; 59};
60 60
61static const signed short ff_wheel[] = {
62 FF_CONSTANT,
63 FF_AUTOCENTER,
64 -1
65};
66
67static const struct dev_type devices[] = { 61static const struct dev_type devices[] = {
68 { 0x046d, 0xc211, ff_rumble }, 62 { 0x046d, 0xc211, ff_rumble },
69 { 0x046d, 0xc219, ff_rumble }, 63 { 0x046d, 0xc219, ff_rumble },
@@ -71,14 +65,7 @@ static const struct dev_type devices[] = {
71 { 0x046d, 0xc286, ff_joystick_ac }, 65 { 0x046d, 0xc286, ff_joystick_ac },
72 { 0x046d, 0xc287, ff_joystick_ac }, 66 { 0x046d, 0xc287, ff_joystick_ac },
73 { 0x046d, 0xc293, ff_joystick }, 67 { 0x046d, 0xc293, ff_joystick },
74 { 0x046d, 0xc294, ff_wheel },
75 { 0x046d, 0xc298, ff_wheel },
76 { 0x046d, 0xc299, ff_wheel },
77 { 0x046d, 0xc29b, ff_wheel },
78 { 0x046d, 0xc295, ff_joystick }, 68 { 0x046d, 0xc295, ff_joystick },
79 { 0x046d, 0xc298, ff_wheel },
80 { 0x046d, 0xc299, ff_wheel },
81 { 0x046d, 0xca03, ff_wheel },
82}; 69};
83 70
84static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *effect) 71static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
diff --git a/drivers/hid/hid-logitech-dj.c b/drivers/hid/hid-logitech-dj.c
new file mode 100644
index 000000000000..38b12e45780c
--- /dev/null
+++ b/drivers/hid/hid-logitech-dj.c
@@ -0,0 +1,922 @@
1/*
2 * HID driver for Logitech Unifying receivers
3 *
4 * Copyright (c) 2011 Logitech
5 */
6
7/*
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
24
25#include <linux/device.h>
26#include <linux/hid.h>
27#include <linux/module.h>
28#include <linux/usb.h>
29#include "usbhid/usbhid.h"
30#include "hid-ids.h"
31#include "hid-logitech-dj.h"
32
33/* Keyboard descriptor (1) */
34static const char kbd_descriptor[] = {
35 0x05, 0x01, /* USAGE_PAGE (generic Desktop) */
36 0x09, 0x06, /* USAGE (Keyboard) */
37 0xA1, 0x01, /* COLLECTION (Application) */
38 0x85, 0x01, /* REPORT_ID (1) */
39 0x95, 0x08, /* REPORT_COUNT (8) */
40 0x75, 0x01, /* REPORT_SIZE (1) */
41 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
42 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
43 0x05, 0x07, /* USAGE_PAGE (Keyboard) */
44 0x19, 0xE0, /* USAGE_MINIMUM (Left Control) */
45 0x29, 0xE7, /* USAGE_MAXIMUM (Right GUI) */
46 0x81, 0x02, /* INPUT (Data,Var,Abs) */
47 0x95, 0x05, /* REPORT COUNT (5) */
48 0x05, 0x08, /* USAGE PAGE (LED page) */
49 0x19, 0x01, /* USAGE MINIMUM (1) */
50 0x29, 0x05, /* USAGE MAXIMUM (5) */
51 0x91, 0x02, /* OUTPUT (Data, Variable, Absolute) */
52 0x95, 0x01, /* REPORT COUNT (1) */
53 0x75, 0x03, /* REPORT SIZE (3) */
54 0x91, 0x01, /* OUTPUT (Constant) */
55 0x95, 0x06, /* REPORT_COUNT (6) */
56 0x75, 0x08, /* REPORT_SIZE (8) */
57 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
58 0x26, 0xFF, 0x00, /* LOGICAL_MAXIMUM (255) */
59 0x05, 0x07, /* USAGE_PAGE (Keyboard) */
60 0x19, 0x00, /* USAGE_MINIMUM (no event) */
61 0x2A, 0xFF, 0x00, /* USAGE_MAXIMUM (reserved) */
62 0x81, 0x00, /* INPUT (Data,Ary,Abs) */
63 0xC0
64};
65
66/* Mouse descriptor (2) */
67static const char mse_descriptor[] = {
68 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
69 0x09, 0x02, /* USAGE (Mouse) */
70 0xA1, 0x01, /* COLLECTION (Application) */
71 0x85, 0x02, /* REPORT_ID = 2 */
72 0x09, 0x01, /* USAGE (pointer) */
73 0xA1, 0x00, /* COLLECTION (physical) */
74 0x05, 0x09, /* USAGE_PAGE (buttons) */
75 0x19, 0x01, /* USAGE_MIN (1) */
76 0x29, 0x10, /* USAGE_MAX (16) */
77 0x15, 0x00, /* LOGICAL_MIN (0) */
78 0x25, 0x01, /* LOGICAL_MAX (1) */
79 0x95, 0x10, /* REPORT_COUNT (16) */
80 0x75, 0x01, /* REPORT_SIZE (1) */
81 0x81, 0x02, /* INPUT (data var abs) */
82 0x05, 0x01, /* USAGE_PAGE (generic desktop) */
83 0x16, 0x01, 0xF8, /* LOGICAL_MIN (-2047) */
84 0x26, 0xFF, 0x07, /* LOGICAL_MAX (2047) */
85 0x75, 0x0C, /* REPORT_SIZE (12) */
86 0x95, 0x02, /* REPORT_COUNT (2) */
87 0x09, 0x30, /* USAGE (X) */
88 0x09, 0x31, /* USAGE (Y) */
89 0x81, 0x06, /* INPUT */
90 0x15, 0x81, /* LOGICAL_MIN (-127) */
91 0x25, 0x7F, /* LOGICAL_MAX (127) */
92 0x75, 0x08, /* REPORT_SIZE (8) */
93 0x95, 0x01, /* REPORT_COUNT (1) */
94 0x09, 0x38, /* USAGE (wheel) */
95 0x81, 0x06, /* INPUT */
96 0x05, 0x0C, /* USAGE_PAGE(consumer) */
97 0x0A, 0x38, 0x02, /* USAGE(AC Pan) */
98 0x95, 0x01, /* REPORT_COUNT (1) */
99 0x81, 0x06, /* INPUT */
100 0xC0, /* END_COLLECTION */
101 0xC0, /* END_COLLECTION */
102};
103
104/* Consumer Control descriptor (3) */
105static const char consumer_descriptor[] = {
106 0x05, 0x0C, /* USAGE_PAGE (Consumer Devices) */
107 0x09, 0x01, /* USAGE (Consumer Control) */
108 0xA1, 0x01, /* COLLECTION (Application) */
109 0x85, 0x03, /* REPORT_ID = 3 */
110 0x75, 0x10, /* REPORT_SIZE (16) */
111 0x95, 0x02, /* REPORT_COUNT (2) */
112 0x15, 0x01, /* LOGICAL_MIN (1) */
113 0x26, 0x8C, 0x02, /* LOGICAL_MAX (652) */
114 0x19, 0x01, /* USAGE_MIN (1) */
115 0x2A, 0x8C, 0x02, /* USAGE_MAX (652) */
116 0x81, 0x00, /* INPUT (Data Ary Abs) */
117 0xC0, /* END_COLLECTION */
118}; /* */
119
120/* System control descriptor (4) */
121static const char syscontrol_descriptor[] = {
122 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
123 0x09, 0x80, /* USAGE (System Control) */
124 0xA1, 0x01, /* COLLECTION (Application) */
125 0x85, 0x04, /* REPORT_ID = 4 */
126 0x75, 0x02, /* REPORT_SIZE (2) */
127 0x95, 0x01, /* REPORT_COUNT (1) */
128 0x15, 0x01, /* LOGICAL_MIN (1) */
129 0x25, 0x03, /* LOGICAL_MAX (3) */
130 0x09, 0x82, /* USAGE (System Sleep) */
131 0x09, 0x81, /* USAGE (System Power Down) */
132 0x09, 0x83, /* USAGE (System Wake Up) */
133 0x81, 0x60, /* INPUT (Data Ary Abs NPrf Null) */
134 0x75, 0x06, /* REPORT_SIZE (6) */
135 0x81, 0x03, /* INPUT (Cnst Var Abs) */
136 0xC0, /* END_COLLECTION */
137};
138
139/* Media descriptor (8) */
140static const char media_descriptor[] = {
141 0x06, 0xbc, 0xff, /* Usage Page 0xffbc */
142 0x09, 0x88, /* Usage 0x0088 */
143 0xa1, 0x01, /* BeginCollection */
144 0x85, 0x08, /* Report ID 8 */
145 0x19, 0x01, /* Usage Min 0x0001 */
146 0x29, 0xff, /* Usage Max 0x00ff */
147 0x15, 0x01, /* Logical Min 1 */
148 0x26, 0xff, 0x00, /* Logical Max 255 */
149 0x75, 0x08, /* Report Size 8 */
150 0x95, 0x01, /* Report Count 1 */
151 0x81, 0x00, /* Input */
152 0xc0, /* EndCollection */
153}; /* */
154
155/* Maximum size of all defined hid reports in bytes (including report id) */
156#define MAX_REPORT_SIZE 8
157
158/* Number of possible hid report types that can be created by this driver.
159 *
160 * Right now, RF report types have the same report types (or report id's)
161 * than the hid report created from those RF reports. In the future
162 * this doesnt have to be true.
163 *
164 * For instance, RF report type 0x01 which has a size of 8 bytes, corresponds
165 * to hid report id 0x01, this is standard keyboard. Same thing applies to mice
166 * reports and consumer control, etc. If a new RF report is created, it doesn't
167 * has to have the same report id as its corresponding hid report, so an
168 * translation may have to take place for future report types.
169 */
170#define NUMBER_OF_HID_REPORTS 32
171static const u8 hid_reportid_size_map[NUMBER_OF_HID_REPORTS] = {
172 [1] = 8, /* Standard keyboard */
173 [2] = 8, /* Standard mouse */
174 [3] = 5, /* Consumer control */
175 [4] = 2, /* System control */
176 [8] = 2, /* Media Center */
177};
178
179
180#define LOGITECH_DJ_INTERFACE_NUMBER 0x02
181
182static struct hid_ll_driver logi_dj_ll_driver;
183
184static int logi_dj_output_hidraw_report(struct hid_device *hid, u8 * buf,
185 size_t count,
186 unsigned char report_type);
187
188static void logi_dj_recv_destroy_djhid_device(struct dj_receiver_dev *djrcv_dev,
189 struct dj_report *dj_report)
190{
191 /* Called in delayed work context */
192 struct dj_device *dj_dev;
193 unsigned long flags;
194
195 spin_lock_irqsave(&djrcv_dev->lock, flags);
196 dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
197 djrcv_dev->paired_dj_devices[dj_report->device_index] = NULL;
198 spin_unlock_irqrestore(&djrcv_dev->lock, flags);
199
200 if (dj_dev != NULL) {
201 hid_destroy_device(dj_dev->hdev);
202 kfree(dj_dev);
203 } else {
204 dev_err(&djrcv_dev->hdev->dev, "%s: can't destroy a NULL device\n",
205 __func__);
206 }
207}
208
209static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
210 struct dj_report *dj_report)
211{
212 /* Called in delayed work context */
213 struct hid_device *djrcv_hdev = djrcv_dev->hdev;
214 struct usb_interface *intf = to_usb_interface(djrcv_hdev->dev.parent);
215 struct usb_device *usbdev = interface_to_usbdev(intf);
216 struct hid_device *dj_hiddev;
217 struct dj_device *dj_dev;
218
219 /* Device index goes from 1 to 6, we need 3 bytes to store the
220 * semicolon, the index, and a null terminator
221 */
222 unsigned char tmpstr[3];
223
224 if (dj_report->report_params[DEVICE_PAIRED_PARAM_SPFUNCTION] &
225 SPFUNCTION_DEVICE_LIST_EMPTY) {
226 dbg_hid("%s: device list is empty\n", __func__);
227 return;
228 }
229
230 if ((dj_report->device_index < DJ_DEVICE_INDEX_MIN) ||
231 (dj_report->device_index > DJ_DEVICE_INDEX_MAX)) {
232 dev_err(&djrcv_hdev->dev, "%s: invalid device index:%d\n",
233 __func__, dj_report->device_index);
234 return;
235 }
236
237 dj_hiddev = hid_allocate_device();
238 if (IS_ERR(dj_hiddev)) {
239 dev_err(&djrcv_hdev->dev, "%s: hid_allocate_device failed\n",
240 __func__);
241 return;
242 }
243
244 dj_hiddev->ll_driver = &logi_dj_ll_driver;
245 dj_hiddev->hid_output_raw_report = logi_dj_output_hidraw_report;
246
247 dj_hiddev->dev.parent = &djrcv_hdev->dev;
248 dj_hiddev->bus = BUS_USB;
249 dj_hiddev->vendor = le16_to_cpu(usbdev->descriptor.idVendor);
250 dj_hiddev->product = le16_to_cpu(usbdev->descriptor.idProduct);
251 snprintf(dj_hiddev->name, sizeof(dj_hiddev->name),
252 "Logitech Unifying Device. Wireless PID:%02x%02x",
253 dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_MSB],
254 dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_LSB]);
255
256 usb_make_path(usbdev, dj_hiddev->phys, sizeof(dj_hiddev->phys));
257 snprintf(tmpstr, sizeof(tmpstr), ":%d", dj_report->device_index);
258 strlcat(dj_hiddev->phys, tmpstr, sizeof(dj_hiddev->phys));
259
260 dj_dev = kzalloc(sizeof(struct dj_device), GFP_KERNEL);
261
262 if (!dj_dev) {
263 dev_err(&djrcv_hdev->dev, "%s: failed allocating dj_device\n",
264 __func__);
265 goto dj_device_allocate_fail;
266 }
267
268 dj_dev->reports_supported = le32_to_cpu(
269 dj_report->report_params[DEVICE_PAIRED_RF_REPORT_TYPE]);
270 dj_dev->hdev = dj_hiddev;
271 dj_dev->dj_receiver_dev = djrcv_dev;
272 dj_dev->device_index = dj_report->device_index;
273 dj_hiddev->driver_data = dj_dev;
274
275 djrcv_dev->paired_dj_devices[dj_report->device_index] = dj_dev;
276
277 if (hid_add_device(dj_hiddev)) {
278 dev_err(&djrcv_hdev->dev, "%s: failed adding dj_device\n",
279 __func__);
280 goto hid_add_device_fail;
281 }
282
283 return;
284
285hid_add_device_fail:
286 djrcv_dev->paired_dj_devices[dj_report->device_index] = NULL;
287 kfree(dj_dev);
288dj_device_allocate_fail:
289 hid_destroy_device(dj_hiddev);
290}
291
292static void delayedwork_callback(struct work_struct *work)
293{
294 struct dj_receiver_dev *djrcv_dev =
295 container_of(work, struct dj_receiver_dev, work);
296
297 struct dj_report dj_report;
298 unsigned long flags;
299 int count;
300
301 dbg_hid("%s\n", __func__);
302
303 spin_lock_irqsave(&djrcv_dev->lock, flags);
304
305 count = kfifo_out(&djrcv_dev->notif_fifo, &dj_report,
306 sizeof(struct dj_report));
307
308 if (count != sizeof(struct dj_report)) {
309 dev_err(&djrcv_dev->hdev->dev, "%s: workitem triggered without "
310 "notifications available\n", __func__);
311 spin_unlock_irqrestore(&djrcv_dev->lock, flags);
312 return;
313 }
314
315 if (!kfifo_is_empty(&djrcv_dev->notif_fifo)) {
316 if (schedule_work(&djrcv_dev->work) == 0) {
317 dbg_hid("%s: did not schedule the work item, was "
318 "already queued\n", __func__);
319 }
320 }
321
322 spin_unlock_irqrestore(&djrcv_dev->lock, flags);
323
324 switch (dj_report.report_type) {
325 case REPORT_TYPE_NOTIF_DEVICE_PAIRED:
326 logi_dj_recv_add_djhid_device(djrcv_dev, &dj_report);
327 break;
328 case REPORT_TYPE_NOTIF_DEVICE_UNPAIRED:
329 logi_dj_recv_destroy_djhid_device(djrcv_dev, &dj_report);
330 break;
331 default:
332 dbg_hid("%s: unexpected report type\n", __func__);
333 }
334}
335
336static void logi_dj_recv_queue_notification(struct dj_receiver_dev *djrcv_dev,
337 struct dj_report *dj_report)
338{
339 /* We are called from atomic context (tasklet && djrcv->lock held) */
340
341 kfifo_in(&djrcv_dev->notif_fifo, dj_report, sizeof(struct dj_report));
342
343 if (schedule_work(&djrcv_dev->work) == 0) {
344 dbg_hid("%s: did not schedule the work item, was already "
345 "queued\n", __func__);
346 }
347}
348
349static void logi_dj_recv_forward_null_report(struct dj_receiver_dev *djrcv_dev,
350 struct dj_report *dj_report)
351{
352 /* We are called from atomic context (tasklet && djrcv->lock held) */
353 unsigned int i;
354 u8 reportbuffer[MAX_REPORT_SIZE];
355 struct dj_device *djdev;
356
357 djdev = djrcv_dev->paired_dj_devices[dj_report->device_index];
358
359 if (!djdev) {
360 dbg_hid("djrcv_dev->paired_dj_devices[dj_report->device_index]"
361 " is NULL, index %d\n", dj_report->device_index);
362 return;
363 }
364
365 memset(reportbuffer, 0, sizeof(reportbuffer));
366
367 for (i = 0; i < NUMBER_OF_HID_REPORTS; i++) {
368 if (djdev->reports_supported & (1 << i)) {
369 reportbuffer[0] = i;
370 if (hid_input_report(djdev->hdev,
371 HID_INPUT_REPORT,
372 reportbuffer,
373 hid_reportid_size_map[i], 1)) {
374 dbg_hid("hid_input_report error sending null "
375 "report\n");
376 }
377 }
378 }
379}
380
381static void logi_dj_recv_forward_report(struct dj_receiver_dev *djrcv_dev,
382 struct dj_report *dj_report)
383{
384 /* We are called from atomic context (tasklet && djrcv->lock held) */
385 struct dj_device *dj_device;
386
387 dj_device = djrcv_dev->paired_dj_devices[dj_report->device_index];
388
389 if (dj_device == NULL) {
390 dbg_hid("djrcv_dev->paired_dj_devices[dj_report->device_index]"
391 " is NULL, index %d\n", dj_report->device_index);
392 return;
393 }
394
395 if ((dj_report->report_type > ARRAY_SIZE(hid_reportid_size_map) - 1) ||
396 (hid_reportid_size_map[dj_report->report_type] == 0)) {
397 dbg_hid("invalid report type:%x\n", dj_report->report_type);
398 return;
399 }
400
401 if (hid_input_report(dj_device->hdev,
402 HID_INPUT_REPORT, &dj_report->report_type,
403 hid_reportid_size_map[dj_report->report_type], 1)) {
404 dbg_hid("hid_input_report error\n");
405 }
406}
407
408
409static int logi_dj_recv_send_report(struct dj_receiver_dev *djrcv_dev,
410 struct dj_report *dj_report)
411{
412 struct hid_device *hdev = djrcv_dev->hdev;
413 int sent_bytes;
414
415 if (!hdev->hid_output_raw_report) {
416 dev_err(&hdev->dev, "%s:"
417 "hid_output_raw_report is null\n", __func__);
418 return -ENODEV;
419 }
420
421 sent_bytes = hdev->hid_output_raw_report(hdev, (u8 *) dj_report,
422 sizeof(struct dj_report),
423 HID_OUTPUT_REPORT);
424
425 return (sent_bytes < 0) ? sent_bytes : 0;
426}
427
428static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev)
429{
430 struct dj_report dj_report;
431
432 memset(&dj_report, 0, sizeof(dj_report));
433 dj_report.report_id = REPORT_ID_DJ_SHORT;
434 dj_report.device_index = 0xFF;
435 dj_report.report_type = REPORT_TYPE_CMD_GET_PAIRED_DEVICES;
436 return logi_dj_recv_send_report(djrcv_dev, &dj_report);
437}
438
439static int logi_dj_recv_switch_to_dj_mode(struct dj_receiver_dev *djrcv_dev,
440 unsigned timeout)
441{
442 struct dj_report dj_report;
443
444 memset(&dj_report, 0, sizeof(dj_report));
445 dj_report.report_id = REPORT_ID_DJ_SHORT;
446 dj_report.device_index = 0xFF;
447 dj_report.report_type = REPORT_TYPE_CMD_SWITCH;
448 dj_report.report_params[CMD_SWITCH_PARAM_DEVBITFIELD] = 0x1F;
449 dj_report.report_params[CMD_SWITCH_PARAM_TIMEOUT_SECONDS] = (u8)timeout;
450 return logi_dj_recv_send_report(djrcv_dev, &dj_report);
451}
452
453
454static int logi_dj_ll_open(struct hid_device *hid)
455{
456 dbg_hid("%s:%s\n", __func__, hid->phys);
457 return 0;
458
459}
460
461static void logi_dj_ll_close(struct hid_device *hid)
462{
463 dbg_hid("%s:%s\n", __func__, hid->phys);
464}
465
466static int logi_dj_output_hidraw_report(struct hid_device *hid, u8 * buf,
467 size_t count,
468 unsigned char report_type)
469{
470 /* Called by hid raw to send data */
471 dbg_hid("%s\n", __func__);
472
473 return 0;
474}
475
476static int logi_dj_ll_parse(struct hid_device *hid)
477{
478 struct dj_device *djdev = hid->driver_data;
479 int retval;
480
481 dbg_hid("%s\n", __func__);
482
483 djdev->hdev->version = 0x0111;
484 djdev->hdev->country = 0x00;
485
486 if (djdev->reports_supported & STD_KEYBOARD) {
487 dbg_hid("%s: sending a kbd descriptor, reports_supported: %x\n",
488 __func__, djdev->reports_supported);
489 retval = hid_parse_report(hid,
490 (u8 *) kbd_descriptor,
491 sizeof(kbd_descriptor));
492 if (retval) {
493 dbg_hid("%s: sending a kbd descriptor, hid_parse failed"
494 " error: %d\n", __func__, retval);
495 return retval;
496 }
497 }
498
499 if (djdev->reports_supported & STD_MOUSE) {
500 dbg_hid("%s: sending a mouse descriptor, reports_supported: "
501 "%x\n", __func__, djdev->reports_supported);
502 retval = hid_parse_report(hid,
503 (u8 *) mse_descriptor,
504 sizeof(mse_descriptor));
505 if (retval) {
506 dbg_hid("%s: sending a mouse descriptor, hid_parse "
507 "failed error: %d\n", __func__, retval);
508 return retval;
509 }
510 }
511
512 if (djdev->reports_supported & MULTIMEDIA) {
513 dbg_hid("%s: sending a multimedia report descriptor: %x\n",
514 __func__, djdev->reports_supported);
515 retval = hid_parse_report(hid,
516 (u8 *) consumer_descriptor,
517 sizeof(consumer_descriptor));
518 if (retval) {
519 dbg_hid("%s: sending a consumer_descriptor, hid_parse "
520 "failed error: %d\n", __func__, retval);
521 return retval;
522 }
523 }
524
525 if (djdev->reports_supported & POWER_KEYS) {
526 dbg_hid("%s: sending a power keys report descriptor: %x\n",
527 __func__, djdev->reports_supported);
528 retval = hid_parse_report(hid,
529 (u8 *) syscontrol_descriptor,
530 sizeof(syscontrol_descriptor));
531 if (retval) {
532 dbg_hid("%s: sending a syscontrol_descriptor, "
533 "hid_parse failed error: %d\n",
534 __func__, retval);
535 return retval;
536 }
537 }
538
539 if (djdev->reports_supported & MEDIA_CENTER) {
540 dbg_hid("%s: sending a media center report descriptor: %x\n",
541 __func__, djdev->reports_supported);
542 retval = hid_parse_report(hid,
543 (u8 *) media_descriptor,
544 sizeof(media_descriptor));
545 if (retval) {
546 dbg_hid("%s: sending a media_descriptor, hid_parse "
547 "failed error: %d\n", __func__, retval);
548 return retval;
549 }
550 }
551
552 if (djdev->reports_supported & KBD_LEDS) {
553 dbg_hid("%s: need to send kbd leds report descriptor: %x\n",
554 __func__, djdev->reports_supported);
555 }
556
557 return 0;
558}
559
560static int logi_dj_ll_input_event(struct input_dev *dev, unsigned int type,
561 unsigned int code, int value)
562{
563 /* Sent by the input layer to handle leds and Force Feedback */
564 struct hid_device *dj_hiddev = input_get_drvdata(dev);
565 struct dj_device *dj_dev = dj_hiddev->driver_data;
566
567 struct dj_receiver_dev *djrcv_dev =
568 dev_get_drvdata(dj_hiddev->dev.parent);
569 struct hid_device *dj_rcv_hiddev = djrcv_dev->hdev;
570 struct hid_report_enum *output_report_enum;
571
572 struct hid_field *field;
573 struct hid_report *report;
574 unsigned char data[8];
575 int offset;
576
577 dbg_hid("%s: %s, type:%d | code:%d | value:%d\n",
578 __func__, dev->phys, type, code, value);
579
580 if (type != EV_LED)
581 return -1;
582
583 offset = hidinput_find_field(dj_hiddev, type, code, &field);
584
585 if (offset == -1) {
586 dev_warn(&dev->dev, "event field not found\n");
587 return -1;
588 }
589 hid_set_field(field, offset, value);
590 hid_output_report(field->report, &data[0]);
591
592 output_report_enum = &dj_rcv_hiddev->report_enum[HID_OUTPUT_REPORT];
593 report = output_report_enum->report_id_hash[REPORT_ID_DJ_SHORT];
594 hid_set_field(report->field[0], 0, dj_dev->device_index);
595 hid_set_field(report->field[0], 1, REPORT_TYPE_LEDS);
596 hid_set_field(report->field[0], 2, data[1]);
597
598 usbhid_submit_report(dj_rcv_hiddev, report, USB_DIR_OUT);
599
600 return 0;
601
602}
603
604static int logi_dj_ll_start(struct hid_device *hid)
605{
606 dbg_hid("%s\n", __func__);
607 return 0;
608}
609
610static void logi_dj_ll_stop(struct hid_device *hid)
611{
612 dbg_hid("%s\n", __func__);
613}
614
615
616static struct hid_ll_driver logi_dj_ll_driver = {
617 .parse = logi_dj_ll_parse,
618 .start = logi_dj_ll_start,
619 .stop = logi_dj_ll_stop,
620 .open = logi_dj_ll_open,
621 .close = logi_dj_ll_close,
622 .hidinput_input_event = logi_dj_ll_input_event,
623};
624
625
626static int logi_dj_raw_event(struct hid_device *hdev,
627 struct hid_report *report, u8 *data,
628 int size)
629{
630 struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
631 struct dj_report *dj_report = (struct dj_report *) data;
632 unsigned long flags;
633 bool report_processed = false;
634
635 dbg_hid("%s, size:%d\n", __func__, size);
636
637 /* Here we receive all data coming from iface 2, there are 4 cases:
638 *
639 * 1) Data should continue its normal processing i.e. data does not
640 * come from the DJ collection, in which case we do nothing and
641 * return 0, so hid-core can continue normal processing (will forward
642 * to associated hidraw device)
643 *
644 * 2) Data is from DJ collection, and is intended for this driver i. e.
645 * data contains arrival, departure, etc notifications, in which case
646 * we queue them for delayed processing by the work queue. We return 1
647 * to hid-core as no further processing is required from it.
648 *
649 * 3) Data is from DJ collection, and informs a connection change,
650 * if the change means rf link loss, then we must send a null report
651 * to the upper layer to discard potentially pressed keys that may be
652 * repeated forever by the input layer. Return 1 to hid-core as no
653 * further processing is required.
654 *
655 * 4) Data is from DJ collection and is an actual input event from
656 * a paired DJ device in which case we forward it to the correct hid
657 * device (via hid_input_report() ) and return 1 so hid-core does not do
658 * anything else with it.
659 */
660
661 spin_lock_irqsave(&djrcv_dev->lock, flags);
662 if (dj_report->report_id == REPORT_ID_DJ_SHORT) {
663 switch (dj_report->report_type) {
664 case REPORT_TYPE_NOTIF_DEVICE_PAIRED:
665 case REPORT_TYPE_NOTIF_DEVICE_UNPAIRED:
666 logi_dj_recv_queue_notification(djrcv_dev, dj_report);
667 break;
668 case REPORT_TYPE_NOTIF_CONNECTION_STATUS:
669 if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
670 STATUS_LINKLOSS) {
671 logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
672 }
673 break;
674 default:
675 logi_dj_recv_forward_report(djrcv_dev, dj_report);
676 }
677 report_processed = true;
678 }
679 spin_unlock_irqrestore(&djrcv_dev->lock, flags);
680
681 return report_processed;
682}
683
684static int logi_dj_probe(struct hid_device *hdev,
685 const struct hid_device_id *id)
686{
687 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
688 struct dj_receiver_dev *djrcv_dev;
689 int retval;
690
691 if (is_dj_device((struct dj_device *)hdev->driver_data))
692 return -ENODEV;
693
694 dbg_hid("%s called for ifnum %d\n", __func__,
695 intf->cur_altsetting->desc.bInterfaceNumber);
696
697 /* Ignore interfaces 0 and 1, they will not carry any data, dont create
698 * any hid_device for them */
699 if (intf->cur_altsetting->desc.bInterfaceNumber !=
700 LOGITECH_DJ_INTERFACE_NUMBER) {
701 dbg_hid("%s: ignoring ifnum %d\n", __func__,
702 intf->cur_altsetting->desc.bInterfaceNumber);
703 return -ENODEV;
704 }
705
706 /* Treat interface 2 */
707
708 djrcv_dev = kzalloc(sizeof(struct dj_receiver_dev), GFP_KERNEL);
709 if (!djrcv_dev) {
710 dev_err(&hdev->dev,
711 "%s:failed allocating dj_receiver_dev\n", __func__);
712 return -ENOMEM;
713 }
714 djrcv_dev->hdev = hdev;
715 INIT_WORK(&djrcv_dev->work, delayedwork_callback);
716 spin_lock_init(&djrcv_dev->lock);
717 if (kfifo_alloc(&djrcv_dev->notif_fifo,
718 DJ_MAX_NUMBER_NOTIFICATIONS * sizeof(struct dj_report),
719 GFP_KERNEL)) {
720 dev_err(&hdev->dev,
721 "%s:failed allocating notif_fifo\n", __func__);
722 kfree(djrcv_dev);
723 return -ENOMEM;
724 }
725 hid_set_drvdata(hdev, djrcv_dev);
726
727 /* Call to usbhid to fetch the HID descriptors of interface 2 and
728 * subsequently call to the hid/hid-core to parse the fetched
729 * descriptors, this will in turn create the hidraw and hiddev nodes
730 * for interface 2 of the receiver */
731 retval = hid_parse(hdev);
732 if (retval) {
733 dev_err(&hdev->dev,
734 "%s:parse of interface 2 failed\n", __func__);
735 goto hid_parse_fail;
736 }
737
738 /* Starts the usb device and connects to upper interfaces hiddev and
739 * hidraw */
740 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
741 if (retval) {
742 dev_err(&hdev->dev,
743 "%s:hid_hw_start returned error\n", __func__);
744 goto hid_hw_start_fail;
745 }
746
747 retval = logi_dj_recv_switch_to_dj_mode(djrcv_dev, 0);
748 if (retval < 0) {
749 dev_err(&hdev->dev,
750 "%s:logi_dj_recv_switch_to_dj_mode returned error:%d\n",
751 __func__, retval);
752 goto switch_to_dj_mode_fail;
753 }
754
755 /* This is enabling the polling urb on the IN endpoint */
756 retval = hdev->ll_driver->open(hdev);
757 if (retval < 0) {
758 dev_err(&hdev->dev, "%s:hdev->ll_driver->open returned "
759 "error:%d\n", __func__, retval);
760 goto llopen_failed;
761 }
762
763 retval = logi_dj_recv_query_paired_devices(djrcv_dev);
764 if (retval < 0) {
765 dev_err(&hdev->dev, "%s:logi_dj_recv_query_paired_devices "
766 "error:%d\n", __func__, retval);
767 goto logi_dj_recv_query_paired_devices_failed;
768 }
769
770 return retval;
771
772logi_dj_recv_query_paired_devices_failed:
773 hdev->ll_driver->close(hdev);
774
775llopen_failed:
776switch_to_dj_mode_fail:
777 hid_hw_stop(hdev);
778
779hid_hw_start_fail:
780hid_parse_fail:
781 kfifo_free(&djrcv_dev->notif_fifo);
782 kfree(djrcv_dev);
783 hid_set_drvdata(hdev, NULL);
784 return retval;
785
786}
787
788#ifdef CONFIG_PM
789static int logi_dj_reset_resume(struct hid_device *hdev)
790{
791 int retval;
792 struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
793
794 retval = logi_dj_recv_switch_to_dj_mode(djrcv_dev, 0);
795 if (retval < 0) {
796 dev_err(&hdev->dev,
797 "%s:logi_dj_recv_switch_to_dj_mode returned error:%d\n",
798 __func__, retval);
799 }
800
801 return 0;
802}
803#endif
804
805static void logi_dj_remove(struct hid_device *hdev)
806{
807 struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
808 struct dj_device *dj_dev;
809 int i;
810
811 dbg_hid("%s\n", __func__);
812
813 cancel_work_sync(&djrcv_dev->work);
814
815 hdev->ll_driver->close(hdev);
816 hid_hw_stop(hdev);
817
818 /* I suppose that at this point the only context that can access
819 * the djrecv_data is this thread as the work item is guaranteed to
820 * have finished and no more raw_event callbacks should arrive after
821 * the remove callback was triggered so no locks are put around the
822 * code below */
823 for (i = 0; i < (DJ_MAX_PAIRED_DEVICES + DJ_DEVICE_INDEX_MIN); i++) {
824 dj_dev = djrcv_dev->paired_dj_devices[i];
825 if (dj_dev != NULL) {
826 hid_destroy_device(dj_dev->hdev);
827 kfree(dj_dev);
828 djrcv_dev->paired_dj_devices[i] = NULL;
829 }
830 }
831
832 kfifo_free(&djrcv_dev->notif_fifo);
833 kfree(djrcv_dev);
834 hid_set_drvdata(hdev, NULL);
835}
836
837static int logi_djdevice_probe(struct hid_device *hdev,
838 const struct hid_device_id *id)
839{
840 int ret;
841 struct dj_device *dj_dev = hdev->driver_data;
842
843 if (!is_dj_device(dj_dev))
844 return -ENODEV;
845
846 ret = hid_parse(hdev);
847 if (!ret)
848 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
849
850 return ret;
851}
852
853static const struct hid_device_id logi_dj_receivers[] = {
854 {HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
855 USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER)},
856 {HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
857 USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2)},
858 {}
859};
860
861MODULE_DEVICE_TABLE(hid, logi_dj_receivers);
862
863static struct hid_driver logi_djreceiver_driver = {
864 .name = "logitech-djreceiver",
865 .id_table = logi_dj_receivers,
866 .probe = logi_dj_probe,
867 .remove = logi_dj_remove,
868 .raw_event = logi_dj_raw_event,
869#ifdef CONFIG_PM
870 .reset_resume = logi_dj_reset_resume,
871#endif
872};
873
874
875static const struct hid_device_id logi_dj_devices[] = {
876 {HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
877 USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER)},
878 {HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
879 USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2)},
880 {}
881};
882
883static struct hid_driver logi_djdevice_driver = {
884 .name = "logitech-djdevice",
885 .id_table = logi_dj_devices,
886 .probe = logi_djdevice_probe,
887};
888
889
890static int __init logi_dj_init(void)
891{
892 int retval;
893
894 dbg_hid("Logitech-DJ:%s\n", __func__);
895
896 retval = hid_register_driver(&logi_djreceiver_driver);
897 if (retval)
898 return retval;
899
900 retval = hid_register_driver(&logi_djdevice_driver);
901 if (retval)
902 hid_unregister_driver(&logi_djreceiver_driver);
903
904 return retval;
905
906}
907
908static void __exit logi_dj_exit(void)
909{
910 dbg_hid("Logitech-DJ:%s\n", __func__);
911
912 hid_unregister_driver(&logi_djdevice_driver);
913 hid_unregister_driver(&logi_djreceiver_driver);
914
915}
916
917module_init(logi_dj_init);
918module_exit(logi_dj_exit);
919MODULE_LICENSE("GPL");
920MODULE_AUTHOR("Logitech");
921MODULE_AUTHOR("Nestor Lopez Casado");
922MODULE_AUTHOR("nlopezcasad@logitech.com");
diff --git a/drivers/hid/hid-logitech-dj.h b/drivers/hid/hid-logitech-dj.h
new file mode 100644
index 000000000000..fd28a5e0ca3b
--- /dev/null
+++ b/drivers/hid/hid-logitech-dj.h
@@ -0,0 +1,123 @@
1#ifndef __HID_LOGITECH_DJ_H
2#define __HID_LOGITECH_DJ_H
3
4/*
5 * HID driver for Logitech Unifying receivers
6 *
7 * Copyright (c) 2011 Logitech
8 */
9
10/*
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25
26#include <linux/kfifo.h>
27
28#define DJ_MAX_PAIRED_DEVICES 6
29#define DJ_MAX_NUMBER_NOTIFICATIONS 8
30#define DJ_DEVICE_INDEX_MIN 1
31#define DJ_DEVICE_INDEX_MAX 6
32
33#define DJREPORT_SHORT_LENGTH 15
34#define DJREPORT_LONG_LENGTH 32
35
36#define REPORT_ID_DJ_SHORT 0x20
37#define REPORT_ID_DJ_LONG 0x21
38
39#define REPORT_TYPE_RFREPORT_FIRST 0x01
40#define REPORT_TYPE_RFREPORT_LAST 0x1F
41
42/* Command Switch to DJ mode */
43#define REPORT_TYPE_CMD_SWITCH 0x80
44#define CMD_SWITCH_PARAM_DEVBITFIELD 0x00
45#define CMD_SWITCH_PARAM_TIMEOUT_SECONDS 0x01
46#define TIMEOUT_NO_KEEPALIVE 0x00
47
48/* Command to Get the list of Paired devices */
49#define REPORT_TYPE_CMD_GET_PAIRED_DEVICES 0x81
50
51/* Device Paired Notification */
52#define REPORT_TYPE_NOTIF_DEVICE_PAIRED 0x41
53#define SPFUNCTION_MORE_NOTIF_EXPECTED 0x01
54#define SPFUNCTION_DEVICE_LIST_EMPTY 0x02
55#define DEVICE_PAIRED_PARAM_SPFUNCTION 0x00
56#define DEVICE_PAIRED_PARAM_EQUAD_ID_LSB 0x01
57#define DEVICE_PAIRED_PARAM_EQUAD_ID_MSB 0x02
58#define DEVICE_PAIRED_RF_REPORT_TYPE 0x03
59
60/* Device Un-Paired Notification */
61#define REPORT_TYPE_NOTIF_DEVICE_UNPAIRED 0x40
62
63
64/* Connection Status Notification */
65#define REPORT_TYPE_NOTIF_CONNECTION_STATUS 0x42
66#define CONNECTION_STATUS_PARAM_STATUS 0x00
67#define STATUS_LINKLOSS 0x01
68
69/* Error Notification */
70#define REPORT_TYPE_NOTIF_ERROR 0x7F
71#define NOTIF_ERROR_PARAM_ETYPE 0x00
72#define ETYPE_KEEPALIVE_TIMEOUT 0x01
73
74/* supported DJ HID && RF report types */
75#define REPORT_TYPE_KEYBOARD 0x01
76#define REPORT_TYPE_MOUSE 0x02
77#define REPORT_TYPE_CONSUMER_CONTROL 0x03
78#define REPORT_TYPE_SYSTEM_CONTROL 0x04
79#define REPORT_TYPE_MEDIA_CENTER 0x08
80#define REPORT_TYPE_LEDS 0x0E
81
82/* RF Report types bitfield */
83#define STD_KEYBOARD 0x00000002
84#define STD_MOUSE 0x00000004
85#define MULTIMEDIA 0x00000008
86#define POWER_KEYS 0x00000010
87#define MEDIA_CENTER 0x00000100
88#define KBD_LEDS 0x00004000
89
90struct dj_report {
91 u8 report_id;
92 u8 device_index;
93 u8 report_type;
94 u8 report_params[DJREPORT_SHORT_LENGTH - 3];
95};
96
97struct dj_receiver_dev {
98 struct hid_device *hdev;
99 struct dj_device *paired_dj_devices[DJ_MAX_PAIRED_DEVICES +
100 DJ_DEVICE_INDEX_MIN];
101 struct work_struct work;
102 struct kfifo notif_fifo;
103 spinlock_t lock;
104};
105
106struct dj_device {
107 struct hid_device *hdev;
108 struct dj_receiver_dev *dj_receiver_dev;
109 u32 reports_supported;
110 u8 device_index;
111};
112
113/**
114 * is_dj_device - know if the given dj_device is not the receiver.
115 * @dj_dev: the dj device to test
116 *
117 * This macro tests if a struct dj_device pointer is a device created
118 * by the bus enumarator.
119 */
120#define is_dj_device(dj_dev) \
121 (&(dj_dev)->dj_receiver_dev->hdev->dev == (dj_dev)->hdev->dev.parent)
122
123#endif
diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c
index f0fbd7bd239e..2ab71758e2e2 100644
--- a/drivers/hid/hid-magicmouse.c
+++ b/drivers/hid/hid-magicmouse.c
@@ -405,6 +405,13 @@ static void magicmouse_setup_input(struct input_dev *input, struct hid_device *h
405 __set_bit(REL_HWHEEL, input->relbit); 405 __set_bit(REL_HWHEEL, input->relbit);
406 } 406 }
407 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */ 407 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
408 /* input->keybit is initialized with incorrect button info
409 * for Magic Trackpad. There really is only one physical
410 * button (BTN_LEFT == BTN_MOUSE). Make sure we don't
411 * advertise buttons that don't exist...
412 */
413 __clear_bit(BTN_RIGHT, input->keybit);
414 __clear_bit(BTN_MIDDLE, input->keybit);
408 __set_bit(BTN_MOUSE, input->keybit); 415 __set_bit(BTN_MOUSE, input->keybit);
409 __set_bit(BTN_TOOL_FINGER, input->keybit); 416 __set_bit(BTN_TOOL_FINGER, input->keybit);
410 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit); 417 __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index 58d0e7aaf088..fa5d7a1ffa9e 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -47,10 +47,11 @@ MODULE_LICENSE("GPL");
47#define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1) 47#define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1)
48#define MT_QUIRK_CYPRESS (1 << 2) 48#define MT_QUIRK_CYPRESS (1 << 2)
49#define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3) 49#define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3)
50#define MT_QUIRK_VALID_IS_INRANGE (1 << 4) 50#define MT_QUIRK_ALWAYS_VALID (1 << 4)
51#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 5) 51#define MT_QUIRK_VALID_IS_INRANGE (1 << 5)
52#define MT_QUIRK_EGALAX_XYZ_FIXUP (1 << 6) 52#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 6)
53#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 7) 53#define MT_QUIRK_EGALAX_XYZ_FIXUP (1 << 7)
54#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 8)
54 55
55struct mt_slot { 56struct mt_slot {
56 __s32 x, y, p, w, h; 57 __s32 x, y, p, w, h;
@@ -86,11 +87,12 @@ struct mt_class {
86/* classes of device behavior */ 87/* classes of device behavior */
87#define MT_CLS_DEFAULT 0x0001 88#define MT_CLS_DEFAULT 0x0001
88 89
89#define MT_CLS_CONFIDENCE 0x0002 90#define MT_CLS_SERIAL 0x0002
90#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0003 91#define MT_CLS_CONFIDENCE 0x0003
91#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0004 92#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0004
92#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0005 93#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0005
93#define MT_CLS_DUAL_NSMU_CONTACTID 0x0006 94#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0006
95#define MT_CLS_DUAL_NSMU_CONTACTID 0x0007
94 96
95/* vendor specific classes */ 97/* vendor specific classes */
96#define MT_CLS_3M 0x0101 98#define MT_CLS_3M 0x0101
@@ -134,6 +136,8 @@ static int find_slot_from_contactid(struct mt_device *td)
134struct mt_class mt_classes[] = { 136struct mt_class mt_classes[] = {
135 { .name = MT_CLS_DEFAULT, 137 { .name = MT_CLS_DEFAULT,
136 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP }, 138 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
139 { .name = MT_CLS_SERIAL,
140 .quirks = MT_QUIRK_ALWAYS_VALID},
137 { .name = MT_CLS_CONFIDENCE, 141 { .name = MT_CLS_CONFIDENCE,
138 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE }, 142 .quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
139 { .name = MT_CLS_CONFIDENCE_MINUS_ONE, 143 { .name = MT_CLS_CONFIDENCE_MINUS_ONE,
@@ -213,6 +217,16 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
213 struct mt_class *cls = td->mtclass; 217 struct mt_class *cls = td->mtclass;
214 __s32 quirks = cls->quirks; 218 __s32 quirks = cls->quirks;
215 219
220 /* Only map fields from TouchScreen or TouchPad collections.
221 * We need to ignore fields that belong to other collections
222 * such as Mouse that might have the same GenericDesktop usages. */
223 if (field->application == HID_DG_TOUCHSCREEN)
224 set_bit(INPUT_PROP_DIRECT, hi->input->propbit);
225 else if (field->application == HID_DG_TOUCHPAD)
226 set_bit(INPUT_PROP_POINTER, hi->input->propbit);
227 else
228 return 0;
229
216 switch (usage->hid & HID_USAGE_PAGE) { 230 switch (usage->hid & HID_USAGE_PAGE) {
217 231
218 case HID_UP_GENDESK: 232 case HID_UP_GENDESK:
@@ -277,6 +291,7 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
277 td->last_slot_field = usage->hid; 291 td->last_slot_field = usage->hid;
278 td->last_field_index = field->index; 292 td->last_field_index = field->index;
279 td->last_mt_collection = usage->collection_index; 293 td->last_mt_collection = usage->collection_index;
294 hdev->quirks &= ~HID_QUIRK_MULTITOUCH;
280 return 1; 295 return 1;
281 case HID_DG_WIDTH: 296 case HID_DG_WIDTH:
282 hid_map_usage(hi, usage, bit, max, 297 hid_map_usage(hi, usage, bit, max,
@@ -435,7 +450,9 @@ static int mt_event(struct hid_device *hid, struct hid_field *field,
435 if (hid->claimed & HID_CLAIMED_INPUT && td->slots) { 450 if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
436 switch (usage->hid) { 451 switch (usage->hid) {
437 case HID_DG_INRANGE: 452 case HID_DG_INRANGE:
438 if (quirks & MT_QUIRK_VALID_IS_INRANGE) 453 if (quirks & MT_QUIRK_ALWAYS_VALID)
454 td->curvalid = true;
455 else if (quirks & MT_QUIRK_VALID_IS_INRANGE)
439 td->curvalid = value; 456 td->curvalid = value;
440 break; 457 break;
441 case HID_DG_TIPSWITCH: 458 case HID_DG_TIPSWITCH:
@@ -513,12 +530,44 @@ static void mt_set_input_mode(struct hid_device *hdev)
513 } 530 }
514} 531}
515 532
533/* a list of devices for which there is a specialized multitouch driver */
534static const struct hid_device_id mt_have_special_driver[] = {
535 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, 0x0001) },
536 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, 0x0006) },
537 { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
538 USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
539 { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
540 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
541 { }
542};
543
544static bool mt_match_one_id(struct hid_device *hdev,
545 const struct hid_device_id *id)
546{
547 return id->bus == hdev->bus &&
548 (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
549 (id->product == HID_ANY_ID || id->product == hdev->product);
550}
551
552static const struct hid_device_id *mt_match_id(struct hid_device *hdev,
553 const struct hid_device_id *id)
554{
555 for (; id->bus; id++)
556 if (mt_match_one_id(hdev, id))
557 return id;
558
559 return NULL;
560}
561
516static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) 562static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
517{ 563{
518 int ret, i; 564 int ret, i;
519 struct mt_device *td; 565 struct mt_device *td;
520 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */ 566 struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
521 567
568 if (mt_match_id(hdev, mt_have_special_driver))
569 return -ENODEV;
570
522 for (i = 0; mt_classes[i].name ; i++) { 571 for (i = 0; mt_classes[i].name ; i++) {
523 if (id->driver_data == mt_classes[i].name) { 572 if (id->driver_data == mt_classes[i].name) {
524 mtclass = &(mt_classes[i]); 573 mtclass = &(mt_classes[i]);
@@ -526,10 +575,6 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
526 } 575 }
527 } 576 }
528 577
529 /* This allows the driver to correctly support devices
530 * that emit events over several HID messages.
531 */
532 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
533 578
534 td = kzalloc(sizeof(struct mt_device), GFP_KERNEL); 579 td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
535 if (!td) { 580 if (!td) {
@@ -545,10 +590,16 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
545 if (ret != 0) 590 if (ret != 0)
546 goto fail; 591 goto fail;
547 592
593 hdev->quirks |= HID_QUIRK_MULTITOUCH;
548 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 594 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
549 if (ret) 595 if (ret)
550 goto fail; 596 goto fail;
551 597
598 /* This allows the driver to correctly support devices
599 * that emit events over several HID messages.
600 */
601 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
602
552 td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot), 603 td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
553 GFP_KERNEL); 604 GFP_KERNEL);
554 if (!td->slots) { 605 if (!td->slots) {
@@ -662,6 +713,11 @@ static const struct hid_device_id mt_devices[] = {
662 HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, 713 HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH,
663 USB_DEVICE_ID_GOODTOUCH_000f) }, 714 USB_DEVICE_ID_GOODTOUCH_000f) },
664 715
716 /* Ideacom panel */
717 { .driver_data = MT_CLS_SERIAL,
718 HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
719 USB_DEVICE_ID_IDEACOM_IDC6650) },
720
665 /* Ilitek dual touch panel */ 721 /* Ilitek dual touch panel */
666 { .driver_data = MT_CLS_DEFAULT, 722 { .driver_data = MT_CLS_DEFAULT,
667 HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, 723 HID_USB_DEVICE(USB_VENDOR_ID_ILITEK,
@@ -672,6 +728,11 @@ static const struct hid_device_id mt_devices[] = {
672 HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, 728 HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
673 USB_DEVICE_ID_IRTOUCH_INFRARED_USB) }, 729 USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
674 730
731 /* LG Display panels */
732 { .driver_data = MT_CLS_DEFAULT,
733 HID_USB_DEVICE(USB_VENDOR_ID_LG,
734 USB_DEVICE_ID_LG_MULTITOUCH) },
735
675 /* Lumio panels */ 736 /* Lumio panels */
676 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 737 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
677 HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, 738 HID_USB_DEVICE(USB_VENDOR_ID_LUMIO,
@@ -732,6 +793,10 @@ static const struct hid_device_id mt_devices[] = {
732 HID_USB_DEVICE(USB_VENDOR_ID_XAT, 793 HID_USB_DEVICE(USB_VENDOR_ID_XAT,
733 USB_DEVICE_ID_XAT_CSR) }, 794 USB_DEVICE_ID_XAT_CSR) },
734 795
796 /* Rest of the world */
797 { .driver_data = MT_CLS_DEFAULT,
798 HID_USB_DEVICE(HID_ANY_ID, HID_ANY_ID) },
799
735 { } 800 { }
736}; 801};
737MODULE_DEVICE_TABLE(hid, mt_devices); 802MODULE_DEVICE_TABLE(hid, mt_devices);
diff --git a/drivers/hid/hid-primax.c b/drivers/hid/hid-primax.c
new file mode 100644
index 000000000000..4d3c60d88318
--- /dev/null
+++ b/drivers/hid/hid-primax.c
@@ -0,0 +1,117 @@
1/*
2 * HID driver for primax and similar keyboards with in-band modifiers
3 *
4 * Copyright 2011 Google Inc. All Rights Reserved
5 *
6 * Author:
7 * Terry Lambert <tlambert@google.com>
8 *
9 * This software is licensed under the terms of the GNU General Public
10 * License version 2, as published by the Free Software Foundation, and
11 * may be copied, distributed, and modified under those terms.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 */
18
19#include <linux/device.h>
20#include <linux/hid.h>
21#include <linux/module.h>
22
23#include "hid-ids.h"
24
25static int px_raw_event(struct hid_device *hid, struct hid_report *report,
26 u8 *data, int size)
27{
28 int idx = size;
29
30 switch (report->id) {
31 case 0: /* keyboard input */
32 /*
33 * Convert in-band modifier key values into out of band
34 * modifier bits and pull the key strokes from the report.
35 * Thus a report data set which looked like:
36 *
37 * [00][00][E0][30][00][00][00][00]
38 * (no modifier bits + "Left Shift" key + "1" key)
39 *
40 * Would be converted to:
41 *
42 * [01][00][00][30][00][00][00][00]
43 * (Left Shift modifier bit + "1" key)
44 *
45 * As long as it's in the size range, the upper level
46 * drivers don't particularly care if there are in-band
47 * 0-valued keys, so they don't stop parsing.
48 */
49 while (--idx > 1) {
50 if (data[idx] < 0xE0 || data[idx] > 0xE7)
51 continue;
52 data[0] |= (1 << (data[idx] - 0xE0));
53 data[idx] = 0;
54 }
55 hid_report_raw_event(hid, HID_INPUT_REPORT, data, size, 0);
56 return 1;
57
58 default: /* unknown report */
59 /* Unknown report type; pass upstream */
60 hid_info(hid, "unknown report type %d\n", report->id);
61 break;
62 }
63
64 return 0;
65}
66
67static int px_probe(struct hid_device *hid, const struct hid_device_id *id)
68{
69 int ret;
70
71 ret = hid_parse(hid);
72 if (ret) {
73 hid_err(hid, "parse failed\n");
74 goto fail;
75 }
76
77 ret = hid_hw_start(hid, HID_CONNECT_DEFAULT);
78 if (ret)
79 hid_err(hid, "hw start failed\n");
80
81fail:
82 return ret;
83}
84
85static void px_remove(struct hid_device *hid)
86{
87 hid_hw_stop(hid);
88}
89
90static const struct hid_device_id px_devices[] = {
91 { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
92 { }
93};
94MODULE_DEVICE_TABLE(hid, px_devices);
95
96static struct hid_driver px_driver = {
97 .name = "primax",
98 .id_table = px_devices,
99 .raw_event = px_raw_event,
100 .probe = px_probe,
101 .remove = px_remove,
102};
103
104static int __init px_init(void)
105{
106 return hid_register_driver(&px_driver);
107}
108
109static void __exit px_exit(void)
110{
111 hid_unregister_driver(&px_driver);
112}
113
114module_init(px_init);
115module_exit(px_exit);
116MODULE_AUTHOR("Terry Lambert <tlambert@google.com>");
117MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-prodikeys.c b/drivers/hid/hid-prodikeys.c
index 158b389d0fb7..f779009104eb 100644
--- a/drivers/hid/hid-prodikeys.c
+++ b/drivers/hid/hid-prodikeys.c
@@ -816,7 +816,7 @@ static int pk_probe(struct hid_device *hdev, const struct hid_device_id *id)
816 if (pm == NULL) { 816 if (pm == NULL) {
817 hid_err(hdev, "can't alloc descriptor\n"); 817 hid_err(hdev, "can't alloc descriptor\n");
818 ret = -ENOMEM; 818 ret = -ENOMEM;
819 goto err_free; 819 goto err_free_pk;
820 } 820 }
821 821
822 pm->pk = pk; 822 pm->pk = pk;
@@ -849,10 +849,10 @@ static int pk_probe(struct hid_device *hdev, const struct hid_device_id *id)
849err_stop: 849err_stop:
850 hid_hw_stop(hdev); 850 hid_hw_stop(hdev);
851err_free: 851err_free:
852 if (pm != NULL) 852 kfree(pm);
853 kfree(pm); 853err_free_pk:
854
855 kfree(pk); 854 kfree(pk);
855
856 return ret; 856 return ret;
857} 857}
858 858
diff --git a/drivers/hid/hid-roccat-kone.c b/drivers/hid/hid-roccat-kone.c
index 2b8f3a31ffb3..e2072afb34bb 100644
--- a/drivers/hid/hid-roccat-kone.c
+++ b/drivers/hid/hid-roccat-kone.c
@@ -37,6 +37,21 @@
37 37
38static uint profile_numbers[5] = {0, 1, 2, 3, 4}; 38static uint profile_numbers[5] = {0, 1, 2, 3, 4};
39 39
40static void kone_profile_activated(struct kone_device *kone, uint new_profile)
41{
42 kone->actual_profile = new_profile;
43 kone->actual_dpi = kone->profiles[new_profile - 1].startup_dpi;
44}
45
46static void kone_profile_report(struct kone_device *kone, uint new_profile)
47{
48 struct kone_roccat_report roccat_report;
49 roccat_report.event = kone_mouse_event_switch_profile;
50 roccat_report.value = new_profile;
51 roccat_report.key = 0;
52 roccat_report_event(kone->chrdev_minor, (uint8_t *)&roccat_report);
53}
54
40static int kone_receive(struct usb_device *usb_dev, uint usb_command, 55static int kone_receive(struct usb_device *usb_dev, uint usb_command,
41 void *data, uint size) 56 void *data, uint size)
42{ 57{
@@ -283,7 +298,7 @@ static ssize_t kone_sysfs_write_settings(struct file *fp, struct kobject *kobj,
283 container_of(kobj, struct device, kobj)->parent->parent; 298 container_of(kobj, struct device, kobj)->parent->parent;
284 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev)); 299 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
285 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 300 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
286 int retval = 0, difference; 301 int retval = 0, difference, old_profile;
287 302
288 /* I need to get my data in one piece */ 303 /* I need to get my data in one piece */
289 if (off != 0 || count != sizeof(struct kone_settings)) 304 if (off != 0 || count != sizeof(struct kone_settings))
@@ -294,21 +309,20 @@ static ssize_t kone_sysfs_write_settings(struct file *fp, struct kobject *kobj,
294 if (difference) { 309 if (difference) {
295 retval = kone_set_settings(usb_dev, 310 retval = kone_set_settings(usb_dev,
296 (struct kone_settings const *)buf); 311 (struct kone_settings const *)buf);
297 if (!retval) 312 if (retval) {
298 memcpy(&kone->settings, buf, 313 mutex_unlock(&kone->kone_lock);
299 sizeof(struct kone_settings)); 314 return retval;
300 } 315 }
301 mutex_unlock(&kone->kone_lock);
302 316
303 if (retval) 317 old_profile = kone->settings.startup_profile;
304 return retval; 318 memcpy(&kone->settings, buf, sizeof(struct kone_settings));
305 319
306 /* 320 kone_profile_activated(kone, kone->settings.startup_profile);
307 * If we get here, treat settings as okay and update actual values 321
308 * according to startup_profile 322 if (kone->settings.startup_profile != old_profile)
309 */ 323 kone_profile_report(kone, kone->settings.startup_profile);
310 kone->actual_profile = kone->settings.startup_profile; 324 }
311 kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi; 325 mutex_unlock(&kone->kone_lock);
312 326
313 return sizeof(struct kone_settings); 327 return sizeof(struct kone_settings);
314} 328}
@@ -501,6 +515,8 @@ static ssize_t kone_sysfs_set_tcu(struct device *dev,
501 goto exit_no_settings; 515 goto exit_no_settings;
502 goto exit_unlock; 516 goto exit_unlock;
503 } 517 }
518 /* calibration resets profile */
519 kone_profile_activated(kone, kone->settings.startup_profile);
504 } 520 }
505 521
506 retval = size; 522 retval = size;
@@ -544,16 +560,16 @@ static ssize_t kone_sysfs_set_startup_profile(struct device *dev,
544 kone_set_settings_checksum(&kone->settings); 560 kone_set_settings_checksum(&kone->settings);
545 561
546 retval = kone_set_settings(usb_dev, &kone->settings); 562 retval = kone_set_settings(usb_dev, &kone->settings);
547 563 if (retval) {
548 mutex_unlock(&kone->kone_lock); 564 mutex_unlock(&kone->kone_lock);
549
550 if (retval)
551 return retval; 565 return retval;
566 }
552 567
553 /* changing the startup profile immediately activates this profile */ 568 /* changing the startup profile immediately activates this profile */
554 kone->actual_profile = new_startup_profile; 569 kone_profile_activated(kone, new_startup_profile);
555 kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi; 570 kone_profile_report(kone, new_startup_profile);
556 571
572 mutex_unlock(&kone->kone_lock);
557 return size; 573 return size;
558} 574}
559 575
@@ -665,8 +681,7 @@ static int kone_init_kone_device_struct(struct usb_device *usb_dev,
665 if (retval) 681 if (retval)
666 return retval; 682 return retval;
667 683
668 kone->actual_profile = kone->settings.startup_profile; 684 kone_profile_activated(kone, kone->settings.startup_profile);
669 kone->actual_dpi = kone->profiles[kone->actual_profile].startup_dpi;
670 685
671 return 0; 686 return 0;
672} 687}
@@ -776,10 +791,10 @@ static void kone_keep_values_up_to_date(struct kone_device *kone,
776{ 791{
777 switch (event->event) { 792 switch (event->event) {
778 case kone_mouse_event_switch_profile: 793 case kone_mouse_event_switch_profile:
794 kone->actual_dpi = kone->profiles[event->value - 1].
795 startup_dpi;
779 case kone_mouse_event_osd_profile: 796 case kone_mouse_event_osd_profile:
780 kone->actual_profile = event->value; 797 kone->actual_profile = event->value;
781 kone->actual_dpi = kone->profiles[kone->actual_profile - 1].
782 startup_dpi;
783 break; 798 break;
784 case kone_mouse_event_switch_dpi: 799 case kone_mouse_event_switch_dpi:
785 case kone_mouse_event_osd_dpi: 800 case kone_mouse_event_osd_dpi:
diff --git a/drivers/hid/hid-roccat-kovaplus.c b/drivers/hid/hid-roccat-kovaplus.c
index 1f8336e3f584..112d934132c8 100644
--- a/drivers/hid/hid-roccat-kovaplus.c
+++ b/drivers/hid/hid-roccat-kovaplus.c
@@ -323,6 +323,7 @@ static ssize_t kovaplus_sysfs_set_actual_profile(struct device *dev,
323 struct usb_device *usb_dev; 323 struct usb_device *usb_dev;
324 unsigned long profile; 324 unsigned long profile;
325 int retval; 325 int retval;
326 struct kovaplus_roccat_report roccat_report;
326 327
327 dev = dev->parent->parent; 328 dev = dev->parent->parent;
328 kovaplus = hid_get_drvdata(dev_get_drvdata(dev)); 329 kovaplus = hid_get_drvdata(dev_get_drvdata(dev));
@@ -337,10 +338,22 @@ static ssize_t kovaplus_sysfs_set_actual_profile(struct device *dev,
337 338
338 mutex_lock(&kovaplus->kovaplus_lock); 339 mutex_lock(&kovaplus->kovaplus_lock);
339 retval = kovaplus_set_actual_profile(usb_dev, profile); 340 retval = kovaplus_set_actual_profile(usb_dev, profile);
341 if (retval) {
342 mutex_unlock(&kovaplus->kovaplus_lock);
343 return retval;
344 }
345
340 kovaplus_profile_activated(kovaplus, profile); 346 kovaplus_profile_activated(kovaplus, profile);
347
348 roccat_report.type = KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE_1;
349 roccat_report.profile = profile + 1;
350 roccat_report.button = 0;
351 roccat_report.data1 = profile + 1;
352 roccat_report.data2 = 0;
353 roccat_report_event(kovaplus->chrdev_minor,
354 (uint8_t const *)&roccat_report);
355
341 mutex_unlock(&kovaplus->kovaplus_lock); 356 mutex_unlock(&kovaplus->kovaplus_lock);
342 if (retval)
343 return retval;
344 357
345 return size; 358 return size;
346} 359}
diff --git a/drivers/hid/hid-roccat-pyra.c b/drivers/hid/hid-roccat-pyra.c
index 8140776bd8c5..df05c1b1064f 100644
--- a/drivers/hid/hid-roccat-pyra.c
+++ b/drivers/hid/hid-roccat-pyra.c
@@ -298,6 +298,7 @@ static ssize_t pyra_sysfs_write_settings(struct file *fp,
298 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 298 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
299 int retval = 0; 299 int retval = 0;
300 int difference; 300 int difference;
301 struct pyra_roccat_report roccat_report;
301 302
302 if (off != 0 || count != sizeof(struct pyra_settings)) 303 if (off != 0 || count != sizeof(struct pyra_settings))
303 return -EINVAL; 304 return -EINVAL;
@@ -307,17 +308,23 @@ static ssize_t pyra_sysfs_write_settings(struct file *fp,
307 if (difference) { 308 if (difference) {
308 retval = pyra_set_settings(usb_dev, 309 retval = pyra_set_settings(usb_dev,
309 (struct pyra_settings const *)buf); 310 (struct pyra_settings const *)buf);
310 if (!retval) 311 if (retval) {
311 memcpy(&pyra->settings, buf, 312 mutex_unlock(&pyra->pyra_lock);
312 sizeof(struct pyra_settings)); 313 return retval;
313 } 314 }
314 mutex_unlock(&pyra->pyra_lock);
315 315
316 if (retval) 316 memcpy(&pyra->settings, buf,
317 return retval; 317 sizeof(struct pyra_settings));
318 318
319 profile_activated(pyra, pyra->settings.startup_profile); 319 profile_activated(pyra, pyra->settings.startup_profile);
320 320
321 roccat_report.type = PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2;
322 roccat_report.value = pyra->settings.startup_profile + 1;
323 roccat_report.key = 0;
324 roccat_report_event(pyra->chrdev_minor,
325 (uint8_t const *)&roccat_report);
326 }
327 mutex_unlock(&pyra->pyra_lock);
321 return sizeof(struct pyra_settings); 328 return sizeof(struct pyra_settings);
322} 329}
323 330
diff --git a/drivers/hid/hid-sjoy.c b/drivers/hid/hid-sjoy.c
index 16f7cafc9695..670da9109f86 100644
--- a/drivers/hid/hid-sjoy.c
+++ b/drivers/hid/hid-sjoy.c
@@ -65,8 +65,7 @@ static int sjoyff_init(struct hid_device *hid)
65{ 65{
66 struct sjoyff_device *sjoyff; 66 struct sjoyff_device *sjoyff;
67 struct hid_report *report; 67 struct hid_report *report;
68 struct hid_input *hidinput = list_entry(hid->inputs.next, 68 struct hid_input *hidinput;
69 struct hid_input, list);
70 struct list_head *report_list = 69 struct list_head *report_list =
71 &hid->report_enum[HID_OUTPUT_REPORT].report_list; 70 &hid->report_enum[HID_OUTPUT_REPORT].report_list;
72 struct list_head *report_ptr = report_list; 71 struct list_head *report_ptr = report_list;
@@ -78,43 +77,45 @@ static int sjoyff_init(struct hid_device *hid)
78 return -ENODEV; 77 return -ENODEV;
79 } 78 }
80 79
81 report_ptr = report_ptr->next; 80 list_for_each_entry(hidinput, &hid->inputs, list) {
81 report_ptr = report_ptr->next;
82 82
83 if (report_ptr == report_list) { 83 if (report_ptr == report_list) {
84 hid_err(hid, "required output report is missing\n"); 84 hid_err(hid, "required output report is missing\n");
85 return -ENODEV; 85 return -ENODEV;
86 } 86 }
87 87
88 report = list_entry(report_ptr, struct hid_report, list); 88 report = list_entry(report_ptr, struct hid_report, list);
89 if (report->maxfield < 1) { 89 if (report->maxfield < 1) {
90 hid_err(hid, "no fields in the report\n"); 90 hid_err(hid, "no fields in the report\n");
91 return -ENODEV; 91 return -ENODEV;
92 } 92 }
93 93
94 if (report->field[0]->report_count < 3) { 94 if (report->field[0]->report_count < 3) {
95 hid_err(hid, "not enough values in the field\n"); 95 hid_err(hid, "not enough values in the field\n");
96 return -ENODEV; 96 return -ENODEV;
97 } 97 }
98 98
99 sjoyff = kzalloc(sizeof(struct sjoyff_device), GFP_KERNEL); 99 sjoyff = kzalloc(sizeof(struct sjoyff_device), GFP_KERNEL);
100 if (!sjoyff) 100 if (!sjoyff)
101 return -ENOMEM; 101 return -ENOMEM;
102 102
103 dev = hidinput->input; 103 dev = hidinput->input;
104 104
105 set_bit(FF_RUMBLE, dev->ffbit); 105 set_bit(FF_RUMBLE, dev->ffbit);
106 106
107 error = input_ff_create_memless(dev, sjoyff, hid_sjoyff_play); 107 error = input_ff_create_memless(dev, sjoyff, hid_sjoyff_play);
108 if (error) { 108 if (error) {
109 kfree(sjoyff); 109 kfree(sjoyff);
110 return error; 110 return error;
111 } 111 }
112 112
113 sjoyff->report = report; 113 sjoyff->report = report;
114 sjoyff->report->field[0]->value[0] = 0x01; 114 sjoyff->report->field[0]->value[0] = 0x01;
115 sjoyff->report->field[0]->value[1] = 0x00; 115 sjoyff->report->field[0]->value[1] = 0x00;
116 sjoyff->report->field[0]->value[2] = 0x00; 116 sjoyff->report->field[0]->value[2] = 0x00;
117 usbhid_submit_report(hid, sjoyff->report, USB_DIR_OUT); 117 usbhid_submit_report(hid, sjoyff->report, USB_DIR_OUT);
118 }
118 119
119 hid_info(hid, "Force feedback for SmartJoy PLUS PS2/USB adapter\n"); 120 hid_info(hid, "Force feedback for SmartJoy PLUS PS2/USB adapter\n");
120 121
@@ -131,6 +132,8 @@ static int sjoy_probe(struct hid_device *hdev, const struct hid_device_id *id)
131{ 132{
132 int ret; 133 int ret;
133 134
135 hdev->quirks |= id->driver_data;
136
134 ret = hid_parse(hdev); 137 ret = hid_parse(hdev);
135 if (ret) { 138 if (ret) {
136 hid_err(hdev, "parse failed\n"); 139 hid_err(hdev, "parse failed\n");
@@ -151,7 +154,17 @@ err:
151} 154}
152 155
153static const struct hid_device_id sjoy_devices[] = { 156static const struct hid_device_id sjoy_devices[] = {
157 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
158 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO),
159 .driver_data = HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET |
160 HID_QUIRK_SKIP_OUTPUT_REPORTS },
161 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO),
162 .driver_data = HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET |
163 HID_QUIRK_SKIP_OUTPUT_REPORTS },
154 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) }, 164 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
165 { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD),
166 .driver_data = HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET |
167 HID_QUIRK_SKIP_OUTPUT_REPORTS },
155 { } 168 { }
156}; 169};
157MODULE_DEVICE_TABLE(hid, sjoy_devices); 170MODULE_DEVICE_TABLE(hid, sjoy_devices);
diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c
index 72ca689b6474..17bb88f782b6 100644
--- a/drivers/hid/hid-wacom.c
+++ b/drivers/hid/hid-wacom.c
@@ -304,11 +304,51 @@ static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
304 return 1; 304 return 1;
305} 305}
306 306
307static int wacom_input_mapped(struct hid_device *hdev, struct hid_input *hi,
308 struct hid_field *field, struct hid_usage *usage, unsigned long **bit,
309 int *max)
310{
311 struct input_dev *input = hi->input;
312
313 __set_bit(INPUT_PROP_POINTER, input->propbit);
314
315 /* Basics */
316 input->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL);
317
318 __set_bit(REL_WHEEL, input->relbit);
319
320 __set_bit(BTN_TOOL_PEN, input->keybit);
321 __set_bit(BTN_TOUCH, input->keybit);
322 __set_bit(BTN_STYLUS, input->keybit);
323 __set_bit(BTN_STYLUS2, input->keybit);
324 __set_bit(BTN_LEFT, input->keybit);
325 __set_bit(BTN_RIGHT, input->keybit);
326 __set_bit(BTN_MIDDLE, input->keybit);
327
328 /* Pad */
329 input->evbit[0] |= BIT(EV_MSC);
330
331 __set_bit(MSC_SERIAL, input->mscbit);
332
333 __set_bit(BTN_0, input->keybit);
334 __set_bit(BTN_1, input->keybit);
335 __set_bit(BTN_TOOL_FINGER, input->keybit);
336
337 /* Distance, rubber and mouse */
338 __set_bit(BTN_TOOL_RUBBER, input->keybit);
339 __set_bit(BTN_TOOL_MOUSE, input->keybit);
340
341 input_set_abs_params(input, ABS_X, 0, 16704, 4, 0);
342 input_set_abs_params(input, ABS_Y, 0, 12064, 4, 0);
343 input_set_abs_params(input, ABS_PRESSURE, 0, 511, 0, 0);
344 input_set_abs_params(input, ABS_DISTANCE, 0, 32, 0, 0);
345
346 return 0;
347}
348
307static int wacom_probe(struct hid_device *hdev, 349static int wacom_probe(struct hid_device *hdev,
308 const struct hid_device_id *id) 350 const struct hid_device_id *id)
309{ 351{
310 struct hid_input *hidinput;
311 struct input_dev *input;
312 struct wacom_data *wdata; 352 struct wacom_data *wdata;
313 int ret; 353 int ret;
314 354
@@ -370,42 +410,6 @@ static int wacom_probe(struct hid_device *hdev,
370 goto err_ac; 410 goto err_ac;
371 } 411 }
372#endif 412#endif
373 hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
374 input = hidinput->input;
375
376 __set_bit(INPUT_PROP_POINTER, input->propbit);
377
378 /* Basics */
379 input->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL);
380
381 __set_bit(REL_WHEEL, input->relbit);
382
383 __set_bit(BTN_TOOL_PEN, input->keybit);
384 __set_bit(BTN_TOUCH, input->keybit);
385 __set_bit(BTN_STYLUS, input->keybit);
386 __set_bit(BTN_STYLUS2, input->keybit);
387 __set_bit(BTN_LEFT, input->keybit);
388 __set_bit(BTN_RIGHT, input->keybit);
389 __set_bit(BTN_MIDDLE, input->keybit);
390
391 /* Pad */
392 input->evbit[0] |= BIT(EV_MSC);
393
394 __set_bit(MSC_SERIAL, input->mscbit);
395
396 __set_bit(BTN_0, input->keybit);
397 __set_bit(BTN_1, input->keybit);
398 __set_bit(BTN_TOOL_FINGER, input->keybit);
399
400 /* Distance, rubber and mouse */
401 __set_bit(BTN_TOOL_RUBBER, input->keybit);
402 __set_bit(BTN_TOOL_MOUSE, input->keybit);
403
404 input_set_abs_params(input, ABS_X, 0, 16704, 4, 0);
405 input_set_abs_params(input, ABS_Y, 0, 12064, 4, 0);
406 input_set_abs_params(input, ABS_PRESSURE, 0, 511, 0, 0);
407 input_set_abs_params(input, ABS_DISTANCE, 0, 32, 0, 0);
408
409 return 0; 413 return 0;
410 414
411#ifdef CONFIG_HID_WACOM_POWER_SUPPLY 415#ifdef CONFIG_HID_WACOM_POWER_SUPPLY
@@ -448,6 +452,7 @@ static struct hid_driver wacom_driver = {
448 .probe = wacom_probe, 452 .probe = wacom_probe,
449 .remove = wacom_remove, 453 .remove = wacom_remove,
450 .raw_event = wacom_raw_event, 454 .raw_event = wacom_raw_event,
455 .input_mapped = wacom_input_mapped,
451}; 456};
452 457
453static int __init wacom_init(void) 458static int __init wacom_init(void)
diff --git a/drivers/hid/hid-wiimote.c b/drivers/hid/hid-wiimote.c
index 85a02e5f9fe8..76739c07fa3c 100644
--- a/drivers/hid/hid-wiimote.c
+++ b/drivers/hid/hid-wiimote.c
@@ -10,15 +10,18 @@
10 * any later version. 10 * any later version.
11 */ 11 */
12 12
13#include <linux/completion.h>
13#include <linux/device.h> 14#include <linux/device.h>
14#include <linux/hid.h> 15#include <linux/hid.h>
15#include <linux/input.h> 16#include <linux/input.h>
16#include <linux/leds.h> 17#include <linux/leds.h>
17#include <linux/module.h> 18#include <linux/module.h>
19#include <linux/mutex.h>
20#include <linux/power_supply.h>
18#include <linux/spinlock.h> 21#include <linux/spinlock.h>
19#include "hid-ids.h" 22#include "hid-ids.h"
20 23
21#define WIIMOTE_VERSION "0.1" 24#define WIIMOTE_VERSION "0.2"
22#define WIIMOTE_NAME "Nintendo Wii Remote" 25#define WIIMOTE_NAME "Nintendo Wii Remote"
23#define WIIMOTE_BUFSIZE 32 26#define WIIMOTE_BUFSIZE 32
24 27
@@ -30,12 +33,26 @@ struct wiimote_buf {
30struct wiimote_state { 33struct wiimote_state {
31 spinlock_t lock; 34 spinlock_t lock;
32 __u8 flags; 35 __u8 flags;
36 __u8 accel_split[2];
37
38 /* synchronous cmd requests */
39 struct mutex sync;
40 struct completion ready;
41 int cmd;
42 __u32 opt;
43
44 /* results of synchronous requests */
45 __u8 cmd_battery;
46 __u8 cmd_err;
33}; 47};
34 48
35struct wiimote_data { 49struct wiimote_data {
36 struct hid_device *hdev; 50 struct hid_device *hdev;
37 struct input_dev *input; 51 struct input_dev *input;
38 struct led_classdev *leds[4]; 52 struct led_classdev *leds[4];
53 struct input_dev *accel;
54 struct input_dev *ir;
55 struct power_supply battery;
39 56
40 spinlock_t qlock; 57 spinlock_t qlock;
41 __u8 head; 58 __u8 head;
@@ -46,23 +63,47 @@ struct wiimote_data {
46 struct wiimote_state state; 63 struct wiimote_state state;
47}; 64};
48 65
49#define WIIPROTO_FLAG_LED1 0x01 66#define WIIPROTO_FLAG_LED1 0x01
50#define WIIPROTO_FLAG_LED2 0x02 67#define WIIPROTO_FLAG_LED2 0x02
51#define WIIPROTO_FLAG_LED3 0x04 68#define WIIPROTO_FLAG_LED3 0x04
52#define WIIPROTO_FLAG_LED4 0x08 69#define WIIPROTO_FLAG_LED4 0x08
70#define WIIPROTO_FLAG_RUMBLE 0x10
71#define WIIPROTO_FLAG_ACCEL 0x20
72#define WIIPROTO_FLAG_IR_BASIC 0x40
73#define WIIPROTO_FLAG_IR_EXT 0x80
74#define WIIPROTO_FLAG_IR_FULL 0xc0 /* IR_BASIC | IR_EXT */
53#define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \ 75#define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
54 WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4) 76 WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)
77#define WIIPROTO_FLAGS_IR (WIIPROTO_FLAG_IR_BASIC | WIIPROTO_FLAG_IR_EXT | \
78 WIIPROTO_FLAG_IR_FULL)
55 79
56/* return flag for led \num */ 80/* return flag for led \num */
57#define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1)) 81#define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))
58 82
59enum wiiproto_reqs { 83enum wiiproto_reqs {
60 WIIPROTO_REQ_NULL = 0x0, 84 WIIPROTO_REQ_NULL = 0x0,
85 WIIPROTO_REQ_RUMBLE = 0x10,
61 WIIPROTO_REQ_LED = 0x11, 86 WIIPROTO_REQ_LED = 0x11,
62 WIIPROTO_REQ_DRM = 0x12, 87 WIIPROTO_REQ_DRM = 0x12,
88 WIIPROTO_REQ_IR1 = 0x13,
89 WIIPROTO_REQ_SREQ = 0x15,
90 WIIPROTO_REQ_WMEM = 0x16,
91 WIIPROTO_REQ_RMEM = 0x17,
92 WIIPROTO_REQ_IR2 = 0x1a,
63 WIIPROTO_REQ_STATUS = 0x20, 93 WIIPROTO_REQ_STATUS = 0x20,
94 WIIPROTO_REQ_DATA = 0x21,
64 WIIPROTO_REQ_RETURN = 0x22, 95 WIIPROTO_REQ_RETURN = 0x22,
65 WIIPROTO_REQ_DRM_K = 0x30, 96 WIIPROTO_REQ_DRM_K = 0x30,
97 WIIPROTO_REQ_DRM_KA = 0x31,
98 WIIPROTO_REQ_DRM_KE = 0x32,
99 WIIPROTO_REQ_DRM_KAI = 0x33,
100 WIIPROTO_REQ_DRM_KEE = 0x34,
101 WIIPROTO_REQ_DRM_KAE = 0x35,
102 WIIPROTO_REQ_DRM_KIE = 0x36,
103 WIIPROTO_REQ_DRM_KAIE = 0x37,
104 WIIPROTO_REQ_DRM_E = 0x3d,
105 WIIPROTO_REQ_DRM_SKAI1 = 0x3e,
106 WIIPROTO_REQ_DRM_SKAI2 = 0x3f,
66}; 107};
67 108
68enum wiiproto_keys { 109enum wiiproto_keys {
@@ -94,6 +135,56 @@ static __u16 wiiproto_keymap[] = {
94 BTN_MODE, /* WIIPROTO_KEY_HOME */ 135 BTN_MODE, /* WIIPROTO_KEY_HOME */
95}; 136};
96 137
138static enum power_supply_property wiimote_battery_props[] = {
139 POWER_SUPPLY_PROP_CAPACITY
140};
141
142/* requires the state.lock spinlock to be held */
143static inline bool wiimote_cmd_pending(struct wiimote_data *wdata, int cmd,
144 __u32 opt)
145{
146 return wdata->state.cmd == cmd && wdata->state.opt == opt;
147}
148
149/* requires the state.lock spinlock to be held */
150static inline void wiimote_cmd_complete(struct wiimote_data *wdata)
151{
152 wdata->state.cmd = WIIPROTO_REQ_NULL;
153 complete(&wdata->state.ready);
154}
155
156static inline int wiimote_cmd_acquire(struct wiimote_data *wdata)
157{
158 return mutex_lock_interruptible(&wdata->state.sync) ? -ERESTARTSYS : 0;
159}
160
161/* requires the state.lock spinlock to be held */
162static inline void wiimote_cmd_set(struct wiimote_data *wdata, int cmd,
163 __u32 opt)
164{
165 INIT_COMPLETION(wdata->state.ready);
166 wdata->state.cmd = cmd;
167 wdata->state.opt = opt;
168}
169
170static inline void wiimote_cmd_release(struct wiimote_data *wdata)
171{
172 mutex_unlock(&wdata->state.sync);
173}
174
175static inline int wiimote_cmd_wait(struct wiimote_data *wdata)
176{
177 int ret;
178
179 ret = wait_for_completion_interruptible_timeout(&wdata->state.ready, HZ);
180 if (ret < 0)
181 return -ERESTARTSYS;
182 else if (ret == 0)
183 return -EIO;
184 else
185 return 0;
186}
187
97static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer, 188static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
98 size_t count) 189 size_t count)
99{ 190{
@@ -172,6 +263,39 @@ static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
172 spin_unlock_irqrestore(&wdata->qlock, flags); 263 spin_unlock_irqrestore(&wdata->qlock, flags);
173} 264}
174 265
266/*
267 * This sets the rumble bit on the given output report if rumble is
268 * currently enabled.
269 * \cmd1 must point to the second byte in the output report => &cmd[1]
270 * This must be called on nearly every output report before passing it
271 * into the output queue!
272 */
273static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
274{
275 if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE)
276 *cmd1 |= 0x01;
277}
278
279static void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
280{
281 __u8 cmd[2];
282
283 rumble = !!rumble;
284 if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE))
285 return;
286
287 if (rumble)
288 wdata->state.flags |= WIIPROTO_FLAG_RUMBLE;
289 else
290 wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE;
291
292 cmd[0] = WIIPROTO_REQ_RUMBLE;
293 cmd[1] = 0;
294
295 wiiproto_keep_rumble(wdata, &cmd[1]);
296 wiimote_queue(wdata, cmd, sizeof(cmd));
297}
298
175static void wiiproto_req_leds(struct wiimote_data *wdata, int leds) 299static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
176{ 300{
177 __u8 cmd[2]; 301 __u8 cmd[2];
@@ -193,6 +317,7 @@ static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
193 if (leds & WIIPROTO_FLAG_LED4) 317 if (leds & WIIPROTO_FLAG_LED4)
194 cmd[1] |= 0x80; 318 cmd[1] |= 0x80;
195 319
320 wiiproto_keep_rumble(wdata, &cmd[1]);
196 wiimote_queue(wdata, cmd, sizeof(cmd)); 321 wiimote_queue(wdata, cmd, sizeof(cmd));
197} 322}
198 323
@@ -203,7 +328,23 @@ static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
203 */ 328 */
204static __u8 select_drm(struct wiimote_data *wdata) 329static __u8 select_drm(struct wiimote_data *wdata)
205{ 330{
206 return WIIPROTO_REQ_DRM_K; 331 __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
332
333 if (ir == WIIPROTO_FLAG_IR_BASIC) {
334 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
335 return WIIPROTO_REQ_DRM_KAIE;
336 else
337 return WIIPROTO_REQ_DRM_KIE;
338 } else if (ir == WIIPROTO_FLAG_IR_EXT) {
339 return WIIPROTO_REQ_DRM_KAI;
340 } else if (ir == WIIPROTO_FLAG_IR_FULL) {
341 return WIIPROTO_REQ_DRM_SKAI1;
342 } else {
343 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
344 return WIIPROTO_REQ_DRM_KA;
345 else
346 return WIIPROTO_REQ_DRM_K;
347 }
207} 348}
208 349
209static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm) 350static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
@@ -217,9 +358,256 @@ static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
217 cmd[1] = 0; 358 cmd[1] = 0;
218 cmd[2] = drm; 359 cmd[2] = drm;
219 360
361 wiiproto_keep_rumble(wdata, &cmd[1]);
362 wiimote_queue(wdata, cmd, sizeof(cmd));
363}
364
365static void wiiproto_req_status(struct wiimote_data *wdata)
366{
367 __u8 cmd[2];
368
369 cmd[0] = WIIPROTO_REQ_SREQ;
370 cmd[1] = 0;
371
372 wiiproto_keep_rumble(wdata, &cmd[1]);
373 wiimote_queue(wdata, cmd, sizeof(cmd));
374}
375
376static void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
377{
378 accel = !!accel;
379 if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
380 return;
381
382 if (accel)
383 wdata->state.flags |= WIIPROTO_FLAG_ACCEL;
384 else
385 wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL;
386
387 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
388}
389
390static void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
391{
392 __u8 cmd[2];
393
394 cmd[0] = WIIPROTO_REQ_IR1;
395 cmd[1] = flags;
396
397 wiiproto_keep_rumble(wdata, &cmd[1]);
398 wiimote_queue(wdata, cmd, sizeof(cmd));
399}
400
401static void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
402{
403 __u8 cmd[2];
404
405 cmd[0] = WIIPROTO_REQ_IR2;
406 cmd[1] = flags;
407
408 wiiproto_keep_rumble(wdata, &cmd[1]);
409 wiimote_queue(wdata, cmd, sizeof(cmd));
410}
411
412#define wiiproto_req_wreg(wdata, os, buf, sz) \
413 wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
414
415#define wiiproto_req_weeprom(wdata, os, buf, sz) \
416 wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
417
418static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom,
419 __u32 offset, const __u8 *buf, __u8 size)
420{
421 __u8 cmd[22];
422
423 if (size > 16 || size == 0) {
424 hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size);
425 return;
426 }
427
428 memset(cmd, 0, sizeof(cmd));
429 cmd[0] = WIIPROTO_REQ_WMEM;
430 cmd[2] = (offset >> 16) & 0xff;
431 cmd[3] = (offset >> 8) & 0xff;
432 cmd[4] = offset & 0xff;
433 cmd[5] = size;
434 memcpy(&cmd[6], buf, size);
435
436 if (!eeprom)
437 cmd[1] |= 0x04;
438
439 wiiproto_keep_rumble(wdata, &cmd[1]);
220 wiimote_queue(wdata, cmd, sizeof(cmd)); 440 wiimote_queue(wdata, cmd, sizeof(cmd));
221} 441}
222 442
443/* requries the cmd-mutex to be held */
444static int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
445 const __u8 *wmem, __u8 size)
446{
447 unsigned long flags;
448 int ret;
449
450 spin_lock_irqsave(&wdata->state.lock, flags);
451 wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0);
452 wiiproto_req_wreg(wdata, offset, wmem, size);
453 spin_unlock_irqrestore(&wdata->state.lock, flags);
454
455 ret = wiimote_cmd_wait(wdata);
456 if (!ret && wdata->state.cmd_err)
457 ret = -EIO;
458
459 return ret;
460}
461
462static int wiimote_battery_get_property(struct power_supply *psy,
463 enum power_supply_property psp,
464 union power_supply_propval *val)
465{
466 struct wiimote_data *wdata = container_of(psy,
467 struct wiimote_data, battery);
468 int ret = 0, state;
469 unsigned long flags;
470
471 ret = wiimote_cmd_acquire(wdata);
472 if (ret)
473 return ret;
474
475 spin_lock_irqsave(&wdata->state.lock, flags);
476 wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
477 wiiproto_req_status(wdata);
478 spin_unlock_irqrestore(&wdata->state.lock, flags);
479
480 ret = wiimote_cmd_wait(wdata);
481 state = wdata->state.cmd_battery;
482 wiimote_cmd_release(wdata);
483
484 if (ret)
485 return ret;
486
487 switch (psp) {
488 case POWER_SUPPLY_PROP_CAPACITY:
489 val->intval = state * 100 / 255;
490 break;
491 default:
492 ret = -EINVAL;
493 break;
494 }
495
496 return ret;
497}
498
499static int wiimote_init_ir(struct wiimote_data *wdata, __u16 mode)
500{
501 int ret;
502 unsigned long flags;
503 __u8 format = 0;
504 static const __u8 data_enable[] = { 0x01 };
505 static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
506 0x00, 0xaa, 0x00, 0x64 };
507 static const __u8 data_sens2[] = { 0x63, 0x03 };
508 static const __u8 data_fin[] = { 0x08 };
509
510 spin_lock_irqsave(&wdata->state.lock, flags);
511
512 if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
513 spin_unlock_irqrestore(&wdata->state.lock, flags);
514 return 0;
515 }
516
517 if (mode == 0) {
518 wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
519 wiiproto_req_ir1(wdata, 0);
520 wiiproto_req_ir2(wdata, 0);
521 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
522 spin_unlock_irqrestore(&wdata->state.lock, flags);
523 return 0;
524 }
525
526 spin_unlock_irqrestore(&wdata->state.lock, flags);
527
528 ret = wiimote_cmd_acquire(wdata);
529 if (ret)
530 return ret;
531
532 /* send PIXEL CLOCK ENABLE cmd first */
533 spin_lock_irqsave(&wdata->state.lock, flags);
534 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
535 wiiproto_req_ir1(wdata, 0x06);
536 spin_unlock_irqrestore(&wdata->state.lock, flags);
537
538 ret = wiimote_cmd_wait(wdata);
539 if (ret)
540 goto unlock;
541 if (wdata->state.cmd_err) {
542 ret = -EIO;
543 goto unlock;
544 }
545
546 /* enable IR LOGIC */
547 spin_lock_irqsave(&wdata->state.lock, flags);
548 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0);
549 wiiproto_req_ir2(wdata, 0x06);
550 spin_unlock_irqrestore(&wdata->state.lock, flags);
551
552 ret = wiimote_cmd_wait(wdata);
553 if (ret)
554 goto unlock;
555 if (wdata->state.cmd_err) {
556 ret = -EIO;
557 goto unlock;
558 }
559
560 /* enable IR cam but do not make it send data, yet */
561 ret = wiimote_cmd_write(wdata, 0xb00030, data_enable,
562 sizeof(data_enable));
563 if (ret)
564 goto unlock;
565
566 /* write first sensitivity block */
567 ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
568 sizeof(data_sens1));
569 if (ret)
570 goto unlock;
571
572 /* write second sensitivity block */
573 ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
574 sizeof(data_sens2));
575 if (ret)
576 goto unlock;
577
578 /* put IR cam into desired state */
579 switch (mode) {
580 case WIIPROTO_FLAG_IR_FULL:
581 format = 5;
582 break;
583 case WIIPROTO_FLAG_IR_EXT:
584 format = 3;
585 break;
586 case WIIPROTO_FLAG_IR_BASIC:
587 format = 1;
588 break;
589 }
590 ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format));
591 if (ret)
592 goto unlock;
593
594 /* make IR cam send data */
595 ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin));
596 if (ret)
597 goto unlock;
598
599 /* request new DRM mode compatible to IR mode */
600 spin_lock_irqsave(&wdata->state.lock, flags);
601 wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
602 wdata->state.flags |= mode & WIIPROTO_FLAGS_IR;
603 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
604 spin_unlock_irqrestore(&wdata->state.lock, flags);
605
606unlock:
607 wiimote_cmd_release(wdata);
608 return ret;
609}
610
223static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev) 611static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
224{ 612{
225 struct wiimote_data *wdata; 613 struct wiimote_data *wdata;
@@ -268,9 +656,28 @@ static void wiimote_leds_set(struct led_classdev *led_dev,
268 } 656 }
269} 657}
270 658
271static int wiimote_input_event(struct input_dev *dev, unsigned int type, 659static int wiimote_ff_play(struct input_dev *dev, void *data,
272 unsigned int code, int value) 660 struct ff_effect *eff)
273{ 661{
662 struct wiimote_data *wdata = input_get_drvdata(dev);
663 __u8 value;
664 unsigned long flags;
665
666 /*
667 * The wiimote supports only a single rumble motor so if any magnitude
668 * is set to non-zero then we start the rumble motor. If both are set to
669 * zero, we stop the rumble motor.
670 */
671
672 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
673 value = 1;
674 else
675 value = 0;
676
677 spin_lock_irqsave(&wdata->state.lock, flags);
678 wiiproto_req_rumble(wdata, value);
679 spin_unlock_irqrestore(&wdata->state.lock, flags);
680
274 return 0; 681 return 0;
275} 682}
276 683
@@ -288,6 +695,61 @@ static void wiimote_input_close(struct input_dev *dev)
288 hid_hw_close(wdata->hdev); 695 hid_hw_close(wdata->hdev);
289} 696}
290 697
698static int wiimote_accel_open(struct input_dev *dev)
699{
700 struct wiimote_data *wdata = input_get_drvdata(dev);
701 int ret;
702 unsigned long flags;
703
704 ret = hid_hw_open(wdata->hdev);
705 if (ret)
706 return ret;
707
708 spin_lock_irqsave(&wdata->state.lock, flags);
709 wiiproto_req_accel(wdata, true);
710 spin_unlock_irqrestore(&wdata->state.lock, flags);
711
712 return 0;
713}
714
715static void wiimote_accel_close(struct input_dev *dev)
716{
717 struct wiimote_data *wdata = input_get_drvdata(dev);
718 unsigned long flags;
719
720 spin_lock_irqsave(&wdata->state.lock, flags);
721 wiiproto_req_accel(wdata, false);
722 spin_unlock_irqrestore(&wdata->state.lock, flags);
723
724 hid_hw_close(wdata->hdev);
725}
726
727static int wiimote_ir_open(struct input_dev *dev)
728{
729 struct wiimote_data *wdata = input_get_drvdata(dev);
730 int ret;
731
732 ret = hid_hw_open(wdata->hdev);
733 if (ret)
734 return ret;
735
736 ret = wiimote_init_ir(wdata, WIIPROTO_FLAG_IR_BASIC);
737 if (ret) {
738 hid_hw_close(wdata->hdev);
739 return ret;
740 }
741
742 return 0;
743}
744
745static void wiimote_ir_close(struct input_dev *dev)
746{
747 struct wiimote_data *wdata = input_get_drvdata(dev);
748
749 wiimote_init_ir(wdata, 0);
750 hid_hw_close(wdata->hdev);
751}
752
291static void handler_keys(struct wiimote_data *wdata, const __u8 *payload) 753static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
292{ 754{
293 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT], 755 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
@@ -315,12 +777,100 @@ static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
315 input_sync(wdata->input); 777 input_sync(wdata->input);
316} 778}
317 779
780static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
781{
782 __u16 x, y, z;
783
784 if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
785 return;
786
787 /*
788 * payload is: BB BB XX YY ZZ
789 * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
790 * contain the upper 8 bits of each value. The lower 2 bits are
791 * contained in the buttons data BB BB.
792 * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
793 * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
794 * accel value and bit 6 is the second bit of the Z value.
795 * The first bit of Y and Z values is not available and always set to 0.
796 * 0x200 is returned on no movement.
797 */
798
799 x = payload[2] << 2;
800 y = payload[3] << 2;
801 z = payload[4] << 2;
802
803 x |= (payload[0] >> 5) & 0x3;
804 y |= (payload[1] >> 4) & 0x2;
805 z |= (payload[1] >> 5) & 0x2;
806
807 input_report_abs(wdata->accel, ABS_RX, x - 0x200);
808 input_report_abs(wdata->accel, ABS_RY, y - 0x200);
809 input_report_abs(wdata->accel, ABS_RZ, z - 0x200);
810 input_sync(wdata->accel);
811}
812
813#define ir_to_input0(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
814 ABS_HAT0X, ABS_HAT0Y)
815#define ir_to_input1(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
816 ABS_HAT1X, ABS_HAT1Y)
817#define ir_to_input2(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
818 ABS_HAT2X, ABS_HAT2Y)
819#define ir_to_input3(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
820 ABS_HAT3X, ABS_HAT3Y)
821
822static void __ir_to_input(struct wiimote_data *wdata, const __u8 *ir,
823 bool packed, __u8 xid, __u8 yid)
824{
825 __u16 x, y;
826
827 if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
828 return;
829
830 /*
831 * Basic IR data is encoded into 3 bytes. The first two bytes are the
832 * upper 8 bit of the X/Y data, the 3rd byte contains the lower 2 bits
833 * of both.
834 * If data is packed, then the 3rd byte is put first and slightly
835 * reordered. This allows to interleave packed and non-packed data to
836 * have two IR sets in 5 bytes instead of 6.
837 * The resulting 10bit X/Y values are passed to the ABS_HATXY input dev.
838 */
839
840 if (packed) {
841 x = ir[1] << 2;
842 y = ir[2] << 2;
843
844 x |= ir[0] & 0x3;
845 y |= (ir[0] >> 2) & 0x3;
846 } else {
847 x = ir[0] << 2;
848 y = ir[1] << 2;
849
850 x |= (ir[2] >> 4) & 0x3;
851 y |= (ir[2] >> 6) & 0x3;
852 }
853
854 input_report_abs(wdata->ir, xid, x);
855 input_report_abs(wdata->ir, yid, y);
856}
857
318static void handler_status(struct wiimote_data *wdata, const __u8 *payload) 858static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
319{ 859{
320 handler_keys(wdata, payload); 860 handler_keys(wdata, payload);
321 861
322 /* on status reports the drm is reset so we need to resend the drm */ 862 /* on status reports the drm is reset so we need to resend the drm */
323 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 863 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
864
865 if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0)) {
866 wdata->state.cmd_battery = payload[5];
867 wiimote_cmd_complete(wdata);
868 }
869}
870
871static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
872{
873 handler_keys(wdata, payload);
324} 874}
325 875
326static void handler_return(struct wiimote_data *wdata, const __u8 *payload) 876static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
@@ -330,9 +880,105 @@ static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
330 880
331 handler_keys(wdata, payload); 881 handler_keys(wdata, payload);
332 882
333 if (err) 883 if (wiimote_cmd_pending(wdata, cmd, 0)) {
884 wdata->state.cmd_err = err;
885 wiimote_cmd_complete(wdata);
886 } else if (err) {
334 hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err, 887 hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
335 cmd); 888 cmd);
889 }
890}
891
892static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
893{
894 handler_keys(wdata, payload);
895 handler_accel(wdata, payload);
896}
897
898static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload)
899{
900 handler_keys(wdata, payload);
901}
902
903static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
904{
905 handler_keys(wdata, payload);
906 handler_accel(wdata, payload);
907 ir_to_input0(wdata, &payload[5], false);
908 ir_to_input1(wdata, &payload[8], false);
909 ir_to_input2(wdata, &payload[11], false);
910 ir_to_input3(wdata, &payload[14], false);
911 input_sync(wdata->ir);
912}
913
914static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload)
915{
916 handler_keys(wdata, payload);
917}
918
919static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
920{
921 handler_keys(wdata, payload);
922 ir_to_input0(wdata, &payload[2], false);
923 ir_to_input1(wdata, &payload[4], true);
924 ir_to_input2(wdata, &payload[7], false);
925 ir_to_input3(wdata, &payload[9], true);
926 input_sync(wdata->ir);
927}
928
929static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
930{
931 handler_keys(wdata, payload);
932 handler_accel(wdata, payload);
933}
934
935static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
936{
937 handler_keys(wdata, payload);
938 handler_accel(wdata, payload);
939 ir_to_input0(wdata, &payload[5], false);
940 ir_to_input1(wdata, &payload[7], true);
941 ir_to_input2(wdata, &payload[10], false);
942 ir_to_input3(wdata, &payload[12], true);
943 input_sync(wdata->ir);
944}
945
946static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
947{
948}
949
950static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
951{
952 handler_keys(wdata, payload);
953
954 wdata->state.accel_split[0] = payload[2];
955 wdata->state.accel_split[1] = (payload[0] >> 1) & (0x10 | 0x20);
956 wdata->state.accel_split[1] |= (payload[1] << 1) & (0x40 | 0x80);
957
958 ir_to_input0(wdata, &payload[3], false);
959 ir_to_input1(wdata, &payload[12], false);
960 input_sync(wdata->ir);
961}
962
963static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
964{
965 __u8 buf[5];
966
967 handler_keys(wdata, payload);
968
969 wdata->state.accel_split[1] |= (payload[0] >> 5) & (0x01 | 0x02);
970 wdata->state.accel_split[1] |= (payload[1] >> 3) & (0x04 | 0x08);
971
972 buf[0] = 0;
973 buf[1] = 0;
974 buf[2] = wdata->state.accel_split[0];
975 buf[3] = payload[2];
976 buf[4] = wdata->state.accel_split[1];
977 handler_accel(wdata, buf);
978
979 ir_to_input2(wdata, &payload[3], false);
980 ir_to_input3(wdata, &payload[12], false);
981 input_sync(wdata->ir);
336} 982}
337 983
338struct wiiproto_handler { 984struct wiiproto_handler {
@@ -343,8 +989,19 @@ struct wiiproto_handler {
343 989
344static struct wiiproto_handler handlers[] = { 990static struct wiiproto_handler handlers[] = {
345 { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status }, 991 { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
992 { .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
346 { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return }, 993 { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
347 { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys }, 994 { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
995 { .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
996 { .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
997 { .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
998 { .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
999 { .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
1000 { .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
1001 { .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
1002 { .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
1003 { .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
1004 { .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
348 { .id = 0 } 1005 { .id = 0 }
349}; 1006};
350 1007
@@ -355,6 +1012,7 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
355 struct wiiproto_handler *h; 1012 struct wiiproto_handler *h;
356 int i; 1013 int i;
357 unsigned long flags; 1014 unsigned long flags;
1015 bool handled = false;
358 1016
359 if (size < 1) 1017 if (size < 1)
360 return -EINVAL; 1018 return -EINVAL;
@@ -363,10 +1021,16 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
363 1021
364 for (i = 0; handlers[i].id; ++i) { 1022 for (i = 0; handlers[i].id; ++i) {
365 h = &handlers[i]; 1023 h = &handlers[i];
366 if (h->id == raw_data[0] && h->size < size) 1024 if (h->id == raw_data[0] && h->size < size) {
367 h->func(wdata, &raw_data[1]); 1025 h->func(wdata, &raw_data[1]);
1026 handled = true;
1027 }
368 } 1028 }
369 1029
1030 if (!handled)
1031 hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
1032 size);
1033
370 spin_unlock_irqrestore(&wdata->state.lock, flags); 1034 spin_unlock_irqrestore(&wdata->state.lock, flags);
371 1035
372 return 0; 1036 return 0;
@@ -434,16 +1098,13 @@ static struct wiimote_data *wiimote_create(struct hid_device *hdev)
434 return NULL; 1098 return NULL;
435 1099
436 wdata->input = input_allocate_device(); 1100 wdata->input = input_allocate_device();
437 if (!wdata->input) { 1101 if (!wdata->input)
438 kfree(wdata); 1102 goto err;
439 return NULL;
440 }
441 1103
442 wdata->hdev = hdev; 1104 wdata->hdev = hdev;
443 hid_set_drvdata(hdev, wdata); 1105 hid_set_drvdata(hdev, wdata);
444 1106
445 input_set_drvdata(wdata->input, wdata); 1107 input_set_drvdata(wdata->input, wdata);
446 wdata->input->event = wiimote_input_event;
447 wdata->input->open = wiimote_input_open; 1108 wdata->input->open = wiimote_input_open;
448 wdata->input->close = wiimote_input_close; 1109 wdata->input->close = wiimote_input_close;
449 wdata->input->dev.parent = &wdata->hdev->dev; 1110 wdata->input->dev.parent = &wdata->hdev->dev;
@@ -457,18 +1118,89 @@ static struct wiimote_data *wiimote_create(struct hid_device *hdev)
457 for (i = 0; i < WIIPROTO_KEY_COUNT; ++i) 1118 for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
458 set_bit(wiiproto_keymap[i], wdata->input->keybit); 1119 set_bit(wiiproto_keymap[i], wdata->input->keybit);
459 1120
1121 set_bit(FF_RUMBLE, wdata->input->ffbit);
1122 if (input_ff_create_memless(wdata->input, NULL, wiimote_ff_play))
1123 goto err_input;
1124
1125 wdata->accel = input_allocate_device();
1126 if (!wdata->accel)
1127 goto err_input;
1128
1129 input_set_drvdata(wdata->accel, wdata);
1130 wdata->accel->open = wiimote_accel_open;
1131 wdata->accel->close = wiimote_accel_close;
1132 wdata->accel->dev.parent = &wdata->hdev->dev;
1133 wdata->accel->id.bustype = wdata->hdev->bus;
1134 wdata->accel->id.vendor = wdata->hdev->vendor;
1135 wdata->accel->id.product = wdata->hdev->product;
1136 wdata->accel->id.version = wdata->hdev->version;
1137 wdata->accel->name = WIIMOTE_NAME " Accelerometer";
1138
1139 set_bit(EV_ABS, wdata->accel->evbit);
1140 set_bit(ABS_RX, wdata->accel->absbit);
1141 set_bit(ABS_RY, wdata->accel->absbit);
1142 set_bit(ABS_RZ, wdata->accel->absbit);
1143 input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4);
1144 input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4);
1145 input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4);
1146
1147 wdata->ir = input_allocate_device();
1148 if (!wdata->ir)
1149 goto err_ir;
1150
1151 input_set_drvdata(wdata->ir, wdata);
1152 wdata->ir->open = wiimote_ir_open;
1153 wdata->ir->close = wiimote_ir_close;
1154 wdata->ir->dev.parent = &wdata->hdev->dev;
1155 wdata->ir->id.bustype = wdata->hdev->bus;
1156 wdata->ir->id.vendor = wdata->hdev->vendor;
1157 wdata->ir->id.product = wdata->hdev->product;
1158 wdata->ir->id.version = wdata->hdev->version;
1159 wdata->ir->name = WIIMOTE_NAME " IR";
1160
1161 set_bit(EV_ABS, wdata->ir->evbit);
1162 set_bit(ABS_HAT0X, wdata->ir->absbit);
1163 set_bit(ABS_HAT0Y, wdata->ir->absbit);
1164 set_bit(ABS_HAT1X, wdata->ir->absbit);
1165 set_bit(ABS_HAT1Y, wdata->ir->absbit);
1166 set_bit(ABS_HAT2X, wdata->ir->absbit);
1167 set_bit(ABS_HAT2Y, wdata->ir->absbit);
1168 set_bit(ABS_HAT3X, wdata->ir->absbit);
1169 set_bit(ABS_HAT3Y, wdata->ir->absbit);
1170 input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4);
1171 input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4);
1172 input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4);
1173 input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4);
1174 input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4);
1175 input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4);
1176 input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4);
1177 input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4);
1178
460 spin_lock_init(&wdata->qlock); 1179 spin_lock_init(&wdata->qlock);
461 INIT_WORK(&wdata->worker, wiimote_worker); 1180 INIT_WORK(&wdata->worker, wiimote_worker);
462 1181
463 spin_lock_init(&wdata->state.lock); 1182 spin_lock_init(&wdata->state.lock);
1183 init_completion(&wdata->state.ready);
1184 mutex_init(&wdata->state.sync);
464 1185
465 return wdata; 1186 return wdata;
1187
1188err_ir:
1189 input_free_device(wdata->accel);
1190err_input:
1191 input_free_device(wdata->input);
1192err:
1193 kfree(wdata);
1194 return NULL;
466} 1195}
467 1196
468static void wiimote_destroy(struct wiimote_data *wdata) 1197static void wiimote_destroy(struct wiimote_data *wdata)
469{ 1198{
470 wiimote_leds_destroy(wdata); 1199 wiimote_leds_destroy(wdata);
471 1200
1201 power_supply_unregister(&wdata->battery);
1202 input_unregister_device(wdata->accel);
1203 input_unregister_device(wdata->ir);
472 input_unregister_device(wdata->input); 1204 input_unregister_device(wdata->input);
473 cancel_work_sync(&wdata->worker); 1205 cancel_work_sync(&wdata->worker);
474 hid_hw_stop(wdata->hdev); 1206 hid_hw_stop(wdata->hdev);
@@ -500,12 +1232,37 @@ static int wiimote_hid_probe(struct hid_device *hdev,
500 goto err; 1232 goto err;
501 } 1233 }
502 1234
503 ret = input_register_device(wdata->input); 1235 ret = input_register_device(wdata->accel);
504 if (ret) { 1236 if (ret) {
505 hid_err(hdev, "Cannot register input device\n"); 1237 hid_err(hdev, "Cannot register input device\n");
506 goto err_stop; 1238 goto err_stop;
507 } 1239 }
508 1240
1241 ret = input_register_device(wdata->ir);
1242 if (ret) {
1243 hid_err(hdev, "Cannot register input device\n");
1244 goto err_ir;
1245 }
1246
1247 ret = input_register_device(wdata->input);
1248 if (ret) {
1249 hid_err(hdev, "Cannot register input device\n");
1250 goto err_input;
1251 }
1252
1253 wdata->battery.properties = wiimote_battery_props;
1254 wdata->battery.num_properties = ARRAY_SIZE(wiimote_battery_props);
1255 wdata->battery.get_property = wiimote_battery_get_property;
1256 wdata->battery.name = "wiimote_battery";
1257 wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1258 wdata->battery.use_for_apm = 0;
1259
1260 ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
1261 if (ret) {
1262 hid_err(hdev, "Cannot register battery device\n");
1263 goto err_battery;
1264 }
1265
509 ret = wiimote_leds_create(wdata); 1266 ret = wiimote_leds_create(wdata);
510 if (ret) 1267 if (ret)
511 goto err_free; 1268 goto err_free;
@@ -523,9 +1280,20 @@ err_free:
523 wiimote_destroy(wdata); 1280 wiimote_destroy(wdata);
524 return ret; 1281 return ret;
525 1282
1283err_battery:
1284 input_unregister_device(wdata->input);
1285 wdata->input = NULL;
1286err_input:
1287 input_unregister_device(wdata->ir);
1288 wdata->ir = NULL;
1289err_ir:
1290 input_unregister_device(wdata->accel);
1291 wdata->accel = NULL;
526err_stop: 1292err_stop:
527 hid_hw_stop(hdev); 1293 hid_hw_stop(hdev);
528err: 1294err:
1295 input_free_device(wdata->ir);
1296 input_free_device(wdata->accel);
529 input_free_device(wdata->input); 1297 input_free_device(wdata->input);
530 kfree(wdata); 1298 kfree(wdata);
531 return ret; 1299 return ret;
diff --git a/drivers/hid/hid-zydacron.c b/drivers/hid/hid-zydacron.c
index e90371508fd2..1ad85f2257b4 100644
--- a/drivers/hid/hid-zydacron.c
+++ b/drivers/hid/hid-zydacron.c
@@ -201,9 +201,7 @@ static void zc_remove(struct hid_device *hdev)
201 struct zc_device *zc = hid_get_drvdata(hdev); 201 struct zc_device *zc = hid_get_drvdata(hdev);
202 202
203 hid_hw_stop(hdev); 203 hid_hw_stop(hdev);
204 204 kfree(zc);
205 if (NULL != zc)
206 kfree(zc);
207} 205}
208 206
209static const struct hid_device_id zc_devices[] = { 207static const struct hid_device_id zc_devices[] = {
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index c79578b5a788..cf7d6d58e79f 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -259,7 +259,6 @@ static int hidraw_open(struct inode *inode, struct file *file)
259 259
260 mutex_lock(&minors_lock); 260 mutex_lock(&minors_lock);
261 if (!hidraw_table[minor]) { 261 if (!hidraw_table[minor]) {
262 kfree(list);
263 err = -ENODEV; 262 err = -ENODEV;
264 goto out_unlock; 263 goto out_unlock;
265 } 264 }
@@ -272,8 +271,10 @@ static int hidraw_open(struct inode *inode, struct file *file)
272 dev = hidraw_table[minor]; 271 dev = hidraw_table[minor];
273 if (!dev->open++) { 272 if (!dev->open++) {
274 err = hid_hw_power(dev->hid, PM_HINT_FULLON); 273 err = hid_hw_power(dev->hid, PM_HINT_FULLON);
275 if (err < 0) 274 if (err < 0) {
275 dev->open--;
276 goto out_unlock; 276 goto out_unlock;
277 }
277 278
278 err = hid_hw_open(dev->hid); 279 err = hid_hw_open(dev->hid);
279 if (err < 0) { 280 if (err < 0) {
@@ -285,6 +286,8 @@ static int hidraw_open(struct inode *inode, struct file *file)
285out_unlock: 286out_unlock:
286 mutex_unlock(&minors_lock); 287 mutex_unlock(&minors_lock);
287out: 288out:
289 if (err < 0)
290 kfree(list);
288 return err; 291 return err;
289 292
290} 293}
@@ -510,13 +513,12 @@ void hidraw_disconnect(struct hid_device *hid)
510{ 513{
511 struct hidraw *hidraw = hid->hidraw; 514 struct hidraw *hidraw = hid->hidraw;
512 515
516 mutex_lock(&minors_lock);
513 hidraw->exist = 0; 517 hidraw->exist = 0;
514 518
515 device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor)); 519 device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor));
516 520
517 mutex_lock(&minors_lock);
518 hidraw_table[hidraw->minor] = NULL; 521 hidraw_table[hidraw->minor] = NULL;
519 mutex_unlock(&minors_lock);
520 522
521 if (hidraw->open) { 523 if (hidraw->open) {
522 hid_hw_close(hid); 524 hid_hw_close(hid);
@@ -524,6 +526,7 @@ void hidraw_disconnect(struct hid_device *hid)
524 } else { 526 } else {
525 kfree(hidraw); 527 kfree(hidraw);
526 } 528 }
529 mutex_unlock(&minors_lock);
527} 530}
528EXPORT_SYMBOL_GPL(hidraw_disconnect); 531EXPORT_SYMBOL_GPL(hidraw_disconnect);
529 532
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index ad978f5748d3..77e705c2209c 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -1270,7 +1270,7 @@ static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid)
1270 1270
1271static void hid_cease_io(struct usbhid_device *usbhid) 1271static void hid_cease_io(struct usbhid_device *usbhid)
1272{ 1272{
1273 del_timer(&usbhid->io_retry); 1273 del_timer_sync(&usbhid->io_retry);
1274 usb_kill_urb(usbhid->urbin); 1274 usb_kill_urb(usbhid->urbin);
1275 usb_kill_urb(usbhid->urbctrl); 1275 usb_kill_urb(usbhid->urbctrl);
1276 usb_kill_urb(usbhid->urbout); 1276 usb_kill_urb(usbhid->urbout);
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 3146fdcda272..4ea464151c3b 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -80,10 +80,8 @@ static const struct hid_blacklist {
80 { USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U, HID_QUIRK_MULTI_INPUT }, 80 { USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U, HID_QUIRK_MULTI_INPUT },
81 { USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH, HID_QUIRK_MULTI_INPUT }, 81 { USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH, HID_QUIRK_MULTI_INPUT },
82 { USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH, HID_QUIRK_MULTI_INPUT }, 82 { USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH, HID_QUIRK_MULTI_INPUT },
83 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
84 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, 83 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
85 84
86 { USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
87 { USB_VENDOR_ID_WISEGROUP_LTD2, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, 85 { USB_VENDOR_ID_WISEGROUP_LTD2, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
88 86
89 { USB_VENDOR_ID_PI_ENGINEERING, USB_DEVICE_ID_PI_ENGINEERING_VEC_USB_FOOTPEDAL, HID_QUIRK_HIDINPUT_FORCE }, 87 { USB_VENDOR_ID_PI_ENGINEERING, USB_DEVICE_ID_PI_ENGINEERING_VEC_USB_FOOTPEDAL, HID_QUIRK_HIDINPUT_FORCE },
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 7c1188b53c3e..4ef02b269a71 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -641,6 +641,8 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
641 struct usb_device *dev = hid_to_usb_dev(hid); 641 struct usb_device *dev = hid_to_usb_dev(hid);
642 struct usbhid_device *usbhid = hid->driver_data; 642 struct usbhid_device *usbhid = hid->driver_data;
643 643
644 memset(&dinfo, 0, sizeof(dinfo));
645
644 dinfo.bustype = BUS_USB; 646 dinfo.bustype = BUS_USB;
645 dinfo.busnum = dev->bus->busnum; 647 dinfo.busnum = dev->bus->busnum;
646 dinfo.devnum = dev->devnum; 648 dinfo.devnum = dev->devnum;
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 9cf8e7ae7450..deed5f9a1e1c 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -71,6 +71,7 @@
71#include <linux/timer.h> 71#include <linux/timer.h>
72#include <linux/workqueue.h> 72#include <linux/workqueue.h>
73#include <linux/input.h> 73#include <linux/input.h>
74#include <linux/semaphore.h>
74 75
75/* 76/*
76 * We parse each description item into this structure. Short items data 77 * We parse each description item into this structure. Short items data
@@ -312,6 +313,7 @@ struct hid_item {
312#define HID_QUIRK_BADPAD 0x00000020 313#define HID_QUIRK_BADPAD 0x00000020
313#define HID_QUIRK_MULTI_INPUT 0x00000040 314#define HID_QUIRK_MULTI_INPUT 0x00000040
314#define HID_QUIRK_HIDINPUT_FORCE 0x00000080 315#define HID_QUIRK_HIDINPUT_FORCE 0x00000080
316#define HID_QUIRK_MULTITOUCH 0x00000100
315#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000 317#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000
316#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000 318#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000
317#define HID_QUIRK_NO_INIT_REPORTS 0x20000000 319#define HID_QUIRK_NO_INIT_REPORTS 0x20000000
@@ -475,6 +477,7 @@ struct hid_device { /* device report descriptor */
475 unsigned country; /* HID country */ 477 unsigned country; /* HID country */
476 struct hid_report_enum report_enum[HID_REPORT_TYPES]; 478 struct hid_report_enum report_enum[HID_REPORT_TYPES];
477 479
480 struct semaphore driver_lock; /* protects the current driver */
478 struct device dev; /* device */ 481 struct device dev; /* device */
479 struct hid_driver *driver; 482 struct hid_driver *driver;
480 struct hid_ll_driver *ll_driver; 483 struct hid_ll_driver *ll_driver;
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-06 06:45:50 -0500