projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
HID: sony: do not bail out when the sixaxis refuses the output report
[linux-2.6-block.git] / drivers / hid / hid-sony.c
CommitLineData
bd28ce00 1/*
077147a3 2 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
bd28ce00
JS		 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
bd28ce00 7 * Copyright (c) 2008 Jiri Slaby
078328da
JK		 8 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
f04d5140 10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
077147a3 11 * Copyright (c) 2014 Frank Praznik <frank.praznik@gmail.com>
bd28ce00
JS		 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
ad142b9e
FP		 21/*
22 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
078328da
JK		 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
bd28ce00
JS		 29#include <linux/device.h>
30#include <linux/hid.h>
31#include <linux/module.h>
5a0e3ad6 32#include <linux/slab.h>
40e32ee6 33#include <linux/leds.h>
d902f472
FP		 34#include <linux/power_supply.h>
35#include <linux/spinlock.h>
d2d782fc 36#include <linux/list.h>
8025087a 37#include <linux/idr.h>
e5606230 38#include <linux/input/mt.h>
bd28ce00
JS		 39
40#include "hid-ids.h"
41
6c79c18c
FP		 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)
8ab1676b
FP		 47#define DUALSHOCK4_CONTROLLER_USB BIT(5)
48#define DUALSHOCK4_CONTROLLER_BT BIT(6)
b3bca326
SW		 49#define MOTION_CONTROLLER_USB BIT(7)
50#define MOTION_CONTROLLER_BT BIT(8)
4545ee0a
SW		 51#define NAVIGATION_CONTROLLER_USB BIT(9)
52#define NAVIGATION_CONTROLLER_BT BIT(10)
cc6e0bbb 53
fee4e2d5 54#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
b3bca326 55#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
4545ee0a
SW		 56#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
57 NAVIGATION_CONTROLLER_BT)
68330d83
FP		 58#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
59 DUALSHOCK4_CONTROLLER_BT)
fee4e2d5 60#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
4545ee0a
SW		 61 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
62 NAVIGATION_CONTROLLER)
12e9a6d7 63#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
4545ee0a 64 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
c5e0c1c4
FP		 65#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
66 MOTION_CONTROLLER)
60781cf4
FP		 67
68#define MAX_LEDS 4
0a286ef2 69
4c3e8298
FP		 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 */
c607fb8d 77static __u8 sixaxis_rdesc[] = {
fb705a6d 78 0x05, 0x01, /* Usage Page (Desktop), */
4c3e8298 79 0x09, 0x04, /* Usage (Joystick), */
fb705a6d
AO		 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 */
e57a67da
MCC		 152};
153
c5e0c1c4
FP		 154/* PS/3 Motion controller */
155static __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), */
c5e0c1c4 161 0x75, 0x01, /* Report Size (1), */
8b2513c3 162 0x95, 0x15, /* Report Count (21), */
c5e0c1c4
FP		 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), */
8b2513c3
SW		 169 0x29, 0x15, /* Usage Maximum (15h), */
170 0x81, 0x02, /* Input (Variable), * Buttons */
171 0x95, 0x0B, /* Report Count (11), */
c5e0c1c4 172 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
8b2513c3 173 0x81, 0x03, /* Input (Constant, Variable), * Padding */
c5e0c1c4
FP		 174 0x15, 0x00, /* Logical Minimum (0), */
175 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
176 0x05, 0x01, /* Usage Page (Desktop), */
c5e0c1c4
FP		 177 0xA1, 0x00, /* Collection (Physical), */
178 0x75, 0x08, /* Report Size (8), */
8b2513c3 179 0x95, 0x01, /* Report Count (1), */
c5e0c1c4
FP		 180 0x35, 0x00, /* Physical Minimum (0), */
181 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
182 0x09, 0x30, /* Usage (X), */
8b2513c3 183 0x81, 0x02, /* Input (Variable), * Trigger */
c5e0c1c4 184 0xC0, /* End Collection, */
8b2513c3
SW		 185 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
186 0x75, 0x08, /* Report Size (8), */
187 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
c5e0c1c4 188 0x81, 0x02, /* Input (Variable), */
8b2513c3 189 0x05, 0x01, /* Usage Page (Desktop), */
c5e0c1c4 190 0x75, 0x10, /* Report Size (16), */
8b2513c3
SW		 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), */
c5e0c1c4 202 0x09, 0x01, /* Usage (Pointer), */
8b2513c3
SW		 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 */
c5e0c1c4 207 0x81, 0x02, /* Input (Variable), */
8b2513c3
SW		 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), */
c5e0c1c4
FP		 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
b2723eb7
SW		 251/* PS/3 Navigation controller */
252static __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), */
2259b5bb
SW		 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), */
b2723eb7
SW		 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};
c5e0c1c4 340
ad142b9e
FP		 341/*
342 * The default descriptor doesn't provide mapping for the accelerometers
58d7027b
FP		 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 */
ed19d8cf 347static u8 dualshock4_usb_rdesc[] = {
58d7027b
FP		 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), */
fb291cbd 384 0x25, 0x3F, /* Logical Maximum (63), */
58d7027b
FP		 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), */
fb291cbd
FP		 408 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
409 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
58d7027b
FP		 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), */
fb291cbd 415 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
58d7027b
FP		 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 */
ed19d8cf
FP		 599};
600
ad142b9e
FP		 601/*
602 * The default behavior of the Dualshock 4 is to send reports using report
077147a3
FP		 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
d829674d 606 * descriptor the button and axis definitions must be moved to report 17 or
077147a3 607 * the HID layer won't process the received input.
d829674d
FP		 608 */
609static 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), */
fb291cbd
FP		 717 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
718 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
d829674d
FP		 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
078328da
JK		 812static __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
872static 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};
892static 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
f04d5140 928static const unsigned int buzz_keymap[] = {
ad142b9e
FP		 929 /*
930 * The controller has 4 remote buzzers, each with one LED and 5
f04d5140
CL		 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
d902f472
FP		 968static 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
55d3b664
FP		 975struct 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
983struct 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
991struct 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
1000union sixaxis_output_report_01 {
1001 struct sixaxis_output_report data;
1002 __u8 buf[36];
1003};
1004
c5e0c1c4
FP		 1005struct motion_output_report_02 {
1006 u8 type, zero;
1007 u8 r, g, b;
1008 u8 zero2;
1009 u8 rumble;
1010};
1011
9b2b5c9a
FP		 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
29b691a8 1016#define SIXAXIS_REPORT_0xF2_SIZE 17
a85d67b5 1017#define SIXAXIS_REPORT_0xF5_SIZE 8
41d2d425 1018#define MOTION_REPORT_0x02_SIZE 49
9b2b5c9a 1019
8b402c92 1020static DEFINE_SPINLOCK(sony_dev_list_lock);
d2d782fc 1021static LIST_HEAD(sony_device_list);
8025087a 1022static DEFINE_IDA(sony_device_id_allocator);
d2d782fc 1023
cc6e0bbb 1024struct sony_sc {
d902f472 1025 spinlock_t lock;
d2d782fc 1026 struct list_head list_node;
0a286ef2 1027 struct hid_device *hdev;
60781cf4 1028 struct led_classdev *leds[MAX_LEDS];
cc6e0bbb 1029 unsigned long quirks;
0a286ef2 1030 struct work_struct state_worker;
d8aaccda 1031 void(*send_output_report)(struct sony_sc*);
297d716f
KK		 1032 struct power_supply *battery;
1033 struct power_supply_desc battery_desc;
8025087a 1034 int device_id;
9b2b5c9a 1035 __u8 *output_report_dmabuf;
f04d5140 1036
9f323b68 1037#ifdef CONFIG_SONY_FF
9f323b68
SE		 1038 __u8 left;
1039 __u8 right;
1040#endif
1041
d2d782fc 1042 __u8 mac_address[6];
5f5750d2 1043 __u8 worker_initialized;
d902f472
FP		 1044 __u8 cable_state;
1045 __u8 battery_charging;
1046 __u8 battery_capacity;
60781cf4 1047 __u8 led_state[MAX_LEDS];
decd946c 1048 __u8 resume_led_state[MAX_LEDS];
b3ed458c
FP		 1049 __u8 led_delay_on[MAX_LEDS];
1050 __u8 led_delay_off[MAX_LEDS];
60781cf4 1051 __u8 led_count;
cc6e0bbb
JK		 1052};
1053
c607fb8d
AO		 1054static __u8 *sixaxis_fixup(struct hid_device *hdev, __u8 *rdesc,
1055 unsigned int *rsize)
1056{
1057 *rsize = sizeof(sixaxis_rdesc);
1058 return sixaxis_rdesc;
1059}
1060
c5e0c1c4
FP		 1061static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
1062 unsigned int *rsize)
1063{
1064 *rsize = sizeof(motion_rdesc);
1065 return motion_rdesc;
1066}
1067
b2723eb7
SW		 1068static u8 *navigation_fixup(struct hid_device *hdev, u8 *rdesc,
1069 unsigned int *rsize)
1070{
1071 *rsize = sizeof(navigation_rdesc);
1072 return navigation_rdesc;
1073}
1074
078328da
JK		 1075static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
1076 unsigned int *rsize)
1077{
1078 *rsize = sizeof(ps3remote_rdesc);
1079 return ps3remote_rdesc;
1080}
1081
1082static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
1083 struct hid_field *field, struct hid_usage *usage,
1084 unsigned long **bit, int *max)
1085{
1086 unsigned int key = usage->hid & HID_USAGE;
1087
1088 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1089 return -1;
1090
1091 switch (usage->collection_index) {
1092 case 1:
1093 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
1094 return -1;
1095
1096 key = ps3remote_keymap_joypad_buttons[key];
1097 if (!key)
1098 return -1;
1099 break;
1100 case 2:
1101 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
1102 return -1;
1103
1104 key = ps3remote_keymap_remote_buttons[key];
1105 if (!key)
1106 return -1;
1107 break;
1108 default:
1109 return -1;
1110 }
1111
1112 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1113 return 1;
1114}
1115
73e4008d
NK		 1116static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
1117 unsigned int *rsize)
cc6e0bbb
JK		 1118{
1119 struct sony_sc *sc = hid_get_drvdata(hdev);
1120
99d24902
FLVC		 1121 /*
1122 * Some Sony RF receivers wrongly declare the mouse pointer as a
1123 * a constant non-data variable.
1124 */
1125 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
1126 /* usage page: generic desktop controls */
1127 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
1128 /* usage: mouse */
1129 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
1130 /* input (usage page for x,y axes): constant, variable, relative */
1131 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
a4649184 1132 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 1133 /* input: data, variable, relative */
cc6e0bbb
JK		 1134 rdesc[55] = 0x06;
1135 }
61ab44be 1136
ed19d8cf
FP		 1137 /*
1138 * The default Dualshock 4 USB descriptor doesn't assign
1139 * the gyroscope values to corresponding axes so we need a
1140 * modified one.
1141 */
b71b5578 1142 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
ed19d8cf
FP		 1143 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
1144 rdesc = dualshock4_usb_rdesc;
1145 *rsize = sizeof(dualshock4_usb_rdesc);
b71b5578 1146 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
d829674d
FP		 1147 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
1148 rdesc = dualshock4_bt_rdesc;
1149 *rsize = sizeof(dualshock4_bt_rdesc);
ed19d8cf
FP		 1150 }
1151
c607fb8d
AO		 1152 if (sc->quirks & SIXAXIS_CONTROLLER)
1153 return sixaxis_fixup(hdev, rdesc, rsize);
078328da 1154
c5e0c1c4
FP		 1155 if (sc->quirks & MOTION_CONTROLLER)
1156 return motion_fixup(hdev, rdesc, rsize);
1157
4545ee0a 1158 if (sc->quirks & NAVIGATION_CONTROLLER)
b2723eb7 1159 return navigation_fixup(hdev, rdesc, rsize);
4545ee0a 1160
078328da
JK		 1161 if (sc->quirks & PS3REMOTE)
1162 return ps3remote_fixup(hdev, rdesc, rsize);
1163
73e4008d 1164 return rdesc;
cc6e0bbb
JK		 1165}
1166
d902f472
FP		 1167static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
1168{
1169 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
1170 unsigned long flags;
12e9a6d7 1171 int offset;
d902f472
FP		 1172 __u8 cable_state, battery_capacity, battery_charging;
1173
ad142b9e
FP		 1174 /*
1175 * The sixaxis is charging if the battery value is 0xee
d902f472
FP		 1176 * and it is fully charged if the value is 0xef.
1177 * It does not report the actual level while charging so it
1178 * is set to 100% while charging is in progress.
1179 */
12e9a6d7
SW		 1180 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1181
1182 if (rd[offset] >= 0xee) {
d902f472 1183 battery_capacity = 100;
12e9a6d7 1184 battery_charging = !(rd[offset] & 0x01);
9fddd74a 1185 cable_state = 1;
d902f472 1186 } else {
12e9a6d7 1187 __u8 index = rd[offset] <= 5 ? rd[offset] : 5;
ac3c9a94 1188 battery_capacity = sixaxis_battery_capacity[index];
d902f472 1189 battery_charging = 0;
9fddd74a 1190 cable_state = 0;
d902f472 1191 }
d902f472
FP		 1192
1193 spin_lock_irqsave(&sc->lock, flags);
1194 sc->cable_state = cable_state;
1195 sc->battery_capacity = battery_capacity;
1196 sc->battery_charging = battery_charging;
1197 spin_unlock_irqrestore(&sc->lock, flags);
1198}
1199
1200static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
1201{
e5606230
FP		 1202 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1203 struct hid_input, list);
1204 struct input_dev *input_dev = hidinput->input;
d902f472 1205 unsigned long flags;
6c5f860d 1206 int n, offset;
d902f472
FP		 1207 __u8 cable_state, battery_capacity, battery_charging;
1208
ad142b9e
FP		 1209 /*
1210 * Battery and touchpad data starts at byte 30 in the USB report and
6c5f860d
FP		 1211 * 32 in Bluetooth report.
1212 */
1213 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
1214
ad142b9e
FP		 1215 /*
1216 * The lower 4 bits of byte 30 contain the battery level
d902f472
FP		 1217 * and the 5th bit contains the USB cable state.
1218 */
6c5f860d
FP		 1219 cable_state = (rd[offset] >> 4) & 0x01;
1220 battery_capacity = rd[offset] & 0x0F;
d902f472 1221
ad142b9e
FP		 1222 /*
1223 * When a USB power source is connected the battery level ranges from
6c5f860d
FP		 1224 * 0 to 10, and when running on battery power it ranges from 0 to 9.
1225 * A battery level above 10 when plugged in means charge completed.
d902f472 1226 */
6c5f860d 1227 if (!cable_state || battery_capacity > 10)
d902f472
FP		 1228 battery_charging = 0;
1229 else
1230 battery_charging = 1;
1231
6c5f860d
FP		 1232 if (!cable_state)
1233 battery_capacity++;
d902f472 1234 if (battery_capacity > 10)
6c5f860d
FP		 1235 battery_capacity = 10;
1236
d902f472
FP		 1237 battery_capacity *= 10;
1238
1239 spin_lock_irqsave(&sc->lock, flags);
1240 sc->cable_state = cable_state;
1241 sc->battery_capacity = battery_capacity;
1242 sc->battery_charging = battery_charging;
1243 spin_unlock_irqrestore(&sc->lock, flags);
e5606230 1244
6c5f860d
FP		 1245 offset += 5;
1246
ad142b9e
FP		 1247 /*
1248 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
6c5f860d 1249 * and 37 on Bluetooth.
e5606230
FP		 1250 * The first 7 bits of the first byte is a counter and bit 8 is a touch
1251 * indicator that is 0 when pressed and 1 when not pressed.
1252 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1253 * The data for the second touch is in the same format and immediatly
1254 * follows the data for the first.
1255 */
1256 for (n = 0; n < 2; n++) {
1257 __u16 x, y;
1258
1259 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1260 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1261
1262 input_mt_slot(input_dev, n);
1263 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
1264 !(rd[offset] >> 7));
1265 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1266 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1267
1268 offset += 4;
1269 }
d902f472
FP		 1270}
1271
c9e4d877
SW		 1272static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1273 __u8 *rd, int size)
1274{
1275 struct sony_sc *sc = hid_get_drvdata(hdev);
1276
ad142b9e
FP		 1277 /*
1278 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
c9e4d877
SW		 1279 * has to be BYTE_SWAPPED before passing up to joystick interface
1280 */
fee4e2d5 1281 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
8f5f0bc2
FP		 1282 /*
1283 * When connected via Bluetooth the Sixaxis occasionally sends
1284 * a report with the second byte 0xff and the rest zeroed.
1285 *
1286 * This report does not reflect the actual state of the
1287 * controller must be ignored to avoid generating false input
1288 * events.
1289 */
1290 if (rd[1] == 0xff)
1291 return -EINVAL;
1292
c9e4d877
SW		 1293 swap(rd[41], rd[42]);
1294 swap(rd[43], rd[44]);
1295 swap(rd[45], rd[46]);
1296 swap(rd[47], rd[48]);
d902f472 1297
12e9a6d7
SW		 1298 sixaxis_parse_report(sc, rd, size);
1299 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
d902f472 1300 sixaxis_parse_report(sc, rd, size);
4545ee0a
SW		 1301 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1302 size == 49) {
1303 sixaxis_parse_report(sc, rd, size);
68330d83
FP		 1304 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1305 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1306 && rd[0] == 0x11 && size == 78)) {
d902f472 1307 dualshock4_parse_report(sc, rd, size);
c9e4d877
SW		 1308 }
1309
1310 return 0;
1311}
1312
f04d5140
CL		 1313static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1314 struct hid_field *field, struct hid_usage *usage,
1315 unsigned long **bit, int *max)
1316{
1317 struct sony_sc *sc = hid_get_drvdata(hdev);
1318
1319 if (sc->quirks & BUZZ_CONTROLLER) {
1320 unsigned int key = usage->hid & HID_USAGE;
1321
1322 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1323 return -1;
1324
1325 switch (usage->collection_index) {
1326 case 1:
1327 if (key >= ARRAY_SIZE(buzz_keymap))
1328 return -1;
1329
1330 key = buzz_keymap[key];
1331 if (!key)
1332 return -1;
1333 break;
1334 default:
1335 return -1;
1336 }
1337
1338 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1339 return 1;
1340 }
1341
078328da
JK		 1342 if (sc->quirks & PS3REMOTE)
1343 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1344
6f498018
BT		 1345 /* Let hid-core decide for the others */
1346 return 0;
f04d5140
CL		 1347}
1348
ce8efc3b
FP		 1349static int sony_register_touchpad(struct hid_input *hi, int touch_count,
1350 int w, int h)
1351{
1352 struct input_dev *input_dev = hi->input;
1353 int ret;
1354
1355 ret = input_mt_init_slots(input_dev, touch_count, 0);
1356 if (ret < 0)
1357 return ret;
1358
1359 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1360 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1361
1362 return 0;
1363}
1364
9154301a 1365static int sony_input_configured(struct hid_device *hdev,
ce8efc3b
FP		 1366 struct hid_input *hidinput)
1367{
1368 struct sony_sc *sc = hid_get_drvdata(hdev);
9154301a 1369 int ret;
ce8efc3b
FP		 1370
1371 /*
1372 * The Dualshock 4 touchpad supports 2 touches and has a
981c5b4a 1373 * resolution of 1920x942 (44.86 dots/mm).
ce8efc3b
FP		 1374 */
1375 if (sc->quirks & DUALSHOCK4_CONTROLLER) {
9154301a
DT		 1376 ret = sony_register_touchpad(hidinput, 2, 1920, 942);
1377 if (ret) {
ce8efc3b 1378 hid_err(sc->hdev,
9154301a
DT		 1379 "Unable to initialize multi-touch slots: %d\n",
1380 ret);
1381 return ret;
1382 }
ce8efc3b 1383 }
9154301a
DT		 1384
1385 return 0;
ce8efc3b
FP		 1386}
1387
bd28ce00
JS		 1388/*
1389 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1390 * to "operational". Without this, the ps3 controller will not report any
1391 * events.
1392 */
816651a7 1393static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 1394{
a85d67b5
AO		 1395 const int buf_size =
1396 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
2e701a35 1397 __u8 *buf;
bd28ce00 1398 int ret;
bd28ce00 1399
2e701a35 1400 buf = kmalloc(buf_size, GFP_KERNEL);
bd28ce00
JS		 1401 if (!buf)
1402 return -ENOMEM;
1403
a85d67b5
AO		 1404 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1405 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1406 if (ret < 0) {
1407 hid_err(hdev, "can't set operational mode: step 1\n");
1408 goto out;
1409 }
f204828a 1410
a7de9b86
LK		 1411 /*
1412 * Some compatible controllers like the Speedlink Strike FX and
1413 * Gasia need another query plus an USB interrupt to get operational.
1414 */
a85d67b5
AO		 1415 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1416 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1417 if (ret < 0) {
1418 hid_err(hdev, "can't set operational mode: step 2\n");
1419 goto out;
1420 }
f204828a 1421
a7de9b86 1422 ret = hid_hw_output_report(hdev, buf, 1);
19f4c2ba
BT		 1423 if (ret < 0) {
1424 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1425 ret = 0;
1426 }
bd28ce00 1427
a7de9b86 1428out:
bd28ce00
JS		 1429 kfree(buf);
1430
1431 return ret;
1432}
1433
816651a7 1434static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 1435{
9b2b5c9a
FP		 1436 static const __u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1437 __u8 *buf;
1438 int ret;
1439
1440 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1441 if (!buf)
1442 return -ENOMEM;
1443
1444 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
b0dd72aa 1445 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
9b2b5c9a
FP		 1446
1447 kfree(buf);
1448
1449 return ret;
f9ce7c28
BN		 1450}
1451
ad142b9e
FP		 1452/*
1453 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
68330d83
FP		 1454 * controller so that it sends full input reports of type 0x11.
1455 */
1456static int dualshock4_set_operational_bt(struct hid_device *hdev)
1457{
9b2b5c9a
FP		 1458 __u8 *buf;
1459 int ret;
68330d83 1460
9b2b5c9a
FP		 1461 buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1462 if (!buf)
1463 return -ENOMEM;
1464
1465 ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
68330d83 1466 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
9b2b5c9a
FP		 1467
1468 kfree(buf);
1469
1470 return ret;
f9ce7c28
BN		 1471}
1472
221399b3 1473static void sixaxis_set_leds_from_id(struct sony_sc *sc)
8025087a
FP		 1474{
1475 static const __u8 sixaxis_leds[10][4] = {
1476 { 0x01, 0x00, 0x00, 0x00 },
1477 { 0x00, 0x01, 0x00, 0x00 },
1478 { 0x00, 0x00, 0x01, 0x00 },
1479 { 0x00, 0x00, 0x00, 0x01 },
1480 { 0x01, 0x00, 0x00, 0x01 },
1481 { 0x00, 0x01, 0x00, 0x01 },
1482 { 0x00, 0x00, 0x01, 0x01 },
1483 { 0x01, 0x00, 0x01, 0x01 },
1484 { 0x00, 0x01, 0x01, 0x01 },
1485 { 0x01, 0x01, 0x01, 0x01 }
1486 };
1487
221399b3
FP		 1488 int id = sc->device_id;
1489
1490 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
8025087a
FP		 1491
1492 if (id < 0)
1493 return;
1494
1495 id %= 10;
221399b3 1496 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
8025087a
FP		 1497}
1498
221399b3 1499static void dualshock4_set_leds_from_id(struct sony_sc *sc)
8025087a
FP		 1500{
1501 /* The first 4 color/index entries match what the PS4 assigns */
1502 static const __u8 color_code[7][3] = {
1503 /* Blue */ { 0x00, 0x00, 0x01 },
1504 /* Red */ { 0x01, 0x00, 0x00 },
1505 /* Green */ { 0x00, 0x01, 0x00 },
1506 /* Pink */ { 0x02, 0x00, 0x01 },
1507 /* Orange */ { 0x02, 0x01, 0x00 },
1508 /* Teal */ { 0x00, 0x01, 0x01 },
1509 /* White */ { 0x01, 0x01, 0x01 }
1510 };
1511
221399b3
FP		 1512 int id = sc->device_id;
1513
1514 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
8025087a
FP		 1515
1516 if (id < 0)
1517 return;
1518
1519 id %= 7;
221399b3 1520 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
8025087a
FP		 1521}
1522
221399b3 1523static void buzz_set_leds(struct sony_sc *sc)
f04d5140 1524{
221399b3 1525 struct hid_device *hdev = sc->hdev;
f04d5140
CL		 1526 struct list_head *report_list =
1527 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1528 struct hid_report *report = list_entry(report_list->next,
1529 struct hid_report, list);
1530 __s32 *value = report->field[0]->value;
1531
221399b3
FP		 1532 BUILD_BUG_ON(MAX_LEDS < 4);
1533
f04d5140 1534 value[0] = 0x00;
221399b3
FP		 1535 value[1] = sc->led_state[0] ? 0xff : 0x00;
1536 value[2] = sc->led_state[1] ? 0xff : 0x00;
1537 value[3] = sc->led_state[2] ? 0xff : 0x00;
1538 value[4] = sc->led_state[3] ? 0xff : 0x00;
f04d5140
CL		 1539 value[5] = 0x00;
1540 value[6] = 0x00;
1541 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1542}
1543
221399b3 1544static void sony_set_leds(struct sony_sc *sc)
0a286ef2 1545{
221399b3 1546 if (!(sc->quirks & BUZZ_CONTROLLER))
fa57a810 1547 schedule_work(&sc->state_worker);
221399b3
FP		 1548 else
1549 buzz_set_leds(sc);
0a286ef2
SE		 1550}
1551
c5382519 1552static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 1553 enum led_brightness value)
1554{
1555 struct device *dev = led->dev->parent;
ee79a8f8 1556 struct hid_device *hdev = to_hid_device(dev);
f04d5140 1557 struct sony_sc *drv_data;
f04d5140
CL		 1558
1559 int n;
b3ed458c 1560 int force_update;
f04d5140
CL		 1561
1562 drv_data = hid_get_drvdata(hdev);
2251b85f 1563 if (!drv_data) {
f04d5140
CL		 1564 hid_err(hdev, "No device data\n");
1565 return;
1566 }
f04d5140 1567
b3ed458c
FP		 1568 /*
1569 * The Sixaxis on USB will override any LED settings sent to it
1570 * and keep flashing all of the LEDs until the PS button is pressed.
1571 * Updates, even if redundant, must be always be sent to the
1572 * controller to avoid having to toggle the state of an LED just to
1573 * stop the flashing later on.
1574 */
1575 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1576
60781cf4 1577 for (n = 0; n < drv_data->led_count; n++) {
b3ed458c
FP		 1578 if (led == drv_data->leds[n] && (force_update ||
1579 (value != drv_data->led_state[n] ||
1580 drv_data->led_delay_on[n] ||
1581 drv_data->led_delay_off[n]))) {
1582
1583 drv_data->led_state[n] = value;
1584
1585 /* Setting the brightness stops the blinking */
1586 drv_data->led_delay_on[n] = 0;
1587 drv_data->led_delay_off[n] = 0;
1588
221399b3 1589 sony_set_leds(drv_data);
f04d5140
CL		 1590 break;
1591 }
1592 }
1593}
1594
c5382519 1595static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 1596{
1597 struct device *dev = led->dev->parent;
ee79a8f8 1598 struct hid_device *hdev = to_hid_device(dev);
f04d5140 1599 struct sony_sc *drv_data;
f04d5140
CL		 1600
1601 int n;
f04d5140
CL		 1602
1603 drv_data = hid_get_drvdata(hdev);
2251b85f 1604 if (!drv_data) {
f04d5140
CL		 1605 hid_err(hdev, "No device data\n");
1606 return LED_OFF;
1607 }
f04d5140 1608
60781cf4 1609 for (n = 0; n < drv_data->led_count; n++) {
7db7504a
SW		 1610 if (led == drv_data->leds[n])
1611 return drv_data->led_state[n];
f04d5140
CL		 1612 }
1613
7db7504a 1614 return LED_OFF;
f04d5140 1615}
f04d5140 1616
b3ed458c
FP		 1617static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1618 unsigned long *delay_off)
1619{
1620 struct device *dev = led->dev->parent;
ee79a8f8 1621 struct hid_device *hdev = to_hid_device(dev);
b3ed458c
FP		 1622 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1623 int n;
1624 __u8 new_on, new_off;
1625
1626 if (!drv_data) {
1627 hid_err(hdev, "No device data\n");
1628 return -EINVAL;
1629 }
1630
1631 /* Max delay is 255 deciseconds or 2550 milliseconds */
1632 if (*delay_on > 2550)
1633 *delay_on = 2550;
1634 if (*delay_off > 2550)
1635 *delay_off = 2550;
1636
1637 /* Blink at 1 Hz if both values are zero */
1638 if (!*delay_on && !*delay_off)
1639 *delay_on = *delay_off = 500;
1640
1641 new_on = *delay_on / 10;
1642 new_off = *delay_off / 10;
1643
1644 for (n = 0; n < drv_data->led_count; n++) {
1645 if (led == drv_data->leds[n])
1646 break;
1647 }
1648
1649 /* This LED is not registered on this device */
1650 if (n >= drv_data->led_count)
1651 return -EINVAL;
1652
1653 /* Don't schedule work if the values didn't change */
1654 if (new_on != drv_data->led_delay_on[n] ||
1655 new_off != drv_data->led_delay_off[n]) {
1656 drv_data->led_delay_on[n] = new_on;
1657 drv_data->led_delay_off[n] = new_off;
1658 schedule_work(&drv_data->state_worker);
1659 }
1660
1661 return 0;
1662}
1663
fa57a810 1664static void sony_leds_remove(struct sony_sc *sc)
0a286ef2 1665{
0a286ef2
SE		 1666 struct led_classdev *led;
1667 int n;
1668
fa57a810 1669 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1670
fa57a810
FP		 1671 for (n = 0; n < sc->led_count; n++) {
1672 led = sc->leds[n];
1673 sc->leds[n] = NULL;
0a286ef2
SE		 1674 if (!led)
1675 continue;
1676 led_classdev_unregister(led);
1677 kfree(led);
1678 }
60781cf4 1679
fa57a810 1680 sc->led_count = 0;
0a286ef2
SE		 1681}
1682
fa57a810 1683static int sony_leds_init(struct sony_sc *sc)
f04d5140 1684{
fa57a810 1685 struct hid_device *hdev = sc->hdev;
40e32ee6 1686 int n, ret = 0;
b3ed458c 1687 int use_ds4_names;
40e32ee6
JK		 1688 struct led_classdev *led;
1689 size_t name_sz;
1690 char *name;
0a286ef2
SE		 1691 size_t name_len;
1692 const char *name_fmt;
b3ed458c
FP		 1693 static const char * const ds4_name_str[] = { "red", "green", "blue",
1694 "global" };
5607c89a 1695 __u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
b3ed458c 1696 __u8 use_hw_blink[MAX_LEDS] = { 0 };
f04d5140 1697
fa57a810 1698 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1699
fa57a810
FP		 1700 if (sc->quirks & BUZZ_CONTROLLER) {
1701 sc->led_count = 4;
b3ed458c 1702 use_ds4_names = 0;
0a286ef2
SE		 1703 name_len = strlen("::buzz#");
1704 name_fmt = "%s::buzz%d";
1705 /* Validate expected report characteristics. */
1706 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1707 return -ENODEV;
fa57a810 1708 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
221399b3
FP		 1709 dualshock4_set_leds_from_id(sc);
1710 sc->led_state[3] = 1;
b3ed458c
FP		 1711 sc->led_count = 4;
1712 memset(max_brightness, 255, 3);
1713 use_hw_blink[3] = 1;
1714 use_ds4_names = 1;
61ebca93
FP		 1715 name_len = 0;
1716 name_fmt = "%s:%s";
c5e0c1c4
FP		 1717 } else if (sc->quirks & MOTION_CONTROLLER) {
1718 sc->led_count = 3;
1719 memset(max_brightness, 255, 3);
1720 use_ds4_names = 1;
1721 name_len = 0;
1722 name_fmt = "%s:%s";
4545ee0a
SW		 1723 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1724 static const __u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1725
1726 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1727 sc->led_count = 1;
1728 memset(use_hw_blink, 1, 4);
1729 use_ds4_names = 0;
1730 name_len = strlen("::sony#");
1731 name_fmt = "%s::sony%d";
60781cf4 1732 } else {
221399b3 1733 sixaxis_set_leds_from_id(sc);
fa57a810 1734 sc->led_count = 4;
b3ed458c
FP		 1735 memset(use_hw_blink, 1, 4);
1736 use_ds4_names = 0;
61ebca93
FP		 1737 name_len = strlen("::sony#");
1738 name_fmt = "%s::sony%d";
60781cf4
FP		 1739 }
1740
ad142b9e
FP		 1741 /*
1742 * Clear LEDs as we have no way of reading their initial state. This is
f04d5140 1743 * only relevant if the driver is loaded after somebody actively set the
ad142b9e
FP		 1744 * LEDs to on
1745 */
221399b3 1746 sony_set_leds(sc);
f04d5140 1747
0a286ef2 1748 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 1749
fa57a810 1750 for (n = 0; n < sc->led_count; n++) {
61ebca93 1751
b3ed458c
FP		 1752 if (use_ds4_names)
1753 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
61ebca93 1754
40e32ee6
JK		 1755 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1756 if (!led) {
1757 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
8cd5fcda 1758 ret = -ENOMEM;
40e32ee6
JK		 1759 goto error_leds;
1760 }
f04d5140 1761
40e32ee6 1762 name = (void *)(&led[1]);
b3ed458c
FP		 1763 if (use_ds4_names)
1764 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1765 ds4_name_str[n]);
61ebca93
FP		 1766 else
1767 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6 1768 led->name = name;
221399b3 1769 led->brightness = sc->led_state[n];
b3ed458c 1770 led->max_brightness = max_brightness[n];
c5382519
SE		 1771 led->brightness_get = sony_led_get_brightness;
1772 led->brightness_set = sony_led_set_brightness;
f04d5140 1773
b3ed458c
FP		 1774 if (use_hw_blink[n])
1775 led->blink_set = sony_led_blink_set;
1776
8025087a
FP		 1777 sc->leds[n] = led;
1778
8cd5fcda
JL		 1779 ret = led_classdev_register(&hdev->dev, led);
1780 if (ret) {
40e32ee6 1781 hid_err(hdev, "Failed to register LED %d\n", n);
8025087a 1782 sc->leds[n] = NULL;
40e32ee6
JK		 1783 kfree(led);
1784 goto error_leds;
f04d5140
CL		 1785 }
1786 }
f04d5140
CL		 1787
1788 return ret;
1789
f04d5140 1790error_leds:
fa57a810 1791 sony_leds_remove(sc);
f04d5140 1792
f04d5140 1793 return ret;
f04d5140
CL		 1794}
1795
d8aaccda 1796static void sixaxis_send_output_report(struct sony_sc *sc)
a08c22c0 1797{
9b2b5c9a 1798 static const union sixaxis_output_report_01 default_report = {
55d3b664
FP		 1799 .buf = {
1800 0x01,
1801 0x00, 0xff, 0x00, 0xff, 0x00,
1802 0x00, 0x00, 0x00, 0x00, 0x00,
1803 0xff, 0x27, 0x10, 0x00, 0x32,
1804 0xff, 0x27, 0x10, 0x00, 0x32,
1805 0xff, 0x27, 0x10, 0x00, 0x32,
1806 0xff, 0x27, 0x10, 0x00, 0x32,
1807 0x00, 0x00, 0x00, 0x00, 0x00
1808 }
a08c22c0 1809 };
9b2b5c9a
FP		 1810 struct sixaxis_output_report *report =
1811 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1812 int n;
1813
1814 /* Initialize the report with default values */
1815 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
9f323b68 1816
0a286ef2 1817#ifdef CONFIG_SONY_FF
9b2b5c9a
FP		 1818 report->rumble.right_motor_on = sc->right ? 1 : 0;
1819 report->rumble.left_motor_force = sc->left;
0a286ef2
SE		 1820#endif
1821
9b2b5c9a
FP		 1822 report->leds_bitmap |= sc->led_state[0] << 1;
1823 report->leds_bitmap |= sc->led_state[1] << 2;
1824 report->leds_bitmap |= sc->led_state[2] << 3;
1825 report->leds_bitmap |= sc->led_state[3] << 4;
9f323b68 1826
88f6576f 1827 /* Set flag for all leds off, required for 3rd party INTEC controller */
9b2b5c9a
FP		 1828 if ((report->leds_bitmap & 0x1E) == 0)
1829 report->leds_bitmap |= 0x20;
88f6576f 1830
b3ed458c
FP		 1831 /*
1832 * The LEDs in the report are indexed in reverse order to their
1833 * corresponding light on the controller.
1834 * Index 0 = LED 4, index 1 = LED 3, etc...
1835 *
1836 * In the case of both delay values being zero (blinking disabled) the
1837 * default report values should be used or the controller LED will be
1838 * always off.
1839 */
1840 for (n = 0; n < 4; n++) {
1841 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
9b2b5c9a
FP		 1842 report->led[3 - n].duty_off = sc->led_delay_off[n];
1843 report->led[3 - n].duty_on = sc->led_delay_on[n];
b3ed458c
FP		 1844 }
1845 }
1846
9b2b5c9a
FP		 1847 hid_hw_raw_request(sc->hdev, report->report_id, (__u8 *)report,
1848 sizeof(struct sixaxis_output_report),
1849 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
9f323b68
SE		 1850}
1851
d8aaccda 1852static void dualshock4_send_output_report(struct sony_sc *sc)
0bd88dd3 1853{
0da8ea65 1854 struct hid_device *hdev = sc->hdev;
9b2b5c9a 1855 __u8 *buf = sc->output_report_dmabuf;
48220237
FP		 1856 int offset;
1857
fdcf105d 1858 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
9b2b5c9a 1859 memset(buf, 0, DS4_REPORT_0x05_SIZE);
fdcf105d 1860 buf[0] = 0x05;
b3ed458c 1861 buf[1] = 0xFF;
fdcf105d
FP		 1862 offset = 4;
1863 } else {
9b2b5c9a 1864 memset(buf, 0, DS4_REPORT_0x11_SIZE);
fdcf105d 1865 buf[0] = 0x11;
824deff8 1866 buf[1] = 0x80;
fdcf105d
FP		 1867 buf[3] = 0x0F;
1868 offset = 6;
1869 }
0bd88dd3
FP		 1870
1871#ifdef CONFIG_SONY_FF
48220237
FP		 1872 buf[offset++] = sc->right;
1873 buf[offset++] = sc->left;
1874#else
1875 offset += 2;
0bd88dd3
FP		 1876#endif
1877
b3ed458c
FP		 1878 /* LED 3 is the global control */
1879 if (sc->led_state[3]) {
1880 buf[offset++] = sc->led_state[0];
1881 buf[offset++] = sc->led_state[1];
1882 buf[offset++] = sc->led_state[2];
1883 } else {
1884 offset += 3;
1885 }
1886
1887 /* If both delay values are zero the DualShock 4 disables blinking. */
1888 buf[offset++] = sc->led_delay_on[3];
1889 buf[offset++] = sc->led_delay_off[3];
60781cf4 1890
fdcf105d 1891 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
9b2b5c9a 1892 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
fdcf105d 1893 else
9b2b5c9a 1894 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
fdcf105d 1895 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
0bd88dd3
FP		 1896}
1897
d8aaccda 1898static void motion_send_output_report(struct sony_sc *sc)
c5e0c1c4 1899{
c5e0c1c4
FP		 1900 struct hid_device *hdev = sc->hdev;
1901 struct motion_output_report_02 *report =
1902 (struct motion_output_report_02 *)sc->output_report_dmabuf;
1903
41d2d425 1904 memset(report, 0, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 1905
1906 report->type = 0x02; /* set leds */
1907 report->r = sc->led_state[0];
1908 report->g = sc->led_state[1];
1909 report->b = sc->led_state[2];
1910
1911#ifdef CONFIG_SONY_FF
1912 report->rumble = max(sc->right, sc->left);
1913#endif
1914
41d2d425 1915 hid_hw_output_report(hdev, (__u8 *)report, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 1916}
1917
decd946c
FP		 1918static inline void sony_send_output_report(struct sony_sc *sc)
1919{
1920 if (sc->send_output_report)
1921 sc->send_output_report(sc);
1922}
1923
d8aaccda
FP		 1924static void sony_state_worker(struct work_struct *work)
1925{
1926 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1927 sc->send_output_report(sc);
1928}
1929
9b2b5c9a
FP		 1930static int sony_allocate_output_report(struct sony_sc *sc)
1931{
4545ee0a
SW		 1932 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1933 (sc->quirks & NAVIGATION_CONTROLLER))
9b2b5c9a
FP		 1934 sc->output_report_dmabuf =
1935 kmalloc(sizeof(union sixaxis_output_report_01),
1936 GFP_KERNEL);
1937 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1938 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1939 GFP_KERNEL);
1940 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1941 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1942 GFP_KERNEL);
c5e0c1c4 1943 else if (sc->quirks & MOTION_CONTROLLER)
41d2d425
SW		 1944 sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
1945 GFP_KERNEL);
9b2b5c9a
FP		 1946 else
1947 return 0;
1948
1949 if (!sc->output_report_dmabuf)
1950 return -ENOMEM;
1951
1952 return 0;
1953}
1954
0a286ef2 1955#ifdef CONFIG_SONY_FF
9f323b68
SE		 1956static int sony_play_effect(struct input_dev *dev, void *data,
1957 struct ff_effect *effect)
1958{
a08c22c0 1959 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 1960 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 1961
1962 if (effect->type != FF_RUMBLE)
1963 return 0;
1964
9f323b68 1965 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 1966 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 1967
92b5c411 1968 schedule_work(&sc->state_worker);
9f323b68 1969 return 0;
a08c22c0
SE		 1970}
1971
fa57a810 1972static int sony_init_ff(struct sony_sc *sc)
a08c22c0 1973{
fa57a810 1974 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
a08c22c0
SE		 1975 struct hid_input, list);
1976 struct input_dev *input_dev = hidinput->input;
1977
1978 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1979 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1980}
1981
1982#else
fa57a810 1983static int sony_init_ff(struct sony_sc *sc)
a08c22c0
SE		 1984{
1985 return 0;
1986}
9f323b68 1987
a08c22c0
SE		 1988#endif
1989
d902f472
FP		 1990static int sony_battery_get_property(struct power_supply *psy,
1991 enum power_supply_property psp,
1992 union power_supply_propval *val)
1993{
297d716f 1994 struct sony_sc *sc = power_supply_get_drvdata(psy);
d902f472
FP		 1995 unsigned long flags;
1996 int ret = 0;
1997 u8 battery_charging, battery_capacity, cable_state;
1998
1999 spin_lock_irqsave(&sc->lock, flags);
2000 battery_charging = sc->battery_charging;
2001 battery_capacity = sc->battery_capacity;
2002 cable_state = sc->cable_state;
2003 spin_unlock_irqrestore(&sc->lock, flags);
2004
2005 switch (psp) {
2006 case POWER_SUPPLY_PROP_PRESENT:
2007 val->intval = 1;
2008 break;
2009 case POWER_SUPPLY_PROP_SCOPE:
2010 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2011 break;
2012 case POWER_SUPPLY_PROP_CAPACITY:
2013 val->intval = battery_capacity;
2014 break;
2015 case POWER_SUPPLY_PROP_STATUS:
2016 if (battery_charging)
2017 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2018 else
2019 if (battery_capacity == 100 && cable_state)
2020 val->intval = POWER_SUPPLY_STATUS_FULL;
2021 else
2022 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2023 break;
2024 default:
2025 ret = -EINVAL;
2026 break;
2027 }
2028 return ret;
9f323b68
SE		 2029}
2030
d902f472 2031static int sony_battery_probe(struct sony_sc *sc)
c4e1ddf2 2032{
297d716f 2033 struct power_supply_config psy_cfg = { .drv_data = sc, };
c4e1ddf2 2034 struct hid_device *hdev = sc->hdev;
d902f472 2035 int ret;
c4e1ddf2 2036
ad142b9e
FP		 2037 /*
2038 * Set the default battery level to 100% to avoid low battery warnings
d9a293a9
FP		 2039 * if the battery is polled before the first device report is received.
2040 */
2041 sc->battery_capacity = 100;
2042
297d716f
KK		 2043 sc->battery_desc.properties = sony_battery_props;
2044 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2045 sc->battery_desc.get_property = sony_battery_get_property;
2046 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2047 sc->battery_desc.use_for_apm = 0;
2048 sc->battery_desc.name = kasprintf(GFP_KERNEL,
2049 "sony_controller_battery_%pMR",
2050 sc->mac_address);
2051 if (!sc->battery_desc.name)
d902f472 2052 return -ENOMEM;
c4e1ddf2 2053
297d716f
KK		 2054 sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
2055 &psy_cfg);
2056 if (IS_ERR(sc->battery)) {
2057 ret = PTR_ERR(sc->battery);
d902f472
FP		 2058 hid_err(hdev, "Unable to register battery device\n");
2059 goto err_free;
2060 }
c4e1ddf2 2061
297d716f 2062 power_supply_powers(sc->battery, &hdev->dev);
a08c22c0 2063 return 0;
d902f472
FP		 2064
2065err_free:
297d716f
KK		 2066 kfree(sc->battery_desc.name);
2067 sc->battery_desc.name = NULL;
d902f472 2068 return ret;
a08c22c0 2069}
9f323b68 2070
d902f472 2071static void sony_battery_remove(struct sony_sc *sc)
9f323b68 2072{
297d716f 2073 if (!sc->battery_desc.name)
d902f472
FP		 2074 return;
2075
297d716f
KK		 2076 power_supply_unregister(sc->battery);
2077 kfree(sc->battery_desc.name);
2078 sc->battery_desc.name = NULL;
9f323b68 2079}
a08c22c0 2080
d2d782fc
FP		 2081/*
2082 * If a controller is plugged in via USB while already connected via Bluetooth
2083 * it will show up as two devices. A global list of connected controllers and
2084 * their MAC addresses is maintained to ensure that a device is only connected
2085 * once.
2086 */
2087static int sony_check_add_dev_list(struct sony_sc *sc)
2088{
2089 struct sony_sc *entry;
2090 unsigned long flags;
2091 int ret;
2092
2093 spin_lock_irqsave(&sony_dev_list_lock, flags);
2094
2095 list_for_each_entry(entry, &sony_device_list, list_node) {
2096 ret = memcmp(sc->mac_address, entry->mac_address,
2097 sizeof(sc->mac_address));
2098 if (!ret) {
2099 ret = -EEXIST;
2100 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
2101 sc->mac_address);
2102 goto unlock;
c4e1ddf2
FP		 2103 }
2104 }
2105
d2d782fc
FP		 2106 ret = 0;
2107 list_add(&(sc->list_node), &sony_device_list);
c4e1ddf2 2108
d2d782fc
FP		 2109unlock:
2110 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2111 return ret;
2112}
2113
2114static void sony_remove_dev_list(struct sony_sc *sc)
2115{
2116 unsigned long flags;
c4e1ddf2 2117
d2d782fc
FP		 2118 if (sc->list_node.next) {
2119 spin_lock_irqsave(&sony_dev_list_lock, flags);
2120 list_del(&(sc->list_node));
2121 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2122 }
c4e1ddf2
FP		 2123}
2124
d2d782fc
FP		 2125static int sony_get_bt_devaddr(struct sony_sc *sc)
2126{
2127 int ret;
2128
2129 /* HIDP stores the device MAC address as a string in the uniq field. */
2130 ret = strlen(sc->hdev->uniq);
2131 if (ret != 17)
2132 return -EINVAL;
2133
2134 ret = sscanf(sc->hdev->uniq,
2135 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2136 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2137 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2138
2139 if (ret != 6)
2140 return -EINVAL;
2141
2142 return 0;
2143}
2144
2145static int sony_check_add(struct sony_sc *sc)
2146{
9b2b5c9a 2147 __u8 *buf = NULL;
d2d782fc
FP		 2148 int n, ret;
2149
2150 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
12e9a6d7 2151 (sc->quirks & MOTION_CONTROLLER_BT) ||
4545ee0a 2152 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
d2d782fc
FP		 2153 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2154 /*
2155 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2156 * address from the uniq string where HIDP stores it.
2157 * As uniq cannot be guaranteed to be a MAC address in all cases
2158 * a failure of this function should not prevent the connection.
2159 */
2160 if (sony_get_bt_devaddr(sc) < 0) {
2161 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2162 return 0;
2163 }
2164 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
9b2b5c9a
FP		 2165 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
2166 if (!buf)
2167 return -ENOMEM;
d2d782fc
FP		 2168
2169 /*
2170 * The MAC address of a DS4 controller connected via USB can be
2171 * retrieved with feature report 0x81. The address begins at
2172 * offset 1.
2173 */
9b2b5c9a
FP		 2174 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2175 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2176 HID_REQ_GET_REPORT);
d2d782fc 2177
9b2b5c9a 2178 if (ret != DS4_REPORT_0x81_SIZE) {
d2d782fc 2179 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
9b2b5c9a
FP		 2180 ret = ret < 0 ? ret : -EINVAL;
2181 goto out_free;
d2d782fc
FP		 2182 }
2183
2184 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
4545ee0a
SW		 2185 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2186 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
9b2b5c9a
FP		 2187 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2188 if (!buf)
2189 return -ENOMEM;
d2d782fc
FP		 2190
2191 /*
2192 * The MAC address of a Sixaxis controller connected via USB can
2193 * be retrieved with feature report 0xf2. The address begins at
2194 * offset 4.
2195 */
9b2b5c9a
FP		 2196 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2197 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2198 HID_REQ_GET_REPORT);
d2d782fc 2199
9b2b5c9a 2200 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
d2d782fc 2201 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
9b2b5c9a
FP		 2202 ret = ret < 0 ? ret : -EINVAL;
2203 goto out_free;
d2d782fc
FP		 2204 }
2205
2206 /*
2207 * The Sixaxis device MAC in the report is big-endian and must
2208 * be byte-swapped.
2209 */
2210 for (n = 0; n < 6; n++)
2211 sc->mac_address[5-n] = buf[4+n];
2212 } else {
2213 return 0;
2214 }
2215
9b2b5c9a
FP		 2216 ret = sony_check_add_dev_list(sc);
2217
2218out_free:
2219
2220 kfree(buf);
2221
2222 return ret;
d2d782fc
FP		 2223}
2224
8025087a
FP		 2225static int sony_set_device_id(struct sony_sc *sc)
2226{
2227 int ret;
2228
2229 /*
2230 * Only DualShock 4 or Sixaxis controllers get an id.
2231 * All others are set to -1.
2232 */
2233 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2234 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2235 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2236 GFP_KERNEL);
2237 if (ret < 0) {
2238 sc->device_id = -1;
2239 return ret;
2240 }
2241 sc->device_id = ret;
2242 } else {
2243 sc->device_id = -1;
2244 }
2245
2246 return 0;
2247}
2248
2249static void sony_release_device_id(struct sony_sc *sc)
2250{
2251 if (sc->device_id >= 0) {
2252 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2253 sc->device_id = -1;
2254 }
2255}
2256
d8aaccda
FP		 2257static inline void sony_init_output_report(struct sony_sc *sc,
2258 void(*send_output_report)(struct sony_sc*))
46262047 2259{
d8aaccda
FP		 2260 sc->send_output_report = send_output_report;
2261
46262047 2262 if (!sc->worker_initialized)
d8aaccda 2263 INIT_WORK(&sc->state_worker, sony_state_worker);
46262047
FP		 2264
2265 sc->worker_initialized = 1;
2266}
2267
2268static inline void sony_cancel_work_sync(struct sony_sc *sc)
2269{
2270 if (sc->worker_initialized)
2271 cancel_work_sync(&sc->state_worker);
2272}
d2d782fc 2273
bd28ce00
JS		 2274static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2275{
2276 int ret;
cc6e0bbb
JK		 2277 unsigned long quirks = id->driver_data;
2278 struct sony_sc *sc;
f04d5140 2279 unsigned int connect_mask = HID_CONNECT_DEFAULT;
cc6e0bbb 2280
abf832bf 2281 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
cc6e0bbb 2282 if (sc == NULL) {
4291ee30 2283 hid_err(hdev, "can't alloc sony descriptor\n");
cc6e0bbb
JK		 2284 return -ENOMEM;
2285 }
2286
b94993f6
FP		 2287 spin_lock_init(&sc->lock);
2288
cc6e0bbb
JK		 2289 sc->quirks = quirks;
2290 hid_set_drvdata(hdev, sc);
0a286ef2 2291 sc->hdev = hdev;
bd28ce00 2292
bd28ce00
JS		 2293 ret = hid_parse(hdev);
2294 if (ret) {
4291ee30 2295 hid_err(hdev, "parse failed\n");
abf832bf 2296 return ret;
bd28ce00
JS		 2297 }
2298
f04d5140
CL		 2299 if (sc->quirks & VAIO_RDESC_CONSTANT)
2300 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
50764650 2301 else if (sc->quirks & SIXAXIS_CONTROLLER)
f04d5140
CL		 2302 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2303
2304 ret = hid_hw_start(hdev, connect_mask);
bd28ce00 2305 if (ret) {
4291ee30 2306 hid_err(hdev, "hw start failed\n");
abf832bf 2307 return ret;
bd28ce00
JS		 2308 }
2309
131a8a9a 2310 ret = sony_set_device_id(sc);
9b2b5c9a 2311 if (ret < 0) {
131a8a9a 2312 hid_err(hdev, "failed to allocate the device id\n");
9b2b5c9a
FP		 2313 goto err_stop;
2314 }
2315
131a8a9a 2316 ret = sony_allocate_output_report(sc);
8025087a 2317 if (ret < 0) {
131a8a9a 2318 hid_err(hdev, "failed to allocate the output report buffer\n");
8025087a
FP		 2319 goto err_stop;
2320 }
2321
4545ee0a
SW		 2322 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2323 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
e534a935
BT		 2324 /*
2325 * The Sony Sixaxis does not handle HID Output Reports on the
2326 * Interrupt EP like it could, so we need to force HID Output
2327 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2328 *
2329 * There is also another issue about HID Output Reports via USB,
2330 * the Sixaxis does not want the report_id as part of the data
2331 * packet, so we have to discard buf[0] when sending the actual
2332 * control message, even for numbered reports, humpf!
2333 */
2334 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2335 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
816651a7 2336 ret = sixaxis_set_operational_usb(hdev);
d8aaccda 2337 sony_init_output_report(sc, sixaxis_send_output_report);
4545ee0a
SW		 2338 } else if ((sc->quirks & SIXAXIS_CONTROLLER_BT) ||
2339 (sc->quirks & NAVIGATION_CONTROLLER_BT)) {
2078b9bb
FP		 2340 /*
2341 * The Sixaxis wants output reports sent on the ctrl endpoint
2342 * when connected via Bluetooth.
2343 */
2344 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
816651a7 2345 ret = sixaxis_set_operational_bt(hdev);
d8aaccda 2346 sony_init_output_report(sc, sixaxis_send_output_report);
fee4e2d5 2347 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
68330d83 2348 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2078b9bb
FP		 2349 /*
2350 * The DualShock 4 wants output reports sent on the ctrl
2351 * endpoint when connected via Bluetooth.
2352 */
2353 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
68330d83
FP		 2354 ret = dualshock4_set_operational_bt(hdev);
2355 if (ret < 0) {
2356 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2357 goto err_stop;
2358 }
2359 }
c4e1ddf2 2360
d8aaccda 2361 sony_init_output_report(sc, dualshock4_send_output_report);
c5e0c1c4 2362 } else if (sc->quirks & MOTION_CONTROLLER) {
d8aaccda 2363 sony_init_output_report(sc, motion_send_output_report);
0bd88dd3
FP		 2364 } else {
2365 ret = 0;
2366 }
f9ce7c28 2367
d2d782fc
FP		 2368 if (ret < 0)
2369 goto err_stop;
2370
2371 ret = sony_check_add(sc);
4dfdc464 2372 if (ret < 0)
bd28ce00
JS		 2373 goto err_stop;
2374
0a286ef2 2375 if (sc->quirks & SONY_LED_SUPPORT) {
fa57a810 2376 ret = sony_leds_init(sc);
0a286ef2
SE		 2377 if (ret < 0)
2378 goto err_stop;
2379 }
2380
d902f472
FP		 2381 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2382 ret = sony_battery_probe(sc);
2383 if (ret < 0)
2384 goto err_stop;
2385
2386 /* Open the device to receive reports with battery info */
2387 ret = hid_hw_open(hdev);
2388 if (ret < 0) {
2389 hid_err(hdev, "hw open failed\n");
2390 goto err_stop;
2391 }
2392 }
2393
c8de9dbb 2394 if (sc->quirks & SONY_FF_SUPPORT) {
fa57a810 2395 ret = sony_init_ff(sc);
c8de9dbb
FP		 2396 if (ret < 0)
2397 goto err_close;
5f5750d2 2398 }
a08c22c0 2399
bd28ce00 2400 return 0;
d902f472
FP		 2401err_close:
2402 hid_hw_close(hdev);
bd28ce00 2403err_stop:
0a286ef2 2404 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 2405 sony_leds_remove(sc);
d902f472
FP		 2406 if (sc->quirks & SONY_BATTERY_SUPPORT)
2407 sony_battery_remove(sc);
46262047 2408 sony_cancel_work_sync(sc);
9b2b5c9a 2409 kfree(sc->output_report_dmabuf);
d2d782fc 2410 sony_remove_dev_list(sc);
8025087a 2411 sony_release_device_id(sc);
bd28ce00 2412 hid_hw_stop(hdev);
bd28ce00
JS		 2413 return ret;
2414}
2415
cc6e0bbb
JK		 2416static void sony_remove(struct hid_device *hdev)
2417{
f04d5140
CL		 2418 struct sony_sc *sc = hid_get_drvdata(hdev);
2419
0a286ef2 2420 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 2421 sony_leds_remove(sc);
f04d5140 2422
d902f472
FP		 2423 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2424 hid_hw_close(hdev);
2425 sony_battery_remove(sc);
2426 }
2427
46262047 2428 sony_cancel_work_sync(sc);
9f323b68 2429
9b2b5c9a
FP		 2430 kfree(sc->output_report_dmabuf);
2431
d2d782fc 2432 sony_remove_dev_list(sc);
9f323b68 2433
8025087a
FP		 2434 sony_release_device_id(sc);
2435
cc6e0bbb 2436 hid_hw_stop(hdev);
cc6e0bbb
JK		 2437}
2438
decd946c
FP		 2439#ifdef CONFIG_PM
2440
2441static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2442{
2443 /*
2444 * On suspend save the current LED state,
2445 * stop running force-feedback and blank the LEDS.
2446 */
2447 if (SONY_LED_SUPPORT || SONY_FF_SUPPORT) {
2448 struct sony_sc *sc = hid_get_drvdata(hdev);
2449
2450#ifdef CONFIG_SONY_FF
2451 sc->left = sc->right = 0;
2452#endif
2453
2454 memcpy(sc->resume_led_state, sc->led_state,
2455 sizeof(sc->resume_led_state));
2456 memset(sc->led_state, 0, sizeof(sc->led_state));
2457
2458 sony_send_output_report(sc);
2459 }
2460
2461 return 0;
2462}
2463
2464static int sony_resume(struct hid_device *hdev)
2465{
2466 /* Restore the state of controller LEDs on resume */
2467 if (SONY_LED_SUPPORT) {
2468 struct sony_sc *sc = hid_get_drvdata(hdev);
2469
2470 memcpy(sc->led_state, sc->resume_led_state,
2471 sizeof(sc->led_state));
2472
2473 /*
2474 * The Sixaxis and navigation controllers on USB need to be
2475 * reinitialized on resume or they won't behave properly.
2476 */
2477 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2478 (sc->quirks & NAVIGATION_CONTROLLER_USB))
2479 sixaxis_set_operational_usb(sc->hdev);
2480
2481 sony_set_leds(sc);
2482 }
2483
2484 return 0;
2485}
2486
2487#endif
2488
bd28ce00 2489static const struct hid_device_id sony_devices[] = {
816651a7
AO		 2490 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2491 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4 2492 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 2493 .driver_data = NAVIGATION_CONTROLLER_USB },
6eabaaa0 2494 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 2495 .driver_data = NAVIGATION_CONTROLLER_BT },
c5e0c1c4 2496 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 2497 .driver_data = MOTION_CONTROLLER_USB },
a4afa854 2498 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 2499 .driver_data = MOTION_CONTROLLER_BT },
816651a7
AO		 2500 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2501 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 2502 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2503 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 2504 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2505 .driver_data = VAIO_RDESC_CONSTANT },
f04d5140
CL		 2506 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2507 * Logitech joystick from the device descriptor. */
2508 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2509 .driver_data = BUZZ_CONTROLLER },
2510 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2511 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 2512 /* PS3 BD Remote Control */
2513 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2514 .driver_data = PS3REMOTE },
2515 /* Logitech Harmony Adapter for PS3 */
2516 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2517 .driver_data = PS3REMOTE },
68a49e51
FP		 2518 /* SMK-Link PS3 BD Remote Control */
2519 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2520 .driver_data = PS3REMOTE },
0bd88dd3
FP		 2521 /* Sony Dualshock 4 controllers for PS4 */
2522 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 2523 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 2524 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 2525 .driver_data = DUALSHOCK4_CONTROLLER_BT },
bd28ce00
JS		 2526 { }
2527};
2528MODULE_DEVICE_TABLE(hid, sony_devices);
2529
2530static struct hid_driver sony_driver = {
ce8efc3b
FP		 2531 .name = "sony",
2532 .id_table = sony_devices,
2533 .input_mapping = sony_mapping,
2534 .input_configured = sony_input_configured,
2535 .probe = sony_probe,
2536 .remove = sony_remove,
2537 .report_fixup = sony_report_fixup,
decd946c
FP		 2538 .raw_event = sony_raw_event,
2539
2540#ifdef CONFIG_PM
2541 .suspend = sony_suspend,
2542 .resume = sony_resume,
2543 .reset_resume = sony_resume,
2544#endif
bd28ce00 2545};
8025087a
FP		 2546
2547static int __init sony_init(void)
2548{
2549 dbg_hid("Sony:%s\n", __func__);
2550
2551 return hid_register_driver(&sony_driver);
2552}
2553
2554static void __exit sony_exit(void)
2555{
2556 dbg_hid("Sony:%s\n", __func__);
2557
8025087a 2558 hid_unregister_driver(&sony_driver);
6c40065f 2559 ida_destroy(&sony_device_id_allocator);
8025087a
FP		 2560}
2561module_init(sony_init);
2562module_exit(sony_exit);
bd28ce00 2563
bd28ce00 2564MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)