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

Linux/drivers/hid/hid-sony.c

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

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