Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us