]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/hid/hid-sony.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
HID: sony: Coding style cleanups in sixaxis_set_operational_usb()
[mirror_ubuntu-artful-kernel.git] / drivers / hid / hid-sony.c
1 /*
2 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
3 *
4 * Copyright (c) 1999 Andreas Gal
5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7 * Copyright (c) 2008 Jiri Slaby
8 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
11 * Copyright (c) 2014 Frank Praznik <frank.praznik@gmail.com>
12 */
13
14 /*
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the Free
17 * Software Foundation; either version 2 of the License, or (at your option)
18 * any later version.
19 */
20
21 /*
22 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
23 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
24 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
25 *
26 * There will be no PIN request from the device.
27 */
28
29 #include <linux/device.h>
30 #include <linux/hid.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/leds.h>
34 #include <linux/power_supply.h>
35 #include <linux/spinlock.h>
36 #include <linux/list.h>
37 #include <linux/idr.h>
38 #include <linux/input/mt.h>
39
40 #include "hid-ids.h"
41
42 #define VAIO_RDESC_CONSTANT BIT(0)
43 #define SIXAXIS_CONTROLLER_USB BIT(1)
44 #define SIXAXIS_CONTROLLER_BT BIT(2)
45 #define BUZZ_CONTROLLER BIT(3)
46 #define PS3REMOTE BIT(4)
47 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
48 #define DUALSHOCK4_CONTROLLER_BT BIT(6)
49
50 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
51 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
52 DUALSHOCK4_CONTROLLER_BT)
53 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
54 DUALSHOCK4_CONTROLLER)
55 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
56 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
57
58 #define MAX_LEDS 4
59
60 static __u8 sixaxis_rdesc[] = {
61 0x05, 0x01, /* Usage Page (Desktop), */
62 0x09, 0x04, /* Usage (Joystik), */
63 0xA1, 0x01, /* Collection (Application), */
64 0xA1, 0x02, /* Collection (Logical), */
65 0x85, 0x01, /* Report ID (1), */
66 0x75, 0x08, /* Report Size (8), */
67 0x95, 0x01, /* Report Count (1), */
68 0x15, 0x00, /* Logical Minimum (0), */
69 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
70 0x81, 0x03, /* Input (Constant, Variable), */
71 0x75, 0x01, /* Report Size (1), */
72 0x95, 0x13, /* Report Count (19), */
73 0x15, 0x00, /* Logical Minimum (0), */
74 0x25, 0x01, /* Logical Maximum (1), */
75 0x35, 0x00, /* Physical Minimum (0), */
76 0x45, 0x01, /* Physical Maximum (1), */
77 0x05, 0x09, /* Usage Page (Button), */
78 0x19, 0x01, /* Usage Minimum (01h), */
79 0x29, 0x13, /* Usage Maximum (13h), */
80 0x81, 0x02, /* Input (Variable), */
81 0x75, 0x01, /* Report Size (1), */
82 0x95, 0x0D, /* Report Count (13), */
83 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
84 0x81, 0x03, /* Input (Constant, Variable), */
85 0x15, 0x00, /* Logical Minimum (0), */
86 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
87 0x05, 0x01, /* Usage Page (Desktop), */
88 0x09, 0x01, /* Usage (Pointer), */
89 0xA1, 0x00, /* Collection (Physical), */
90 0x75, 0x08, /* Report Size (8), */
91 0x95, 0x04, /* Report Count (4), */
92 0x35, 0x00, /* Physical Minimum (0), */
93 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
94 0x09, 0x30, /* Usage (X), */
95 0x09, 0x31, /* Usage (Y), */
96 0x09, 0x32, /* Usage (Z), */
97 0x09, 0x35, /* Usage (Rz), */
98 0x81, 0x02, /* Input (Variable), */
99 0xC0, /* End Collection, */
100 0x05, 0x01, /* Usage Page (Desktop), */
101 0x95, 0x13, /* Report Count (19), */
102 0x09, 0x01, /* Usage (Pointer), */
103 0x81, 0x02, /* Input (Variable), */
104 0x95, 0x0C, /* Report Count (12), */
105 0x81, 0x01, /* Input (Constant), */
106 0x75, 0x10, /* Report Size (16), */
107 0x95, 0x04, /* Report Count (4), */
108 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */
109 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */
110 0x09, 0x01, /* Usage (Pointer), */
111 0x81, 0x02, /* Input (Variable), */
112 0xC0, /* End Collection, */
113 0xA1, 0x02, /* Collection (Logical), */
114 0x85, 0x02, /* Report ID (2), */
115 0x75, 0x08, /* Report Size (8), */
116 0x95, 0x30, /* Report Count (48), */
117 0x09, 0x01, /* Usage (Pointer), */
118 0xB1, 0x02, /* Feature (Variable), */
119 0xC0, /* End Collection, */
120 0xA1, 0x02, /* Collection (Logical), */
121 0x85, 0xEE, /* Report ID (238), */
122 0x75, 0x08, /* Report Size (8), */
123 0x95, 0x30, /* Report Count (48), */
124 0x09, 0x01, /* Usage (Pointer), */
125 0xB1, 0x02, /* Feature (Variable), */
126 0xC0, /* End Collection, */
127 0xA1, 0x02, /* Collection (Logical), */
128 0x85, 0xEF, /* Report ID (239), */
129 0x75, 0x08, /* Report Size (8), */
130 0x95, 0x30, /* Report Count (48), */
131 0x09, 0x01, /* Usage (Pointer), */
132 0xB1, 0x02, /* Feature (Variable), */
133 0xC0, /* End Collection, */
134 0xC0 /* End Collection */
135 };
136
137 /*
138 * The default descriptor doesn't provide mapping for the accelerometers
139 * or orientation sensors. This fixed descriptor maps the accelerometers
140 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
141 * to usage values 0x43, 0x44 and 0x45.
142 */
143 static u8 dualshock4_usb_rdesc[] = {
144 0x05, 0x01, /* Usage Page (Desktop), */
145 0x09, 0x05, /* Usage (Gamepad), */
146 0xA1, 0x01, /* Collection (Application), */
147 0x85, 0x01, /* Report ID (1), */
148 0x09, 0x30, /* Usage (X), */
149 0x09, 0x31, /* Usage (Y), */
150 0x09, 0x32, /* Usage (Z), */
151 0x09, 0x35, /* Usage (Rz), */
152 0x15, 0x00, /* Logical Minimum (0), */
153 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
154 0x75, 0x08, /* Report Size (8), */
155 0x95, 0x04, /* Report Count (4), */
156 0x81, 0x02, /* Input (Variable), */
157 0x09, 0x39, /* Usage (Hat Switch), */
158 0x15, 0x00, /* Logical Minimum (0), */
159 0x25, 0x07, /* Logical Maximum (7), */
160 0x35, 0x00, /* Physical Minimum (0), */
161 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
162 0x65, 0x14, /* Unit (Degrees), */
163 0x75, 0x04, /* Report Size (4), */
164 0x95, 0x01, /* Report Count (1), */
165 0x81, 0x42, /* Input (Variable, Null State), */
166 0x65, 0x00, /* Unit, */
167 0x05, 0x09, /* Usage Page (Button), */
168 0x19, 0x01, /* Usage Minimum (01h), */
169 0x29, 0x0E, /* Usage Maximum (0Eh), */
170 0x15, 0x00, /* Logical Minimum (0), */
171 0x25, 0x01, /* Logical Maximum (1), */
172 0x75, 0x01, /* Report Size (1), */
173 0x95, 0x0E, /* Report Count (14), */
174 0x81, 0x02, /* Input (Variable), */
175 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
176 0x09, 0x20, /* Usage (20h), */
177 0x75, 0x06, /* Report Size (6), */
178 0x95, 0x01, /* Report Count (1), */
179 0x15, 0x00, /* Logical Minimum (0), */
180 0x25, 0x3F, /* Logical Maximum (63), */
181 0x81, 0x02, /* Input (Variable), */
182 0x05, 0x01, /* Usage Page (Desktop), */
183 0x09, 0x33, /* Usage (Rx), */
184 0x09, 0x34, /* Usage (Ry), */
185 0x15, 0x00, /* Logical Minimum (0), */
186 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
187 0x75, 0x08, /* Report Size (8), */
188 0x95, 0x02, /* Report Count (2), */
189 0x81, 0x02, /* Input (Variable), */
190 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
191 0x09, 0x21, /* Usage (21h), */
192 0x95, 0x03, /* Report Count (3), */
193 0x81, 0x02, /* Input (Variable), */
194 0x05, 0x01, /* Usage Page (Desktop), */
195 0x19, 0x40, /* Usage Minimum (40h), */
196 0x29, 0x42, /* Usage Maximum (42h), */
197 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
198 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
199 0x75, 0x10, /* Report Size (16), */
200 0x95, 0x03, /* Report Count (3), */
201 0x81, 0x02, /* Input (Variable), */
202 0x19, 0x43, /* Usage Minimum (43h), */
203 0x29, 0x45, /* Usage Maximum (45h), */
204 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
205 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
206 0x95, 0x03, /* Report Count (3), */
207 0x81, 0x02, /* Input (Variable), */
208 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
209 0x09, 0x21, /* Usage (21h), */
210 0x15, 0x00, /* Logical Minimum (0), */
211 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
212 0x75, 0x08, /* Report Size (8), */
213 0x95, 0x27, /* Report Count (39), */
214 0x81, 0x02, /* Input (Variable), */
215 0x85, 0x05, /* Report ID (5), */
216 0x09, 0x22, /* Usage (22h), */
217 0x95, 0x1F, /* Report Count (31), */
218 0x91, 0x02, /* Output (Variable), */
219 0x85, 0x04, /* Report ID (4), */
220 0x09, 0x23, /* Usage (23h), */
221 0x95, 0x24, /* Report Count (36), */
222 0xB1, 0x02, /* Feature (Variable), */
223 0x85, 0x02, /* Report ID (2), */
224 0x09, 0x24, /* Usage (24h), */
225 0x95, 0x24, /* Report Count (36), */
226 0xB1, 0x02, /* Feature (Variable), */
227 0x85, 0x08, /* Report ID (8), */
228 0x09, 0x25, /* Usage (25h), */
229 0x95, 0x03, /* Report Count (3), */
230 0xB1, 0x02, /* Feature (Variable), */
231 0x85, 0x10, /* Report ID (16), */
232 0x09, 0x26, /* Usage (26h), */
233 0x95, 0x04, /* Report Count (4), */
234 0xB1, 0x02, /* Feature (Variable), */
235 0x85, 0x11, /* Report ID (17), */
236 0x09, 0x27, /* Usage (27h), */
237 0x95, 0x02, /* Report Count (2), */
238 0xB1, 0x02, /* Feature (Variable), */
239 0x85, 0x12, /* Report ID (18), */
240 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
241 0x09, 0x21, /* Usage (21h), */
242 0x95, 0x0F, /* Report Count (15), */
243 0xB1, 0x02, /* Feature (Variable), */
244 0x85, 0x13, /* Report ID (19), */
245 0x09, 0x22, /* Usage (22h), */
246 0x95, 0x16, /* Report Count (22), */
247 0xB1, 0x02, /* Feature (Variable), */
248 0x85, 0x14, /* Report ID (20), */
249 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
250 0x09, 0x20, /* Usage (20h), */
251 0x95, 0x10, /* Report Count (16), */
252 0xB1, 0x02, /* Feature (Variable), */
253 0x85, 0x15, /* Report ID (21), */
254 0x09, 0x21, /* Usage (21h), */
255 0x95, 0x2C, /* Report Count (44), */
256 0xB1, 0x02, /* Feature (Variable), */
257 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
258 0x85, 0x80, /* Report ID (128), */
259 0x09, 0x20, /* Usage (20h), */
260 0x95, 0x06, /* Report Count (6), */
261 0xB1, 0x02, /* Feature (Variable), */
262 0x85, 0x81, /* Report ID (129), */
263 0x09, 0x21, /* Usage (21h), */
264 0x95, 0x06, /* Report Count (6), */
265 0xB1, 0x02, /* Feature (Variable), */
266 0x85, 0x82, /* Report ID (130), */
267 0x09, 0x22, /* Usage (22h), */
268 0x95, 0x05, /* Report Count (5), */
269 0xB1, 0x02, /* Feature (Variable), */
270 0x85, 0x83, /* Report ID (131), */
271 0x09, 0x23, /* Usage (23h), */
272 0x95, 0x01, /* Report Count (1), */
273 0xB1, 0x02, /* Feature (Variable), */
274 0x85, 0x84, /* Report ID (132), */
275 0x09, 0x24, /* Usage (24h), */
276 0x95, 0x04, /* Report Count (4), */
277 0xB1, 0x02, /* Feature (Variable), */
278 0x85, 0x85, /* Report ID (133), */
279 0x09, 0x25, /* Usage (25h), */
280 0x95, 0x06, /* Report Count (6), */
281 0xB1, 0x02, /* Feature (Variable), */
282 0x85, 0x86, /* Report ID (134), */
283 0x09, 0x26, /* Usage (26h), */
284 0x95, 0x06, /* Report Count (6), */
285 0xB1, 0x02, /* Feature (Variable), */
286 0x85, 0x87, /* Report ID (135), */
287 0x09, 0x27, /* Usage (27h), */
288 0x95, 0x23, /* Report Count (35), */
289 0xB1, 0x02, /* Feature (Variable), */
290 0x85, 0x88, /* Report ID (136), */
291 0x09, 0x28, /* Usage (28h), */
292 0x95, 0x22, /* Report Count (34), */
293 0xB1, 0x02, /* Feature (Variable), */
294 0x85, 0x89, /* Report ID (137), */
295 0x09, 0x29, /* Usage (29h), */
296 0x95, 0x02, /* Report Count (2), */
297 0xB1, 0x02, /* Feature (Variable), */
298 0x85, 0x90, /* Report ID (144), */
299 0x09, 0x30, /* Usage (30h), */
300 0x95, 0x05, /* Report Count (5), */
301 0xB1, 0x02, /* Feature (Variable), */
302 0x85, 0x91, /* Report ID (145), */
303 0x09, 0x31, /* Usage (31h), */
304 0x95, 0x03, /* Report Count (3), */
305 0xB1, 0x02, /* Feature (Variable), */
306 0x85, 0x92, /* Report ID (146), */
307 0x09, 0x32, /* Usage (32h), */
308 0x95, 0x03, /* Report Count (3), */
309 0xB1, 0x02, /* Feature (Variable), */
310 0x85, 0x93, /* Report ID (147), */
311 0x09, 0x33, /* Usage (33h), */
312 0x95, 0x0C, /* Report Count (12), */
313 0xB1, 0x02, /* Feature (Variable), */
314 0x85, 0xA0, /* Report ID (160), */
315 0x09, 0x40, /* Usage (40h), */
316 0x95, 0x06, /* Report Count (6), */
317 0xB1, 0x02, /* Feature (Variable), */
318 0x85, 0xA1, /* Report ID (161), */
319 0x09, 0x41, /* Usage (41h), */
320 0x95, 0x01, /* Report Count (1), */
321 0xB1, 0x02, /* Feature (Variable), */
322 0x85, 0xA2, /* Report ID (162), */
323 0x09, 0x42, /* Usage (42h), */
324 0x95, 0x01, /* Report Count (1), */
325 0xB1, 0x02, /* Feature (Variable), */
326 0x85, 0xA3, /* Report ID (163), */
327 0x09, 0x43, /* Usage (43h), */
328 0x95, 0x30, /* Report Count (48), */
329 0xB1, 0x02, /* Feature (Variable), */
330 0x85, 0xA4, /* Report ID (164), */
331 0x09, 0x44, /* Usage (44h), */
332 0x95, 0x0D, /* Report Count (13), */
333 0xB1, 0x02, /* Feature (Variable), */
334 0x85, 0xA5, /* Report ID (165), */
335 0x09, 0x45, /* Usage (45h), */
336 0x95, 0x15, /* Report Count (21), */
337 0xB1, 0x02, /* Feature (Variable), */
338 0x85, 0xA6, /* Report ID (166), */
339 0x09, 0x46, /* Usage (46h), */
340 0x95, 0x15, /* Report Count (21), */
341 0xB1, 0x02, /* Feature (Variable), */
342 0x85, 0xF0, /* Report ID (240), */
343 0x09, 0x47, /* Usage (47h), */
344 0x95, 0x3F, /* Report Count (63), */
345 0xB1, 0x02, /* Feature (Variable), */
346 0x85, 0xF1, /* Report ID (241), */
347 0x09, 0x48, /* Usage (48h), */
348 0x95, 0x3F, /* Report Count (63), */
349 0xB1, 0x02, /* Feature (Variable), */
350 0x85, 0xF2, /* Report ID (242), */
351 0x09, 0x49, /* Usage (49h), */
352 0x95, 0x0F, /* Report Count (15), */
353 0xB1, 0x02, /* Feature (Variable), */
354 0x85, 0xA7, /* Report ID (167), */
355 0x09, 0x4A, /* Usage (4Ah), */
356 0x95, 0x01, /* Report Count (1), */
357 0xB1, 0x02, /* Feature (Variable), */
358 0x85, 0xA8, /* Report ID (168), */
359 0x09, 0x4B, /* Usage (4Bh), */
360 0x95, 0x01, /* Report Count (1), */
361 0xB1, 0x02, /* Feature (Variable), */
362 0x85, 0xA9, /* Report ID (169), */
363 0x09, 0x4C, /* Usage (4Ch), */
364 0x95, 0x08, /* Report Count (8), */
365 0xB1, 0x02, /* Feature (Variable), */
366 0x85, 0xAA, /* Report ID (170), */
367 0x09, 0x4E, /* Usage (4Eh), */
368 0x95, 0x01, /* Report Count (1), */
369 0xB1, 0x02, /* Feature (Variable), */
370 0x85, 0xAB, /* Report ID (171), */
371 0x09, 0x4F, /* Usage (4Fh), */
372 0x95, 0x39, /* Report Count (57), */
373 0xB1, 0x02, /* Feature (Variable), */
374 0x85, 0xAC, /* Report ID (172), */
375 0x09, 0x50, /* Usage (50h), */
376 0x95, 0x39, /* Report Count (57), */
377 0xB1, 0x02, /* Feature (Variable), */
378 0x85, 0xAD, /* Report ID (173), */
379 0x09, 0x51, /* Usage (51h), */
380 0x95, 0x0B, /* Report Count (11), */
381 0xB1, 0x02, /* Feature (Variable), */
382 0x85, 0xAE, /* Report ID (174), */
383 0x09, 0x52, /* Usage (52h), */
384 0x95, 0x01, /* Report Count (1), */
385 0xB1, 0x02, /* Feature (Variable), */
386 0x85, 0xAF, /* Report ID (175), */
387 0x09, 0x53, /* Usage (53h), */
388 0x95, 0x02, /* Report Count (2), */
389 0xB1, 0x02, /* Feature (Variable), */
390 0x85, 0xB0, /* Report ID (176), */
391 0x09, 0x54, /* Usage (54h), */
392 0x95, 0x3F, /* Report Count (63), */
393 0xB1, 0x02, /* Feature (Variable), */
394 0xC0 /* End Collection */
395 };
396
397 /*
398 * The default behavior of the Dualshock 4 is to send reports using report
399 * type 1 when running over Bluetooth. However, when feature report 2 is
400 * requested during the controller initialization it starts sending input
401 * reports in report 17. Since report 17 is undefined in the default HID
402 * descriptor the button and axis definitions must be moved to report 17 or
403 * the HID layer won't process the received input.
404 */
405 static u8 dualshock4_bt_rdesc[] = {
406 0x05, 0x01, /* Usage Page (Desktop), */
407 0x09, 0x05, /* Usage (Gamepad), */
408 0xA1, 0x01, /* Collection (Application), */
409 0x85, 0x01, /* Report ID (1), */
410 0x75, 0x08, /* Report Size (8), */
411 0x95, 0x0A, /* Report Count (9), */
412 0x81, 0x02, /* Input (Variable), */
413 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
414 0x85, 0x02, /* Report ID (2), */
415 0x09, 0x24, /* Usage (24h), */
416 0x95, 0x24, /* Report Count (36), */
417 0xB1, 0x02, /* Feature (Variable), */
418 0x85, 0xA3, /* Report ID (163), */
419 0x09, 0x25, /* Usage (25h), */
420 0x95, 0x30, /* Report Count (48), */
421 0xB1, 0x02, /* Feature (Variable), */
422 0x85, 0x05, /* Report ID (5), */
423 0x09, 0x26, /* Usage (26h), */
424 0x95, 0x28, /* Report Count (40), */
425 0xB1, 0x02, /* Feature (Variable), */
426 0x85, 0x06, /* Report ID (6), */
427 0x09, 0x27, /* Usage (27h), */
428 0x95, 0x34, /* Report Count (52), */
429 0xB1, 0x02, /* Feature (Variable), */
430 0x85, 0x07, /* Report ID (7), */
431 0x09, 0x28, /* Usage (28h), */
432 0x95, 0x30, /* Report Count (48), */
433 0xB1, 0x02, /* Feature (Variable), */
434 0x85, 0x08, /* Report ID (8), */
435 0x09, 0x29, /* Usage (29h), */
436 0x95, 0x2F, /* Report Count (47), */
437 0xB1, 0x02, /* Feature (Variable), */
438 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
439 0x85, 0x03, /* Report ID (3), */
440 0x09, 0x21, /* Usage (21h), */
441 0x95, 0x26, /* Report Count (38), */
442 0xB1, 0x02, /* Feature (Variable), */
443 0x85, 0x04, /* Report ID (4), */
444 0x09, 0x22, /* Usage (22h), */
445 0x95, 0x2E, /* Report Count (46), */
446 0xB1, 0x02, /* Feature (Variable), */
447 0x85, 0xF0, /* Report ID (240), */
448 0x09, 0x47, /* Usage (47h), */
449 0x95, 0x3F, /* Report Count (63), */
450 0xB1, 0x02, /* Feature (Variable), */
451 0x85, 0xF1, /* Report ID (241), */
452 0x09, 0x48, /* Usage (48h), */
453 0x95, 0x3F, /* Report Count (63), */
454 0xB1, 0x02, /* Feature (Variable), */
455 0x85, 0xF2, /* Report ID (242), */
456 0x09, 0x49, /* Usage (49h), */
457 0x95, 0x0F, /* Report Count (15), */
458 0xB1, 0x02, /* Feature (Variable), */
459 0x85, 0x11, /* Report ID (17), */
460 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
461 0x09, 0x20, /* Usage (20h), */
462 0x95, 0x02, /* Report Count (2), */
463 0x81, 0x02, /* Input (Variable), */
464 0x05, 0x01, /* Usage Page (Desktop), */
465 0x09, 0x30, /* Usage (X), */
466 0x09, 0x31, /* Usage (Y), */
467 0x09, 0x32, /* Usage (Z), */
468 0x09, 0x35, /* Usage (Rz), */
469 0x15, 0x00, /* Logical Minimum (0), */
470 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
471 0x75, 0x08, /* Report Size (8), */
472 0x95, 0x04, /* Report Count (4), */
473 0x81, 0x02, /* Input (Variable), */
474 0x09, 0x39, /* Usage (Hat Switch), */
475 0x15, 0x00, /* Logical Minimum (0), */
476 0x25, 0x07, /* Logical Maximum (7), */
477 0x75, 0x04, /* Report Size (4), */
478 0x95, 0x01, /* Report Count (1), */
479 0x81, 0x42, /* Input (Variable, Null State), */
480 0x05, 0x09, /* Usage Page (Button), */
481 0x19, 0x01, /* Usage Minimum (01h), */
482 0x29, 0x0E, /* Usage Maximum (0Eh), */
483 0x15, 0x00, /* Logical Minimum (0), */
484 0x25, 0x01, /* Logical Maximum (1), */
485 0x75, 0x01, /* Report Size (1), */
486 0x95, 0x0E, /* Report Count (14), */
487 0x81, 0x02, /* Input (Variable), */
488 0x75, 0x06, /* Report Size (6), */
489 0x95, 0x01, /* Report Count (1), */
490 0x81, 0x01, /* Input (Constant), */
491 0x05, 0x01, /* Usage Page (Desktop), */
492 0x09, 0x33, /* Usage (Rx), */
493 0x09, 0x34, /* Usage (Ry), */
494 0x15, 0x00, /* Logical Minimum (0), */
495 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
496 0x75, 0x08, /* Report Size (8), */
497 0x95, 0x02, /* Report Count (2), */
498 0x81, 0x02, /* Input (Variable), */
499 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
500 0x09, 0x20, /* Usage (20h), */
501 0x95, 0x03, /* Report Count (3), */
502 0x81, 0x02, /* Input (Variable), */
503 0x05, 0x01, /* Usage Page (Desktop), */
504 0x19, 0x40, /* Usage Minimum (40h), */
505 0x29, 0x42, /* Usage Maximum (42h), */
506 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
507 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
508 0x75, 0x10, /* Report Size (16), */
509 0x95, 0x03, /* Report Count (3), */
510 0x81, 0x02, /* Input (Variable), */
511 0x19, 0x43, /* Usage Minimum (43h), */
512 0x29, 0x45, /* Usage Maximum (45h), */
513 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
514 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
515 0x95, 0x03, /* Report Count (3), */
516 0x81, 0x02, /* Input (Variable), */
517 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
518 0x09, 0x20, /* Usage (20h), */
519 0x15, 0x00, /* Logical Minimum (0), */
520 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
521 0x75, 0x08, /* Report Size (8), */
522 0x95, 0x31, /* Report Count (51), */
523 0x81, 0x02, /* Input (Variable), */
524 0x09, 0x21, /* Usage (21h), */
525 0x75, 0x08, /* Report Size (8), */
526 0x95, 0x4D, /* Report Count (77), */
527 0x91, 0x02, /* Output (Variable), */
528 0x85, 0x12, /* Report ID (18), */
529 0x09, 0x22, /* Usage (22h), */
530 0x95, 0x8D, /* Report Count (141), */
531 0x81, 0x02, /* Input (Variable), */
532 0x09, 0x23, /* Usage (23h), */
533 0x91, 0x02, /* Output (Variable), */
534 0x85, 0x13, /* Report ID (19), */
535 0x09, 0x24, /* Usage (24h), */
536 0x95, 0xCD, /* Report Count (205), */
537 0x81, 0x02, /* Input (Variable), */
538 0x09, 0x25, /* Usage (25h), */
539 0x91, 0x02, /* Output (Variable), */
540 0x85, 0x14, /* Report ID (20), */
541 0x09, 0x26, /* Usage (26h), */
542 0x96, 0x0D, 0x01, /* Report Count (269), */
543 0x81, 0x02, /* Input (Variable), */
544 0x09, 0x27, /* Usage (27h), */
545 0x91, 0x02, /* Output (Variable), */
546 0x85, 0x15, /* Report ID (21), */
547 0x09, 0x28, /* Usage (28h), */
548 0x96, 0x4D, 0x01, /* Report Count (333), */
549 0x81, 0x02, /* Input (Variable), */
550 0x09, 0x29, /* Usage (29h), */
551 0x91, 0x02, /* Output (Variable), */
552 0x85, 0x16, /* Report ID (22), */
553 0x09, 0x2A, /* Usage (2Ah), */
554 0x96, 0x8D, 0x01, /* Report Count (397), */
555 0x81, 0x02, /* Input (Variable), */
556 0x09, 0x2B, /* Usage (2Bh), */
557 0x91, 0x02, /* Output (Variable), */
558 0x85, 0x17, /* Report ID (23), */
559 0x09, 0x2C, /* Usage (2Ch), */
560 0x96, 0xCD, 0x01, /* Report Count (461), */
561 0x81, 0x02, /* Input (Variable), */
562 0x09, 0x2D, /* Usage (2Dh), */
563 0x91, 0x02, /* Output (Variable), */
564 0x85, 0x18, /* Report ID (24), */
565 0x09, 0x2E, /* Usage (2Eh), */
566 0x96, 0x0D, 0x02, /* Report Count (525), */
567 0x81, 0x02, /* Input (Variable), */
568 0x09, 0x2F, /* Usage (2Fh), */
569 0x91, 0x02, /* Output (Variable), */
570 0x85, 0x19, /* Report ID (25), */
571 0x09, 0x30, /* Usage (30h), */
572 0x96, 0x22, 0x02, /* Report Count (546), */
573 0x81, 0x02, /* Input (Variable), */
574 0x09, 0x31, /* Usage (31h), */
575 0x91, 0x02, /* Output (Variable), */
576 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
577 0x85, 0x82, /* Report ID (130), */
578 0x09, 0x22, /* Usage (22h), */
579 0x95, 0x3F, /* Report Count (63), */
580 0xB1, 0x02, /* Feature (Variable), */
581 0x85, 0x83, /* Report ID (131), */
582 0x09, 0x23, /* Usage (23h), */
583 0xB1, 0x02, /* Feature (Variable), */
584 0x85, 0x84, /* Report ID (132), */
585 0x09, 0x24, /* Usage (24h), */
586 0xB1, 0x02, /* Feature (Variable), */
587 0x85, 0x90, /* Report ID (144), */
588 0x09, 0x30, /* Usage (30h), */
589 0xB1, 0x02, /* Feature (Variable), */
590 0x85, 0x91, /* Report ID (145), */
591 0x09, 0x31, /* Usage (31h), */
592 0xB1, 0x02, /* Feature (Variable), */
593 0x85, 0x92, /* Report ID (146), */
594 0x09, 0x32, /* Usage (32h), */
595 0xB1, 0x02, /* Feature (Variable), */
596 0x85, 0x93, /* Report ID (147), */
597 0x09, 0x33, /* Usage (33h), */
598 0xB1, 0x02, /* Feature (Variable), */
599 0x85, 0xA0, /* Report ID (160), */
600 0x09, 0x40, /* Usage (40h), */
601 0xB1, 0x02, /* Feature (Variable), */
602 0x85, 0xA4, /* Report ID (164), */
603 0x09, 0x44, /* Usage (44h), */
604 0xB1, 0x02, /* Feature (Variable), */
605 0xC0 /* End Collection */
606 };
607
608 static __u8 ps3remote_rdesc[] = {
609 0x05, 0x01, /* GUsagePage Generic Desktop */
610 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
611 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
612
613 /* Use collection 1 for joypad buttons */
614 0xA1, 0x02, /* MCollection Logical (interrelated data) */
615
616 /* Ignore the 1st byte, maybe it is used for a controller
617 * number but it's not needed for correct operation */
618 0x75, 0x08, /* GReportSize 0x08 [8] */
619 0x95, 0x01, /* GReportCount 0x01 [1] */
620 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
621
622 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
623 * buttons multiple keypresses are allowed */
624 0x05, 0x09, /* GUsagePage Button */
625 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
626 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
627 0x14, /* GLogicalMinimum [0] */
628 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
629 0x75, 0x01, /* GReportSize 0x01 [1] */
630 0x95, 0x18, /* GReportCount 0x18 [24] */
631 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
632
633 0xC0, /* MEndCollection */
634
635 /* Use collection 2 for remote control buttons */
636 0xA1, 0x02, /* MCollection Logical (interrelated data) */
637
638 /* 5th byte is used for remote control buttons */
639 0x05, 0x09, /* GUsagePage Button */
640 0x18, /* LUsageMinimum [No button pressed] */
641 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
642 0x14, /* GLogicalMinimum [0] */
643 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
644 0x75, 0x08, /* GReportSize 0x08 [8] */
645 0x95, 0x01, /* GReportCount 0x01 [1] */
646 0x80, /* MInput */
647
648 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
649 * 0xff and 11th is for press indication */
650 0x75, 0x08, /* GReportSize 0x08 [8] */
651 0x95, 0x06, /* GReportCount 0x06 [6] */
652 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
653
654 /* 12th byte is for battery strength */
655 0x05, 0x06, /* GUsagePage Generic Device Controls */
656 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
657 0x14, /* GLogicalMinimum [0] */
658 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
659 0x75, 0x08, /* GReportSize 0x08 [8] */
660 0x95, 0x01, /* GReportCount 0x01 [1] */
661 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
662
663 0xC0, /* MEndCollection */
664
665 0xC0 /* MEndCollection [Game Pad] */
666 };
667
668 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
669 [0x01] = KEY_SELECT,
670 [0x02] = BTN_THUMBL, /* L3 */
671 [0x03] = BTN_THUMBR, /* R3 */
672 [0x04] = BTN_START,
673 [0x05] = KEY_UP,
674 [0x06] = KEY_RIGHT,
675 [0x07] = KEY_DOWN,
676 [0x08] = KEY_LEFT,
677 [0x09] = BTN_TL2, /* L2 */
678 [0x0a] = BTN_TR2, /* R2 */
679 [0x0b] = BTN_TL, /* L1 */
680 [0x0c] = BTN_TR, /* R1 */
681 [0x0d] = KEY_OPTION, /* options/triangle */
682 [0x0e] = KEY_BACK, /* back/circle */
683 [0x0f] = BTN_0, /* cross */
684 [0x10] = KEY_SCREEN, /* view/square */
685 [0x11] = KEY_HOMEPAGE, /* PS button */
686 [0x14] = KEY_ENTER,
687 };
688 static const unsigned int ps3remote_keymap_remote_buttons[] = {
689 [0x00] = KEY_1,
690 [0x01] = KEY_2,
691 [0x02] = KEY_3,
692 [0x03] = KEY_4,
693 [0x04] = KEY_5,
694 [0x05] = KEY_6,
695 [0x06] = KEY_7,
696 [0x07] = KEY_8,
697 [0x08] = KEY_9,
698 [0x09] = KEY_0,
699 [0x0e] = KEY_ESC, /* return */
700 [0x0f] = KEY_CLEAR,
701 [0x16] = KEY_EJECTCD,
702 [0x1a] = KEY_MENU, /* top menu */
703 [0x28] = KEY_TIME,
704 [0x30] = KEY_PREVIOUS,
705 [0x31] = KEY_NEXT,
706 [0x32] = KEY_PLAY,
707 [0x33] = KEY_REWIND, /* scan back */
708 [0x34] = KEY_FORWARD, /* scan forward */
709 [0x38] = KEY_STOP,
710 [0x39] = KEY_PAUSE,
711 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
712 [0x60] = KEY_FRAMEBACK, /* slow/step back */
713 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
714 [0x63] = KEY_SUBTITLE,
715 [0x64] = KEY_AUDIO,
716 [0x65] = KEY_ANGLE,
717 [0x70] = KEY_INFO, /* display */
718 [0x80] = KEY_BLUE,
719 [0x81] = KEY_RED,
720 [0x82] = KEY_GREEN,
721 [0x83] = KEY_YELLOW,
722 };
723
724 static const unsigned int buzz_keymap[] = {
725 /*
726 * The controller has 4 remote buzzers, each with one LED and 5
727 * buttons.
728 *
729 * We use the mapping chosen by the controller, which is:
730 *
731 * Key Offset
732 * -------------------
733 * Buzz 1
734 * Blue 5
735 * Orange 4
736 * Green 3
737 * Yellow 2
738 *
739 * So, for example, the orange button on the third buzzer is mapped to
740 * BTN_TRIGGER_HAPPY14
741 */
742 [ 1] = BTN_TRIGGER_HAPPY1,
743 [ 2] = BTN_TRIGGER_HAPPY2,
744 [ 3] = BTN_TRIGGER_HAPPY3,
745 [ 4] = BTN_TRIGGER_HAPPY4,
746 [ 5] = BTN_TRIGGER_HAPPY5,
747 [ 6] = BTN_TRIGGER_HAPPY6,
748 [ 7] = BTN_TRIGGER_HAPPY7,
749 [ 8] = BTN_TRIGGER_HAPPY8,
750 [ 9] = BTN_TRIGGER_HAPPY9,
751 [10] = BTN_TRIGGER_HAPPY10,
752 [11] = BTN_TRIGGER_HAPPY11,
753 [12] = BTN_TRIGGER_HAPPY12,
754 [13] = BTN_TRIGGER_HAPPY13,
755 [14] = BTN_TRIGGER_HAPPY14,
756 [15] = BTN_TRIGGER_HAPPY15,
757 [16] = BTN_TRIGGER_HAPPY16,
758 [17] = BTN_TRIGGER_HAPPY17,
759 [18] = BTN_TRIGGER_HAPPY18,
760 [19] = BTN_TRIGGER_HAPPY19,
761 [20] = BTN_TRIGGER_HAPPY20,
762 };
763
764 static enum power_supply_property sony_battery_props[] = {
765 POWER_SUPPLY_PROP_PRESENT,
766 POWER_SUPPLY_PROP_CAPACITY,
767 POWER_SUPPLY_PROP_SCOPE,
768 POWER_SUPPLY_PROP_STATUS,
769 };
770
771 struct sixaxis_led {
772 __u8 time_enabled; /* the total time the led is active (0xff means forever) */
773 __u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
774 __u8 enabled;
775 __u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
776 __u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
777 } __packed;
778
779 struct sixaxis_rumble {
780 __u8 padding;
781 __u8 right_duration; /* Right motor duration (0xff means forever) */
782 __u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
783 __u8 left_duration; /* Left motor duration (0xff means forever) */
784 __u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
785 } __packed;
786
787 struct sixaxis_output_report {
788 __u8 report_id;
789 struct sixaxis_rumble rumble;
790 __u8 padding[4];
791 __u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
792 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
793 struct sixaxis_led _reserved; /* LED5, not actually soldered */
794 } __packed;
795
796 union sixaxis_output_report_01 {
797 struct sixaxis_output_report data;
798 __u8 buf[36];
799 };
800
801 #define DS4_REPORT_0x02_SIZE 37
802 #define DS4_REPORT_0x05_SIZE 32
803 #define DS4_REPORT_0x11_SIZE 78
804 #define DS4_REPORT_0x81_SIZE 7
805 #define SIXAXIS_REPORT_0xF2_SIZE 17
806 #define SIXAXIS_REPORT_0xF5_SIZE 8
807
808 static spinlock_t sony_dev_list_lock;
809 static LIST_HEAD(sony_device_list);
810 static DEFINE_IDA(sony_device_id_allocator);
811
812 struct sony_sc {
813 spinlock_t lock;
814 struct list_head list_node;
815 struct hid_device *hdev;
816 struct led_classdev *leds[MAX_LEDS];
817 unsigned long quirks;
818 struct work_struct state_worker;
819 struct power_supply battery;
820 int device_id;
821 __u8 *output_report_dmabuf;
822
823 #ifdef CONFIG_SONY_FF
824 __u8 left;
825 __u8 right;
826 #endif
827
828 __u8 mac_address[6];
829 __u8 worker_initialized;
830 __u8 cable_state;
831 __u8 battery_charging;
832 __u8 battery_capacity;
833 __u8 led_state[MAX_LEDS];
834 __u8 led_delay_on[MAX_LEDS];
835 __u8 led_delay_off[MAX_LEDS];
836 __u8 led_count;
837 };
838
839 static __u8 *sixaxis_fixup(struct hid_device *hdev, __u8 *rdesc,
840 unsigned int *rsize)
841 {
842 *rsize = sizeof(sixaxis_rdesc);
843 return sixaxis_rdesc;
844 }
845
846 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
847 unsigned int *rsize)
848 {
849 *rsize = sizeof(ps3remote_rdesc);
850 return ps3remote_rdesc;
851 }
852
853 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
854 struct hid_field *field, struct hid_usage *usage,
855 unsigned long **bit, int *max)
856 {
857 unsigned int key = usage->hid & HID_USAGE;
858
859 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
860 return -1;
861
862 switch (usage->collection_index) {
863 case 1:
864 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
865 return -1;
866
867 key = ps3remote_keymap_joypad_buttons[key];
868 if (!key)
869 return -1;
870 break;
871 case 2:
872 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
873 return -1;
874
875 key = ps3remote_keymap_remote_buttons[key];
876 if (!key)
877 return -1;
878 break;
879 default:
880 return -1;
881 }
882
883 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
884 return 1;
885 }
886
887 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
888 unsigned int *rsize)
889 {
890 struct sony_sc *sc = hid_get_drvdata(hdev);
891
892 /*
893 * Some Sony RF receivers wrongly declare the mouse pointer as a
894 * a constant non-data variable.
895 */
896 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
897 /* usage page: generic desktop controls */
898 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
899 /* usage: mouse */
900 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
901 /* input (usage page for x,y axes): constant, variable, relative */
902 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
903 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
904 /* input: data, variable, relative */
905 rdesc[55] = 0x06;
906 }
907
908 /*
909 * The default Dualshock 4 USB descriptor doesn't assign
910 * the gyroscope values to corresponding axes so we need a
911 * modified one.
912 */
913 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
914 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
915 rdesc = dualshock4_usb_rdesc;
916 *rsize = sizeof(dualshock4_usb_rdesc);
917 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
918 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
919 rdesc = dualshock4_bt_rdesc;
920 *rsize = sizeof(dualshock4_bt_rdesc);
921 }
922
923 if (sc->quirks & SIXAXIS_CONTROLLER)
924 return sixaxis_fixup(hdev, rdesc, rsize);
925
926 if (sc->quirks & PS3REMOTE)
927 return ps3remote_fixup(hdev, rdesc, rsize);
928
929 return rdesc;
930 }
931
932 static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
933 {
934 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
935 unsigned long flags;
936 __u8 cable_state, battery_capacity, battery_charging;
937
938 /*
939 * The sixaxis is charging if the battery value is 0xee
940 * and it is fully charged if the value is 0xef.
941 * It does not report the actual level while charging so it
942 * is set to 100% while charging is in progress.
943 */
944 if (rd[30] >= 0xee) {
945 battery_capacity = 100;
946 battery_charging = !(rd[30] & 0x01);
947 cable_state = 1;
948 } else {
949 __u8 index = rd[30] <= 5 ? rd[30] : 5;
950 battery_capacity = sixaxis_battery_capacity[index];
951 battery_charging = 0;
952 cable_state = 0;
953 }
954
955 spin_lock_irqsave(&sc->lock, flags);
956 sc->cable_state = cable_state;
957 sc->battery_capacity = battery_capacity;
958 sc->battery_charging = battery_charging;
959 spin_unlock_irqrestore(&sc->lock, flags);
960 }
961
962 static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
963 {
964 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
965 struct hid_input, list);
966 struct input_dev *input_dev = hidinput->input;
967 unsigned long flags;
968 int n, offset;
969 __u8 cable_state, battery_capacity, battery_charging;
970
971 /*
972 * Battery and touchpad data starts at byte 30 in the USB report and
973 * 32 in Bluetooth report.
974 */
975 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
976
977 /*
978 * The lower 4 bits of byte 30 contain the battery level
979 * and the 5th bit contains the USB cable state.
980 */
981 cable_state = (rd[offset] >> 4) & 0x01;
982 battery_capacity = rd[offset] & 0x0F;
983
984 /*
985 * When a USB power source is connected the battery level ranges from
986 * 0 to 10, and when running on battery power it ranges from 0 to 9.
987 * A battery level above 10 when plugged in means charge completed.
988 */
989 if (!cable_state || battery_capacity > 10)
990 battery_charging = 0;
991 else
992 battery_charging = 1;
993
994 if (!cable_state)
995 battery_capacity++;
996 if (battery_capacity > 10)
997 battery_capacity = 10;
998
999 battery_capacity *= 10;
1000
1001 spin_lock_irqsave(&sc->lock, flags);
1002 sc->cable_state = cable_state;
1003 sc->battery_capacity = battery_capacity;
1004 sc->battery_charging = battery_charging;
1005 spin_unlock_irqrestore(&sc->lock, flags);
1006
1007 offset += 5;
1008
1009 /*
1010 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
1011 * and 37 on Bluetooth.
1012 * The first 7 bits of the first byte is a counter and bit 8 is a touch
1013 * indicator that is 0 when pressed and 1 when not pressed.
1014 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1015 * The data for the second touch is in the same format and immediatly
1016 * follows the data for the first.
1017 */
1018 for (n = 0; n < 2; n++) {
1019 __u16 x, y;
1020
1021 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1022 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1023
1024 input_mt_slot(input_dev, n);
1025 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
1026 !(rd[offset] >> 7));
1027 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1028 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1029
1030 offset += 4;
1031 }
1032 }
1033
1034 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1035 __u8 *rd, int size)
1036 {
1037 struct sony_sc *sc = hid_get_drvdata(hdev);
1038
1039 /*
1040 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1041 * has to be BYTE_SWAPPED before passing up to joystick interface
1042 */
1043 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1044 swap(rd[41], rd[42]);
1045 swap(rd[43], rd[44]);
1046 swap(rd[45], rd[46]);
1047 swap(rd[47], rd[48]);
1048
1049 sixaxis_parse_report(sc, rd, size);
1050 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1051 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1052 && rd[0] == 0x11 && size == 78)) {
1053 dualshock4_parse_report(sc, rd, size);
1054 }
1055
1056 return 0;
1057 }
1058
1059 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1060 struct hid_field *field, struct hid_usage *usage,
1061 unsigned long **bit, int *max)
1062 {
1063 struct sony_sc *sc = hid_get_drvdata(hdev);
1064
1065 if (sc->quirks & BUZZ_CONTROLLER) {
1066 unsigned int key = usage->hid & HID_USAGE;
1067
1068 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1069 return -1;
1070
1071 switch (usage->collection_index) {
1072 case 1:
1073 if (key >= ARRAY_SIZE(buzz_keymap))
1074 return -1;
1075
1076 key = buzz_keymap[key];
1077 if (!key)
1078 return -1;
1079 break;
1080 default:
1081 return -1;
1082 }
1083
1084 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1085 return 1;
1086 }
1087
1088 if (sc->quirks & PS3REMOTE)
1089 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1090
1091 /* Let hid-core decide for the others */
1092 return 0;
1093 }
1094
1095 static int sony_register_touchpad(struct hid_input *hi, int touch_count,
1096 int w, int h)
1097 {
1098 struct input_dev *input_dev = hi->input;
1099 int ret;
1100
1101 ret = input_mt_init_slots(input_dev, touch_count, 0);
1102 if (ret < 0)
1103 return ret;
1104
1105 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1106 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1107
1108 return 0;
1109 }
1110
1111 static void sony_input_configured(struct hid_device *hdev,
1112 struct hid_input *hidinput)
1113 {
1114 struct sony_sc *sc = hid_get_drvdata(hdev);
1115
1116 /*
1117 * The Dualshock 4 touchpad supports 2 touches and has a
1118 * resolution of 1920x942 (44.86 dots/mm).
1119 */
1120 if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1121 if (sony_register_touchpad(hidinput, 2, 1920, 942) != 0)
1122 hid_err(sc->hdev,
1123 "Unable to initialize multi-touch slots\n");
1124 }
1125 }
1126
1127 /*
1128 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1129 * to "operational". Without this, the ps3 controller will not report any
1130 * events.
1131 */
1132 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1133 {
1134 const int buf_size =
1135 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1136 __u8 *buf;
1137 int ret;
1138
1139 buf = kmalloc(buf_size, GFP_KERNEL);
1140 if (!buf)
1141 return -ENOMEM;
1142
1143 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1144 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1145 if (ret < 0) {
1146 hid_err(hdev, "can't set operational mode: step 1\n");
1147 goto out;
1148 }
1149
1150 /*
1151 * Some compatible controllers like the Speedlink Strike FX and
1152 * Gasia need another query plus an USB interrupt to get operational.
1153 */
1154 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1155 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1156 if (ret < 0) {
1157 hid_err(hdev, "can't set operational mode: step 2\n");
1158 goto out;
1159 }
1160
1161 ret = hid_hw_output_report(hdev, buf, 1);
1162 if (ret < 0)
1163 hid_err(hdev, "can't set operational mode: step 3\n");
1164
1165 out:
1166 kfree(buf);
1167
1168 return ret;
1169 }
1170
1171 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1172 {
1173 static const __u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1174 __u8 *buf;
1175 int ret;
1176
1177 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1178 if (!buf)
1179 return -ENOMEM;
1180
1181 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1182 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1183
1184 kfree(buf);
1185
1186 return ret;
1187 }
1188
1189 /*
1190 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1191 * controller so that it sends full input reports of type 0x11.
1192 */
1193 static int dualshock4_set_operational_bt(struct hid_device *hdev)
1194 {
1195 __u8 *buf;
1196 int ret;
1197
1198 buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1199 if (!buf)
1200 return -ENOMEM;
1201
1202 ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
1203 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1204
1205 kfree(buf);
1206
1207 return ret;
1208 }
1209
1210 static void sixaxis_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1211 {
1212 static const __u8 sixaxis_leds[10][4] = {
1213 { 0x01, 0x00, 0x00, 0x00 },
1214 { 0x00, 0x01, 0x00, 0x00 },
1215 { 0x00, 0x00, 0x01, 0x00 },
1216 { 0x00, 0x00, 0x00, 0x01 },
1217 { 0x01, 0x00, 0x00, 0x01 },
1218 { 0x00, 0x01, 0x00, 0x01 },
1219 { 0x00, 0x00, 0x01, 0x01 },
1220 { 0x01, 0x00, 0x01, 0x01 },
1221 { 0x00, 0x01, 0x01, 0x01 },
1222 { 0x01, 0x01, 0x01, 0x01 }
1223 };
1224
1225 BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1226
1227 if (id < 0)
1228 return;
1229
1230 id %= 10;
1231 memcpy(values, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1232 }
1233
1234 static void dualshock4_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1235 {
1236 /* The first 4 color/index entries match what the PS4 assigns */
1237 static const __u8 color_code[7][3] = {
1238 /* Blue */ { 0x00, 0x00, 0x01 },
1239 /* Red */ { 0x01, 0x00, 0x00 },
1240 /* Green */ { 0x00, 0x01, 0x00 },
1241 /* Pink */ { 0x02, 0x00, 0x01 },
1242 /* Orange */ { 0x02, 0x01, 0x00 },
1243 /* Teal */ { 0x00, 0x01, 0x01 },
1244 /* White */ { 0x01, 0x01, 0x01 }
1245 };
1246
1247 BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1248
1249 if (id < 0)
1250 return;
1251
1252 id %= 7;
1253 memcpy(values, color_code[id], sizeof(color_code[id]));
1254 }
1255
1256 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1257 {
1258 struct list_head *report_list =
1259 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1260 struct hid_report *report = list_entry(report_list->next,
1261 struct hid_report, list);
1262 __s32 *value = report->field[0]->value;
1263
1264 value[0] = 0x00;
1265 value[1] = leds[0] ? 0xff : 0x00;
1266 value[2] = leds[1] ? 0xff : 0x00;
1267 value[3] = leds[2] ? 0xff : 0x00;
1268 value[4] = leds[3] ? 0xff : 0x00;
1269 value[5] = 0x00;
1270 value[6] = 0x00;
1271 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1272 }
1273
1274 static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count)
1275 {
1276 int n;
1277
1278 BUG_ON(count > MAX_LEDS);
1279
1280 if (sc->quirks & BUZZ_CONTROLLER && count == 4) {
1281 buzz_set_leds(sc->hdev, leds);
1282 } else {
1283 for (n = 0; n < count; n++)
1284 sc->led_state[n] = leds[n];
1285 schedule_work(&sc->state_worker);
1286 }
1287 }
1288
1289 static void sony_led_set_brightness(struct led_classdev *led,
1290 enum led_brightness value)
1291 {
1292 struct device *dev = led->dev->parent;
1293 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1294 struct sony_sc *drv_data;
1295
1296 int n;
1297 int force_update;
1298
1299 drv_data = hid_get_drvdata(hdev);
1300 if (!drv_data) {
1301 hid_err(hdev, "No device data\n");
1302 return;
1303 }
1304
1305 /*
1306 * The Sixaxis on USB will override any LED settings sent to it
1307 * and keep flashing all of the LEDs until the PS button is pressed.
1308 * Updates, even if redundant, must be always be sent to the
1309 * controller to avoid having to toggle the state of an LED just to
1310 * stop the flashing later on.
1311 */
1312 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1313
1314 for (n = 0; n < drv_data->led_count; n++) {
1315 if (led == drv_data->leds[n] && (force_update ||
1316 (value != drv_data->led_state[n] ||
1317 drv_data->led_delay_on[n] ||
1318 drv_data->led_delay_off[n]))) {
1319
1320 drv_data->led_state[n] = value;
1321
1322 /* Setting the brightness stops the blinking */
1323 drv_data->led_delay_on[n] = 0;
1324 drv_data->led_delay_off[n] = 0;
1325
1326 sony_set_leds(drv_data, drv_data->led_state,
1327 drv_data->led_count);
1328 break;
1329 }
1330 }
1331 }
1332
1333 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1334 {
1335 struct device *dev = led->dev->parent;
1336 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1337 struct sony_sc *drv_data;
1338
1339 int n;
1340
1341 drv_data = hid_get_drvdata(hdev);
1342 if (!drv_data) {
1343 hid_err(hdev, "No device data\n");
1344 return LED_OFF;
1345 }
1346
1347 for (n = 0; n < drv_data->led_count; n++) {
1348 if (led == drv_data->leds[n])
1349 return drv_data->led_state[n];
1350 }
1351
1352 return LED_OFF;
1353 }
1354
1355 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1356 unsigned long *delay_off)
1357 {
1358 struct device *dev = led->dev->parent;
1359 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1360 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1361 int n;
1362 __u8 new_on, new_off;
1363
1364 if (!drv_data) {
1365 hid_err(hdev, "No device data\n");
1366 return -EINVAL;
1367 }
1368
1369 /* Max delay is 255 deciseconds or 2550 milliseconds */
1370 if (*delay_on > 2550)
1371 *delay_on = 2550;
1372 if (*delay_off > 2550)
1373 *delay_off = 2550;
1374
1375 /* Blink at 1 Hz if both values are zero */
1376 if (!*delay_on && !*delay_off)
1377 *delay_on = *delay_off = 500;
1378
1379 new_on = *delay_on / 10;
1380 new_off = *delay_off / 10;
1381
1382 for (n = 0; n < drv_data->led_count; n++) {
1383 if (led == drv_data->leds[n])
1384 break;
1385 }
1386
1387 /* This LED is not registered on this device */
1388 if (n >= drv_data->led_count)
1389 return -EINVAL;
1390
1391 /* Don't schedule work if the values didn't change */
1392 if (new_on != drv_data->led_delay_on[n] ||
1393 new_off != drv_data->led_delay_off[n]) {
1394 drv_data->led_delay_on[n] = new_on;
1395 drv_data->led_delay_off[n] = new_off;
1396 schedule_work(&drv_data->state_worker);
1397 }
1398
1399 return 0;
1400 }
1401
1402 static void sony_leds_remove(struct sony_sc *sc)
1403 {
1404 struct led_classdev *led;
1405 int n;
1406
1407 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1408
1409 for (n = 0; n < sc->led_count; n++) {
1410 led = sc->leds[n];
1411 sc->leds[n] = NULL;
1412 if (!led)
1413 continue;
1414 led_classdev_unregister(led);
1415 kfree(led);
1416 }
1417
1418 sc->led_count = 0;
1419 }
1420
1421 static int sony_leds_init(struct sony_sc *sc)
1422 {
1423 struct hid_device *hdev = sc->hdev;
1424 int n, ret = 0;
1425 int use_ds4_names;
1426 struct led_classdev *led;
1427 size_t name_sz;
1428 char *name;
1429 size_t name_len;
1430 const char *name_fmt;
1431 static const char * const ds4_name_str[] = { "red", "green", "blue",
1432 "global" };
1433 __u8 initial_values[MAX_LEDS] = { 0 };
1434 __u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1435 __u8 use_hw_blink[MAX_LEDS] = { 0 };
1436
1437 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1438
1439 if (sc->quirks & BUZZ_CONTROLLER) {
1440 sc->led_count = 4;
1441 use_ds4_names = 0;
1442 name_len = strlen("::buzz#");
1443 name_fmt = "%s::buzz%d";
1444 /* Validate expected report characteristics. */
1445 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1446 return -ENODEV;
1447 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1448 dualshock4_set_leds_from_id(sc->device_id, initial_values);
1449 initial_values[3] = 1;
1450 sc->led_count = 4;
1451 memset(max_brightness, 255, 3);
1452 use_hw_blink[3] = 1;
1453 use_ds4_names = 1;
1454 name_len = 0;
1455 name_fmt = "%s:%s";
1456 } else {
1457 sixaxis_set_leds_from_id(sc->device_id, initial_values);
1458 sc->led_count = 4;
1459 memset(use_hw_blink, 1, 4);
1460 use_ds4_names = 0;
1461 name_len = strlen("::sony#");
1462 name_fmt = "%s::sony%d";
1463 }
1464
1465 /*
1466 * Clear LEDs as we have no way of reading their initial state. This is
1467 * only relevant if the driver is loaded after somebody actively set the
1468 * LEDs to on
1469 */
1470 sony_set_leds(sc, initial_values, sc->led_count);
1471
1472 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1473
1474 for (n = 0; n < sc->led_count; n++) {
1475
1476 if (use_ds4_names)
1477 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1478
1479 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1480 if (!led) {
1481 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1482 ret = -ENOMEM;
1483 goto error_leds;
1484 }
1485
1486 name = (void *)(&led[1]);
1487 if (use_ds4_names)
1488 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1489 ds4_name_str[n]);
1490 else
1491 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1492 led->name = name;
1493 led->brightness = initial_values[n];
1494 led->max_brightness = max_brightness[n];
1495 led->brightness_get = sony_led_get_brightness;
1496 led->brightness_set = sony_led_set_brightness;
1497
1498 if (use_hw_blink[n])
1499 led->blink_set = sony_led_blink_set;
1500
1501 sc->leds[n] = led;
1502
1503 ret = led_classdev_register(&hdev->dev, led);
1504 if (ret) {
1505 hid_err(hdev, "Failed to register LED %d\n", n);
1506 sc->leds[n] = NULL;
1507 kfree(led);
1508 goto error_leds;
1509 }
1510 }
1511
1512 return ret;
1513
1514 error_leds:
1515 sony_leds_remove(sc);
1516
1517 return ret;
1518 }
1519
1520 static void sixaxis_state_worker(struct work_struct *work)
1521 {
1522 static const union sixaxis_output_report_01 default_report = {
1523 .buf = {
1524 0x01,
1525 0x00, 0xff, 0x00, 0xff, 0x00,
1526 0x00, 0x00, 0x00, 0x00, 0x00,
1527 0xff, 0x27, 0x10, 0x00, 0x32,
1528 0xff, 0x27, 0x10, 0x00, 0x32,
1529 0xff, 0x27, 0x10, 0x00, 0x32,
1530 0xff, 0x27, 0x10, 0x00, 0x32,
1531 0x00, 0x00, 0x00, 0x00, 0x00
1532 }
1533 };
1534 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1535 struct sixaxis_output_report *report =
1536 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1537 int n;
1538
1539 /* Initialize the report with default values */
1540 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1541
1542 #ifdef CONFIG_SONY_FF
1543 report->rumble.right_motor_on = sc->right ? 1 : 0;
1544 report->rumble.left_motor_force = sc->left;
1545 #endif
1546
1547 report->leds_bitmap |= sc->led_state[0] << 1;
1548 report->leds_bitmap |= sc->led_state[1] << 2;
1549 report->leds_bitmap |= sc->led_state[2] << 3;
1550 report->leds_bitmap |= sc->led_state[3] << 4;
1551
1552 /* Set flag for all leds off, required for 3rd party INTEC controller */
1553 if ((report->leds_bitmap & 0x1E) == 0)
1554 report->leds_bitmap |= 0x20;
1555
1556 /*
1557 * The LEDs in the report are indexed in reverse order to their
1558 * corresponding light on the controller.
1559 * Index 0 = LED 4, index 1 = LED 3, etc...
1560 *
1561 * In the case of both delay values being zero (blinking disabled) the
1562 * default report values should be used or the controller LED will be
1563 * always off.
1564 */
1565 for (n = 0; n < 4; n++) {
1566 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1567 report->led[3 - n].duty_off = sc->led_delay_off[n];
1568 report->led[3 - n].duty_on = sc->led_delay_on[n];
1569 }
1570 }
1571
1572 hid_hw_raw_request(sc->hdev, report->report_id, (__u8 *)report,
1573 sizeof(struct sixaxis_output_report),
1574 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1575 }
1576
1577 static void dualshock4_state_worker(struct work_struct *work)
1578 {
1579 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1580 struct hid_device *hdev = sc->hdev;
1581 __u8 *buf = sc->output_report_dmabuf;
1582 int offset;
1583
1584 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1585 memset(buf, 0, DS4_REPORT_0x05_SIZE);
1586 buf[0] = 0x05;
1587 buf[1] = 0xFF;
1588 offset = 4;
1589 } else {
1590 memset(buf, 0, DS4_REPORT_0x11_SIZE);
1591 buf[0] = 0x11;
1592 buf[1] = 0xB0;
1593 buf[3] = 0x0F;
1594 offset = 6;
1595 }
1596
1597 #ifdef CONFIG_SONY_FF
1598 buf[offset++] = sc->right;
1599 buf[offset++] = sc->left;
1600 #else
1601 offset += 2;
1602 #endif
1603
1604 /* LED 3 is the global control */
1605 if (sc->led_state[3]) {
1606 buf[offset++] = sc->led_state[0];
1607 buf[offset++] = sc->led_state[1];
1608 buf[offset++] = sc->led_state[2];
1609 } else {
1610 offset += 3;
1611 }
1612
1613 /* If both delay values are zero the DualShock 4 disables blinking. */
1614 buf[offset++] = sc->led_delay_on[3];
1615 buf[offset++] = sc->led_delay_off[3];
1616
1617 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1618 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
1619 else
1620 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
1621 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1622 }
1623
1624 static int sony_allocate_output_report(struct sony_sc *sc)
1625 {
1626 if (sc->quirks & SIXAXIS_CONTROLLER)
1627 sc->output_report_dmabuf =
1628 kmalloc(sizeof(union sixaxis_output_report_01),
1629 GFP_KERNEL);
1630 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1631 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1632 GFP_KERNEL);
1633 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1634 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1635 GFP_KERNEL);
1636 else
1637 return 0;
1638
1639 if (!sc->output_report_dmabuf)
1640 return -ENOMEM;
1641
1642 return 0;
1643 }
1644
1645 #ifdef CONFIG_SONY_FF
1646 static int sony_play_effect(struct input_dev *dev, void *data,
1647 struct ff_effect *effect)
1648 {
1649 struct hid_device *hid = input_get_drvdata(dev);
1650 struct sony_sc *sc = hid_get_drvdata(hid);
1651
1652 if (effect->type != FF_RUMBLE)
1653 return 0;
1654
1655 sc->left = effect->u.rumble.strong_magnitude / 256;
1656 sc->right = effect->u.rumble.weak_magnitude / 256;
1657
1658 schedule_work(&sc->state_worker);
1659 return 0;
1660 }
1661
1662 static int sony_init_ff(struct sony_sc *sc)
1663 {
1664 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1665 struct hid_input, list);
1666 struct input_dev *input_dev = hidinput->input;
1667
1668 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1669 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1670 }
1671
1672 #else
1673 static int sony_init_ff(struct sony_sc *sc)
1674 {
1675 return 0;
1676 }
1677
1678 #endif
1679
1680 static int sony_battery_get_property(struct power_supply *psy,
1681 enum power_supply_property psp,
1682 union power_supply_propval *val)
1683 {
1684 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1685 unsigned long flags;
1686 int ret = 0;
1687 u8 battery_charging, battery_capacity, cable_state;
1688
1689 spin_lock_irqsave(&sc->lock, flags);
1690 battery_charging = sc->battery_charging;
1691 battery_capacity = sc->battery_capacity;
1692 cable_state = sc->cable_state;
1693 spin_unlock_irqrestore(&sc->lock, flags);
1694
1695 switch (psp) {
1696 case POWER_SUPPLY_PROP_PRESENT:
1697 val->intval = 1;
1698 break;
1699 case POWER_SUPPLY_PROP_SCOPE:
1700 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1701 break;
1702 case POWER_SUPPLY_PROP_CAPACITY:
1703 val->intval = battery_capacity;
1704 break;
1705 case POWER_SUPPLY_PROP_STATUS:
1706 if (battery_charging)
1707 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1708 else
1709 if (battery_capacity == 100 && cable_state)
1710 val->intval = POWER_SUPPLY_STATUS_FULL;
1711 else
1712 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1713 break;
1714 default:
1715 ret = -EINVAL;
1716 break;
1717 }
1718 return ret;
1719 }
1720
1721 static int sony_battery_probe(struct sony_sc *sc)
1722 {
1723 struct hid_device *hdev = sc->hdev;
1724 int ret;
1725
1726 /*
1727 * Set the default battery level to 100% to avoid low battery warnings
1728 * if the battery is polled before the first device report is received.
1729 */
1730 sc->battery_capacity = 100;
1731
1732 sc->battery.properties = sony_battery_props;
1733 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1734 sc->battery.get_property = sony_battery_get_property;
1735 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1736 sc->battery.use_for_apm = 0;
1737 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR",
1738 sc->mac_address);
1739 if (!sc->battery.name)
1740 return -ENOMEM;
1741
1742 ret = power_supply_register(&hdev->dev, &sc->battery);
1743 if (ret) {
1744 hid_err(hdev, "Unable to register battery device\n");
1745 goto err_free;
1746 }
1747
1748 power_supply_powers(&sc->battery, &hdev->dev);
1749 return 0;
1750
1751 err_free:
1752 kfree(sc->battery.name);
1753 sc->battery.name = NULL;
1754 return ret;
1755 }
1756
1757 static void sony_battery_remove(struct sony_sc *sc)
1758 {
1759 if (!sc->battery.name)
1760 return;
1761
1762 power_supply_unregister(&sc->battery);
1763 kfree(sc->battery.name);
1764 sc->battery.name = NULL;
1765 }
1766
1767 /*
1768 * If a controller is plugged in via USB while already connected via Bluetooth
1769 * it will show up as two devices. A global list of connected controllers and
1770 * their MAC addresses is maintained to ensure that a device is only connected
1771 * once.
1772 */
1773 static int sony_check_add_dev_list(struct sony_sc *sc)
1774 {
1775 struct sony_sc *entry;
1776 unsigned long flags;
1777 int ret;
1778
1779 spin_lock_irqsave(&sony_dev_list_lock, flags);
1780
1781 list_for_each_entry(entry, &sony_device_list, list_node) {
1782 ret = memcmp(sc->mac_address, entry->mac_address,
1783 sizeof(sc->mac_address));
1784 if (!ret) {
1785 ret = -EEXIST;
1786 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1787 sc->mac_address);
1788 goto unlock;
1789 }
1790 }
1791
1792 ret = 0;
1793 list_add(&(sc->list_node), &sony_device_list);
1794
1795 unlock:
1796 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1797 return ret;
1798 }
1799
1800 static void sony_remove_dev_list(struct sony_sc *sc)
1801 {
1802 unsigned long flags;
1803
1804 if (sc->list_node.next) {
1805 spin_lock_irqsave(&sony_dev_list_lock, flags);
1806 list_del(&(sc->list_node));
1807 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1808 }
1809 }
1810
1811 static int sony_get_bt_devaddr(struct sony_sc *sc)
1812 {
1813 int ret;
1814
1815 /* HIDP stores the device MAC address as a string in the uniq field. */
1816 ret = strlen(sc->hdev->uniq);
1817 if (ret != 17)
1818 return -EINVAL;
1819
1820 ret = sscanf(sc->hdev->uniq,
1821 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1822 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1823 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1824
1825 if (ret != 6)
1826 return -EINVAL;
1827
1828 return 0;
1829 }
1830
1831 static int sony_check_add(struct sony_sc *sc)
1832 {
1833 __u8 *buf = NULL;
1834 int n, ret;
1835
1836 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1837 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1838 /*
1839 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1840 * address from the uniq string where HIDP stores it.
1841 * As uniq cannot be guaranteed to be a MAC address in all cases
1842 * a failure of this function should not prevent the connection.
1843 */
1844 if (sony_get_bt_devaddr(sc) < 0) {
1845 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1846 return 0;
1847 }
1848 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1849 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
1850 if (!buf)
1851 return -ENOMEM;
1852
1853 /*
1854 * The MAC address of a DS4 controller connected via USB can be
1855 * retrieved with feature report 0x81. The address begins at
1856 * offset 1.
1857 */
1858 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
1859 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
1860 HID_REQ_GET_REPORT);
1861
1862 if (ret != DS4_REPORT_0x81_SIZE) {
1863 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1864 ret = ret < 0 ? ret : -EINVAL;
1865 goto out_free;
1866 }
1867
1868 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1869 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1870 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1871 if (!buf)
1872 return -ENOMEM;
1873
1874 /*
1875 * The MAC address of a Sixaxis controller connected via USB can
1876 * be retrieved with feature report 0xf2. The address begins at
1877 * offset 4.
1878 */
1879 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1880 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1881 HID_REQ_GET_REPORT);
1882
1883 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1884 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1885 ret = ret < 0 ? ret : -EINVAL;
1886 goto out_free;
1887 }
1888
1889 /*
1890 * The Sixaxis device MAC in the report is big-endian and must
1891 * be byte-swapped.
1892 */
1893 for (n = 0; n < 6; n++)
1894 sc->mac_address[5-n] = buf[4+n];
1895 } else {
1896 return 0;
1897 }
1898
1899 ret = sony_check_add_dev_list(sc);
1900
1901 out_free:
1902
1903 kfree(buf);
1904
1905 return ret;
1906 }
1907
1908 static int sony_set_device_id(struct sony_sc *sc)
1909 {
1910 int ret;
1911
1912 /*
1913 * Only DualShock 4 or Sixaxis controllers get an id.
1914 * All others are set to -1.
1915 */
1916 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1917 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
1918 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1919 GFP_KERNEL);
1920 if (ret < 0) {
1921 sc->device_id = -1;
1922 return ret;
1923 }
1924 sc->device_id = ret;
1925 } else {
1926 sc->device_id = -1;
1927 }
1928
1929 return 0;
1930 }
1931
1932 static void sony_release_device_id(struct sony_sc *sc)
1933 {
1934 if (sc->device_id >= 0) {
1935 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1936 sc->device_id = -1;
1937 }
1938 }
1939
1940 static inline void sony_init_work(struct sony_sc *sc,
1941 void (*worker)(struct work_struct *))
1942 {
1943 if (!sc->worker_initialized)
1944 INIT_WORK(&sc->state_worker, worker);
1945
1946 sc->worker_initialized = 1;
1947 }
1948
1949 static inline void sony_cancel_work_sync(struct sony_sc *sc)
1950 {
1951 if (sc->worker_initialized)
1952 cancel_work_sync(&sc->state_worker);
1953 }
1954
1955 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1956 {
1957 int ret;
1958 unsigned long quirks = id->driver_data;
1959 struct sony_sc *sc;
1960 unsigned int connect_mask = HID_CONNECT_DEFAULT;
1961
1962 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1963 if (sc == NULL) {
1964 hid_err(hdev, "can't alloc sony descriptor\n");
1965 return -ENOMEM;
1966 }
1967
1968 sc->quirks = quirks;
1969 hid_set_drvdata(hdev, sc);
1970 sc->hdev = hdev;
1971
1972 ret = hid_parse(hdev);
1973 if (ret) {
1974 hid_err(hdev, "parse failed\n");
1975 return ret;
1976 }
1977
1978 if (sc->quirks & VAIO_RDESC_CONSTANT)
1979 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1980 else if (sc->quirks & SIXAXIS_CONTROLLER)
1981 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1982
1983 ret = hid_hw_start(hdev, connect_mask);
1984 if (ret) {
1985 hid_err(hdev, "hw start failed\n");
1986 return ret;
1987 }
1988
1989 ret = sony_allocate_output_report(sc);
1990 if (ret < 0) {
1991 hid_err(hdev, "failed to allocate the output report buffer\n");
1992 goto err_stop;
1993 }
1994
1995 ret = sony_set_device_id(sc);
1996 if (ret < 0) {
1997 hid_err(hdev, "failed to allocate the device id\n");
1998 goto err_stop;
1999 }
2000
2001 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2002 /*
2003 * The Sony Sixaxis does not handle HID Output Reports on the
2004 * Interrupt EP like it could, so we need to force HID Output
2005 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2006 *
2007 * There is also another issue about HID Output Reports via USB,
2008 * the Sixaxis does not want the report_id as part of the data
2009 * packet, so we have to discard buf[0] when sending the actual
2010 * control message, even for numbered reports, humpf!
2011 */
2012 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2013 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2014 ret = sixaxis_set_operational_usb(hdev);
2015 sony_init_work(sc, sixaxis_state_worker);
2016 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2017 /*
2018 * The Sixaxis wants output reports sent on the ctrl endpoint
2019 * when connected via Bluetooth.
2020 */
2021 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2022 ret = sixaxis_set_operational_bt(hdev);
2023 sony_init_work(sc, sixaxis_state_worker);
2024 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2025 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2026 /*
2027 * The DualShock 4 wants output reports sent on the ctrl
2028 * endpoint when connected via Bluetooth.
2029 */
2030 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2031 ret = dualshock4_set_operational_bt(hdev);
2032 if (ret < 0) {
2033 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2034 goto err_stop;
2035 }
2036 }
2037
2038 sony_init_work(sc, dualshock4_state_worker);
2039 } else {
2040 ret = 0;
2041 }
2042
2043 if (ret < 0)
2044 goto err_stop;
2045
2046 ret = sony_check_add(sc);
2047 if (ret < 0)
2048 goto err_stop;
2049
2050 if (sc->quirks & SONY_LED_SUPPORT) {
2051 ret = sony_leds_init(sc);
2052 if (ret < 0)
2053 goto err_stop;
2054 }
2055
2056 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2057 ret = sony_battery_probe(sc);
2058 if (ret < 0)
2059 goto err_stop;
2060
2061 /* Open the device to receive reports with battery info */
2062 ret = hid_hw_open(hdev);
2063 if (ret < 0) {
2064 hid_err(hdev, "hw open failed\n");
2065 goto err_stop;
2066 }
2067 }
2068
2069 if (sc->quirks & SONY_FF_SUPPORT) {
2070 ret = sony_init_ff(sc);
2071 if (ret < 0)
2072 goto err_close;
2073 }
2074
2075 return 0;
2076 err_close:
2077 hid_hw_close(hdev);
2078 err_stop:
2079 if (sc->quirks & SONY_LED_SUPPORT)
2080 sony_leds_remove(sc);
2081 if (sc->quirks & SONY_BATTERY_SUPPORT)
2082 sony_battery_remove(sc);
2083 sony_cancel_work_sync(sc);
2084 kfree(sc->output_report_dmabuf);
2085 sony_remove_dev_list(sc);
2086 sony_release_device_id(sc);
2087 hid_hw_stop(hdev);
2088 return ret;
2089 }
2090
2091 static void sony_remove(struct hid_device *hdev)
2092 {
2093 struct sony_sc *sc = hid_get_drvdata(hdev);
2094
2095 if (sc->quirks & SONY_LED_SUPPORT)
2096 sony_leds_remove(sc);
2097
2098 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2099 hid_hw_close(hdev);
2100 sony_battery_remove(sc);
2101 }
2102
2103 sony_cancel_work_sync(sc);
2104
2105 kfree(sc->output_report_dmabuf);
2106
2107 sony_remove_dev_list(sc);
2108
2109 sony_release_device_id(sc);
2110
2111 hid_hw_stop(hdev);
2112 }
2113
2114 static const struct hid_device_id sony_devices[] = {
2115 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2116 .driver_data = SIXAXIS_CONTROLLER_USB },
2117 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2118 .driver_data = SIXAXIS_CONTROLLER_USB },
2119 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2120 .driver_data = SIXAXIS_CONTROLLER_BT },
2121 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2122 .driver_data = VAIO_RDESC_CONSTANT },
2123 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2124 .driver_data = VAIO_RDESC_CONSTANT },
2125 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2126 * Logitech joystick from the device descriptor. */
2127 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2128 .driver_data = BUZZ_CONTROLLER },
2129 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2130 .driver_data = BUZZ_CONTROLLER },
2131 /* PS3 BD Remote Control */
2132 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2133 .driver_data = PS3REMOTE },
2134 /* Logitech Harmony Adapter for PS3 */
2135 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2136 .driver_data = PS3REMOTE },
2137 /* SMK-Link PS3 BD Remote Control */
2138 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2139 .driver_data = PS3REMOTE },
2140 /* Sony Dualshock 4 controllers for PS4 */
2141 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2142 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2143 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2144 .driver_data = DUALSHOCK4_CONTROLLER_BT },
2145 { }
2146 };
2147 MODULE_DEVICE_TABLE(hid, sony_devices);
2148
2149 static struct hid_driver sony_driver = {
2150 .name = "sony",
2151 .id_table = sony_devices,
2152 .input_mapping = sony_mapping,
2153 .input_configured = sony_input_configured,
2154 .probe = sony_probe,
2155 .remove = sony_remove,
2156 .report_fixup = sony_report_fixup,
2157 .raw_event = sony_raw_event
2158 };
2159
2160 static int __init sony_init(void)
2161 {
2162 dbg_hid("Sony:%s\n", __func__);
2163
2164 return hid_register_driver(&sony_driver);
2165 }
2166
2167 static void __exit sony_exit(void)
2168 {
2169 dbg_hid("Sony:%s\n", __func__);
2170
2171 ida_destroy(&sony_device_id_allocator);
2172 hid_unregister_driver(&sony_driver);
2173 }
2174 module_init(sony_init);
2175 module_exit(sony_exit);
2176
2177 MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror