Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/hid/hid-sony.c

  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 

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