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