Version:  2.0.40 2.2.26 2.4.37 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 4.5 4.6 4.7 4.8 4.9

Linux/drivers/hid/hid-sony.c

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

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