xref: /openbmc/linux/drivers/hid/hid-sony.c (revision ae3473231e77a3f1909d48cd144cebe5e1d049b3)
1 /*
2  *  HID driver for Sony / PS2 / PS3 / PS4 BD devices.
3  *
4  *  Copyright (c) 1999 Andreas Gal
5  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7  *  Copyright (c) 2008 Jiri Slaby
8  *  Copyright (c) 2012 David Dillow <dave@thedillows.org>
9  *  Copyright (c) 2006-2013 Jiri Kosina
10  *  Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
11  *  Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
12  */
13 
14 /*
15  * This program is free software; you can redistribute it and/or modify it
16  * under the terms of the GNU General Public License as published by the Free
17  * Software Foundation; either version 2 of the License, or (at your option)
18  * any later version.
19  */
20 
21 /*
22  * NOTE: in order for the Sony PS3 BD Remote Control to be found by
23  * a Bluetooth host, the key combination Start+Enter has to be kept pressed
24  * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
25  *
26  * There will be no PIN request from the device.
27  */
28 
29 #include <linux/device.h>
30 #include <linux/hid.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/leds.h>
34 #include <linux/power_supply.h>
35 #include <linux/spinlock.h>
36 #include <linux/list.h>
37 #include <linux/idr.h>
38 #include <linux/input/mt.h>
39 #include <linux/crc32.h>
40 #include <asm/unaligned.h>
41 
42 #include "hid-ids.h"
43 
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)
49 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
50 #define DUALSHOCK4_CONTROLLER_BT  BIT(6)
51 #define MOTION_CONTROLLER_USB     BIT(7)
52 #define MOTION_CONTROLLER_BT      BIT(8)
53 #define NAVIGATION_CONTROLLER_USB BIT(9)
54 #define NAVIGATION_CONTROLLER_BT  BIT(10)
55 #define SINO_LITE_CONTROLLER      BIT(11)
56 #define FUTUREMAX_DANCE_MAT       BIT(12)
57 
58 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
59 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
60 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
61 				NAVIGATION_CONTROLLER_BT)
62 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
63 				DUALSHOCK4_CONTROLLER_BT)
64 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
65 				DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
66 				NAVIGATION_CONTROLLER)
67 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
68 				MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
69 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
70 				MOTION_CONTROLLER)
71 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
72 			MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
73 
74 #define MAX_LEDS 4
75 
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  */
83 static u8 sixaxis_rdesc[] = {
84 	0x05, 0x01,         /*  Usage Page (Desktop),               */
85 	0x09, 0x04,         /*  Usage (Joystick),                   */
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                      */
158 };
159 
160 /* PS/3 Motion controller */
161 static u8 motion_rdesc[] = {
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),              */
167 	0x75, 0x01,         /*          Report Size (1),            */
168 	0x95, 0x15,         /*          Report Count (21),          */
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),        */
175 	0x29, 0x15,         /*          Usage Maximum (15h),        */
176 	0x81, 0x02,         /*          Input (Variable),           * Buttons */
177 	0x95, 0x0B,         /*          Report Count (11),          */
178 	0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
179 	0x81, 0x03,         /*          Input (Constant, Variable), * Padding */
180 	0x15, 0x00,         /*          Logical Minimum (0),        */
181 	0x26, 0xFF, 0x00,   /*          Logical Maximum (255),      */
182 	0x05, 0x01,         /*          Usage Page (Desktop),       */
183 	0xA1, 0x00,         /*          Collection (Physical),      */
184 	0x75, 0x08,         /*              Report Size (8),        */
185 	0x95, 0x01,         /*              Report Count (1),       */
186 	0x35, 0x00,         /*              Physical Minimum (0),   */
187 	0x46, 0xFF, 0x00,   /*              Physical Maximum (255), */
188 	0x09, 0x30,         /*              Usage (X),              */
189 	0x81, 0x02,         /*              Input (Variable),       * Trigger */
190 	0xC0,               /*          End Collection,             */
191 	0x06, 0x00, 0xFF,   /*          Usage Page (FF00h),         */
192 	0x75, 0x08,         /*          Report Size (8),            */
193 	0x95, 0x07,         /*          Report Count (7),           * skip 7 bytes */
194 	0x81, 0x02,         /*          Input (Variable),           */
195 	0x05, 0x01,         /*          Usage Page (Desktop),       */
196 	0x75, 0x10,         /*          Report Size (16),           */
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),       */
208 	0x09, 0x01,         /*          Usage (Pointer),            */
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 */
213 	0x81, 0x02,         /*          Input (Variable),           */
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),         */
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 
257 /* PS/3 Navigation controller */
258 static u8 navigation_rdesc[] = {
259 	0x05, 0x01,         /*  Usage Page (Desktop),               */
260 	0x09, 0x04,         /*  Usage (Joystick),                   */
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),         */
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),          */
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 };
346 
347 /*
348  * The default descriptor doesn't provide mapping for the accelerometers
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  */
353 static u8 dualshock4_usb_rdesc[] = {
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),            */
379 	0x29, 0x0D,         /*      Usage Maximum (0Dh),            */
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),            */
390 	0x25, 0x3F,         /*      Logical Maximum (63),           */
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),       */
408 	0x26, 0xFF, 0x7F,   /*      Logical Maximum (32767),        */
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),            */
414 	0x16, 0x00, 0x80,   /*      Logical Minimum (-32768),       */
415 	0x26, 0xFF, 0x7F,   /*      Logical Maximum (32767),        */
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),            */
421 	0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
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                      */
605 };
606 
607 /*
608  * The default behavior of the Dualshock 4 is to send reports using report
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
612  * descriptor the button and axis definitions must be moved to report 17 or
613  * the HID layer won't process the received input.
614  */
615 static 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),            */
692 	0x29, 0x0D,         /*      Usage Maximum (0Dh),            */
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),       */
717 	0x26, 0xFF, 0x7F,   /*      Logical Maximum (32767),        */
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),            */
723 	0x16, 0x00, 0x80,   /*      Logical Minimum (-32768),       */
724 	0x26, 0xFF, 0x7F,   /*      Logical Maximum (32767),        */
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 
818 static u8 ps3remote_rdesc[] = {
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 
826 	  /*
827 	   * Ignore the 1st byte, maybe it is used for a controller
828 	   * number but it's not needed for correct operation
829 	   */
830 	  0x75, 0x08,        /* GReportSize 0x08 [8] */
831 	  0x95, 0x01,        /* GReportCount 0x01 [1] */
832 	  0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
833 
834 	  /*
835 	   * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
836 	   * buttons multiple keypresses are allowed
837 	   */
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 
862 	  /*
863 	   * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
864 	   * 0xff and 11th is for press indication
865 	   */
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 
884 static 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 };
904 static 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 
940 static const unsigned int buzz_keymap[] = {
941 	/*
942 	 * The controller has 4 remote buzzers, each with one LED and 5
943 	 * buttons.
944 	 *
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 	 */
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,
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 
980 static 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 
989 static 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 
1006 static 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 
1013 struct sixaxis_led {
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%) */
1019 } __packed;
1020 
1021 struct sixaxis_rumble {
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 */
1027 } __packed;
1028 
1029 struct sixaxis_output_report {
1030 	u8 report_id;
1031 	struct sixaxis_rumble rumble;
1032 	u8 padding[4];
1033 	u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
1034 	struct sixaxis_led led[4];    /* LEDx at (4 - x) */
1035 	struct sixaxis_led _reserved; /* LED5, not actually soldered */
1036 } __packed;
1037 
1038 union sixaxis_output_report_01 {
1039 	struct sixaxis_output_report data;
1040 	u8 buf[36];
1041 };
1042 
1043 struct motion_output_report_02 {
1044 	u8 type, zero;
1045 	u8 r, g, b;
1046 	u8 zero2;
1047 	u8 rumble;
1048 };
1049 
1050 #define DS4_FEATURE_REPORT_0x02_SIZE 37
1051 #define DS4_FEATURE_REPORT_0x81_SIZE 7
1052 #define DS4_INPUT_REPORT_0x11_SIZE 78
1053 #define DS4_OUTPUT_REPORT_0x05_SIZE 32
1054 #define DS4_OUTPUT_REPORT_0x11_SIZE 78
1055 #define SIXAXIS_REPORT_0xF2_SIZE 17
1056 #define SIXAXIS_REPORT_0xF5_SIZE 8
1057 #define MOTION_REPORT_0x02_SIZE 49
1058 
1059 /* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
1060  * additional +2.
1061  */
1062 #define DS4_INPUT_REPORT_BUTTON_OFFSET    5
1063 #define DS4_INPUT_REPORT_BATTERY_OFFSET  30
1064 #define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
1065 
1066 #define DS4_TOUCHPAD_SUFFIX " Touchpad"
1067 
1068 static DEFINE_SPINLOCK(sony_dev_list_lock);
1069 static LIST_HEAD(sony_device_list);
1070 static DEFINE_IDA(sony_device_id_allocator);
1071 
1072 struct sony_sc {
1073 	spinlock_t lock;
1074 	struct list_head list_node;
1075 	struct hid_device *hdev;
1076 	struct input_dev *touchpad;
1077 	struct led_classdev *leds[MAX_LEDS];
1078 	unsigned long quirks;
1079 	struct work_struct state_worker;
1080 	void (*send_output_report)(struct sony_sc *);
1081 	struct power_supply *battery;
1082 	struct power_supply_desc battery_desc;
1083 	int device_id;
1084 	u8 *output_report_dmabuf;
1085 
1086 #ifdef CONFIG_SONY_FF
1087 	u8 left;
1088 	u8 right;
1089 #endif
1090 
1091 	u8 mac_address[6];
1092 	u8 worker_initialized;
1093 	u8 defer_initialization;
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;
1102 };
1103 
1104 static inline void sony_schedule_work(struct sony_sc *sc)
1105 {
1106 	if (!sc->defer_initialization)
1107 		schedule_work(&sc->state_worker);
1108 }
1109 
1110 static u8 *sixaxis_fixup(struct hid_device *hdev, u8 *rdesc,
1111 			     unsigned int *rsize)
1112 {
1113 	*rsize = sizeof(sixaxis_rdesc);
1114 	return sixaxis_rdesc;
1115 }
1116 
1117 static 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 
1124 static 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 
1131 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
1132 			     unsigned int *rsize)
1133 {
1134 	*rsize = sizeof(ps3remote_rdesc);
1135 	return ps3remote_rdesc;
1136 }
1137 
1138 static 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 
1172 static 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 
1203 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
1204 		unsigned int *rsize)
1205 {
1206 	struct sony_sc *sc = hid_get_drvdata(hdev);
1207 
1208 	if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
1209 		return rdesc;
1210 
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) {
1222 		hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
1223 		/* input: data, variable, relative */
1224 		rdesc[55] = 0x06;
1225 	}
1226 
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 	 */
1232 	if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
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);
1236 	} else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1237 		hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
1238 		rdesc = dualshock4_bt_rdesc;
1239 		*rsize = sizeof(dualshock4_bt_rdesc);
1240 	}
1241 
1242 	if (sc->quirks & SIXAXIS_CONTROLLER)
1243 		return sixaxis_fixup(hdev, rdesc, rsize);
1244 
1245 	if (sc->quirks & MOTION_CONTROLLER)
1246 		return motion_fixup(hdev, rdesc, rsize);
1247 
1248 	if (sc->quirks & NAVIGATION_CONTROLLER)
1249 		return navigation_fixup(hdev, rdesc, rsize);
1250 
1251 	if (sc->quirks & PS3REMOTE)
1252 		return ps3remote_fixup(hdev, rdesc, rsize);
1253 
1254 	return rdesc;
1255 }
1256 
1257 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
1258 {
1259 	static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
1260 	unsigned long flags;
1261 	int offset;
1262 	u8 cable_state, battery_capacity, battery_charging;
1263 
1264 	/*
1265 	 * The sixaxis is charging if the battery value is 0xee
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 	 */
1270 	offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1271 
1272 	if (rd[offset] >= 0xee) {
1273 		battery_capacity = 100;
1274 		battery_charging = !(rd[offset] & 0x01);
1275 		cable_state = 1;
1276 	} else {
1277 		u8 index = rd[offset] <= 5 ? rd[offset] : 5;
1278 		battery_capacity = sixaxis_battery_capacity[index];
1279 		battery_charging = 0;
1280 		cable_state = 0;
1281 	}
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 
1290 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
1291 {
1292 	unsigned long flags;
1293 	int n, m, offset, num_touch_data, max_touch_data;
1294 	u8 cable_state, battery_capacity, battery_charging;
1295 
1296 	/* When using Bluetooth the header is 2 bytes longer, so skip these. */
1297 	int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 0 : 2;
1298 
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 
1303 	/*
1304 	 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1305 	 * and the 5th bit contains the USB cable state.
1306 	 */
1307 	offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1308 	cable_state = (rd[offset] >> 4) & 0x01;
1309 	battery_capacity = rd[offset] & 0x0F;
1310 
1311 	/*
1312 	 * When a USB power source is connected the battery level ranges from
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.
1315 	 */
1316 	if (!cable_state || battery_capacity > 10)
1317 		battery_charging = 0;
1318 	else
1319 		battery_charging = 1;
1320 
1321 	if (!cable_state)
1322 		battery_capacity++;
1323 	if (battery_capacity > 10)
1324 		battery_capacity = 10;
1325 
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);
1333 
1334 	/*
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).
1339 	 */
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;
1347 
1348 	for (m = 0; m < num_touch_data; m++) {
1349 		/* Skip past timestamp */
1350 		offset += 1;
1351 
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);
1368 			input_mt_slot(sc->touchpad, n);
1369 			input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1370 
1371 			if (active) {
1372 				input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1373 				input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1374 			}
1375 
1376 			offset += 4;
1377 		}
1378 		input_mt_sync_frame(sc->touchpad);
1379 		input_sync(sc->touchpad);
1380 	}
1381 }
1382 
1383 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1384 		u8 *rd, int size)
1385 {
1386 	struct sony_sc *sc = hid_get_drvdata(hdev);
1387 
1388 	/*
1389 	 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1390 	 * has to be BYTE_SWAPPED before passing up to joystick interface
1391 	 */
1392 	if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
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 
1404 		swap(rd[41], rd[42]);
1405 		swap(rd[43], rd[44]);
1406 		swap(rd[45], rd[46]);
1407 		swap(rd[47], rd[48]);
1408 
1409 		sixaxis_parse_report(sc, rd, size);
1410 	} else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1411 		sixaxis_parse_report(sc, rd, size);
1412 	} else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1413 			size == 49) {
1414 		sixaxis_parse_report(sc, rd, size);
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)) {
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 		}
1433 		dualshock4_parse_report(sc, rd, size);
1434 	}
1435 
1436 	if (sc->defer_initialization) {
1437 		sc->defer_initialization = 0;
1438 		sony_schedule_work(sc);
1439 	}
1440 
1441 	return 0;
1442 }
1443 
1444 static 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 
1473 	if (sc->quirks & PS3REMOTE)
1474 		return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1475 
1476 
1477 	if (sc->quirks & DUALSHOCK4_CONTROLLER)
1478 		return ds4_mapping(hdev, hi, field, usage, bit, max);
1479 
1480 	/* Let hid-core decide for the others */
1481 	return 0;
1482 }
1483 
1484 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1485 					int w, int h)
1486 {
1487 	size_t name_sz;
1488 	char *name;
1489 	int ret;
1490 
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);
1517 	if (ret < 0)
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);
1524 
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;
1531 
1532 	return 0;
1533 
1534 err:
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;
1542 }
1543 
1544 static 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 }
1555 
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  */
1561 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1562 {
1563 	const int buf_size =
1564 		max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1565 	u8 *buf;
1566 	int ret;
1567 
1568 	buf = kmalloc(buf_size, GFP_KERNEL);
1569 	if (!buf)
1570 		return -ENOMEM;
1571 
1572 	ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1573 				 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1574 	if (ret < 0) {
1575 		hid_err(hdev, "can't set operational mode: step 1\n");
1576 		goto out;
1577 	}
1578 
1579 	/*
1580 	 * Some compatible controllers like the Speedlink Strike FX and
1581 	 * Gasia need another query plus an USB interrupt to get operational.
1582 	 */
1583 	ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1584 				 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1585 	if (ret < 0) {
1586 		hid_err(hdev, "can't set operational mode: step 2\n");
1587 		goto out;
1588 	}
1589 
1590 	ret = hid_hw_output_report(hdev, buf, 1);
1591 	if (ret < 0) {
1592 		hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1593 		ret = 0;
1594 	}
1595 
1596 out:
1597 	kfree(buf);
1598 
1599 	return ret;
1600 }
1601 
1602 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1603 {
1604 	static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1605 	u8 *buf;
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),
1613 				  HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1614 
1615 	kfree(buf);
1616 
1617 	return ret;
1618 }
1619 
1620 /*
1621  * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1622  * controller so that it sends full input reports of type 0x11.
1623  */
1624 static int dualshock4_set_operational_bt(struct hid_device *hdev)
1625 {
1626 	u8 *buf;
1627 	int ret;
1628 
1629 	buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1630 	if (!buf)
1631 		return -ENOMEM;
1632 
1633 	ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_FEATURE_REPORT_0x02_SIZE,
1634 				HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1635 
1636 	kfree(buf);
1637 
1638 	return ret;
1639 }
1640 
1641 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1642 {
1643 	static const u8 sixaxis_leds[10][4] = {
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 
1656 	int id = sc->device_id;
1657 
1658 	BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1659 
1660 	if (id < 0)
1661 		return;
1662 
1663 	id %= 10;
1664 	memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1665 }
1666 
1667 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1668 {
1669 	/* The first 4 color/index entries match what the PS4 assigns */
1670 	static const u8 color_code[7][3] = {
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 
1680 	int id = sc->device_id;
1681 
1682 	BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1683 
1684 	if (id < 0)
1685 		return;
1686 
1687 	id %= 7;
1688 	memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1689 }
1690 
1691 static void buzz_set_leds(struct sony_sc *sc)
1692 {
1693 	struct hid_device *hdev = sc->hdev;
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);
1698 	s32 *value = report->field[0]->value;
1699 
1700 	BUILD_BUG_ON(MAX_LEDS < 4);
1701 
1702 	value[0] = 0x00;
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;
1707 	value[5] = 0x00;
1708 	value[6] = 0x00;
1709 	hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1710 }
1711 
1712 static void sony_set_leds(struct sony_sc *sc)
1713 {
1714 	if (!(sc->quirks & BUZZ_CONTROLLER))
1715 		sony_schedule_work(sc);
1716 	else
1717 		buzz_set_leds(sc);
1718 }
1719 
1720 static void sony_led_set_brightness(struct led_classdev *led,
1721 				    enum led_brightness value)
1722 {
1723 	struct device *dev = led->dev->parent;
1724 	struct hid_device *hdev = to_hid_device(dev);
1725 	struct sony_sc *drv_data;
1726 
1727 	int n;
1728 	int force_update;
1729 
1730 	drv_data = hid_get_drvdata(hdev);
1731 	if (!drv_data) {
1732 		hid_err(hdev, "No device data\n");
1733 		return;
1734 	}
1735 
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 
1745 	for (n = 0; n < drv_data->led_count; n++) {
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 
1757 			sony_set_leds(drv_data);
1758 			break;
1759 		}
1760 	}
1761 }
1762 
1763 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1764 {
1765 	struct device *dev = led->dev->parent;
1766 	struct hid_device *hdev = to_hid_device(dev);
1767 	struct sony_sc *drv_data;
1768 
1769 	int n;
1770 
1771 	drv_data = hid_get_drvdata(hdev);
1772 	if (!drv_data) {
1773 		hid_err(hdev, "No device data\n");
1774 		return LED_OFF;
1775 	}
1776 
1777 	for (n = 0; n < drv_data->led_count; n++) {
1778 		if (led == drv_data->leds[n])
1779 			return drv_data->led_state[n];
1780 	}
1781 
1782 	return LED_OFF;
1783 }
1784 
1785 static 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;
1789 	struct hid_device *hdev = to_hid_device(dev);
1790 	struct sony_sc *drv_data = hid_get_drvdata(hdev);
1791 	int n;
1792 	u8 new_on, new_off;
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;
1826 		sony_schedule_work(drv_data);
1827 	}
1828 
1829 	return 0;
1830 }
1831 
1832 static void sony_leds_remove(struct sony_sc *sc)
1833 {
1834 	struct led_classdev *led;
1835 	int n;
1836 
1837 	BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1838 
1839 	for (n = 0; n < sc->led_count; n++) {
1840 		led = sc->leds[n];
1841 		sc->leds[n] = NULL;
1842 		if (!led)
1843 			continue;
1844 		led_classdev_unregister(led);
1845 		kfree(led);
1846 	}
1847 
1848 	sc->led_count = 0;
1849 }
1850 
1851 static int sony_leds_init(struct sony_sc *sc)
1852 {
1853 	struct hid_device *hdev = sc->hdev;
1854 	int n, ret = 0;
1855 	int use_ds4_names;
1856 	struct led_classdev *led;
1857 	size_t name_sz;
1858 	char *name;
1859 	size_t name_len;
1860 	const char *name_fmt;
1861 	static const char * const ds4_name_str[] = { "red", "green", "blue",
1862 						  "global" };
1863 	u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1864 	u8 use_hw_blink[MAX_LEDS] = { 0 };
1865 
1866 	BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1867 
1868 	if (sc->quirks & BUZZ_CONTROLLER) {
1869 		sc->led_count = 4;
1870 		use_ds4_names = 0;
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;
1876 	} else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1877 		dualshock4_set_leds_from_id(sc);
1878 		sc->led_state[3] = 1;
1879 		sc->led_count = 4;
1880 		memset(max_brightness, 255, 3);
1881 		use_hw_blink[3] = 1;
1882 		use_ds4_names = 1;
1883 		name_len = 0;
1884 		name_fmt = "%s:%s";
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";
1891 	} else if (sc->quirks & NAVIGATION_CONTROLLER) {
1892 		static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
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";
1900 	} else {
1901 		sixaxis_set_leds_from_id(sc);
1902 		sc->led_count = 4;
1903 		memset(use_hw_blink, 1, 4);
1904 		use_ds4_names = 0;
1905 		name_len = strlen("::sony#");
1906 		name_fmt = "%s::sony%d";
1907 	}
1908 
1909 	/*
1910 	 * Clear LEDs as we have no way of reading their initial state. This is
1911 	 * only relevant if the driver is loaded after somebody actively set the
1912 	 * LEDs to on
1913 	 */
1914 	sony_set_leds(sc);
1915 
1916 	name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1917 
1918 	for (n = 0; n < sc->led_count; n++) {
1919 
1920 		if (use_ds4_names)
1921 			name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
1922 
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);
1926 			ret = -ENOMEM;
1927 			goto error_leds;
1928 		}
1929 
1930 		name = (void *)(&led[1]);
1931 		if (use_ds4_names)
1932 			snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1933 			ds4_name_str[n]);
1934 		else
1935 			snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1936 		led->name = name;
1937 		led->brightness = sc->led_state[n];
1938 		led->max_brightness = max_brightness[n];
1939 		led->brightness_get = sony_led_get_brightness;
1940 		led->brightness_set = sony_led_set_brightness;
1941 
1942 		if (use_hw_blink[n])
1943 			led->blink_set = sony_led_blink_set;
1944 
1945 		sc->leds[n] = led;
1946 
1947 		ret = led_classdev_register(&hdev->dev, led);
1948 		if (ret) {
1949 			hid_err(hdev, "Failed to register LED %d\n", n);
1950 			sc->leds[n] = NULL;
1951 			kfree(led);
1952 			goto error_leds;
1953 		}
1954 	}
1955 
1956 	return ret;
1957 
1958 error_leds:
1959 	sony_leds_remove(sc);
1960 
1961 	return ret;
1962 }
1963 
1964 static void sixaxis_send_output_report(struct sony_sc *sc)
1965 {
1966 	static const union sixaxis_output_report_01 default_report = {
1967 		.buf = {
1968 			0x01,
1969 			0x01, 0xff, 0x00, 0xff, 0x00,
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 		}
1977 	};
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));
1984 
1985 #ifdef CONFIG_SONY_FF
1986 	report->rumble.right_motor_on = sc->right ? 1 : 0;
1987 	report->rumble.left_motor_force = sc->left;
1988 #endif
1989 
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;
1994 
1995 	/* Set flag for all leds off, required for 3rd party INTEC controller */
1996 	if ((report->leds_bitmap & 0x1E) == 0)
1997 		report->leds_bitmap |= 0x20;
1998 
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]) {
2010 			report->led[3 - n].duty_off = sc->led_delay_off[n];
2011 			report->led[3 - n].duty_on = sc->led_delay_on[n];
2012 		}
2013 	}
2014 
2015 	hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2016 			sizeof(struct sixaxis_output_report),
2017 			HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2018 }
2019 
2020 static void dualshock4_send_output_report(struct sony_sc *sc)
2021 {
2022 	struct hid_device *hdev = sc->hdev;
2023 	u8 *buf = sc->output_report_dmabuf;
2024 	int offset;
2025 
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 	 */
2037 	if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
2038 		memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2039 		buf[0] = 0x05;
2040 		buf[1] = 0xFF;
2041 		offset = 4;
2042 	} else {
2043 		memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2044 		buf[0] = 0x11;
2045 		buf[1] = 0xC0; /* HID + CRC */
2046 		buf[3] = 0x0F;
2047 		offset = 6;
2048 	}
2049 
2050 #ifdef CONFIG_SONY_FF
2051 	buf[offset++] = sc->right;
2052 	buf[offset++] = sc->left;
2053 #else
2054 	offset += 2;
2055 #endif
2056 
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];
2069 
2070 	if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
2071 		hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
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 	}
2082 }
2083 
2084 static void motion_send_output_report(struct sony_sc *sc)
2085 {
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 
2090 	memset(report, 0, MOTION_REPORT_0x02_SIZE);
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 
2101 	hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2102 }
2103 
2104 static 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 
2110 static void sony_state_worker(struct work_struct *work)
2111 {
2112 	struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2113 
2114 	sc->send_output_report(sc);
2115 }
2116 
2117 static int sony_allocate_output_report(struct sony_sc *sc)
2118 {
2119 	if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2120 			(sc->quirks & NAVIGATION_CONTROLLER))
2121 		sc->output_report_dmabuf =
2122 			kmalloc(sizeof(union sixaxis_output_report_01),
2123 				GFP_KERNEL);
2124 	else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2125 		sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x11_SIZE,
2126 						GFP_KERNEL);
2127 	else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
2128 		sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x05_SIZE,
2129 						GFP_KERNEL);
2130 	else if (sc->quirks & MOTION_CONTROLLER)
2131 		sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
2132 						GFP_KERNEL);
2133 	else
2134 		return 0;
2135 
2136 	if (!sc->output_report_dmabuf)
2137 		return -ENOMEM;
2138 
2139 	return 0;
2140 }
2141 
2142 #ifdef CONFIG_SONY_FF
2143 static int sony_play_effect(struct input_dev *dev, void *data,
2144 			    struct ff_effect *effect)
2145 {
2146 	struct hid_device *hid = input_get_drvdata(dev);
2147 	struct sony_sc *sc = hid_get_drvdata(hid);
2148 
2149 	if (effect->type != FF_RUMBLE)
2150 		return 0;
2151 
2152 	sc->left = effect->u.rumble.strong_magnitude / 256;
2153 	sc->right = effect->u.rumble.weak_magnitude / 256;
2154 
2155 	sony_schedule_work(sc);
2156 	return 0;
2157 }
2158 
2159 static int sony_init_ff(struct sony_sc *sc)
2160 {
2161 	struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
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
2170 static int sony_init_ff(struct sony_sc *sc)
2171 {
2172 	return 0;
2173 }
2174 
2175 #endif
2176 
2177 static int sony_battery_get_property(struct power_supply *psy,
2178 				     enum power_supply_property psp,
2179 				     union power_supply_propval *val)
2180 {
2181 	struct sony_sc *sc = power_supply_get_drvdata(psy);
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;
2216 }
2217 
2218 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2219 {
2220 	const char *battery_str_fmt = append_dev_id ?
2221 		"sony_controller_battery_%pMR_%i" :
2222 		"sony_controller_battery_%pMR";
2223 	struct power_supply_config psy_cfg = { .drv_data = sc, };
2224 	struct hid_device *hdev = sc->hdev;
2225 	int ret;
2226 
2227 	/*
2228 	 * Set the default battery level to 100% to avoid low battery warnings
2229 	 * if the battery is polled before the first device report is received.
2230 	 */
2231 	sc->battery_capacity = 100;
2232 
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;
2238 	sc->battery_desc.name = kasprintf(GFP_KERNEL, battery_str_fmt,
2239 					  sc->mac_address, sc->device_id);
2240 	if (!sc->battery_desc.name)
2241 		return -ENOMEM;
2242 
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);
2247 		hid_err(hdev, "Unable to register battery device\n");
2248 		goto err_free;
2249 	}
2250 
2251 	power_supply_powers(sc->battery, &hdev->dev);
2252 	return 0;
2253 
2254 err_free:
2255 	kfree(sc->battery_desc.name);
2256 	sc->battery_desc.name = NULL;
2257 	return ret;
2258 }
2259 
2260 static void sony_battery_remove(struct sony_sc *sc)
2261 {
2262 	if (!sc->battery_desc.name)
2263 		return;
2264 
2265 	power_supply_unregister(sc->battery);
2266 	kfree(sc->battery_desc.name);
2267 	sc->battery_desc.name = NULL;
2268 }
2269 
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.
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.
2280  */
2281 static 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 
2290 static 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) {
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",
2308 				sc->mac_address);
2309 			}
2310 			goto unlock;
2311 		}
2312 	}
2313 
2314 	ret = 0;
2315 	list_add(&(sc->list_node), &sony_device_list);
2316 
2317 unlock:
2318 	spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2319 	return ret;
2320 }
2321 
2322 static void sony_remove_dev_list(struct sony_sc *sc)
2323 {
2324 	unsigned long flags;
2325 
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 	}
2331 }
2332 
2333 static 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 
2353 static int sony_check_add(struct sony_sc *sc)
2354 {
2355 	u8 *buf = NULL;
2356 	int n, ret;
2357 
2358 	if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2359 	    (sc->quirks & MOTION_CONTROLLER_BT) ||
2360 	    (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
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) {
2373 		buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2374 		if (!buf)
2375 			return -ENOMEM;
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 		 */
2382 		ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2383 				DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2384 				HID_REQ_GET_REPORT);
2385 
2386 		if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2387 			hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2388 			ret = ret < 0 ? ret : -EINVAL;
2389 			goto out_free;
2390 		}
2391 
2392 		memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2393 	} else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2394 			(sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2395 		buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2396 		if (!buf)
2397 			return -ENOMEM;
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 		 */
2404 		ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2405 				SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2406 				HID_REQ_GET_REPORT);
2407 
2408 		if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2409 			hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2410 			ret = ret < 0 ? ret : -EINVAL;
2411 			goto out_free;
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 
2424 	ret = sony_check_add_dev_list(sc);
2425 
2426 out_free:
2427 
2428 	kfree(buf);
2429 
2430 	return ret;
2431 }
2432 
2433 static 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 
2457 static 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 
2465 static inline void sony_init_output_report(struct sony_sc *sc,
2466 				void (*send_output_report)(struct sony_sc *))
2467 {
2468 	sc->send_output_report = send_output_report;
2469 
2470 	if (!sc->worker_initialized)
2471 		INIT_WORK(&sc->state_worker, sony_state_worker);
2472 
2473 	sc->worker_initialized = 1;
2474 }
2475 
2476 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2477 {
2478 	if (sc->worker_initialized)
2479 		cancel_work_sync(&sc->state_worker);
2480 }
2481 
2482 static int sony_input_configured(struct hid_device *hdev,
2483 					struct hid_input *hidinput)
2484 {
2485 	struct sony_sc *sc = hid_get_drvdata(hdev);
2486 	int append_dev_id;
2487 	int ret;
2488 
2489 	ret = sony_set_device_id(sc);
2490 	if (ret < 0) {
2491 		hid_err(hdev, "failed to allocate the device id\n");
2492 		goto err_stop;
2493 	}
2494 
2495 	ret = sony_allocate_output_report(sc);
2496 	if (ret < 0) {
2497 		hid_err(hdev, "failed to allocate the output report buffer\n");
2498 		goto err_stop;
2499 	}
2500 
2501 	if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2502 			(sc->quirks & NAVIGATION_CONTROLLER_USB)) {
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!
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.
2518 		 */
2519 		hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2520 		hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2521 		sc->defer_initialization = 1;
2522 		ret = sixaxis_set_operational_usb(hdev);
2523 		sony_init_output_report(sc, sixaxis_send_output_report);
2524 	} else if ((sc->quirks & SIXAXIS_CONTROLLER_BT) ||
2525 			(sc->quirks & NAVIGATION_CONTROLLER_BT)) {
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;
2531 		ret = sixaxis_set_operational_bt(hdev);
2532 		sony_init_output_report(sc, sixaxis_send_output_report);
2533 	} else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
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 		}
2541 
2542 		/*
2543 		 * The Dualshock 4 touchpad supports 2 touches and has a
2544 		 * resolution of 1920x942 (44.86 dots/mm).
2545 		 */
2546 		ret = sony_register_touchpad(sc, 2, 1920, 942);
2547 		if (ret) {
2548 			hid_err(sc->hdev,
2549 			"Unable to initialize multi-touch slots: %d\n",
2550 			ret);
2551 			return ret;
2552 		}
2553 
2554 		sony_init_output_report(sc, dualshock4_send_output_report);
2555 	} else if (sc->quirks & MOTION_CONTROLLER) {
2556 		sony_init_output_report(sc, motion_send_output_report);
2557 	} else {
2558 		ret = 0;
2559 	}
2560 
2561 	if (ret < 0)
2562 		goto err_stop;
2563 
2564 	ret = append_dev_id = sony_check_add(sc);
2565 	if (ret < 0)
2566 		goto err_stop;
2567 
2568 	if (sc->quirks & SONY_LED_SUPPORT) {
2569 		ret = sony_leds_init(sc);
2570 		if (ret < 0)
2571 			goto err_stop;
2572 	}
2573 
2574 	if (sc->quirks & SONY_BATTERY_SUPPORT) {
2575 		ret = sony_battery_probe(sc, append_dev_id);
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 
2587 	if (sc->quirks & SONY_FF_SUPPORT) {
2588 		ret = sony_init_ff(sc);
2589 		if (ret < 0)
2590 			goto err_close;
2591 	}
2592 
2593 	return 0;
2594 err_close:
2595 	hid_hw_close(hdev);
2596 err_stop:
2597 	if (sc->quirks & SONY_LED_SUPPORT)
2598 		sony_leds_remove(sc);
2599 	if (sc->quirks & SONY_BATTERY_SUPPORT)
2600 		sony_battery_remove(sc);
2601 	sony_cancel_work_sync(sc);
2602 	kfree(sc->output_report_dmabuf);
2603 	sony_remove_dev_list(sc);
2604 	sony_release_device_id(sc);
2605 	hid_hw_stop(hdev);
2606 	return ret;
2607 }
2608 
2609 static 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 
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 
2651 	ret = hid_hw_start(hdev, connect_mask);
2652 	if (ret) {
2653 		hid_err(hdev, "hw start failed\n");
2654 		return ret;
2655 	}
2656 
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 
2670 	return ret;
2671 }
2672 
2673 static void sony_remove(struct hid_device *hdev)
2674 {
2675 	struct sony_sc *sc = hid_get_drvdata(hdev);
2676 
2677 	hid_hw_close(hdev);
2678 
2679 	if (sc->quirks & SONY_LED_SUPPORT)
2680 		sony_leds_remove(sc);
2681 
2682 	if (sc->quirks & SONY_BATTERY_SUPPORT)
2683 		sony_battery_remove(sc);
2684 
2685 	if (sc->touchpad)
2686 		sony_unregister_touchpad(sc);
2687 
2688 	sony_cancel_work_sync(sc);
2689 
2690 	kfree(sc->output_report_dmabuf);
2691 
2692 	sony_remove_dev_list(sc);
2693 
2694 	sony_release_device_id(sc);
2695 
2696 	hid_hw_stop(hdev);
2697 }
2698 
2699 #ifdef CONFIG_PM
2700 
2701 static 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.
2706 	 */
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 
2724 static 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) ||
2738 			(sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2739 			sixaxis_set_operational_usb(sc->hdev);
2740 			sc->defer_initialization = 1;
2741 		}
2742 
2743 		sony_set_leds(sc);
2744 	}
2745 
2746 	return 0;
2747 }
2748 
2749 #endif
2750 
2751 static const struct hid_device_id sony_devices[] = {
2752 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2753 		.driver_data = SIXAXIS_CONTROLLER_USB },
2754 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2755 		.driver_data = NAVIGATION_CONTROLLER_USB },
2756 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2757 		.driver_data = NAVIGATION_CONTROLLER_BT },
2758 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2759 		.driver_data = MOTION_CONTROLLER_USB },
2760 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2761 		.driver_data = MOTION_CONTROLLER_BT },
2762 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2763 		.driver_data = SIXAXIS_CONTROLLER_BT },
2764 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2765 		.driver_data = VAIO_RDESC_CONSTANT },
2766 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2767 		.driver_data = VAIO_RDESC_CONSTANT },
2768 	/*
2769 	 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2770 	 * Logitech joystick from the device descriptor.
2771 	 */
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 },
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 },
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 },
2785 	/* Sony Dualshock 4 controllers for PS4 */
2786 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2787 		.driver_data = DUALSHOCK4_CONTROLLER_USB },
2788 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2789 		.driver_data = DUALSHOCK4_CONTROLLER_BT },
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 },
2794 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
2795 		.driver_data = DUALSHOCK4_CONTROLLER_USB },
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 },
2799 	{ }
2800 };
2801 MODULE_DEVICE_TABLE(hid, sony_devices);
2802 
2803 static struct hid_driver sony_driver = {
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,
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
2818 };
2819 
2820 static int __init sony_init(void)
2821 {
2822 	dbg_hid("Sony:%s\n", __func__);
2823 
2824 	return hid_register_driver(&sony_driver);
2825 }
2826 
2827 static void __exit sony_exit(void)
2828 {
2829 	dbg_hid("Sony:%s\n", __func__);
2830 
2831 	hid_unregister_driver(&sony_driver);
2832 	ida_destroy(&sony_device_id_allocator);
2833 }
2834 module_init(sony_init);
2835 module_exit(sony_exit);
2836 
2837 MODULE_LICENSE("GPL");
2838