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