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