Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/hid/hid-sony.c

  1 /*
  2  *  HID driver for Sony / PS2 / PS3 BD devices.
  3  *
  4  *  Copyright (c) 1999 Andreas Gal
  5  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  6  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  7  *  Copyright (c) 2008 Jiri Slaby
  8  *  Copyright (c) 2012 David Dillow <dave@thedillows.org>
  9  *  Copyright (c) 2006-2013 Jiri Kosina
 10  *  Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
 11  */
 12 
 13 /*
 14  * This program is free software; you can redistribute it and/or modify it
 15  * under the terms of the GNU General Public License as published by the Free
 16  * Software Foundation; either version 2 of the License, or (at your option)
 17  * any later version.
 18  */
 19 
 20 /* NOTE: in order for the Sony PS3 BD Remote Control to be found by
 21  * a Bluetooth host, the key combination Start+Enter has to be kept pressed
 22  * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
 23  *
 24  * There will be no PIN request from the device.
 25  */
 26 
 27 #include <linux/device.h>
 28 #include <linux/hid.h>
 29 #include <linux/module.h>
 30 #include <linux/slab.h>
 31 #include <linux/usb.h>
 32 #include <linux/leds.h>
 33 
 34 #include "hid-ids.h"
 35 
 36 #define VAIO_RDESC_CONSTANT       BIT(0)
 37 #define SIXAXIS_CONTROLLER_USB    BIT(1)
 38 #define SIXAXIS_CONTROLLER_BT     BIT(2)
 39 #define BUZZ_CONTROLLER           BIT(3)
 40 #define PS3REMOTE                 BIT(4)
 41 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
 42 #define DUALSHOCK4_CONTROLLER_BT  BIT(6)
 43 
 44 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER_USB | BUZZ_CONTROLLER | DUALSHOCK4_CONTROLLER_USB)
 45 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER_USB | DUALSHOCK4_CONTROLLER_USB)
 46 
 47 #define MAX_LEDS 4
 48 
 49 static const u8 sixaxis_rdesc_fixup[] = {
 50         0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
 51         0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
 52         0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
 53 };
 54 
 55 static const u8 sixaxis_rdesc_fixup2[] = {
 56         0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
 57         0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
 58         0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
 59         0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
 60         0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
 61         0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
 62         0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
 63         0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
 64         0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
 65         0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
 66         0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
 67         0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
 68         0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
 69         0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
 70         0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
 71         0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
 72         0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
 73         0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
 74         0xb1, 0x02, 0xc0, 0xc0,
 75 };
 76 
 77 /* The default descriptor doesn't provide mapping for the accelerometers
 78  * or orientation sensors.  This fixed descriptor maps the accelerometers
 79  * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
 80  * to usage values 0x43, 0x44 and 0x45.
 81  */
 82 static u8 dualshock4_usb_rdesc[] = {
 83         0x05, 0x01,         /*  Usage Page (Desktop),               */
 84         0x09, 0x05,         /*  Usage (Gamepad),                    */
 85         0xA1, 0x01,         /*  Collection (Application),           */
 86         0x85, 0x01,         /*      Report ID (1),                  */
 87         0x09, 0x30,         /*      Usage (X),                      */
 88         0x09, 0x31,         /*      Usage (Y),                      */
 89         0x09, 0x32,         /*      Usage (Z),                      */
 90         0x09, 0x35,         /*      Usage (Rz),                     */
 91         0x15, 0x00,         /*      Logical Minimum (0),            */
 92         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
 93         0x75, 0x08,         /*      Report Size (8),                */
 94         0x95, 0x04,         /*      Report Count (4),               */
 95         0x81, 0x02,         /*      Input (Variable),               */
 96         0x09, 0x39,         /*      Usage (Hat Switch),             */
 97         0x15, 0x00,         /*      Logical Minimum (0),            */
 98         0x25, 0x07,         /*      Logical Maximum (7),            */
 99         0x35, 0x00,         /*      Physical Minimum (0),           */
100         0x46, 0x3B, 0x01,   /*      Physical Maximum (315),         */
101         0x65, 0x14,         /*      Unit (Degrees),                 */
102         0x75, 0x04,         /*      Report Size (4),                */
103         0x95, 0x01,         /*      Report Count (1),               */
104         0x81, 0x42,         /*      Input (Variable, Null State),   */
105         0x65, 0x00,         /*      Unit,                           */
106         0x05, 0x09,         /*      Usage Page (Button),            */
107         0x19, 0x01,         /*      Usage Minimum (01h),            */
108         0x29, 0x0E,         /*      Usage Maximum (0Eh),            */
109         0x15, 0x00,         /*      Logical Minimum (0),            */
110         0x25, 0x01,         /*      Logical Maximum (1),            */
111         0x75, 0x01,         /*      Report Size (1),                */
112         0x95, 0x0E,         /*      Report Count (14),              */
113         0x81, 0x02,         /*      Input (Variable),               */
114         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
115         0x09, 0x20,         /*      Usage (20h),                    */
116         0x75, 0x06,         /*      Report Size (6),                */
117         0x95, 0x01,         /*      Report Count (1),               */
118         0x15, 0x00,         /*      Logical Minimum (0),            */
119         0x25, 0x7F,         /*      Logical Maximum (127),          */
120         0x81, 0x02,         /*      Input (Variable),               */
121         0x05, 0x01,         /*      Usage Page (Desktop),           */
122         0x09, 0x33,         /*      Usage (Rx),                     */
123         0x09, 0x34,         /*      Usage (Ry),                     */
124         0x15, 0x00,         /*      Logical Minimum (0),            */
125         0x26, 0xFF, 0x00,   /*      Logical Maximum (255),          */
126         0x75, 0x08,         /*      Report Size (8),                */
127         0x95, 0x02,         /*      Report Count (2),               */
128         0x81, 0x02,         /*      Input (Variable),               */
129         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
130         0x09, 0x21,         /*      Usage (21h),                    */
131         0x95, 0x03,         /*      Report Count (3),               */
132         0x81, 0x02,         /*      Input (Variable),               */
133         0x05, 0x01,         /*      Usage Page (Desktop),           */
134         0x19, 0x40,         /*      Usage Minimum (40h),            */
135         0x29, 0x42,         /*      Usage Maximum (42h),            */
136         0x16, 0x00, 0x80,   /*      Logical Minimum (-32768),       */
137         0x26, 0x00, 0x7F,   /*      Logical Maximum (32767),        */
138         0x75, 0x10,         /*      Report Size (16),               */
139         0x95, 0x03,         /*      Report Count (3),               */
140         0x81, 0x02,         /*      Input (Variable),               */
141         0x19, 0x43,         /*      Usage Minimum (43h),            */
142         0x29, 0x45,         /*      Usage Maximum (45h),            */
143         0x16, 0xFF, 0xBF,   /*      Logical Minimum (-16385),       */
144         0x26, 0x00, 0x40,   /*      Logical Maximum (16384),        */
145         0x95, 0x03,         /*      Report Count (3),               */
146         0x81, 0x02,         /*      Input (Variable),               */
147         0x06, 0x00, 0xFF,   /*      Usage Page (FF00h),             */
148         0x09, 0x21,         /*      Usage (21h),                    */
149         0x15, 0x00,         /*      Logical Minimum (0),            */
150         0x25, 0xFF,         /*      Logical Maximum (255),          */
151         0x75, 0x08,         /*      Report Size (8),                */
152         0x95, 0x27,         /*      Report Count (39),              */
153         0x81, 0x02,         /*      Input (Variable),               */
154         0x85, 0x05,         /*      Report ID (5),                  */
155         0x09, 0x22,         /*      Usage (22h),                    */
156         0x95, 0x1F,         /*      Report Count (31),              */
157         0x91, 0x02,         /*      Output (Variable),              */
158         0x85, 0x04,         /*      Report ID (4),                  */
159         0x09, 0x23,         /*      Usage (23h),                    */
160         0x95, 0x24,         /*      Report Count (36),              */
161         0xB1, 0x02,         /*      Feature (Variable),             */
162         0x85, 0x02,         /*      Report ID (2),                  */
163         0x09, 0x24,         /*      Usage (24h),                    */
164         0x95, 0x24,         /*      Report Count (36),              */
165         0xB1, 0x02,         /*      Feature (Variable),             */
166         0x85, 0x08,         /*      Report ID (8),                  */
167         0x09, 0x25,         /*      Usage (25h),                    */
168         0x95, 0x03,         /*      Report Count (3),               */
169         0xB1, 0x02,         /*      Feature (Variable),             */
170         0x85, 0x10,         /*      Report ID (16),                 */
171         0x09, 0x26,         /*      Usage (26h),                    */
172         0x95, 0x04,         /*      Report Count (4),               */
173         0xB1, 0x02,         /*      Feature (Variable),             */
174         0x85, 0x11,         /*      Report ID (17),                 */
175         0x09, 0x27,         /*      Usage (27h),                    */
176         0x95, 0x02,         /*      Report Count (2),               */
177         0xB1, 0x02,         /*      Feature (Variable),             */
178         0x85, 0x12,         /*      Report ID (18),                 */
179         0x06, 0x02, 0xFF,   /*      Usage Page (FF02h),             */
180         0x09, 0x21,         /*      Usage (21h),                    */
181         0x95, 0x0F,         /*      Report Count (15),              */
182         0xB1, 0x02,         /*      Feature (Variable),             */
183         0x85, 0x13,         /*      Report ID (19),                 */
184         0x09, 0x22,         /*      Usage (22h),                    */
185         0x95, 0x16,         /*      Report Count (22),              */
186         0xB1, 0x02,         /*      Feature (Variable),             */
187         0x85, 0x14,         /*      Report ID (20),                 */
188         0x06, 0x05, 0xFF,   /*      Usage Page (FF05h),             */
189         0x09, 0x20,         /*      Usage (20h),                    */
190         0x95, 0x10,         /*      Report Count (16),              */
191         0xB1, 0x02,         /*      Feature (Variable),             */
192         0x85, 0x15,         /*      Report ID (21),                 */
193         0x09, 0x21,         /*      Usage (21h),                    */
194         0x95, 0x2C,         /*      Report Count (44),              */
195         0xB1, 0x02,         /*      Feature (Variable),             */
196         0x06, 0x80, 0xFF,   /*      Usage Page (FF80h),             */
197         0x85, 0x80,         /*      Report ID (128),                */
198         0x09, 0x20,         /*      Usage (20h),                    */
199         0x95, 0x06,         /*      Report Count (6),               */
200         0xB1, 0x02,         /*      Feature (Variable),             */
201         0x85, 0x81,         /*      Report ID (129),                */
202         0x09, 0x21,         /*      Usage (21h),                    */
203         0x95, 0x06,         /*      Report Count (6),               */
204         0xB1, 0x02,         /*      Feature (Variable),             */
205         0x85, 0x82,         /*      Report ID (130),                */
206         0x09, 0x22,         /*      Usage (22h),                    */
207         0x95, 0x05,         /*      Report Count (5),               */
208         0xB1, 0x02,         /*      Feature (Variable),             */
209         0x85, 0x83,         /*      Report ID (131),                */
210         0x09, 0x23,         /*      Usage (23h),                    */
211         0x95, 0x01,         /*      Report Count (1),               */
212         0xB1, 0x02,         /*      Feature (Variable),             */
213         0x85, 0x84,         /*      Report ID (132),                */
214         0x09, 0x24,         /*      Usage (24h),                    */
215         0x95, 0x04,         /*      Report Count (4),               */
216         0xB1, 0x02,         /*      Feature (Variable),             */
217         0x85, 0x85,         /*      Report ID (133),                */
218         0x09, 0x25,         /*      Usage (25h),                    */
219         0x95, 0x06,         /*      Report Count (6),               */
220         0xB1, 0x02,         /*      Feature (Variable),             */
221         0x85, 0x86,         /*      Report ID (134),                */
222         0x09, 0x26,         /*      Usage (26h),                    */
223         0x95, 0x06,         /*      Report Count (6),               */
224         0xB1, 0x02,         /*      Feature (Variable),             */
225         0x85, 0x87,         /*      Report ID (135),                */
226         0x09, 0x27,         /*      Usage (27h),                    */
227         0x95, 0x23,         /*      Report Count (35),              */
228         0xB1, 0x02,         /*      Feature (Variable),             */
229         0x85, 0x88,         /*      Report ID (136),                */
230         0x09, 0x28,         /*      Usage (28h),                    */
231         0x95, 0x22,         /*      Report Count (34),              */
232         0xB1, 0x02,         /*      Feature (Variable),             */
233         0x85, 0x89,         /*      Report ID (137),                */
234         0x09, 0x29,         /*      Usage (29h),                    */
235         0x95, 0x02,         /*      Report Count (2),               */
236         0xB1, 0x02,         /*      Feature (Variable),             */
237         0x85, 0x90,         /*      Report ID (144),                */
238         0x09, 0x30,         /*      Usage (30h),                    */
239         0x95, 0x05,         /*      Report Count (5),               */
240         0xB1, 0x02,         /*      Feature (Variable),             */
241         0x85, 0x91,         /*      Report ID (145),                */
242         0x09, 0x31,         /*      Usage (31h),                    */
243         0x95, 0x03,         /*      Report Count (3),               */
244         0xB1, 0x02,         /*      Feature (Variable),             */
245         0x85, 0x92,         /*      Report ID (146),                */
246         0x09, 0x32,         /*      Usage (32h),                    */
247         0x95, 0x03,         /*      Report Count (3),               */
248         0xB1, 0x02,         /*      Feature (Variable),             */
249         0x85, 0x93,         /*      Report ID (147),                */
250         0x09, 0x33,         /*      Usage (33h),                    */
251         0x95, 0x0C,         /*      Report Count (12),              */
252         0xB1, 0x02,         /*      Feature (Variable),             */
253         0x85, 0xA0,         /*      Report ID (160),                */
254         0x09, 0x40,         /*      Usage (40h),                    */
255         0x95, 0x06,         /*      Report Count (6),               */
256         0xB1, 0x02,         /*      Feature (Variable),             */
257         0x85, 0xA1,         /*      Report ID (161),                */
258         0x09, 0x41,         /*      Usage (41h),                    */
259         0x95, 0x01,         /*      Report Count (1),               */
260         0xB1, 0x02,         /*      Feature (Variable),             */
261         0x85, 0xA2,         /*      Report ID (162),                */
262         0x09, 0x42,         /*      Usage (42h),                    */
263         0x95, 0x01,         /*      Report Count (1),               */
264         0xB1, 0x02,         /*      Feature (Variable),             */
265         0x85, 0xA3,         /*      Report ID (163),                */
266         0x09, 0x43,         /*      Usage (43h),                    */
267         0x95, 0x30,         /*      Report Count (48),              */
268         0xB1, 0x02,         /*      Feature (Variable),             */
269         0x85, 0xA4,         /*      Report ID (164),                */
270         0x09, 0x44,         /*      Usage (44h),                    */
271         0x95, 0x0D,         /*      Report Count (13),              */
272         0xB1, 0x02,         /*      Feature (Variable),             */
273         0x85, 0xA5,         /*      Report ID (165),                */
274         0x09, 0x45,         /*      Usage (45h),                    */
275         0x95, 0x15,         /*      Report Count (21),              */
276         0xB1, 0x02,         /*      Feature (Variable),             */
277         0x85, 0xA6,         /*      Report ID (166),                */
278         0x09, 0x46,         /*      Usage (46h),                    */
279         0x95, 0x15,         /*      Report Count (21),              */
280         0xB1, 0x02,         /*      Feature (Variable),             */
281         0x85, 0xF0,         /*      Report ID (240),                */
282         0x09, 0x47,         /*      Usage (47h),                    */
283         0x95, 0x3F,         /*      Report Count (63),              */
284         0xB1, 0x02,         /*      Feature (Variable),             */
285         0x85, 0xF1,         /*      Report ID (241),                */
286         0x09, 0x48,         /*      Usage (48h),                    */
287         0x95, 0x3F,         /*      Report Count (63),              */
288         0xB1, 0x02,         /*      Feature (Variable),             */
289         0x85, 0xF2,         /*      Report ID (242),                */
290         0x09, 0x49,         /*      Usage (49h),                    */
291         0x95, 0x0F,         /*      Report Count (15),              */
292         0xB1, 0x02,         /*      Feature (Variable),             */
293         0x85, 0xA7,         /*      Report ID (167),                */
294         0x09, 0x4A,         /*      Usage (4Ah),                    */
295         0x95, 0x01,         /*      Report Count (1),               */
296         0xB1, 0x02,         /*      Feature (Variable),             */
297         0x85, 0xA8,         /*      Report ID (168),                */
298         0x09, 0x4B,         /*      Usage (4Bh),                    */
299         0x95, 0x01,         /*      Report Count (1),               */
300         0xB1, 0x02,         /*      Feature (Variable),             */
301         0x85, 0xA9,         /*      Report ID (169),                */
302         0x09, 0x4C,         /*      Usage (4Ch),                    */
303         0x95, 0x08,         /*      Report Count (8),               */
304         0xB1, 0x02,         /*      Feature (Variable),             */
305         0x85, 0xAA,         /*      Report ID (170),                */
306         0x09, 0x4E,         /*      Usage (4Eh),                    */
307         0x95, 0x01,         /*      Report Count (1),               */
308         0xB1, 0x02,         /*      Feature (Variable),             */
309         0x85, 0xAB,         /*      Report ID (171),                */
310         0x09, 0x4F,         /*      Usage (4Fh),                    */
311         0x95, 0x39,         /*      Report Count (57),              */
312         0xB1, 0x02,         /*      Feature (Variable),             */
313         0x85, 0xAC,         /*      Report ID (172),                */
314         0x09, 0x50,         /*      Usage (50h),                    */
315         0x95, 0x39,         /*      Report Count (57),              */
316         0xB1, 0x02,         /*      Feature (Variable),             */
317         0x85, 0xAD,         /*      Report ID (173),                */
318         0x09, 0x51,         /*      Usage (51h),                    */
319         0x95, 0x0B,         /*      Report Count (11),              */
320         0xB1, 0x02,         /*      Feature (Variable),             */
321         0x85, 0xAE,         /*      Report ID (174),                */
322         0x09, 0x52,         /*      Usage (52h),                    */
323         0x95, 0x01,         /*      Report Count (1),               */
324         0xB1, 0x02,         /*      Feature (Variable),             */
325         0x85, 0xAF,         /*      Report ID (175),                */
326         0x09, 0x53,         /*      Usage (53h),                    */
327         0x95, 0x02,         /*      Report Count (2),               */
328         0xB1, 0x02,         /*      Feature (Variable),             */
329         0x85, 0xB0,         /*      Report ID (176),                */
330         0x09, 0x54,         /*      Usage (54h),                    */
331         0x95, 0x3F,         /*      Report Count (63),              */
332         0xB1, 0x02,         /*      Feature (Variable),             */
333         0xC0                /*  End Collection                      */
334 };
335 
336 static __u8 ps3remote_rdesc[] = {
337         0x05, 0x01,          /* GUsagePage Generic Desktop */
338         0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
339         0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
340 
341          /* Use collection 1 for joypad buttons */
342          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
343 
344           /* Ignore the 1st byte, maybe it is used for a controller
345            * number but it's not needed for correct operation */
346           0x75, 0x08,        /* GReportSize 0x08 [8] */
347           0x95, 0x01,        /* GReportCount 0x01 [1] */
348           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
349 
350           /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
351            * buttons multiple keypresses are allowed */
352           0x05, 0x09,        /* GUsagePage Button */
353           0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
354           0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
355           0x14,              /* GLogicalMinimum [0] */
356           0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
357           0x75, 0x01,        /* GReportSize 0x01 [1] */
358           0x95, 0x18,        /* GReportCount 0x18 [24] */
359           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
360 
361           0xC0,              /* MEndCollection */
362 
363          /* Use collection 2 for remote control buttons */
364          0xA1, 0x02,         /* MCollection Logical (interrelated data) */
365 
366           /* 5th byte is used for remote control buttons */
367           0x05, 0x09,        /* GUsagePage Button */
368           0x18,              /* LUsageMinimum [No button pressed] */
369           0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
370           0x14,              /* GLogicalMinimum [0] */
371           0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
372           0x75, 0x08,        /* GReportSize 0x08 [8] */
373           0x95, 0x01,        /* GReportCount 0x01 [1] */
374           0x80,              /* MInput  */
375 
376           /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
377            * 0xff and 11th is for press indication */
378           0x75, 0x08,        /* GReportSize 0x08 [8] */
379           0x95, 0x06,        /* GReportCount 0x06 [6] */
380           0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
381 
382           /* 12th byte is for battery strength */
383           0x05, 0x06,        /* GUsagePage Generic Device Controls */
384           0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
385           0x14,              /* GLogicalMinimum [0] */
386           0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
387           0x75, 0x08,        /* GReportSize 0x08 [8] */
388           0x95, 0x01,        /* GReportCount 0x01 [1] */
389           0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
390 
391           0xC0,              /* MEndCollection */
392 
393          0xC0                /* MEndCollection [Game Pad] */
394 };
395 
396 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
397         [0x01] = KEY_SELECT,
398         [0x02] = BTN_THUMBL,            /* L3 */
399         [0x03] = BTN_THUMBR,            /* R3 */
400         [0x04] = BTN_START,
401         [0x05] = KEY_UP,
402         [0x06] = KEY_RIGHT,
403         [0x07] = KEY_DOWN,
404         [0x08] = KEY_LEFT,
405         [0x09] = BTN_TL2,               /* L2 */
406         [0x0a] = BTN_TR2,               /* R2 */
407         [0x0b] = BTN_TL,                /* L1 */
408         [0x0c] = BTN_TR,                /* R1 */
409         [0x0d] = KEY_OPTION,            /* options/triangle */
410         [0x0e] = KEY_BACK,              /* back/circle */
411         [0x0f] = BTN_0,                 /* cross */
412         [0x10] = KEY_SCREEN,            /* view/square */
413         [0x11] = KEY_HOMEPAGE,          /* PS button */
414         [0x14] = KEY_ENTER,
415 };
416 static const unsigned int ps3remote_keymap_remote_buttons[] = {
417         [0x00] = KEY_1,
418         [0x01] = KEY_2,
419         [0x02] = KEY_3,
420         [0x03] = KEY_4,
421         [0x04] = KEY_5,
422         [0x05] = KEY_6,
423         [0x06] = KEY_7,
424         [0x07] = KEY_8,
425         [0x08] = KEY_9,
426         [0x09] = KEY_0,
427         [0x0e] = KEY_ESC,               /* return */
428         [0x0f] = KEY_CLEAR,
429         [0x16] = KEY_EJECTCD,
430         [0x1a] = KEY_MENU,              /* top menu */
431         [0x28] = KEY_TIME,
432         [0x30] = KEY_PREVIOUS,
433         [0x31] = KEY_NEXT,
434         [0x32] = KEY_PLAY,
435         [0x33] = KEY_REWIND,            /* scan back */
436         [0x34] = KEY_FORWARD,           /* scan forward */
437         [0x38] = KEY_STOP,
438         [0x39] = KEY_PAUSE,
439         [0x40] = KEY_CONTEXT_MENU,      /* pop up/menu */
440         [0x60] = KEY_FRAMEBACK,         /* slow/step back */
441         [0x61] = KEY_FRAMEFORWARD,      /* slow/step forward */
442         [0x63] = KEY_SUBTITLE,
443         [0x64] = KEY_AUDIO,
444         [0x65] = KEY_ANGLE,
445         [0x70] = KEY_INFO,              /* display */
446         [0x80] = KEY_BLUE,
447         [0x81] = KEY_RED,
448         [0x82] = KEY_GREEN,
449         [0x83] = KEY_YELLOW,
450 };
451 
452 static const unsigned int buzz_keymap[] = {
453         /* The controller has 4 remote buzzers, each with one LED and 5
454          * buttons.
455          * 
456          * We use the mapping chosen by the controller, which is:
457          *
458          * Key          Offset
459          * -------------------
460          * Buzz              1
461          * Blue              5
462          * Orange            4
463          * Green             3
464          * Yellow            2
465          *
466          * So, for example, the orange button on the third buzzer is mapped to
467          * BTN_TRIGGER_HAPPY14
468          */
469         [ 1] = BTN_TRIGGER_HAPPY1,
470         [ 2] = BTN_TRIGGER_HAPPY2,
471         [ 3] = BTN_TRIGGER_HAPPY3,
472         [ 4] = BTN_TRIGGER_HAPPY4,
473         [ 5] = BTN_TRIGGER_HAPPY5,
474         [ 6] = BTN_TRIGGER_HAPPY6,
475         [ 7] = BTN_TRIGGER_HAPPY7,
476         [ 8] = BTN_TRIGGER_HAPPY8,
477         [ 9] = BTN_TRIGGER_HAPPY9,
478         [10] = BTN_TRIGGER_HAPPY10,
479         [11] = BTN_TRIGGER_HAPPY11,
480         [12] = BTN_TRIGGER_HAPPY12,
481         [13] = BTN_TRIGGER_HAPPY13,
482         [14] = BTN_TRIGGER_HAPPY14,
483         [15] = BTN_TRIGGER_HAPPY15,
484         [16] = BTN_TRIGGER_HAPPY16,
485         [17] = BTN_TRIGGER_HAPPY17,
486         [18] = BTN_TRIGGER_HAPPY18,
487         [19] = BTN_TRIGGER_HAPPY19,
488         [20] = BTN_TRIGGER_HAPPY20,
489 };
490 
491 struct sony_sc {
492         struct hid_device *hdev;
493         struct led_classdev *leds[MAX_LEDS];
494         struct hid_report *output_report;
495         unsigned long quirks;
496         struct work_struct state_worker;
497 
498 #ifdef CONFIG_SONY_FF
499         __u8 left;
500         __u8 right;
501 #endif
502 
503         __u8 worker_initialized;
504         __u8 led_state[MAX_LEDS];
505         __u8 led_count;
506 };
507 
508 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
509                              unsigned int *rsize)
510 {
511         *rsize = sizeof(ps3remote_rdesc);
512         return ps3remote_rdesc;
513 }
514 
515 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
516                              struct hid_field *field, struct hid_usage *usage,
517                              unsigned long **bit, int *max)
518 {
519         unsigned int key = usage->hid & HID_USAGE;
520 
521         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
522                 return -1;
523 
524         switch (usage->collection_index) {
525         case 1:
526                 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
527                         return -1;
528 
529                 key = ps3remote_keymap_joypad_buttons[key];
530                 if (!key)
531                         return -1;
532                 break;
533         case 2:
534                 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
535                         return -1;
536 
537                 key = ps3remote_keymap_remote_buttons[key];
538                 if (!key)
539                         return -1;
540                 break;
541         default:
542                 return -1;
543         }
544 
545         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
546         return 1;
547 }
548 
549 
550 /* Sony Vaio VGX has wrongly mouse pointer declared as constant */
551 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
552                 unsigned int *rsize)
553 {
554         struct sony_sc *sc = hid_get_drvdata(hdev);
555 
556         /*
557          * Some Sony RF receivers wrongly declare the mouse pointer as a
558          * a constant non-data variable.
559          */
560         if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
561             /* usage page: generic desktop controls */
562             /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
563             /* usage: mouse */
564             rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
565             /* input (usage page for x,y axes): constant, variable, relative */
566             rdesc[54] == 0x81 && rdesc[55] == 0x07) {
567                 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
568                 /* input: data, variable, relative */
569                 rdesc[55] = 0x06;
570         }
571 
572         /*
573          * The default Dualshock 4 USB descriptor doesn't assign
574          * the gyroscope values to corresponding axes so we need a
575          * modified one.
576          */
577         if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
578                 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
579                 rdesc = dualshock4_usb_rdesc;
580                 *rsize = sizeof(dualshock4_usb_rdesc);
581         }
582 
583         /* The HID descriptor exposed over BT has a trailing zero byte */
584         if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
585                         ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
586                         rdesc[83] == 0x75) {
587                 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
588                 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
589                         sizeof(sixaxis_rdesc_fixup));
590         } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
591                    *rsize > sizeof(sixaxis_rdesc_fixup2)) {
592                 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
593                          *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
594                 *rsize = sizeof(sixaxis_rdesc_fixup2);
595                 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
596         }
597 
598         if (sc->quirks & PS3REMOTE)
599                 return ps3remote_fixup(hdev, rdesc, rsize);
600 
601         return rdesc;
602 }
603 
604 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
605                 __u8 *rd, int size)
606 {
607         struct sony_sc *sc = hid_get_drvdata(hdev);
608 
609         /* Sixaxis HID report has acclerometers/gyro with MSByte first, this
610          * has to be BYTE_SWAPPED before passing up to joystick interface
611          */
612         if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) &&
613                         rd[0] == 0x01 && size == 49) {
614                 swap(rd[41], rd[42]);
615                 swap(rd[43], rd[44]);
616                 swap(rd[45], rd[46]);
617                 swap(rd[47], rd[48]);
618         }
619 
620         return 0;
621 }
622 
623 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
624                         struct hid_field *field, struct hid_usage *usage,
625                         unsigned long **bit, int *max)
626 {
627         struct sony_sc *sc = hid_get_drvdata(hdev);
628 
629         if (sc->quirks & BUZZ_CONTROLLER) {
630                 unsigned int key = usage->hid & HID_USAGE;
631 
632                 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
633                         return -1;
634 
635                 switch (usage->collection_index) {
636                 case 1:
637                         if (key >= ARRAY_SIZE(buzz_keymap))
638                                 return -1;
639 
640                         key = buzz_keymap[key];
641                         if (!key)
642                                 return -1;
643                         break;
644                 default:
645                         return -1;
646                 }
647 
648                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
649                 return 1;
650         }
651 
652         if (sc->quirks & PS3REMOTE)
653                 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
654 
655         /* Let hid-core decide for the others */
656         return 0;
657 }
658 
659 /*
660  * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
661  * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
662  * so we need to override that forcing HID Output Reports on the Control EP.
663  *
664  * There is also another issue about HID Output Reports via USB, the Sixaxis
665  * does not want the report_id as part of the data packet, so we have to
666  * discard buf[0] when sending the actual control message, even for numbered
667  * reports, humpf!
668  */
669 static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
670                 size_t count, unsigned char report_type)
671 {
672         struct usb_interface *intf = to_usb_interface(hid->dev.parent);
673         struct usb_device *dev = interface_to_usbdev(intf);
674         struct usb_host_interface *interface = intf->cur_altsetting;
675         int report_id = buf[0];
676         int ret;
677 
678         if (report_type == HID_OUTPUT_REPORT) {
679                 /* Don't send the Report ID */
680                 buf++;
681                 count--;
682         }
683 
684         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
685                 HID_REQ_SET_REPORT,
686                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
687                 ((report_type + 1) << 8) | report_id,
688                 interface->desc.bInterfaceNumber, buf, count,
689                 USB_CTRL_SET_TIMEOUT);
690 
691         /* Count also the Report ID, in case of an Output report. */
692         if (ret > 0 && report_type == HID_OUTPUT_REPORT)
693                 ret++;
694 
695         return ret;
696 }
697 
698 /*
699  * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
700  * to "operational".  Without this, the ps3 controller will not report any
701  * events.
702  */
703 static int sixaxis_set_operational_usb(struct hid_device *hdev)
704 {
705         int ret;
706         char *buf = kmalloc(18, GFP_KERNEL);
707 
708         if (!buf)
709                 return -ENOMEM;
710 
711         ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT);
712 
713         if (ret < 0)
714                 hid_err(hdev, "can't set operational mode\n");
715 
716         kfree(buf);
717 
718         return ret;
719 }
720 
721 static int sixaxis_set_operational_bt(struct hid_device *hdev)
722 {
723         unsigned char buf[] = { 0xf4,  0x42, 0x03, 0x00, 0x00 };
724         return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
725 }
726 
727 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
728 {
729         struct list_head *report_list =
730                 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
731         struct hid_report *report = list_entry(report_list->next,
732                 struct hid_report, list);
733         __s32 *value = report->field[0]->value;
734 
735         value[0] = 0x00;
736         value[1] = leds[0] ? 0xff : 0x00;
737         value[2] = leds[1] ? 0xff : 0x00;
738         value[3] = leds[2] ? 0xff : 0x00;
739         value[4] = leds[3] ? 0xff : 0x00;
740         value[5] = 0x00;
741         value[6] = 0x00;
742         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
743 }
744 
745 static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
746 {
747         struct sony_sc *drv_data = hid_get_drvdata(hdev);
748         int n;
749 
750         BUG_ON(count > MAX_LEDS);
751 
752         if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
753                 buzz_set_leds(hdev, leds);
754         } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) ||
755                    (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
756                 for (n = 0; n < count; n++)
757                         drv_data->led_state[n] = leds[n];
758                 schedule_work(&drv_data->state_worker);
759         }
760 }
761 
762 static void sony_led_set_brightness(struct led_classdev *led,
763                                     enum led_brightness value)
764 {
765         struct device *dev = led->dev->parent;
766         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
767         struct sony_sc *drv_data;
768 
769         int n;
770 
771         drv_data = hid_get_drvdata(hdev);
772         if (!drv_data) {
773                 hid_err(hdev, "No device data\n");
774                 return;
775         }
776 
777         for (n = 0; n < drv_data->led_count; n++) {
778                 if (led == drv_data->leds[n]) {
779                         if (value != drv_data->led_state[n]) {
780                                 drv_data->led_state[n] = value;
781                                 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
782                         }
783                         break;
784                 }
785         }
786 }
787 
788 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
789 {
790         struct device *dev = led->dev->parent;
791         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
792         struct sony_sc *drv_data;
793 
794         int n;
795         int on = 0;
796 
797         drv_data = hid_get_drvdata(hdev);
798         if (!drv_data) {
799                 hid_err(hdev, "No device data\n");
800                 return LED_OFF;
801         }
802 
803         for (n = 0; n < drv_data->led_count; n++) {
804                 if (led == drv_data->leds[n]) {
805                         on = !!(drv_data->led_state[n]);
806                         break;
807                 }
808         }
809 
810         return on ? LED_FULL : LED_OFF;
811 }
812 
813 static void sony_leds_remove(struct hid_device *hdev)
814 {
815         struct sony_sc *drv_data;
816         struct led_classdev *led;
817         int n;
818 
819         drv_data = hid_get_drvdata(hdev);
820         BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
821 
822         for (n = 0; n < drv_data->led_count; n++) {
823                 led = drv_data->leds[n];
824                 drv_data->leds[n] = NULL;
825                 if (!led)
826                         continue;
827                 led_classdev_unregister(led);
828                 kfree(led);
829         }
830 
831         drv_data->led_count = 0;
832 }
833 
834 static int sony_leds_init(struct hid_device *hdev)
835 {
836         struct sony_sc *drv_data;
837         int n, ret = 0;
838         int max_brightness;
839         int use_colors;
840         struct led_classdev *led;
841         size_t name_sz;
842         char *name;
843         size_t name_len;
844         const char *name_fmt;
845         static const char * const color_str[] = { "red", "green", "blue" };
846         static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
847 
848         drv_data = hid_get_drvdata(hdev);
849         BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
850 
851         if (drv_data->quirks & BUZZ_CONTROLLER) {
852                 drv_data->led_count = 4;
853                 max_brightness = 1;
854                 use_colors = 0;
855                 name_len = strlen("::buzz#");
856                 name_fmt = "%s::buzz%d";
857                 /* Validate expected report characteristics. */
858                 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
859                         return -ENODEV;
860         } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) {
861                 drv_data->led_count = 3;
862                 max_brightness = 255;
863                 use_colors = 1;
864                 name_len = 0;
865                 name_fmt = "%s:%s";
866         } else {
867                 drv_data->led_count = 4;
868                 max_brightness = 1;
869                 use_colors = 0;
870                 name_len = strlen("::sony#");
871                 name_fmt = "%s::sony%d";
872         }
873 
874         /* Clear LEDs as we have no way of reading their initial state. This is
875          * only relevant if the driver is loaded after somebody actively set the
876          * LEDs to on */
877         sony_set_leds(hdev, initial_values, drv_data->led_count);
878 
879         name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
880 
881         for (n = 0; n < drv_data->led_count; n++) {
882 
883                 if (use_colors)
884                         name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
885 
886                 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
887                 if (!led) {
888                         hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
889                         ret = -ENOMEM;
890                         goto error_leds;
891                 }
892 
893                 name = (void *)(&led[1]);
894                 if (use_colors)
895                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
896                 else
897                         snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
898                 led->name = name;
899                 led->brightness = 0;
900                 led->max_brightness = max_brightness;
901                 led->brightness_get = sony_led_get_brightness;
902                 led->brightness_set = sony_led_set_brightness;
903 
904                 ret = led_classdev_register(&hdev->dev, led);
905                 if (ret) {
906                         hid_err(hdev, "Failed to register LED %d\n", n);
907                         kfree(led);
908                         goto error_leds;
909                 }
910 
911                 drv_data->leds[n] = led;
912         }
913 
914         return ret;
915 
916 error_leds:
917         sony_leds_remove(hdev);
918 
919         return ret;
920 }
921 
922 static void sixaxis_state_worker(struct work_struct *work)
923 {
924         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
925         unsigned char buf[] = {
926                 0x01,
927                 0x00, 0xff, 0x00, 0xff, 0x00,
928                 0x00, 0x00, 0x00, 0x00, 0x00,
929                 0xff, 0x27, 0x10, 0x00, 0x32,
930                 0xff, 0x27, 0x10, 0x00, 0x32,
931                 0xff, 0x27, 0x10, 0x00, 0x32,
932                 0xff, 0x27, 0x10, 0x00, 0x32,
933                 0x00, 0x00, 0x00, 0x00, 0x00
934         };
935 
936 #ifdef CONFIG_SONY_FF
937         buf[3] = sc->right ? 1 : 0;
938         buf[5] = sc->left;
939 #endif
940 
941         buf[10] |= sc->led_state[0] << 1;
942         buf[10] |= sc->led_state[1] << 2;
943         buf[10] |= sc->led_state[2] << 3;
944         buf[10] |= sc->led_state[3] << 4;
945 
946         sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf),
947                                         HID_OUTPUT_REPORT);
948 }
949 
950 static void dualshock4_state_worker(struct work_struct *work)
951 {
952         struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
953         struct hid_device *hdev = sc->hdev;
954         struct hid_report *report = sc->output_report;
955         __s32 *value = report->field[0]->value;
956 
957         value[0] = 0x03;
958 
959 #ifdef CONFIG_SONY_FF
960         value[3] = sc->right;
961         value[4] = sc->left;
962 #endif
963 
964         value[5] = sc->led_state[0];
965         value[6] = sc->led_state[1];
966         value[7] = sc->led_state[2];
967 
968         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
969 }
970 
971 #ifdef CONFIG_SONY_FF
972 static int sony_play_effect(struct input_dev *dev, void *data,
973                             struct ff_effect *effect)
974 {
975         struct hid_device *hid = input_get_drvdata(dev);
976         struct sony_sc *sc = hid_get_drvdata(hid);
977 
978         if (effect->type != FF_RUMBLE)
979                 return 0;
980 
981         sc->left = effect->u.rumble.strong_magnitude / 256;
982         sc->right = effect->u.rumble.weak_magnitude / 256;
983 
984         schedule_work(&sc->state_worker);
985         return 0;
986 }
987 
988 static int sony_init_ff(struct hid_device *hdev)
989 {
990         struct hid_input *hidinput = list_entry(hdev->inputs.next,
991                                                 struct hid_input, list);
992         struct input_dev *input_dev = hidinput->input;
993 
994         input_set_capability(input_dev, EV_FF, FF_RUMBLE);
995         return input_ff_create_memless(input_dev, NULL, sony_play_effect);
996 }
997 
998 #else
999 static int sony_init_ff(struct hid_device *hdev)
1000 {
1001         return 0;
1002 }
1003 #endif
1004 
1005 static int sony_set_output_report(struct sony_sc *sc, int req_id, int req_size)
1006 {
1007         struct list_head *head, *list;
1008         struct hid_report *report;
1009         struct hid_device *hdev = sc->hdev;
1010 
1011         list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1012 
1013         list_for_each(head, list) {
1014                 report = list_entry(head, struct hid_report, list);
1015 
1016                 if (report->id == req_id) {
1017                         if (report->size < req_size) {
1018                                 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n",
1019                                         req_id, report->size, req_size);
1020                                 return -EINVAL;
1021                         }
1022                         sc->output_report = report;
1023                         return 0;
1024                 }
1025         }
1026 
1027         hid_err(hdev, "Unable to locate output report 0x%02x\n", req_id);
1028 
1029         return -EINVAL;
1030 }
1031 
1032 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1033 {
1034         int ret;
1035         unsigned long quirks = id->driver_data;
1036         struct sony_sc *sc;
1037         unsigned int connect_mask = HID_CONNECT_DEFAULT;
1038 
1039         sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1040         if (sc == NULL) {
1041                 hid_err(hdev, "can't alloc sony descriptor\n");
1042                 return -ENOMEM;
1043         }
1044 
1045         sc->quirks = quirks;
1046         hid_set_drvdata(hdev, sc);
1047         sc->hdev = hdev;
1048 
1049         ret = hid_parse(hdev);
1050         if (ret) {
1051                 hid_err(hdev, "parse failed\n");
1052                 return ret;
1053         }
1054 
1055         if (sc->quirks & VAIO_RDESC_CONSTANT)
1056                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1057         else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1058                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1059         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1060                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1061 
1062         ret = hid_hw_start(hdev, connect_mask);
1063         if (ret) {
1064                 hid_err(hdev, "hw start failed\n");
1065                 return ret;
1066         }
1067 
1068         if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1069                 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
1070                 ret = sixaxis_set_operational_usb(hdev);
1071 
1072                 sc->worker_initialized = 1;
1073                 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1074         }
1075         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1076                 ret = sixaxis_set_operational_bt(hdev);
1077         else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1078                 /* Report 5 (31 bytes) is used to send data to the controller via USB */
1079                 ret = sony_set_output_report(sc, 0x05, 248);
1080                 if (ret < 0)
1081                         goto err_stop;
1082 
1083                 sc->worker_initialized = 1;
1084                 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1085         } else {
1086                 ret = 0;
1087         }
1088 
1089         if (ret < 0)
1090                 goto err_stop;
1091 
1092         if (sc->quirks & SONY_LED_SUPPORT) {
1093                 ret = sony_leds_init(hdev);
1094                 if (ret < 0)
1095                         goto err_stop;
1096         }
1097 
1098         if (sc->quirks & SONY_FF_SUPPORT) {
1099                 ret = sony_init_ff(hdev);
1100                 if (ret < 0)
1101                         goto err_stop;
1102         }
1103 
1104         return 0;
1105 err_stop:
1106         if (sc->quirks & SONY_LED_SUPPORT)
1107                 sony_leds_remove(hdev);
1108         hid_hw_stop(hdev);
1109         return ret;
1110 }
1111 
1112 static void sony_remove(struct hid_device *hdev)
1113 {
1114         struct sony_sc *sc = hid_get_drvdata(hdev);
1115 
1116         if (sc->quirks & SONY_LED_SUPPORT)
1117                 sony_leds_remove(hdev);
1118 
1119         if (sc->worker_initialized)
1120                 cancel_work_sync(&sc->state_worker);
1121 
1122         hid_hw_stop(hdev);
1123 }
1124 
1125 static const struct hid_device_id sony_devices[] = {
1126         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1127                 .driver_data = SIXAXIS_CONTROLLER_USB },
1128         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1129                 .driver_data = SIXAXIS_CONTROLLER_USB },
1130         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1131                 .driver_data = SIXAXIS_CONTROLLER_BT },
1132         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1133                 .driver_data = VAIO_RDESC_CONSTANT },
1134         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1135                 .driver_data = VAIO_RDESC_CONSTANT },
1136         /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1137          * Logitech joystick from the device descriptor. */
1138         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1139                 .driver_data = BUZZ_CONTROLLER },
1140         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1141                 .driver_data = BUZZ_CONTROLLER },
1142         /* PS3 BD Remote Control */
1143         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1144                 .driver_data = PS3REMOTE },
1145         /* Logitech Harmony Adapter for PS3 */
1146         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1147                 .driver_data = PS3REMOTE },
1148         /* Sony Dualshock 4 controllers for PS4 */
1149         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1150                 .driver_data = DUALSHOCK4_CONTROLLER_USB },
1151         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1152                 .driver_data = DUALSHOCK4_CONTROLLER_BT },
1153         { }
1154 };
1155 MODULE_DEVICE_TABLE(hid, sony_devices);
1156 
1157 static struct hid_driver sony_driver = {
1158         .name          = "sony",
1159         .id_table      = sony_devices,
1160         .input_mapping = sony_mapping,
1161         .probe         = sony_probe,
1162         .remove        = sony_remove,
1163         .report_fixup  = sony_report_fixup,
1164         .raw_event     = sony_raw_event
1165 };
1166 module_hid_driver(sony_driver);
1167 
1168 MODULE_LICENSE("GPL");
1169 

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