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

Linux/drivers/hid/hid-sony.c

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

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