aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/hid/hid-transport.txt317
-rw-r--r--drivers/hid/Kconfig19
-rw-r--r--drivers/hid/Makefile1
-rw-r--r--drivers/hid/hid-core.c51
-rw-r--r--drivers/hid/hid-cp2112.c1073
-rw-r--r--drivers/hid/hid-hyperv.c10
-rw-r--r--drivers/hid/hid-ids.h1
-rw-r--r--drivers/hid/hid-input.c18
-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-sony.c800
-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.c71
-rw-r--r--drivers/hid/uhid.c38
-rw-r--r--drivers/hid/usbhid/hid-core.c64
-rw-r--r--include/linux/hid.h65
-rw-r--r--net/bluetooth/hidp/core.c118
21 files changed, 2386 insertions, 444 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/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 f36b3524caf1..3736f6a121b7 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) },
@@ -2432,6 +2473,14 @@ int hid_add_device(struct hid_device *hdev)
2432 return -ENODEV; 2473 return -ENODEV;
2433 2474
2434 /* 2475 /*
2476 * Check for the mandatory transport channel.
2477 */
2478 if (!hdev->ll_driver->raw_request) {
2479 hid_err(hdev, "transport driver missing .raw_request()\n");
2480 return -EINVAL;
2481 }
2482
2483 /*
2435 * Read the device report descriptor once and use as template 2484 * Read the device report descriptor once and use as template
2436 * for the driver-specific modifications. 2485 * for the driver-specific modifications.
2437 */ 2486 */
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 00fd7452722f..5c34e658fd59 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -242,6 +242,7 @@
242#define USB_VENDOR_ID_CYGNAL 0x10c4 242#define USB_VENDOR_ID_CYGNAL 0x10c4
243#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X 0x818a 243#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X 0x818a
244#define USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH 0x81b9 244#define USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH 0x81b9
245#define USB_DEVICE_ID_CYGNAL_CP2112 0xea90
245 246
246#define USB_VENDOR_ID_CYPRESS 0x04b4 247#define USB_VENDOR_ID_CYPRESS 0x04b4
247#define USB_DEVICE_ID_CYPRESS_MOUSE 0x0001 248#define USB_DEVICE_ID_CYPRESS_MOUSE 0x0001
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index a713e6211419..333190f771f5 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;
@@ -1150,7 +1150,7 @@ static void hidinput_led_worker(struct work_struct *work)
1150 led_work); 1150 led_work);
1151 struct hid_field *field; 1151 struct hid_field *field;
1152 struct hid_report *report; 1152 struct hid_report *report;
1153 int len; 1153 int len, ret;
1154 __u8 *buf; 1154 __u8 *buf;
1155 1155
1156 field = hidinput_get_led_field(hid); 1156 field = hidinput_get_led_field(hid);
@@ -1184,7 +1184,10 @@ static void hidinput_led_worker(struct work_struct *work)
1184 1184
1185 hid_output_report(report, buf); 1185 hid_output_report(report, buf);
1186 /* synchronous output report */ 1186 /* synchronous output report */
1187 hid->hid_output_raw_report(hid, buf, len, HID_OUTPUT_REPORT); 1187 ret = hid_hw_output_report(hid, buf, len);
1188 if (ret == -ENOSYS)
1189 hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
1190 HID_REQ_SET_REPORT);
1188 kfree(buf); 1191 kfree(buf);
1189} 1192}
1190 1193
@@ -1263,10 +1266,7 @@ static struct hid_input *hidinput_allocate(struct hid_device *hid)
1263 } 1266 }
1264 1267
1265 input_set_drvdata(input_dev, hid); 1268 input_set_drvdata(input_dev, hid);
1266 if (hid->ll_driver->hidinput_input_event) 1269 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; 1270 input_dev->open = hidinput_open;
1271 input_dev->close = hidinput_close; 1271 input_dev->close = hidinput_close;
1272 input_dev->setkeycode = hidinput_setkeycode; 1272 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-sony.c b/drivers/hid/hid-sony.c
index 2f19b15f47f2..b3e82585309e 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] >> 4) & 0x01);
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; 1277
1278 __u8 buf[78] = { 0 };
956 1279
957 value[0] = 0x03; 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)
1347{
1348 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
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)
1006{ 1386{
1007 struct list_head *head, *list; 1387 static atomic_t power_id_seq = ATOMIC_INIT(0);
1008 struct hid_report *report; 1388 unsigned long power_id;
1009 struct hid_device *hdev = sc->hdev; 1389 struct hid_device *hdev = sc->hdev;
1390 int ret;
1010 1391
1011 list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list; 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;
1012 1409
1013 list_for_each(head, list) { 1410 ret = power_supply_register(&hdev->dev, &sc->battery);
1014 report = list_entry(head, struct hid_report, list); 1411 if (ret) {
1412 hid_err(hdev, "Unable to register battery device\n");
1413 goto err_free;
1414 }
1015 1415
1016 if (report->id == req_id) { 1416 power_supply_powers(&sc->battery, &hdev->dev);
1017 if (report->size < req_size) { 1417 return 0;
1018 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n", 1418
1019 req_id, report->size, req_size); 1419err_free:
1020 return -EINVAL; 1420 kfree(sc->battery.name);
1021 } 1421 sc->battery.name = NULL;
1022 sc->output_report = report; 1422 return ret;
1023 return 0; 1423}
1424
1425static void sony_battery_remove(struct sony_sc *sc)
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);
1482
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;
1028 1491
1029 return -EINVAL; 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,38 @@ 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)
1076 ret = sixaxis_set_operational_bt(hdev); 1635 ret = sixaxis_set_operational_bt(hdev);
1077 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) { 1636 sc->worker_initialized = 1;
1078 /* Report 5 (31 bytes) is used to send data to the controller via USB */ 1637 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1079 ret = sony_set_output_report(sc, 0x05, 248); 1638 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1639 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1640 ret = dualshock4_set_operational_bt(hdev);
1641 if (ret < 0) {
1642 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1643 goto err_stop;
1644 }
1645 }
1646 /*
1647 * The Dualshock 4 touchpad supports 2 touches and has a
1648 * resolution of 1920x940.
1649 */
1650 ret = sony_register_touchpad(sc, 2, 1920, 940);
1080 if (ret < 0) 1651 if (ret < 0)
1081 goto err_stop; 1652 goto err_stop;
1082 1653
@@ -1089,6 +1660,10 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1089 if (ret < 0) 1660 if (ret < 0)
1090 goto err_stop; 1661 goto err_stop;
1091 1662
1663 ret = sony_check_add(sc);
1664 if (ret < 0)
1665 goto err_stop;
1666
1092 if (sc->quirks & SONY_LED_SUPPORT) { 1667 if (sc->quirks & SONY_LED_SUPPORT) {
1093 ret = sony_leds_init(hdev); 1668 ret = sony_leds_init(hdev);
1094 if (ret < 0) 1669 if (ret < 0)
@@ -1099,12 +1674,36 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1099 ret = sony_init_ff(hdev); 1674 ret = sony_init_ff(hdev);
1100 if (ret < 0) 1675 if (ret < 0)
1101 goto err_stop; 1676 goto err_stop;
1677 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1678 ret = sony_battery_probe(sc);
1679 if (ret < 0)
1680 goto err_stop;
1681
1682 /* Open the device to receive reports with battery info */
1683 ret = hid_hw_open(hdev);
1684 if (ret < 0) {
1685 hid_err(hdev, "hw open failed\n");
1686 goto err_stop;
1687 }
1688 }
1689
1690 if (sc->quirks & SONY_FF_SUPPORT) {
1691 ret = sony_init_ff(hdev);
1692 if (ret < 0)
1693 goto err_close;
1102 } 1694 }
1103 1695
1104 return 0; 1696 return 0;
1697err_close:
1698 hid_hw_close(hdev);
1105err_stop: 1699err_stop:
1106 if (sc->quirks & SONY_LED_SUPPORT) 1700 if (sc->quirks & SONY_LED_SUPPORT)
1107 sony_leds_remove(hdev); 1701 sony_leds_remove(hdev);
1702 if (sc->quirks & SONY_BATTERY_SUPPORT)
1703 sony_battery_remove(sc);
1704 if (sc->worker_initialized)
1705 cancel_work_sync(&sc->state_worker);
1706 sony_remove_dev_list(sc);
1108 hid_hw_stop(hdev); 1707 hid_hw_stop(hdev);
1109 return ret; 1708 return ret;
1110} 1709}
@@ -1118,6 +1717,15 @@ static void sony_remove(struct hid_device *hdev)
1118 1717
1119 if (sc->worker_initialized) 1718 if (sc->worker_initialized)
1120 cancel_work_sync(&sc->state_worker); 1719 cancel_work_sync(&sc->state_worker);
1720 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1721 hid_hw_close(hdev);
1722 sony_battery_remove(sc);
1723 }
1724
1725 if (sc->worker_initialized)
1726 cancel_work_sync(&sc->state_worker);
1727
1728 sony_remove_dev_list(sc);
1121 1729
1122 hid_hw_stop(hdev); 1730 hid_hw_stop(hdev);
1123} 1731}
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 c121990c6beb..8c52a07d5652 100644
--- a/drivers/hid/i2c-hid/i2c-hid.c
+++ b/drivers/hid/i2c-hid/i2c-hid.c
@@ -257,18 +257,27 @@ static int i2c_hid_get_report(struct i2c_client *client, u8 reportType,
257 return 0; 257 return 0;
258} 258}
259 259
260static int i2c_hid_set_report(struct i2c_client *client, u8 reportType, 260/**
261 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)
262{ 271{
263 struct i2c_hid *ihid = i2c_get_clientdata(client); 272 struct i2c_hid *ihid = i2c_get_clientdata(client);
264 u8 *args = ihid->argsbuf; 273 u8 *args = ihid->argsbuf;
265 const struct i2c_hid_cmd * hidcmd = &hid_set_report_cmd; 274 const struct i2c_hid_cmd *hidcmd;
266 int ret; 275 int ret;
267 u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister); 276 u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
268 u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister); 277 u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
269 u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength); 278 u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
270 279
271 /* hidraw already checked that data_len < HID_MAX_BUFFER_SIZE */ 280 /* hid_hw_* already checked that data_len < HID_MAX_BUFFER_SIZE */
272 u16 size = 2 /* size */ + 281 u16 size = 2 /* size */ +
273 (reportID ? 1 : 0) /* reportID */ + 282 (reportID ? 1 : 0) /* reportID */ +
274 data_len /* buf */; 283 data_len /* buf */;
@@ -279,6 +288,9 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
279 288
280 i2c_hid_dbg(ihid, "%s\n", __func__); 289 i2c_hid_dbg(ihid, "%s\n", __func__);
281 290
291 if (!use_data && maxOutputLength == 0)
292 return -ENOSYS;
293
282 if (reportID >= 0x0F) { 294 if (reportID >= 0x0F) {
283 args[index++] = reportID; 295 args[index++] = reportID;
284 reportID = 0x0F; 296 reportID = 0x0F;
@@ -288,9 +300,10 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
288 * 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
289 * support the output register 301 * support the output register
290 */ 302 */
291 if (reportType == 0x03 || maxOutputLength == 0) { 303 if (use_data) {
292 args[index++] = dataRegister & 0xFF; 304 args[index++] = dataRegister & 0xFF;
293 args[index++] = dataRegister >> 8; 305 args[index++] = dataRegister >> 8;
306 hidcmd = &hid_set_report_cmd;
294 } else { 307 } else {
295 args[index++] = outputRegister & 0xFF; 308 args[index++] = outputRegister & 0xFF;
296 args[index++] = outputRegister >> 8; 309 args[index++] = outputRegister >> 8;
@@ -559,7 +572,7 @@ static int i2c_hid_get_raw_report(struct hid_device *hid,
559} 572}
560 573
561static 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,
562 size_t count, unsigned char report_type) 575 size_t count, unsigned char report_type, bool use_data)
563{ 576{
564 struct i2c_client *client = hid->driver_data; 577 struct i2c_client *client = hid->driver_data;
565 int report_id = buf[0]; 578 int report_id = buf[0];
@@ -573,9 +586,9 @@ static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
573 count--; 586 count--;
574 } 587 }
575 588
576 ret = i2c_hid_set_report(client, 589 ret = i2c_hid_set_or_send_report(client,
577 report_type == HID_FEATURE_REPORT ? 0x03 : 0x02, 590 report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
578 report_id, buf, count); 591 report_id, buf, count, use_data);
579 592
580 if (report_id && ret >= 0) 593 if (report_id && ret >= 0)
581 ret++; /* add report_id to the number of transfered bytes */ 594 ret++; /* add report_id to the number of transfered bytes */
@@ -583,34 +596,27 @@ static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
583 return ret; 596 return ret;
584} 597}
585 598
586static void i2c_hid_request(struct hid_device *hid, struct hid_report *rep, 599static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf,
587 int reqtype) 600 size_t count)
588{ 601{
589 struct i2c_client *client = hid->driver_data; 602 return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT,
590 char *buf; 603 false);
591 int ret; 604}
592 int len = i2c_hid_get_report_length(rep) - 2;
593
594 buf = hid_alloc_report_buf(rep, GFP_KERNEL);
595 if (!buf)
596 return;
597 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{
598 switch (reqtype) { 610 switch (reqtype) {
599 case HID_REQ_GET_REPORT: 611 case HID_REQ_GET_REPORT:
600 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);
601 if (ret < 0)
602 dev_err(&client->dev, "%s: unable to get report: %d\n",
603 __func__, ret);
604 else
605 hid_input_report(hid, rep->type, buf, ret, 0);
606 break;
607 case HID_REQ_SET_REPORT: 613 case HID_REQ_SET_REPORT:
608 hid_output_report(rep, buf); 614 if (buf[0] != reportnum)
609 i2c_hid_output_raw_report(hid, buf, len, rep->type); 615 return -EINVAL;
610 break; 616 return i2c_hid_output_raw_report(hid, buf, len, rtype, true);
617 default:
618 return -EIO;
611 } 619 }
612
613 kfree(buf);
614} 620}
615 621
616static int i2c_hid_parse(struct hid_device *hid) 622static int i2c_hid_parse(struct hid_device *hid)
@@ -768,7 +774,8 @@ static struct hid_ll_driver i2c_hid_ll_driver = {
768 .open = i2c_hid_open, 774 .open = i2c_hid_open,
769 .close = i2c_hid_close, 775 .close = i2c_hid_close,
770 .power = i2c_hid_power, 776 .power = i2c_hid_power,
771 .request = i2c_hid_request, 777 .output_report = i2c_hid_output_report,
778 .raw_request = i2c_hid_raw_request,
772}; 779};
773 780
774static int i2c_hid_init_irq(struct i2c_client *client) 781static int i2c_hid_init_irq(struct i2c_client *client)
@@ -1017,8 +1024,6 @@ static int i2c_hid_probe(struct i2c_client *client,
1017 1024
1018 hid->driver_data = client; 1025 hid->driver_data = client;
1019 hid->ll_driver = &i2c_hid_ll_driver; 1026 hid->ll_driver = &i2c_hid_ll_driver;
1020 hid->hid_get_raw_report = i2c_hid_get_raw_report;
1021 hid->hid_output_raw_report = i2c_hid_output_raw_report;
1022 hid->dev.parent = &client->dev; 1027 hid->dev.parent = &client->dev;
1023 ACPI_COMPANION_SET(&hid->dev, ACPI_COMPANION(&client->dev)); 1028 ACPI_COMPANION_SET(&hid->dev, ACPI_COMPANION(&client->dev));
1024 hid->bus = BUS_I2C; 1029 hid->bus = BUS_I2C;
diff --git a/drivers/hid/uhid.c b/drivers/hid/uhid.c
index f5a2b1931143..7ed79be2686a 100644
--- a/drivers/hid/uhid.c
+++ b/drivers/hid/uhid.c
@@ -247,27 +247,22 @@ static int uhid_hid_output_raw(struct hid_device *hid, __u8 *buf, size_t count,
247static int uhid_hid_output_report(struct hid_device *hid, __u8 *buf, 247static int uhid_hid_output_report(struct hid_device *hid, __u8 *buf,
248 size_t count) 248 size_t count)
249{ 249{
250 struct uhid_device *uhid = hid->driver_data; 250 return uhid_hid_output_raw(hid, buf, count, HID_OUTPUT_REPORT);
251 unsigned long flags; 251}
252 struct uhid_event *ev;
253
254 if (count < 1 || count > UHID_DATA_MAX)
255 return -EINVAL;
256
257 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
258 if (!ev)
259 return -ENOMEM;
260
261 ev->type = UHID_OUTPUT;
262 ev->u.output.size = count;
263 ev->u.output.rtype = UHID_OUTPUT_REPORT;
264 memcpy(ev->u.output.data, buf, count);
265
266 spin_lock_irqsave(&uhid->qlock, flags);
267 uhid_queue(uhid, ev);
268 spin_unlock_irqrestore(&uhid->qlock, flags);
269 252
270 return count; 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 }
271} 266}
272 267
273static struct hid_ll_driver uhid_hid_driver = { 268static struct hid_ll_driver uhid_hid_driver = {
@@ -277,6 +272,7 @@ static struct hid_ll_driver uhid_hid_driver = {
277 .close = uhid_hid_close, 272 .close = uhid_hid_close,
278 .parse = uhid_hid_parse, 273 .parse = uhid_hid_parse,
279 .output_report = uhid_hid_output_report, 274 .output_report = uhid_hid_output_report,
275 .raw_request = uhid_raw_request,
280}; 276};
281 277
282#ifdef CONFIG_COMPAT 278#ifdef CONFIG_COMPAT
@@ -404,8 +400,6 @@ static int uhid_dev_create(struct uhid_device *uhid,
404 hid->uniq[63] = 0; 400 hid->uniq[63] = 0;
405 401
406 hid->ll_driver = &uhid_hid_driver; 402 hid->ll_driver = &uhid_hid_driver;
407 hid->hid_get_raw_report = uhid_hid_get_raw;
408 hid->hid_output_raw_report = uhid_hid_output_raw;
409 hid->bus = ev->u.create.bus; 403 hid->bus = ev->u.create.bus;
410 hid->vendor = ev->u.create.vendor; 404 hid->vendor = ev->u.create.vendor;
411 hid->product = ev->u.create.product; 405 hid->product = ev->u.create.product;
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index f8ca312bae1b..7b88f4cb9902 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -894,7 +894,12 @@ static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum,
894 int ret, skipped_report_id = 0; 894 int ret, skipped_report_id = 0;
895 895
896 /* Byte 0 is the report number. Report data starts at byte 1.*/ 896 /* Byte 0 is the report number. Report data starts at byte 1.*/
897 buf[0] = reportnum; 897 if ((rtype == HID_OUTPUT_REPORT) &&
898 (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORT_ID))
899 buf[0] = 0;
900 else
901 buf[0] = reportnum;
902
898 if (buf[0] == 0x0) { 903 if (buf[0] == 0x0) {
899 /* Don't send the Report ID */ 904 /* Don't send the Report ID */
900 buf++; 905 buf++;
@@ -915,59 +920,6 @@ static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum,
915 return ret; 920 return ret;
916} 921}
917 922
918
919static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t count,
920 unsigned char report_type)
921{
922 struct usbhid_device *usbhid = hid->driver_data;
923 struct usb_device *dev = hid_to_usb_dev(hid);
924 struct usb_interface *intf = usbhid->intf;
925 struct usb_host_interface *interface = intf->cur_altsetting;
926 int ret;
927
928 if (usbhid->urbout && report_type != HID_FEATURE_REPORT) {
929 int actual_length;
930 int skipped_report_id = 0;
931
932 if (buf[0] == 0x0) {
933 /* Don't send the Report ID */
934 buf++;
935 count--;
936 skipped_report_id = 1;
937 }
938 ret = usb_interrupt_msg(dev, usbhid->urbout->pipe,
939 buf, count, &actual_length,
940 USB_CTRL_SET_TIMEOUT);
941 /* return the number of bytes transferred */
942 if (ret == 0) {
943 ret = actual_length;
944 /* count also the report id */
945 if (skipped_report_id)
946 ret++;
947 }
948 } else {
949 int skipped_report_id = 0;
950 int report_id = buf[0];
951 if (buf[0] == 0x0) {
952 /* Don't send the Report ID */
953 buf++;
954 count--;
955 skipped_report_id = 1;
956 }
957 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
958 HID_REQ_SET_REPORT,
959 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
960 ((report_type + 1) << 8) | report_id,
961 interface->desc.bInterfaceNumber, buf, count,
962 USB_CTRL_SET_TIMEOUT);
963 /* count also the report id, if this was a numbered report. */
964 if (ret > 0 && skipped_report_id)
965 ret++;
966 }
967
968 return ret;
969}
970
971static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count) 923static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count)
972{ 924{
973 struct usbhid_device *usbhid = hid->driver_data; 925 struct usbhid_device *usbhid = hid->driver_data;
@@ -975,7 +927,7 @@ static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count)
975 int actual_length, skipped_report_id = 0, ret; 927 int actual_length, skipped_report_id = 0, ret;
976 928
977 if (!usbhid->urbout) 929 if (!usbhid->urbout)
978 return -EIO; 930 return -ENOSYS;
979 931
980 if (buf[0] == 0x0) { 932 if (buf[0] == 0x0) {
981 /* Don't send the Report ID */ 933 /* Don't send the Report ID */
@@ -1331,8 +1283,6 @@ static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *
1331 1283
1332 usb_set_intfdata(intf, hid); 1284 usb_set_intfdata(intf, hid);
1333 hid->ll_driver = &usb_hid_driver; 1285 hid->ll_driver = &usb_hid_driver;
1334 hid->hid_get_raw_report = usbhid_get_raw_report;
1335 hid->hid_output_raw_report = usbhid_output_raw_report;
1336 hid->ff_init = hid_pidff_init; 1286 hid->ff_init = hid_pidff_init;
1337#ifdef CONFIG_USB_HIDDEV 1287#ifdef CONFIG_USB_HIDDEV
1338 hid->hiddev_connect = hiddev_connect; 1288 hid->hiddev_connect = hiddev_connect;
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 003cc8e89831..01a90b8d53bb 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -287,6 +287,8 @@ struct hid_item {
287#define HID_QUIRK_NO_EMPTY_INPUT 0x00000100 287#define HID_QUIRK_NO_EMPTY_INPUT 0x00000100
288#define HID_QUIRK_NO_INIT_INPUT_REPORTS 0x00000200 288#define HID_QUIRK_NO_INIT_INPUT_REPORTS 0x00000200
289#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000 289#define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000
290#define HID_QUIRK_SKIP_OUTPUT_REPORT_ID 0x00020000
291#define HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP 0x00040000
290#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000 292#define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000
291#define HID_QUIRK_NO_INIT_REPORTS 0x20000000 293#define HID_QUIRK_NO_INIT_REPORTS 0x20000000
292#define HID_QUIRK_NO_IGNORE 0x40000000 294#define HID_QUIRK_NO_IGNORE 0x40000000
@@ -508,12 +510,6 @@ struct hid_device { /* device report descriptor */
508 struct hid_usage *, __s32); 510 struct hid_usage *, __s32);
509 void (*hiddev_report_event) (struct hid_device *, struct hid_report *); 511 void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
510 512
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 */ 513 /* debugging support via debugfs */
518 unsigned short debug; 514 unsigned short debug;
519 struct dentry *debug_dir; 515 struct dentry *debug_dir;
@@ -675,11 +671,12 @@ struct hid_driver {
675 * @stop: called on remove 671 * @stop: called on remove
676 * @open: called by input layer on open 672 * @open: called by input layer on open
677 * @close: called by input layer on close 673 * @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, 674 * @parse: this method is called only once to parse the device data,
680 * shouldn't allocate anything to not leak memory 675 * shouldn't allocate anything to not leak memory
681 * @request: send report request to device (e.g. feature report) 676 * @request: send report request to device (e.g. feature report)
682 * @wait: wait for buffered io to complete (send/recv reports) 677 * @wait: wait for buffered io to complete (send/recv reports)
678 * @raw_request: send raw report request to device (e.g. feature report)
679 * @output_report: send output report to device
683 * @idle: send idle request to device 680 * @idle: send idle request to device
684 */ 681 */
685struct hid_ll_driver { 682struct hid_ll_driver {
@@ -691,9 +688,6 @@ struct hid_ll_driver {
691 688
692 int (*power)(struct hid_device *hdev, int level); 689 int (*power)(struct hid_device *hdev, int level);
693 690
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); 691 int (*parse)(struct hid_device *hdev);
698 692
699 void (*request)(struct hid_device *hdev, 693 void (*request)(struct hid_device *hdev,
@@ -758,6 +752,7 @@ struct hid_field *hidinput_get_led_field(struct hid_device *hid);
758unsigned int hidinput_count_leds(struct hid_device *hid); 752unsigned int hidinput_count_leds(struct hid_device *hid);
759__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code); 753__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code);
760void hid_output_report(struct hid_report *report, __u8 *data); 754void hid_output_report(struct hid_report *report, __u8 *data);
755void __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
761u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags); 756u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags);
762struct hid_device *hid_allocate_device(void); 757struct hid_device *hid_allocate_device(void);
763struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id); 758struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id);
@@ -970,7 +965,55 @@ static inline void hid_hw_request(struct hid_device *hdev,
970 struct hid_report *report, int reqtype) 965 struct hid_report *report, int reqtype)
971{ 966{
972 if (hdev->ll_driver->request) 967 if (hdev->ll_driver->request)
973 hdev->ll_driver->request(hdev, report, reqtype); 968 return hdev->ll_driver->request(hdev, report, reqtype);
969
970 __hid_request(hdev, report, reqtype);
971}
972
973/**
974 * hid_hw_raw_request - send report request to device
975 *
976 * @hdev: hid device
977 * @reportnum: report ID
978 * @buf: in/out data to transfer
979 * @len: length of buf
980 * @rtype: HID report type
981 * @reqtype: HID_REQ_GET_REPORT or HID_REQ_SET_REPORT
982 *
983 * @return: count of data transfered, negative if error
984 *
985 * Same behavior as hid_hw_request, but with raw buffers instead.
986 */
987static inline int hid_hw_raw_request(struct hid_device *hdev,
988 unsigned char reportnum, __u8 *buf,
989 size_t len, unsigned char rtype, int reqtype)
990{
991 if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
992 return -EINVAL;
993
994 return hdev->ll_driver->raw_request(hdev, reportnum, buf, len,
995 rtype, reqtype);
996}
997
998/**
999 * hid_hw_output_report - send output report to device
1000 *
1001 * @hdev: hid device
1002 * @buf: raw data to transfer
1003 * @len: length of buf
1004 *
1005 * @return: count of data transfered, negative if error
1006 */
1007static inline int hid_hw_output_report(struct hid_device *hdev, __u8 *buf,
1008 size_t len)
1009{
1010 if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
1011 return -EINVAL;
1012
1013 if (hdev->ll_driver->output_report)
1014 return hdev->ll_driver->output_report(hdev, buf, len);
1015
1016 return -ENOSYS;
974} 1017}
975 1018
976/** 1019/**
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index 450a0b999614..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,
@@ -418,62 +373,13 @@ err:
418 return ret; 373 return ret;
419} 374}
420 375
421static int hidp_output_raw_report(struct hid_device *hid, unsigned char *data, size_t count, 376static int hidp_output_report(struct hid_device *hid, __u8 *data, size_t count)
422 unsigned char report_type)
423{ 377{
424 struct hidp_session *session = hid->driver_data; 378 struct hidp_session *session = hid->driver_data;
425 int ret;
426
427 if (report_type == HID_OUTPUT_REPORT) {
428 report_type = HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT;
429 return hidp_send_intr_message(session, report_type,
430 data, count);
431 } else if (report_type != HID_FEATURE_REPORT) {
432 return -EINVAL;
433 }
434
435 if (mutex_lock_interruptible(&session->report_mutex))
436 return -ERESTARTSYS;
437 379
438 /* Set up our wait, and send the report request to the device. */ 380 return hidp_send_intr_message(session,
439 set_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags); 381 HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT,
440 report_type = HIDP_TRANS_SET_REPORT | HIDP_DATA_RTYPE_FEATURE; 382 data, count);
441 ret = hidp_send_ctrl_message(session, report_type, data, count);
442 if (ret)
443 goto err;
444
445 /* Wait for the ACK from the device. */
446 while (test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags) &&
447 !atomic_read(&session->terminate)) {
448 int res;
449
450 res = wait_event_interruptible_timeout(session->report_queue,
451 !test_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags)
452 || atomic_read(&session->terminate),
453 10*HZ);
454 if (res == 0) {
455 /* timeout */
456 ret = -EIO;
457 goto err;
458 }
459 if (res < 0) {
460 /* signal */
461 ret = -ERESTARTSYS;
462 goto err;
463 }
464 }
465
466 if (!session->output_report_success) {
467 ret = -EIO;
468 goto err;
469 }
470
471 ret = count;
472
473err:
474 clear_bit(HIDP_WAITING_FOR_SEND_ACK, &session->flags);
475 mutex_unlock(&session->report_mutex);
476 return ret;
477} 383}
478 384
479static int hidp_raw_request(struct hid_device *hid, unsigned char reportnum, 385static int hidp_raw_request(struct hid_device *hid, unsigned char reportnum,
@@ -490,15 +396,6 @@ static int hidp_raw_request(struct hid_device *hid, unsigned char reportnum,
490 } 396 }
491} 397}
492 398
493static int hidp_output_report(struct hid_device *hid, __u8 *data, size_t count)
494{
495 struct hidp_session *session = hid->driver_data;
496
497 return hidp_send_intr_message(session,
498 HIDP_TRANS_DATA | HIDP_DATA_RTYPE_OUPUT,
499 data, count);
500}
501
502static void hidp_idle_timeout(unsigned long arg) 399static void hidp_idle_timeout(unsigned long arg)
503{ 400{
504 struct hidp_session *session = (struct hidp_session *) arg; 401 struct hidp_session *session = (struct hidp_session *) arg;
@@ -829,7 +726,6 @@ static struct hid_ll_driver hidp_hid_driver = {
829 .close = hidp_close, 726 .close = hidp_close,
830 .raw_request = hidp_raw_request, 727 .raw_request = hidp_raw_request,
831 .output_report = hidp_output_report, 728 .output_report = hidp_output_report,
832 .hidinput_input_event = hidp_hidinput_event,
833}; 729};
834 730
835/* 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
@@ -871,15 +767,15 @@ static int hidp_setup_hid(struct hidp_session *session,
871 snprintf(hid->phys, sizeof(hid->phys), "%pMR", 767 snprintf(hid->phys, sizeof(hid->phys), "%pMR",
872 &l2cap_pi(session->ctrl_sock->sk)->chan->src); 768 &l2cap_pi(session->ctrl_sock->sk)->chan->src);
873 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 */
874 snprintf(hid->uniq, sizeof(hid->uniq), "%pMR", 773 snprintf(hid->uniq, sizeof(hid->uniq), "%pMR",
875 &l2cap_pi(session->ctrl_sock->sk)->chan->dst); 774 &l2cap_pi(session->ctrl_sock->sk)->chan->dst);
876 775
877 hid->dev.parent = &session->conn->hcon->dev; 776 hid->dev.parent = &session->conn->hcon->dev;
878 hid->ll_driver = &hidp_hid_driver; 777 hid->ll_driver = &hidp_hid_driver;
879 778
880 hid->hid_get_raw_report = hidp_get_raw_report;
881 hid->hid_output_raw_report = hidp_output_raw_report;
882
883 /* True if device is blacklisted in drivers/hid/hid-core.c */ 779 /* True if device is blacklisted in drivers/hid/hid-core.c */
884 if (hid_ignore(hid)) { 780 if (hid_ignore(hid)) {
885 hid_destroy_device(session->hid); 781 hid_destroy_device(session->hid);
generated by cgit v1.2.2 (git 2.25.0) at 2026-04-28 06:41:34 -0400