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