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