Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4

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

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