Version:  2.0.40 2.2.26 2.4.37 2.6.39 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

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

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