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