aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/hid/hid-transport.txt317
-rw-r--r--Documentation/hid/uhid.txt11
-rw-r--r--drivers/hid/Kconfig19
-rw-r--r--drivers/hid/Makefile1
-rw-r--r--drivers/hid/hid-core.c52
-rw-r--r--drivers/hid/hid-cp2112.c1073
-rw-r--r--drivers/hid/hid-hyperv.c10
-rw-r--r--drivers/hid/hid-ids.h5
-rw-r--r--drivers/hid/hid-input.c21
-rw-r--r--drivers/hid/hid-lg.c6
-rw-r--r--drivers/hid/hid-logitech-dj.c111
-rw-r--r--drivers/hid/hid-magicmouse.c4
-rw-r--r--drivers/hid/hid-microsoft.c74
-rw-r--r--drivers/hid/hid-multitouch.c281
-rw-r--r--drivers/hid/hid-sensor-hub.c217
-rw-r--r--drivers/hid/hid-sony.c808
-rw-r--r--drivers/hid/hid-thingm.c4
-rw-r--r--drivers/hid/hid-wacom.c28
-rw-r--r--drivers/hid/hid-wiimote-core.c4
-rw-r--r--drivers/hid/hidraw.c27
-rw-r--r--drivers/hid/i2c-hid/i2c-hid.c139
-rw-r--r--drivers/hid/uhid.c103
-rw-r--r--drivers/hid/usbhid/hid-core.c102
-rw-r--r--drivers/iio/common/hid-sensors/hid-sensor-trigger.c39
-rw-r--r--include/linux/hid-sensor-hub.h9
-rw-r--r--include/linux/hid-sensor-ids.h16
-rw-r--r--include/linux/hid.h76
-rw-r--r--include/uapi/linux/uhid.h23
-rw-r--r--net/bluetooth/hidp/core.c100
29 files changed, 3022 insertions, 658 deletions
diff --git a/Documentation/hid/hid-transport.txt b/Documentation/hid/hid-transport.txt
new file mode 100644
index 000000000000..3dcba9fd4a3a
--- /dev/null
+++ b/Documentation/hid/hid-transport.txt
@@ -0,0 +1,317 @@
1 HID I/O Transport Drivers
2 ===========================
3
4The HID subsystem is independent of the underlying transport driver. Initially,
5only USB was supported, but other specifications adopted the HID design and
6provided new transport drivers. The kernel includes at least support for USB,
7Bluetooth, I2C and user-space I/O drivers.
8
91) HID Bus
10==========
11
12The HID subsystem is designed as a bus. Any I/O subsystem may provide HID
13devices and register them with the HID bus. HID core then loads generic device
14drivers on top of it. The transport drivers are responsible of raw data
15transport and device setup/management. HID core is responsible of
16report-parsing, report interpretation and the user-space API. Device specifics
17and quirks are handled by all layers depending on the quirk.
18
19 +-----------+ +-----------+ +-----------+ +-----------+
20 | Device #1 | | Device #i | | Device #j | | Device #k |
21 +-----------+ +-----------+ +-----------+ +-----------+
22 \\ // \\ //
23 +------------+ +------------+
24 | I/O Driver | | I/O Driver |
25 +------------+ +------------+
26 || ||
27 +------------------+ +------------------+
28 | Transport Driver | | Transport Driver |
29 +------------------+ +------------------+
30 \___ ___/
31 \ /
32 +----------------+
33 | HID Core |
34 +----------------+
35 / | | \
36 / | | \
37 ____________/ | | \_________________
38 / | | \
39 / | | \
40 +----------------+ +-----------+ +------------------+ +------------------+
41 | Generic Driver | | MT Driver | | Custom Driver #1 | | Custom Driver #2 |
42 +----------------+ +-----------+ +------------------+ +------------------+
43
44Example Drivers:
45 I/O: USB, I2C, Bluetooth-l2cap
46 Transport: USB-HID, I2C-HID, BT-HIDP
47
48Everything below "HID Core" is simplified in this graph as it is only of
49interest to HID device drivers. Transport drivers do not need to know the
50specifics.
51
521.1) Device Setup
53-----------------
54
55I/O drivers normally provide hotplug detection or device enumeration APIs to the
56transport drivers. Transport drivers use this to find any suitable HID device.
57They allocate HID device objects and register them with HID core. Transport
58drivers are not required to register themselves with HID core. HID core is never
59aware of which transport drivers are available and is not interested in it. It
60is only interested in devices.
61
62Transport drivers attach a constant "struct hid_ll_driver" object with each
63device. Once a device is registered with HID core, the callbacks provided via
64this struct are used by HID core to communicate with the device.
65
66Transport drivers are responsible of detecting device failures and unplugging.
67HID core will operate a device as long as it is registered regardless of any
68device failures. Once transport drivers detect unplug or failure events, they
69must unregister the device from HID core and HID core will stop using the
70provided callbacks.
71
721.2) Transport Driver Requirements
73----------------------------------
74
75The terms "asynchronous" and "synchronous" in this document describe the
76transmission behavior regarding acknowledgements. An asynchronous channel must
77not perform any synchronous operations like waiting for acknowledgements or
78verifications. Generally, HID calls operating on asynchronous channels must be
79running in atomic-context just fine.
80On the other hand, synchronous channels can be implemented by the transport
81driver in whatever way they like. They might just be the same as asynchronous
82channels, but they can also provide acknowledgement reports, automatic
83retransmission on failure, etc. in a blocking manner. If such functionality is
84required on asynchronous channels, a transport-driver must implement that via
85its own worker threads.
86
87HID core requires transport drivers to follow a given design. A Transport
88driver must provide two bi-directional I/O channels to each HID device. These
89channels must not necessarily be bi-directional in the hardware itself. A
90transport driver might just provide 4 uni-directional channels. Or it might
91multiplex all four on a single physical channel. However, in this document we
92will describe them as two bi-directional channels as they have several
93properties in common.
94
95 - Interrupt Channel (intr): The intr channel is used for asynchronous data
96 reports. No management commands or data acknowledgements are sent on this
97 channel. Any unrequested incoming or outgoing data report must be sent on
98 this channel and is never acknowledged by the remote side. Devices usually
99 send their input events on this channel. Outgoing events are normally
100 not send via intr, except if high throughput is required.
101 - Control Channel (ctrl): The ctrl channel is used for synchronous requests and
102 device management. Unrequested data input events must not be sent on this
103 channel and are normally ignored. Instead, devices only send management
104 events or answers to host requests on this channel.
105 The control-channel is used for direct blocking queries to the device
106 independent of any events on the intr-channel.
107 Outgoing reports are usually sent on the ctrl channel via synchronous
108 SET_REPORT requests.
109
110Communication between devices and HID core is mostly done via HID reports. A
111report can be of one of three types:
112
113 - INPUT Report: Input reports provide data from device to host. This
114 data may include button events, axis events, battery status or more. This
115 data is generated by the device and sent to the host with or without
116 requiring explicit requests. Devices can choose to send data continuously or
117 only on change.
118 - OUTPUT Report: Output reports change device states. They are sent from host
119 to device and may include LED requests, rumble requests or more. Output
120 reports are never sent from device to host, but a host can retrieve their
121 current state.
122 Hosts may choose to send output reports either continuously or only on
123 change.
124 - FEATURE Report: Feature reports are used for specific static device features
125 and never reported spontaneously. A host can read and/or write them to access
126 data like battery-state or device-settings.
127 Feature reports are never sent without requests. A host must explicitly set
128 or retrieve a feature report. This also means, feature reports are never sent
129 on the intr channel as this channel is asynchronous.
130
131INPUT and OUTPUT reports can be sent as pure data reports on the intr channel.
132For INPUT reports this is the usual operational mode. But for OUTPUT reports,
133this is rarely done as OUTPUT reports are normally quite scarce. But devices are
134free to make excessive use of asynchronous OUTPUT reports (for instance, custom
135HID audio speakers make great use of it).
136
137Plain reports must not be sent on the ctrl channel, though. Instead, the ctrl
138channel provides synchronous GET/SET_REPORT requests. Plain reports are only
139allowed on the intr channel and are the only means of data there.
140
141 - GET_REPORT: A GET_REPORT request has a report ID as payload and is sent
142 from host to device. The device must answer with a data report for the
143 requested report ID on the ctrl channel as a synchronous acknowledgement.
144 Only one GET_REPORT request can be pending for each device. This restriction
145 is enforced by HID core as several transport drivers don't allow multiple
146 simultaneous GET_REPORT requests.
147 Note that data reports which are sent as answer to a GET_REPORT request are
148 not handled as generic device events. That is, if a device does not operate
149 in continuous data reporting mode, an answer to GET_REPORT does not replace
150 the raw data report on the intr channel on state change.
151 GET_REPORT is only used by custom HID device drivers to query device state.
152 Normally, HID core caches any device state so this request is not necessary
153 on devices that follow the HID specs except during device initialization to
154 retrieve the current state.
155 GET_REPORT requests can be sent for any of the 3 report types and shall
156 return the current report state of the device. However, OUTPUT reports as
157 payload may be blocked by the underlying transport driver if the
158 specification does not allow them.
159 - SET_REPORT: A SET_REPORT request has a report ID plus data as payload. It is
160 sent from host to device and a device must update it's current report state
161 according to the given data. Any of the 3 report types can be used. However,
162 INPUT reports as payload might be blocked by the underlying transport driver
163 if the specification does not allow them.
164 A device must answer with a synchronous acknowledgement. However, HID core
165 does not require transport drivers to forward this acknowledgement to HID
166 core.
167 Same as for GET_REPORT, only one SET_REPORT can be pending at a time. This
168 restriction is enforced by HID core as some transport drivers do not support
169 multiple synchronous SET_REPORT requests.
170
171Other ctrl-channel requests are supported by USB-HID but are not available
172(or deprecated) in most other transport level specifications:
173
174 - GET/SET_IDLE: Only used by USB-HID and I2C-HID.
175 - GET/SET_PROTOCOL: Not used by HID core.
176 - RESET: Used by I2C-HID, not hooked up in HID core.
177 - SET_POWER: Used by I2C-HID, not hooked up in HID core.
178
1792) HID API
180==========
181
1822.1) Initialization
183-------------------
184
185Transport drivers normally use the following procedure to register a new device
186with HID core:
187
188 struct hid_device *hid;
189 int ret;
190
191 hid = hid_allocate_device();
192 if (IS_ERR(hid)) {
193 ret = PTR_ERR(hid);
194 goto err_<...>;
195 }
196
197 strlcpy(hid->name, <device-name-src>, 127);
198 strlcpy(hid->phys, <device-phys-src>, 63);
199 strlcpy(hid->uniq, <device-uniq-src>, 63);
200
201 hid->ll_driver = &custom_ll_driver;
202 hid->bus = <device-bus>;
203 hid->vendor = <device-vendor>;
204 hid->product = <device-product>;
205 hid->version = <device-version>;
206 hid->country = <device-country>;
207 hid->dev.parent = <pointer-to-parent-device>;
208 hid->driver_data = <transport-driver-data-field>;
209
210 ret = hid_add_device(hid);
211 if (ret)
212 goto err_<...>;
213
214Once hid_add_device() is entered, HID core might use the callbacks provided in
215"custom_ll_driver". Note that fields like "country" can be ignored by underlying
216transport-drivers if not supported.
217
218To unregister a device, use:
219
220 hid_destroy_device(hid);
221
222Once hid_destroy_device() returns, HID core will no longer make use of any
223driver callbacks.
224
2252.2) hid_ll_driver operations
226-----------------------------
227
228The available HID callbacks are:
229 - int (*start) (struct hid_device *hdev)
230 Called from HID device drivers once they want to use the device. Transport
231 drivers can choose to setup their device in this callback. However, normally
232 devices are already set up before transport drivers register them to HID core
233 so this is mostly only used by USB-HID.
234
235 - void (*stop) (struct hid_device *hdev)
236 Called from HID device drivers once they are done with a device. Transport
237 drivers can free any buffers and deinitialize the device. But note that
238 ->start() might be called again if another HID device driver is loaded on the
239 device.
240 Transport drivers are free to ignore it and deinitialize devices after they
241 destroyed them via hid_destroy_device().
242
243 - int (*open) (struct hid_device *hdev)
244 Called from HID device drivers once they are interested in data reports.
245 Usually, while user-space didn't open any input API/etc., device drivers are
246 not interested in device data and transport drivers can put devices asleep.
247 However, once ->open() is called, transport drivers must be ready for I/O.
248 ->open() calls are nested for each client that opens the HID device.
249
250 - void (*close) (struct hid_device *hdev)
251 Called from HID device drivers after ->open() was called but they are no
252 longer interested in device reports. (Usually if user-space closed any input
253 devices of the driver).
254 Transport drivers can put devices asleep and terminate any I/O of all
255 ->open() calls have been followed by a ->close() call. However, ->start() may
256 be called again if the device driver is interested in input reports again.
257
258 - int (*parse) (struct hid_device *hdev)
259 Called once during device setup after ->start() has been called. Transport
260 drivers must read the HID report-descriptor from the device and tell HID core
261 about it via hid_parse_report().
262
263 - int (*power) (struct hid_device *hdev, int level)
264 Called by HID core to give PM hints to transport drivers. Usually this is
265 analogical to the ->open() and ->close() hints and redundant.
266
267 - void (*request) (struct hid_device *hdev, struct hid_report *report,
268 int reqtype)
269 Send an HID request on the ctrl channel. "report" contains the report that
270 should be sent and "reqtype" the request type. Request-type can be
271 HID_REQ_SET_REPORT or HID_REQ_GET_REPORT.
272 This callback is optional. If not provided, HID core will assemble a raw
273 report following the HID specs and send it via the ->raw_request() callback.
274 The transport driver is free to implement this asynchronously.
275
276 - int (*wait) (struct hid_device *hdev)
277 Used by HID core before calling ->request() again. A transport driver can use
278 it to wait for any pending requests to complete if only one request is
279 allowed at a time.
280
281 - int (*raw_request) (struct hid_device *hdev, unsigned char reportnum,
282 __u8 *buf, size_t count, unsigned char rtype,
283 int reqtype)
284 Same as ->request() but provides the report as raw buffer. This request shall
285 be synchronous. A transport driver must not use ->wait() to complete such
286 requests. This request is mandatory and hid core will reject the device if
287 it is missing.
288
289 - int (*output_report) (struct hid_device *hdev, __u8 *buf, size_t len)
290 Send raw output report via intr channel. Used by some HID device drivers
291 which require high throughput for outgoing requests on the intr channel. This
292 must not cause SET_REPORT calls! This must be implemented as asynchronous
293 output report on the intr channel!
294
295 - int (*idle) (struct hid_device *hdev, int report, int idle, int reqtype)
296 Perform SET/GET_IDLE request. Only used by USB-HID, do not implement!
297
2982.3) Data Path
299--------------
300
301Transport drivers are responsible of reading data from I/O devices. They must
302handle any I/O-related state-tracking themselves. HID core does not implement
303protocol handshakes or other management commands which can be required by the
304given HID transport specification.
305
306Every raw data packet read from a device must be fed into HID core via
307hid_input_report(). You must specify the channel-type (intr or ctrl) and report
308type (input/output/feature). Under normal conditions, only input reports are
309provided via this API.
310
311Responses to GET_REPORT requests via ->request() must also be provided via this
312API. Responses to ->raw_request() are synchronous and must be intercepted by the
313transport driver and not passed to hid_input_report().
314Acknowledgements to SET_REPORT requests are not of interest to HID core.
315
316----------------------------------------------------
317Written 2013, David Herrmann <dh.herrmann@gmail.com>
diff --git a/Documentation/hid/uhid.txt b/Documentation/hid/uhid.txt
index dc35a2b75eee..ee6593608c8e 100644
--- a/Documentation/hid/uhid.txt
+++ b/Documentation/hid/uhid.txt
@@ -93,6 +93,11 @@ the request was handled successfully.
93 event to the kernel. The payload is of type struct uhid_create_req and 93 event to the kernel. The payload is of type struct uhid_create_req and
94 contains information about your device. You can start I/O now. 94 contains information about your device. You can start I/O now.
95 95
96 UHID_CREATE2:
97 Same as UHID_CREATE, but the HID report descriptor data (rd_data) is an array
98 inside struct uhid_create2_req, instead of a pointer to a separate array.
99 Enables use from languages that don't support pointers, e.g. Python.
100
96 UHID_DESTROY: 101 UHID_DESTROY:
97 This destroys the internal HID device. No further I/O will be accepted. There 102 This destroys the internal HID device. No further I/O will be accepted. There
98 may still be pending messages that you can receive with read() but no further 103 may still be pending messages that you can receive with read() but no further
@@ -105,6 +110,12 @@ the request was handled successfully.
105 contains a data-payload. This is the raw data that you read from your device. 110 contains a data-payload. This is the raw data that you read from your device.
106 The kernel will parse the HID reports and react on it. 111 The kernel will parse the HID reports and react on it.
107 112
113 UHID_INPUT2:
114 Same as UHID_INPUT, but the data array is the last field of uhid_input2_req.
115 Enables userspace to write only the required bytes to kernel (ev.type +
116 ev.u.input2.size + the part of the data array that matters), instead of
117 the entire struct uhid_input2_req.
118
108 UHID_FEATURE_ANSWER: 119 UHID_FEATURE_ANSWER:
109 If you receive a UHID_FEATURE request you must answer with this request. You 120 If you receive a UHID_FEATURE request you must answer with this request. You
110 must copy the "id" field from the request into the answer. Set the "err" field 121 must copy the "id" field from the request into the answer. Set the "err" field
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index f7220011a00b..7af9d0b5dea1 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -175,6 +175,15 @@ config HID_PRODIKEYS
175 multimedia keyboard, but will lack support for the musical keyboard 175 multimedia keyboard, but will lack support for the musical keyboard
176 and some additional multimedia keys. 176 and some additional multimedia keys.
177 177
178config HID_CP2112
179 tristate "Silicon Labs CP2112 HID USB-to-SMBus Bridge support"
180 depends on USB_HID && I2C && GPIOLIB
181 ---help---
182 Support for Silicon Labs CP2112 HID USB to SMBus Master Bridge.
183 This is a HID device driver which registers as an i2c adapter
184 and gpiochip to expose these functions of the CP2112. The
185 customizable USB descriptor fields are exposed as sysfs attributes.
186
178config HID_CYPRESS 187config HID_CYPRESS
179 tristate "Cypress mouse and barcode readers" if EXPERT 188 tristate "Cypress mouse and barcode readers" if EXPERT
180 depends on HID 189 depends on HID
@@ -608,25 +617,27 @@ config HID_SAMSUNG
608 Support for Samsung InfraRed remote control or keyboards. 617 Support for Samsung InfraRed remote control or keyboards.
609 618
610config HID_SONY 619config HID_SONY
611 tristate "Sony PS2/3 accessories" 620 tristate "Sony PS2/3/4 accessories"
612 depends on USB_HID 621 depends on USB_HID
613 depends on NEW_LEDS 622 depends on NEW_LEDS
614 depends on LEDS_CLASS 623 depends on LEDS_CLASS
624 select POWER_SUPPLY
615 ---help--- 625 ---help---
616 Support for 626 Support for
617 627
618 * Sony PS3 6-axis controllers 628 * Sony PS3 6-axis controllers
629 * Sony PS4 DualShock 4 controllers
619 * Buzz controllers 630 * Buzz controllers
620 * Sony PS3 Blue-ray Disk Remote Control (Bluetooth) 631 * Sony PS3 Blue-ray Disk Remote Control (Bluetooth)
621 * Logitech Harmony adapter for Sony Playstation 3 (Bluetooth) 632 * Logitech Harmony adapter for Sony Playstation 3 (Bluetooth)
622 633
623config SONY_FF 634config SONY_FF
624 bool "Sony PS2/3 accessories force feedback support" 635 bool "Sony PS2/3/4 accessories force feedback support"
625 depends on HID_SONY 636 depends on HID_SONY
626 select INPUT_FF_MEMLESS 637 select INPUT_FF_MEMLESS
627 ---help--- 638 ---help---
628 Say Y here if you have a Sony PS2/3 accessory and want to enable force 639 Say Y here if you have a Sony PS2/3/4 accessory and want to enable
629 feedback support for it. 640 force feedback support for it.
630 641
631config HID_SPEEDLINK 642config HID_SPEEDLINK
632 tristate "Speedlink VAD Cezanne mouse support" 643 tristate "Speedlink VAD Cezanne mouse support"
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 30e44318f87f..fc712dde02a4 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_HID_AUREAL) += hid-aureal.o
41obj-$(CONFIG_HID_BELKIN) += hid-belkin.o 41obj-$(CONFIG_HID_BELKIN) += hid-belkin.o
42obj-$(CONFIG_HID_CHERRY) += hid-cherry.o 42obj-$(CONFIG_HID_CHERRY) += hid-cherry.o
43obj-$(CONFIG_HID_CHICONY) += hid-chicony.o 43obj-$(CONFIG_HID_CHICONY) += hid-chicony.o
44obj-$(CONFIG_HID_CP2112) += hid-cp2112.o
44obj-$(CONFIG_HID_CYPRESS) += hid-cypress.o 45obj-$(CONFIG_HID_CYPRESS) += hid-cypress.o
45obj-$(CONFIG_HID_DRAGONRISE) += hid-dr.o 46obj-$(CONFIG_HID_DRAGONRISE) += hid-dr.o
46obj-$(CONFIG_HID_EMS_FF) += hid-emsff.o 47obj-$(CONFIG_HID_EMS_FF) += hid-emsff.o
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 2448d757b449..9e8064205bc7 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1248,6 +1248,11 @@ void hid_output_report(struct hid_report *report, __u8 *data)
1248} 1248}
1249EXPORT_SYMBOL_GPL(hid_output_report); 1249EXPORT_SYMBOL_GPL(hid_output_report);
1250 1250
1251static int hid_report_len(struct hid_report *report)
1252{
1253 return ((report->size - 1) >> 3) + 1 + (report->id > 0) + 7;
1254}
1255
1251/* 1256/*
1252 * Allocator for buffer that is going to be passed to hid_output_report() 1257 * Allocator for buffer that is going to be passed to hid_output_report()
1253 */ 1258 */
@@ -1258,7 +1263,7 @@ u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)
1258 * of implement() working on 8 byte chunks 1263 * of implement() working on 8 byte chunks
1259 */ 1264 */
1260 1265
1261 int len = ((report->size - 1) >> 3) + 1 + (report->id > 0) + 7; 1266 int len = hid_report_len(report);
1262 1267
1263 return kmalloc(len, flags); 1268 return kmalloc(len, flags);
1264} 1269}
@@ -1314,6 +1319,41 @@ static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
1314 return report; 1319 return report;
1315} 1320}
1316 1321
1322/*
1323 * Implement a generic .request() callback, using .raw_request()
1324 * DO NOT USE in hid drivers directly, but through hid_hw_request instead.
1325 */
1326void __hid_request(struct hid_device *hid, struct hid_report *report,
1327 int reqtype)
1328{
1329 char *buf;
1330 int ret;
1331 int len;
1332
1333 buf = hid_alloc_report_buf(report, GFP_KERNEL);
1334 if (!buf)
1335 return;
1336
1337 len = hid_report_len(report);
1338
1339 if (reqtype == HID_REQ_SET_REPORT)
1340 hid_output_report(report, buf);
1341
1342 ret = hid->ll_driver->raw_request(hid, report->id, buf, len,
1343 report->type, reqtype);
1344 if (ret < 0) {
1345 dbg_hid("unable to complete request: %d\n", ret);
1346 goto out;
1347 }
1348
1349 if (reqtype == HID_REQ_GET_REPORT)
1350 hid_input_report(hid, report->type, buf, ret, 0);
1351
1352out:
1353 kfree(buf);
1354}
1355EXPORT_SYMBOL_GPL(__hid_request);
1356
1317int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size, 1357int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
1318 int interrupt) 1358 int interrupt)
1319{ 1359{
@@ -1693,6 +1733,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
1693 { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) }, 1733 { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
1694 { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) }, 1734 { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) },
1695 { HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) }, 1735 { HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
1736 { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
1696 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) }, 1737 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
1697 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) }, 1738 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
1698 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) }, 1739 { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },
@@ -1782,6 +1823,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
1782 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) }, 1823 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
1783 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_2) }, 1824 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_2) },
1784 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2) }, 1825 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2) },
1826 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB) },
1785 { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) }, 1827 { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
1786 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) }, 1828 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
1787 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) }, 1829 { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
@@ -2434,6 +2476,14 @@ int hid_add_device(struct hid_device *hdev)
2434 return -ENODEV; 2476 return -ENODEV;
2435 2477
2436 /* 2478 /*
2479 * Check for the mandatory transport channel.
2480 */
2481 if (!hdev->ll_driver->raw_request) {
2482 hid_err(hdev, "transport driver missing .raw_request()\n");
2483 return -EINVAL;
2484 }
2485
2486 /*
2437 * Read the device report descriptor once and use as template 2487 * Read the device report descriptor once and use as template
2438 * for the driver-specific modifications. 2488 * for the driver-specific modifications.
2439 */ 2489 */
diff --git a/drivers/hid/hid-cp2112.c b/drivers/hid/hid-cp2112.c
new file mode 100644
index 000000000000..56be85a9a77c
--- /dev/null
+++ b/drivers/hid/hid-cp2112.c
@@ -0,0 +1,1073 @@
1/*
2 * hid-cp2112.c - Silicon Labs HID USB to SMBus master bridge
3 * Copyright (c) 2013,2014 Uplogix, Inc.
4 * David Barksdale <dbarksdale@uplogix.com>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16/*
17 * The Silicon Labs CP2112 chip is a USB HID device which provides an
18 * SMBus controller for talking to slave devices and 8 GPIO pins. The
19 * host communicates with the CP2112 via raw HID reports.
20 *
21 * Data Sheet:
22 * http://www.silabs.com/Support%20Documents/TechnicalDocs/CP2112.pdf
23 * Programming Interface Specification:
24 * http://www.silabs.com/Support%20Documents/TechnicalDocs/AN495.pdf
25 */
26
27#include <linux/gpio.h>
28#include <linux/hid.h>
29#include <linux/i2c.h>
30#include <linux/module.h>
31#include <linux/nls.h>
32#include <linux/usb/ch9.h>
33#include "hid-ids.h"
34
35enum {
36 CP2112_GPIO_CONFIG = 0x02,
37 CP2112_GPIO_GET = 0x03,
38 CP2112_GPIO_SET = 0x04,
39 CP2112_GET_VERSION_INFO = 0x05,
40 CP2112_SMBUS_CONFIG = 0x06,
41 CP2112_DATA_READ_REQUEST = 0x10,
42 CP2112_DATA_WRITE_READ_REQUEST = 0x11,
43 CP2112_DATA_READ_FORCE_SEND = 0x12,
44 CP2112_DATA_READ_RESPONSE = 0x13,
45 CP2112_DATA_WRITE_REQUEST = 0x14,
46 CP2112_TRANSFER_STATUS_REQUEST = 0x15,
47 CP2112_TRANSFER_STATUS_RESPONSE = 0x16,
48 CP2112_CANCEL_TRANSFER = 0x17,
49 CP2112_LOCK_BYTE = 0x20,
50 CP2112_USB_CONFIG = 0x21,
51 CP2112_MANUFACTURER_STRING = 0x22,
52 CP2112_PRODUCT_STRING = 0x23,
53 CP2112_SERIAL_STRING = 0x24,
54};
55
56enum {
57 STATUS0_IDLE = 0x00,
58 STATUS0_BUSY = 0x01,
59 STATUS0_COMPLETE = 0x02,
60 STATUS0_ERROR = 0x03,
61};
62
63enum {
64 STATUS1_TIMEOUT_NACK = 0x00,
65 STATUS1_TIMEOUT_BUS = 0x01,
66 STATUS1_ARBITRATION_LOST = 0x02,
67 STATUS1_READ_INCOMPLETE = 0x03,
68 STATUS1_WRITE_INCOMPLETE = 0x04,
69 STATUS1_SUCCESS = 0x05,
70};
71
72struct cp2112_smbus_config_report {
73 u8 report; /* CP2112_SMBUS_CONFIG */
74 __be32 clock_speed; /* Hz */
75 u8 device_address; /* Stored in the upper 7 bits */
76 u8 auto_send_read; /* 1 = enabled, 0 = disabled */
77 __be16 write_timeout; /* ms, 0 = no timeout */
78 __be16 read_timeout; /* ms, 0 = no timeout */
79 u8 scl_low_timeout; /* 1 = enabled, 0 = disabled */
80 __be16 retry_time; /* # of retries, 0 = no limit */
81} __packed;
82
83struct cp2112_usb_config_report {
84 u8 report; /* CP2112_USB_CONFIG */
85 __le16 vid; /* Vendor ID */
86 __le16 pid; /* Product ID */
87 u8 max_power; /* Power requested in 2mA units */
88 u8 power_mode; /* 0x00 = bus powered
89 0x01 = self powered & regulator off
90 0x02 = self powered & regulator on */
91 u8 release_major;
92 u8 release_minor;
93 u8 mask; /* What fields to program */
94} __packed;
95
96struct cp2112_read_req_report {
97 u8 report; /* CP2112_DATA_READ_REQUEST */
98 u8 slave_address;
99 __be16 length;
100} __packed;
101
102struct cp2112_write_read_req_report {
103 u8 report; /* CP2112_DATA_WRITE_READ_REQUEST */
104 u8 slave_address;
105 __be16 length;
106 u8 target_address_length;
107 u8 target_address[16];
108} __packed;
109
110struct cp2112_write_req_report {
111 u8 report; /* CP2112_DATA_WRITE_REQUEST */
112 u8 slave_address;
113 u8 length;
114 u8 data[61];
115} __packed;
116
117struct cp2112_force_read_report {
118 u8 report; /* CP2112_DATA_READ_FORCE_SEND */
119 __be16 length;
120} __packed;
121
122struct cp2112_xfer_status_report {
123 u8 report; /* CP2112_TRANSFER_STATUS_RESPONSE */
124 u8 status0; /* STATUS0_* */
125 u8 status1; /* STATUS1_* */
126 __be16 retries;
127 __be16 length;
128} __packed;
129
130struct cp2112_string_report {
131 u8 dummy; /* force .string to be aligned */
132 u8 report; /* CP2112_*_STRING */
133 u8 length; /* length in bytes of everyting after .report */
134 u8 type; /* USB_DT_STRING */
135 wchar_t string[30]; /* UTF16_LITTLE_ENDIAN string */
136} __packed;
137
138/* Number of times to request transfer status before giving up waiting for a
139 transfer to complete. This may need to be changed if SMBUS clock, retries,
140 or read/write/scl_low timeout settings are changed. */
141static const int XFER_STATUS_RETRIES = 10;
142
143/* Time in ms to wait for a CP2112_DATA_READ_RESPONSE or
144 CP2112_TRANSFER_STATUS_RESPONSE. */
145static const int RESPONSE_TIMEOUT = 50;
146
147static const struct hid_device_id cp2112_devices[] = {
148 { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
149 { }
150};
151MODULE_DEVICE_TABLE(hid, cp2112_devices);
152
153struct cp2112_device {
154 struct i2c_adapter adap;
155 struct hid_device *hdev;
156 wait_queue_head_t wait;
157 u8 read_data[61];
158 u8 read_length;
159 int xfer_status;
160 atomic_t read_avail;
161 atomic_t xfer_avail;
162 struct gpio_chip gc;
163};
164
165static int gpio_push_pull = 0xFF;
166module_param(gpio_push_pull, int, S_IRUGO | S_IWUSR);
167MODULE_PARM_DESC(gpio_push_pull, "GPIO push-pull configuration bitmask");
168
169static int cp2112_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
170{
171 struct cp2112_device *dev = container_of(chip, struct cp2112_device,
172 gc);
173 struct hid_device *hdev = dev->hdev;
174 u8 buf[5];
175 int ret;
176
177 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
178 sizeof(buf), HID_FEATURE_REPORT,
179 HID_REQ_GET_REPORT);
180 if (ret != sizeof(buf)) {
181 hid_err(hdev, "error requesting GPIO config: %d\n", ret);
182 return ret;
183 }
184
185 buf[1] &= ~(1 << offset);
186 buf[2] = gpio_push_pull;
187
188 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, sizeof(buf),
189 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
190 if (ret < 0) {
191 hid_err(hdev, "error setting GPIO config: %d\n", ret);
192 return ret;
193 }
194
195 return 0;
196}
197
198static void cp2112_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
199{
200 struct cp2112_device *dev = container_of(chip, struct cp2112_device,
201 gc);
202 struct hid_device *hdev = dev->hdev;
203 u8 buf[3];
204 int ret;
205
206 buf[0] = CP2112_GPIO_SET;
207 buf[1] = value ? 0xff : 0;
208 buf[2] = 1 << offset;
209
210 ret = hid_hw_raw_request(hdev, CP2112_GPIO_SET, buf, sizeof(buf),
211 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
212 if (ret < 0)
213 hid_err(hdev, "error setting GPIO values: %d\n", ret);
214}
215
216static int cp2112_gpio_get(struct gpio_chip *chip, unsigned offset)
217{
218 struct cp2112_device *dev = container_of(chip, struct cp2112_device,
219 gc);
220 struct hid_device *hdev = dev->hdev;
221 u8 buf[2];
222 int ret;
223
224 ret = hid_hw_raw_request(hdev, CP2112_GPIO_GET, buf, sizeof(buf),
225 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
226 if (ret != sizeof(buf)) {
227 hid_err(hdev, "error requesting GPIO values: %d\n", ret);
228 return ret;
229 }
230
231 return (buf[1] >> offset) & 1;
232}
233
234static int cp2112_gpio_direction_output(struct gpio_chip *chip,
235 unsigned offset, int value)
236{
237 struct cp2112_device *dev = container_of(chip, struct cp2112_device,
238 gc);
239 struct hid_device *hdev = dev->hdev;
240 u8 buf[5];
241 int ret;
242
243 cp2112_gpio_set(chip, offset, value);
244
245 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf,
246 sizeof(buf), HID_FEATURE_REPORT,
247 HID_REQ_GET_REPORT);
248 if (ret != sizeof(buf)) {
249 hid_err(hdev, "error requesting GPIO config: %d\n", ret);
250 return ret;
251 }
252
253 buf[1] |= 1 << offset;
254 buf[2] = gpio_push_pull;
255
256 ret = hid_hw_raw_request(hdev, CP2112_GPIO_CONFIG, buf, sizeof(buf),
257 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
258 if (ret < 0) {
259 hid_err(hdev, "error setting GPIO config: %d\n", ret);
260 return ret;
261 }
262
263 return 0;
264}
265
266static int cp2112_hid_get(struct hid_device *hdev, unsigned char report_number,
267 u8 *data, size_t count, unsigned char report_type)
268{
269 u8 *buf;
270 int ret;
271
272 buf = kmalloc(count, GFP_KERNEL);
273 if (!buf)
274 return -ENOMEM;
275
276 ret = hid_hw_raw_request(hdev, report_number, buf, count,
277 report_type, HID_REQ_GET_REPORT);
278 memcpy(data, buf, count);
279 kfree(buf);
280 return ret;
281}
282
283static int cp2112_hid_output(struct hid_device *hdev, u8 *data, size_t count,
284 unsigned char report_type)
285{
286 u8 *buf;
287 int ret;
288
289 buf = kmemdup(data, count, GFP_KERNEL);
290 if (!buf)
291 return -ENOMEM;
292
293 if (report_type == HID_OUTPUT_REPORT)
294 ret = hid_hw_output_report(hdev, buf, count);
295 else
296 ret = hid_hw_raw_request(hdev, buf[0], buf, count, report_type,
297 HID_REQ_SET_REPORT);
298
299 kfree(buf);
300 return ret;
301}
302
303static int cp2112_wait(struct cp2112_device *dev, atomic_t *avail)
304{
305 int ret = 0;
306
307 /* We have sent either a CP2112_TRANSFER_STATUS_REQUEST or a
308 * CP2112_DATA_READ_FORCE_SEND and we are waiting for the response to
309 * come in cp2112_raw_event or timeout. There will only be one of these
310 * in flight at any one time. The timeout is extremely large and is a
311 * last resort if the CP2112 has died. If we do timeout we don't expect
312 * to receive the response which would cause data races, it's not like
313 * we can do anything about it anyway.
314 */
315 ret = wait_event_interruptible_timeout(dev->wait,
316 atomic_read(avail), msecs_to_jiffies(RESPONSE_TIMEOUT));
317 if (-ERESTARTSYS == ret)
318 return ret;
319 if (!ret)
320 return -ETIMEDOUT;
321
322 atomic_set(avail, 0);
323 return 0;
324}
325
326static int cp2112_xfer_status(struct cp2112_device *dev)
327{
328 struct hid_device *hdev = dev->hdev;
329 u8 buf[2];
330 int ret;
331
332 buf[0] = CP2112_TRANSFER_STATUS_REQUEST;
333 buf[1] = 0x01;
334 atomic_set(&dev->xfer_avail, 0);
335
336 ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
337 if (ret < 0) {
338 hid_warn(hdev, "Error requesting status: %d\n", ret);
339 return ret;
340 }
341
342 ret = cp2112_wait(dev, &dev->xfer_avail);
343 if (ret)
344 return ret;
345
346 return dev->xfer_status;
347}
348
349static int cp2112_read(struct cp2112_device *dev, u8 *data, size_t size)
350{
351 struct hid_device *hdev = dev->hdev;
352 struct cp2112_force_read_report report;
353 int ret;
354
355 report.report = CP2112_DATA_READ_FORCE_SEND;
356 report.length = cpu_to_be16(size);
357
358 atomic_set(&dev->read_avail, 0);
359
360 ret = cp2112_hid_output(hdev, &report.report, sizeof(report),
361 HID_OUTPUT_REPORT);
362 if (ret < 0) {
363 hid_warn(hdev, "Error requesting data: %d\n", ret);
364 return ret;
365 }
366
367 ret = cp2112_wait(dev, &dev->read_avail);
368 if (ret)
369 return ret;
370
371 hid_dbg(hdev, "read %d of %zd bytes requested\n",
372 dev->read_length, size);
373
374 if (size > dev->read_length)
375 size = dev->read_length;
376
377 memcpy(data, dev->read_data, size);
378 return dev->read_length;
379}
380
381static int cp2112_read_req(void *buf, u8 slave_address, u16 length)
382{
383 struct cp2112_read_req_report *report = buf;
384
385 if (length < 1 || length > 512)
386 return -EINVAL;
387
388 report->report = CP2112_DATA_READ_REQUEST;
389 report->slave_address = slave_address << 1;
390 report->length = cpu_to_be16(length);
391 return sizeof(*report);
392}
393
394static int cp2112_write_read_req(void *buf, u8 slave_address, u16 length,
395 u8 command, u8 *data, u8 data_length)
396{
397 struct cp2112_write_read_req_report *report = buf;
398
399 if (length < 1 || length > 512
400 || data_length > sizeof(report->target_address) - 1)
401 return -EINVAL;
402
403 report->report = CP2112_DATA_WRITE_READ_REQUEST;
404 report->slave_address = slave_address << 1;
405 report->length = cpu_to_be16(length);
406 report->target_address_length = data_length + 1;
407 report->target_address[0] = command;
408 memcpy(&report->target_address[1], data, data_length);
409 return data_length + 6;
410}
411
412static int cp2112_write_req(void *buf, u8 slave_address, u8 command, u8 *data,
413 u8 data_length)
414{
415 struct cp2112_write_req_report *report = buf;
416
417 if (data_length > sizeof(report->data) - 1)
418 return -EINVAL;
419
420 report->report = CP2112_DATA_WRITE_REQUEST;
421 report->slave_address = slave_address << 1;
422 report->length = data_length + 1;
423 report->data[0] = command;
424 memcpy(&report->data[1], data, data_length);
425 return data_length + 4;
426}
427
428static int cp2112_xfer(struct i2c_adapter *adap, u16 addr,
429 unsigned short flags, char read_write, u8 command,
430 int size, union i2c_smbus_data *data)
431{
432 struct cp2112_device *dev = (struct cp2112_device *)adap->algo_data;
433 struct hid_device *hdev = dev->hdev;
434 u8 buf[64];
435 __be16 word;
436 ssize_t count;
437 size_t read_length = 0;
438 unsigned int retries;
439 int ret;
440
441 hid_dbg(hdev, "%s addr 0x%x flags 0x%x cmd 0x%x size %d\n",
442 read_write == I2C_SMBUS_WRITE ? "write" : "read",
443 addr, flags, command, size);
444
445 switch (size) {
446 case I2C_SMBUS_BYTE:
447 read_length = 1;
448
449 if (I2C_SMBUS_READ == read_write)
450 count = cp2112_read_req(buf, addr, read_length);
451 else
452 count = cp2112_write_req(buf, addr, data->byte, NULL,
453 0);
454 break;
455 case I2C_SMBUS_BYTE_DATA:
456 read_length = 1;
457
458 if (I2C_SMBUS_READ == read_write)
459 count = cp2112_write_read_req(buf, addr, read_length,
460 command, NULL, 0);
461 else
462 count = cp2112_write_req(buf, addr, command,
463 &data->byte, 1);
464 break;
465 case I2C_SMBUS_WORD_DATA:
466 read_length = 2;
467 word = cpu_to_be16(data->word);
468
469 if (I2C_SMBUS_READ == read_write)
470 count = cp2112_write_read_req(buf, addr, read_length,
471 command, NULL, 0);
472 else
473 count = cp2112_write_req(buf, addr, command,
474 (u8 *)&word, 2);
475 break;
476 case I2C_SMBUS_PROC_CALL:
477 size = I2C_SMBUS_WORD_DATA;
478 read_write = I2C_SMBUS_READ;
479 read_length = 2;
480 word = cpu_to_be16(data->word);
481
482 count = cp2112_write_read_req(buf, addr, read_length, command,
483 (u8 *)&word, 2);
484 break;
485 case I2C_SMBUS_I2C_BLOCK_DATA:
486 size = I2C_SMBUS_BLOCK_DATA;
487 /* fallthrough */
488 case I2C_SMBUS_BLOCK_DATA:
489 if (I2C_SMBUS_READ == read_write) {
490 count = cp2112_write_read_req(buf, addr,
491 I2C_SMBUS_BLOCK_MAX,
492 command, NULL, 0);
493 } else {
494 count = cp2112_write_req(buf, addr, command,
495 data->block,
496 data->block[0] + 1);
497 }
498 break;
499 case I2C_SMBUS_BLOCK_PROC_CALL:
500 size = I2C_SMBUS_BLOCK_DATA;
501 read_write = I2C_SMBUS_READ;
502
503 count = cp2112_write_read_req(buf, addr, I2C_SMBUS_BLOCK_MAX,
504 command, data->block,
505 data->block[0] + 1);
506 break;
507 default:
508 hid_warn(hdev, "Unsupported transaction %d\n", size);
509 return -EOPNOTSUPP;
510 }
511
512 if (count < 0)
513 return count;
514
515 ret = hid_hw_power(hdev, PM_HINT_FULLON);
516 if (ret < 0) {
517 hid_err(hdev, "power management error: %d\n", ret);
518 return ret;
519 }
520
521 ret = cp2112_hid_output(hdev, buf, count, HID_OUTPUT_REPORT);
522 if (ret < 0) {
523 hid_warn(hdev, "Error starting transaction: %d\n", ret);
524 goto power_normal;
525 }
526
527 for (retries = 0; retries < XFER_STATUS_RETRIES; ++retries) {
528 ret = cp2112_xfer_status(dev);
529 if (-EBUSY == ret)
530 continue;
531 if (ret < 0)
532 goto power_normal;
533 break;
534 }
535
536 if (XFER_STATUS_RETRIES <= retries) {
537 hid_warn(hdev, "Transfer timed out, cancelling.\n");
538 buf[0] = CP2112_CANCEL_TRANSFER;
539 buf[1] = 0x01;
540
541 ret = cp2112_hid_output(hdev, buf, 2, HID_OUTPUT_REPORT);
542 if (ret < 0)
543 hid_warn(hdev, "Error cancelling transaction: %d\n",
544 ret);
545
546 ret = -ETIMEDOUT;
547 goto power_normal;
548 }
549
550 if (I2C_SMBUS_WRITE == read_write) {
551 ret = 0;
552 goto power_normal;
553 }
554
555 if (I2C_SMBUS_BLOCK_DATA == size)
556 read_length = ret;
557
558 ret = cp2112_read(dev, buf, read_length);
559 if (ret < 0)
560 goto power_normal;
561 if (ret != read_length) {
562 hid_warn(hdev, "short read: %d < %zd\n", ret, read_length);
563 ret = -EIO;
564 goto power_normal;
565 }
566
567 switch (size) {
568 case I2C_SMBUS_BYTE:
569 case I2C_SMBUS_BYTE_DATA:
570 data->byte = buf[0];
571 break;
572 case I2C_SMBUS_WORD_DATA:
573 data->word = be16_to_cpup((__be16 *)buf);
574 break;
575 case I2C_SMBUS_BLOCK_DATA:
576 if (read_length > I2C_SMBUS_BLOCK_MAX) {
577 ret = -EPROTO;
578 goto power_normal;
579 }
580
581 memcpy(data->block, buf, read_length);
582 break;
583 }
584
585 ret = 0;
586power_normal:
587 hid_hw_power(hdev, PM_HINT_NORMAL);
588 hid_dbg(hdev, "transfer finished: %d\n", ret);
589 return ret;
590}
591
592static u32 cp2112_functionality(struct i2c_adapter *adap)
593{
594 return I2C_FUNC_SMBUS_BYTE |
595 I2C_FUNC_SMBUS_BYTE_DATA |
596 I2C_FUNC_SMBUS_WORD_DATA |
597 I2C_FUNC_SMBUS_BLOCK_DATA |
598 I2C_FUNC_SMBUS_I2C_BLOCK |
599 I2C_FUNC_SMBUS_PROC_CALL |
600 I2C_FUNC_SMBUS_BLOCK_PROC_CALL;
601}
602
603static const struct i2c_algorithm smbus_algorithm = {
604 .smbus_xfer = cp2112_xfer,
605 .functionality = cp2112_functionality,
606};
607
608static int cp2112_get_usb_config(struct hid_device *hdev,
609 struct cp2112_usb_config_report *cfg)
610{
611 int ret;
612
613 ret = cp2112_hid_get(hdev, CP2112_USB_CONFIG, (u8 *)cfg, sizeof(*cfg),
614 HID_FEATURE_REPORT);
615 if (ret != sizeof(*cfg)) {
616 hid_err(hdev, "error reading usb config: %d\n", ret);
617 if (ret < 0)
618 return ret;
619 return -EIO;
620 }
621
622 return 0;
623}
624
625static int cp2112_set_usb_config(struct hid_device *hdev,
626 struct cp2112_usb_config_report *cfg)
627{
628 int ret;
629
630 BUG_ON(cfg->report != CP2112_USB_CONFIG);
631
632 ret = cp2112_hid_output(hdev, (u8 *)cfg, sizeof(*cfg),
633 HID_FEATURE_REPORT);
634 if (ret != sizeof(*cfg)) {
635 hid_err(hdev, "error writing usb config: %d\n", ret);
636 if (ret < 0)
637 return ret;
638 return -EIO;
639 }
640
641 return 0;
642}
643
644static void chmod_sysfs_attrs(struct hid_device *hdev);
645
646#define CP2112_CONFIG_ATTR(name, store, format, ...) \
647static ssize_t name##_store(struct device *kdev, \
648 struct device_attribute *attr, const char *buf, \
649 size_t count) \
650{ \
651 struct hid_device *hdev = container_of(kdev, struct hid_device, dev); \
652 struct cp2112_usb_config_report cfg; \
653 int ret = cp2112_get_usb_config(hdev, &cfg); \
654 if (ret) \
655 return ret; \
656 store; \
657 ret = cp2112_set_usb_config(hdev, &cfg); \
658 if (ret) \
659 return ret; \
660 chmod_sysfs_attrs(hdev); \
661 return count; \
662} \
663static ssize_t name##_show(struct device *kdev, \
664 struct device_attribute *attr, char *buf) \
665{ \
666 struct hid_device *hdev = container_of(kdev, struct hid_device, dev); \
667 struct cp2112_usb_config_report cfg; \
668 int ret = cp2112_get_usb_config(hdev, &cfg); \
669 if (ret) \
670 return ret; \
671 return scnprintf(buf, PAGE_SIZE, format, ##__VA_ARGS__); \
672} \
673static DEVICE_ATTR_RW(name);
674
675CP2112_CONFIG_ATTR(vendor_id, ({
676 u16 vid;
677
678 if (sscanf(buf, "%hi", &vid) != 1)
679 return -EINVAL;
680
681 cfg.vid = cpu_to_le16(vid);
682 cfg.mask = 0x01;
683}), "0x%04x\n", le16_to_cpu(cfg.vid));
684
685CP2112_CONFIG_ATTR(product_id, ({
686 u16 pid;
687
688 if (sscanf(buf, "%hi", &pid) != 1)
689 return -EINVAL;
690
691 cfg.pid = cpu_to_le16(pid);
692 cfg.mask = 0x02;
693}), "0x%04x\n", le16_to_cpu(cfg.pid));
694
695CP2112_CONFIG_ATTR(max_power, ({
696 int mA;
697
698 if (sscanf(buf, "%i", &mA) != 1)
699 return -EINVAL;
700
701 cfg.max_power = (mA + 1) / 2;
702 cfg.mask = 0x04;
703}), "%u mA\n", cfg.max_power * 2);
704
705CP2112_CONFIG_ATTR(power_mode, ({
706 if (sscanf(buf, "%hhi", &cfg.power_mode) != 1)
707 return -EINVAL;
708
709 cfg.mask = 0x08;
710}), "%u\n", cfg.power_mode);
711
712CP2112_CONFIG_ATTR(release_version, ({
713 if (sscanf(buf, "%hhi.%hhi", &cfg.release_major, &cfg.release_minor)
714 != 2)
715 return -EINVAL;
716
717 cfg.mask = 0x10;
718}), "%u.%u\n", cfg.release_major, cfg.release_minor);
719
720#undef CP2112_CONFIG_ATTR
721
722struct cp2112_pstring_attribute {
723 struct device_attribute attr;
724 unsigned char report;
725};
726
727static ssize_t pstr_store(struct device *kdev,
728 struct device_attribute *kattr, const char *buf,
729 size_t count)
730{
731 struct hid_device *hdev = container_of(kdev, struct hid_device, dev);
732 struct cp2112_pstring_attribute *attr =
733 container_of(kattr, struct cp2112_pstring_attribute, attr);
734 struct cp2112_string_report report;
735 int ret;
736
737 memset(&report, 0, sizeof(report));
738
739 ret = utf8s_to_utf16s(buf, count, UTF16_LITTLE_ENDIAN,
740 report.string, ARRAY_SIZE(report.string));
741 report.report = attr->report;
742 report.length = ret * sizeof(report.string[0]) + 2;
743 report.type = USB_DT_STRING;
744
745 ret = cp2112_hid_output(hdev, &report.report, report.length + 1,
746 HID_FEATURE_REPORT);
747 if (ret != report.length + 1) {
748 hid_err(hdev, "error writing %s string: %d\n", kattr->attr.name,
749 ret);
750 if (ret < 0)
751 return ret;
752 return -EIO;
753 }
754
755 chmod_sysfs_attrs(hdev);
756 return count;
757}
758
759static ssize_t pstr_show(struct device *kdev,
760 struct device_attribute *kattr, char *buf)
761{
762 struct hid_device *hdev = container_of(kdev, struct hid_device, dev);
763 struct cp2112_pstring_attribute *attr =
764 container_of(kattr, struct cp2112_pstring_attribute, attr);
765 struct cp2112_string_report report;
766 u8 length;
767 int ret;
768
769 ret = cp2112_hid_get(hdev, attr->report, &report.report,
770 sizeof(report) - 1, HID_FEATURE_REPORT);
771 if (ret < 3) {
772 hid_err(hdev, "error reading %s string: %d\n", kattr->attr.name,
773 ret);
774 if (ret < 0)
775 return ret;
776 return -EIO;
777 }
778
779 if (report.length < 2) {
780 hid_err(hdev, "invalid %s string length: %d\n",
781 kattr->attr.name, report.length);
782 return -EIO;
783 }
784
785 length = report.length > ret - 1 ? ret - 1 : report.length;
786 length = (length - 2) / sizeof(report.string[0]);
787 ret = utf16s_to_utf8s(report.string, length, UTF16_LITTLE_ENDIAN, buf,
788 PAGE_SIZE - 1);
789 buf[ret++] = '\n';
790 return ret;
791}
792
793#define CP2112_PSTR_ATTR(name, _report) \
794static struct cp2112_pstring_attribute dev_attr_##name = { \
795 .attr = __ATTR(name, (S_IWUSR | S_IRUGO), pstr_show, pstr_store), \
796 .report = _report, \
797};
798
799CP2112_PSTR_ATTR(manufacturer, CP2112_MANUFACTURER_STRING);
800CP2112_PSTR_ATTR(product, CP2112_PRODUCT_STRING);
801CP2112_PSTR_ATTR(serial, CP2112_SERIAL_STRING);
802
803#undef CP2112_PSTR_ATTR
804
805static const struct attribute_group cp2112_attr_group = {
806 .attrs = (struct attribute *[]){
807 &dev_attr_vendor_id.attr,
808 &dev_attr_product_id.attr,
809 &dev_attr_max_power.attr,
810 &dev_attr_power_mode.attr,
811 &dev_attr_release_version.attr,
812 &dev_attr_manufacturer.attr.attr,
813 &dev_attr_product.attr.attr,
814 &dev_attr_serial.attr.attr,
815 NULL
816 }
817};
818
819/* Chmoding our sysfs attributes is simply a way to expose which fields in the
820 * PROM have already been programmed. We do not depend on this preventing
821 * writing to these attributes since the CP2112 will simply ignore writes to
822 * already-programmed fields. This is why there is no sense in fixing this
823 * racy behaviour.
824 */
825static void chmod_sysfs_attrs(struct hid_device *hdev)
826{
827 struct attribute **attr;
828 u8 buf[2];
829 int ret;
830
831 ret = cp2112_hid_get(hdev, CP2112_LOCK_BYTE, buf, sizeof(buf),
832 HID_FEATURE_REPORT);
833 if (ret != sizeof(buf)) {
834 hid_err(hdev, "error reading lock byte: %d\n", ret);
835 return;
836 }
837
838 for (attr = cp2112_attr_group.attrs; *attr; ++attr) {
839 umode_t mode = (buf[1] & 1) ? S_IWUSR | S_IRUGO : S_IRUGO;
840 ret = sysfs_chmod_file(&hdev->dev.kobj, *attr, mode);
841 if (ret < 0)
842 hid_err(hdev, "error chmoding sysfs file %s\n",
843 (*attr)->name);
844 buf[1] >>= 1;
845 }
846}
847
848static int cp2112_probe(struct hid_device *hdev, const struct hid_device_id *id)
849{
850 struct cp2112_device *dev;
851 u8 buf[3];
852 struct cp2112_smbus_config_report config;
853 int ret;
854
855 ret = hid_parse(hdev);
856 if (ret) {
857 hid_err(hdev, "parse failed\n");
858 return ret;
859 }
860
861 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
862 if (ret) {
863 hid_err(hdev, "hw start failed\n");
864 return ret;
865 }
866
867 ret = hid_hw_open(hdev);
868 if (ret) {
869 hid_err(hdev, "hw open failed\n");
870 goto err_hid_stop;
871 }
872
873 ret = hid_hw_power(hdev, PM_HINT_FULLON);
874 if (ret < 0) {
875 hid_err(hdev, "power management error: %d\n", ret);
876 goto err_hid_close;
877 }
878
879 ret = cp2112_hid_get(hdev, CP2112_GET_VERSION_INFO, buf, sizeof(buf),
880 HID_FEATURE_REPORT);
881 if (ret != sizeof(buf)) {
882 hid_err(hdev, "error requesting version\n");
883 if (ret >= 0)
884 ret = -EIO;
885 goto err_power_normal;
886 }
887
888 hid_info(hdev, "Part Number: 0x%02X Device Version: 0x%02X\n",
889 buf[1], buf[2]);
890
891 ret = cp2112_hid_get(hdev, CP2112_SMBUS_CONFIG, (u8 *)&config,
892 sizeof(config), HID_FEATURE_REPORT);
893 if (ret != sizeof(config)) {
894 hid_err(hdev, "error requesting SMBus config\n");
895 if (ret >= 0)
896 ret = -EIO;
897 goto err_power_normal;
898 }
899
900 config.retry_time = cpu_to_be16(1);
901
902 ret = cp2112_hid_output(hdev, (u8 *)&config, sizeof(config),
903 HID_FEATURE_REPORT);
904 if (ret != sizeof(config)) {
905 hid_err(hdev, "error setting SMBus config\n");
906 if (ret >= 0)
907 ret = -EIO;
908 goto err_power_normal;
909 }
910
911 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
912 if (!dev) {
913 ret = -ENOMEM;
914 goto err_power_normal;
915 }
916
917 hid_set_drvdata(hdev, (void *)dev);
918 dev->hdev = hdev;
919 dev->adap.owner = THIS_MODULE;
920 dev->adap.class = I2C_CLASS_HWMON;
921 dev->adap.algo = &smbus_algorithm;
922 dev->adap.algo_data = dev;
923 dev->adap.dev.parent = &hdev->dev;
924 snprintf(dev->adap.name, sizeof(dev->adap.name),
925 "CP2112 SMBus Bridge on hiddev%d", hdev->minor);
926 init_waitqueue_head(&dev->wait);
927
928 hid_device_io_start(hdev);
929 ret = i2c_add_adapter(&dev->adap);
930 hid_device_io_stop(hdev);
931
932 if (ret) {
933 hid_err(hdev, "error registering i2c adapter\n");
934 goto err_free_dev;
935 }
936
937 hid_dbg(hdev, "adapter registered\n");
938
939 dev->gc.label = "cp2112_gpio";
940 dev->gc.direction_input = cp2112_gpio_direction_input;
941 dev->gc.direction_output = cp2112_gpio_direction_output;
942 dev->gc.set = cp2112_gpio_set;
943 dev->gc.get = cp2112_gpio_get;
944 dev->gc.base = -1;
945 dev->gc.ngpio = 8;
946 dev->gc.can_sleep = 1;
947 dev->gc.dev = &hdev->dev;
948
949 ret = gpiochip_add(&dev->gc);
950 if (ret < 0) {
951 hid_err(hdev, "error registering gpio chip\n");
952 goto err_free_i2c;
953 }
954
955 ret = sysfs_create_group(&hdev->dev.kobj, &cp2112_attr_group);
956 if (ret < 0) {
957 hid_err(hdev, "error creating sysfs attrs\n");
958 goto err_gpiochip_remove;
959 }
960
961 chmod_sysfs_attrs(hdev);
962 hid_hw_power(hdev, PM_HINT_NORMAL);
963
964 return ret;
965
966err_gpiochip_remove:
967 if (gpiochip_remove(&dev->gc) < 0)
968 hid_err(hdev, "error removing gpio chip\n");
969err_free_i2c:
970 i2c_del_adapter(&dev->adap);
971err_free_dev:
972 kfree(dev);
973err_power_normal:
974 hid_hw_power(hdev, PM_HINT_NORMAL);
975err_hid_close:
976 hid_hw_close(hdev);
977err_hid_stop:
978 hid_hw_stop(hdev);
979 return ret;
980}
981
982static void cp2112_remove(struct hid_device *hdev)
983{
984 struct cp2112_device *dev = hid_get_drvdata(hdev);
985
986 sysfs_remove_group(&hdev->dev.kobj, &cp2112_attr_group);
987 if (gpiochip_remove(&dev->gc))
988 hid_err(hdev, "unable to remove gpio chip\n");
989 i2c_del_adapter(&dev->adap);
990 /* i2c_del_adapter has finished removing all i2c devices from our
991 * adapter. Well behaved devices should no longer call our cp2112_xfer
992 * and should have waited for any pending calls to finish. It has also
993 * waited for device_unregister(&adap->dev) to complete. Therefore we
994 * can safely free our struct cp2112_device.
995 */
996 hid_hw_close(hdev);
997 hid_hw_stop(hdev);
998 kfree(dev);
999}
1000
1001static int cp2112_raw_event(struct hid_device *hdev, struct hid_report *report,
1002 u8 *data, int size)
1003{
1004 struct cp2112_device *dev = hid_get_drvdata(hdev);
1005 struct cp2112_xfer_status_report *xfer = (void *)data;
1006
1007 switch (data[0]) {
1008 case CP2112_TRANSFER_STATUS_RESPONSE:
1009 hid_dbg(hdev, "xfer status: %02x %02x %04x %04x\n",
1010 xfer->status0, xfer->status1,
1011 be16_to_cpu(xfer->retries), be16_to_cpu(xfer->length));
1012
1013 switch (xfer->status0) {
1014 case STATUS0_IDLE:
1015 dev->xfer_status = -EAGAIN;
1016 break;
1017 case STATUS0_BUSY:
1018 dev->xfer_status = -EBUSY;
1019 break;
1020 case STATUS0_COMPLETE:
1021 dev->xfer_status = be16_to_cpu(xfer->length);
1022 break;
1023 case STATUS0_ERROR:
1024 switch (xfer->status1) {
1025 case STATUS1_TIMEOUT_NACK:
1026 case STATUS1_TIMEOUT_BUS:
1027 dev->xfer_status = -ETIMEDOUT;
1028 break;
1029 default:
1030 dev->xfer_status = -EIO;
1031 break;
1032 }
1033 break;
1034 default:
1035 dev->xfer_status = -EINVAL;
1036 break;
1037 }
1038
1039 atomic_set(&dev->xfer_avail, 1);
1040 break;
1041 case CP2112_DATA_READ_RESPONSE:
1042 hid_dbg(hdev, "read response: %02x %02x\n", data[1], data[2]);
1043
1044 dev->read_length = data[2];
1045 if (dev->read_length > sizeof(dev->read_data))
1046 dev->read_length = sizeof(dev->read_data);
1047
1048 memcpy(dev->read_data, &data[3], dev->read_length);
1049 atomic_set(&dev->read_avail, 1);
1050 break;
1051 default:
1052 hid_err(hdev, "unknown report\n");
1053
1054 return 0;
1055 }
1056
1057 wake_up_interruptible(&dev->wait);
1058 return 1;
1059}
1060
1061static struct hid_driver cp2112_driver = {
1062 .name = "cp2112",
1063 .id_table = cp2112_devices,
1064 .probe = cp2112_probe,
1065 .remove = cp2112_remove,
1066 .raw_event = cp2112_raw_event,
1067};
1068
1069module_hid_driver(cp2112_driver);
1070MODULE_DESCRIPTION("Silicon Labs HID USB to SMBus master bridge");
1071MODULE_AUTHOR("David Barksdale <dbarksdale@uplogix.com>");
1072MODULE_LICENSE("GPL");
1073
diff --git a/drivers/hid/hid-hyperv.c b/drivers/hid/hid-hyperv.c
index c24908f14934..f52dbcb7133b 100644
--- a/drivers/hid/hid-hyperv.c
+++ b/drivers/hid/hid-hyperv.c
@@ -460,12 +460,22 @@ static void mousevsc_hid_stop(struct hid_device *hid)
460{ 460{
461} 461}
462 462
463static int mousevsc_hid_raw_request(struct hid_device *hid,
464 unsigned char report_num,
465 __u8 *buf, size_t len,
466 unsigned char rtype,
467 int reqtype)
468{
469 return 0;
470}
471
463static struct hid_ll_driver mousevsc_ll_driver = { 472static struct hid_ll_driver mousevsc_ll_driver = {
464 .parse = mousevsc_hid_parse, 473 .parse = mousevsc_hid_parse,
465 .open = mousevsc_hid_open, 474 .open = mousevsc_hid_open,
466 .close = mousevsc_hid_close, 475 .close = mousevsc_hid_close,
467 .start = mousevsc_hid_start, 476 .start = mousevsc_hid_start,
468 .stop = mousevsc_hid_stop, 477 .stop = mousevsc_hid_stop,
478 .raw_request = mousevsc_hid_raw_request,
469}; 479};
470 480
471static struct hid_driver mousevsc_hid_driver; 481static struct hid_driver mousevsc_hid_driver;
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 830de69d2df0..bd221263c739 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -67,6 +67,9 @@
67#define USB_VENDOR_ID_ALPS 0x0433 67#define USB_VENDOR_ID_ALPS 0x0433
68#define USB_DEVICE_ID_IBM_GAMEPAD 0x1101 68#define USB_DEVICE_ID_IBM_GAMEPAD 0x1101
69 69
70#define USB_VENDOR_ID_ANTON 0x1130
71#define USB_DEVICE_ID_ANTON_TOUCH_PAD 0x3101
72
70#define USB_VENDOR_ID_APPLE 0x05ac 73#define USB_VENDOR_ID_APPLE 0x05ac
71#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304 74#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
72#define USB_DEVICE_ID_APPLE_MAGICMOUSE 0x030d 75#define USB_DEVICE_ID_APPLE_MAGICMOUSE 0x030d
@@ -242,6 +245,7 @@
242#define USB_VENDOR_ID_CYGNAL 0x10c4 245#define USB_VENDOR_ID_CYGNAL 0x10c4
243#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X 0x818a 246#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X 0x818a
244#define USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH 0x81b9 247#define USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH 0x81b9
248#define USB_DEVICE_ID_CYGNAL_CP2112 0xea90
245 249
246#define USB_DEVICE_ID_CYGNAL_RADIO_SI4713 0x8244 250#define USB_DEVICE_ID_CYGNAL_RADIO_SI4713 0x8244
247 251
@@ -616,6 +620,7 @@
616 620
617#define USB_VENDOR_ID_MICROSOFT 0x045e 621#define USB_VENDOR_ID_MICROSOFT 0x045e
618#define USB_DEVICE_ID_SIDEWINDER_GV 0x003b 622#define USB_DEVICE_ID_SIDEWINDER_GV 0x003b
623#define USB_DEVICE_ID_MS_OFFICE_KB 0x0048
619#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d 624#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
620#define USB_DEVICE_ID_MS_NE4K 0x00db 625#define USB_DEVICE_ID_MS_NE4K 0x00db
621#define USB_DEVICE_ID_MS_NE4K_JP 0x00dc 626#define USB_DEVICE_ID_MS_NE4K_JP 0x00dc
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index a713e6211419..e7e8b19a9284 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -350,9 +350,9 @@ static int hidinput_get_battery_property(struct power_supply *psy,
350 ret = -ENOMEM; 350 ret = -ENOMEM;
351 break; 351 break;
352 } 352 }
353 ret = dev->hid_get_raw_report(dev, dev->battery_report_id, 353 ret = hid_hw_raw_request(dev, dev->battery_report_id, buf, 2,
354 buf, 2, 354 dev->battery_report_type,
355 dev->battery_report_type); 355 HID_REQ_GET_REPORT);
356 356
357 if (ret != 2) { 357 if (ret != 2) {
358 ret = -ENODATA; 358 ret = -ENODATA;
@@ -789,10 +789,13 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
789 case 0x199: map_key_clear(KEY_CHAT); break; 789 case 0x199: map_key_clear(KEY_CHAT); break;
790 case 0x19c: map_key_clear(KEY_LOGOFF); break; 790 case 0x19c: map_key_clear(KEY_LOGOFF); break;
791 case 0x19e: map_key_clear(KEY_COFFEE); break; 791 case 0x19e: map_key_clear(KEY_COFFEE); break;
792 case 0x1a3: map_key_clear(KEY_NEXT); break;
793 case 0x1a4: map_key_clear(KEY_PREVIOUS); break;
792 case 0x1a6: map_key_clear(KEY_HELP); break; 794 case 0x1a6: map_key_clear(KEY_HELP); break;
793 case 0x1a7: map_key_clear(KEY_DOCUMENTS); break; 795 case 0x1a7: map_key_clear(KEY_DOCUMENTS); break;
794 case 0x1ab: map_key_clear(KEY_SPELLCHECK); break; 796 case 0x1ab: map_key_clear(KEY_SPELLCHECK); break;
795 case 0x1ae: map_key_clear(KEY_KEYBOARD); break; 797 case 0x1ae: map_key_clear(KEY_KEYBOARD); break;
798 case 0x1b4: map_key_clear(KEY_FILE); break;
796 case 0x1b6: map_key_clear(KEY_IMAGES); break; 799 case 0x1b6: map_key_clear(KEY_IMAGES); break;
797 case 0x1b7: map_key_clear(KEY_AUDIO); break; 800 case 0x1b7: map_key_clear(KEY_AUDIO); break;
798 case 0x1b8: map_key_clear(KEY_VIDEO); break; 801 case 0x1b8: map_key_clear(KEY_VIDEO); break;
@@ -1150,7 +1153,7 @@ static void hidinput_led_worker(struct work_struct *work)
1150 led_work); 1153 led_work);
1151 struct hid_field *field; 1154 struct hid_field *field;
1152 struct hid_report *report; 1155 struct hid_report *report;
1153 int len; 1156 int len, ret;
1154 __u8 *buf; 1157 __u8 *buf;
1155 1158
1156 field = hidinput_get_led_field(hid); 1159 field = hidinput_get_led_field(hid);
@@ -1184,7 +1187,10 @@ static void hidinput_led_worker(struct work_struct *work)
1184 1187
1185 hid_output_report(report, buf); 1188 hid_output_report(report, buf);
1186 /* synchronous output report */ 1189 /* synchronous output report */
1187 hid->hid_output_raw_report(hid, buf, len, HID_OUTPUT_REPORT); 1190 ret = hid_hw_output_report(hid, buf, len);
1191 if (ret == -ENOSYS)
1192 hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
1193 HID_REQ_SET_REPORT);
1188 kfree(buf); 1194 kfree(buf);
1189} 1195}
1190 1196
@@ -1263,10 +1269,7 @@ static struct hid_input *hidinput_allocate(struct hid_device *hid)
1263 } 1269 }
1264 1270
1265 input_set_drvdata(input_dev, hid); 1271 input_set_drvdata(input_dev, hid);
1266 if (hid->ll_driver->hidinput_input_event) 1272 input_dev->event = hidinput_input_event;
1267 input_dev->event = hid->ll_driver->hidinput_input_event;
1268 else if (hid->ll_driver->request || hid->hid_output_raw_report)
1269 input_dev->event = hidinput_input_event;
1270 input_dev->open = hidinput_open; 1273 input_dev->open = hidinput_open;
1271 input_dev->close = hidinput_close; 1274 input_dev->close = hidinput_close;
1272 input_dev->setkeycode = hidinput_setkeycode; 1275 input_dev->setkeycode = hidinput_setkeycode;
diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c
index 9fe9d4ac3114..a976f48263f6 100644
--- a/drivers/hid/hid-lg.c
+++ b/drivers/hid/hid-lg.c
@@ -692,7 +692,8 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
692 if (hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) { 692 if (hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
693 unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 693 unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
694 694
695 ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); 695 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
696 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
696 697
697 if (ret >= 0) { 698 if (ret >= 0) {
698 /* insert a little delay of 10 jiffies ~ 40ms */ 699 /* insert a little delay of 10 jiffies ~ 40ms */
@@ -704,7 +705,8 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
704 buf[1] = 0xB2; 705 buf[1] = 0xB2;
705 get_random_bytes(&buf[2], 2); 706 get_random_bytes(&buf[2], 2);
706 707
707 ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); 708 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
709 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
708 } 710 }
709 } 711 }
710 712
diff --git a/drivers/hid/hid-logitech-dj.c b/drivers/hid/hid-logitech-dj.c
index f45279c3b11a..486dbde2ba2d 100644
--- a/drivers/hid/hid-logitech-dj.c
+++ b/drivers/hid/hid-logitech-dj.c
@@ -44,14 +44,6 @@ static const char kbd_descriptor[] = {
44 0x19, 0xE0, /* USAGE_MINIMUM (Left Control) */ 44 0x19, 0xE0, /* USAGE_MINIMUM (Left Control) */
45 0x29, 0xE7, /* USAGE_MAXIMUM (Right GUI) */ 45 0x29, 0xE7, /* USAGE_MAXIMUM (Right GUI) */
46 0x81, 0x02, /* INPUT (Data,Var,Abs) */ 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) */ 47 0x95, 0x06, /* REPORT_COUNT (6) */
56 0x75, 0x08, /* REPORT_SIZE (8) */ 48 0x75, 0x08, /* REPORT_SIZE (8) */
57 0x15, 0x00, /* LOGICAL_MINIMUM (0) */ 49 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
@@ -60,6 +52,18 @@ static const char kbd_descriptor[] = {
60 0x19, 0x00, /* USAGE_MINIMUM (no event) */ 52 0x19, 0x00, /* USAGE_MINIMUM (no event) */
61 0x2A, 0xFF, 0x00, /* USAGE_MAXIMUM (reserved) */ 53 0x2A, 0xFF, 0x00, /* USAGE_MAXIMUM (reserved) */
62 0x81, 0x00, /* INPUT (Data,Ary,Abs) */ 54 0x81, 0x00, /* INPUT (Data,Ary,Abs) */
55 0x85, 0x0e, /* REPORT_ID (14) */
56 0x05, 0x08, /* USAGE PAGE (LED page) */
57 0x95, 0x05, /* REPORT COUNT (5) */
58 0x75, 0x01, /* REPORT SIZE (1) */
59 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
60 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
61 0x19, 0x01, /* USAGE MINIMUM (1) */
62 0x29, 0x05, /* USAGE MAXIMUM (5) */
63 0x91, 0x02, /* OUTPUT (Data, Variable, Absolute) */
64 0x95, 0x01, /* REPORT COUNT (1) */
65 0x75, 0x03, /* REPORT SIZE (3) */
66 0x91, 0x01, /* OUTPUT (Constant) */
63 0xC0 67 0xC0
64}; 68};
65 69
@@ -189,9 +193,6 @@ static const u8 hid_reportid_size_map[NUMBER_OF_HID_REPORTS] = {
189 193
190static struct hid_ll_driver logi_dj_ll_driver; 194static struct hid_ll_driver logi_dj_ll_driver;
191 195
192static int logi_dj_output_hidraw_report(struct hid_device *hid, u8 * buf,
193 size_t count,
194 unsigned char report_type);
195static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev); 196static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev);
196 197
197static void logi_dj_recv_destroy_djhid_device(struct dj_receiver_dev *djrcv_dev, 198static void logi_dj_recv_destroy_djhid_device(struct dj_receiver_dev *djrcv_dev,
@@ -258,7 +259,6 @@ static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
258 } 259 }
259 260
260 dj_hiddev->ll_driver = &logi_dj_ll_driver; 261 dj_hiddev->ll_driver = &logi_dj_ll_driver;
261 dj_hiddev->hid_output_raw_report = logi_dj_output_hidraw_report;
262 262
263 dj_hiddev->dev.parent = &djrcv_hdev->dev; 263 dj_hiddev->dev.parent = &djrcv_hdev->dev;
264 dj_hiddev->bus = BUS_USB; 264 dj_hiddev->bus = BUS_USB;
@@ -540,14 +540,35 @@ static void logi_dj_ll_close(struct hid_device *hid)
540 dbg_hid("%s:%s\n", __func__, hid->phys); 540 dbg_hid("%s:%s\n", __func__, hid->phys);
541} 541}
542 542
543static int logi_dj_output_hidraw_report(struct hid_device *hid, u8 * buf, 543static int logi_dj_ll_raw_request(struct hid_device *hid,
544 size_t count, 544 unsigned char reportnum, __u8 *buf,
545 unsigned char report_type) 545 size_t count, unsigned char report_type,
546 int reqtype)
546{ 547{
547 /* Called by hid raw to send data */ 548 struct dj_device *djdev = hid->driver_data;
548 dbg_hid("%s\n", __func__); 549 struct dj_receiver_dev *djrcv_dev = djdev->dj_receiver_dev;
550 u8 *out_buf;
551 int ret;
549 552
550 return 0; 553 if (buf[0] != REPORT_TYPE_LEDS)
554 return -EINVAL;
555
556 out_buf = kzalloc(DJREPORT_SHORT_LENGTH, GFP_ATOMIC);
557 if (!out_buf)
558 return -ENOMEM;
559
560 if (count < DJREPORT_SHORT_LENGTH - 2)
561 count = DJREPORT_SHORT_LENGTH - 2;
562
563 out_buf[0] = REPORT_ID_DJ_SHORT;
564 out_buf[1] = djdev->device_index;
565 memcpy(out_buf + 2, buf, count);
566
567 ret = hid_hw_raw_request(djrcv_dev->hdev, out_buf[0], out_buf,
568 DJREPORT_SHORT_LENGTH, report_type, reqtype);
569
570 kfree(out_buf);
571 return ret;
551} 572}
552 573
553static void rdcat(char *rdesc, unsigned int *rsize, const char *data, unsigned int size) 574static void rdcat(char *rdesc, unsigned int *rsize, const char *data, unsigned int size)
@@ -613,58 +634,6 @@ static int logi_dj_ll_parse(struct hid_device *hid)
613 return retval; 634 return retval;
614} 635}
615 636
616static int logi_dj_ll_input_event(struct input_dev *dev, unsigned int type,
617 unsigned int code, int value)
618{
619 /* Sent by the input layer to handle leds and Force Feedback */
620 struct hid_device *dj_hiddev = input_get_drvdata(dev);
621 struct dj_device *dj_dev = dj_hiddev->driver_data;
622
623 struct dj_receiver_dev *djrcv_dev =
624 dev_get_drvdata(dj_hiddev->dev.parent);
625 struct hid_device *dj_rcv_hiddev = djrcv_dev->hdev;
626 struct hid_report_enum *output_report_enum;
627
628 struct hid_field *field;
629 struct hid_report *report;
630 unsigned char *data;
631 int offset;
632
633 dbg_hid("%s: %s, type:%d | code:%d | value:%d\n",
634 __func__, dev->phys, type, code, value);
635
636 if (type != EV_LED)
637 return -1;
638
639 offset = hidinput_find_field(dj_hiddev, type, code, &field);
640
641 if (offset == -1) {
642 dev_warn(&dev->dev, "event field not found\n");
643 return -1;
644 }
645 hid_set_field(field, offset, value);
646
647 data = hid_alloc_report_buf(field->report, GFP_ATOMIC);
648 if (!data) {
649 dev_warn(&dev->dev, "failed to allocate report buf memory\n");
650 return -1;
651 }
652
653 hid_output_report(field->report, &data[0]);
654
655 output_report_enum = &dj_rcv_hiddev->report_enum[HID_OUTPUT_REPORT];
656 report = output_report_enum->report_id_hash[REPORT_ID_DJ_SHORT];
657 hid_set_field(report->field[0], 0, dj_dev->device_index);
658 hid_set_field(report->field[0], 1, REPORT_TYPE_LEDS);
659 hid_set_field(report->field[0], 2, data[1]);
660
661 hid_hw_request(dj_rcv_hiddev, report, HID_REQ_SET_REPORT);
662
663 kfree(data);
664
665 return 0;
666}
667
668static int logi_dj_ll_start(struct hid_device *hid) 637static int logi_dj_ll_start(struct hid_device *hid)
669{ 638{
670 dbg_hid("%s\n", __func__); 639 dbg_hid("%s\n", __func__);
@@ -683,7 +652,7 @@ static struct hid_ll_driver logi_dj_ll_driver = {
683 .stop = logi_dj_ll_stop, 652 .stop = logi_dj_ll_stop,
684 .open = logi_dj_ll_open, 653 .open = logi_dj_ll_open,
685 .close = logi_dj_ll_close, 654 .close = logi_dj_ll_close,
686 .hidinput_input_event = logi_dj_ll_input_event, 655 .raw_request = logi_dj_ll_raw_request,
687}; 656};
688 657
689 658
diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c
index 3b43d1cfa936..ecc2cbf300cc 100644
--- a/drivers/hid/hid-magicmouse.c
+++ b/drivers/hid/hid-magicmouse.c
@@ -538,8 +538,8 @@ static int magicmouse_probe(struct hid_device *hdev,
538 * but there seems to be no other way of switching the mode. 538 * but there seems to be no other way of switching the mode.
539 * Thus the super-ugly hacky success check below. 539 * Thus the super-ugly hacky success check below.
540 */ 540 */
541 ret = hdev->hid_output_raw_report(hdev, feature, sizeof(feature), 541 ret = hid_hw_raw_request(hdev, feature[0], feature, sizeof(feature),
542 HID_FEATURE_REPORT); 542 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
543 if (ret != -EIO && ret != sizeof(feature)) { 543 if (ret != -EIO && ret != sizeof(feature)) {
544 hid_err(hdev, "unable to request touch data (%d)\n", ret); 544 hid_err(hdev, "unable to request touch data (%d)\n", ret);
545 goto err_stop_hw; 545 goto err_stop_hw;
diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c
index 404a3a8a82f1..6fd58175a291 100644
--- a/drivers/hid/hid-microsoft.c
+++ b/drivers/hid/hid-microsoft.c
@@ -62,9 +62,48 @@ static int ms_ergonomy_kb_quirk(struct hid_input *hi, struct hid_usage *usage,
62{ 62{
63 struct input_dev *input = hi->input; 63 struct input_dev *input = hi->input;
64 64
65 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
66 switch (usage->hid & HID_USAGE) {
67 /*
68 * Microsoft uses these 2 reserved usage ids for 2 keys on
69 * the MS office kb labelled "Office Home" and "Task Pane".
70 */
71 case 0x29d:
72 ms_map_key_clear(KEY_PROG1);
73 return 1;
74 case 0x29e:
75 ms_map_key_clear(KEY_PROG2);
76 return 1;
77 }
78 return 0;
79 }
80
81 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
82 return 0;
83
65 switch (usage->hid & HID_USAGE) { 84 switch (usage->hid & HID_USAGE) {
66 case 0xfd06: ms_map_key_clear(KEY_CHAT); break; 85 case 0xfd06: ms_map_key_clear(KEY_CHAT); break;
67 case 0xfd07: ms_map_key_clear(KEY_PHONE); break; 86 case 0xfd07: ms_map_key_clear(KEY_PHONE); break;
87 case 0xff00:
88 /* Special keypad keys */
89 ms_map_key_clear(KEY_KPEQUAL);
90 set_bit(KEY_KPLEFTPAREN, input->keybit);
91 set_bit(KEY_KPRIGHTPAREN, input->keybit);
92 break;
93 case 0xff01:
94 /* Scroll wheel */
95 hid_map_usage_clear(hi, usage, bit, max, EV_REL, REL_WHEEL);
96 break;
97 case 0xff02:
98 /*
99 * This byte contains a copy of the modifier keys byte of a
100 * standard hid keyboard report, as send by interface 0
101 * (this usage is found on interface 1).
102 *
103 * This byte only gets send when another key in the same report
104 * changes state, and as such is useless, ignore it.
105 */
106 return -1;
68 case 0xff05: 107 case 0xff05:
69 set_bit(EV_REP, input->evbit); 108 set_bit(EV_REP, input->evbit);
70 ms_map_key_clear(KEY_F13); 109 ms_map_key_clear(KEY_F13);
@@ -83,6 +122,9 @@ static int ms_ergonomy_kb_quirk(struct hid_input *hi, struct hid_usage *usage,
83static int ms_presenter_8k_quirk(struct hid_input *hi, struct hid_usage *usage, 122static int ms_presenter_8k_quirk(struct hid_input *hi, struct hid_usage *usage,
84 unsigned long **bit, int *max) 123 unsigned long **bit, int *max)
85{ 124{
125 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
126 return 0;
127
86 set_bit(EV_REP, hi->input->evbit); 128 set_bit(EV_REP, hi->input->evbit);
87 switch (usage->hid & HID_USAGE) { 129 switch (usage->hid & HID_USAGE) {
88 case 0xfd08: ms_map_key_clear(KEY_FORWARD); break; 130 case 0xfd08: ms_map_key_clear(KEY_FORWARD); break;
@@ -102,9 +144,6 @@ static int ms_input_mapping(struct hid_device *hdev, struct hid_input *hi,
102{ 144{
103 unsigned long quirks = (unsigned long)hid_get_drvdata(hdev); 145 unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
104 146
105 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
106 return 0;
107
108 if (quirks & MS_ERGONOMY) { 147 if (quirks & MS_ERGONOMY) {
109 int ret = ms_ergonomy_kb_quirk(hi, usage, bit, max); 148 int ret = ms_ergonomy_kb_quirk(hi, usage, bit, max);
110 if (ret) 149 if (ret)
@@ -134,14 +173,39 @@ static int ms_event(struct hid_device *hdev, struct hid_field *field,
134 struct hid_usage *usage, __s32 value) 173 struct hid_usage *usage, __s32 value)
135{ 174{
136 unsigned long quirks = (unsigned long)hid_get_drvdata(hdev); 175 unsigned long quirks = (unsigned long)hid_get_drvdata(hdev);
176 struct input_dev *input;
137 177
138 if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput || 178 if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
139 !usage->type) 179 !usage->type)
140 return 0; 180 return 0;
141 181
182 input = field->hidinput->input;
183
142 /* Handling MS keyboards special buttons */ 184 /* Handling MS keyboards special buttons */
185 if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff00)) {
186 /* Special keypad keys */
187 input_report_key(input, KEY_KPEQUAL, value & 0x01);
188 input_report_key(input, KEY_KPLEFTPAREN, value & 0x02);
189 input_report_key(input, KEY_KPRIGHTPAREN, value & 0x04);
190 return 1;
191 }
192
193 if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff01)) {
194 /* Scroll wheel */
195 int step = ((value & 0x60) >> 5) + 1;
196
197 switch (value & 0x1f) {
198 case 0x01:
199 input_report_rel(input, REL_WHEEL, step);
200 break;
201 case 0x1f:
202 input_report_rel(input, REL_WHEEL, -step);
203 break;
204 }
205 return 1;
206 }
207
143 if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) { 208 if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
144 struct input_dev *input = field->hidinput->input;
145 static unsigned int last_key = 0; 209 static unsigned int last_key = 0;
146 unsigned int key = 0; 210 unsigned int key = 0;
147 switch (value) { 211 switch (value) {
@@ -194,6 +258,8 @@ err_free:
194static const struct hid_device_id ms_devices[] = { 258static const struct hid_device_id ms_devices[] = {
195 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV), 259 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV),
196 .driver_data = MS_HIDINPUT }, 260 .driver_data = MS_HIDINPUT },
261 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB),
262 .driver_data = MS_ERGONOMY },
197 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K), 263 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K),
198 .driver_data = MS_ERGONOMY }, 264 .driver_data = MS_ERGONOMY },
199 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP), 265 { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP),
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index 221d503f1c24..35278e43c7a4 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -68,6 +68,9 @@ MODULE_LICENSE("GPL");
68#define MT_QUIRK_HOVERING (1 << 11) 68#define MT_QUIRK_HOVERING (1 << 11)
69#define MT_QUIRK_CONTACT_CNT_ACCURATE (1 << 12) 69#define MT_QUIRK_CONTACT_CNT_ACCURATE (1 << 12)
70 70
71#define MT_INPUTMODE_TOUCHSCREEN 0x02
72#define MT_INPUTMODE_TOUCHPAD 0x03
73
71struct mt_slot { 74struct mt_slot {
72 __s32 x, y, cx, cy, p, w, h; 75 __s32 x, y, cx, cy, p, w, h;
73 __s32 contactid; /* the device ContactID assigned to this slot */ 76 __s32 contactid; /* the device ContactID assigned to this slot */
@@ -84,6 +87,7 @@ struct mt_class {
84 __s32 sn_pressure; /* Signal/noise ratio for pressure events */ 87 __s32 sn_pressure; /* Signal/noise ratio for pressure events */
85 __u8 maxcontacts; 88 __u8 maxcontacts;
86 bool is_indirect; /* true for touchpads */ 89 bool is_indirect; /* true for touchpads */
90 bool export_all_inputs; /* do not ignore mouse, keyboards, etc... */
87}; 91};
88 92
89struct mt_fields { 93struct mt_fields {
@@ -100,11 +104,11 @@ struct mt_device {
100 int cc_value_index; /* contact count value index in the field */ 104 int cc_value_index; /* contact count value index in the field */
101 unsigned last_slot_field; /* the last field of a slot */ 105 unsigned last_slot_field; /* the last field of a slot */
102 unsigned mt_report_id; /* the report ID of the multitouch device */ 106 unsigned mt_report_id; /* the report ID of the multitouch device */
103 unsigned pen_report_id; /* the report ID of the pen device */
104 __s16 inputmode; /* InputMode HID feature, -1 if non-existent */ 107 __s16 inputmode; /* InputMode HID feature, -1 if non-existent */
105 __s16 inputmode_index; /* InputMode HID feature index in the report */ 108 __s16 inputmode_index; /* InputMode HID feature index in the report */
106 __s16 maxcontact_report_id; /* Maximum Contact Number HID feature, 109 __s16 maxcontact_report_id; /* Maximum Contact Number HID feature,
107 -1 if non-existent */ 110 -1 if non-existent */
111 __u8 inputmode_value; /* InputMode HID feature value */
108 __u8 num_received; /* how many contacts we received */ 112 __u8 num_received; /* how many contacts we received */
109 __u8 num_expected; /* expected last contact index */ 113 __u8 num_expected; /* expected last contact index */
110 __u8 maxcontacts; 114 __u8 maxcontacts;
@@ -128,16 +132,17 @@ static void mt_post_parse(struct mt_device *td);
128#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005 132#define MT_CLS_CONFIDENCE_MINUS_ONE 0x0005
129#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006 133#define MT_CLS_DUAL_INRANGE_CONTACTID 0x0006
130#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007 134#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 0x0007
131#define MT_CLS_DUAL_NSMU_CONTACTID 0x0008 135/* reserved 0x0008 */
132#define MT_CLS_INRANGE_CONTACTNUMBER 0x0009 136#define MT_CLS_INRANGE_CONTACTNUMBER 0x0009
133#define MT_CLS_NSMU 0x000a 137#define MT_CLS_NSMU 0x000a
134#define MT_CLS_DUAL_CONTACT_NUMBER 0x0010 138/* reserved 0x0010 */
135#define MT_CLS_DUAL_CONTACT_ID 0x0011 139/* reserved 0x0011 */
136#define MT_CLS_WIN_8 0x0012 140#define MT_CLS_WIN_8 0x0012
141#define MT_CLS_EXPORT_ALL_INPUTS 0x0013
137 142
138/* vendor specific classes */ 143/* vendor specific classes */
139#define MT_CLS_3M 0x0101 144#define MT_CLS_3M 0x0101
140#define MT_CLS_CYPRESS 0x0102 145/* reserved 0x0102 */
141#define MT_CLS_EGALAX 0x0103 146#define MT_CLS_EGALAX 0x0103
142#define MT_CLS_EGALAX_SERIAL 0x0104 147#define MT_CLS_EGALAX_SERIAL 0x0104
143#define MT_CLS_TOPSEED 0x0105 148#define MT_CLS_TOPSEED 0x0105
@@ -189,28 +194,18 @@ static struct mt_class mt_classes[] = {
189 .quirks = MT_QUIRK_VALID_IS_INRANGE | 194 .quirks = MT_QUIRK_VALID_IS_INRANGE |
190 MT_QUIRK_SLOT_IS_CONTACTNUMBER, 195 MT_QUIRK_SLOT_IS_CONTACTNUMBER,
191 .maxcontacts = 2 }, 196 .maxcontacts = 2 },
192 { .name = MT_CLS_DUAL_NSMU_CONTACTID,
193 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
194 MT_QUIRK_SLOT_IS_CONTACTID,
195 .maxcontacts = 2 },
196 { .name = MT_CLS_INRANGE_CONTACTNUMBER, 197 { .name = MT_CLS_INRANGE_CONTACTNUMBER,
197 .quirks = MT_QUIRK_VALID_IS_INRANGE | 198 .quirks = MT_QUIRK_VALID_IS_INRANGE |
198 MT_QUIRK_SLOT_IS_CONTACTNUMBER }, 199 MT_QUIRK_SLOT_IS_CONTACTNUMBER },
199 { .name = MT_CLS_DUAL_CONTACT_NUMBER,
200 .quirks = MT_QUIRK_ALWAYS_VALID |
201 MT_QUIRK_CONTACT_CNT_ACCURATE |
202 MT_QUIRK_SLOT_IS_CONTACTNUMBER,
203 .maxcontacts = 2 },
204 { .name = MT_CLS_DUAL_CONTACT_ID,
205 .quirks = MT_QUIRK_ALWAYS_VALID |
206 MT_QUIRK_CONTACT_CNT_ACCURATE |
207 MT_QUIRK_SLOT_IS_CONTACTID,
208 .maxcontacts = 2 },
209 { .name = MT_CLS_WIN_8, 200 { .name = MT_CLS_WIN_8,
210 .quirks = MT_QUIRK_ALWAYS_VALID | 201 .quirks = MT_QUIRK_ALWAYS_VALID |
211 MT_QUIRK_IGNORE_DUPLICATES | 202 MT_QUIRK_IGNORE_DUPLICATES |
212 MT_QUIRK_HOVERING | 203 MT_QUIRK_HOVERING |
213 MT_QUIRK_CONTACT_CNT_ACCURATE }, 204 MT_QUIRK_CONTACT_CNT_ACCURATE },
205 { .name = MT_CLS_EXPORT_ALL_INPUTS,
206 .quirks = MT_QUIRK_ALWAYS_VALID |
207 MT_QUIRK_CONTACT_CNT_ACCURATE,
208 .export_all_inputs = true },
214 209
215 /* 210 /*
216 * vendor specific classes 211 * vendor specific classes
@@ -223,10 +218,6 @@ static struct mt_class mt_classes[] = {
223 .sn_height = 128, 218 .sn_height = 128,
224 .maxcontacts = 60, 219 .maxcontacts = 60,
225 }, 220 },
226 { .name = MT_CLS_CYPRESS,
227 .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
228 MT_QUIRK_CYPRESS,
229 .maxcontacts = 10 },
230 { .name = MT_CLS_EGALAX, 221 { .name = MT_CLS_EGALAX,
231 .quirks = MT_QUIRK_SLOT_IS_CONTACTID | 222 .quirks = MT_QUIRK_SLOT_IS_CONTACTID |
232 MT_QUIRK_VALID_IS_INRANGE, 223 MT_QUIRK_VALID_IS_INRANGE,
@@ -360,45 +351,6 @@ static void mt_store_field(struct hid_usage *usage, struct mt_device *td,
360 f->usages[f->length++] = usage->hid; 351 f->usages[f->length++] = usage->hid;
361} 352}
362 353
363static int mt_pen_input_mapping(struct hid_device *hdev, struct hid_input *hi,
364 struct hid_field *field, struct hid_usage *usage,
365 unsigned long **bit, int *max)
366{
367 struct mt_device *td = hid_get_drvdata(hdev);
368
369 td->pen_report_id = field->report->id;
370
371 return 0;
372}
373
374static int mt_pen_input_mapped(struct hid_device *hdev, struct hid_input *hi,
375 struct hid_field *field, struct hid_usage *usage,
376 unsigned long **bit, int *max)
377{
378 return 0;
379}
380
381static int mt_pen_event(struct hid_device *hid, struct hid_field *field,
382 struct hid_usage *usage, __s32 value)
383{
384 /* let hid-input handle it */
385 return 0;
386}
387
388static void mt_pen_report(struct hid_device *hid, struct hid_report *report)
389{
390 struct hid_field *field = report->field[0];
391
392 input_sync(field->hidinput->input);
393}
394
395static void mt_pen_input_configured(struct hid_device *hdev,
396 struct hid_input *hi)
397{
398 /* force BTN_STYLUS to allow tablet matching in udev */
399 __set_bit(BTN_STYLUS, hi->input->keybit);
400}
401
402static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi, 354static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
403 struct hid_field *field, struct hid_usage *usage, 355 struct hid_field *field, struct hid_usage *usage,
404 unsigned long **bit, int *max) 356 unsigned long **bit, int *max)
@@ -415,8 +367,10 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
415 * Model touchscreens providing buttons as touchpads. 367 * Model touchscreens providing buttons as touchpads.
416 */ 368 */
417 if (field->application == HID_DG_TOUCHPAD || 369 if (field->application == HID_DG_TOUCHPAD ||
418 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) 370 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
419 td->mt_flags |= INPUT_MT_POINTER; 371 td->mt_flags |= INPUT_MT_POINTER;
372 td->inputmode_value = MT_INPUTMODE_TOUCHPAD;
373 }
420 374
421 if (usage->usage_index) 375 if (usage->usage_index)
422 prev_usage = &field->usage[usage->usage_index - 1]; 376 prev_usage = &field->usage[usage->usage_index - 1];
@@ -776,28 +730,52 @@ static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
776 struct hid_field *field, struct hid_usage *usage, 730 struct hid_field *field, struct hid_usage *usage,
777 unsigned long **bit, int *max) 731 unsigned long **bit, int *max)
778{ 732{
779 /* Only map fields from TouchScreen or TouchPad collections. 733 struct mt_device *td = hid_get_drvdata(hdev);
780 * We need to ignore fields that belong to other collections 734
781 * such as Mouse that might have the same GenericDesktop usages. */ 735 /*
782 if (field->application != HID_DG_TOUCHSCREEN && 736 * If mtclass.export_all_inputs is not set, only map fields from
737 * TouchScreen or TouchPad collections. We need to ignore fields
738 * that belong to other collections such as Mouse that might have
739 * the same GenericDesktop usages.
740 */
741 if (!td->mtclass.export_all_inputs &&
742 field->application != HID_DG_TOUCHSCREEN &&
783 field->application != HID_DG_PEN && 743 field->application != HID_DG_PEN &&
784 field->application != HID_DG_TOUCHPAD) 744 field->application != HID_DG_TOUCHPAD)
785 return -1; 745 return -1;
786 746
747 /*
748 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
749 * for the stylus.
750 */
787 if (field->physical == HID_DG_STYLUS) 751 if (field->physical == HID_DG_STYLUS)
788 return mt_pen_input_mapping(hdev, hi, field, usage, bit, max); 752 return 0;
789 753
790 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max); 754 if (field->application == HID_DG_TOUCHSCREEN ||
755 field->application == HID_DG_TOUCHPAD)
756 return mt_touch_input_mapping(hdev, hi, field, usage, bit, max);
757
758 /* let hid-core decide for the others */
759 return 0;
791} 760}
792 761
793static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi, 762static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
794 struct hid_field *field, struct hid_usage *usage, 763 struct hid_field *field, struct hid_usage *usage,
795 unsigned long **bit, int *max) 764 unsigned long **bit, int *max)
796{ 765{
766 /*
767 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
768 * for the stylus.
769 */
797 if (field->physical == HID_DG_STYLUS) 770 if (field->physical == HID_DG_STYLUS)
798 return mt_pen_input_mapped(hdev, hi, field, usage, bit, max); 771 return 0;
799 772
800 return mt_touch_input_mapped(hdev, hi, field, usage, bit, max); 773 if (field->application == HID_DG_TOUCHSCREEN ||
774 field->application == HID_DG_TOUCHPAD)
775 return mt_touch_input_mapped(hdev, hi, field, usage, bit, max);
776
777 /* let hid-core decide for the others */
778 return 0;
801} 779}
802 780
803static int mt_event(struct hid_device *hid, struct hid_field *field, 781static int mt_event(struct hid_device *hid, struct hid_field *field,
@@ -808,25 +786,22 @@ static int mt_event(struct hid_device *hid, struct hid_field *field,
808 if (field->report->id == td->mt_report_id) 786 if (field->report->id == td->mt_report_id)
809 return mt_touch_event(hid, field, usage, value); 787 return mt_touch_event(hid, field, usage, value);
810 788
811 if (field->report->id == td->pen_report_id) 789 return 0;
812 return mt_pen_event(hid, field, usage, value);
813
814 /* ignore other reports */
815 return 1;
816} 790}
817 791
818static void mt_report(struct hid_device *hid, struct hid_report *report) 792static void mt_report(struct hid_device *hid, struct hid_report *report)
819{ 793{
820 struct mt_device *td = hid_get_drvdata(hid); 794 struct mt_device *td = hid_get_drvdata(hid);
795 struct hid_field *field = report->field[0];
821 796
822 if (!(hid->claimed & HID_CLAIMED_INPUT)) 797 if (!(hid->claimed & HID_CLAIMED_INPUT))
823 return; 798 return;
824 799
825 if (report->id == td->mt_report_id) 800 if (report->id == td->mt_report_id)
826 mt_touch_report(hid, report); 801 return mt_touch_report(hid, report);
827 802
828 if (report->id == td->pen_report_id) 803 if (field && field->hidinput && field->hidinput->input)
829 mt_pen_report(hid, report); 804 input_sync(field->hidinput->input);
830} 805}
831 806
832static void mt_set_input_mode(struct hid_device *hdev) 807static void mt_set_input_mode(struct hid_device *hdev)
@@ -841,7 +816,7 @@ static void mt_set_input_mode(struct hid_device *hdev)
841 re = &(hdev->report_enum[HID_FEATURE_REPORT]); 816 re = &(hdev->report_enum[HID_FEATURE_REPORT]);
842 r = re->report_id_hash[td->inputmode]; 817 r = re->report_id_hash[td->inputmode];
843 if (r) { 818 if (r) {
844 r->field[0]->value[td->inputmode_index] = 0x02; 819 r->field[0]->value[td->inputmode_index] = td->inputmode_value;
845 hid_hw_request(hdev, r, HID_REQ_SET_REPORT); 820 hid_hw_request(hdev, r, HID_REQ_SET_REPORT);
846 } 821 }
847} 822}
@@ -907,13 +882,49 @@ static void mt_input_configured(struct hid_device *hdev, struct hid_input *hi)
907 struct mt_device *td = hid_get_drvdata(hdev); 882 struct mt_device *td = hid_get_drvdata(hdev);
908 char *name; 883 char *name;
909 const char *suffix = NULL; 884 const char *suffix = NULL;
885 struct hid_field *field = hi->report->field[0];
910 886
911 if (hi->report->id == td->mt_report_id) 887 if (hi->report->id == td->mt_report_id)
912 mt_touch_input_configured(hdev, hi); 888 mt_touch_input_configured(hdev, hi);
913 889
890 /*
891 * some egalax touchscreens have "application == HID_DG_TOUCHSCREEN"
892 * for the stylus. Check this first, and then rely on the application
893 * field.
894 */
914 if (hi->report->field[0]->physical == HID_DG_STYLUS) { 895 if (hi->report->field[0]->physical == HID_DG_STYLUS) {
915 suffix = "Pen"; 896 suffix = "Pen";
916 mt_pen_input_configured(hdev, hi); 897 /* force BTN_STYLUS to allow tablet matching in udev */
898 __set_bit(BTN_STYLUS, hi->input->keybit);
899 } else {
900 switch (field->application) {
901 case HID_GD_KEYBOARD:
902 suffix = "Keyboard";
903 break;
904 case HID_GD_KEYPAD:
905 suffix = "Keypad";
906 break;
907 case HID_GD_MOUSE:
908 suffix = "Mouse";
909 break;
910 case HID_DG_STYLUS:
911 suffix = "Pen";
912 /* force BTN_STYLUS to allow tablet matching in udev */
913 __set_bit(BTN_STYLUS, hi->input->keybit);
914 break;
915 case HID_DG_TOUCHSCREEN:
916 /* we do not set suffix = "Touchscreen" */
917 break;
918 case HID_GD_SYSTEM_CONTROL:
919 suffix = "System Control";
920 break;
921 case HID_CP_CONSUMER_CONTROL:
922 suffix = "Consumer Control";
923 break;
924 default:
925 suffix = "UNKNOWN";
926 break;
927 }
917 } 928 }
918 929
919 if (suffix) { 930 if (suffix) {
@@ -973,9 +984,9 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
973 td->mtclass = *mtclass; 984 td->mtclass = *mtclass;
974 td->inputmode = -1; 985 td->inputmode = -1;
975 td->maxcontact_report_id = -1; 986 td->maxcontact_report_id = -1;
987 td->inputmode_value = MT_INPUTMODE_TOUCHSCREEN;
976 td->cc_index = -1; 988 td->cc_index = -1;
977 td->mt_report_id = -1; 989 td->mt_report_id = -1;
978 td->pen_report_id = -1;
979 hid_set_drvdata(hdev, td); 990 hid_set_drvdata(hdev, td);
980 991
981 td->fields = devm_kzalloc(&hdev->dev, sizeof(struct mt_fields), 992 td->fields = devm_kzalloc(&hdev->dev, sizeof(struct mt_fields),
@@ -1034,6 +1045,12 @@ static void mt_remove(struct hid_device *hdev)
1034 hid_hw_stop(hdev); 1045 hid_hw_stop(hdev);
1035} 1046}
1036 1047
1048/*
1049 * This list contains only:
1050 * - VID/PID of products not working with the default multitouch handling
1051 * - 2 generic rules.
1052 * So there is no point in adding here any device with MT_CLS_DEFAULT.
1053 */
1037static const struct hid_device_id mt_devices[] = { 1054static const struct hid_device_id mt_devices[] = {
1038 1055
1039 /* 3M panels */ 1056 /* 3M panels */
@@ -1047,33 +1064,25 @@ static const struct hid_device_id mt_devices[] = {
1047 MT_USB_DEVICE(USB_VENDOR_ID_3M, 1064 MT_USB_DEVICE(USB_VENDOR_ID_3M,
1048 USB_DEVICE_ID_3M3266) }, 1065 USB_DEVICE_ID_3M3266) },
1049 1066
1050 /* ActionStar panels */ 1067 /* Anton devices */
1051 { .driver_data = MT_CLS_NSMU, 1068 { .driver_data = MT_CLS_EXPORT_ALL_INPUTS,
1052 MT_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR, 1069 MT_USB_DEVICE(USB_VENDOR_ID_ANTON,
1053 USB_DEVICE_ID_ACTIONSTAR_1011) }, 1070 USB_DEVICE_ID_ANTON_TOUCH_PAD) },
1054 1071
1055 /* Atmel panels */ 1072 /* Atmel panels */
1056 { .driver_data = MT_CLS_SERIAL, 1073 { .driver_data = MT_CLS_SERIAL,
1057 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL, 1074 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
1058 USB_DEVICE_ID_ATMEL_MULTITOUCH) },
1059 { .driver_data = MT_CLS_SERIAL,
1060 MT_USB_DEVICE(USB_VENDOR_ID_ATMEL,
1061 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) }, 1075 USB_DEVICE_ID_ATMEL_MXT_DIGITIZER) },
1062 1076
1063 /* Baanto multitouch devices */ 1077 /* Baanto multitouch devices */
1064 { .driver_data = MT_CLS_NSMU, 1078 { .driver_data = MT_CLS_NSMU,
1065 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO, 1079 MT_USB_DEVICE(USB_VENDOR_ID_BAANTO,
1066 USB_DEVICE_ID_BAANTO_MT_190W2) }, 1080 USB_DEVICE_ID_BAANTO_MT_190W2) },
1081
1067 /* Cando panels */ 1082 /* Cando panels */
1068 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1083 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1069 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1084 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1070 USB_DEVICE_ID_CANDO_MULTI_TOUCH) }, 1085 USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
1071 { .driver_data = MT_CLS_DUAL_CONTACT_NUMBER,
1072 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1073 USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
1074 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1075 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1076 USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
1077 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER, 1086 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
1078 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1087 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1079 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) }, 1088 USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
@@ -1088,16 +1097,6 @@ static const struct hid_device_id mt_devices[] = {
1088 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, 1097 MT_USB_DEVICE(USB_VENDOR_ID_CVTOUCH,
1089 USB_DEVICE_ID_CVTOUCH_SCREEN) }, 1098 USB_DEVICE_ID_CVTOUCH_SCREEN) },
1090 1099
1091 /* Cypress panel */
1092 { .driver_data = MT_CLS_CYPRESS,
1093 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
1094 USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
1095
1096 /* Data Modul easyMaxTouch */
1097 { .driver_data = MT_CLS_DEFAULT,
1098 MT_USB_DEVICE(USB_VENDOR_ID_DATA_MODUL,
1099 USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH) },
1100
1101 /* eGalax devices (resistive) */ 1100 /* eGalax devices (resistive) */
1102 { .driver_data = MT_CLS_EGALAX, 1101 { .driver_data = MT_CLS_EGALAX,
1103 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1102 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
@@ -1156,11 +1155,6 @@ static const struct hid_device_id mt_devices[] = {
1156 MT_USB_DEVICE(USB_VENDOR_ID_DWAV, 1155 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
1157 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) }, 1156 USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
1158 1157
1159 /* Elo TouchSystems IntelliTouch Plus panel */
1160 { .driver_data = MT_CLS_DUAL_CONTACT_ID,
1161 MT_USB_DEVICE(USB_VENDOR_ID_ELO,
1162 USB_DEVICE_ID_ELO_TS2515) },
1163
1164 /* Flatfrog Panels */ 1158 /* Flatfrog Panels */
1165 { .driver_data = MT_CLS_FLATFROG, 1159 { .driver_data = MT_CLS_FLATFROG,
1166 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG, 1160 MT_USB_DEVICE(USB_VENDOR_ID_FLATFROG,
@@ -1209,37 +1203,11 @@ static const struct hid_device_id mt_devices[] = {
1209 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, 1203 MT_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT,
1210 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) }, 1204 USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
1211 1205
1212 /* Ideacom panel */
1213 { .driver_data = MT_CLS_SERIAL,
1214 MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
1215 USB_DEVICE_ID_IDEACOM_IDC6650) },
1216 { .driver_data = MT_CLS_SERIAL,
1217 MT_USB_DEVICE(USB_VENDOR_ID_IDEACOM,
1218 USB_DEVICE_ID_IDEACOM_IDC6651) },
1219
1220 /* Ilitek dual touch panel */ 1206 /* Ilitek dual touch panel */
1221 { .driver_data = MT_CLS_NSMU, 1207 { .driver_data = MT_CLS_NSMU,
1222 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK, 1208 MT_USB_DEVICE(USB_VENDOR_ID_ILITEK,
1223 USB_DEVICE_ID_ILITEK_MULTITOUCH) }, 1209 USB_DEVICE_ID_ILITEK_MULTITOUCH) },
1224 1210
1225 /* IRTOUCH panels */
1226 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1227 MT_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
1228 USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
1229
1230 /* LG Display panels */
1231 { .driver_data = MT_CLS_DEFAULT,
1232 MT_USB_DEVICE(USB_VENDOR_ID_LG,
1233 USB_DEVICE_ID_LG_MULTITOUCH) },
1234
1235 /* Lumio panels */
1236 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1237 MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
1238 USB_DEVICE_ID_CRYSTALTOUCH) },
1239 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1240 MT_USB_DEVICE(USB_VENDOR_ID_LUMIO,
1241 USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
1242
1243 /* MosArt panels */ 1211 /* MosArt panels */
1244 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, 1212 { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE,
1245 MT_USB_DEVICE(USB_VENDOR_ID_ASUS, 1213 MT_USB_DEVICE(USB_VENDOR_ID_ASUS,
@@ -1251,11 +1219,6 @@ static const struct hid_device_id mt_devices[] = {
1251 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX, 1219 MT_USB_DEVICE(USB_VENDOR_ID_TURBOX,
1252 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) }, 1220 USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
1253 1221
1254 /* Nexio panels */
1255 { .driver_data = MT_CLS_DEFAULT,
1256 MT_USB_DEVICE(USB_VENDOR_ID_NEXIO,
1257 USB_DEVICE_ID_NEXIO_MULTITOUCH_420)},
1258
1259 /* Panasonic panels */ 1222 /* Panasonic panels */
1260 { .driver_data = MT_CLS_PANASONIC, 1223 { .driver_data = MT_CLS_PANASONIC,
1261 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC, 1224 MT_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
@@ -1269,11 +1232,6 @@ static const struct hid_device_id mt_devices[] = {
1269 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK, 1232 MT_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
1270 USB_DEVICE_ID_NOVATEK_PCT) }, 1233 USB_DEVICE_ID_NOVATEK_PCT) },
1271 1234
1272 /* PenMount panels */
1273 { .driver_data = MT_CLS_CONFIDENCE,
1274 MT_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
1275 USB_DEVICE_ID_PENMOUNT_PCI) },
1276
1277 /* PixArt optical touch screen */ 1235 /* PixArt optical touch screen */
1278 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER, 1236 { .driver_data = MT_CLS_INRANGE_CONTACTNUMBER,
1279 MT_USB_DEVICE(USB_VENDOR_ID_PIXART, 1237 MT_USB_DEVICE(USB_VENDOR_ID_PIXART,
@@ -1287,44 +1245,18 @@ static const struct hid_device_id mt_devices[] = {
1287 1245
1288 /* PixCir-based panels */ 1246 /* PixCir-based panels */
1289 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID, 1247 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1290 MT_USB_DEVICE(USB_VENDOR_ID_HANVON,
1291 USB_DEVICE_ID_HANVON_MULTITOUCH) },
1292 { .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
1293 MT_USB_DEVICE(USB_VENDOR_ID_CANDO, 1248 MT_USB_DEVICE(USB_VENDOR_ID_CANDO,
1294 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) }, 1249 USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
1295 1250
1296 /* Quanta-based panels */ 1251 /* Quanta-based panels */
1297 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID, 1252 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1298 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA, 1253 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1299 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
1300 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1301 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1302 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) }, 1254 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001) },
1303 { .driver_data = MT_CLS_CONFIDENCE_CONTACT_ID,
1304 MT_USB_DEVICE(USB_VENDOR_ID_QUANTA,
1305 USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008) },
1306
1307 /* SiS panels */
1308 { .driver_data = MT_CLS_DEFAULT,
1309 HID_USB_DEVICE(USB_VENDOR_ID_SIS_TOUCH,
1310 USB_DEVICE_ID_SIS9200_TOUCH) },
1311 { .driver_data = MT_CLS_DEFAULT,
1312 HID_USB_DEVICE(USB_VENDOR_ID_SIS_TOUCH,
1313 USB_DEVICE_ID_SIS817_TOUCH) },
1314 { .driver_data = MT_CLS_DEFAULT,
1315 HID_USB_DEVICE(USB_VENDOR_ID_SIS_TOUCH,
1316 USB_DEVICE_ID_SIS1030_TOUCH) },
1317 1255
1318 /* Stantum panels */ 1256 /* Stantum panels */
1319 { .driver_data = MT_CLS_CONFIDENCE, 1257 { .driver_data = MT_CLS_CONFIDENCE,
1320 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM,
1321 USB_DEVICE_ID_MTP)},
1322 { .driver_data = MT_CLS_CONFIDENCE,
1323 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, 1258 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM,
1324 USB_DEVICE_ID_MTP_STM)}, 1259 USB_DEVICE_ID_MTP_STM)},
1325 { .driver_data = MT_CLS_DEFAULT,
1326 MT_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX,
1327 USB_DEVICE_ID_MTP_SITRONIX)},
1328 1260
1329 /* TopSeed panels */ 1261 /* TopSeed panels */
1330 { .driver_data = MT_CLS_TOPSEED, 1262 { .driver_data = MT_CLS_TOPSEED,
@@ -1383,11 +1315,6 @@ static const struct hid_device_id mt_devices[] = {
1383 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU, 1315 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
1384 USB_DEVICE_ID_XIROKU_CSR2) }, 1316 USB_DEVICE_ID_XIROKU_CSR2) },
1385 1317
1386 /* Zytronic panels */
1387 { .driver_data = MT_CLS_SERIAL,
1388 MT_USB_DEVICE(USB_VENDOR_ID_ZYTRONIC,
1389 USB_DEVICE_ID_ZYTRONIC_ZXY100) },
1390
1391 /* Generic MT device */ 1318 /* Generic MT device */
1392 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) }, 1319 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
1393 1320
diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c
index 9c22e14c57f0..5182031f7b52 100644
--- a/drivers/hid/hid-sensor-hub.c
+++ b/drivers/hid/hid-sensor-hub.c
@@ -56,9 +56,9 @@ struct sensor_hub_pending {
56 * @dyn_callback_lock: spin lock to protect callback list 56 * @dyn_callback_lock: spin lock to protect callback list
57 * @hid_sensor_hub_client_devs: Stores all MFD cells for a hub instance. 57 * @hid_sensor_hub_client_devs: Stores all MFD cells for a hub instance.
58 * @hid_sensor_client_cnt: Number of MFD cells, (no of sensors attached). 58 * @hid_sensor_client_cnt: Number of MFD cells, (no of sensors attached).
59 * @ref_cnt: Number of MFD clients have opened this device
59 */ 60 */
60struct sensor_hub_data { 61struct sensor_hub_data {
61 struct hid_sensor_hub_device *hsdev;
62 struct mutex mutex; 62 struct mutex mutex;
63 spinlock_t lock; 63 spinlock_t lock;
64 struct sensor_hub_pending pending; 64 struct sensor_hub_pending pending;
@@ -67,6 +67,7 @@ struct sensor_hub_data {
67 struct mfd_cell *hid_sensor_hub_client_devs; 67 struct mfd_cell *hid_sensor_hub_client_devs;
68 int hid_sensor_client_cnt; 68 int hid_sensor_client_cnt;
69 unsigned long quirks; 69 unsigned long quirks;
70 int ref_cnt;
70}; 71};
71 72
72/** 73/**
@@ -79,6 +80,7 @@ struct sensor_hub_data {
79struct hid_sensor_hub_callbacks_list { 80struct hid_sensor_hub_callbacks_list {
80 struct list_head list; 81 struct list_head list;
81 u32 usage_id; 82 u32 usage_id;
83 struct hid_sensor_hub_device *hsdev;
82 struct hid_sensor_hub_callbacks *usage_callback; 84 struct hid_sensor_hub_callbacks *usage_callback;
83 void *priv; 85 void *priv;
84}; 86};
@@ -97,20 +99,18 @@ static struct hid_report *sensor_hub_report(int id, struct hid_device *hdev,
97 return NULL; 99 return NULL;
98} 100}
99 101
100static int sensor_hub_get_physical_device_count( 102static int sensor_hub_get_physical_device_count(struct hid_device *hdev)
101 struct hid_report_enum *report_enum)
102{ 103{
103 struct hid_report *report; 104 int i;
104 struct hid_field *field; 105 int count = 0;
105 int cnt = 0;
106 106
107 list_for_each_entry(report, &report_enum->report_list, list) { 107 for (i = 0; i < hdev->maxcollection; ++i) {
108 field = report->field[0]; 108 struct hid_collection *collection = &hdev->collection[i];
109 if (report->maxfield && field && field->physical) 109 if (collection->type == HID_COLLECTION_PHYSICAL)
110 cnt++; 110 ++count;
111 } 111 }
112 112
113 return cnt; 113 return count;
114} 114}
115 115
116static void sensor_hub_fill_attr_info( 116static void sensor_hub_fill_attr_info(
@@ -128,15 +128,23 @@ static void sensor_hub_fill_attr_info(
128 128
129static struct hid_sensor_hub_callbacks *sensor_hub_get_callback( 129static struct hid_sensor_hub_callbacks *sensor_hub_get_callback(
130 struct hid_device *hdev, 130 struct hid_device *hdev,
131 u32 usage_id, void **priv) 131 u32 usage_id,
132 int collection_index,
133 struct hid_sensor_hub_device **hsdev,
134 void **priv)
132{ 135{
133 struct hid_sensor_hub_callbacks_list *callback; 136 struct hid_sensor_hub_callbacks_list *callback;
134 struct sensor_hub_data *pdata = hid_get_drvdata(hdev); 137 struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
135 138
136 spin_lock(&pdata->dyn_callback_lock); 139 spin_lock(&pdata->dyn_callback_lock);
137 list_for_each_entry(callback, &pdata->dyn_callback_list, list) 140 list_for_each_entry(callback, &pdata->dyn_callback_list, list)
138 if (callback->usage_id == usage_id) { 141 if (callback->usage_id == usage_id &&
142 (collection_index >=
143 callback->hsdev->start_collection_index) &&
144 (collection_index <
145 callback->hsdev->end_collection_index)) {
139 *priv = callback->priv; 146 *priv = callback->priv;
147 *hsdev = callback->hsdev;
140 spin_unlock(&pdata->dyn_callback_lock); 148 spin_unlock(&pdata->dyn_callback_lock);
141 return callback->usage_callback; 149 return callback->usage_callback;
142 } 150 }
@@ -154,7 +162,8 @@ int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev,
154 162
155 spin_lock(&pdata->dyn_callback_lock); 163 spin_lock(&pdata->dyn_callback_lock);
156 list_for_each_entry(callback, &pdata->dyn_callback_list, list) 164 list_for_each_entry(callback, &pdata->dyn_callback_list, list)
157 if (callback->usage_id == usage_id) { 165 if (callback->usage_id == usage_id &&
166 callback->hsdev == hsdev) {
158 spin_unlock(&pdata->dyn_callback_lock); 167 spin_unlock(&pdata->dyn_callback_lock);
159 return -EINVAL; 168 return -EINVAL;
160 } 169 }
@@ -163,6 +172,7 @@ int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev,
163 spin_unlock(&pdata->dyn_callback_lock); 172 spin_unlock(&pdata->dyn_callback_lock);
164 return -ENOMEM; 173 return -ENOMEM;
165 } 174 }
175 callback->hsdev = hsdev;
166 callback->usage_callback = usage_callback; 176 callback->usage_callback = usage_callback;
167 callback->usage_id = usage_id; 177 callback->usage_id = usage_id;
168 callback->priv = NULL; 178 callback->priv = NULL;
@@ -181,7 +191,8 @@ int sensor_hub_remove_callback(struct hid_sensor_hub_device *hsdev,
181 191
182 spin_lock(&pdata->dyn_callback_lock); 192 spin_lock(&pdata->dyn_callback_lock);
183 list_for_each_entry(callback, &pdata->dyn_callback_list, list) 193 list_for_each_entry(callback, &pdata->dyn_callback_list, list)
184 if (callback->usage_id == usage_id) { 194 if (callback->usage_id == usage_id &&
195 callback->hsdev == hsdev) {
185 list_del(&callback->list); 196 list_del(&callback->list);
186 kfree(callback); 197 kfree(callback);
187 break; 198 break;
@@ -260,13 +271,12 @@ int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev,
260 271
261 spin_lock_irqsave(&data->lock, flags); 272 spin_lock_irqsave(&data->lock, flags);
262 data->pending.status = true; 273 data->pending.status = true;
274 spin_unlock_irqrestore(&data->lock, flags);
263 report = sensor_hub_report(report_id, hsdev->hdev, HID_INPUT_REPORT); 275 report = sensor_hub_report(report_id, hsdev->hdev, HID_INPUT_REPORT);
264 if (!report) { 276 if (!report)
265 spin_unlock_irqrestore(&data->lock, flags);
266 goto err_free; 277 goto err_free;
267 } 278
268 hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT); 279 hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
269 spin_unlock_irqrestore(&data->lock, flags);
270 wait_for_completion_interruptible_timeout(&data->pending.ready, HZ*5); 280 wait_for_completion_interruptible_timeout(&data->pending.ready, HZ*5);
271 switch (data->pending.raw_size) { 281 switch (data->pending.raw_size) {
272 case 1: 282 case 1:
@@ -291,6 +301,28 @@ err_free:
291} 301}
292EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value); 302EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value);
293 303
304int hid_sensor_get_usage_index(struct hid_sensor_hub_device *hsdev,
305 u32 report_id, int field_index, u32 usage_id)
306{
307 struct hid_report *report;
308 struct hid_field *field;
309 int i;
310
311 report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);
312 if (!report || (field_index >= report->maxfield))
313 goto done_proc;
314
315 field = report->field[field_index];
316 for (i = 0; i < field->maxusage; ++i) {
317 if (field->usage[i].hid == usage_id)
318 return field->usage[i].usage_index;
319 }
320
321done_proc:
322 return -EINVAL;
323}
324EXPORT_SYMBOL_GPL(hid_sensor_get_usage_index);
325
294int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev, 326int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev,
295 u8 type, 327 u8 type,
296 u32 usage_id, 328 u32 usage_id,
@@ -298,8 +330,7 @@ int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev,
298 struct hid_sensor_hub_attribute_info *info) 330 struct hid_sensor_hub_attribute_info *info)
299{ 331{
300 int ret = -1; 332 int ret = -1;
301 int i, j; 333 int i;
302 int collection_index = -1;
303 struct hid_report *report; 334 struct hid_report *report;
304 struct hid_field *field; 335 struct hid_field *field;
305 struct hid_report_enum *report_enum; 336 struct hid_report_enum *report_enum;
@@ -313,44 +344,31 @@ int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev,
313 info->units = -1; 344 info->units = -1;
314 info->unit_expo = -1; 345 info->unit_expo = -1;
315 346
316 for (i = 0; i < hdev->maxcollection; ++i) {
317 struct hid_collection *collection = &hdev->collection[i];
318 if (usage_id == collection->usage) {
319 collection_index = i;
320 break;
321 }
322 }
323 if (collection_index == -1)
324 goto err_ret;
325
326 report_enum = &hdev->report_enum[type]; 347 report_enum = &hdev->report_enum[type];
327 list_for_each_entry(report, &report_enum->report_list, list) { 348 list_for_each_entry(report, &report_enum->report_list, list) {
328 for (i = 0; i < report->maxfield; ++i) { 349 for (i = 0; i < report->maxfield; ++i) {
329 field = report->field[i]; 350 field = report->field[i];
330 if (field->physical == usage_id && 351 if (field->maxusage) {
331 field->logical == attr_usage_id) { 352 if (field->physical == usage_id &&
332 sensor_hub_fill_attr_info(info, i, report->id, 353 (field->logical == attr_usage_id ||
333 field); 354 field->usage[0].hid ==
334 ret = 0; 355 attr_usage_id) &&
335 } else { 356 (field->usage[0].collection_index >=
336 for (j = 0; j < field->maxusage; ++j) { 357 hsdev->start_collection_index) &&
337 if (field->usage[j].hid == 358 (field->usage[0].collection_index <
338 attr_usage_id && 359 hsdev->end_collection_index)) {
339 field->usage[j].collection_index == 360
340 collection_index) { 361 sensor_hub_fill_attr_info(info, i,
341 sensor_hub_fill_attr_info(info, 362 report->id,
342 i, report->id, field); 363 field);
343 ret = 0; 364 ret = 0;
344 break; 365 break;
345 }
346 } 366 }
347 } 367 }
348 if (ret == 0)
349 break;
350 } 368 }
369
351 } 370 }
352 371
353err_ret:
354 return ret; 372 return ret;
355} 373}
356EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info); 374EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info);
@@ -366,7 +384,7 @@ static int sensor_hub_suspend(struct hid_device *hdev, pm_message_t message)
366 list_for_each_entry(callback, &pdata->dyn_callback_list, list) { 384 list_for_each_entry(callback, &pdata->dyn_callback_list, list) {
367 if (callback->usage_callback->suspend) 385 if (callback->usage_callback->suspend)
368 callback->usage_callback->suspend( 386 callback->usage_callback->suspend(
369 pdata->hsdev, callback->priv); 387 callback->hsdev, callback->priv);
370 } 388 }
371 spin_unlock(&pdata->dyn_callback_lock); 389 spin_unlock(&pdata->dyn_callback_lock);
372 390
@@ -383,7 +401,7 @@ static int sensor_hub_resume(struct hid_device *hdev)
383 list_for_each_entry(callback, &pdata->dyn_callback_list, list) { 401 list_for_each_entry(callback, &pdata->dyn_callback_list, list) {
384 if (callback->usage_callback->resume) 402 if (callback->usage_callback->resume)
385 callback->usage_callback->resume( 403 callback->usage_callback->resume(
386 pdata->hsdev, callback->priv); 404 callback->hsdev, callback->priv);
387 } 405 }
388 spin_unlock(&pdata->dyn_callback_lock); 406 spin_unlock(&pdata->dyn_callback_lock);
389 407
@@ -410,6 +428,7 @@ static int sensor_hub_raw_event(struct hid_device *hdev,
410 struct hid_sensor_hub_callbacks *callback = NULL; 428 struct hid_sensor_hub_callbacks *callback = NULL;
411 struct hid_collection *collection = NULL; 429 struct hid_collection *collection = NULL;
412 void *priv = NULL; 430 void *priv = NULL;
431 struct hid_sensor_hub_device *hsdev = NULL;
413 432
414 hid_dbg(hdev, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n", 433 hid_dbg(hdev, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n",
415 report->id, size, report->type); 434 report->id, size, report->type);
@@ -444,23 +463,26 @@ static int sensor_hub_raw_event(struct hid_device *hdev,
444 report->field[i]->usage->collection_index]; 463 report->field[i]->usage->collection_index];
445 hid_dbg(hdev, "collection->usage %x\n", 464 hid_dbg(hdev, "collection->usage %x\n",
446 collection->usage); 465 collection->usage);
447 callback = sensor_hub_get_callback(pdata->hsdev->hdev, 466
448 report->field[i]->physical, 467 callback = sensor_hub_get_callback(hdev,
449 &priv); 468 report->field[i]->physical,
469 report->field[i]->usage[0].collection_index,
470 &hsdev, &priv);
471
450 if (callback && callback->capture_sample) { 472 if (callback && callback->capture_sample) {
451 if (report->field[i]->logical) 473 if (report->field[i]->logical)
452 callback->capture_sample(pdata->hsdev, 474 callback->capture_sample(hsdev,
453 report->field[i]->logical, sz, ptr, 475 report->field[i]->logical, sz, ptr,
454 callback->pdev); 476 callback->pdev);
455 else 477 else
456 callback->capture_sample(pdata->hsdev, 478 callback->capture_sample(hsdev,
457 report->field[i]->usage->hid, sz, ptr, 479 report->field[i]->usage->hid, sz, ptr,
458 callback->pdev); 480 callback->pdev);
459 } 481 }
460 ptr += sz; 482 ptr += sz;
461 } 483 }
462 if (callback && collection && callback->send_event) 484 if (callback && collection && callback->send_event)
463 callback->send_event(pdata->hsdev, collection->usage, 485 callback->send_event(hsdev, collection->usage,
464 callback->pdev); 486 callback->pdev);
465 spin_unlock_irqrestore(&pdata->lock, flags); 487 spin_unlock_irqrestore(&pdata->lock, flags);
466 488
@@ -473,7 +495,7 @@ int sensor_hub_device_open(struct hid_sensor_hub_device *hsdev)
473 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); 495 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
474 496
475 mutex_lock(&data->mutex); 497 mutex_lock(&data->mutex);
476 if (!hsdev->ref_cnt) { 498 if (!data->ref_cnt) {
477 ret = hid_hw_open(hsdev->hdev); 499 ret = hid_hw_open(hsdev->hdev);
478 if (ret) { 500 if (ret) {
479 hid_err(hsdev->hdev, "failed to open hid device\n"); 501 hid_err(hsdev->hdev, "failed to open hid device\n");
@@ -481,7 +503,7 @@ int sensor_hub_device_open(struct hid_sensor_hub_device *hsdev)
481 return ret; 503 return ret;
482 } 504 }
483 } 505 }
484 hsdev->ref_cnt++; 506 data->ref_cnt++;
485 mutex_unlock(&data->mutex); 507 mutex_unlock(&data->mutex);
486 508
487 return ret; 509 return ret;
@@ -493,8 +515,8 @@ void sensor_hub_device_close(struct hid_sensor_hub_device *hsdev)
493 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); 515 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
494 516
495 mutex_lock(&data->mutex); 517 mutex_lock(&data->mutex);
496 hsdev->ref_cnt--; 518 data->ref_cnt--;
497 if (!hsdev->ref_cnt) 519 if (!data->ref_cnt)
498 hid_hw_close(hsdev->hdev); 520 hid_hw_close(hsdev->hdev);
499 mutex_unlock(&data->mutex); 521 mutex_unlock(&data->mutex);
500} 522}
@@ -541,26 +563,19 @@ static int sensor_hub_probe(struct hid_device *hdev,
541 struct sensor_hub_data *sd; 563 struct sensor_hub_data *sd;
542 int i; 564 int i;
543 char *name; 565 char *name;
544 struct hid_report *report;
545 struct hid_report_enum *report_enum;
546 struct hid_field *field;
547 int dev_cnt; 566 int dev_cnt;
567 struct hid_sensor_hub_device *hsdev;
568 struct hid_sensor_hub_device *last_hsdev = NULL;
548 569
549 sd = devm_kzalloc(&hdev->dev, sizeof(*sd), GFP_KERNEL); 570 sd = devm_kzalloc(&hdev->dev, sizeof(*sd), GFP_KERNEL);
550 if (!sd) { 571 if (!sd) {
551 hid_err(hdev, "cannot allocate Sensor data\n"); 572 hid_err(hdev, "cannot allocate Sensor data\n");
552 return -ENOMEM; 573 return -ENOMEM;
553 } 574 }
554 sd->hsdev = devm_kzalloc(&hdev->dev, sizeof(*sd->hsdev), GFP_KERNEL); 575
555 if (!sd->hsdev) {
556 hid_err(hdev, "cannot allocate hid_sensor_hub_device\n");
557 return -ENOMEM;
558 }
559 hid_set_drvdata(hdev, sd); 576 hid_set_drvdata(hdev, sd);
560 sd->quirks = id->driver_data; 577 sd->quirks = id->driver_data;
561 sd->hsdev->hdev = hdev; 578
562 sd->hsdev->vendor_id = hdev->vendor;
563 sd->hsdev->product_id = hdev->product;
564 spin_lock_init(&sd->lock); 579 spin_lock_init(&sd->lock);
565 spin_lock_init(&sd->dyn_callback_lock); 580 spin_lock_init(&sd->dyn_callback_lock);
566 mutex_init(&sd->mutex); 581 mutex_init(&sd->mutex);
@@ -578,9 +593,8 @@ static int sensor_hub_probe(struct hid_device *hdev,
578 } 593 }
579 INIT_LIST_HEAD(&sd->dyn_callback_list); 594 INIT_LIST_HEAD(&sd->dyn_callback_list);
580 sd->hid_sensor_client_cnt = 0; 595 sd->hid_sensor_client_cnt = 0;
581 report_enum = &hdev->report_enum[HID_INPUT_REPORT];
582 596
583 dev_cnt = sensor_hub_get_physical_device_count(report_enum); 597 dev_cnt = sensor_hub_get_physical_device_count(hdev);
584 if (dev_cnt > HID_MAX_PHY_DEVICES) { 598 if (dev_cnt > HID_MAX_PHY_DEVICES) {
585 hid_err(hdev, "Invalid Physical device count\n"); 599 hid_err(hdev, "Invalid Physical device count\n");
586 ret = -EINVAL; 600 ret = -EINVAL;
@@ -594,42 +608,63 @@ static int sensor_hub_probe(struct hid_device *hdev,
594 ret = -ENOMEM; 608 ret = -ENOMEM;
595 goto err_stop_hw; 609 goto err_stop_hw;
596 } 610 }
597 list_for_each_entry(report, &report_enum->report_list, list) { 611
598 hid_dbg(hdev, "Report id:%x\n", report->id); 612 for (i = 0; i < hdev->maxcollection; ++i) {
599 field = report->field[0]; 613 struct hid_collection *collection = &hdev->collection[i];
600 if (report->maxfield && field && 614
601 field->physical) { 615 if (collection->type == HID_COLLECTION_PHYSICAL) {
616
617 hsdev = kzalloc(sizeof(*hsdev), GFP_KERNEL);
618 if (!hsdev) {
619 hid_err(hdev, "cannot allocate hid_sensor_hub_device\n");
620 ret = -ENOMEM;
621 goto err_no_mem;
622 }
623 hsdev->hdev = hdev;
624 hsdev->vendor_id = hdev->vendor;
625 hsdev->product_id = hdev->product;
626 hsdev->start_collection_index = i;
627 if (last_hsdev)
628 last_hsdev->end_collection_index = i;
629 last_hsdev = hsdev;
602 name = kasprintf(GFP_KERNEL, "HID-SENSOR-%x", 630 name = kasprintf(GFP_KERNEL, "HID-SENSOR-%x",
603 field->physical); 631 collection->usage);
604 if (name == NULL) { 632 if (name == NULL) {
605 hid_err(hdev, "Failed MFD device name\n"); 633 hid_err(hdev, "Failed MFD device name\n");
606 ret = -ENOMEM; 634 ret = -ENOMEM;
607 goto err_free_names; 635 goto err_no_mem;
608 } 636 }
609 sd->hid_sensor_hub_client_devs[ 637 sd->hid_sensor_hub_client_devs[
610 sd->hid_sensor_client_cnt].id = PLATFORM_DEVID_AUTO; 638 sd->hid_sensor_client_cnt].id =
639 PLATFORM_DEVID_AUTO;
611 sd->hid_sensor_hub_client_devs[ 640 sd->hid_sensor_hub_client_devs[
612 sd->hid_sensor_client_cnt].name = name; 641 sd->hid_sensor_client_cnt].name = name;
613 sd->hid_sensor_hub_client_devs[ 642 sd->hid_sensor_hub_client_devs[
614 sd->hid_sensor_client_cnt].platform_data = 643 sd->hid_sensor_client_cnt].platform_data =
615 sd->hsdev; 644 hsdev;
616 sd->hid_sensor_hub_client_devs[ 645 sd->hid_sensor_hub_client_devs[
617 sd->hid_sensor_client_cnt].pdata_size = 646 sd->hid_sensor_client_cnt].pdata_size =
618 sizeof(*sd->hsdev); 647 sizeof(*hsdev);
619 hid_dbg(hdev, "Adding %s:%p\n", name, sd); 648 hid_dbg(hdev, "Adding %s:%d\n", name,
649 hsdev->start_collection_index);
620 sd->hid_sensor_client_cnt++; 650 sd->hid_sensor_client_cnt++;
621 } 651 }
622 } 652 }
653 if (last_hsdev)
654 last_hsdev->end_collection_index = i;
655
623 ret = mfd_add_devices(&hdev->dev, 0, sd->hid_sensor_hub_client_devs, 656 ret = mfd_add_devices(&hdev->dev, 0, sd->hid_sensor_hub_client_devs,
624 sd->hid_sensor_client_cnt, NULL, 0, NULL); 657 sd->hid_sensor_client_cnt, NULL, 0, NULL);
625 if (ret < 0) 658 if (ret < 0)
626 goto err_free_names; 659 goto err_no_mem;
627 660
628 return ret; 661 return ret;
629 662
630err_free_names: 663err_no_mem:
631 for (i = 0; i < sd->hid_sensor_client_cnt ; ++i) 664 for (i = 0; i < sd->hid_sensor_client_cnt; ++i) {
632 kfree(sd->hid_sensor_hub_client_devs[i].name); 665 kfree(sd->hid_sensor_hub_client_devs[i].name);
666 kfree(sd->hid_sensor_hub_client_devs[i].platform_data);
667 }
633 kfree(sd->hid_sensor_hub_client_devs); 668 kfree(sd->hid_sensor_hub_client_devs);
634err_stop_hw: 669err_stop_hw:
635 hid_hw_stop(hdev); 670 hid_hw_stop(hdev);
@@ -651,8 +686,10 @@ static void sensor_hub_remove(struct hid_device *hdev)
651 complete(&data->pending.ready); 686 complete(&data->pending.ready);
652 spin_unlock_irqrestore(&data->lock, flags); 687 spin_unlock_irqrestore(&data->lock, flags);
653 mfd_remove_devices(&hdev->dev); 688 mfd_remove_devices(&hdev->dev);
654 for (i = 0; i < data->hid_sensor_client_cnt ; ++i) 689 for (i = 0; i < data->hid_sensor_client_cnt; ++i) {
655 kfree(data->hid_sensor_hub_client_devs[i].name); 690 kfree(data->hid_sensor_hub_client_devs[i].name);
691 kfree(data->hid_sensor_hub_client_devs[i].platform_data);
692 }
656 kfree(data->hid_sensor_hub_client_devs); 693 kfree(data->hid_sensor_hub_client_devs);
657 hid_set_drvdata(hdev, NULL); 694 hid_set_drvdata(hdev, NULL);
658 mutex_destroy(&data->mutex); 695 mutex_destroy(&data->mutex);
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
index 2f19b15f47f2..69204afea7a4 100644
--- a/drivers/hid/hid-sony.c
+++ b/drivers/hid/hid-sony.c
@@ -17,7 +17,8 @@
17 * any later version. 17 * any later version.
18 */ 18 */
19 19
20/* NOTE: in order for the Sony PS3 BD Remote Control to be found by 20/*
21 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
21 * a Bluetooth host, the key combination Start+Enter has to be kept pressed 22 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
22 * for about 7 seconds with the Bluetooth Host Controller in discovering mode. 23 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
23 * 24 *
@@ -28,8 +29,11 @@
28#include <linux/hid.h> 29#include <linux/hid.h>
29#include <linux/module.h> 30#include <linux/module.h>
30#include <linux/slab.h> 31#include <linux/slab.h>
31#include <linux/usb.h>
32#include <linux/leds.h> 32#include <linux/leds.h>
33#include <linux/power_supply.h>
34#include <linux/spinlock.h>
35#include <linux/list.h>
36#include <linux/input/mt.h>
33 37
34#include "hid-ids.h" 38#include "hid-ids.h"
35 39
@@ -41,8 +45,13 @@
41#define DUALSHOCK4_CONTROLLER_USB BIT(5) 45#define DUALSHOCK4_CONTROLLER_USB BIT(5)
42#define DUALSHOCK4_CONTROLLER_BT BIT(6) 46#define DUALSHOCK4_CONTROLLER_BT BIT(6)
43 47
44#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER_USB | BUZZ_CONTROLLER | DUALSHOCK4_CONTROLLER_USB) 48#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
45#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER_USB | DUALSHOCK4_CONTROLLER_USB) 49#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
50 DUALSHOCK4_CONTROLLER_BT)
51#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
52 DUALSHOCK4_CONTROLLER)
53#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
54#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
46 55
47#define MAX_LEDS 4 56#define MAX_LEDS 4
48 57
@@ -74,7 +83,8 @@ static const u8 sixaxis_rdesc_fixup2[] = {
74 0xb1, 0x02, 0xc0, 0xc0, 83 0xb1, 0x02, 0xc0, 0xc0,
75}; 84};
76 85
77/* The default descriptor doesn't provide mapping for the accelerometers 86/*
87 * The default descriptor doesn't provide mapping for the accelerometers
78 * or orientation sensors. This fixed descriptor maps the accelerometers 88 * or orientation sensors. This fixed descriptor maps the accelerometers
79 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors 89 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
80 * to usage values 0x43, 0x44 and 0x45. 90 * to usage values 0x43, 0x44 and 0x45.
@@ -333,6 +343,217 @@ static u8 dualshock4_usb_rdesc[] = {
333 0xC0 /* End Collection */ 343 0xC0 /* End Collection */
334}; 344};
335 345
346/*
347 * The default behavior of the Dualshock 4 is to send reports using report
348 * type 1 when running over Bluetooth. However, as soon as it receives a
349 * report of type 17 to set the LEDs or rumble it starts returning it's state
350 * in report 17 instead of 1. Since report 17 is undefined in the default HID
351 * descriptor the button and axis definitions must be moved to report 17 or
352 * the HID layer won't process the received input once a report is sent.
353 */
354static u8 dualshock4_bt_rdesc[] = {
355 0x05, 0x01, /* Usage Page (Desktop), */
356 0x09, 0x05, /* Usage (Gamepad), */
357 0xA1, 0x01, /* Collection (Application), */
358 0x85, 0x01, /* Report ID (1), */
359 0x75, 0x08, /* Report Size (8), */
360 0x95, 0x0A, /* Report Count (9), */
361 0x81, 0x02, /* Input (Variable), */
362 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
363 0x85, 0x02, /* Report ID (2), */
364 0x09, 0x24, /* Usage (24h), */
365 0x95, 0x24, /* Report Count (36), */
366 0xB1, 0x02, /* Feature (Variable), */
367 0x85, 0xA3, /* Report ID (163), */
368 0x09, 0x25, /* Usage (25h), */
369 0x95, 0x30, /* Report Count (48), */
370 0xB1, 0x02, /* Feature (Variable), */
371 0x85, 0x05, /* Report ID (5), */
372 0x09, 0x26, /* Usage (26h), */
373 0x95, 0x28, /* Report Count (40), */
374 0xB1, 0x02, /* Feature (Variable), */
375 0x85, 0x06, /* Report ID (6), */
376 0x09, 0x27, /* Usage (27h), */
377 0x95, 0x34, /* Report Count (52), */
378 0xB1, 0x02, /* Feature (Variable), */
379 0x85, 0x07, /* Report ID (7), */
380 0x09, 0x28, /* Usage (28h), */
381 0x95, 0x30, /* Report Count (48), */
382 0xB1, 0x02, /* Feature (Variable), */
383 0x85, 0x08, /* Report ID (8), */
384 0x09, 0x29, /* Usage (29h), */
385 0x95, 0x2F, /* Report Count (47), */
386 0xB1, 0x02, /* Feature (Variable), */
387 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
388 0x85, 0x03, /* Report ID (3), */
389 0x09, 0x21, /* Usage (21h), */
390 0x95, 0x26, /* Report Count (38), */
391 0xB1, 0x02, /* Feature (Variable), */
392 0x85, 0x04, /* Report ID (4), */
393 0x09, 0x22, /* Usage (22h), */
394 0x95, 0x2E, /* Report Count (46), */
395 0xB1, 0x02, /* Feature (Variable), */
396 0x85, 0xF0, /* Report ID (240), */
397 0x09, 0x47, /* Usage (47h), */
398 0x95, 0x3F, /* Report Count (63), */
399 0xB1, 0x02, /* Feature (Variable), */
400 0x85, 0xF1, /* Report ID (241), */
401 0x09, 0x48, /* Usage (48h), */
402 0x95, 0x3F, /* Report Count (63), */
403 0xB1, 0x02, /* Feature (Variable), */
404 0x85, 0xF2, /* Report ID (242), */
405 0x09, 0x49, /* Usage (49h), */
406 0x95, 0x0F, /* Report Count (15), */
407 0xB1, 0x02, /* Feature (Variable), */
408 0x85, 0x11, /* Report ID (17), */
409 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
410 0x09, 0x20, /* Usage (20h), */
411 0x95, 0x02, /* Report Count (2), */
412 0x81, 0x02, /* Input (Variable), */
413 0x05, 0x01, /* Usage Page (Desktop), */
414 0x09, 0x30, /* Usage (X), */
415 0x09, 0x31, /* Usage (Y), */
416 0x09, 0x32, /* Usage (Z), */
417 0x09, 0x35, /* Usage (Rz), */
418 0x15, 0x00, /* Logical Minimum (0), */
419 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
420 0x75, 0x08, /* Report Size (8), */
421 0x95, 0x04, /* Report Count (4), */
422 0x81, 0x02, /* Input (Variable), */
423 0x09, 0x39, /* Usage (Hat Switch), */
424 0x15, 0x00, /* Logical Minimum (0), */
425 0x25, 0x07, /* Logical Maximum (7), */
426 0x75, 0x04, /* Report Size (4), */
427 0x95, 0x01, /* Report Count (1), */
428 0x81, 0x42, /* Input (Variable, Null State), */
429 0x05, 0x09, /* Usage Page (Button), */
430 0x19, 0x01, /* Usage Minimum (01h), */
431 0x29, 0x0E, /* Usage Maximum (0Eh), */
432 0x15, 0x00, /* Logical Minimum (0), */
433 0x25, 0x01, /* Logical Maximum (1), */
434 0x75, 0x01, /* Report Size (1), */
435 0x95, 0x0E, /* Report Count (14), */
436 0x81, 0x02, /* Input (Variable), */
437 0x75, 0x06, /* Report Size (6), */
438 0x95, 0x01, /* Report Count (1), */
439 0x81, 0x01, /* Input (Constant), */
440 0x05, 0x01, /* Usage Page (Desktop), */
441 0x09, 0x33, /* Usage (Rx), */
442 0x09, 0x34, /* Usage (Ry), */
443 0x15, 0x00, /* Logical Minimum (0), */
444 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
445 0x75, 0x08, /* Report Size (8), */
446 0x95, 0x02, /* Report Count (2), */
447 0x81, 0x02, /* Input (Variable), */
448 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
449 0x09, 0x20, /* Usage (20h), */
450 0x95, 0x03, /* Report Count (3), */
451 0x81, 0x02, /* Input (Variable), */
452 0x05, 0x01, /* Usage Page (Desktop), */
453 0x19, 0x40, /* Usage Minimum (40h), */
454 0x29, 0x42, /* Usage Maximum (42h), */
455 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
456 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
457 0x75, 0x10, /* Report Size (16), */
458 0x95, 0x03, /* Report Count (3), */
459 0x81, 0x02, /* Input (Variable), */
460 0x19, 0x43, /* Usage Minimum (43h), */
461 0x29, 0x45, /* Usage Maximum (45h), */
462 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
463 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
464 0x95, 0x03, /* Report Count (3), */
465 0x81, 0x02, /* Input (Variable), */
466 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
467 0x09, 0x20, /* Usage (20h), */
468 0x15, 0x00, /* Logical Minimum (0), */
469 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
470 0x75, 0x08, /* Report Size (8), */
471 0x95, 0x31, /* Report Count (51), */
472 0x81, 0x02, /* Input (Variable), */
473 0x09, 0x21, /* Usage (21h), */
474 0x75, 0x08, /* Report Size (8), */
475 0x95, 0x4D, /* Report Count (77), */
476 0x91, 0x02, /* Output (Variable), */
477 0x85, 0x12, /* Report ID (18), */
478 0x09, 0x22, /* Usage (22h), */
479 0x95, 0x8D, /* Report Count (141), */
480 0x81, 0x02, /* Input (Variable), */
481 0x09, 0x23, /* Usage (23h), */
482 0x91, 0x02, /* Output (Variable), */
483 0x85, 0x13, /* Report ID (19), */
484 0x09, 0x24, /* Usage (24h), */
485 0x95, 0xCD, /* Report Count (205), */
486 0x81, 0x02, /* Input (Variable), */
487 0x09, 0x25, /* Usage (25h), */
488 0x91, 0x02, /* Output (Variable), */
489 0x85, 0x14, /* Report ID (20), */
490 0x09, 0x26, /* Usage (26h), */
491 0x96, 0x0D, 0x01, /* Report Count (269), */
492 0x81, 0x02, /* Input (Variable), */
493 0x09, 0x27, /* Usage (27h), */
494 0x91, 0x02, /* Output (Variable), */
495 0x85, 0x15, /* Report ID (21), */
496 0x09, 0x28, /* Usage (28h), */
497 0x96, 0x4D, 0x01, /* Report Count (333), */
498 0x81, 0x02, /* Input (Variable), */
499 0x09, 0x29, /* Usage (29h), */
500 0x91, 0x02, /* Output (Variable), */
501 0x85, 0x16, /* Report ID (22), */
502 0x09, 0x2A, /* Usage (2Ah), */
503 0x96, 0x8D, 0x01, /* Report Count (397), */
504 0x81, 0x02, /* Input (Variable), */
505 0x09, 0x2B, /* Usage (2Bh), */
506 0x91, 0x02, /* Output (Variable), */
507 0x85, 0x17, /* Report ID (23), */
508 0x09, 0x2C, /* Usage (2Ch), */
509 0x96, 0xCD, 0x01, /* Report Count (461), */
510 0x81, 0x02, /* Input (Variable), */
511 0x09, 0x2D, /* Usage (2Dh), */
512 0x91, 0x02, /* Output (Variable), */
513 0x85, 0x18, /* Report ID (24), */
514 0x09, 0x2E, /* Usage (2Eh), */
515 0x96, 0x0D, 0x02, /* Report Count (525), */
516 0x81, 0x02, /* Input (Variable), */
517 0x09, 0x2F, /* Usage (2Fh), */
518 0x91, 0x02, /* Output (Variable), */
519 0x85, 0x19, /* Report ID (25), */
520 0x09, 0x30, /* Usage (30h), */
521 0x96, 0x22, 0x02, /* Report Count (546), */
522 0x81, 0x02, /* Input (Variable), */
523 0x09, 0x31, /* Usage (31h), */
524 0x91, 0x02, /* Output (Variable), */
525 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
526 0x85, 0x82, /* Report ID (130), */
527 0x09, 0x22, /* Usage (22h), */
528 0x95, 0x3F, /* Report Count (63), */
529 0xB1, 0x02, /* Feature (Variable), */
530 0x85, 0x83, /* Report ID (131), */
531 0x09, 0x23, /* Usage (23h), */
532 0xB1, 0x02, /* Feature (Variable), */
533 0x85, 0x84, /* Report ID (132), */
534 0x09, 0x24, /* Usage (24h), */
535 0xB1, 0x02, /* Feature (Variable), */
536 0x85, 0x90, /* Report ID (144), */
537 0x09, 0x30, /* Usage (30h), */
538 0xB1, 0x02, /* Feature (Variable), */
539 0x85, 0x91, /* Report ID (145), */
540 0x09, 0x31, /* Usage (31h), */
541 0xB1, 0x02, /* Feature (Variable), */
542 0x85, 0x92, /* Report ID (146), */
543 0x09, 0x32, /* Usage (32h), */
544 0xB1, 0x02, /* Feature (Variable), */
545 0x85, 0x93, /* Report ID (147), */
546 0x09, 0x33, /* Usage (33h), */
547 0xB1, 0x02, /* Feature (Variable), */
548 0x85, 0xA0, /* Report ID (160), */
549 0x09, 0x40, /* Usage (40h), */
550 0xB1, 0x02, /* Feature (Variable), */
551 0x85, 0xA4, /* Report ID (164), */
552 0x09, 0x44, /* Usage (44h), */
553 0xB1, 0x02, /* Feature (Variable), */
554 0xC0 /* End Collection */
555};
556
336static __u8 ps3remote_rdesc[] = { 557static __u8 ps3remote_rdesc[] = {
337 0x05, 0x01, /* GUsagePage Generic Desktop */ 558 0x05, 0x01, /* GUsagePage Generic Desktop */
338 0x09, 0x05, /* LUsage 0x05 [Game Pad] */ 559 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
@@ -450,7 +671,8 @@ static const unsigned int ps3remote_keymap_remote_buttons[] = {
450}; 671};
451 672
452static const unsigned int buzz_keymap[] = { 673static const unsigned int buzz_keymap[] = {
453 /* The controller has 4 remote buzzers, each with one LED and 5 674 /*
675 * The controller has 4 remote buzzers, each with one LED and 5
454 * buttons. 676 * buttons.
455 * 677 *
456 * We use the mapping chosen by the controller, which is: 678 * We use the mapping chosen by the controller, which is:
@@ -488,19 +710,35 @@ static const unsigned int buzz_keymap[] = {
488 [20] = BTN_TRIGGER_HAPPY20, 710 [20] = BTN_TRIGGER_HAPPY20,
489}; 711};
490 712
713static enum power_supply_property sony_battery_props[] = {
714 POWER_SUPPLY_PROP_PRESENT,
715 POWER_SUPPLY_PROP_CAPACITY,
716 POWER_SUPPLY_PROP_SCOPE,
717 POWER_SUPPLY_PROP_STATUS,
718};
719
720static spinlock_t sony_dev_list_lock;
721static LIST_HEAD(sony_device_list);
722
491struct sony_sc { 723struct sony_sc {
724 spinlock_t lock;
725 struct list_head list_node;
492 struct hid_device *hdev; 726 struct hid_device *hdev;
493 struct led_classdev *leds[MAX_LEDS]; 727 struct led_classdev *leds[MAX_LEDS];
494 struct hid_report *output_report;
495 unsigned long quirks; 728 unsigned long quirks;
496 struct work_struct state_worker; 729 struct work_struct state_worker;
730 struct power_supply battery;
497 731
498#ifdef CONFIG_SONY_FF 732#ifdef CONFIG_SONY_FF
499 __u8 left; 733 __u8 left;
500 __u8 right; 734 __u8 right;
501#endif 735#endif
502 736
737 __u8 mac_address[6];
503 __u8 worker_initialized; 738 __u8 worker_initialized;
739 __u8 cable_state;
740 __u8 battery_charging;
741 __u8 battery_capacity;
504 __u8 led_state[MAX_LEDS]; 742 __u8 led_state[MAX_LEDS];
505 __u8 led_count; 743 __u8 led_count;
506}; 744};
@@ -578,6 +816,10 @@ static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
578 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n"); 816 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
579 rdesc = dualshock4_usb_rdesc; 817 rdesc = dualshock4_usb_rdesc;
580 *rsize = sizeof(dualshock4_usb_rdesc); 818 *rsize = sizeof(dualshock4_usb_rdesc);
819 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
820 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
821 rdesc = dualshock4_bt_rdesc;
822 *rsize = sizeof(dualshock4_bt_rdesc);
581 } 823 }
582 824
583 /* The HID descriptor exposed over BT has a trailing zero byte */ 825 /* The HID descriptor exposed over BT has a trailing zero byte */
@@ -601,20 +843,127 @@ static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
601 return rdesc; 843 return rdesc;
602} 844}
603 845
846static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
847{
848 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
849 unsigned long flags;
850 __u8 cable_state, battery_capacity, battery_charging;
851
852 /*
853 * The sixaxis is charging if the battery value is 0xee
854 * and it is fully charged if the value is 0xef.
855 * It does not report the actual level while charging so it
856 * is set to 100% while charging is in progress.
857 */
858 if (rd[30] >= 0xee) {
859 battery_capacity = 100;
860 battery_charging = !(rd[30] & 0x01);
861 } else {
862 __u8 index = rd[30] <= 5 ? rd[30] : 5;
863 battery_capacity = sixaxis_battery_capacity[index];
864 battery_charging = 0;
865 }
866 cable_state = !(rd[31] & 0x04);
867
868 spin_lock_irqsave(&sc->lock, flags);
869 sc->cable_state = cable_state;
870 sc->battery_capacity = battery_capacity;
871 sc->battery_charging = battery_charging;
872 spin_unlock_irqrestore(&sc->lock, flags);
873}
874
875static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
876{
877 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
878 struct hid_input, list);
879 struct input_dev *input_dev = hidinput->input;
880 unsigned long flags;
881 int n, offset;
882 __u8 cable_state, battery_capacity, battery_charging;
883
884 /*
885 * Battery and touchpad data starts at byte 30 in the USB report and
886 * 32 in Bluetooth report.
887 */
888 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
889
890 /*
891 * The lower 4 bits of byte 30 contain the battery level
892 * and the 5th bit contains the USB cable state.
893 */
894 cable_state = (rd[offset] >> 4) & 0x01;
895 battery_capacity = rd[offset] & 0x0F;
896
897 /*
898 * When a USB power source is connected the battery level ranges from
899 * 0 to 10, and when running on battery power it ranges from 0 to 9.
900 * A battery level above 10 when plugged in means charge completed.
901 */
902 if (!cable_state || battery_capacity > 10)
903 battery_charging = 0;
904 else
905 battery_charging = 1;
906
907 if (!cable_state)
908 battery_capacity++;
909 if (battery_capacity > 10)
910 battery_capacity = 10;
911
912 battery_capacity *= 10;
913
914 spin_lock_irqsave(&sc->lock, flags);
915 sc->cable_state = cable_state;
916 sc->battery_capacity = battery_capacity;
917 sc->battery_charging = battery_charging;
918 spin_unlock_irqrestore(&sc->lock, flags);
919
920 offset += 5;
921
922 /*
923 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
924 * and 37 on Bluetooth.
925 * The first 7 bits of the first byte is a counter and bit 8 is a touch
926 * indicator that is 0 when pressed and 1 when not pressed.
927 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
928 * The data for the second touch is in the same format and immediatly
929 * follows the data for the first.
930 */
931 for (n = 0; n < 2; n++) {
932 __u16 x, y;
933
934 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
935 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
936
937 input_mt_slot(input_dev, n);
938 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
939 !(rd[offset] >> 7));
940 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
941 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
942
943 offset += 4;
944 }
945}
946
604static int sony_raw_event(struct hid_device *hdev, struct hid_report *report, 947static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
605 __u8 *rd, int size) 948 __u8 *rd, int size)
606{ 949{
607 struct sony_sc *sc = hid_get_drvdata(hdev); 950 struct sony_sc *sc = hid_get_drvdata(hdev);
608 951
609 /* Sixaxis HID report has acclerometers/gyro with MSByte first, this 952 /*
953 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
610 * has to be BYTE_SWAPPED before passing up to joystick interface 954 * has to be BYTE_SWAPPED before passing up to joystick interface
611 */ 955 */
612 if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) && 956 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
613 rd[0] == 0x01 && size == 49) {
614 swap(rd[41], rd[42]); 957 swap(rd[41], rd[42]);
615 swap(rd[43], rd[44]); 958 swap(rd[43], rd[44]);
616 swap(rd[45], rd[46]); 959 swap(rd[45], rd[46]);
617 swap(rd[47], rd[48]); 960 swap(rd[47], rd[48]);
961
962 sixaxis_parse_report(sc, rd, size);
963 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
964 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
965 && rd[0] == 0x11 && size == 78)) {
966 dualshock4_parse_report(sc, rd, size);
618 } 967 }
619 968
620 return 0; 969 return 0;
@@ -657,45 +1006,6 @@ static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
657} 1006}
658 1007
659/* 1008/*
660 * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
661 * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
662 * so we need to override that forcing HID Output Reports on the Control EP.
663 *
664 * There is also another issue about HID Output Reports via USB, the Sixaxis
665 * does not want the report_id as part of the data packet, so we have to
666 * discard buf[0] when sending the actual control message, even for numbered
667 * reports, humpf!
668 */
669static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
670 size_t count, unsigned char report_type)
671{
672 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
673 struct usb_device *dev = interface_to_usbdev(intf);
674 struct usb_host_interface *interface = intf->cur_altsetting;
675 int report_id = buf[0];
676 int ret;
677
678 if (report_type == HID_OUTPUT_REPORT) {
679 /* Don't send the Report ID */
680 buf++;
681 count--;
682 }
683
684 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
685 HID_REQ_SET_REPORT,
686 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
687 ((report_type + 1) << 8) | report_id,
688 interface->desc.bInterfaceNumber, buf, count,
689 USB_CTRL_SET_TIMEOUT);
690
691 /* Count also the Report ID, in case of an Output report. */
692 if (ret > 0 && report_type == HID_OUTPUT_REPORT)
693 ret++;
694
695 return ret;
696}
697
698/*
699 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller 1009 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
700 * to "operational". Without this, the ps3 controller will not report any 1010 * to "operational". Without this, the ps3 controller will not report any
701 * events. 1011 * events.
@@ -708,7 +1018,8 @@ static int sixaxis_set_operational_usb(struct hid_device *hdev)
708 if (!buf) 1018 if (!buf)
709 return -ENOMEM; 1019 return -ENOMEM;
710 1020
711 ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT); 1021 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1022 HID_REQ_GET_REPORT);
712 1023
713 if (ret < 0) 1024 if (ret < 0)
714 hid_err(hdev, "can't set operational mode\n"); 1025 hid_err(hdev, "can't set operational mode\n");
@@ -721,7 +1032,20 @@ static int sixaxis_set_operational_usb(struct hid_device *hdev)
721static int sixaxis_set_operational_bt(struct hid_device *hdev) 1032static int sixaxis_set_operational_bt(struct hid_device *hdev)
722{ 1033{
723 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 }; 1034 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
724 return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); 1035 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
1036 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1037}
1038
1039/*
1040 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1041 * controller so that it sends full input reports of type 0x11.
1042 */
1043static int dualshock4_set_operational_bt(struct hid_device *hdev)
1044{
1045 __u8 buf[37] = { 0 };
1046
1047 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf),
1048 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
725} 1049}
726 1050
727static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds) 1051static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
@@ -751,8 +1075,7 @@ static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
751 1075
752 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) { 1076 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
753 buzz_set_leds(hdev, leds); 1077 buzz_set_leds(hdev, leds);
754 } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) || 1078 } else {
755 (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
756 for (n = 0; n < count; n++) 1079 for (n = 0; n < count; n++)
757 drv_data->led_state[n] = leds[n]; 1080 drv_data->led_state[n] = leds[n];
758 schedule_work(&drv_data->state_worker); 1081 schedule_work(&drv_data->state_worker);
@@ -792,7 +1115,6 @@ static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
792 struct sony_sc *drv_data; 1115 struct sony_sc *drv_data;
793 1116
794 int n; 1117 int n;
795 int on = 0;
796 1118
797 drv_data = hid_get_drvdata(hdev); 1119 drv_data = hid_get_drvdata(hdev);
798 if (!drv_data) { 1120 if (!drv_data) {
@@ -801,13 +1123,11 @@ static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
801 } 1123 }
802 1124
803 for (n = 0; n < drv_data->led_count; n++) { 1125 for (n = 0; n < drv_data->led_count; n++) {
804 if (led == drv_data->leds[n]) { 1126 if (led == drv_data->leds[n])
805 on = !!(drv_data->led_state[n]); 1127 return drv_data->led_state[n];
806 break;
807 }
808 } 1128 }
809 1129
810 return on ? LED_FULL : LED_OFF; 1130 return LED_OFF;
811} 1131}
812 1132
813static void sony_leds_remove(struct hid_device *hdev) 1133static void sony_leds_remove(struct hid_device *hdev)
@@ -857,7 +1177,7 @@ static int sony_leds_init(struct hid_device *hdev)
857 /* Validate expected report characteristics. */ 1177 /* Validate expected report characteristics. */
858 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7)) 1178 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
859 return -ENODEV; 1179 return -ENODEV;
860 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) { 1180 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER) {
861 drv_data->led_count = 3; 1181 drv_data->led_count = 3;
862 max_brightness = 255; 1182 max_brightness = 255;
863 use_colors = 1; 1183 use_colors = 1;
@@ -871,9 +1191,11 @@ static int sony_leds_init(struct hid_device *hdev)
871 name_fmt = "%s::sony%d"; 1191 name_fmt = "%s::sony%d";
872 } 1192 }
873 1193
874 /* Clear LEDs as we have no way of reading their initial state. This is 1194 /*
1195 * Clear LEDs as we have no way of reading their initial state. This is
875 * only relevant if the driver is loaded after somebody actively set the 1196 * only relevant if the driver is loaded after somebody actively set the
876 * LEDs to on */ 1197 * LEDs to on
1198 */
877 sony_set_leds(hdev, initial_values, drv_data->led_count); 1199 sony_set_leds(hdev, initial_values, drv_data->led_count);
878 1200
879 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1; 1201 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
@@ -943,29 +1265,45 @@ static void sixaxis_state_worker(struct work_struct *work)
943 buf[10] |= sc->led_state[2] << 3; 1265 buf[10] |= sc->led_state[2] << 3;
944 buf[10] |= sc->led_state[3] << 4; 1266 buf[10] |= sc->led_state[3] << 4;
945 1267
946 sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf), 1268 hid_hw_raw_request(sc->hdev, 0x01, buf, sizeof(buf), HID_OUTPUT_REPORT,
947 HID_OUTPUT_REPORT); 1269 HID_REQ_SET_REPORT);
948} 1270}
949 1271
950static void dualshock4_state_worker(struct work_struct *work) 1272static void dualshock4_state_worker(struct work_struct *work)
951{ 1273{
952 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker); 1274 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
953 struct hid_device *hdev = sc->hdev; 1275 struct hid_device *hdev = sc->hdev;
954 struct hid_report *report = sc->output_report; 1276 int offset;
955 __s32 *value = report->field[0]->value;
956 1277
957 value[0] = 0x03; 1278 __u8 buf[78] = { 0 };
1279
1280 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1281 buf[0] = 0x05;
1282 buf[1] = 0x03;
1283 offset = 4;
1284 } else {
1285 buf[0] = 0x11;
1286 buf[1] = 0xB0;
1287 buf[3] = 0x0F;
1288 offset = 6;
1289 }
958 1290
959#ifdef CONFIG_SONY_FF 1291#ifdef CONFIG_SONY_FF
960 value[3] = sc->right; 1292 buf[offset++] = sc->right;
961 value[4] = sc->left; 1293 buf[offset++] = sc->left;
1294#else
1295 offset += 2;
962#endif 1296#endif
963 1297
964 value[5] = sc->led_state[0]; 1298 buf[offset++] = sc->led_state[0];
965 value[6] = sc->led_state[1]; 1299 buf[offset++] = sc->led_state[1];
966 value[7] = sc->led_state[2]; 1300 buf[offset++] = sc->led_state[2];
967 1301
968 hid_hw_request(hdev, report, HID_REQ_SET_REPORT); 1302 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1303 hid_hw_output_report(hdev, buf, 32);
1304 else
1305 hid_hw_raw_request(hdev, 0x11, buf, 78,
1306 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
969} 1307}
970 1308
971#ifdef CONFIG_SONY_FF 1309#ifdef CONFIG_SONY_FF
@@ -1000,35 +1338,247 @@ static int sony_init_ff(struct hid_device *hdev)
1000{ 1338{
1001 return 0; 1339 return 0;
1002} 1340}
1341
1003#endif 1342#endif
1004 1343
1005static int sony_set_output_report(struct sony_sc *sc, int req_id, int req_size) 1344static int sony_battery_get_property(struct power_supply *psy,
1345 enum power_supply_property psp,
1346 union power_supply_propval *val)
1006{ 1347{
1007 struct list_head *head, *list; 1348 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1008 struct hid_report *report; 1349 unsigned long flags;
1350 int ret = 0;
1351 u8 battery_charging, battery_capacity, cable_state;
1352
1353 spin_lock_irqsave(&sc->lock, flags);
1354 battery_charging = sc->battery_charging;
1355 battery_capacity = sc->battery_capacity;
1356 cable_state = sc->cable_state;
1357 spin_unlock_irqrestore(&sc->lock, flags);
1358
1359 switch (psp) {
1360 case POWER_SUPPLY_PROP_PRESENT:
1361 val->intval = 1;
1362 break;
1363 case POWER_SUPPLY_PROP_SCOPE:
1364 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1365 break;
1366 case POWER_SUPPLY_PROP_CAPACITY:
1367 val->intval = battery_capacity;
1368 break;
1369 case POWER_SUPPLY_PROP_STATUS:
1370 if (battery_charging)
1371 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1372 else
1373 if (battery_capacity == 100 && cable_state)
1374 val->intval = POWER_SUPPLY_STATUS_FULL;
1375 else
1376 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1377 break;
1378 default:
1379 ret = -EINVAL;
1380 break;
1381 }
1382 return ret;
1383}
1384
1385static int sony_battery_probe(struct sony_sc *sc)
1386{
1387 static atomic_t power_id_seq = ATOMIC_INIT(0);
1388 unsigned long power_id;
1009 struct hid_device *hdev = sc->hdev; 1389 struct hid_device *hdev = sc->hdev;
1390 int ret;
1391
1392 /*
1393 * Set the default battery level to 100% to avoid low battery warnings
1394 * if the battery is polled before the first device report is received.
1395 */
1396 sc->battery_capacity = 100;
1397
1398 power_id = (unsigned long)atomic_inc_return(&power_id_seq);
1399
1400 sc->battery.properties = sony_battery_props;
1401 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1402 sc->battery.get_property = sony_battery_get_property;
1403 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1404 sc->battery.use_for_apm = 0;
1405 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%lu",
1406 power_id);
1407 if (!sc->battery.name)
1408 return -ENOMEM;
1010 1409
1011 list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list; 1410 ret = power_supply_register(&hdev->dev, &sc->battery);
1411 if (ret) {
1412 hid_err(hdev, "Unable to register battery device\n");
1413 goto err_free;
1414 }
1012 1415
1013 list_for_each(head, list) { 1416 power_supply_powers(&sc->battery, &hdev->dev);
1014 report = list_entry(head, struct hid_report, list); 1417 return 0;
1015 1418
1016 if (report->id == req_id) { 1419err_free:
1017 if (report->size < req_size) { 1420 kfree(sc->battery.name);
1018 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n", 1421 sc->battery.name = NULL;
1019 req_id, report->size, req_size); 1422 return ret;
1020 return -EINVAL; 1423}
1021 } 1424
1022 sc->output_report = report; 1425static void sony_battery_remove(struct sony_sc *sc)
1023 return 0; 1426{
1427 if (!sc->battery.name)
1428 return;
1429
1430 power_supply_unregister(&sc->battery);
1431 kfree(sc->battery.name);
1432 sc->battery.name = NULL;
1433}
1434
1435static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1436 int w, int h)
1437{
1438 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1439 struct hid_input, list);
1440 struct input_dev *input_dev = hidinput->input;
1441 int ret;
1442
1443 ret = input_mt_init_slots(input_dev, touch_count, 0);
1444 if (ret < 0) {
1445 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1446 return ret;
1447 }
1448
1449 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1450 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1451
1452 return 0;
1453}
1454
1455/*
1456 * If a controller is plugged in via USB while already connected via Bluetooth
1457 * it will show up as two devices. A global list of connected controllers and
1458 * their MAC addresses is maintained to ensure that a device is only connected
1459 * once.
1460 */
1461static int sony_check_add_dev_list(struct sony_sc *sc)
1462{
1463 struct sony_sc *entry;
1464 unsigned long flags;
1465 int ret;
1466
1467 spin_lock_irqsave(&sony_dev_list_lock, flags);
1468
1469 list_for_each_entry(entry, &sony_device_list, list_node) {
1470 ret = memcmp(sc->mac_address, entry->mac_address,
1471 sizeof(sc->mac_address));
1472 if (!ret) {
1473 ret = -EEXIST;
1474 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1475 sc->mac_address);
1476 goto unlock;
1024 } 1477 }
1025 } 1478 }
1026 1479
1027 hid_err(hdev, "Unable to locate output report 0x%02x\n", req_id); 1480 ret = 0;
1481 list_add(&(sc->list_node), &sony_device_list);
1028 1482
1029 return -EINVAL; 1483unlock:
1484 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1485 return ret;
1486}
1487
1488static void sony_remove_dev_list(struct sony_sc *sc)
1489{
1490 unsigned long flags;
1491
1492 if (sc->list_node.next) {
1493 spin_lock_irqsave(&sony_dev_list_lock, flags);
1494 list_del(&(sc->list_node));
1495 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1496 }
1030} 1497}
1031 1498
1499static int sony_get_bt_devaddr(struct sony_sc *sc)
1500{
1501 int ret;
1502
1503 /* HIDP stores the device MAC address as a string in the uniq field. */
1504 ret = strlen(sc->hdev->uniq);
1505 if (ret != 17)
1506 return -EINVAL;
1507
1508 ret = sscanf(sc->hdev->uniq,
1509 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1510 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1511 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1512
1513 if (ret != 6)
1514 return -EINVAL;
1515
1516 return 0;
1517}
1518
1519static int sony_check_add(struct sony_sc *sc)
1520{
1521 int n, ret;
1522
1523 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1524 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1525 /*
1526 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1527 * address from the uniq string where HIDP stores it.
1528 * As uniq cannot be guaranteed to be a MAC address in all cases
1529 * a failure of this function should not prevent the connection.
1530 */
1531 if (sony_get_bt_devaddr(sc) < 0) {
1532 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1533 return 0;
1534 }
1535 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1536 __u8 buf[7];
1537
1538 /*
1539 * The MAC address of a DS4 controller connected via USB can be
1540 * retrieved with feature report 0x81. The address begins at
1541 * offset 1.
1542 */
1543 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1544 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1545
1546 if (ret != 7) {
1547 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1548 return ret < 0 ? ret : -EINVAL;
1549 }
1550
1551 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1552 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1553 __u8 buf[18];
1554
1555 /*
1556 * The MAC address of a Sixaxis controller connected via USB can
1557 * be retrieved with feature report 0xf2. The address begins at
1558 * offset 4.
1559 */
1560 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1561 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1562
1563 if (ret != 18) {
1564 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1565 return ret < 0 ? ret : -EINVAL;
1566 }
1567
1568 /*
1569 * The Sixaxis device MAC in the report is big-endian and must
1570 * be byte-swapped.
1571 */
1572 for (n = 0; n < 6; n++)
1573 sc->mac_address[5-n] = buf[4+n];
1574 } else {
1575 return 0;
1576 }
1577
1578 return sony_check_add_dev_list(sc);
1579}
1580
1581
1032static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) 1582static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1033{ 1583{
1034 int ret; 1584 int ret;
@@ -1066,17 +1616,48 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1066 } 1616 }
1067 1617
1068 if (sc->quirks & SIXAXIS_CONTROLLER_USB) { 1618 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1069 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report; 1619 /*
1620 * The Sony Sixaxis does not handle HID Output Reports on the
1621 * Interrupt EP like it could, so we need to force HID Output
1622 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1623 *
1624 * There is also another issue about HID Output Reports via USB,
1625 * the Sixaxis does not want the report_id as part of the data
1626 * packet, so we have to discard buf[0] when sending the actual
1627 * control message, even for numbered reports, humpf!
1628 */
1629 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1630 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1070 ret = sixaxis_set_operational_usb(hdev); 1631 ret = sixaxis_set_operational_usb(hdev);
1071
1072 sc->worker_initialized = 1; 1632 sc->worker_initialized = 1;
1073 INIT_WORK(&sc->state_worker, sixaxis_state_worker); 1633 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1074 } 1634 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1075 else if (sc->quirks & SIXAXIS_CONTROLLER_BT) 1635 /*
1636 * The Sixaxis wants output reports sent on the ctrl endpoint
1637 * when connected via Bluetooth.
1638 */
1639 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1076 ret = sixaxis_set_operational_bt(hdev); 1640 ret = sixaxis_set_operational_bt(hdev);
1077 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) { 1641 sc->worker_initialized = 1;
1078 /* Report 5 (31 bytes) is used to send data to the controller via USB */ 1642 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1079 ret = sony_set_output_report(sc, 0x05, 248); 1643 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1644 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1645 /*
1646 * The DualShock 4 wants output reports sent on the ctrl
1647 * endpoint when connected via Bluetooth.
1648 */
1649 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1650 ret = dualshock4_set_operational_bt(hdev);
1651 if (ret < 0) {
1652 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1653 goto err_stop;
1654 }
1655 }
1656 /*
1657 * The Dualshock 4 touchpad supports 2 touches and has a
1658 * resolution of 1920x940.
1659 */
1660 ret = sony_register_touchpad(sc, 2, 1920, 940);
1080 if (ret < 0) 1661 if (ret < 0)
1081 goto err_stop; 1662 goto err_stop;
1082 1663
@@ -1089,22 +1670,46 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1089 if (ret < 0) 1670 if (ret < 0)
1090 goto err_stop; 1671 goto err_stop;
1091 1672
1673 ret = sony_check_add(sc);
1674 if (ret < 0)
1675 goto err_stop;
1676
1092 if (sc->quirks & SONY_LED_SUPPORT) { 1677 if (sc->quirks & SONY_LED_SUPPORT) {
1093 ret = sony_leds_init(hdev); 1678 ret = sony_leds_init(hdev);
1094 if (ret < 0) 1679 if (ret < 0)
1095 goto err_stop; 1680 goto err_stop;
1096 } 1681 }
1097 1682
1683 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1684 ret = sony_battery_probe(sc);
1685 if (ret < 0)
1686 goto err_stop;
1687
1688 /* Open the device to receive reports with battery info */
1689 ret = hid_hw_open(hdev);
1690 if (ret < 0) {
1691 hid_err(hdev, "hw open failed\n");
1692 goto err_stop;
1693 }
1694 }
1695
1098 if (sc->quirks & SONY_FF_SUPPORT) { 1696 if (sc->quirks & SONY_FF_SUPPORT) {
1099 ret = sony_init_ff(hdev); 1697 ret = sony_init_ff(hdev);
1100 if (ret < 0) 1698 if (ret < 0)
1101 goto err_stop; 1699 goto err_close;
1102 } 1700 }
1103 1701
1104 return 0; 1702 return 0;
1703err_close:
1704 hid_hw_close(hdev);
1105err_stop: 1705err_stop:
1106 if (sc->quirks & SONY_LED_SUPPORT) 1706 if (sc->quirks & SONY_LED_SUPPORT)
1107 sony_leds_remove(hdev); 1707 sony_leds_remove(hdev);
1708 if (sc->quirks & SONY_BATTERY_SUPPORT)
1709 sony_battery_remove(sc);
1710 if (sc->worker_initialized)
1711 cancel_work_sync(&sc->state_worker);
1712 sony_remove_dev_list(sc);
1108 hid_hw_stop(hdev); 1713 hid_hw_stop(hdev);
1109 return ret; 1714 return ret;
1110} 1715}
@@ -1118,6 +1723,15 @@ static void sony_remove(struct hid_device *hdev)
1118 1723
1119 if (sc->worker_initialized) 1724 if (sc->worker_initialized)
1120 cancel_work_sync(&sc->state_worker); 1725 cancel_work_sync(&sc->state_worker);
1726 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1727 hid_hw_close(hdev);
1728 sony_battery_remove(sc);
1729 }
1730
1731 if (sc->worker_initialized)
1732 cancel_work_sync(&sc->state_worker);
1733
1734 sony_remove_dev_list(sc);
1121 1735
1122 hid_hw_stop(hdev); 1736 hid_hw_stop(hdev);
1123} 1737}
diff --git a/drivers/hid/hid-thingm.c b/drivers/hid/hid-thingm.c
index 99342cfa0ea2..a97c78845f7b 100644
--- a/drivers/hid/hid-thingm.c
+++ b/drivers/hid/hid-thingm.c
@@ -48,8 +48,8 @@ static int blink1_send_command(struct blink1_data *data,
48 buf[0], buf[1], buf[2], buf[3], buf[4], 48 buf[0], buf[1], buf[2], buf[3], buf[4],
49 buf[5], buf[6], buf[7], buf[8]); 49 buf[5], buf[6], buf[7], buf[8]);
50 50
51 ret = data->hdev->hid_output_raw_report(data->hdev, buf, 51 ret = hid_hw_raw_request(data->hdev, buf[0], buf, BLINK1_CMD_SIZE,
52 BLINK1_CMD_SIZE, HID_FEATURE_REPORT); 52 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
53 53
54 return ret < 0 ? ret : 0; 54 return ret < 0 ? ret : 0;
55} 55}
diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c
index 60c75dcbbdb8..902013ec041b 100644
--- a/drivers/hid/hid-wacom.c
+++ b/drivers/hid/hid-wacom.c
@@ -128,8 +128,8 @@ static void wacom_set_image(struct hid_device *hdev, const char *image,
128 128
129 rep_data[0] = WAC_CMD_ICON_START_STOP; 129 rep_data[0] = WAC_CMD_ICON_START_STOP;
130 rep_data[1] = 0; 130 rep_data[1] = 0;
131 ret = hdev->hid_output_raw_report(hdev, rep_data, 2, 131 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
132 HID_FEATURE_REPORT); 132 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
133 if (ret < 0) 133 if (ret < 0)
134 goto err; 134 goto err;
135 135
@@ -143,15 +143,15 @@ static void wacom_set_image(struct hid_device *hdev, const char *image,
143 rep_data[j + 3] = p[(i << 6) + j]; 143 rep_data[j + 3] = p[(i << 6) + j];
144 144
145 rep_data[2] = i; 145 rep_data[2] = i;
146 ret = hdev->hid_output_raw_report(hdev, rep_data, 67, 146 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 67,
147 HID_FEATURE_REPORT); 147 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
148 } 148 }
149 149
150 rep_data[0] = WAC_CMD_ICON_START_STOP; 150 rep_data[0] = WAC_CMD_ICON_START_STOP;
151 rep_data[1] = 0; 151 rep_data[1] = 0;
152 152
153 ret = hdev->hid_output_raw_report(hdev, rep_data, 2, 153 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
154 HID_FEATURE_REPORT); 154 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
155 155
156err: 156err:
157 return; 157 return;
@@ -183,7 +183,8 @@ static void wacom_leds_set_brightness(struct led_classdev *led_dev,
183 buf[3] = value; 183 buf[3] = value;
184 /* use fixed brightness for OLEDs */ 184 /* use fixed brightness for OLEDs */
185 buf[4] = 0x08; 185 buf[4] = 0x08;
186 hdev->hid_output_raw_report(hdev, buf, 9, HID_FEATURE_REPORT); 186 hid_hw_raw_request(hdev, buf[0], buf, 9, HID_FEATURE_REPORT,
187 HID_REQ_SET_REPORT);
187 kfree(buf); 188 kfree(buf);
188 } 189 }
189 190
@@ -339,8 +340,8 @@ static void wacom_set_features(struct hid_device *hdev, u8 speed)
339 rep_data[0] = 0x03 ; rep_data[1] = 0x00; 340 rep_data[0] = 0x03 ; rep_data[1] = 0x00;
340 limit = 3; 341 limit = 3;
341 do { 342 do {
342 ret = hdev->hid_output_raw_report(hdev, rep_data, 2, 343 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
343 HID_FEATURE_REPORT); 344 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
344 } while (ret < 0 && limit-- > 0); 345 } while (ret < 0 && limit-- > 0);
345 346
346 if (ret >= 0) { 347 if (ret >= 0) {
@@ -352,8 +353,9 @@ static void wacom_set_features(struct hid_device *hdev, u8 speed)
352 rep_data[1] = 0x00; 353 rep_data[1] = 0x00;
353 limit = 3; 354 limit = 3;
354 do { 355 do {
355 ret = hdev->hid_output_raw_report(hdev, 356 ret = hid_hw_raw_request(hdev, rep_data[0],
356 rep_data, 2, HID_FEATURE_REPORT); 357 rep_data, 2, HID_FEATURE_REPORT,
358 HID_REQ_SET_REPORT);
357 } while (ret < 0 && limit-- > 0); 359 } while (ret < 0 && limit-- > 0);
358 360
359 if (ret >= 0) { 361 if (ret >= 0) {
@@ -378,8 +380,8 @@ static void wacom_set_features(struct hid_device *hdev, u8 speed)
378 rep_data[0] = 0x03; 380 rep_data[0] = 0x03;
379 rep_data[1] = wdata->features; 381 rep_data[1] = wdata->features;
380 382
381 ret = hdev->hid_output_raw_report(hdev, rep_data, 2, 383 ret = hid_hw_raw_request(hdev, rep_data[0], rep_data, 2,
382 HID_FEATURE_REPORT); 384 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
383 if (ret >= 0) 385 if (ret >= 0)
384 wdata->high_speed = speed; 386 wdata->high_speed = speed;
385 break; 387 break;
diff --git a/drivers/hid/hid-wiimote-core.c b/drivers/hid/hid-wiimote-core.c
index abb20db2b443..d00391418d1a 100644
--- a/drivers/hid/hid-wiimote-core.c
+++ b/drivers/hid/hid-wiimote-core.c
@@ -28,14 +28,14 @@ static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
28 __u8 *buf; 28 __u8 *buf;
29 int ret; 29 int ret;
30 30
31 if (!hdev->hid_output_raw_report) 31 if (!hdev->ll_driver->output_report)
32 return -ENODEV; 32 return -ENODEV;
33 33
34 buf = kmemdup(buffer, count, GFP_KERNEL); 34 buf = kmemdup(buffer, count, GFP_KERNEL);
35 if (!buf) 35 if (!buf)
36 return -ENOMEM; 36 return -ENOMEM;
37 37
38 ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT); 38 ret = hid_hw_output_report(hdev, buf, count);
39 39
40 kfree(buf); 40 kfree(buf);
41 return ret; 41 return ret;
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index ab24ce2eb28f..9c2d7c23f296 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -123,10 +123,6 @@ static ssize_t hidraw_send_report(struct file *file, const char __user *buffer,
123 123
124 dev = hidraw_table[minor]->hid; 124 dev = hidraw_table[minor]->hid;
125 125
126 if (!dev->hid_output_raw_report) {
127 ret = -ENODEV;
128 goto out;
129 }
130 126
131 if (count > HID_MAX_BUFFER_SIZE) { 127 if (count > HID_MAX_BUFFER_SIZE) {
132 hid_warn(dev, "pid %d passed too large report\n", 128 hid_warn(dev, "pid %d passed too large report\n",
@@ -153,7 +149,21 @@ static ssize_t hidraw_send_report(struct file *file, const char __user *buffer,
153 goto out_free; 149 goto out_free;
154 } 150 }
155 151
156 ret = dev->hid_output_raw_report(dev, buf, count, report_type); 152 if ((report_type == HID_OUTPUT_REPORT) &&
153 !(dev->quirks & HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP)) {
154 ret = hid_hw_output_report(dev, buf, count);
155 /*
156 * compatibility with old implementation of USB-HID and I2C-HID:
157 * if the device does not support receiving output reports,
158 * on an interrupt endpoint, fallback to SET_REPORT HID command.
159 */
160 if (ret != -ENOSYS)
161 goto out_free;
162 }
163
164 ret = hid_hw_raw_request(dev, buf[0], buf, count, report_type,
165 HID_REQ_SET_REPORT);
166
157out_free: 167out_free:
158 kfree(buf); 168 kfree(buf);
159out: 169out:
@@ -189,7 +199,7 @@ static ssize_t hidraw_get_report(struct file *file, char __user *buffer, size_t
189 199
190 dev = hidraw_table[minor]->hid; 200 dev = hidraw_table[minor]->hid;
191 201
192 if (!dev->hid_get_raw_report) { 202 if (!dev->ll_driver->raw_request) {
193 ret = -ENODEV; 203 ret = -ENODEV;
194 goto out; 204 goto out;
195 } 205 }
@@ -216,14 +226,15 @@ static ssize_t hidraw_get_report(struct file *file, char __user *buffer, size_t
216 226
217 /* 227 /*
218 * Read the first byte from the user. This is the report number, 228 * Read the first byte from the user. This is the report number,
219 * which is passed to dev->hid_get_raw_report(). 229 * which is passed to hid_hw_raw_request().
220 */ 230 */
221 if (copy_from_user(&report_number, buffer, 1)) { 231 if (copy_from_user(&report_number, buffer, 1)) {
222 ret = -EFAULT; 232 ret = -EFAULT;
223 goto out_free; 233 goto out_free;
224 } 234 }
225 235
226 ret = dev->hid_get_raw_report(dev, report_number, buf, count, report_type); 236 ret = hid_hw_raw_request(dev, report_number, buf, count, report_type,
237 HID_REQ_GET_REPORT);
227 238
228 if (ret < 0) 239 if (ret < 0)
229 goto out_free; 240 goto out_free;
diff --git a/drivers/hid/i2c-hid/i2c-hid.c b/drivers/hid/i2c-hid/i2c-hid.c
index 42eebd14de1f..b50860db92f1 100644
--- a/drivers/hid/i2c-hid/i2c-hid.c
+++ b/drivers/hid/i2c-hid/i2c-hid.c
@@ -25,6 +25,7 @@
25#include <linux/delay.h> 25#include <linux/delay.h>
26#include <linux/slab.h> 26#include <linux/slab.h>
27#include <linux/pm.h> 27#include <linux/pm.h>
28#include <linux/pm_runtime.h>
28#include <linux/device.h> 29#include <linux/device.h>
29#include <linux/wait.h> 30#include <linux/wait.h>
30#include <linux/err.h> 31#include <linux/err.h>
@@ -256,18 +257,27 @@ static int i2c_hid_get_report(struct i2c_client *client, u8 reportType,
256 return 0; 257 return 0;
257} 258}
258 259
259static int i2c_hid_set_report(struct i2c_client *client, u8 reportType, 260/**
260 u8 reportID, unsigned char *buf, size_t data_len) 261 * i2c_hid_set_or_send_report: forward an incoming report to the device
262 * @client: the i2c_client of the device
263 * @reportType: 0x03 for HID_FEATURE_REPORT ; 0x02 for HID_OUTPUT_REPORT
264 * @reportID: the report ID
265 * @buf: the actual data to transfer, without the report ID
266 * @len: size of buf
267 * @use_data: true: use SET_REPORT HID command, false: send plain OUTPUT report
268 */
269static int i2c_hid_set_or_send_report(struct i2c_client *client, u8 reportType,
270 u8 reportID, unsigned char *buf, size_t data_len, bool use_data)
261{ 271{
262 struct i2c_hid *ihid = i2c_get_clientdata(client); 272 struct i2c_hid *ihid = i2c_get_clientdata(client);
263 u8 *args = ihid->argsbuf; 273 u8 *args = ihid->argsbuf;
264 const struct i2c_hid_cmd * hidcmd = &hid_set_report_cmd; 274 const struct i2c_hid_cmd *hidcmd;
265 int ret; 275 int ret;
266 u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister); 276 u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
267 u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister); 277 u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
268 u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength); 278 u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
269 279
270 /* hidraw already checked that data_len < HID_MAX_BUFFER_SIZE */ 280 /* hid_hw_* already checked that data_len < HID_MAX_BUFFER_SIZE */
271 u16 size = 2 /* size */ + 281 u16 size = 2 /* size */ +
272 (reportID ? 1 : 0) /* reportID */ + 282 (reportID ? 1 : 0) /* reportID */ +
273 data_len /* buf */; 283 data_len /* buf */;
@@ -278,6 +288,9 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
278 288
279 i2c_hid_dbg(ihid, "%s\n", __func__); 289 i2c_hid_dbg(ihid, "%s\n", __func__);
280 290
291 if (!use_data && maxOutputLength == 0)
292 return -ENOSYS;
293
281 if (reportID >= 0x0F) { 294 if (reportID >= 0x0F) {
282 args[index++] = reportID; 295 args[index++] = reportID;
283 reportID = 0x0F; 296 reportID = 0x0F;
@@ -287,9 +300,10 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
287 * use the data register for feature reports or if the device does not 300 * use the data register for feature reports or if the device does not
288 * support the output register 301 * support the output register
289 */ 302 */
290 if (reportType == 0x03 || maxOutputLength == 0) { 303 if (use_data) {
291 args[index++] = dataRegister & 0xFF; 304 args[index++] = dataRegister & 0xFF;
292 args[index++] = dataRegister >> 8; 305 args[index++] = dataRegister >> 8;
306 hidcmd = &hid_set_report_cmd;
293 } else { 307 } else {
294 args[index++] = outputRegister & 0xFF; 308 args[index++] = outputRegister & 0xFF;
295 args[index++] = outputRegister >> 8; 309 args[index++] = outputRegister >> 8;
@@ -454,10 +468,18 @@ static void i2c_hid_init_reports(struct hid_device *hid)
454 return; 468 return;
455 } 469 }
456 470
471 /*
472 * The device must be powered on while we fetch initial reports
473 * from it.
474 */
475 pm_runtime_get_sync(&client->dev);
476
457 list_for_each_entry(report, 477 list_for_each_entry(report,
458 &hid->report_enum[HID_FEATURE_REPORT].report_list, list) 478 &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
459 i2c_hid_init_report(report, inbuf, ihid->bufsize); 479 i2c_hid_init_report(report, inbuf, ihid->bufsize);
460 480
481 pm_runtime_put(&client->dev);
482
461 kfree(inbuf); 483 kfree(inbuf);
462} 484}
463 485
@@ -550,7 +572,7 @@ static int i2c_hid_get_raw_report(struct hid_device *hid,
550} 572}
551 573
552static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf, 574static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
553 size_t count, unsigned char report_type) 575 size_t count, unsigned char report_type, bool use_data)
554{ 576{
555 struct i2c_client *client = hid->driver_data; 577 struct i2c_client *client = hid->driver_data;
556 int report_id = buf[0]; 578 int report_id = buf[0];
@@ -564,9 +586,9 @@ static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
564 count--; 586 count--;
565 } 587 }
566 588
567 ret = i2c_hid_set_report(client, 589 ret = i2c_hid_set_or_send_report(client,
568 report_type == HID_FEATURE_REPORT ? 0x03 : 0x02, 590 report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
569 report_id, buf, count); 591 report_id, buf, count, use_data);
570 592
571 if (report_id && ret >= 0) 593 if (report_id && ret >= 0)
572 ret++; /* add report_id to the number of transfered bytes */ 594 ret++; /* add report_id to the number of transfered bytes */
@@ -574,34 +596,27 @@ static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
574 return ret; 596 return ret;
575} 597}
576 598
577static void i2c_hid_request(struct hid_device *hid, struct hid_report *rep, 599static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf,
578 int reqtype) 600 size_t count)
579{ 601{
580 struct i2c_client *client = hid->driver_data; 602 return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT,
581 char *buf; 603 false);
582 int ret; 604}
583 int len = i2c_hid_get_report_length(rep) - 2;
584
585 buf = hid_alloc_report_buf(rep, GFP_KERNEL);
586 if (!buf)
587 return;
588 605
606static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
607 __u8 *buf, size_t len, unsigned char rtype,
608 int reqtype)
609{
589 switch (reqtype) { 610 switch (reqtype) {
590 case HID_REQ_GET_REPORT: 611 case HID_REQ_GET_REPORT:
591 ret = i2c_hid_get_raw_report(hid, rep->id, buf, len, rep->type); 612 return i2c_hid_get_raw_report(hid, reportnum, buf, len, rtype);
592 if (ret < 0)
593 dev_err(&client->dev, "%s: unable to get report: %d\n",
594 __func__, ret);
595 else
596 hid_input_report(hid, rep->type, buf, ret, 0);
597 break;
598 case HID_REQ_SET_REPORT: 613 case HID_REQ_SET_REPORT:
599 hid_output_report(rep, buf); 614 if (buf[0] != reportnum)
600 i2c_hid_output_raw_report(hid, buf, len, rep->type); 615 return -EINVAL;
601 break; 616 return i2c_hid_output_raw_report(hid, buf, len, rtype, true);
617 default:
618 return -EIO;
602 } 619 }
603
604 kfree(buf);
605} 620}
606 621
607static int i2c_hid_parse(struct hid_device *hid) 622static int i2c_hid_parse(struct hid_device *hid)
@@ -703,8 +718,8 @@ static int i2c_hid_open(struct hid_device *hid)
703 718
704 mutex_lock(&i2c_hid_open_mut); 719 mutex_lock(&i2c_hid_open_mut);
705 if (!hid->open++) { 720 if (!hid->open++) {
706 ret = i2c_hid_set_power(client, I2C_HID_PWR_ON); 721 ret = pm_runtime_get_sync(&client->dev);
707 if (ret) { 722 if (ret < 0) {
708 hid->open--; 723 hid->open--;
709 goto done; 724 goto done;
710 } 725 }
@@ -712,7 +727,7 @@ static int i2c_hid_open(struct hid_device *hid)
712 } 727 }
713done: 728done:
714 mutex_unlock(&i2c_hid_open_mut); 729 mutex_unlock(&i2c_hid_open_mut);
715 return ret; 730 return ret < 0 ? ret : 0;
716} 731}
717 732
718static void i2c_hid_close(struct hid_device *hid) 733static void i2c_hid_close(struct hid_device *hid)
@@ -729,7 +744,7 @@ static void i2c_hid_close(struct hid_device *hid)
729 clear_bit(I2C_HID_STARTED, &ihid->flags); 744 clear_bit(I2C_HID_STARTED, &ihid->flags);
730 745
731 /* Save some power */ 746 /* Save some power */
732 i2c_hid_set_power(client, I2C_HID_PWR_SLEEP); 747 pm_runtime_put(&client->dev);
733 } 748 }
734 mutex_unlock(&i2c_hid_open_mut); 749 mutex_unlock(&i2c_hid_open_mut);
735} 750}
@@ -738,19 +753,18 @@ static int i2c_hid_power(struct hid_device *hid, int lvl)
738{ 753{
739 struct i2c_client *client = hid->driver_data; 754 struct i2c_client *client = hid->driver_data;
740 struct i2c_hid *ihid = i2c_get_clientdata(client); 755 struct i2c_hid *ihid = i2c_get_clientdata(client);
741 int ret = 0;
742 756
743 i2c_hid_dbg(ihid, "%s lvl:%d\n", __func__, lvl); 757 i2c_hid_dbg(ihid, "%s lvl:%d\n", __func__, lvl);
744 758
745 switch (lvl) { 759 switch (lvl) {
746 case PM_HINT_FULLON: 760 case PM_HINT_FULLON:
747 ret = i2c_hid_set_power(client, I2C_HID_PWR_ON); 761 pm_runtime_get_sync(&client->dev);
748 break; 762 break;
749 case PM_HINT_NORMAL: 763 case PM_HINT_NORMAL:
750 ret = i2c_hid_set_power(client, I2C_HID_PWR_SLEEP); 764 pm_runtime_put(&client->dev);
751 break; 765 break;
752 } 766 }
753 return ret; 767 return 0;
754} 768}
755 769
756static struct hid_ll_driver i2c_hid_ll_driver = { 770static struct hid_ll_driver i2c_hid_ll_driver = {
@@ -760,7 +774,8 @@ static struct hid_ll_driver i2c_hid_ll_driver = {
760 .open = i2c_hid_open, 774 .open = i2c_hid_open,
761 .close = i2c_hid_close, 775 .close = i2c_hid_close,
762 .power = i2c_hid_power, 776 .power = i2c_hid_power,
763 .request = i2c_hid_request, 777 .output_report = i2c_hid_output_report,
778 .raw_request = i2c_hid_raw_request,
764}; 779};
765 780
766static int i2c_hid_init_irq(struct i2c_client *client) 781static int i2c_hid_init_irq(struct i2c_client *client)
@@ -973,13 +988,17 @@ static int i2c_hid_probe(struct i2c_client *client,
973 if (ret < 0) 988 if (ret < 0)
974 goto err; 989 goto err;
975 990
991 pm_runtime_get_noresume(&client->dev);
992 pm_runtime_set_active(&client->dev);
993 pm_runtime_enable(&client->dev);
994
976 ret = i2c_hid_fetch_hid_descriptor(ihid); 995 ret = i2c_hid_fetch_hid_descriptor(ihid);
977 if (ret < 0) 996 if (ret < 0)
978 goto err; 997 goto err_pm;
979 998
980 ret = i2c_hid_init_irq(client); 999 ret = i2c_hid_init_irq(client);
981 if (ret < 0) 1000 if (ret < 0)
982 goto err; 1001 goto err_pm;
983 1002
984 hid = hid_allocate_device(); 1003 hid = hid_allocate_device();
985 if (IS_ERR(hid)) { 1004 if (IS_ERR(hid)) {
@@ -991,8 +1010,6 @@ static int i2c_hid_probe(struct i2c_client *client,
991 1010
992 hid->driver_data = client; 1011 hid->driver_data = client;
993 hid->ll_driver = &i2c_hid_ll_driver; 1012 hid->ll_driver = &i2c_hid_ll_driver;
994 hid->hid_get_raw_report = i2c_hid_get_raw_report;
995 hid->hid_output_raw_report = i2c_hid_output_raw_report;
996 hid->dev.parent = &client->dev; 1013 hid->dev.parent = &client->dev;
997 ACPI_COMPANION_SET(&hid->dev, ACPI_COMPANION(&client->dev)); 1014 ACPI_COMPANION_SET(&hid->dev, ACPI_COMPANION(&client->dev));
998 hid->bus = BUS_I2C; 1015 hid->bus = BUS_I2C;
@@ -1010,6 +1027,7 @@ static int i2c_hid_probe(struct i2c_client *client,
1010 goto err_mem_free; 1027 goto err_mem_free;
1011 } 1028 }
1012 1029
1030 pm_runtime_put(&client->dev);
1013 return 0; 1031 return 0;
1014 1032
1015err_mem_free: 1033err_mem_free:
@@ -1018,6 +1036,10 @@ err_mem_free:
1018err_irq: 1036err_irq:
1019 free_irq(client->irq, ihid); 1037 free_irq(client->irq, ihid);
1020 1038
1039err_pm:
1040 pm_runtime_put_noidle(&client->dev);
1041 pm_runtime_disable(&client->dev);
1042
1021err: 1043err:
1022 i2c_hid_free_buffers(ihid); 1044 i2c_hid_free_buffers(ihid);
1023 kfree(ihid); 1045 kfree(ihid);
@@ -1029,6 +1051,11 @@ static int i2c_hid_remove(struct i2c_client *client)
1029 struct i2c_hid *ihid = i2c_get_clientdata(client); 1051 struct i2c_hid *ihid = i2c_get_clientdata(client);
1030 struct hid_device *hid; 1052 struct hid_device *hid;
1031 1053
1054 pm_runtime_get_sync(&client->dev);
1055 pm_runtime_disable(&client->dev);
1056 pm_runtime_set_suspended(&client->dev);
1057 pm_runtime_put_noidle(&client->dev);
1058
1032 hid = ihid->hid; 1059 hid = ihid->hid;
1033 hid_destroy_device(hid); 1060 hid_destroy_device(hid);
1034 1061
@@ -1074,7 +1101,31 @@ static int i2c_hid_resume(struct device *dev)
1074} 1101}
1075#endif 1102#endif
1076 1103
1077static SIMPLE_DEV_PM_OPS(i2c_hid_pm, i2c_hid_suspend, i2c_hid_resume); 1104#ifdef CONFIG_PM_RUNTIME
1105static int i2c_hid_runtime_suspend(struct device *dev)
1106{
1107 struct i2c_client *client = to_i2c_client(dev);
1108
1109 i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
1110 disable_irq(client->irq);
1111 return 0;
1112}
1113
1114static int i2c_hid_runtime_resume(struct device *dev)
1115{
1116 struct i2c_client *client = to_i2c_client(dev);
1117
1118 enable_irq(client->irq);
1119 i2c_hid_set_power(client, I2C_HID_PWR_ON);
1120 return 0;
1121}
1122#endif
1123
1124static const struct dev_pm_ops i2c_hid_pm = {
1125 SET_SYSTEM_SLEEP_PM_OPS(i2c_hid_suspend, i2c_hid_resume)
1126 SET_RUNTIME_PM_OPS(i2c_hid_runtime_suspend, i2c_hid_runtime_resume,
1127 NULL)
1128};
1078 1129
1079static const struct i2c_device_id i2c_hid_id_table[] = { 1130static const struct i2c_device_id i2c_hid_id_table[] = {
1080 { "hid", 0 }, 1131 { "hid", 0 },
diff --git a/drivers/hid/uhid.c b/drivers/hid/uhid.c
index cedc6da93c19..0d078c32db4f 100644
--- a/drivers/hid/uhid.c
+++ b/drivers/hid/uhid.c
@@ -244,12 +244,35 @@ static int uhid_hid_output_raw(struct hid_device *hid, __u8 *buf, size_t count,
244 return count; 244 return count;
245} 245}
246 246
247static int uhid_hid_output_report(struct hid_device *hid, __u8 *buf,
248 size_t count)
249{
250 return uhid_hid_output_raw(hid, buf, count, HID_OUTPUT_REPORT);
251}
252
253static int uhid_raw_request(struct hid_device *hid, unsigned char reportnum,
254 __u8 *buf, size_t len, unsigned char rtype,
255 int reqtype)
256{
257 switch (reqtype) {
258 case HID_REQ_GET_REPORT:
259 return uhid_hid_get_raw(hid, reportnum, buf, len, rtype);
260 case HID_REQ_SET_REPORT:
261 /* TODO: implement proper SET_REPORT functionality */
262 return -ENOSYS;
263 default:
264 return -EIO;
265 }
266}
267
247static struct hid_ll_driver uhid_hid_driver = { 268static struct hid_ll_driver uhid_hid_driver = {
248 .start = uhid_hid_start, 269 .start = uhid_hid_start,
249 .stop = uhid_hid_stop, 270 .stop = uhid_hid_stop,
250 .open = uhid_hid_open, 271 .open = uhid_hid_open,
251 .close = uhid_hid_close, 272 .close = uhid_hid_close,
252 .parse = uhid_hid_parse, 273 .parse = uhid_hid_parse,
274 .output_report = uhid_hid_output_report,
275 .raw_request = uhid_raw_request,
253}; 276};
254 277
255#ifdef CONFIG_COMPAT 278#ifdef CONFIG_COMPAT
@@ -377,8 +400,6 @@ static int uhid_dev_create(struct uhid_device *uhid,
377 hid->uniq[63] = 0; 400 hid->uniq[63] = 0;
378 401
379 hid->ll_driver = &uhid_hid_driver; 402 hid->ll_driver = &uhid_hid_driver;
380 hid->hid_get_raw_report = uhid_hid_get_raw;
381 hid->hid_output_raw_report = uhid_hid_output_raw;
382 hid->bus = ev->u.create.bus; 403 hid->bus = ev->u.create.bus;
383 hid->vendor = ev->u.create.vendor; 404 hid->vendor = ev->u.create.vendor;
384 hid->product = ev->u.create.product; 405 hid->product = ev->u.create.product;
@@ -407,6 +428,67 @@ err_free:
407 return ret; 428 return ret;
408} 429}
409 430
431static int uhid_dev_create2(struct uhid_device *uhid,
432 const struct uhid_event *ev)
433{
434 struct hid_device *hid;
435 int ret;
436
437 if (uhid->running)
438 return -EALREADY;
439
440 uhid->rd_size = ev->u.create2.rd_size;
441 if (uhid->rd_size <= 0 || uhid->rd_size > HID_MAX_DESCRIPTOR_SIZE)
442 return -EINVAL;
443
444 uhid->rd_data = kmalloc(uhid->rd_size, GFP_KERNEL);
445 if (!uhid->rd_data)
446 return -ENOMEM;
447
448 memcpy(uhid->rd_data, ev->u.create2.rd_data, uhid->rd_size);
449
450 hid = hid_allocate_device();
451 if (IS_ERR(hid)) {
452 ret = PTR_ERR(hid);
453 goto err_free;
454 }
455
456 strncpy(hid->name, ev->u.create2.name, 127);
457 hid->name[127] = 0;
458 strncpy(hid->phys, ev->u.create2.phys, 63);
459 hid->phys[63] = 0;
460 strncpy(hid->uniq, ev->u.create2.uniq, 63);
461 hid->uniq[63] = 0;
462
463 hid->ll_driver = &uhid_hid_driver;
464 hid->bus = ev->u.create2.bus;
465 hid->vendor = ev->u.create2.vendor;
466 hid->product = ev->u.create2.product;
467 hid->version = ev->u.create2.version;
468 hid->country = ev->u.create2.country;
469 hid->driver_data = uhid;
470 hid->dev.parent = uhid_misc.this_device;
471
472 uhid->hid = hid;
473 uhid->running = true;
474
475 ret = hid_add_device(hid);
476 if (ret) {
477 hid_err(hid, "Cannot register HID device\n");
478 goto err_hid;
479 }
480
481 return 0;
482
483err_hid:
484 hid_destroy_device(hid);
485 uhid->hid = NULL;
486 uhid->running = false;
487err_free:
488 kfree(uhid->rd_data);
489 return ret;
490}
491
410static int uhid_dev_destroy(struct uhid_device *uhid) 492static int uhid_dev_destroy(struct uhid_device *uhid)
411{ 493{
412 if (!uhid->running) 494 if (!uhid->running)
@@ -435,6 +517,17 @@ static int uhid_dev_input(struct uhid_device *uhid, struct uhid_event *ev)
435 return 0; 517 return 0;
436} 518}
437 519
520static int uhid_dev_input2(struct uhid_device *uhid, struct uhid_event *ev)
521{
522 if (!uhid->running)
523 return -EINVAL;
524
525 hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input2.data,
526 min_t(size_t, ev->u.input2.size, UHID_DATA_MAX), 0);
527
528 return 0;
529}
530
438static int uhid_dev_feature_answer(struct uhid_device *uhid, 531static int uhid_dev_feature_answer(struct uhid_device *uhid,
439 struct uhid_event *ev) 532 struct uhid_event *ev)
440{ 533{
@@ -571,12 +664,18 @@ static ssize_t uhid_char_write(struct file *file, const char __user *buffer,
571 case UHID_CREATE: 664 case UHID_CREATE:
572 ret = uhid_dev_create(uhid, &uhid->input_buf); 665 ret = uhid_dev_create(uhid, &uhid->input_buf);
573 break; 666 break;
667 case UHID_CREATE2:
668 ret = uhid_dev_create2(uhid, &uhid->input_buf);
669 break;
574 case UHID_DESTROY: 670 case UHID_DESTROY:
575 ret = uhid_dev_destroy(uhid); 671 ret = uhid_dev_destroy(uhid);
576 break; 672 break;
577 case UHID_INPUT: 673 case UHID_INPUT:
578 ret = uhid_dev_input(uhid, &uhid->input_buf); 674 ret = uhid_dev_input(uhid, &uhid->input_buf);
579 break; 675 break;
676 case UHID_INPUT2:
677 ret = uhid_dev_input2(uhid, &uhid->input_buf);
678 break;
580 case UHID_FEATURE_ANSWER: 679 case UHID_FEATURE_ANSWER:
581 ret = uhid_dev_feature_answer(uhid, &uhid->input_buf); 680 ret = uhid_dev_feature_answer(uhid, &uhid->input_buf);
582 break; 681 break;
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 44df131d390a..7b88f4cb9902 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -884,52 +884,66 @@ static int usbhid_get_raw_report(struct hid_device *hid,
884 return ret; 884 return ret;
885} 885}
886 886
887static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t count, 887static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum,
888 unsigned char report_type) 888 __u8 *buf, size_t count, unsigned char rtype)
889{ 889{
890 struct usbhid_device *usbhid = hid->driver_data; 890 struct usbhid_device *usbhid = hid->driver_data;
891 struct usb_device *dev = hid_to_usb_dev(hid); 891 struct usb_device *dev = hid_to_usb_dev(hid);
892 struct usb_interface *intf = usbhid->intf; 892 struct usb_interface *intf = usbhid->intf;
893 struct usb_host_interface *interface = intf->cur_altsetting; 893 struct usb_host_interface *interface = intf->cur_altsetting;
894 int ret; 894 int ret, skipped_report_id = 0;
895 895
896 if (usbhid->urbout && report_type != HID_FEATURE_REPORT) { 896 /* Byte 0 is the report number. Report data starts at byte 1.*/
897 int actual_length; 897 if ((rtype == HID_OUTPUT_REPORT) &&
898 int skipped_report_id = 0; 898 (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORT_ID))
899 buf[0] = 0;
900 else
901 buf[0] = reportnum;
902
903 if (buf[0] == 0x0) {
904 /* Don't send the Report ID */
905 buf++;
906 count--;
907 skipped_report_id = 1;
908 }
899 909
900 if (buf[0] == 0x0) { 910 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
901 /* Don't send the Report ID */
902 buf++;
903 count--;
904 skipped_report_id = 1;
905 }
906 ret = usb_interrupt_msg(dev, usbhid->urbout->pipe,
907 buf, count, &actual_length,
908 USB_CTRL_SET_TIMEOUT);
909 /* return the number of bytes transferred */
910 if (ret == 0) {
911 ret = actual_length;
912 /* count also the report id */
913 if (skipped_report_id)
914 ret++;
915 }
916 } else {
917 int skipped_report_id = 0;
918 int report_id = buf[0];
919 if (buf[0] == 0x0) {
920 /* Don't send the Report ID */
921 buf++;
922 count--;
923 skipped_report_id = 1;
924 }
925 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
926 HID_REQ_SET_REPORT, 911 HID_REQ_SET_REPORT,
927 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 912 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
928 ((report_type + 1) << 8) | report_id, 913 ((rtype + 1) << 8) | reportnum,
929 interface->desc.bInterfaceNumber, buf, count, 914 interface->desc.bInterfaceNumber, buf, count,
930 USB_CTRL_SET_TIMEOUT); 915 USB_CTRL_SET_TIMEOUT);
931 /* count also the report id, if this was a numbered report. */ 916 /* count also the report id, if this was a numbered report. */
932 if (ret > 0 && skipped_report_id) 917 if (ret > 0 && skipped_report_id)
918 ret++;
919
920 return ret;
921}
922
923static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count)
924{
925 struct usbhid_device *usbhid = hid->driver_data;
926 struct usb_device *dev = hid_to_usb_dev(hid);
927 int actual_length, skipped_report_id = 0, ret;
928
929 if (!usbhid->urbout)
930 return -ENOSYS;
931
932 if (buf[0] == 0x0) {
933 /* Don't send the Report ID */
934 buf++;
935 count--;
936 skipped_report_id = 1;
937 }
938
939 ret = usb_interrupt_msg(dev, usbhid->urbout->pipe,
940 buf, count, &actual_length,
941 USB_CTRL_SET_TIMEOUT);
942 /* return the number of bytes transferred */
943 if (ret == 0) {
944 ret = actual_length;
945 /* count also the report id */
946 if (skipped_report_id)
933 ret++; 947 ret++;
934 } 948 }
935 949
@@ -1200,6 +1214,20 @@ static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int r
1200 } 1214 }
1201} 1215}
1202 1216
1217static int usbhid_raw_request(struct hid_device *hid, unsigned char reportnum,
1218 __u8 *buf, size_t len, unsigned char rtype,
1219 int reqtype)
1220{
1221 switch (reqtype) {
1222 case HID_REQ_GET_REPORT:
1223 return usbhid_get_raw_report(hid, reportnum, buf, len, rtype);
1224 case HID_REQ_SET_REPORT:
1225 return usbhid_set_raw_report(hid, reportnum, buf, len, rtype);
1226 default:
1227 return -EIO;
1228 }
1229}
1230
1203static int usbhid_idle(struct hid_device *hid, int report, int idle, 1231static int usbhid_idle(struct hid_device *hid, int report, int idle,
1204 int reqtype) 1232 int reqtype)
1205{ 1233{
@@ -1223,6 +1251,8 @@ static struct hid_ll_driver usb_hid_driver = {
1223 .power = usbhid_power, 1251 .power = usbhid_power,
1224 .request = usbhid_request, 1252 .request = usbhid_request,
1225 .wait = usbhid_wait_io, 1253 .wait = usbhid_wait_io,
1254 .raw_request = usbhid_raw_request,
1255 .output_report = usbhid_output_report,
1226 .idle = usbhid_idle, 1256 .idle = usbhid_idle,
1227}; 1257};
1228 1258
@@ -1253,8 +1283,6 @@ static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *
1253 1283
1254 usb_set_intfdata(intf, hid); 1284 usb_set_intfdata(intf, hid);
1255 hid->ll_driver = &usb_hid_driver; 1285 hid->ll_driver = &usb_hid_driver;
1256 hid->hid_get_raw_report = usbhid_get_raw_report;
1257 hid->hid_output_raw_report = usbhid_output_raw_report;
1258 hid->ff_init = hid_pidff_init; 1286 hid->ff_init = hid_pidff_init;
1259#ifdef CONFIG_USB_HIDDEV 1287#ifdef CONFIG_USB_HIDDEV
1260 hid->hiddev_connect = hiddev_connect; 1288 hid->hiddev_connect = hiddev_connect;
diff --git a/drivers/iio/common/hid-sensors/hid-sensor-trigger.c b/drivers/iio/common/hid-sensors/hid-sensor-trigger.c
index 7dcf83998e6f..dbefbdaf7cd1 100644
--- a/drivers/iio/common/hid-sensors/hid-sensor-trigger.c
+++ b/drivers/iio/common/hid-sensors/hid-sensor-trigger.c
@@ -38,29 +38,40 @@ static int hid_sensor_data_rdy_trigger_set_state(struct iio_trigger *trig,
38 if (state) { 38 if (state) {
39 if (sensor_hub_device_open(st->hsdev)) 39 if (sensor_hub_device_open(st->hsdev))
40 return -EIO; 40 return -EIO;
41 state_val = 41 state_val = hid_sensor_get_usage_index(st->hsdev,
42 HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM; 42 st->power_state.report_id,
43 report_val = 43 st->power_state.index,
44 HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM; 44 HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM);
45 45 report_val = hid_sensor_get_usage_index(st->hsdev,
46 st->report_state.report_id,
47 st->report_state.index,
48 HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM);
46 } else { 49 } else {
47 sensor_hub_device_close(st->hsdev); 50 sensor_hub_device_close(st->hsdev);
48 state_val = 51 state_val = hid_sensor_get_usage_index(st->hsdev,
49 HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM; 52 st->power_state.report_id,
50 report_val = 53 st->power_state.index,
51 HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM; 54 HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM);
55 report_val = hid_sensor_get_usage_index(st->hsdev,
56 st->report_state.report_id,
57 st->report_state.index,
58 HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM);
52 } 59 }
53
54 st->data_ready = state; 60 st->data_ready = state;
55 state_val += st->power_state.logical_minimum; 61
56 report_val += st->report_state.logical_minimum; 62 if (state_val >= 0) {
57 sensor_hub_set_feature(st->hsdev, st->power_state.report_id, 63 state_val += st->power_state.logical_minimum;
64 sensor_hub_set_feature(st->hsdev, st->power_state.report_id,
58 st->power_state.index, 65 st->power_state.index,
59 (s32)state_val); 66 (s32)state_val);
67 }
60 68
61 sensor_hub_set_feature(st->hsdev, st->report_state.report_id, 69 if (report_val >= 0) {
70 report_val += st->report_state.logical_minimum;
71 sensor_hub_set_feature(st->hsdev, st->report_state.report_id,
62 st->report_state.index, 72 st->report_state.index,
63 (s32)report_val); 73 (s32)report_val);
74 }
64 75
65 return 0; 76 return 0;
66} 77}
diff --git a/include/linux/hid-sensor-hub.h b/include/linux/hid-sensor-hub.h
index b914ca3f57ba..b70cfd7ff29c 100644
--- a/include/linux/hid-sensor-hub.h
+++ b/include/linux/hid-sensor-hub.h
@@ -51,13 +51,15 @@ struct hid_sensor_hub_attribute_info {
51 * @hdev: Stores the hid instance. 51 * @hdev: Stores the hid instance.
52 * @vendor_id: Vendor id of hub device. 52 * @vendor_id: Vendor id of hub device.
53 * @product_id: Product id of hub device. 53 * @product_id: Product id of hub device.
54 * @ref_cnt: Number of MFD clients have opened this device 54 * @start_collection_index: Starting index for a phy type collection
55 * @end_collection_index: Last index for a phy type collection
55 */ 56 */
56struct hid_sensor_hub_device { 57struct hid_sensor_hub_device {
57 struct hid_device *hdev; 58 struct hid_device *hdev;
58 u32 vendor_id; 59 u32 vendor_id;
59 u32 product_id; 60 u32 product_id;
60 int ref_cnt; 61 int start_collection_index;
62 int end_collection_index;
61}; 63};
62 64
63/** 65/**
@@ -218,4 +220,7 @@ int hid_sensor_write_samp_freq_value(struct hid_sensor_common *st,
218int hid_sensor_read_samp_freq_value(struct hid_sensor_common *st, 220int hid_sensor_read_samp_freq_value(struct hid_sensor_common *st,
219 int *val1, int *val2); 221 int *val1, int *val2);
220 222
223int hid_sensor_get_usage_index(struct hid_sensor_hub_device *hsdev,
224 u32 report_id, int field_index, u32 usage_id);
225
221#endif 226#endif
diff --git a/include/linux/hid-sensor-ids.h b/include/linux/hid-sensor-ids.h
index 537161a997ab..14ead9e8eda8 100644
--- a/include/linux/hid-sensor-ids.h
+++ b/include/linux/hid-sensor-ids.h
@@ -140,15 +140,15 @@
140#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS 0x1000 140#define HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS 0x1000
141 141
142/* Power state enumerations */ 142/* Power state enumerations */
143#define HID_USAGE_SENSOR_PROP_POWER_STATE_UNDEFINED_ENUM 0x00 143#define HID_USAGE_SENSOR_PROP_POWER_STATE_UNDEFINED_ENUM 0x200850
144#define HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM 0x01 144#define HID_USAGE_SENSOR_PROP_POWER_STATE_D0_FULL_POWER_ENUM 0x200851
145#define HID_USAGE_SENSOR_PROP_POWER_STATE_D1_LOW_POWER_ENUM 0x02 145#define HID_USAGE_SENSOR_PROP_POWER_STATE_D1_LOW_POWER_ENUM 0x200852
146#define HID_USAGE_SENSOR_PROP_POWER_STATE_D2_STANDBY_WITH_WAKE_ENUM 0x03 146#define HID_USAGE_SENSOR_PROP_POWER_STATE_D2_STANDBY_WITH_WAKE_ENUM 0x200853
147#define HID_USAGE_SENSOR_PROP_POWER_STATE_D3_SLEEP_WITH_WAKE_ENUM 0x04 147#define HID_USAGE_SENSOR_PROP_POWER_STATE_D3_SLEEP_WITH_WAKE_ENUM 0x200854
148#define HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM 0x05 148#define HID_USAGE_SENSOR_PROP_POWER_STATE_D4_POWER_OFF_ENUM 0x200855
149 149
150/* Report State enumerations */ 150/* Report State enumerations */
151#define HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM 0x00 151#define HID_USAGE_SENSOR_PROP_REPORTING_STATE_NO_EVENTS_ENUM 0x200840
152#define HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM 0x01 152#define HID_USAGE_SENSOR_PROP_REPORTING_STATE_ALL_EVENTS_ENUM 0x200841
153 153
154#endif 154#endif
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 31b9d299ef6c..720e3a10608c 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -201,6 +201,7 @@ struct hid_item {
201#define HID_GD_VBRZ 0x00010045 201#define HID_GD_VBRZ 0x00010045
202#define HID_GD_VNO 0x00010046 202#define HID_GD_VNO 0x00010046
203#define HID_GD_FEATURE 0x00010047 203#define HID_GD_FEATURE 0x00010047
204#define HID_GD_SYSTEM_CONTROL 0x00010080
204#define HID_GD_UP 0x00010090 205#define HID_GD_UP 0x00010090
205#define HID_GD_DOWN 0x00010091 206#define HID_GD_DOWN 0x00010091
206#define HID_GD_RIGHT 0x00010092 207#define HID_GD_RIGHT 0x00010092
@@ -208,6 +209,8 @@ struct hid_item {
208 209
209#define HID_DC_BATTERYSTRENGTH 0x00060020 210#define HID_DC_BATTERYSTRENGTH 0x00060020
210 211
212#define HID_CP_CONSUMER_CONTROL 0x000c0001
213
211#define HID_DG_DIGITIZER 0x000d0001 214#define HID_DG_DIGITIZER 0x000d0001
212#define HID_DG_PEN 0x000d0002 215#define HID_DG_PEN 0x000d0002
213#define HID_DG_LIGHTPEN 0x000d0003 216#define HID_DG_LIGHTPEN 0x000d0003
@@ -287,6 +290,8 @@ struct hid_item {
287#define HID_QUIRK_NO_EMPTY_INPUT 0x00000100 290#define HID_QUIRK_NO_EMPTY_INPUT 0x00000100
288#define HID_QUIRK_NO_INIT_INPUT_REPORTS 0x00000200 291#define HID_QUIRK_NO_INIT_INPUT_REPORTS 0x00000200
289#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000 292#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000
293#define HID_QUIRK_SKIP_OUTPUT_REPORT_ID 0x00020000
294#define HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP 0x00040000
290#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000 295#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000
291#define HID_QUIRK_NO_INIT_REPORTS 0x20000000 296#define HID_QUIRK_NO_INIT_REPORTS 0x20000000
292#define HID_QUIRK_NO_IGNORE 0x40000000 297#define HID_QUIRK_NO_IGNORE 0x40000000
@@ -508,12 +513,6 @@ struct hid_device { /* device report descriptor */
508 struct hid_usage *, __s32); 513 struct hid_usage *, __s32);
509 void (*hiddev_report_event) (struct hid_device *, struct hid_report *); 514 void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
510 515
511 /* handler for raw input (Get_Report) data, used by hidraw */
512 int (*hid_get_raw_report) (struct hid_device *, unsigned char, __u8 *, size_t, unsigned char);
513
514 /* handler for raw output data, used by hidraw */
515 int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t, unsigned char);
516
517 /* debugging support via debugfs */ 516 /* debugging support via debugfs */
518 unsigned short debug; 517 unsigned short debug;
519 struct dentry *debug_dir; 518 struct dentry *debug_dir;
@@ -675,11 +674,12 @@ struct hid_driver {
675 * @stop: called on remove 674 * @stop: called on remove
676 * @open: called by input layer on open 675 * @open: called by input layer on open
677 * @close: called by input layer on close 676 * @close: called by input layer on close
678 * @hidinput_input_event: event input event (e.g. ff or leds)
679 * @parse: this method is called only once to parse the device data, 677 * @parse: this method is called only once to parse the device data,
680 * shouldn't allocate anything to not leak memory 678 * shouldn't allocate anything to not leak memory
681 * @request: send report request to device (e.g. feature report) 679 * @request: send report request to device (e.g. feature report)
682 * @wait: wait for buffered io to complete (send/recv reports) 680 * @wait: wait for buffered io to complete (send/recv reports)
681 * @raw_request: send raw report request to device (e.g. feature report)
682 * @output_report: send output report to device
683 * @idle: send idle request to device 683 * @idle: send idle request to device
684 */ 684 */
685struct hid_ll_driver { 685struct hid_ll_driver {
@@ -691,17 +691,20 @@ struct hid_ll_driver {
691 691
692 int (*power)(struct hid_device *hdev, int level); 692 int (*power)(struct hid_device *hdev, int level);
693 693
694 int (*hidinput_input_event) (struct input_dev *idev, unsigned int type,
695 unsigned int code, int value);
696
697 int (*parse)(struct hid_device *hdev); 694 int (*parse)(struct hid_device *hdev);
698 695
699 void (*request)(struct hid_device *hdev, 696 void (*request)(struct hid_device *hdev,
700 struct hid_report *report, int reqtype); 697 struct hid_report *report, int reqtype);
701 698
702 int (*wait)(struct hid_device *hdev); 699 int (*wait)(struct hid_device *hdev);
703 int (*idle)(struct hid_device *hdev, int report, int idle, int reqtype);
704 700
701 int (*raw_request) (struct hid_device *hdev, unsigned char reportnum,
702 __u8 *buf, size_t len, unsigned char rtype,
703 int reqtype);
704
705 int (*output_report) (struct hid_device *hdev, __u8 *buf, size_t len);
706
707 int (*idle)(struct hid_device *hdev, int report, int idle, int reqtype);
705}; 708};
706 709
707#define PM_HINT_FULLON 1<<5 710#define PM_HINT_FULLON 1<<5
@@ -752,6 +755,7 @@ struct hid_field *hidinput_get_led_field(struct hid_device *hid);
752unsigned int hidinput_count_leds(struct hid_device *hid); 755unsigned int hidinput_count_leds(struct hid_device *hid);
753__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code); 756__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code);
754void hid_output_report(struct hid_report *report, __u8 *data); 757void hid_output_report(struct hid_report *report, __u8 *data);
758void __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
755u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags); 759u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags);
756struct hid_device *hid_allocate_device(void); 760struct hid_device *hid_allocate_device(void);
757struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id); 761struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id);
@@ -964,7 +968,55 @@ static inline void hid_hw_request(struct hid_device *hdev,
964 struct hid_report *report, int reqtype) 968 struct hid_report *report, int reqtype)
965{ 969{
966 if (hdev->ll_driver->request) 970 if (hdev->ll_driver->request)
967 hdev->ll_driver->request(hdev, report, reqtype); 971 return hdev->ll_driver->request(hdev, report, reqtype);
972
973 __hid_request(hdev, report, reqtype);
974}
975
976/**
977 * hid_hw_raw_request - send report request to device
978 *
979 * @hdev: hid device
980 * @reportnum: report ID
981 * @buf: in/out data to transfer
982 * @len: length of buf
983 * @rtype: HID report type
984 * @reqtype: HID_REQ_GET_REPORT or HID_REQ_SET_REPORT
985 *
986 * @return: count of data transfered, negative if error
987 *
988 * Same behavior as hid_hw_request, but with raw buffers instead.
989 */
990static inline int hid_hw_raw_request(struct hid_device *hdev,
991 unsigned char reportnum, __u8 *buf,
992 size_t len, unsigned char rtype, int reqtype)
993{
994 if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
995 return -EINVAL;
996
997 return hdev->ll_driver->raw_request(hdev, reportnum, buf, len,
998 rtype, reqtype);
999}
1000
1001/**
1002 * hid_hw_output_report - send output report to device
1003 *
1004 * @hdev: hid device
1005 * @buf: raw data to transfer
1006 * @len: length of buf
1007 *
1008 * @return: count of data transfered, negative if error
1009 */
1010static inline int hid_hw_output_report(struct hid_device *hdev, __u8 *buf,
1011 size_t len)
1012{
1013 if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
1014 return -EINVAL;
1015
1016 if (hdev->ll_driver->output_report)
1017 return hdev->ll_driver->output_report(hdev, buf, len);
1018
1019 return -ENOSYS;
968} 1020}
969 1021
970/** 1022/**
diff --git a/include/uapi/linux/uhid.h b/include/uapi/linux/uhid.h
index 414b74be4da1..1e3b09c191cd 100644
--- a/include/uapi/linux/uhid.h
+++ b/include/uapi/linux/uhid.h
@@ -21,6 +21,7 @@
21 21
22#include <linux/input.h> 22#include <linux/input.h>
23#include <linux/types.h> 23#include <linux/types.h>
24#include <linux/hid.h>
24 25
25enum uhid_event_type { 26enum uhid_event_type {
26 UHID_CREATE, 27 UHID_CREATE,
@@ -34,6 +35,8 @@ enum uhid_event_type {
34 UHID_INPUT, 35 UHID_INPUT,
35 UHID_FEATURE, 36 UHID_FEATURE,
36 UHID_FEATURE_ANSWER, 37 UHID_FEATURE_ANSWER,
38 UHID_CREATE2,
39 UHID_INPUT2,
37}; 40};
38 41
39struct uhid_create_req { 42struct uhid_create_req {
@@ -50,6 +53,19 @@ struct uhid_create_req {
50 __u32 country; 53 __u32 country;
51} __attribute__((__packed__)); 54} __attribute__((__packed__));
52 55
56struct uhid_create2_req {
57 __u8 name[128];
58 __u8 phys[64];
59 __u8 uniq[64];
60 __u16 rd_size;
61 __u16 bus;
62 __u32 vendor;
63 __u32 product;
64 __u32 version;
65 __u32 country;
66 __u8 rd_data[HID_MAX_DESCRIPTOR_SIZE];
67} __attribute__((__packed__));
68
53#define UHID_DATA_MAX 4096 69#define UHID_DATA_MAX 4096
54 70
55enum uhid_report_type { 71enum uhid_report_type {
@@ -63,6 +79,11 @@ struct uhid_input_req {
63 __u16 size; 79 __u16 size;
64} __attribute__((__packed__)); 80} __attribute__((__packed__));
65 81
82struct uhid_input2_req {
83 __u16 size;
84 __u8 data[UHID_DATA_MAX];
85} __attribute__((__packed__));
86
66struct uhid_output_req { 87struct uhid_output_req {
67 __u8 data[UHID_DATA_MAX]; 88 __u8 data[UHID_DATA_MAX];
68 __u16 size; 89 __u16 size;
@@ -100,6 +121,8 @@ struct uhid_event {
100 struct uhid_output_ev_req output_ev; 121 struct uhid_output_ev_req output_ev;
101 struct uhid_feature_req feature; 122 struct uhid_feature_req feature;
102 struct uhid_feature_answer_req feature_answer; 123 struct uhid_feature_answer_req feature_answer;
124 struct uhid_create2_req create2;
125 struct uhid_input2_req input2;
103 } u; 126 } u;
104} __attribute__((__packed__)); 127} __attribute__((__packed__));
105 128
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index d9fb93451442..8181ea4bc2f2 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -223,51 +223,6 @@ static void hidp_input_report(struct hidp_session *session, struct sk_buff *skb)
223 input_sync(dev); 223 input_sync(dev);
224} 224}
225 225
226static int hidp_send_report(struct hidp_session *session, struct hid_report *report)
227{
228 unsigned char hdr;
229 u8 *buf;
230 int rsize, ret;
231
232 buf = hid_alloc_report_buf(report, GFP_ATOMIC);
233 if (!buf)
234 return -EIO;
235
236 hid_output_report(report, buf);
237 hdr = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
238
239 rsize = ((report->size - 1) >> 3) + 1 + (report->id > 0);
240 ret = hidp_send_intr_message(session, hdr, buf, rsize);
241
242 kfree(buf);
243 return ret;
244}
245
246static int hidp_hidinput_event(struct input_dev *dev, unsigned int type,
247 unsigned int code, int value)
248{
249 struct hid_device *hid = input_get_drvdata(dev);
250 struct hidp_session *session = hid->driver_data;
251 struct hid_field *field;
252 int offset;
253
254 BT_DBG("session %p type %d code %d value %d",
255 session, type, code, value);
256
257 if (type != EV_LED)
258 return -1;
259
260 offset = hidinput_find_field(hid, type, code, &field);
261 if (offset == -1) {
262 hid_warn(dev, "event field not found\n");
263 return -1;
264 }
265
266 hid_set_field(field, offset, value);
267
268 return hidp_send_report(session, field->report);
269}
270
271static int hidp_get_raw_report(struct hid_device *hid, 226static int hidp_get_raw_report(struct hid_device *hid,
272 unsigned char report_number, 227 unsigned char report_number,
273 unsigned char *data, size_t count, 228 unsigned char *data, size_t count,
@@ -353,17 +308,24 @@ err:
353 return ret; 308 return ret;
354} 309}
355 310
356static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count, 311static int hidp_set_raw_report(struct hid_device *hid, unsigned char reportnum,
357 unsigned char report_type) 312 unsigned char *data, size_t count,
313 unsigned char report_type)
358{ 314{
359 struct hidp_session *session = hid->driver_data; 315 struct hidp_session *session = hid->driver_data;
360 int ret; 316 int ret;
361 317
362 if (report_type == HID_OUTPUT_REPORT) { 318 switch (report_type) {
363 report_type = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT; 319 case HID_FEATURE_REPORT:
364 return hidp_send_intr_message(session, report_type, 320 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE;
365 data, count); 321 break;
366 } else if (report_type != HID_FEATURE_REPORT) { 322 case HID_INPUT_REPORT:
323 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_INPUT;
324 break;
325 case HID_OUTPUT_REPORT:
326 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_OUPUT;
327 break;
328 default:
367 return -EINVAL; 329 return -EINVAL;
368 } 330 }
369 331
@@ -371,8 +333,8 @@ static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, s
371 return -ERESTARTSYS; 333 return -ERESTARTSYS;
372 334
373 /* Set up our wait, and send the report request to the device. */ 335 /* Set up our wait, and send the report request to the device. */
336 data[0] = reportnum;
374 set_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags); 337 set_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
375 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE;
376 ret = hidp_send_ctrl_message(session, report_type, data, count); 338 ret = hidp_send_ctrl_message(session, report_type, data, count);
377 if (ret) 339 if (ret)
378 goto err; 340 goto err;
@@ -411,6 +373,29 @@ err:
411 return ret; 373 return ret;
412} 374}
413 375
376static int hidp_output_report(struct hid_device *hid, __u8 *data, size_t count)
377{
378 struct hidp_session *session = hid->driver_data;
379
380 return hidp_send_intr_message(session,
381 HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT,
382 data, count);
383}
384
385static int hidp_raw_request(struct hid_device *hid, unsigned char reportnum,
386 __u8 *buf, size_t len, unsigned char rtype,
387 int reqtype)
388{
389 switch (reqtype) {
390 case HID_REQ_GET_REPORT:
391 return hidp_get_raw_report(hid, reportnum, buf, len, rtype);
392 case HID_REQ_SET_REPORT:
393 return hidp_set_raw_report(hid, reportnum, buf, len, rtype);
394 default:
395 return -EIO;
396 }
397}
398
414static void hidp_idle_timeout(unsigned long arg) 399static void hidp_idle_timeout(unsigned long arg)
415{ 400{
416 struct hidp_session *session = (struct hidp_session *) arg; 401 struct hidp_session *session = (struct hidp_session *) arg;
@@ -739,7 +724,8 @@ static struct hid_ll_driver hidp_hid_driver = {
739 .stop = hidp_stop, 724 .stop = hidp_stop,
740 .open = hidp_open, 725 .open = hidp_open,
741 .close = hidp_close, 726 .close = hidp_close,
742 .hidinput_input_event = hidp_hidinput_event, 727 .raw_request = hidp_raw_request,
728 .output_report = hidp_output_report,
743}; 729};
744 730
745/* This function sets up the hid device. It does not add it 731/* This function sets up the hid device. It does not add it
@@ -781,15 +767,15 @@ static int hidp_setup_hid(struct hidp_session *session,
781 snprintf(hid->phys, sizeof(hid->phys), "%pMR", 767 snprintf(hid->phys, sizeof(hid->phys), "%pMR",
782 &l2cap_pi(session->ctrl_sock->sk)->chan->src); 768 &l2cap_pi(session->ctrl_sock->sk)->chan->src);
783 769
770 /* NOTE: Some device modules depend on the dst address being stored in
771 * uniq. Please be aware of this before making changes to this behavior.
772 */
784 snprintf(hid->uniq, sizeof(hid->uniq), "%pMR", 773 snprintf(hid->uniq, sizeof(hid->uniq), "%pMR",
785 &l2cap_pi(session->ctrl_sock->sk)->chan->dst); 774 &l2cap_pi(session->ctrl_sock->sk)->chan->dst);
786 775
787 hid->dev.parent = &session->conn->hcon->dev; 776 hid->dev.parent = &session->conn->hcon->dev;
788 hid->ll_driver = &hidp_hid_driver; 777 hid->ll_driver = &hidp_hid_driver;
789 778
790 hid->hid_get_raw_report = hidp_get_raw_report;
791 hid->hid_output_raw_report = hidp_output_raw_report;
792
793 /* True if device is blacklisted in drivers/hid/hid-core.c */ 779 /* True if device is blacklisted in drivers/hid/hid-core.c */
794 if (hid_ignore(hid)) { 780 if (hid_ignore(hid)) {
795 hid_destroy_device(session->hid); 781 hid_destroy_device(session->hid);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-21 23:42:15 -0500