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