2 * HID driver for Sony / PS2 / PS3 BD devices.
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>
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)
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.
24 * There will be no PIN request from the device.
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>
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)
44 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER_USB | BUZZ_CONTROLLER | DUALSHOCK4_CONTROLLER_USB)
48 static const u8 sixaxis_rdesc_fixup[] = {
49 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
50 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
51 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
54 static const u8 sixaxis_rdesc_fixup2[] = {
55 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
56 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
57 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
58 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
59 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
60 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
61 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
62 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
63 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
64 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
65 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
66 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
67 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
68 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
69 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
70 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
71 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
72 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
73 0xb1, 0x02, 0xc0, 0xc0,
76 /* The default descriptor doesn't provide mapping for the accelerometers
77 * or orientation sensors. This fixed descriptor maps the accelerometers
78 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
79 * to usage values 0x43, 0x44 and 0x45.
81 static u8 dualshock4_usb_rdesc[] = {
82 0x05, 0x01, /* Usage Page (Desktop), */
83 0x09, 0x05, /* Usage (Gamepad), */
84 0xA1, 0x01, /* Collection (Application), */
85 0x85, 0x01, /* Report ID (1), */
86 0x09, 0x30, /* Usage (X), */
87 0x09, 0x31, /* Usage (Y), */
88 0x09, 0x32, /* Usage (Z), */
89 0x09, 0x35, /* Usage (Rz), */
90 0x15, 0x00, /* Logical Minimum (0), */
91 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
92 0x75, 0x08, /* Report Size (8), */
93 0x95, 0x04, /* Report Count (4), */
94 0x81, 0x02, /* Input (Variable), */
95 0x09, 0x39, /* Usage (Hat Switch), */
96 0x15, 0x00, /* Logical Minimum (0), */
97 0x25, 0x07, /* Logical Maximum (7), */
98 0x35, 0x00, /* Physical Minimum (0), */
99 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
100 0x65, 0x14, /* Unit (Degrees), */
101 0x75, 0x04, /* Report Size (4), */
102 0x95, 0x01, /* Report Count (1), */
103 0x81, 0x42, /* Input (Variable, Null State), */
104 0x65, 0x00, /* Unit, */
105 0x05, 0x09, /* Usage Page (Button), */
106 0x19, 0x01, /* Usage Minimum (01h), */
107 0x29, 0x0E, /* Usage Maximum (0Eh), */
108 0x15, 0x00, /* Logical Minimum (0), */
109 0x25, 0x01, /* Logical Maximum (1), */
110 0x75, 0x01, /* Report Size (1), */
111 0x95, 0x0E, /* Report Count (14), */
112 0x81, 0x02, /* Input (Variable), */
113 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
114 0x09, 0x20, /* Usage (20h), */
115 0x75, 0x06, /* Report Size (6), */
116 0x95, 0x01, /* Report Count (1), */
117 0x15, 0x00, /* Logical Minimum (0), */
118 0x25, 0x7F, /* Logical Maximum (127), */
119 0x81, 0x02, /* Input (Variable), */
120 0x05, 0x01, /* Usage Page (Desktop), */
121 0x09, 0x33, /* Usage (Rx), */
122 0x09, 0x34, /* Usage (Ry), */
123 0x15, 0x00, /* Logical Minimum (0), */
124 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
125 0x75, 0x08, /* Report Size (8), */
126 0x95, 0x02, /* Report Count (2), */
127 0x81, 0x02, /* Input (Variable), */
128 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
129 0x09, 0x21, /* Usage (21h), */
130 0x95, 0x03, /* Report Count (3), */
131 0x81, 0x02, /* Input (Variable), */
132 0x05, 0x01, /* Usage Page (Desktop), */
133 0x19, 0x40, /* Usage Minimum (40h), */
134 0x29, 0x42, /* Usage Maximum (42h), */
135 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
136 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
137 0x75, 0x10, /* Report Size (16), */
138 0x95, 0x03, /* Report Count (3), */
139 0x81, 0x02, /* Input (Variable), */
140 0x19, 0x43, /* Usage Minimum (43h), */
141 0x29, 0x45, /* Usage Maximum (45h), */
142 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
143 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
144 0x95, 0x03, /* Report Count (3), */
145 0x81, 0x02, /* Input (Variable), */
146 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
147 0x09, 0x21, /* Usage (21h), */
148 0x15, 0x00, /* Logical Minimum (0), */
149 0x25, 0xFF, /* Logical Maximum (255), */
150 0x75, 0x08, /* Report Size (8), */
151 0x95, 0x27, /* Report Count (39), */
152 0x81, 0x02, /* Input (Variable), */
153 0x85, 0x05, /* Report ID (5), */
154 0x09, 0x22, /* Usage (22h), */
155 0x95, 0x1F, /* Report Count (31), */
156 0x91, 0x02, /* Output (Variable), */
157 0x85, 0x04, /* Report ID (4), */
158 0x09, 0x23, /* Usage (23h), */
159 0x95, 0x24, /* Report Count (36), */
160 0xB1, 0x02, /* Feature (Variable), */
161 0x85, 0x02, /* Report ID (2), */
162 0x09, 0x24, /* Usage (24h), */
163 0x95, 0x24, /* Report Count (36), */
164 0xB1, 0x02, /* Feature (Variable), */
165 0x85, 0x08, /* Report ID (8), */
166 0x09, 0x25, /* Usage (25h), */
167 0x95, 0x03, /* Report Count (3), */
168 0xB1, 0x02, /* Feature (Variable), */
169 0x85, 0x10, /* Report ID (16), */
170 0x09, 0x26, /* Usage (26h), */
171 0x95, 0x04, /* Report Count (4), */
172 0xB1, 0x02, /* Feature (Variable), */
173 0x85, 0x11, /* Report ID (17), */
174 0x09, 0x27, /* Usage (27h), */
175 0x95, 0x02, /* Report Count (2), */
176 0xB1, 0x02, /* Feature (Variable), */
177 0x85, 0x12, /* Report ID (18), */
178 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
179 0x09, 0x21, /* Usage (21h), */
180 0x95, 0x0F, /* Report Count (15), */
181 0xB1, 0x02, /* Feature (Variable), */
182 0x85, 0x13, /* Report ID (19), */
183 0x09, 0x22, /* Usage (22h), */
184 0x95, 0x16, /* Report Count (22), */
185 0xB1, 0x02, /* Feature (Variable), */
186 0x85, 0x14, /* Report ID (20), */
187 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
188 0x09, 0x20, /* Usage (20h), */
189 0x95, 0x10, /* Report Count (16), */
190 0xB1, 0x02, /* Feature (Variable), */
191 0x85, 0x15, /* Report ID (21), */
192 0x09, 0x21, /* Usage (21h), */
193 0x95, 0x2C, /* Report Count (44), */
194 0xB1, 0x02, /* Feature (Variable), */
195 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
196 0x85, 0x80, /* Report ID (128), */
197 0x09, 0x20, /* Usage (20h), */
198 0x95, 0x06, /* Report Count (6), */
199 0xB1, 0x02, /* Feature (Variable), */
200 0x85, 0x81, /* Report ID (129), */
201 0x09, 0x21, /* Usage (21h), */
202 0x95, 0x06, /* Report Count (6), */
203 0xB1, 0x02, /* Feature (Variable), */
204 0x85, 0x82, /* Report ID (130), */
205 0x09, 0x22, /* Usage (22h), */
206 0x95, 0x05, /* Report Count (5), */
207 0xB1, 0x02, /* Feature (Variable), */
208 0x85, 0x83, /* Report ID (131), */
209 0x09, 0x23, /* Usage (23h), */
210 0x95, 0x01, /* Report Count (1), */
211 0xB1, 0x02, /* Feature (Variable), */
212 0x85, 0x84, /* Report ID (132), */
213 0x09, 0x24, /* Usage (24h), */
214 0x95, 0x04, /* Report Count (4), */
215 0xB1, 0x02, /* Feature (Variable), */
216 0x85, 0x85, /* Report ID (133), */
217 0x09, 0x25, /* Usage (25h), */
218 0x95, 0x06, /* Report Count (6), */
219 0xB1, 0x02, /* Feature (Variable), */
220 0x85, 0x86, /* Report ID (134), */
221 0x09, 0x26, /* Usage (26h), */
222 0x95, 0x06, /* Report Count (6), */
223 0xB1, 0x02, /* Feature (Variable), */
224 0x85, 0x87, /* Report ID (135), */
225 0x09, 0x27, /* Usage (27h), */
226 0x95, 0x23, /* Report Count (35), */
227 0xB1, 0x02, /* Feature (Variable), */
228 0x85, 0x88, /* Report ID (136), */
229 0x09, 0x28, /* Usage (28h), */
230 0x95, 0x22, /* Report Count (34), */
231 0xB1, 0x02, /* Feature (Variable), */
232 0x85, 0x89, /* Report ID (137), */
233 0x09, 0x29, /* Usage (29h), */
234 0x95, 0x02, /* Report Count (2), */
235 0xB1, 0x02, /* Feature (Variable), */
236 0x85, 0x90, /* Report ID (144), */
237 0x09, 0x30, /* Usage (30h), */
238 0x95, 0x05, /* Report Count (5), */
239 0xB1, 0x02, /* Feature (Variable), */
240 0x85, 0x91, /* Report ID (145), */
241 0x09, 0x31, /* Usage (31h), */
242 0x95, 0x03, /* Report Count (3), */
243 0xB1, 0x02, /* Feature (Variable), */
244 0x85, 0x92, /* Report ID (146), */
245 0x09, 0x32, /* Usage (32h), */
246 0x95, 0x03, /* Report Count (3), */
247 0xB1, 0x02, /* Feature (Variable), */
248 0x85, 0x93, /* Report ID (147), */
249 0x09, 0x33, /* Usage (33h), */
250 0x95, 0x0C, /* Report Count (12), */
251 0xB1, 0x02, /* Feature (Variable), */
252 0x85, 0xA0, /* Report ID (160), */
253 0x09, 0x40, /* Usage (40h), */
254 0x95, 0x06, /* Report Count (6), */
255 0xB1, 0x02, /* Feature (Variable), */
256 0x85, 0xA1, /* Report ID (161), */
257 0x09, 0x41, /* Usage (41h), */
258 0x95, 0x01, /* Report Count (1), */
259 0xB1, 0x02, /* Feature (Variable), */
260 0x85, 0xA2, /* Report ID (162), */
261 0x09, 0x42, /* Usage (42h), */
262 0x95, 0x01, /* Report Count (1), */
263 0xB1, 0x02, /* Feature (Variable), */
264 0x85, 0xA3, /* Report ID (163), */
265 0x09, 0x43, /* Usage (43h), */
266 0x95, 0x30, /* Report Count (48), */
267 0xB1, 0x02, /* Feature (Variable), */
268 0x85, 0xA4, /* Report ID (164), */
269 0x09, 0x44, /* Usage (44h), */
270 0x95, 0x0D, /* Report Count (13), */
271 0xB1, 0x02, /* Feature (Variable), */
272 0x85, 0xA5, /* Report ID (165), */
273 0x09, 0x45, /* Usage (45h), */
274 0x95, 0x15, /* Report Count (21), */
275 0xB1, 0x02, /* Feature (Variable), */
276 0x85, 0xA6, /* Report ID (166), */
277 0x09, 0x46, /* Usage (46h), */
278 0x95, 0x15, /* Report Count (21), */
279 0xB1, 0x02, /* Feature (Variable), */
280 0x85, 0xF0, /* Report ID (240), */
281 0x09, 0x47, /* Usage (47h), */
282 0x95, 0x3F, /* Report Count (63), */
283 0xB1, 0x02, /* Feature (Variable), */
284 0x85, 0xF1, /* Report ID (241), */
285 0x09, 0x48, /* Usage (48h), */
286 0x95, 0x3F, /* Report Count (63), */
287 0xB1, 0x02, /* Feature (Variable), */
288 0x85, 0xF2, /* Report ID (242), */
289 0x09, 0x49, /* Usage (49h), */
290 0x95, 0x0F, /* Report Count (15), */
291 0xB1, 0x02, /* Feature (Variable), */
292 0x85, 0xA7, /* Report ID (167), */
293 0x09, 0x4A, /* Usage (4Ah), */
294 0x95, 0x01, /* Report Count (1), */
295 0xB1, 0x02, /* Feature (Variable), */
296 0x85, 0xA8, /* Report ID (168), */
297 0x09, 0x4B, /* Usage (4Bh), */
298 0x95, 0x01, /* Report Count (1), */
299 0xB1, 0x02, /* Feature (Variable), */
300 0x85, 0xA9, /* Report ID (169), */
301 0x09, 0x4C, /* Usage (4Ch), */
302 0x95, 0x08, /* Report Count (8), */
303 0xB1, 0x02, /* Feature (Variable), */
304 0x85, 0xAA, /* Report ID (170), */
305 0x09, 0x4E, /* Usage (4Eh), */
306 0x95, 0x01, /* Report Count (1), */
307 0xB1, 0x02, /* Feature (Variable), */
308 0x85, 0xAB, /* Report ID (171), */
309 0x09, 0x4F, /* Usage (4Fh), */
310 0x95, 0x39, /* Report Count (57), */
311 0xB1, 0x02, /* Feature (Variable), */
312 0x85, 0xAC, /* Report ID (172), */
313 0x09, 0x50, /* Usage (50h), */
314 0x95, 0x39, /* Report Count (57), */
315 0xB1, 0x02, /* Feature (Variable), */
316 0x85, 0xAD, /* Report ID (173), */
317 0x09, 0x51, /* Usage (51h), */
318 0x95, 0x0B, /* Report Count (11), */
319 0xB1, 0x02, /* Feature (Variable), */
320 0x85, 0xAE, /* Report ID (174), */
321 0x09, 0x52, /* Usage (52h), */
322 0x95, 0x01, /* Report Count (1), */
323 0xB1, 0x02, /* Feature (Variable), */
324 0x85, 0xAF, /* Report ID (175), */
325 0x09, 0x53, /* Usage (53h), */
326 0x95, 0x02, /* Report Count (2), */
327 0xB1, 0x02, /* Feature (Variable), */
328 0x85, 0xB0, /* Report ID (176), */
329 0x09, 0x54, /* Usage (54h), */
330 0x95, 0x3F, /* Report Count (63), */
331 0xB1, 0x02, /* Feature (Variable), */
332 0xC0 /* End Collection */
335 static __u8 ps3remote_rdesc[] = {
336 0x05, 0x01, /* GUsagePage Generic Desktop */
337 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
338 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
340 /* Use collection 1 for joypad buttons */
341 0xA1, 0x02, /* MCollection Logical (interrelated data) */
343 /* Ignore the 1st byte, maybe it is used for a controller
344 * number but it's not needed for correct operation */
345 0x75, 0x08, /* GReportSize 0x08 [8] */
346 0x95, 0x01, /* GReportCount 0x01 [1] */
347 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
349 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
350 * buttons multiple keypresses are allowed */
351 0x05, 0x09, /* GUsagePage Button */
352 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
353 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
354 0x14, /* GLogicalMinimum [0] */
355 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
356 0x75, 0x01, /* GReportSize 0x01 [1] */
357 0x95, 0x18, /* GReportCount 0x18 [24] */
358 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
360 0xC0, /* MEndCollection */
362 /* Use collection 2 for remote control buttons */
363 0xA1, 0x02, /* MCollection Logical (interrelated data) */
365 /* 5th byte is used for remote control buttons */
366 0x05, 0x09, /* GUsagePage Button */
367 0x18, /* LUsageMinimum [No button pressed] */
368 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
369 0x14, /* GLogicalMinimum [0] */
370 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
371 0x75, 0x08, /* GReportSize 0x08 [8] */
372 0x95, 0x01, /* GReportCount 0x01 [1] */
375 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
376 * 0xff and 11th is for press indication */
377 0x75, 0x08, /* GReportSize 0x08 [8] */
378 0x95, 0x06, /* GReportCount 0x06 [6] */
379 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
381 /* 12th byte is for battery strength */
382 0x05, 0x06, /* GUsagePage Generic Device Controls */
383 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
384 0x14, /* GLogicalMinimum [0] */
385 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
386 0x75, 0x08, /* GReportSize 0x08 [8] */
387 0x95, 0x01, /* GReportCount 0x01 [1] */
388 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
390 0xC0, /* MEndCollection */
392 0xC0 /* MEndCollection [Game Pad] */
395 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
397 [0x02] = BTN_THUMBL, /* L3 */
398 [0x03] = BTN_THUMBR, /* R3 */
404 [0x09] = BTN_TL2, /* L2 */
405 [0x0a] = BTN_TR2, /* R2 */
406 [0x0b] = BTN_TL, /* L1 */
407 [0x0c] = BTN_TR, /* R1 */
408 [0x0d] = KEY_OPTION, /* options/triangle */
409 [0x0e] = KEY_BACK, /* back/circle */
410 [0x0f] = BTN_0, /* cross */
411 [0x10] = KEY_SCREEN, /* view/square */
412 [0x11] = KEY_HOMEPAGE, /* PS button */
415 static const unsigned int ps3remote_keymap_remote_buttons[] = {
426 [0x0e] = KEY_ESC, /* return */
428 [0x16] = KEY_EJECTCD,
429 [0x1a] = KEY_MENU, /* top menu */
431 [0x30] = KEY_PREVIOUS,
434 [0x33] = KEY_REWIND, /* scan back */
435 [0x34] = KEY_FORWARD, /* scan forward */
438 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
439 [0x60] = KEY_FRAMEBACK, /* slow/step back */
440 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
441 [0x63] = KEY_SUBTITLE,
444 [0x70] = KEY_INFO, /* display */
451 static const unsigned int buzz_keymap[] = {
452 /* The controller has 4 remote buzzers, each with one LED and 5
455 * We use the mapping chosen by the controller, which is:
458 * -------------------
465 * So, for example, the orange button on the third buzzer is mapped to
466 * BTN_TRIGGER_HAPPY14
468 [ 1] = BTN_TRIGGER_HAPPY1,
469 [ 2] = BTN_TRIGGER_HAPPY2,
470 [ 3] = BTN_TRIGGER_HAPPY3,
471 [ 4] = BTN_TRIGGER_HAPPY4,
472 [ 5] = BTN_TRIGGER_HAPPY5,
473 [ 6] = BTN_TRIGGER_HAPPY6,
474 [ 7] = BTN_TRIGGER_HAPPY7,
475 [ 8] = BTN_TRIGGER_HAPPY8,
476 [ 9] = BTN_TRIGGER_HAPPY9,
477 [10] = BTN_TRIGGER_HAPPY10,
478 [11] = BTN_TRIGGER_HAPPY11,
479 [12] = BTN_TRIGGER_HAPPY12,
480 [13] = BTN_TRIGGER_HAPPY13,
481 [14] = BTN_TRIGGER_HAPPY14,
482 [15] = BTN_TRIGGER_HAPPY15,
483 [16] = BTN_TRIGGER_HAPPY16,
484 [17] = BTN_TRIGGER_HAPPY17,
485 [18] = BTN_TRIGGER_HAPPY18,
486 [19] = BTN_TRIGGER_HAPPY19,
487 [20] = BTN_TRIGGER_HAPPY20,
491 struct hid_device *hdev;
492 struct led_classdev *leds[MAX_LEDS];
493 struct hid_report *output_report;
494 unsigned long quirks;
495 struct work_struct state_worker;
497 #ifdef CONFIG_SONY_FF
502 __u8 led_state[MAX_LEDS];
506 static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
509 *rsize = sizeof(ps3remote_rdesc);
510 return ps3remote_rdesc;
513 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
514 struct hid_field *field, struct hid_usage *usage,
515 unsigned long **bit, int *max)
517 unsigned int key = usage->hid & HID_USAGE;
519 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
522 switch (usage->collection_index) {
524 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
527 key = ps3remote_keymap_joypad_buttons[key];
532 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
535 key = ps3remote_keymap_remote_buttons[key];
543 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
548 /* Sony Vaio VGX has wrongly mouse pointer declared as constant */
549 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
552 struct sony_sc *sc = hid_get_drvdata(hdev);
555 * Some Sony RF receivers wrongly declare the mouse pointer as a
556 * a constant non-data variable.
558 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
559 /* usage page: generic desktop controls */
560 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
562 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
563 /* input (usage page for x,y axes): constant, variable, relative */
564 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
565 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
566 /* input: data, variable, relative */
571 * The default Dualshock 4 USB descriptor doesn't assign
572 * the gyroscope values to corresponding axes so we need a
575 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
576 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
577 rdesc = dualshock4_usb_rdesc;
578 *rsize = sizeof(dualshock4_usb_rdesc);
581 /* The HID descriptor exposed over BT has a trailing zero byte */
582 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
583 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
585 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
586 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
587 sizeof(sixaxis_rdesc_fixup));
588 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
589 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
590 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
591 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
592 *rsize = sizeof(sixaxis_rdesc_fixup2);
593 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
596 if (sc->quirks & PS3REMOTE)
597 return ps3remote_fixup(hdev, rdesc, rsize);
602 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
605 struct sony_sc *sc = hid_get_drvdata(hdev);
607 /* Sixaxis HID report has acclerometers/gyro with MSByte first, this
608 * has to be BYTE_SWAPPED before passing up to joystick interface
610 if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) &&
611 rd[0] == 0x01 && size == 49) {
612 swap(rd[41], rd[42]);
613 swap(rd[43], rd[44]);
614 swap(rd[45], rd[46]);
615 swap(rd[47], rd[48]);
621 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
622 struct hid_field *field, struct hid_usage *usage,
623 unsigned long **bit, int *max)
625 struct sony_sc *sc = hid_get_drvdata(hdev);
627 if (sc->quirks & BUZZ_CONTROLLER) {
628 unsigned int key = usage->hid & HID_USAGE;
630 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
633 switch (usage->collection_index) {
635 if (key >= ARRAY_SIZE(buzz_keymap))
638 key = buzz_keymap[key];
646 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
650 if (sc->quirks & PS3REMOTE)
651 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
653 /* Let hid-core decide for the others */
658 * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
659 * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
660 * so we need to override that forcing HID Output Reports on the Control EP.
662 * There is also another issue about HID Output Reports via USB, the Sixaxis
663 * does not want the report_id as part of the data packet, so we have to
664 * discard buf[0] when sending the actual control message, even for numbered
667 static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
668 size_t count, unsigned char report_type)
670 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
671 struct usb_device *dev = interface_to_usbdev(intf);
672 struct usb_host_interface *interface = intf->cur_altsetting;
673 int report_id = buf[0];
676 if (report_type == HID_OUTPUT_REPORT) {
677 /* Don't send the Report ID */
682 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
684 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
685 ((report_type + 1) << 8) | report_id,
686 interface->desc.bInterfaceNumber, buf, count,
687 USB_CTRL_SET_TIMEOUT);
689 /* Count also the Report ID, in case of an Output report. */
690 if (ret > 0 && report_type == HID_OUTPUT_REPORT)
697 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
698 * to "operational". Without this, the ps3 controller will not report any
701 static int sixaxis_set_operational_usb(struct hid_device *hdev)
704 char *buf = kmalloc(18, GFP_KERNEL);
709 ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT);
712 hid_err(hdev, "can't set operational mode\n");
719 static int sixaxis_set_operational_bt(struct hid_device *hdev)
721 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
722 return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
725 static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
727 struct list_head *report_list =
728 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
729 struct hid_report *report = list_entry(report_list->next,
730 struct hid_report, list);
731 __s32 *value = report->field[0]->value;
734 value[1] = leds[0] ? 0xff : 0x00;
735 value[2] = leds[1] ? 0xff : 0x00;
736 value[3] = leds[2] ? 0xff : 0x00;
737 value[4] = leds[3] ? 0xff : 0x00;
740 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
743 static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
745 struct sony_sc *drv_data = hid_get_drvdata(hdev);
748 BUG_ON(count > MAX_LEDS);
750 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
751 buzz_set_leds(hdev, leds);
752 } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) ||
753 (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
754 for (n = 0; n < count; n++)
755 drv_data->led_state[n] = leds[n];
756 schedule_work(&drv_data->state_worker);
760 static void sony_led_set_brightness(struct led_classdev *led,
761 enum led_brightness value)
763 struct device *dev = led->dev->parent;
764 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
765 struct sony_sc *drv_data;
769 drv_data = hid_get_drvdata(hdev);
771 hid_err(hdev, "No device data\n");
775 for (n = 0; n < drv_data->led_count; n++) {
776 if (led == drv_data->leds[n]) {
777 if (value != drv_data->led_state[n]) {
778 drv_data->led_state[n] = value;
779 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
786 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
788 struct device *dev = led->dev->parent;
789 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
790 struct sony_sc *drv_data;
795 drv_data = hid_get_drvdata(hdev);
797 hid_err(hdev, "No device data\n");
801 for (n = 0; n < drv_data->led_count; n++) {
802 if (led == drv_data->leds[n]) {
803 on = !!(drv_data->led_state[n]);
808 return on ? LED_FULL : LED_OFF;
811 static void sony_leds_remove(struct hid_device *hdev)
813 struct sony_sc *drv_data;
814 struct led_classdev *led;
817 drv_data = hid_get_drvdata(hdev);
818 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
820 for (n = 0; n < drv_data->led_count; n++) {
821 led = drv_data->leds[n];
822 drv_data->leds[n] = NULL;
825 led_classdev_unregister(led);
829 drv_data->led_count = 0;
832 static int sony_leds_init(struct hid_device *hdev)
834 struct sony_sc *drv_data;
837 struct led_classdev *led;
841 const char *name_fmt;
842 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
844 drv_data = hid_get_drvdata(hdev);
845 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
847 if (drv_data->quirks & BUZZ_CONTROLLER) {
848 name_len = strlen("::buzz#");
849 name_fmt = "%s::buzz%d";
850 /* Validate expected report characteristics. */
851 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
854 name_len = strlen("::sony#");
855 name_fmt = "%s::sony%d";
858 if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) {
859 drv_data->led_count = 3;
860 max_brightness = 255;
862 drv_data->led_count = 4;
866 /* Clear LEDs as we have no way of reading their initial state. This is
867 * only relevant if the driver is loaded after somebody actively set the
869 sony_set_leds(hdev, initial_values, drv_data->led_count);
871 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
873 for (n = 0; n < drv_data->led_count; n++) {
874 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
876 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
881 name = (void *)(&led[1]);
882 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
885 led->max_brightness = max_brightness;
886 led->brightness_get = sony_led_get_brightness;
887 led->brightness_set = sony_led_set_brightness;
889 ret = led_classdev_register(&hdev->dev, led);
891 hid_err(hdev, "Failed to register LED %d\n", n);
896 drv_data->leds[n] = led;
902 sony_leds_remove(hdev);
907 static void sixaxis_state_worker(struct work_struct *work)
909 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
910 unsigned char buf[] = {
912 0x00, 0xff, 0x00, 0xff, 0x00,
913 0x00, 0x00, 0x00, 0x00, 0x00,
914 0xff, 0x27, 0x10, 0x00, 0x32,
915 0xff, 0x27, 0x10, 0x00, 0x32,
916 0xff, 0x27, 0x10, 0x00, 0x32,
917 0xff, 0x27, 0x10, 0x00, 0x32,
918 0x00, 0x00, 0x00, 0x00, 0x00
921 #ifdef CONFIG_SONY_FF
922 buf[3] = sc->right ? 1 : 0;
926 buf[10] |= sc->led_state[0] << 1;
927 buf[10] |= sc->led_state[1] << 2;
928 buf[10] |= sc->led_state[2] << 3;
929 buf[10] |= sc->led_state[3] << 4;
931 sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf),
935 static void dualshock4_state_worker(struct work_struct *work)
937 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
938 struct hid_device *hdev = sc->hdev;
939 struct hid_report *report = sc->output_report;
940 __s32 *value = report->field[0]->value;
944 #ifdef CONFIG_SONY_FF
945 value[3] = sc->right;
949 value[5] = sc->led_state[0];
950 value[6] = sc->led_state[1];
951 value[7] = sc->led_state[2];
953 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
956 #ifdef CONFIG_SONY_FF
957 static int sony_play_effect(struct input_dev *dev, void *data,
958 struct ff_effect *effect)
960 struct hid_device *hid = input_get_drvdata(dev);
961 struct sony_sc *sc = hid_get_drvdata(hid);
963 if (effect->type != FF_RUMBLE)
966 sc->left = effect->u.rumble.strong_magnitude / 256;
967 sc->right = effect->u.rumble.weak_magnitude / 256;
969 schedule_work(&sc->state_worker);
973 static int sony_init_ff(struct hid_device *hdev)
975 struct hid_input *hidinput = list_entry(hdev->inputs.next,
976 struct hid_input, list);
977 struct input_dev *input_dev = hidinput->input;
979 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
980 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
983 static void sony_destroy_ff(struct hid_device *hdev)
985 struct sony_sc *sc = hid_get_drvdata(hdev);
987 cancel_work_sync(&sc->state_worker);
991 static int sony_init_ff(struct hid_device *hdev)
996 static void sony_destroy_ff(struct hid_device *hdev)
1001 static int sony_set_output_report(struct sony_sc *sc, int req_id, int req_size)
1003 struct list_head *head, *list;
1004 struct hid_report *report;
1005 struct hid_device *hdev = sc->hdev;
1007 list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1009 list_for_each(head, list) {
1010 report = list_entry(head, struct hid_report, list);
1012 if (report->id == req_id) {
1013 if (report->size < req_size) {
1014 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n",
1015 req_id, report->size, req_size);
1018 sc->output_report = report;
1023 hid_err(hdev, "Unable to locate output report 0x%02x\n", req_id);
1028 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1031 unsigned long quirks = id->driver_data;
1033 unsigned int connect_mask = HID_CONNECT_DEFAULT;
1035 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1037 hid_err(hdev, "can't alloc sony descriptor\n");
1041 sc->quirks = quirks;
1042 hid_set_drvdata(hdev, sc);
1045 ret = hid_parse(hdev);
1047 hid_err(hdev, "parse failed\n");
1051 if (sc->quirks & VAIO_RDESC_CONSTANT)
1052 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1053 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1054 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1055 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1056 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1058 ret = hid_hw_start(hdev, connect_mask);
1060 hid_err(hdev, "hw start failed\n");
1064 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1065 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
1066 ret = sixaxis_set_operational_usb(hdev);
1067 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1069 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1070 ret = sixaxis_set_operational_bt(hdev);
1071 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1072 /* Report 5 (31 bytes) is used to send data to the controller via USB */
1073 ret = sony_set_output_report(sc, 0x05, 248);
1077 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1085 if (sc->quirks & SONY_LED_SUPPORT) {
1086 ret = sony_leds_init(hdev);
1091 ret = sony_init_ff(hdev);
1097 if (sc->quirks & SONY_LED_SUPPORT)
1098 sony_leds_remove(hdev);
1103 static void sony_remove(struct hid_device *hdev)
1105 struct sony_sc *sc = hid_get_drvdata(hdev);
1107 if (sc->quirks & SONY_LED_SUPPORT)
1108 sony_leds_remove(hdev);
1110 sony_destroy_ff(hdev);
1115 static const struct hid_device_id sony_devices[] = {
1116 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1117 .driver_data = SIXAXIS_CONTROLLER_USB },
1118 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1119 .driver_data = SIXAXIS_CONTROLLER_USB },
1120 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1121 .driver_data = SIXAXIS_CONTROLLER_BT },
1122 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1123 .driver_data = VAIO_RDESC_CONSTANT },
1124 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1125 .driver_data = VAIO_RDESC_CONSTANT },
1126 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1127 * Logitech joystick from the device descriptor. */
1128 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1129 .driver_data = BUZZ_CONTROLLER },
1130 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1131 .driver_data = BUZZ_CONTROLLER },
1132 /* PS3 BD Remote Control */
1133 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1134 .driver_data = PS3REMOTE },
1135 /* Logitech Harmony Adapter for PS3 */
1136 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1137 .driver_data = PS3REMOTE },
1138 /* Sony Dualshock 4 controllers for PS4 */
1139 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1140 .driver_data = DUALSHOCK4_CONTROLLER_USB },
1141 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1142 .driver_data = DUALSHOCK4_CONTROLLER_BT },
1145 MODULE_DEVICE_TABLE(hid, sony_devices);
1147 static struct hid_driver sony_driver = {
1149 .id_table = sony_devices,
1150 .input_mapping = sony_mapping,
1151 .probe = sony_probe,
1152 .remove = sony_remove,
1153 .report_fixup = sony_report_fixup,
1154 .raw_event = sony_raw_event
1156 module_hid_driver(sony_driver);
1158 MODULE_LICENSE("GPL");