Loading...
1/*
2 * HID driver for Sony / PS2 / PS3 BD devices.
3 *
4 * Copyright (c) 1999 Andreas Gal
5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7 * Copyright (c) 2008 Jiri Slaby
8 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
11 */
12
13/*
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the Free
16 * Software Foundation; either version 2 of the License, or (at your option)
17 * any later version.
18 */
19
20/*
21 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
22 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
23 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
24 *
25 * There will be no PIN request from the device.
26 */
27
28#include <linux/device.h>
29#include <linux/hid.h>
30#include <linux/module.h>
31#include <linux/slab.h>
32#include <linux/leds.h>
33#include <linux/power_supply.h>
34#include <linux/spinlock.h>
35#include <linux/list.h>
36#include <linux/input/mt.h>
37
38#include "hid-ids.h"
39
40#define VAIO_RDESC_CONSTANT BIT(0)
41#define SIXAXIS_CONTROLLER_USB BIT(1)
42#define SIXAXIS_CONTROLLER_BT BIT(2)
43#define BUZZ_CONTROLLER BIT(3)
44#define PS3REMOTE BIT(4)
45#define DUALSHOCK4_CONTROLLER_USB BIT(5)
46#define DUALSHOCK4_CONTROLLER_BT BIT(6)
47
48#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
49#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
50 DUALSHOCK4_CONTROLLER_BT)
51#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
52 DUALSHOCK4_CONTROLLER)
53#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
54#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
55
56#define MAX_LEDS 4
57
58static const u8 sixaxis_rdesc_fixup[] = {
59 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
60 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
61 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
62};
63
64static const u8 sixaxis_rdesc_fixup2[] = {
65 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
66 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
67 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
68 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
69 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
70 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
71 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
72 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
73 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
74 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
75 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
76 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
77 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
78 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
79 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
80 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
81 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
82 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
83 0xb1, 0x02, 0xc0, 0xc0,
84};
85
86/*
87 * The default descriptor doesn't provide mapping for the accelerometers
88 * or orientation sensors. This fixed descriptor maps the accelerometers
89 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
90 * to usage values 0x43, 0x44 and 0x45.
91 */
92static u8 dualshock4_usb_rdesc[] = {
93 0x05, 0x01, /* Usage Page (Desktop), */
94 0x09, 0x05, /* Usage (Gamepad), */
95 0xA1, 0x01, /* Collection (Application), */
96 0x85, 0x01, /* Report ID (1), */
97 0x09, 0x30, /* Usage (X), */
98 0x09, 0x31, /* Usage (Y), */
99 0x09, 0x32, /* Usage (Z), */
100 0x09, 0x35, /* Usage (Rz), */
101 0x15, 0x00, /* Logical Minimum (0), */
102 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
103 0x75, 0x08, /* Report Size (8), */
104 0x95, 0x04, /* Report Count (4), */
105 0x81, 0x02, /* Input (Variable), */
106 0x09, 0x39, /* Usage (Hat Switch), */
107 0x15, 0x00, /* Logical Minimum (0), */
108 0x25, 0x07, /* Logical Maximum (7), */
109 0x35, 0x00, /* Physical Minimum (0), */
110 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
111 0x65, 0x14, /* Unit (Degrees), */
112 0x75, 0x04, /* Report Size (4), */
113 0x95, 0x01, /* Report Count (1), */
114 0x81, 0x42, /* Input (Variable, Null State), */
115 0x65, 0x00, /* Unit, */
116 0x05, 0x09, /* Usage Page (Button), */
117 0x19, 0x01, /* Usage Minimum (01h), */
118 0x29, 0x0E, /* Usage Maximum (0Eh), */
119 0x15, 0x00, /* Logical Minimum (0), */
120 0x25, 0x01, /* Logical Maximum (1), */
121 0x75, 0x01, /* Report Size (1), */
122 0x95, 0x0E, /* Report Count (14), */
123 0x81, 0x02, /* Input (Variable), */
124 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
125 0x09, 0x20, /* Usage (20h), */
126 0x75, 0x06, /* Report Size (6), */
127 0x95, 0x01, /* Report Count (1), */
128 0x15, 0x00, /* Logical Minimum (0), */
129 0x25, 0x7F, /* Logical Maximum (127), */
130 0x81, 0x02, /* Input (Variable), */
131 0x05, 0x01, /* Usage Page (Desktop), */
132 0x09, 0x33, /* Usage (Rx), */
133 0x09, 0x34, /* Usage (Ry), */
134 0x15, 0x00, /* Logical Minimum (0), */
135 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
136 0x75, 0x08, /* Report Size (8), */
137 0x95, 0x02, /* Report Count (2), */
138 0x81, 0x02, /* Input (Variable), */
139 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
140 0x09, 0x21, /* Usage (21h), */
141 0x95, 0x03, /* Report Count (3), */
142 0x81, 0x02, /* Input (Variable), */
143 0x05, 0x01, /* Usage Page (Desktop), */
144 0x19, 0x40, /* Usage Minimum (40h), */
145 0x29, 0x42, /* Usage Maximum (42h), */
146 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
147 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
148 0x75, 0x10, /* Report Size (16), */
149 0x95, 0x03, /* Report Count (3), */
150 0x81, 0x02, /* Input (Variable), */
151 0x19, 0x43, /* Usage Minimum (43h), */
152 0x29, 0x45, /* Usage Maximum (45h), */
153 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
154 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
155 0x95, 0x03, /* Report Count (3), */
156 0x81, 0x02, /* Input (Variable), */
157 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
158 0x09, 0x21, /* Usage (21h), */
159 0x15, 0x00, /* Logical Minimum (0), */
160 0x25, 0xFF, /* Logical Maximum (255), */
161 0x75, 0x08, /* Report Size (8), */
162 0x95, 0x27, /* Report Count (39), */
163 0x81, 0x02, /* Input (Variable), */
164 0x85, 0x05, /* Report ID (5), */
165 0x09, 0x22, /* Usage (22h), */
166 0x95, 0x1F, /* Report Count (31), */
167 0x91, 0x02, /* Output (Variable), */
168 0x85, 0x04, /* Report ID (4), */
169 0x09, 0x23, /* Usage (23h), */
170 0x95, 0x24, /* Report Count (36), */
171 0xB1, 0x02, /* Feature (Variable), */
172 0x85, 0x02, /* Report ID (2), */
173 0x09, 0x24, /* Usage (24h), */
174 0x95, 0x24, /* Report Count (36), */
175 0xB1, 0x02, /* Feature (Variable), */
176 0x85, 0x08, /* Report ID (8), */
177 0x09, 0x25, /* Usage (25h), */
178 0x95, 0x03, /* Report Count (3), */
179 0xB1, 0x02, /* Feature (Variable), */
180 0x85, 0x10, /* Report ID (16), */
181 0x09, 0x26, /* Usage (26h), */
182 0x95, 0x04, /* Report Count (4), */
183 0xB1, 0x02, /* Feature (Variable), */
184 0x85, 0x11, /* Report ID (17), */
185 0x09, 0x27, /* Usage (27h), */
186 0x95, 0x02, /* Report Count (2), */
187 0xB1, 0x02, /* Feature (Variable), */
188 0x85, 0x12, /* Report ID (18), */
189 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
190 0x09, 0x21, /* Usage (21h), */
191 0x95, 0x0F, /* Report Count (15), */
192 0xB1, 0x02, /* Feature (Variable), */
193 0x85, 0x13, /* Report ID (19), */
194 0x09, 0x22, /* Usage (22h), */
195 0x95, 0x16, /* Report Count (22), */
196 0xB1, 0x02, /* Feature (Variable), */
197 0x85, 0x14, /* Report ID (20), */
198 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
199 0x09, 0x20, /* Usage (20h), */
200 0x95, 0x10, /* Report Count (16), */
201 0xB1, 0x02, /* Feature (Variable), */
202 0x85, 0x15, /* Report ID (21), */
203 0x09, 0x21, /* Usage (21h), */
204 0x95, 0x2C, /* Report Count (44), */
205 0xB1, 0x02, /* Feature (Variable), */
206 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
207 0x85, 0x80, /* Report ID (128), */
208 0x09, 0x20, /* Usage (20h), */
209 0x95, 0x06, /* Report Count (6), */
210 0xB1, 0x02, /* Feature (Variable), */
211 0x85, 0x81, /* Report ID (129), */
212 0x09, 0x21, /* Usage (21h), */
213 0x95, 0x06, /* Report Count (6), */
214 0xB1, 0x02, /* Feature (Variable), */
215 0x85, 0x82, /* Report ID (130), */
216 0x09, 0x22, /* Usage (22h), */
217 0x95, 0x05, /* Report Count (5), */
218 0xB1, 0x02, /* Feature (Variable), */
219 0x85, 0x83, /* Report ID (131), */
220 0x09, 0x23, /* Usage (23h), */
221 0x95, 0x01, /* Report Count (1), */
222 0xB1, 0x02, /* Feature (Variable), */
223 0x85, 0x84, /* Report ID (132), */
224 0x09, 0x24, /* Usage (24h), */
225 0x95, 0x04, /* Report Count (4), */
226 0xB1, 0x02, /* Feature (Variable), */
227 0x85, 0x85, /* Report ID (133), */
228 0x09, 0x25, /* Usage (25h), */
229 0x95, 0x06, /* Report Count (6), */
230 0xB1, 0x02, /* Feature (Variable), */
231 0x85, 0x86, /* Report ID (134), */
232 0x09, 0x26, /* Usage (26h), */
233 0x95, 0x06, /* Report Count (6), */
234 0xB1, 0x02, /* Feature (Variable), */
235 0x85, 0x87, /* Report ID (135), */
236 0x09, 0x27, /* Usage (27h), */
237 0x95, 0x23, /* Report Count (35), */
238 0xB1, 0x02, /* Feature (Variable), */
239 0x85, 0x88, /* Report ID (136), */
240 0x09, 0x28, /* Usage (28h), */
241 0x95, 0x22, /* Report Count (34), */
242 0xB1, 0x02, /* Feature (Variable), */
243 0x85, 0x89, /* Report ID (137), */
244 0x09, 0x29, /* Usage (29h), */
245 0x95, 0x02, /* Report Count (2), */
246 0xB1, 0x02, /* Feature (Variable), */
247 0x85, 0x90, /* Report ID (144), */
248 0x09, 0x30, /* Usage (30h), */
249 0x95, 0x05, /* Report Count (5), */
250 0xB1, 0x02, /* Feature (Variable), */
251 0x85, 0x91, /* Report ID (145), */
252 0x09, 0x31, /* Usage (31h), */
253 0x95, 0x03, /* Report Count (3), */
254 0xB1, 0x02, /* Feature (Variable), */
255 0x85, 0x92, /* Report ID (146), */
256 0x09, 0x32, /* Usage (32h), */
257 0x95, 0x03, /* Report Count (3), */
258 0xB1, 0x02, /* Feature (Variable), */
259 0x85, 0x93, /* Report ID (147), */
260 0x09, 0x33, /* Usage (33h), */
261 0x95, 0x0C, /* Report Count (12), */
262 0xB1, 0x02, /* Feature (Variable), */
263 0x85, 0xA0, /* Report ID (160), */
264 0x09, 0x40, /* Usage (40h), */
265 0x95, 0x06, /* Report Count (6), */
266 0xB1, 0x02, /* Feature (Variable), */
267 0x85, 0xA1, /* Report ID (161), */
268 0x09, 0x41, /* Usage (41h), */
269 0x95, 0x01, /* Report Count (1), */
270 0xB1, 0x02, /* Feature (Variable), */
271 0x85, 0xA2, /* Report ID (162), */
272 0x09, 0x42, /* Usage (42h), */
273 0x95, 0x01, /* Report Count (1), */
274 0xB1, 0x02, /* Feature (Variable), */
275 0x85, 0xA3, /* Report ID (163), */
276 0x09, 0x43, /* Usage (43h), */
277 0x95, 0x30, /* Report Count (48), */
278 0xB1, 0x02, /* Feature (Variable), */
279 0x85, 0xA4, /* Report ID (164), */
280 0x09, 0x44, /* Usage (44h), */
281 0x95, 0x0D, /* Report Count (13), */
282 0xB1, 0x02, /* Feature (Variable), */
283 0x85, 0xA5, /* Report ID (165), */
284 0x09, 0x45, /* Usage (45h), */
285 0x95, 0x15, /* Report Count (21), */
286 0xB1, 0x02, /* Feature (Variable), */
287 0x85, 0xA6, /* Report ID (166), */
288 0x09, 0x46, /* Usage (46h), */
289 0x95, 0x15, /* Report Count (21), */
290 0xB1, 0x02, /* Feature (Variable), */
291 0x85, 0xF0, /* Report ID (240), */
292 0x09, 0x47, /* Usage (47h), */
293 0x95, 0x3F, /* Report Count (63), */
294 0xB1, 0x02, /* Feature (Variable), */
295 0x85, 0xF1, /* Report ID (241), */
296 0x09, 0x48, /* Usage (48h), */
297 0x95, 0x3F, /* Report Count (63), */
298 0xB1, 0x02, /* Feature (Variable), */
299 0x85, 0xF2, /* Report ID (242), */
300 0x09, 0x49, /* Usage (49h), */
301 0x95, 0x0F, /* Report Count (15), */
302 0xB1, 0x02, /* Feature (Variable), */
303 0x85, 0xA7, /* Report ID (167), */
304 0x09, 0x4A, /* Usage (4Ah), */
305 0x95, 0x01, /* Report Count (1), */
306 0xB1, 0x02, /* Feature (Variable), */
307 0x85, 0xA8, /* Report ID (168), */
308 0x09, 0x4B, /* Usage (4Bh), */
309 0x95, 0x01, /* Report Count (1), */
310 0xB1, 0x02, /* Feature (Variable), */
311 0x85, 0xA9, /* Report ID (169), */
312 0x09, 0x4C, /* Usage (4Ch), */
313 0x95, 0x08, /* Report Count (8), */
314 0xB1, 0x02, /* Feature (Variable), */
315 0x85, 0xAA, /* Report ID (170), */
316 0x09, 0x4E, /* Usage (4Eh), */
317 0x95, 0x01, /* Report Count (1), */
318 0xB1, 0x02, /* Feature (Variable), */
319 0x85, 0xAB, /* Report ID (171), */
320 0x09, 0x4F, /* Usage (4Fh), */
321 0x95, 0x39, /* Report Count (57), */
322 0xB1, 0x02, /* Feature (Variable), */
323 0x85, 0xAC, /* Report ID (172), */
324 0x09, 0x50, /* Usage (50h), */
325 0x95, 0x39, /* Report Count (57), */
326 0xB1, 0x02, /* Feature (Variable), */
327 0x85, 0xAD, /* Report ID (173), */
328 0x09, 0x51, /* Usage (51h), */
329 0x95, 0x0B, /* Report Count (11), */
330 0xB1, 0x02, /* Feature (Variable), */
331 0x85, 0xAE, /* Report ID (174), */
332 0x09, 0x52, /* Usage (52h), */
333 0x95, 0x01, /* Report Count (1), */
334 0xB1, 0x02, /* Feature (Variable), */
335 0x85, 0xAF, /* Report ID (175), */
336 0x09, 0x53, /* Usage (53h), */
337 0x95, 0x02, /* Report Count (2), */
338 0xB1, 0x02, /* Feature (Variable), */
339 0x85, 0xB0, /* Report ID (176), */
340 0x09, 0x54, /* Usage (54h), */
341 0x95, 0x3F, /* Report Count (63), */
342 0xB1, 0x02, /* Feature (Variable), */
343 0xC0 /* End Collection */
344};
345
346/*
347 * The default behavior of the Dualshock 4 is to send reports using report
348 * type 1 when running over Bluetooth. However, as soon as it receives a
349 * report of type 17 to set the LEDs or rumble it starts returning it's state
350 * in report 17 instead of 1. Since report 17 is undefined in the default HID
351 * descriptor the button and axis definitions must be moved to report 17 or
352 * the HID layer won't process the received input once a report is sent.
353 */
354static u8 dualshock4_bt_rdesc[] = {
355 0x05, 0x01, /* Usage Page (Desktop), */
356 0x09, 0x05, /* Usage (Gamepad), */
357 0xA1, 0x01, /* Collection (Application), */
358 0x85, 0x01, /* Report ID (1), */
359 0x75, 0x08, /* Report Size (8), */
360 0x95, 0x0A, /* Report Count (9), */
361 0x81, 0x02, /* Input (Variable), */
362 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
363 0x85, 0x02, /* Report ID (2), */
364 0x09, 0x24, /* Usage (24h), */
365 0x95, 0x24, /* Report Count (36), */
366 0xB1, 0x02, /* Feature (Variable), */
367 0x85, 0xA3, /* Report ID (163), */
368 0x09, 0x25, /* Usage (25h), */
369 0x95, 0x30, /* Report Count (48), */
370 0xB1, 0x02, /* Feature (Variable), */
371 0x85, 0x05, /* Report ID (5), */
372 0x09, 0x26, /* Usage (26h), */
373 0x95, 0x28, /* Report Count (40), */
374 0xB1, 0x02, /* Feature (Variable), */
375 0x85, 0x06, /* Report ID (6), */
376 0x09, 0x27, /* Usage (27h), */
377 0x95, 0x34, /* Report Count (52), */
378 0xB1, 0x02, /* Feature (Variable), */
379 0x85, 0x07, /* Report ID (7), */
380 0x09, 0x28, /* Usage (28h), */
381 0x95, 0x30, /* Report Count (48), */
382 0xB1, 0x02, /* Feature (Variable), */
383 0x85, 0x08, /* Report ID (8), */
384 0x09, 0x29, /* Usage (29h), */
385 0x95, 0x2F, /* Report Count (47), */
386 0xB1, 0x02, /* Feature (Variable), */
387 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
388 0x85, 0x03, /* Report ID (3), */
389 0x09, 0x21, /* Usage (21h), */
390 0x95, 0x26, /* Report Count (38), */
391 0xB1, 0x02, /* Feature (Variable), */
392 0x85, 0x04, /* Report ID (4), */
393 0x09, 0x22, /* Usage (22h), */
394 0x95, 0x2E, /* Report Count (46), */
395 0xB1, 0x02, /* Feature (Variable), */
396 0x85, 0xF0, /* Report ID (240), */
397 0x09, 0x47, /* Usage (47h), */
398 0x95, 0x3F, /* Report Count (63), */
399 0xB1, 0x02, /* Feature (Variable), */
400 0x85, 0xF1, /* Report ID (241), */
401 0x09, 0x48, /* Usage (48h), */
402 0x95, 0x3F, /* Report Count (63), */
403 0xB1, 0x02, /* Feature (Variable), */
404 0x85, 0xF2, /* Report ID (242), */
405 0x09, 0x49, /* Usage (49h), */
406 0x95, 0x0F, /* Report Count (15), */
407 0xB1, 0x02, /* Feature (Variable), */
408 0x85, 0x11, /* Report ID (17), */
409 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
410 0x09, 0x20, /* Usage (20h), */
411 0x95, 0x02, /* Report Count (2), */
412 0x81, 0x02, /* Input (Variable), */
413 0x05, 0x01, /* Usage Page (Desktop), */
414 0x09, 0x30, /* Usage (X), */
415 0x09, 0x31, /* Usage (Y), */
416 0x09, 0x32, /* Usage (Z), */
417 0x09, 0x35, /* Usage (Rz), */
418 0x15, 0x00, /* Logical Minimum (0), */
419 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
420 0x75, 0x08, /* Report Size (8), */
421 0x95, 0x04, /* Report Count (4), */
422 0x81, 0x02, /* Input (Variable), */
423 0x09, 0x39, /* Usage (Hat Switch), */
424 0x15, 0x00, /* Logical Minimum (0), */
425 0x25, 0x07, /* Logical Maximum (7), */
426 0x75, 0x04, /* Report Size (4), */
427 0x95, 0x01, /* Report Count (1), */
428 0x81, 0x42, /* Input (Variable, Null State), */
429 0x05, 0x09, /* Usage Page (Button), */
430 0x19, 0x01, /* Usage Minimum (01h), */
431 0x29, 0x0E, /* Usage Maximum (0Eh), */
432 0x15, 0x00, /* Logical Minimum (0), */
433 0x25, 0x01, /* Logical Maximum (1), */
434 0x75, 0x01, /* Report Size (1), */
435 0x95, 0x0E, /* Report Count (14), */
436 0x81, 0x02, /* Input (Variable), */
437 0x75, 0x06, /* Report Size (6), */
438 0x95, 0x01, /* Report Count (1), */
439 0x81, 0x01, /* Input (Constant), */
440 0x05, 0x01, /* Usage Page (Desktop), */
441 0x09, 0x33, /* Usage (Rx), */
442 0x09, 0x34, /* Usage (Ry), */
443 0x15, 0x00, /* Logical Minimum (0), */
444 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
445 0x75, 0x08, /* Report Size (8), */
446 0x95, 0x02, /* Report Count (2), */
447 0x81, 0x02, /* Input (Variable), */
448 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
449 0x09, 0x20, /* Usage (20h), */
450 0x95, 0x03, /* Report Count (3), */
451 0x81, 0x02, /* Input (Variable), */
452 0x05, 0x01, /* Usage Page (Desktop), */
453 0x19, 0x40, /* Usage Minimum (40h), */
454 0x29, 0x42, /* Usage Maximum (42h), */
455 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
456 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
457 0x75, 0x10, /* Report Size (16), */
458 0x95, 0x03, /* Report Count (3), */
459 0x81, 0x02, /* Input (Variable), */
460 0x19, 0x43, /* Usage Minimum (43h), */
461 0x29, 0x45, /* Usage Maximum (45h), */
462 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
463 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
464 0x95, 0x03, /* Report Count (3), */
465 0x81, 0x02, /* Input (Variable), */
466 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
467 0x09, 0x20, /* Usage (20h), */
468 0x15, 0x00, /* Logical Minimum (0), */
469 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
470 0x75, 0x08, /* Report Size (8), */
471 0x95, 0x31, /* Report Count (51), */
472 0x81, 0x02, /* Input (Variable), */
473 0x09, 0x21, /* Usage (21h), */
474 0x75, 0x08, /* Report Size (8), */
475 0x95, 0x4D, /* Report Count (77), */
476 0x91, 0x02, /* Output (Variable), */
477 0x85, 0x12, /* Report ID (18), */
478 0x09, 0x22, /* Usage (22h), */
479 0x95, 0x8D, /* Report Count (141), */
480 0x81, 0x02, /* Input (Variable), */
481 0x09, 0x23, /* Usage (23h), */
482 0x91, 0x02, /* Output (Variable), */
483 0x85, 0x13, /* Report ID (19), */
484 0x09, 0x24, /* Usage (24h), */
485 0x95, 0xCD, /* Report Count (205), */
486 0x81, 0x02, /* Input (Variable), */
487 0x09, 0x25, /* Usage (25h), */
488 0x91, 0x02, /* Output (Variable), */
489 0x85, 0x14, /* Report ID (20), */
490 0x09, 0x26, /* Usage (26h), */
491 0x96, 0x0D, 0x01, /* Report Count (269), */
492 0x81, 0x02, /* Input (Variable), */
493 0x09, 0x27, /* Usage (27h), */
494 0x91, 0x02, /* Output (Variable), */
495 0x85, 0x15, /* Report ID (21), */
496 0x09, 0x28, /* Usage (28h), */
497 0x96, 0x4D, 0x01, /* Report Count (333), */
498 0x81, 0x02, /* Input (Variable), */
499 0x09, 0x29, /* Usage (29h), */
500 0x91, 0x02, /* Output (Variable), */
501 0x85, 0x16, /* Report ID (22), */
502 0x09, 0x2A, /* Usage (2Ah), */
503 0x96, 0x8D, 0x01, /* Report Count (397), */
504 0x81, 0x02, /* Input (Variable), */
505 0x09, 0x2B, /* Usage (2Bh), */
506 0x91, 0x02, /* Output (Variable), */
507 0x85, 0x17, /* Report ID (23), */
508 0x09, 0x2C, /* Usage (2Ch), */
509 0x96, 0xCD, 0x01, /* Report Count (461), */
510 0x81, 0x02, /* Input (Variable), */
511 0x09, 0x2D, /* Usage (2Dh), */
512 0x91, 0x02, /* Output (Variable), */
513 0x85, 0x18, /* Report ID (24), */
514 0x09, 0x2E, /* Usage (2Eh), */
515 0x96, 0x0D, 0x02, /* Report Count (525), */
516 0x81, 0x02, /* Input (Variable), */
517 0x09, 0x2F, /* Usage (2Fh), */
518 0x91, 0x02, /* Output (Variable), */
519 0x85, 0x19, /* Report ID (25), */
520 0x09, 0x30, /* Usage (30h), */
521 0x96, 0x22, 0x02, /* Report Count (546), */
522 0x81, 0x02, /* Input (Variable), */
523 0x09, 0x31, /* Usage (31h), */
524 0x91, 0x02, /* Output (Variable), */
525 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
526 0x85, 0x82, /* Report ID (130), */
527 0x09, 0x22, /* Usage (22h), */
528 0x95, 0x3F, /* Report Count (63), */
529 0xB1, 0x02, /* Feature (Variable), */
530 0x85, 0x83, /* Report ID (131), */
531 0x09, 0x23, /* Usage (23h), */
532 0xB1, 0x02, /* Feature (Variable), */
533 0x85, 0x84, /* Report ID (132), */
534 0x09, 0x24, /* Usage (24h), */
535 0xB1, 0x02, /* Feature (Variable), */
536 0x85, 0x90, /* Report ID (144), */
537 0x09, 0x30, /* Usage (30h), */
538 0xB1, 0x02, /* Feature (Variable), */
539 0x85, 0x91, /* Report ID (145), */
540 0x09, 0x31, /* Usage (31h), */
541 0xB1, 0x02, /* Feature (Variable), */
542 0x85, 0x92, /* Report ID (146), */
543 0x09, 0x32, /* Usage (32h), */
544 0xB1, 0x02, /* Feature (Variable), */
545 0x85, 0x93, /* Report ID (147), */
546 0x09, 0x33, /* Usage (33h), */
547 0xB1, 0x02, /* Feature (Variable), */
548 0x85, 0xA0, /* Report ID (160), */
549 0x09, 0x40, /* Usage (40h), */
550 0xB1, 0x02, /* Feature (Variable), */
551 0x85, 0xA4, /* Report ID (164), */
552 0x09, 0x44, /* Usage (44h), */
553 0xB1, 0x02, /* Feature (Variable), */
554 0xC0 /* End Collection */
555};
556
557static __u8 ps3remote_rdesc[] = {
558 0x05, 0x01, /* GUsagePage Generic Desktop */
559 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
560 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
561
562 /* Use collection 1 for joypad buttons */
563 0xA1, 0x02, /* MCollection Logical (interrelated data) */
564
565 /* Ignore the 1st byte, maybe it is used for a controller
566 * number but it's not needed for correct operation */
567 0x75, 0x08, /* GReportSize 0x08 [8] */
568 0x95, 0x01, /* GReportCount 0x01 [1] */
569 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
570
571 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
572 * buttons multiple keypresses are allowed */
573 0x05, 0x09, /* GUsagePage Button */
574 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
575 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
576 0x14, /* GLogicalMinimum [0] */
577 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
578 0x75, 0x01, /* GReportSize 0x01 [1] */
579 0x95, 0x18, /* GReportCount 0x18 [24] */
580 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
581
582 0xC0, /* MEndCollection */
583
584 /* Use collection 2 for remote control buttons */
585 0xA1, 0x02, /* MCollection Logical (interrelated data) */
586
587 /* 5th byte is used for remote control buttons */
588 0x05, 0x09, /* GUsagePage Button */
589 0x18, /* LUsageMinimum [No button pressed] */
590 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
591 0x14, /* GLogicalMinimum [0] */
592 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
593 0x75, 0x08, /* GReportSize 0x08 [8] */
594 0x95, 0x01, /* GReportCount 0x01 [1] */
595 0x80, /* MInput */
596
597 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
598 * 0xff and 11th is for press indication */
599 0x75, 0x08, /* GReportSize 0x08 [8] */
600 0x95, 0x06, /* GReportCount 0x06 [6] */
601 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
602
603 /* 12th byte is for battery strength */
604 0x05, 0x06, /* GUsagePage Generic Device Controls */
605 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
606 0x14, /* GLogicalMinimum [0] */
607 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
608 0x75, 0x08, /* GReportSize 0x08 [8] */
609 0x95, 0x01, /* GReportCount 0x01 [1] */
610 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
611
612 0xC0, /* MEndCollection */
613
614 0xC0 /* MEndCollection [Game Pad] */
615};
616
617static const unsigned int ps3remote_keymap_joypad_buttons[] = {
618 [0x01] = KEY_SELECT,
619 [0x02] = BTN_THUMBL, /* L3 */
620 [0x03] = BTN_THUMBR, /* R3 */
621 [0x04] = BTN_START,
622 [0x05] = KEY_UP,
623 [0x06] = KEY_RIGHT,
624 [0x07] = KEY_DOWN,
625 [0x08] = KEY_LEFT,
626 [0x09] = BTN_TL2, /* L2 */
627 [0x0a] = BTN_TR2, /* R2 */
628 [0x0b] = BTN_TL, /* L1 */
629 [0x0c] = BTN_TR, /* R1 */
630 [0x0d] = KEY_OPTION, /* options/triangle */
631 [0x0e] = KEY_BACK, /* back/circle */
632 [0x0f] = BTN_0, /* cross */
633 [0x10] = KEY_SCREEN, /* view/square */
634 [0x11] = KEY_HOMEPAGE, /* PS button */
635 [0x14] = KEY_ENTER,
636};
637static const unsigned int ps3remote_keymap_remote_buttons[] = {
638 [0x00] = KEY_1,
639 [0x01] = KEY_2,
640 [0x02] = KEY_3,
641 [0x03] = KEY_4,
642 [0x04] = KEY_5,
643 [0x05] = KEY_6,
644 [0x06] = KEY_7,
645 [0x07] = KEY_8,
646 [0x08] = KEY_9,
647 [0x09] = KEY_0,
648 [0x0e] = KEY_ESC, /* return */
649 [0x0f] = KEY_CLEAR,
650 [0x16] = KEY_EJECTCD,
651 [0x1a] = KEY_MENU, /* top menu */
652 [0x28] = KEY_TIME,
653 [0x30] = KEY_PREVIOUS,
654 [0x31] = KEY_NEXT,
655 [0x32] = KEY_PLAY,
656 [0x33] = KEY_REWIND, /* scan back */
657 [0x34] = KEY_FORWARD, /* scan forward */
658 [0x38] = KEY_STOP,
659 [0x39] = KEY_PAUSE,
660 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
661 [0x60] = KEY_FRAMEBACK, /* slow/step back */
662 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
663 [0x63] = KEY_SUBTITLE,
664 [0x64] = KEY_AUDIO,
665 [0x65] = KEY_ANGLE,
666 [0x70] = KEY_INFO, /* display */
667 [0x80] = KEY_BLUE,
668 [0x81] = KEY_RED,
669 [0x82] = KEY_GREEN,
670 [0x83] = KEY_YELLOW,
671};
672
673static const unsigned int buzz_keymap[] = {
674 /*
675 * The controller has 4 remote buzzers, each with one LED and 5
676 * buttons.
677 *
678 * We use the mapping chosen by the controller, which is:
679 *
680 * Key Offset
681 * -------------------
682 * Buzz 1
683 * Blue 5
684 * Orange 4
685 * Green 3
686 * Yellow 2
687 *
688 * So, for example, the orange button on the third buzzer is mapped to
689 * BTN_TRIGGER_HAPPY14
690 */
691 [ 1] = BTN_TRIGGER_HAPPY1,
692 [ 2] = BTN_TRIGGER_HAPPY2,
693 [ 3] = BTN_TRIGGER_HAPPY3,
694 [ 4] = BTN_TRIGGER_HAPPY4,
695 [ 5] = BTN_TRIGGER_HAPPY5,
696 [ 6] = BTN_TRIGGER_HAPPY6,
697 [ 7] = BTN_TRIGGER_HAPPY7,
698 [ 8] = BTN_TRIGGER_HAPPY8,
699 [ 9] = BTN_TRIGGER_HAPPY9,
700 [10] = BTN_TRIGGER_HAPPY10,
701 [11] = BTN_TRIGGER_HAPPY11,
702 [12] = BTN_TRIGGER_HAPPY12,
703 [13] = BTN_TRIGGER_HAPPY13,
704 [14] = BTN_TRIGGER_HAPPY14,
705 [15] = BTN_TRIGGER_HAPPY15,
706 [16] = BTN_TRIGGER_HAPPY16,
707 [17] = BTN_TRIGGER_HAPPY17,
708 [18] = BTN_TRIGGER_HAPPY18,
709 [19] = BTN_TRIGGER_HAPPY19,
710 [20] = BTN_TRIGGER_HAPPY20,
711};
712
713static enum power_supply_property sony_battery_props[] = {
714 POWER_SUPPLY_PROP_PRESENT,
715 POWER_SUPPLY_PROP_CAPACITY,
716 POWER_SUPPLY_PROP_SCOPE,
717 POWER_SUPPLY_PROP_STATUS,
718};
719
720static spinlock_t sony_dev_list_lock;
721static LIST_HEAD(sony_device_list);
722
723struct sony_sc {
724 spinlock_t lock;
725 struct list_head list_node;
726 struct hid_device *hdev;
727 struct led_classdev *leds[MAX_LEDS];
728 unsigned long quirks;
729 struct work_struct state_worker;
730 struct power_supply battery;
731
732#ifdef CONFIG_SONY_FF
733 __u8 left;
734 __u8 right;
735#endif
736
737 __u8 mac_address[6];
738 __u8 worker_initialized;
739 __u8 cable_state;
740 __u8 battery_charging;
741 __u8 battery_capacity;
742 __u8 led_state[MAX_LEDS];
743 __u8 led_count;
744};
745
746static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
747 unsigned int *rsize)
748{
749 *rsize = sizeof(ps3remote_rdesc);
750 return ps3remote_rdesc;
751}
752
753static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
754 struct hid_field *field, struct hid_usage *usage,
755 unsigned long **bit, int *max)
756{
757 unsigned int key = usage->hid & HID_USAGE;
758
759 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
760 return -1;
761
762 switch (usage->collection_index) {
763 case 1:
764 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
765 return -1;
766
767 key = ps3remote_keymap_joypad_buttons[key];
768 if (!key)
769 return -1;
770 break;
771 case 2:
772 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
773 return -1;
774
775 key = ps3remote_keymap_remote_buttons[key];
776 if (!key)
777 return -1;
778 break;
779 default:
780 return -1;
781 }
782
783 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
784 return 1;
785}
786
787
788/* Sony Vaio VGX has wrongly mouse pointer declared as constant */
789static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
790 unsigned int *rsize)
791{
792 struct sony_sc *sc = hid_get_drvdata(hdev);
793
794 /*
795 * Some Sony RF receivers wrongly declare the mouse pointer as a
796 * a constant non-data variable.
797 */
798 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
799 /* usage page: generic desktop controls */
800 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
801 /* usage: mouse */
802 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
803 /* input (usage page for x,y axes): constant, variable, relative */
804 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
805 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
806 /* input: data, variable, relative */
807 rdesc[55] = 0x06;
808 }
809
810 /*
811 * The default Dualshock 4 USB descriptor doesn't assign
812 * the gyroscope values to corresponding axes so we need a
813 * modified one.
814 */
815 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
816 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
817 rdesc = dualshock4_usb_rdesc;
818 *rsize = sizeof(dualshock4_usb_rdesc);
819 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
820 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
821 rdesc = dualshock4_bt_rdesc;
822 *rsize = sizeof(dualshock4_bt_rdesc);
823 }
824
825 /* The HID descriptor exposed over BT has a trailing zero byte */
826 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
827 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
828 rdesc[83] == 0x75) {
829 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
830 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
831 sizeof(sixaxis_rdesc_fixup));
832 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
833 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
834 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
835 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
836 *rsize = sizeof(sixaxis_rdesc_fixup2);
837 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
838 }
839
840 if (sc->quirks & PS3REMOTE)
841 return ps3remote_fixup(hdev, rdesc, rsize);
842
843 return rdesc;
844}
845
846static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
847{
848 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
849 unsigned long flags;
850 __u8 cable_state, battery_capacity, battery_charging;
851
852 /*
853 * The sixaxis is charging if the battery value is 0xee
854 * and it is fully charged if the value is 0xef.
855 * It does not report the actual level while charging so it
856 * is set to 100% while charging is in progress.
857 */
858 if (rd[30] >= 0xee) {
859 battery_capacity = 100;
860 battery_charging = !(rd[30] & 0x01);
861 } else {
862 __u8 index = rd[30] <= 5 ? rd[30] : 5;
863 battery_capacity = sixaxis_battery_capacity[index];
864 battery_charging = 0;
865 }
866 cable_state = !(rd[31] & 0x04);
867
868 spin_lock_irqsave(&sc->lock, flags);
869 sc->cable_state = cable_state;
870 sc->battery_capacity = battery_capacity;
871 sc->battery_charging = battery_charging;
872 spin_unlock_irqrestore(&sc->lock, flags);
873}
874
875static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
876{
877 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
878 struct hid_input, list);
879 struct input_dev *input_dev = hidinput->input;
880 unsigned long flags;
881 int n, offset;
882 __u8 cable_state, battery_capacity, battery_charging;
883
884 /*
885 * Battery and touchpad data starts at byte 30 in the USB report and
886 * 32 in Bluetooth report.
887 */
888 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
889
890 /*
891 * The lower 4 bits of byte 30 contain the battery level
892 * and the 5th bit contains the USB cable state.
893 */
894 cable_state = (rd[offset] >> 4) & 0x01;
895 battery_capacity = rd[offset] & 0x0F;
896
897 /*
898 * When a USB power source is connected the battery level ranges from
899 * 0 to 10, and when running on battery power it ranges from 0 to 9.
900 * A battery level above 10 when plugged in means charge completed.
901 */
902 if (!cable_state || battery_capacity > 10)
903 battery_charging = 0;
904 else
905 battery_charging = 1;
906
907 if (!cable_state)
908 battery_capacity++;
909 if (battery_capacity > 10)
910 battery_capacity = 10;
911
912 battery_capacity *= 10;
913
914 spin_lock_irqsave(&sc->lock, flags);
915 sc->cable_state = cable_state;
916 sc->battery_capacity = battery_capacity;
917 sc->battery_charging = battery_charging;
918 spin_unlock_irqrestore(&sc->lock, flags);
919
920 offset += 5;
921
922 /*
923 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
924 * and 37 on Bluetooth.
925 * The first 7 bits of the first byte is a counter and bit 8 is a touch
926 * indicator that is 0 when pressed and 1 when not pressed.
927 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
928 * The data for the second touch is in the same format and immediatly
929 * follows the data for the first.
930 */
931 for (n = 0; n < 2; n++) {
932 __u16 x, y;
933
934 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
935 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
936
937 input_mt_slot(input_dev, n);
938 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
939 !(rd[offset] >> 7));
940 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
941 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
942
943 offset += 4;
944 }
945}
946
947static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
948 __u8 *rd, int size)
949{
950 struct sony_sc *sc = hid_get_drvdata(hdev);
951
952 /*
953 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
954 * has to be BYTE_SWAPPED before passing up to joystick interface
955 */
956 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
957 swap(rd[41], rd[42]);
958 swap(rd[43], rd[44]);
959 swap(rd[45], rd[46]);
960 swap(rd[47], rd[48]);
961
962 sixaxis_parse_report(sc, rd, size);
963 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
964 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
965 && rd[0] == 0x11 && size == 78)) {
966 dualshock4_parse_report(sc, rd, size);
967 }
968
969 return 0;
970}
971
972static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
973 struct hid_field *field, struct hid_usage *usage,
974 unsigned long **bit, int *max)
975{
976 struct sony_sc *sc = hid_get_drvdata(hdev);
977
978 if (sc->quirks & BUZZ_CONTROLLER) {
979 unsigned int key = usage->hid & HID_USAGE;
980
981 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
982 return -1;
983
984 switch (usage->collection_index) {
985 case 1:
986 if (key >= ARRAY_SIZE(buzz_keymap))
987 return -1;
988
989 key = buzz_keymap[key];
990 if (!key)
991 return -1;
992 break;
993 default:
994 return -1;
995 }
996
997 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
998 return 1;
999 }
1000
1001 if (sc->quirks & PS3REMOTE)
1002 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1003
1004 /* Let hid-core decide for the others */
1005 return 0;
1006}
1007
1008/*
1009 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1010 * to "operational". Without this, the ps3 controller will not report any
1011 * events.
1012 */
1013static int sixaxis_set_operational_usb(struct hid_device *hdev)
1014{
1015 int ret;
1016 char *buf = kmalloc(18, GFP_KERNEL);
1017
1018 if (!buf)
1019 return -ENOMEM;
1020
1021 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1022 HID_REQ_GET_REPORT);
1023
1024 if (ret < 0)
1025 hid_err(hdev, "can't set operational mode\n");
1026
1027 kfree(buf);
1028
1029 return ret;
1030}
1031
1032static int sixaxis_set_operational_bt(struct hid_device *hdev)
1033{
1034 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1035 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
1036 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1037}
1038
1039/*
1040 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
1041 * controller so that it sends full input reports of type 0x11.
1042 */
1043static int dualshock4_set_operational_bt(struct hid_device *hdev)
1044{
1045 __u8 buf[37] = { 0 };
1046
1047 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf),
1048 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1049}
1050
1051static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
1052{
1053 struct list_head *report_list =
1054 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1055 struct hid_report *report = list_entry(report_list->next,
1056 struct hid_report, list);
1057 __s32 *value = report->field[0]->value;
1058
1059 value[0] = 0x00;
1060 value[1] = leds[0] ? 0xff : 0x00;
1061 value[2] = leds[1] ? 0xff : 0x00;
1062 value[3] = leds[2] ? 0xff : 0x00;
1063 value[4] = leds[3] ? 0xff : 0x00;
1064 value[5] = 0x00;
1065 value[6] = 0x00;
1066 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1067}
1068
1069static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
1070{
1071 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1072 int n;
1073
1074 BUG_ON(count > MAX_LEDS);
1075
1076 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
1077 buzz_set_leds(hdev, leds);
1078 } else {
1079 for (n = 0; n < count; n++)
1080 drv_data->led_state[n] = leds[n];
1081 schedule_work(&drv_data->state_worker);
1082 }
1083}
1084
1085static void sony_led_set_brightness(struct led_classdev *led,
1086 enum led_brightness value)
1087{
1088 struct device *dev = led->dev->parent;
1089 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1090 struct sony_sc *drv_data;
1091
1092 int n;
1093
1094 drv_data = hid_get_drvdata(hdev);
1095 if (!drv_data) {
1096 hid_err(hdev, "No device data\n");
1097 return;
1098 }
1099
1100 for (n = 0; n < drv_data->led_count; n++) {
1101 if (led == drv_data->leds[n]) {
1102 if (value != drv_data->led_state[n]) {
1103 drv_data->led_state[n] = value;
1104 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
1105 }
1106 break;
1107 }
1108 }
1109}
1110
1111static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1112{
1113 struct device *dev = led->dev->parent;
1114 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1115 struct sony_sc *drv_data;
1116
1117 int n;
1118
1119 drv_data = hid_get_drvdata(hdev);
1120 if (!drv_data) {
1121 hid_err(hdev, "No device data\n");
1122 return LED_OFF;
1123 }
1124
1125 for (n = 0; n < drv_data->led_count; n++) {
1126 if (led == drv_data->leds[n])
1127 return drv_data->led_state[n];
1128 }
1129
1130 return LED_OFF;
1131}
1132
1133static void sony_leds_remove(struct hid_device *hdev)
1134{
1135 struct sony_sc *drv_data;
1136 struct led_classdev *led;
1137 int n;
1138
1139 drv_data = hid_get_drvdata(hdev);
1140 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
1141
1142 for (n = 0; n < drv_data->led_count; n++) {
1143 led = drv_data->leds[n];
1144 drv_data->leds[n] = NULL;
1145 if (!led)
1146 continue;
1147 led_classdev_unregister(led);
1148 kfree(led);
1149 }
1150
1151 drv_data->led_count = 0;
1152}
1153
1154static int sony_leds_init(struct hid_device *hdev)
1155{
1156 struct sony_sc *drv_data;
1157 int n, ret = 0;
1158 int max_brightness;
1159 int use_colors;
1160 struct led_classdev *led;
1161 size_t name_sz;
1162 char *name;
1163 size_t name_len;
1164 const char *name_fmt;
1165 static const char * const color_str[] = { "red", "green", "blue" };
1166 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
1167
1168 drv_data = hid_get_drvdata(hdev);
1169 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
1170
1171 if (drv_data->quirks & BUZZ_CONTROLLER) {
1172 drv_data->led_count = 4;
1173 max_brightness = 1;
1174 use_colors = 0;
1175 name_len = strlen("::buzz#");
1176 name_fmt = "%s::buzz%d";
1177 /* Validate expected report characteristics. */
1178 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1179 return -ENODEV;
1180 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER) {
1181 drv_data->led_count = 3;
1182 max_brightness = 255;
1183 use_colors = 1;
1184 name_len = 0;
1185 name_fmt = "%s:%s";
1186 } else {
1187 drv_data->led_count = 4;
1188 max_brightness = 1;
1189 use_colors = 0;
1190 name_len = strlen("::sony#");
1191 name_fmt = "%s::sony%d";
1192 }
1193
1194 /*
1195 * Clear LEDs as we have no way of reading their initial state. This is
1196 * only relevant if the driver is loaded after somebody actively set the
1197 * LEDs to on
1198 */
1199 sony_set_leds(hdev, initial_values, drv_data->led_count);
1200
1201 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
1202
1203 for (n = 0; n < drv_data->led_count; n++) {
1204
1205 if (use_colors)
1206 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
1207
1208 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1209 if (!led) {
1210 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
1211 ret = -ENOMEM;
1212 goto error_leds;
1213 }
1214
1215 name = (void *)(&led[1]);
1216 if (use_colors)
1217 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
1218 else
1219 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1220 led->name = name;
1221 led->brightness = 0;
1222 led->max_brightness = max_brightness;
1223 led->brightness_get = sony_led_get_brightness;
1224 led->brightness_set = sony_led_set_brightness;
1225
1226 ret = led_classdev_register(&hdev->dev, led);
1227 if (ret) {
1228 hid_err(hdev, "Failed to register LED %d\n", n);
1229 kfree(led);
1230 goto error_leds;
1231 }
1232
1233 drv_data->leds[n] = led;
1234 }
1235
1236 return ret;
1237
1238error_leds:
1239 sony_leds_remove(hdev);
1240
1241 return ret;
1242}
1243
1244static void sixaxis_state_worker(struct work_struct *work)
1245{
1246 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1247 unsigned char buf[] = {
1248 0x01,
1249 0x00, 0xff, 0x00, 0xff, 0x00,
1250 0x00, 0x00, 0x00, 0x00, 0x00,
1251 0xff, 0x27, 0x10, 0x00, 0x32,
1252 0xff, 0x27, 0x10, 0x00, 0x32,
1253 0xff, 0x27, 0x10, 0x00, 0x32,
1254 0xff, 0x27, 0x10, 0x00, 0x32,
1255 0x00, 0x00, 0x00, 0x00, 0x00
1256 };
1257
1258#ifdef CONFIG_SONY_FF
1259 buf[3] = sc->right ? 1 : 0;
1260 buf[5] = sc->left;
1261#endif
1262
1263 buf[10] |= sc->led_state[0] << 1;
1264 buf[10] |= sc->led_state[1] << 2;
1265 buf[10] |= sc->led_state[2] << 3;
1266 buf[10] |= sc->led_state[3] << 4;
1267
1268 hid_hw_raw_request(sc->hdev, 0x01, buf, sizeof(buf), HID_OUTPUT_REPORT,
1269 HID_REQ_SET_REPORT);
1270}
1271
1272static void dualshock4_state_worker(struct work_struct *work)
1273{
1274 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1275 struct hid_device *hdev = sc->hdev;
1276 int offset;
1277
1278 __u8 buf[78] = { 0 };
1279
1280 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1281 buf[0] = 0x05;
1282 buf[1] = 0x03;
1283 offset = 4;
1284 } else {
1285 buf[0] = 0x11;
1286 buf[1] = 0xB0;
1287 buf[3] = 0x0F;
1288 offset = 6;
1289 }
1290
1291#ifdef CONFIG_SONY_FF
1292 buf[offset++] = sc->right;
1293 buf[offset++] = sc->left;
1294#else
1295 offset += 2;
1296#endif
1297
1298 buf[offset++] = sc->led_state[0];
1299 buf[offset++] = sc->led_state[1];
1300 buf[offset++] = sc->led_state[2];
1301
1302 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1303 hid_hw_output_report(hdev, buf, 32);
1304 else
1305 hid_hw_raw_request(hdev, 0x11, buf, 78,
1306 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1307}
1308
1309#ifdef CONFIG_SONY_FF
1310static int sony_play_effect(struct input_dev *dev, void *data,
1311 struct ff_effect *effect)
1312{
1313 struct hid_device *hid = input_get_drvdata(dev);
1314 struct sony_sc *sc = hid_get_drvdata(hid);
1315
1316 if (effect->type != FF_RUMBLE)
1317 return 0;
1318
1319 sc->left = effect->u.rumble.strong_magnitude / 256;
1320 sc->right = effect->u.rumble.weak_magnitude / 256;
1321
1322 schedule_work(&sc->state_worker);
1323 return 0;
1324}
1325
1326static int sony_init_ff(struct hid_device *hdev)
1327{
1328 struct hid_input *hidinput = list_entry(hdev->inputs.next,
1329 struct hid_input, list);
1330 struct input_dev *input_dev = hidinput->input;
1331
1332 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1333 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1334}
1335
1336#else
1337static int sony_init_ff(struct hid_device *hdev)
1338{
1339 return 0;
1340}
1341
1342#endif
1343
1344static int sony_battery_get_property(struct power_supply *psy,
1345 enum power_supply_property psp,
1346 union power_supply_propval *val)
1347{
1348 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1349 unsigned long flags;
1350 int ret = 0;
1351 u8 battery_charging, battery_capacity, cable_state;
1352
1353 spin_lock_irqsave(&sc->lock, flags);
1354 battery_charging = sc->battery_charging;
1355 battery_capacity = sc->battery_capacity;
1356 cable_state = sc->cable_state;
1357 spin_unlock_irqrestore(&sc->lock, flags);
1358
1359 switch (psp) {
1360 case POWER_SUPPLY_PROP_PRESENT:
1361 val->intval = 1;
1362 break;
1363 case POWER_SUPPLY_PROP_SCOPE:
1364 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1365 break;
1366 case POWER_SUPPLY_PROP_CAPACITY:
1367 val->intval = battery_capacity;
1368 break;
1369 case POWER_SUPPLY_PROP_STATUS:
1370 if (battery_charging)
1371 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1372 else
1373 if (battery_capacity == 100 && cable_state)
1374 val->intval = POWER_SUPPLY_STATUS_FULL;
1375 else
1376 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1377 break;
1378 default:
1379 ret = -EINVAL;
1380 break;
1381 }
1382 return ret;
1383}
1384
1385static int sony_battery_probe(struct sony_sc *sc)
1386{
1387 static atomic_t power_id_seq = ATOMIC_INIT(0);
1388 unsigned long power_id;
1389 struct hid_device *hdev = sc->hdev;
1390 int ret;
1391
1392 /*
1393 * Set the default battery level to 100% to avoid low battery warnings
1394 * if the battery is polled before the first device report is received.
1395 */
1396 sc->battery_capacity = 100;
1397
1398 power_id = (unsigned long)atomic_inc_return(&power_id_seq);
1399
1400 sc->battery.properties = sony_battery_props;
1401 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1402 sc->battery.get_property = sony_battery_get_property;
1403 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1404 sc->battery.use_for_apm = 0;
1405 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%lu",
1406 power_id);
1407 if (!sc->battery.name)
1408 return -ENOMEM;
1409
1410 ret = power_supply_register(&hdev->dev, &sc->battery);
1411 if (ret) {
1412 hid_err(hdev, "Unable to register battery device\n");
1413 goto err_free;
1414 }
1415
1416 power_supply_powers(&sc->battery, &hdev->dev);
1417 return 0;
1418
1419err_free:
1420 kfree(sc->battery.name);
1421 sc->battery.name = NULL;
1422 return ret;
1423}
1424
1425static void sony_battery_remove(struct sony_sc *sc)
1426{
1427 if (!sc->battery.name)
1428 return;
1429
1430 power_supply_unregister(&sc->battery);
1431 kfree(sc->battery.name);
1432 sc->battery.name = NULL;
1433}
1434
1435static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1436 int w, int h)
1437{
1438 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1439 struct hid_input, list);
1440 struct input_dev *input_dev = hidinput->input;
1441 int ret;
1442
1443 ret = input_mt_init_slots(input_dev, touch_count, 0);
1444 if (ret < 0) {
1445 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1446 return ret;
1447 }
1448
1449 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1450 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1451
1452 return 0;
1453}
1454
1455/*
1456 * If a controller is plugged in via USB while already connected via Bluetooth
1457 * it will show up as two devices. A global list of connected controllers and
1458 * their MAC addresses is maintained to ensure that a device is only connected
1459 * once.
1460 */
1461static int sony_check_add_dev_list(struct sony_sc *sc)
1462{
1463 struct sony_sc *entry;
1464 unsigned long flags;
1465 int ret;
1466
1467 spin_lock_irqsave(&sony_dev_list_lock, flags);
1468
1469 list_for_each_entry(entry, &sony_device_list, list_node) {
1470 ret = memcmp(sc->mac_address, entry->mac_address,
1471 sizeof(sc->mac_address));
1472 if (!ret) {
1473 ret = -EEXIST;
1474 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1475 sc->mac_address);
1476 goto unlock;
1477 }
1478 }
1479
1480 ret = 0;
1481 list_add(&(sc->list_node), &sony_device_list);
1482
1483unlock:
1484 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1485 return ret;
1486}
1487
1488static void sony_remove_dev_list(struct sony_sc *sc)
1489{
1490 unsigned long flags;
1491
1492 if (sc->list_node.next) {
1493 spin_lock_irqsave(&sony_dev_list_lock, flags);
1494 list_del(&(sc->list_node));
1495 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1496 }
1497}
1498
1499static int sony_get_bt_devaddr(struct sony_sc *sc)
1500{
1501 int ret;
1502
1503 /* HIDP stores the device MAC address as a string in the uniq field. */
1504 ret = strlen(sc->hdev->uniq);
1505 if (ret != 17)
1506 return -EINVAL;
1507
1508 ret = sscanf(sc->hdev->uniq,
1509 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1510 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1511 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1512
1513 if (ret != 6)
1514 return -EINVAL;
1515
1516 return 0;
1517}
1518
1519static int sony_check_add(struct sony_sc *sc)
1520{
1521 int n, ret;
1522
1523 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1524 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1525 /*
1526 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1527 * address from the uniq string where HIDP stores it.
1528 * As uniq cannot be guaranteed to be a MAC address in all cases
1529 * a failure of this function should not prevent the connection.
1530 */
1531 if (sony_get_bt_devaddr(sc) < 0) {
1532 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1533 return 0;
1534 }
1535 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1536 __u8 buf[7];
1537
1538 /*
1539 * The MAC address of a DS4 controller connected via USB can be
1540 * retrieved with feature report 0x81. The address begins at
1541 * offset 1.
1542 */
1543 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1544 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1545
1546 if (ret != 7) {
1547 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1548 return ret < 0 ? ret : -EINVAL;
1549 }
1550
1551 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1552 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1553 __u8 buf[18];
1554
1555 /*
1556 * The MAC address of a Sixaxis controller connected via USB can
1557 * be retrieved with feature report 0xf2. The address begins at
1558 * offset 4.
1559 */
1560 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1561 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1562
1563 if (ret != 18) {
1564 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1565 return ret < 0 ? ret : -EINVAL;
1566 }
1567
1568 /*
1569 * The Sixaxis device MAC in the report is big-endian and must
1570 * be byte-swapped.
1571 */
1572 for (n = 0; n < 6; n++)
1573 sc->mac_address[5-n] = buf[4+n];
1574 } else {
1575 return 0;
1576 }
1577
1578 return sony_check_add_dev_list(sc);
1579}
1580
1581
1582static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1583{
1584 int ret;
1585 unsigned long quirks = id->driver_data;
1586 struct sony_sc *sc;
1587 unsigned int connect_mask = HID_CONNECT_DEFAULT;
1588
1589 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
1590 if (sc == NULL) {
1591 hid_err(hdev, "can't alloc sony descriptor\n");
1592 return -ENOMEM;
1593 }
1594
1595 sc->quirks = quirks;
1596 hid_set_drvdata(hdev, sc);
1597 sc->hdev = hdev;
1598
1599 ret = hid_parse(hdev);
1600 if (ret) {
1601 hid_err(hdev, "parse failed\n");
1602 return ret;
1603 }
1604
1605 if (sc->quirks & VAIO_RDESC_CONSTANT)
1606 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1607 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1608 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1609 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1610 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1611
1612 ret = hid_hw_start(hdev, connect_mask);
1613 if (ret) {
1614 hid_err(hdev, "hw start failed\n");
1615 return ret;
1616 }
1617
1618 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1619 /*
1620 * The Sony Sixaxis does not handle HID Output Reports on the
1621 * Interrupt EP like it could, so we need to force HID Output
1622 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1623 *
1624 * There is also another issue about HID Output Reports via USB,
1625 * the Sixaxis does not want the report_id as part of the data
1626 * packet, so we have to discard buf[0] when sending the actual
1627 * control message, even for numbered reports, humpf!
1628 */
1629 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1630 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1631 ret = sixaxis_set_operational_usb(hdev);
1632 sc->worker_initialized = 1;
1633 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1634 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1635 /*
1636 * The Sixaxis wants output reports sent on the ctrl endpoint
1637 * when connected via Bluetooth.
1638 */
1639 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1640 ret = sixaxis_set_operational_bt(hdev);
1641 sc->worker_initialized = 1;
1642 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1643 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1644 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
1645 /*
1646 * The DualShock 4 wants output reports sent on the ctrl
1647 * endpoint when connected via Bluetooth.
1648 */
1649 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1650 ret = dualshock4_set_operational_bt(hdev);
1651 if (ret < 0) {
1652 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1653 goto err_stop;
1654 }
1655 }
1656 /*
1657 * The Dualshock 4 touchpad supports 2 touches and has a
1658 * resolution of 1920x940.
1659 */
1660 ret = sony_register_touchpad(sc, 2, 1920, 940);
1661 if (ret < 0)
1662 goto err_stop;
1663
1664 sc->worker_initialized = 1;
1665 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1666 } else {
1667 ret = 0;
1668 }
1669
1670 if (ret < 0)
1671 goto err_stop;
1672
1673 ret = sony_check_add(sc);
1674 if (ret < 0)
1675 goto err_stop;
1676
1677 if (sc->quirks & SONY_LED_SUPPORT) {
1678 ret = sony_leds_init(hdev);
1679 if (ret < 0)
1680 goto err_stop;
1681 }
1682
1683 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1684 ret = sony_battery_probe(sc);
1685 if (ret < 0)
1686 goto err_stop;
1687
1688 /* Open the device to receive reports with battery info */
1689 ret = hid_hw_open(hdev);
1690 if (ret < 0) {
1691 hid_err(hdev, "hw open failed\n");
1692 goto err_stop;
1693 }
1694 }
1695
1696 if (sc->quirks & SONY_FF_SUPPORT) {
1697 ret = sony_init_ff(hdev);
1698 if (ret < 0)
1699 goto err_close;
1700 }
1701
1702 return 0;
1703err_close:
1704 hid_hw_close(hdev);
1705err_stop:
1706 if (sc->quirks & SONY_LED_SUPPORT)
1707 sony_leds_remove(hdev);
1708 if (sc->quirks & SONY_BATTERY_SUPPORT)
1709 sony_battery_remove(sc);
1710 if (sc->worker_initialized)
1711 cancel_work_sync(&sc->state_worker);
1712 sony_remove_dev_list(sc);
1713 hid_hw_stop(hdev);
1714 return ret;
1715}
1716
1717static void sony_remove(struct hid_device *hdev)
1718{
1719 struct sony_sc *sc = hid_get_drvdata(hdev);
1720
1721 if (sc->quirks & SONY_LED_SUPPORT)
1722 sony_leds_remove(hdev);
1723
1724 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1725 hid_hw_close(hdev);
1726 sony_battery_remove(sc);
1727 }
1728
1729 if (sc->worker_initialized)
1730 cancel_work_sync(&sc->state_worker);
1731
1732 sony_remove_dev_list(sc);
1733
1734 hid_hw_stop(hdev);
1735}
1736
1737static const struct hid_device_id sony_devices[] = {
1738 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1739 .driver_data = SIXAXIS_CONTROLLER_USB },
1740 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1741 .driver_data = SIXAXIS_CONTROLLER_USB },
1742 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1743 .driver_data = SIXAXIS_CONTROLLER_BT },
1744 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1745 .driver_data = VAIO_RDESC_CONSTANT },
1746 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1747 .driver_data = VAIO_RDESC_CONSTANT },
1748 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1749 * Logitech joystick from the device descriptor. */
1750 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1751 .driver_data = BUZZ_CONTROLLER },
1752 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1753 .driver_data = BUZZ_CONTROLLER },
1754 /* PS3 BD Remote Control */
1755 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1756 .driver_data = PS3REMOTE },
1757 /* Logitech Harmony Adapter for PS3 */
1758 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1759 .driver_data = PS3REMOTE },
1760 /* Sony Dualshock 4 controllers for PS4 */
1761 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1762 .driver_data = DUALSHOCK4_CONTROLLER_USB },
1763 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
1764 .driver_data = DUALSHOCK4_CONTROLLER_BT },
1765 { }
1766};
1767MODULE_DEVICE_TABLE(hid, sony_devices);
1768
1769static struct hid_driver sony_driver = {
1770 .name = "sony",
1771 .id_table = sony_devices,
1772 .input_mapping = sony_mapping,
1773 .probe = sony_probe,
1774 .remove = sony_remove,
1775 .report_fixup = sony_report_fixup,
1776 .raw_event = sony_raw_event
1777};
1778module_hid_driver(sony_driver);
1779
1780MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
4 *
5 * Copyright (c) 1999 Andreas Gal
6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
8 * Copyright (c) 2008 Jiri Slaby
9 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
10 * Copyright (c) 2006-2013 Jiri Kosina
11 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
12 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
13 * Copyright (c) 2018 Todd Kelner
14 * Copyright (c) 2020-2021 Pascal Giard <pascal.giard@etsmtl.ca>
15 * Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
16 * Copyright (c) 2021 Daniel Nguyen <daniel.nguyen.1@ens.etsmtl.ca>
17 */
18
19/*
20 */
21
22/*
23 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
24 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
25 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
26 *
27 * There will be no PIN request from the device.
28 */
29
30#include <linux/device.h>
31#include <linux/hid.h>
32#include <linux/module.h>
33#include <linux/slab.h>
34#include <linux/leds.h>
35#include <linux/power_supply.h>
36#include <linux/spinlock.h>
37#include <linux/list.h>
38#include <linux/idr.h>
39#include <linux/input/mt.h>
40#include <linux/crc32.h>
41#include <linux/usb.h>
42#include <linux/timer.h>
43#include <linux/unaligned.h>
44
45#include "hid-ids.h"
46
47#define VAIO_RDESC_CONSTANT BIT(0)
48#define SIXAXIS_CONTROLLER_USB BIT(1)
49#define SIXAXIS_CONTROLLER_BT BIT(2)
50#define BUZZ_CONTROLLER BIT(3)
51#define PS3REMOTE BIT(4)
52#define MOTION_CONTROLLER_USB BIT(5)
53#define MOTION_CONTROLLER_BT BIT(6)
54#define NAVIGATION_CONTROLLER_USB BIT(7)
55#define NAVIGATION_CONTROLLER_BT BIT(8)
56#define SINO_LITE_CONTROLLER BIT(9)
57#define FUTUREMAX_DANCE_MAT BIT(10)
58#define NSG_MR5U_REMOTE_BT BIT(11)
59#define NSG_MR7U_REMOTE_BT BIT(12)
60#define SHANWAN_GAMEPAD BIT(13)
61#define GH_GUITAR_CONTROLLER BIT(14)
62#define GHL_GUITAR_PS3WIIU BIT(15)
63#define GHL_GUITAR_PS4 BIT(16)
64
65#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
66#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
67#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
68 NAVIGATION_CONTROLLER_BT)
69#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
70 MOTION_CONTROLLER | NAVIGATION_CONTROLLER)
71#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
72#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | MOTION_CONTROLLER)
73#define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
74#define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
75
76#define MAX_LEDS 4
77#define NSG_MRXU_MAX_X 1667
78#define NSG_MRXU_MAX_Y 1868
79
80/* The PS3/Wii U dongles require a poke every 10 seconds, but the PS4
81 * requires one every 8 seconds. Using 8 seconds for all for simplicity.
82 */
83#define GHL_GUITAR_POKE_INTERVAL 8 /* In seconds */
84#define GUITAR_TILT_USAGE 44
85
86/* Magic data taken from GHLtarUtility:
87 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
88 * Note: The Wii U and PS3 dongles happen to share the same!
89 */
90static const char ghl_ps3wiiu_magic_data[] = {
91 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
92};
93
94/* Magic data for the PS4 dongles sniffed with a USB protocol
95 * analyzer.
96 */
97static const char ghl_ps4_magic_data[] = {
98 0x30, 0x02, 0x08, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00
99};
100
101/* PS/3 Motion controller */
102static const u8 motion_rdesc[] = {
103 0x05, 0x01, /* Usage Page (Desktop), */
104 0x09, 0x04, /* Usage (Joystick), */
105 0xA1, 0x01, /* Collection (Application), */
106 0xA1, 0x02, /* Collection (Logical), */
107 0x85, 0x01, /* Report ID (1), */
108 0x75, 0x01, /* Report Size (1), */
109 0x95, 0x15, /* Report Count (21), */
110 0x15, 0x00, /* Logical Minimum (0), */
111 0x25, 0x01, /* Logical Maximum (1), */
112 0x35, 0x00, /* Physical Minimum (0), */
113 0x45, 0x01, /* Physical Maximum (1), */
114 0x05, 0x09, /* Usage Page (Button), */
115 0x19, 0x01, /* Usage Minimum (01h), */
116 0x29, 0x15, /* Usage Maximum (15h), */
117 0x81, 0x02, /* Input (Variable), * Buttons */
118 0x95, 0x0B, /* Report Count (11), */
119 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
120 0x81, 0x03, /* Input (Constant, Variable), * Padding */
121 0x15, 0x00, /* Logical Minimum (0), */
122 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
123 0x05, 0x01, /* Usage Page (Desktop), */
124 0xA1, 0x00, /* Collection (Physical), */
125 0x75, 0x08, /* Report Size (8), */
126 0x95, 0x01, /* Report Count (1), */
127 0x35, 0x00, /* Physical Minimum (0), */
128 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
129 0x09, 0x30, /* Usage (X), */
130 0x81, 0x02, /* Input (Variable), * Trigger */
131 0xC0, /* End Collection, */
132 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
133 0x75, 0x08, /* Report Size (8), */
134 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
135 0x81, 0x02, /* Input (Variable), */
136 0x05, 0x01, /* Usage Page (Desktop), */
137 0x75, 0x10, /* Report Size (16), */
138 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
139 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
140 0x95, 0x03, /* Report Count (3), * 3x Accels */
141 0x09, 0x33, /* Usage (rX), */
142 0x09, 0x34, /* Usage (rY), */
143 0x09, 0x35, /* Usage (rZ), */
144 0x81, 0x02, /* Input (Variable), */
145 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
146 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
147 0x81, 0x02, /* Input (Variable), */
148 0x05, 0x01, /* Usage Page (Desktop), */
149 0x09, 0x01, /* Usage (Pointer), */
150 0x95, 0x03, /* Report Count (3), * 3x Gyros */
151 0x81, 0x02, /* Input (Variable), */
152 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
153 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
154 0x81, 0x02, /* Input (Variable), */
155 0x75, 0x0C, /* Report Size (12), */
156 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
157 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
158 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
159 0x81, 0x02, /* Input (Variable), */
160 0x75, 0x08, /* Report Size (8), */
161 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
162 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
163 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
164 0x81, 0x02, /* Input (Variable), */
165 0x75, 0x08, /* Report Size (8), */
166 0x95, 0x30, /* Report Count (48), */
167 0x09, 0x01, /* Usage (Pointer), */
168 0x91, 0x02, /* Output (Variable), */
169 0x75, 0x08, /* Report Size (8), */
170 0x95, 0x30, /* Report Count (48), */
171 0x09, 0x01, /* Usage (Pointer), */
172 0xB1, 0x02, /* Feature (Variable), */
173 0xC0, /* End Collection, */
174 0xA1, 0x02, /* Collection (Logical), */
175 0x85, 0x02, /* Report ID (2), */
176 0x75, 0x08, /* Report Size (8), */
177 0x95, 0x30, /* Report Count (48), */
178 0x09, 0x01, /* Usage (Pointer), */
179 0xB1, 0x02, /* Feature (Variable), */
180 0xC0, /* End Collection, */
181 0xA1, 0x02, /* Collection (Logical), */
182 0x85, 0xEE, /* Report ID (238), */
183 0x75, 0x08, /* Report Size (8), */
184 0x95, 0x30, /* Report Count (48), */
185 0x09, 0x01, /* Usage (Pointer), */
186 0xB1, 0x02, /* Feature (Variable), */
187 0xC0, /* End Collection, */
188 0xA1, 0x02, /* Collection (Logical), */
189 0x85, 0xEF, /* Report ID (239), */
190 0x75, 0x08, /* Report Size (8), */
191 0x95, 0x30, /* Report Count (48), */
192 0x09, 0x01, /* Usage (Pointer), */
193 0xB1, 0x02, /* Feature (Variable), */
194 0xC0, /* End Collection, */
195 0xC0 /* End Collection */
196};
197
198static const u8 ps3remote_rdesc[] = {
199 0x05, 0x01, /* GUsagePage Generic Desktop */
200 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
201 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
202
203 /* Use collection 1 for joypad buttons */
204 0xA1, 0x02, /* MCollection Logical (interrelated data) */
205
206 /*
207 * Ignore the 1st byte, maybe it is used for a controller
208 * number but it's not needed for correct operation
209 */
210 0x75, 0x08, /* GReportSize 0x08 [8] */
211 0x95, 0x01, /* GReportCount 0x01 [1] */
212 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
213
214 /*
215 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
216 * buttons multiple keypresses are allowed
217 */
218 0x05, 0x09, /* GUsagePage Button */
219 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
220 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
221 0x14, /* GLogicalMinimum [0] */
222 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
223 0x75, 0x01, /* GReportSize 0x01 [1] */
224 0x95, 0x18, /* GReportCount 0x18 [24] */
225 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
226
227 0xC0, /* MEndCollection */
228
229 /* Use collection 2 for remote control buttons */
230 0xA1, 0x02, /* MCollection Logical (interrelated data) */
231
232 /* 5th byte is used for remote control buttons */
233 0x05, 0x09, /* GUsagePage Button */
234 0x18, /* LUsageMinimum [No button pressed] */
235 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
236 0x14, /* GLogicalMinimum [0] */
237 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
238 0x75, 0x08, /* GReportSize 0x08 [8] */
239 0x95, 0x01, /* GReportCount 0x01 [1] */
240 0x80, /* MInput */
241
242 /*
243 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
244 * 0xff and 11th is for press indication
245 */
246 0x75, 0x08, /* GReportSize 0x08 [8] */
247 0x95, 0x06, /* GReportCount 0x06 [6] */
248 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
249
250 /* 12th byte is for battery strength */
251 0x05, 0x06, /* GUsagePage Generic Device Controls */
252 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
253 0x14, /* GLogicalMinimum [0] */
254 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
255 0x75, 0x08, /* GReportSize 0x08 [8] */
256 0x95, 0x01, /* GReportCount 0x01 [1] */
257 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
258
259 0xC0, /* MEndCollection */
260
261 0xC0 /* MEndCollection [Game Pad] */
262};
263
264static const unsigned int ps3remote_keymap_joypad_buttons[] = {
265 [0x01] = KEY_SELECT,
266 [0x02] = BTN_THUMBL, /* L3 */
267 [0x03] = BTN_THUMBR, /* R3 */
268 [0x04] = BTN_START,
269 [0x05] = KEY_UP,
270 [0x06] = KEY_RIGHT,
271 [0x07] = KEY_DOWN,
272 [0x08] = KEY_LEFT,
273 [0x09] = BTN_TL2, /* L2 */
274 [0x0a] = BTN_TR2, /* R2 */
275 [0x0b] = BTN_TL, /* L1 */
276 [0x0c] = BTN_TR, /* R1 */
277 [0x0d] = KEY_OPTION, /* options/triangle */
278 [0x0e] = KEY_BACK, /* back/circle */
279 [0x0f] = BTN_0, /* cross */
280 [0x10] = KEY_SCREEN, /* view/square */
281 [0x11] = KEY_HOMEPAGE, /* PS button */
282 [0x14] = KEY_ENTER,
283};
284static const unsigned int ps3remote_keymap_remote_buttons[] = {
285 [0x00] = KEY_1,
286 [0x01] = KEY_2,
287 [0x02] = KEY_3,
288 [0x03] = KEY_4,
289 [0x04] = KEY_5,
290 [0x05] = KEY_6,
291 [0x06] = KEY_7,
292 [0x07] = KEY_8,
293 [0x08] = KEY_9,
294 [0x09] = KEY_0,
295 [0x0e] = KEY_ESC, /* return */
296 [0x0f] = KEY_CLEAR,
297 [0x16] = KEY_EJECTCD,
298 [0x1a] = KEY_MENU, /* top menu */
299 [0x28] = KEY_TIME,
300 [0x30] = KEY_PREVIOUS,
301 [0x31] = KEY_NEXT,
302 [0x32] = KEY_PLAY,
303 [0x33] = KEY_REWIND, /* scan back */
304 [0x34] = KEY_FORWARD, /* scan forward */
305 [0x38] = KEY_STOP,
306 [0x39] = KEY_PAUSE,
307 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
308 [0x60] = KEY_FRAMEBACK, /* slow/step back */
309 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
310 [0x63] = KEY_SUBTITLE,
311 [0x64] = KEY_AUDIO,
312 [0x65] = KEY_ANGLE,
313 [0x70] = KEY_INFO, /* display */
314 [0x80] = KEY_BLUE,
315 [0x81] = KEY_RED,
316 [0x82] = KEY_GREEN,
317 [0x83] = KEY_YELLOW,
318};
319
320static const unsigned int buzz_keymap[] = {
321 /*
322 * The controller has 4 remote buzzers, each with one LED and 5
323 * buttons.
324 *
325 * We use the mapping chosen by the controller, which is:
326 *
327 * Key Offset
328 * -------------------
329 * Buzz 1
330 * Blue 5
331 * Orange 4
332 * Green 3
333 * Yellow 2
334 *
335 * So, for example, the orange button on the third buzzer is mapped to
336 * BTN_TRIGGER_HAPPY14
337 */
338 [1] = BTN_TRIGGER_HAPPY1,
339 [2] = BTN_TRIGGER_HAPPY2,
340 [3] = BTN_TRIGGER_HAPPY3,
341 [4] = BTN_TRIGGER_HAPPY4,
342 [5] = BTN_TRIGGER_HAPPY5,
343 [6] = BTN_TRIGGER_HAPPY6,
344 [7] = BTN_TRIGGER_HAPPY7,
345 [8] = BTN_TRIGGER_HAPPY8,
346 [9] = BTN_TRIGGER_HAPPY9,
347 [10] = BTN_TRIGGER_HAPPY10,
348 [11] = BTN_TRIGGER_HAPPY11,
349 [12] = BTN_TRIGGER_HAPPY12,
350 [13] = BTN_TRIGGER_HAPPY13,
351 [14] = BTN_TRIGGER_HAPPY14,
352 [15] = BTN_TRIGGER_HAPPY15,
353 [16] = BTN_TRIGGER_HAPPY16,
354 [17] = BTN_TRIGGER_HAPPY17,
355 [18] = BTN_TRIGGER_HAPPY18,
356 [19] = BTN_TRIGGER_HAPPY19,
357 [20] = BTN_TRIGGER_HAPPY20,
358};
359
360/* The Navigation controller is a partial DS3 and uses the same HID report
361 * and hence the same keymap indices, however not all axes/buttons
362 * are physically present. We use the same axis and button mapping as
363 * the DS3, which uses the Linux gamepad spec.
364 */
365static const unsigned int navigation_absmap[] = {
366 [0x30] = ABS_X,
367 [0x31] = ABS_Y,
368 [0x33] = ABS_Z, /* L2 */
369};
370
371/* Buttons not physically available on the device, but still available
372 * in the reports are explicitly set to 0 for documentation purposes.
373 */
374static const unsigned int navigation_keymap[] = {
375 [0x01] = 0, /* Select */
376 [0x02] = BTN_THUMBL, /* L3 */
377 [0x03] = 0, /* R3 */
378 [0x04] = 0, /* Start */
379 [0x05] = BTN_DPAD_UP, /* Up */
380 [0x06] = BTN_DPAD_RIGHT, /* Right */
381 [0x07] = BTN_DPAD_DOWN, /* Down */
382 [0x08] = BTN_DPAD_LEFT, /* Left */
383 [0x09] = BTN_TL2, /* L2 */
384 [0x0a] = 0, /* R2 */
385 [0x0b] = BTN_TL, /* L1 */
386 [0x0c] = 0, /* R1 */
387 [0x0d] = BTN_NORTH, /* Triangle */
388 [0x0e] = BTN_EAST, /* Circle */
389 [0x0f] = BTN_SOUTH, /* Cross */
390 [0x10] = BTN_WEST, /* Square */
391 [0x11] = BTN_MODE, /* PS */
392};
393
394static const unsigned int sixaxis_absmap[] = {
395 [0x30] = ABS_X,
396 [0x31] = ABS_Y,
397 [0x32] = ABS_RX, /* right stick X */
398 [0x35] = ABS_RY, /* right stick Y */
399};
400
401static const unsigned int sixaxis_keymap[] = {
402 [0x01] = BTN_SELECT, /* Select */
403 [0x02] = BTN_THUMBL, /* L3 */
404 [0x03] = BTN_THUMBR, /* R3 */
405 [0x04] = BTN_START, /* Start */
406 [0x05] = BTN_DPAD_UP, /* Up */
407 [0x06] = BTN_DPAD_RIGHT, /* Right */
408 [0x07] = BTN_DPAD_DOWN, /* Down */
409 [0x08] = BTN_DPAD_LEFT, /* Left */
410 [0x09] = BTN_TL2, /* L2 */
411 [0x0a] = BTN_TR2, /* R2 */
412 [0x0b] = BTN_TL, /* L1 */
413 [0x0c] = BTN_TR, /* R1 */
414 [0x0d] = BTN_NORTH, /* Triangle */
415 [0x0e] = BTN_EAST, /* Circle */
416 [0x0f] = BTN_SOUTH, /* Cross */
417 [0x10] = BTN_WEST, /* Square */
418 [0x11] = BTN_MODE, /* PS */
419};
420
421static enum power_supply_property sony_battery_props[] = {
422 POWER_SUPPLY_PROP_PRESENT,
423 POWER_SUPPLY_PROP_CAPACITY,
424 POWER_SUPPLY_PROP_SCOPE,
425 POWER_SUPPLY_PROP_STATUS,
426};
427
428struct sixaxis_led {
429 u8 time_enabled; /* the total time the led is active (0xff means forever) */
430 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
431 u8 enabled;
432 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
433 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
434} __packed;
435
436struct sixaxis_rumble {
437 u8 padding;
438 u8 right_duration; /* Right motor duration (0xff means forever) */
439 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
440 u8 left_duration; /* Left motor duration (0xff means forever) */
441 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
442} __packed;
443
444struct sixaxis_output_report {
445 u8 report_id;
446 struct sixaxis_rumble rumble;
447 u8 padding[4];
448 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
449 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
450 struct sixaxis_led _reserved; /* LED5, not actually soldered */
451} __packed;
452
453union sixaxis_output_report_01 {
454 struct sixaxis_output_report data;
455 u8 buf[36];
456};
457
458struct motion_output_report_02 {
459 u8 type, zero;
460 u8 r, g, b;
461 u8 zero2;
462 u8 rumble;
463};
464
465#define SIXAXIS_REPORT_0xF2_SIZE 17
466#define SIXAXIS_REPORT_0xF5_SIZE 8
467#define MOTION_REPORT_0x02_SIZE 49
468
469#define SENSOR_SUFFIX " Motion Sensors"
470#define TOUCHPAD_SUFFIX " Touchpad"
471
472#define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
473#define SIXAXIS_ACC_RES_PER_G 113
474
475static DEFINE_SPINLOCK(sony_dev_list_lock);
476static LIST_HEAD(sony_device_list);
477static DEFINE_IDA(sony_device_id_allocator);
478
479enum sony_worker {
480 SONY_WORKER_STATE
481};
482
483struct sony_sc {
484 spinlock_t lock;
485 struct list_head list_node;
486 struct hid_device *hdev;
487 struct input_dev *touchpad;
488 struct input_dev *sensor_dev;
489 struct led_classdev *leds[MAX_LEDS];
490 unsigned long quirks;
491 struct work_struct state_worker;
492 void (*send_output_report)(struct sony_sc *);
493 struct power_supply *battery;
494 struct power_supply_desc battery_desc;
495 int device_id;
496 u8 *output_report_dmabuf;
497
498#ifdef CONFIG_SONY_FF
499 u8 left;
500 u8 right;
501#endif
502
503 u8 mac_address[6];
504 u8 state_worker_initialized;
505 u8 defer_initialization;
506 u8 battery_capacity;
507 int battery_status;
508 u8 led_state[MAX_LEDS];
509 u8 led_delay_on[MAX_LEDS];
510 u8 led_delay_off[MAX_LEDS];
511 u8 led_count;
512
513 /* GH Live */
514 struct urb *ghl_urb;
515 struct timer_list ghl_poke_timer;
516};
517
518static void sony_set_leds(struct sony_sc *sc);
519
520static inline void sony_schedule_work(struct sony_sc *sc,
521 enum sony_worker which)
522{
523 unsigned long flags;
524
525 switch (which) {
526 case SONY_WORKER_STATE:
527 spin_lock_irqsave(&sc->lock, flags);
528 if (!sc->defer_initialization && sc->state_worker_initialized)
529 schedule_work(&sc->state_worker);
530 spin_unlock_irqrestore(&sc->lock, flags);
531 break;
532 }
533}
534
535static void ghl_magic_poke_cb(struct urb *urb)
536{
537 struct sony_sc *sc = urb->context;
538
539 if (urb->status < 0)
540 hid_err(sc->hdev, "URB transfer failed : %d", urb->status);
541
542 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
543}
544
545static void ghl_magic_poke(struct timer_list *t)
546{
547 int ret;
548 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
549
550 ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC);
551 if (ret < 0)
552 hid_err(sc->hdev, "usb_submit_urb failed: %d", ret);
553}
554
555static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev,
556 const char ghl_magic_data[], u16 poke_size)
557{
558 struct usb_ctrlrequest *cr;
559 u8 *databuf;
560 unsigned int pipe;
561 u16 ghl_magic_value = (((HID_OUTPUT_REPORT + 1) << 8) | ghl_magic_data[0]);
562
563 pipe = usb_sndctrlpipe(usbdev, 0);
564
565 cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
566 if (cr == NULL)
567 return -ENOMEM;
568
569 databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
570 if (databuf == NULL)
571 return -ENOMEM;
572
573 cr->bRequestType =
574 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
575 cr->bRequest = USB_REQ_SET_CONFIGURATION;
576 cr->wValue = cpu_to_le16(ghl_magic_value);
577 cr->wIndex = 0;
578 cr->wLength = cpu_to_le16(poke_size);
579 memcpy(databuf, ghl_magic_data, poke_size);
580 usb_fill_control_urb(
581 sc->ghl_urb, usbdev, pipe,
582 (unsigned char *) cr, databuf, poke_size,
583 ghl_magic_poke_cb, sc);
584 return 0;
585}
586
587static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
588 struct hid_field *field, struct hid_usage *usage,
589 unsigned long **bit, int *max)
590{
591 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
592 unsigned int abs = usage->hid & HID_USAGE;
593
594 if (abs == GUITAR_TILT_USAGE) {
595 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
596 return 1;
597 }
598 }
599 return 0;
600}
601
602static const u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
603 unsigned int *rsize)
604{
605 *rsize = sizeof(motion_rdesc);
606 return motion_rdesc;
607}
608
609static const u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
610 unsigned int *rsize)
611{
612 *rsize = sizeof(ps3remote_rdesc);
613 return ps3remote_rdesc;
614}
615
616static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
617 struct hid_field *field, struct hid_usage *usage,
618 unsigned long **bit, int *max)
619{
620 unsigned int key = usage->hid & HID_USAGE;
621
622 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
623 return -1;
624
625 switch (usage->collection_index) {
626 case 1:
627 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
628 return -1;
629
630 key = ps3remote_keymap_joypad_buttons[key];
631 if (!key)
632 return -1;
633 break;
634 case 2:
635 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
636 return -1;
637
638 key = ps3remote_keymap_remote_buttons[key];
639 if (!key)
640 return -1;
641 break;
642 default:
643 return -1;
644 }
645
646 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
647 return 1;
648}
649
650static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
651 struct hid_field *field, struct hid_usage *usage,
652 unsigned long **bit, int *max)
653{
654 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
655 unsigned int key = usage->hid & HID_USAGE;
656
657 if (key >= ARRAY_SIZE(sixaxis_keymap))
658 return -1;
659
660 key = navigation_keymap[key];
661 if (!key)
662 return -1;
663
664 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
665 return 1;
666 } else if (usage->hid == HID_GD_POINTER) {
667 /* See comment in sixaxis_mapping, basically the L2 (and R2)
668 * triggers are reported through GD Pointer.
669 * In addition we ignore any analog button 'axes' and only
670 * support digital buttons.
671 */
672 switch (usage->usage_index) {
673 case 8: /* L2 */
674 usage->hid = HID_GD_Z;
675 break;
676 default:
677 return -1;
678 }
679
680 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
681 return 1;
682 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
683 unsigned int abs = usage->hid & HID_USAGE;
684
685 if (abs >= ARRAY_SIZE(navigation_absmap))
686 return -1;
687
688 abs = navigation_absmap[abs];
689
690 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
691 return 1;
692 }
693
694 return -1;
695}
696
697
698static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
699 struct hid_field *field, struct hid_usage *usage,
700 unsigned long **bit, int *max)
701{
702 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
703 unsigned int key = usage->hid & HID_USAGE;
704
705 if (key >= ARRAY_SIZE(sixaxis_keymap))
706 return -1;
707
708 key = sixaxis_keymap[key];
709 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
710 return 1;
711 } else if (usage->hid == HID_GD_POINTER) {
712 /* The DS3 provides analog values for most buttons and even
713 * for HAT axes through GD Pointer. L2 and R2 are reported
714 * among these as well instead of as GD Z / RZ. Remap L2
715 * and R2 and ignore other analog 'button axes' as there is
716 * no good way for reporting them.
717 */
718 switch (usage->usage_index) {
719 case 8: /* L2 */
720 usage->hid = HID_GD_Z;
721 break;
722 case 9: /* R2 */
723 usage->hid = HID_GD_RZ;
724 break;
725 default:
726 return -1;
727 }
728
729 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
730 return 1;
731 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
732 unsigned int abs = usage->hid & HID_USAGE;
733
734 if (abs >= ARRAY_SIZE(sixaxis_absmap))
735 return -1;
736
737 abs = sixaxis_absmap[abs];
738
739 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
740 return 1;
741 }
742
743 return -1;
744}
745
746static const u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
747 unsigned int *rsize)
748{
749 struct sony_sc *sc = hid_get_drvdata(hdev);
750
751 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
752 return rdesc;
753
754 /*
755 * Some Sony RF receivers wrongly declare the mouse pointer as a
756 * a constant non-data variable.
757 */
758 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
759 /* usage page: generic desktop controls */
760 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
761 /* usage: mouse */
762 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
763 /* input (usage page for x,y axes): constant, variable, relative */
764 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
765 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
766 /* input: data, variable, relative */
767 rdesc[55] = 0x06;
768 }
769
770 if (sc->quirks & MOTION_CONTROLLER)
771 return motion_fixup(hdev, rdesc, rsize);
772
773 if (sc->quirks & PS3REMOTE)
774 return ps3remote_fixup(hdev, rdesc, rsize);
775
776 /*
777 * Some knock-off USB dongles incorrectly report their button count
778 * as 13 instead of 16 causing three non-functional buttons.
779 */
780 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
781 /* Report Count (13) */
782 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
783 /* Usage Maximum (13) */
784 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
785 /* Report Count (3) */
786 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
787 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
788 rdesc[24] = 0x10;
789 rdesc[38] = 0x10;
790 rdesc[44] = 0x00;
791 }
792
793 return rdesc;
794}
795
796static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
797{
798 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
799 unsigned long flags;
800 int offset;
801 u8 battery_capacity;
802 int battery_status;
803
804 /*
805 * The sixaxis is charging if the battery value is 0xee
806 * and it is fully charged if the value is 0xef.
807 * It does not report the actual level while charging so it
808 * is set to 100% while charging is in progress.
809 */
810 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
811
812 if (rd[offset] >= 0xee) {
813 battery_capacity = 100;
814 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
815 } else {
816 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
817 battery_capacity = sixaxis_battery_capacity[index];
818 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
819 }
820
821 spin_lock_irqsave(&sc->lock, flags);
822 sc->battery_capacity = battery_capacity;
823 sc->battery_status = battery_status;
824 spin_unlock_irqrestore(&sc->lock, flags);
825
826 if (sc->quirks & SIXAXIS_CONTROLLER) {
827 int val;
828
829 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
830 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
831 input_report_abs(sc->sensor_dev, ABS_X, val);
832
833 /* Y and Z are swapped and inversed */
834 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
835 input_report_abs(sc->sensor_dev, ABS_Y, val);
836
837 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
838 input_report_abs(sc->sensor_dev, ABS_Z, val);
839
840 input_sync(sc->sensor_dev);
841 }
842}
843
844static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
845{
846 int n, offset, relx, rely;
847 u8 active;
848
849 /*
850 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
851 * the touch-related data starts at offset 2.
852 * For the first byte, bit 0 is set when touchpad button is pressed.
853 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
854 * This drag key is mapped to BTN_LEFT. It is operational only when a
855 * touch point is active.
856 * Bit 4 is set when only the first touch point is active.
857 * Bit 6 is set when only the second touch point is active.
858 * Bits 5 and 7 are set when both touch points are active.
859 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
860 * The following byte, offset 5, has the touch width and length.
861 * Bits 0-4=X (width), bits 5-7=Y (length).
862 * A signed relative X coordinate is at offset 6.
863 * The bytes at offset 7-9 are the second touch X/Y coordinates.
864 * Offset 10 has the second touch width and length.
865 * Offset 11 has the relative Y coordinate.
866 */
867 offset = 1;
868
869 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
870 active = (rd[offset] >> 4);
871 relx = (s8) rd[offset+5];
872 rely = ((s8) rd[offset+10]) * -1;
873
874 offset++;
875
876 for (n = 0; n < 2; n++) {
877 u16 x, y;
878 u8 contactx, contacty;
879
880 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
881 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
882
883 input_mt_slot(sc->touchpad, n);
884 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
885
886 if (active & 0x03) {
887 contactx = rd[offset+3] & 0x0F;
888 contacty = rd[offset+3] >> 4;
889 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
890 max(contactx, contacty));
891 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
892 min(contactx, contacty));
893 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
894 (bool) (contactx > contacty));
895 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
896 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
897 NSG_MRXU_MAX_Y - y);
898 /*
899 * The relative coordinates belong to the first touch
900 * point, when present, or to the second touch point
901 * when the first is not active.
902 */
903 if ((n == 0) || ((n == 1) && (active & 0x01))) {
904 input_report_rel(sc->touchpad, REL_X, relx);
905 input_report_rel(sc->touchpad, REL_Y, rely);
906 }
907 }
908
909 offset += 5;
910 active >>= 2;
911 }
912
913 input_mt_sync_frame(sc->touchpad);
914
915 input_sync(sc->touchpad);
916}
917
918static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
919 u8 *rd, int size)
920{
921 struct sony_sc *sc = hid_get_drvdata(hdev);
922
923 /*
924 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
925 * has to be BYTE_SWAPPED before passing up to joystick interface
926 */
927 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
928 /*
929 * When connected via Bluetooth the Sixaxis occasionally sends
930 * a report with the second byte 0xff and the rest zeroed.
931 *
932 * This report does not reflect the actual state of the
933 * controller must be ignored to avoid generating false input
934 * events.
935 */
936 if (rd[1] == 0xff)
937 return -EINVAL;
938
939 swap(rd[41], rd[42]);
940 swap(rd[43], rd[44]);
941 swap(rd[45], rd[46]);
942 swap(rd[47], rd[48]);
943
944 sixaxis_parse_report(sc, rd, size);
945 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
946 sixaxis_parse_report(sc, rd, size);
947 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
948 size == 49) {
949 sixaxis_parse_report(sc, rd, size);
950 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
951 nsg_mrxu_parse_report(sc, rd, size);
952 return 1;
953 }
954
955 if (sc->defer_initialization) {
956 sc->defer_initialization = 0;
957 sony_schedule_work(sc, SONY_WORKER_STATE);
958 }
959
960 return 0;
961}
962
963static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
964 struct hid_field *field, struct hid_usage *usage,
965 unsigned long **bit, int *max)
966{
967 struct sony_sc *sc = hid_get_drvdata(hdev);
968
969 if (sc->quirks & BUZZ_CONTROLLER) {
970 unsigned int key = usage->hid & HID_USAGE;
971
972 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
973 return -1;
974
975 switch (usage->collection_index) {
976 case 1:
977 if (key >= ARRAY_SIZE(buzz_keymap))
978 return -1;
979
980 key = buzz_keymap[key];
981 if (!key)
982 return -1;
983 break;
984 default:
985 return -1;
986 }
987
988 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
989 return 1;
990 }
991
992 if (sc->quirks & PS3REMOTE)
993 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
994
995 if (sc->quirks & NAVIGATION_CONTROLLER)
996 return navigation_mapping(hdev, hi, field, usage, bit, max);
997
998 if (sc->quirks & SIXAXIS_CONTROLLER)
999 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1000
1001 if (sc->quirks & GH_GUITAR_CONTROLLER)
1002 return guitar_mapping(hdev, hi, field, usage, bit, max);
1003
1004 /* Let hid-core decide for the others */
1005 return 0;
1006}
1007
1008static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1009 int w, int h, int touch_major, int touch_minor, int orientation)
1010{
1011 size_t name_sz;
1012 char *name;
1013 int ret;
1014
1015 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1016 if (!sc->touchpad)
1017 return -ENOMEM;
1018
1019 input_set_drvdata(sc->touchpad, sc);
1020 sc->touchpad->dev.parent = &sc->hdev->dev;
1021 sc->touchpad->phys = sc->hdev->phys;
1022 sc->touchpad->uniq = sc->hdev->uniq;
1023 sc->touchpad->id.bustype = sc->hdev->bus;
1024 sc->touchpad->id.vendor = sc->hdev->vendor;
1025 sc->touchpad->id.product = sc->hdev->product;
1026 sc->touchpad->id.version = sc->hdev->version;
1027
1028 /* This suffix was originally apended when hid-sony also
1029 * supported DS4 devices. The DS4 was implemented using multiple
1030 * evdev nodes and hence had the need to separete them out using
1031 * a suffix. Other devices which were added later like Sony TV remotes
1032 * inhirited this suffix.
1033 */
1034 name_sz = strlen(sc->hdev->name) + sizeof(TOUCHPAD_SUFFIX);
1035 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1036 if (!name)
1037 return -ENOMEM;
1038 snprintf(name, name_sz, "%s" TOUCHPAD_SUFFIX, sc->hdev->name);
1039 sc->touchpad->name = name;
1040
1041 /* We map the button underneath the touchpad to BTN_LEFT. */
1042 __set_bit(EV_KEY, sc->touchpad->evbit);
1043 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1044 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1045
1046 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1047 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1048
1049 if (touch_major > 0) {
1050 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1051 0, touch_major, 0, 0);
1052 if (touch_minor > 0)
1053 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1054 0, touch_minor, 0, 0);
1055 if (orientation > 0)
1056 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1057 0, orientation, 0, 0);
1058 }
1059
1060 if (sc->quirks & NSG_MRXU_REMOTE) {
1061 __set_bit(EV_REL, sc->touchpad->evbit);
1062 }
1063
1064 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1065 if (ret < 0)
1066 return ret;
1067
1068 ret = input_register_device(sc->touchpad);
1069 if (ret < 0)
1070 return ret;
1071
1072 return 0;
1073}
1074
1075static int sony_register_sensors(struct sony_sc *sc)
1076{
1077 size_t name_sz;
1078 char *name;
1079 int ret;
1080
1081 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1082 if (!sc->sensor_dev)
1083 return -ENOMEM;
1084
1085 input_set_drvdata(sc->sensor_dev, sc);
1086 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1087 sc->sensor_dev->phys = sc->hdev->phys;
1088 sc->sensor_dev->uniq = sc->hdev->uniq;
1089 sc->sensor_dev->id.bustype = sc->hdev->bus;
1090 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1091 sc->sensor_dev->id.product = sc->hdev->product;
1092 sc->sensor_dev->id.version = sc->hdev->version;
1093
1094 /* Append a suffix to the controller name as there are various
1095 * DS4 compatible non-Sony devices with different names.
1096 */
1097 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1098 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1099 if (!name)
1100 return -ENOMEM;
1101 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1102 sc->sensor_dev->name = name;
1103
1104 if (sc->quirks & SIXAXIS_CONTROLLER) {
1105 /* For the DS3 we only support the accelerometer, which works
1106 * quite well even without calibration. The device also has
1107 * a 1-axis gyro, but it is very difficult to manage from within
1108 * the driver even to get data, the sensor is inaccurate and
1109 * the behavior is very different between hardware revisions.
1110 */
1111 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1112 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1113 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1114 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1115 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1116 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1117 }
1118
1119 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1120
1121 ret = input_register_device(sc->sensor_dev);
1122 if (ret < 0)
1123 return ret;
1124
1125 return 0;
1126}
1127
1128/*
1129 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1130 * to "operational". Without this, the ps3 controller will not report any
1131 * events.
1132 */
1133static int sixaxis_set_operational_usb(struct hid_device *hdev)
1134{
1135 struct sony_sc *sc = hid_get_drvdata(hdev);
1136 const int buf_size =
1137 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1138 u8 *buf;
1139 int ret;
1140
1141 buf = kmalloc(buf_size, GFP_KERNEL);
1142 if (!buf)
1143 return -ENOMEM;
1144
1145 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1146 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1147 if (ret < 0) {
1148 hid_err(hdev, "can't set operational mode: step 1\n");
1149 goto out;
1150 }
1151
1152 /*
1153 * Some compatible controllers like the Speedlink Strike FX and
1154 * Gasia need another query plus an USB interrupt to get operational.
1155 */
1156 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1157 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1158 if (ret < 0) {
1159 hid_err(hdev, "can't set operational mode: step 2\n");
1160 goto out;
1161 }
1162
1163 /*
1164 * But the USB interrupt would cause SHANWAN controllers to
1165 * start rumbling non-stop, so skip step 3 for these controllers.
1166 */
1167 if (sc->quirks & SHANWAN_GAMEPAD)
1168 goto out;
1169
1170 ret = hid_hw_output_report(hdev, buf, 1);
1171 if (ret < 0) {
1172 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1173 ret = 0;
1174 }
1175
1176out:
1177 kfree(buf);
1178
1179 return ret;
1180}
1181
1182static int sixaxis_set_operational_bt(struct hid_device *hdev)
1183{
1184 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1185 u8 *buf;
1186 int ret;
1187
1188 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1189 if (!buf)
1190 return -ENOMEM;
1191
1192 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1193 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1194
1195 kfree(buf);
1196
1197 return ret;
1198}
1199
1200static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1201{
1202 static const u8 sixaxis_leds[10][4] = {
1203 { 0x01, 0x00, 0x00, 0x00 },
1204 { 0x00, 0x01, 0x00, 0x00 },
1205 { 0x00, 0x00, 0x01, 0x00 },
1206 { 0x00, 0x00, 0x00, 0x01 },
1207 { 0x01, 0x00, 0x00, 0x01 },
1208 { 0x00, 0x01, 0x00, 0x01 },
1209 { 0x00, 0x00, 0x01, 0x01 },
1210 { 0x01, 0x00, 0x01, 0x01 },
1211 { 0x00, 0x01, 0x01, 0x01 },
1212 { 0x01, 0x01, 0x01, 0x01 }
1213 };
1214
1215 int id = sc->device_id;
1216
1217 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1218
1219 if (id < 0)
1220 return;
1221
1222 id %= 10;
1223 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1224}
1225
1226static void buzz_set_leds(struct sony_sc *sc)
1227{
1228 struct hid_device *hdev = sc->hdev;
1229 struct list_head *report_list =
1230 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1231 struct hid_report *report = list_entry(report_list->next,
1232 struct hid_report, list);
1233 s32 *value = report->field[0]->value;
1234
1235 BUILD_BUG_ON(MAX_LEDS < 4);
1236
1237 value[0] = 0x00;
1238 value[1] = sc->led_state[0] ? 0xff : 0x00;
1239 value[2] = sc->led_state[1] ? 0xff : 0x00;
1240 value[3] = sc->led_state[2] ? 0xff : 0x00;
1241 value[4] = sc->led_state[3] ? 0xff : 0x00;
1242 value[5] = 0x00;
1243 value[6] = 0x00;
1244 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1245}
1246
1247static void sony_set_leds(struct sony_sc *sc)
1248{
1249 if (!(sc->quirks & BUZZ_CONTROLLER))
1250 sony_schedule_work(sc, SONY_WORKER_STATE);
1251 else
1252 buzz_set_leds(sc);
1253}
1254
1255static void sony_led_set_brightness(struct led_classdev *led,
1256 enum led_brightness value)
1257{
1258 struct device *dev = led->dev->parent;
1259 struct hid_device *hdev = to_hid_device(dev);
1260 struct sony_sc *drv_data;
1261
1262 int n;
1263 int force_update;
1264
1265 drv_data = hid_get_drvdata(hdev);
1266 if (!drv_data) {
1267 hid_err(hdev, "No device data\n");
1268 return;
1269 }
1270
1271 /*
1272 * The Sixaxis on USB will override any LED settings sent to it
1273 * and keep flashing all of the LEDs until the PS button is pressed.
1274 * Updates, even if redundant, must be always be sent to the
1275 * controller to avoid having to toggle the state of an LED just to
1276 * stop the flashing later on.
1277 */
1278 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1279
1280 for (n = 0; n < drv_data->led_count; n++) {
1281 if (led == drv_data->leds[n] && (force_update ||
1282 (value != drv_data->led_state[n] ||
1283 drv_data->led_delay_on[n] ||
1284 drv_data->led_delay_off[n]))) {
1285
1286 drv_data->led_state[n] = value;
1287
1288 /* Setting the brightness stops the blinking */
1289 drv_data->led_delay_on[n] = 0;
1290 drv_data->led_delay_off[n] = 0;
1291
1292 sony_set_leds(drv_data);
1293 break;
1294 }
1295 }
1296}
1297
1298static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
1299{
1300 struct device *dev = led->dev->parent;
1301 struct hid_device *hdev = to_hid_device(dev);
1302 struct sony_sc *drv_data;
1303
1304 int n;
1305
1306 drv_data = hid_get_drvdata(hdev);
1307 if (!drv_data) {
1308 hid_err(hdev, "No device data\n");
1309 return LED_OFF;
1310 }
1311
1312 for (n = 0; n < drv_data->led_count; n++) {
1313 if (led == drv_data->leds[n])
1314 return drv_data->led_state[n];
1315 }
1316
1317 return LED_OFF;
1318}
1319
1320static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1321 unsigned long *delay_off)
1322{
1323 struct device *dev = led->dev->parent;
1324 struct hid_device *hdev = to_hid_device(dev);
1325 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1326 int n;
1327 u8 new_on, new_off;
1328
1329 if (!drv_data) {
1330 hid_err(hdev, "No device data\n");
1331 return -EINVAL;
1332 }
1333
1334 /* Max delay is 255 deciseconds or 2550 milliseconds */
1335 if (*delay_on > 2550)
1336 *delay_on = 2550;
1337 if (*delay_off > 2550)
1338 *delay_off = 2550;
1339
1340 /* Blink at 1 Hz if both values are zero */
1341 if (!*delay_on && !*delay_off)
1342 *delay_on = *delay_off = 500;
1343
1344 new_on = *delay_on / 10;
1345 new_off = *delay_off / 10;
1346
1347 for (n = 0; n < drv_data->led_count; n++) {
1348 if (led == drv_data->leds[n])
1349 break;
1350 }
1351
1352 /* This LED is not registered on this device */
1353 if (n >= drv_data->led_count)
1354 return -EINVAL;
1355
1356 /* Don't schedule work if the values didn't change */
1357 if (new_on != drv_data->led_delay_on[n] ||
1358 new_off != drv_data->led_delay_off[n]) {
1359 drv_data->led_delay_on[n] = new_on;
1360 drv_data->led_delay_off[n] = new_off;
1361 sony_schedule_work(drv_data, SONY_WORKER_STATE);
1362 }
1363
1364 return 0;
1365}
1366
1367static int sony_leds_init(struct sony_sc *sc)
1368{
1369 struct hid_device *hdev = sc->hdev;
1370 int n, ret = 0;
1371 int use_color_names;
1372 struct led_classdev *led;
1373 size_t name_sz;
1374 char *name;
1375 size_t name_len;
1376 const char *name_fmt;
1377 static const char * const color_name_str[] = { "red", "green", "blue",
1378 "global" };
1379 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1380 u8 use_hw_blink[MAX_LEDS] = { 0 };
1381
1382 if (WARN_ON(!(sc->quirks & SONY_LED_SUPPORT)))
1383 return -EINVAL;
1384
1385 if (sc->quirks & BUZZ_CONTROLLER) {
1386 sc->led_count = 4;
1387 use_color_names = 0;
1388 name_len = strlen("::buzz#");
1389 name_fmt = "%s::buzz%d";
1390 /* Validate expected report characteristics. */
1391 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1392 return -ENODEV;
1393 } else if (sc->quirks & MOTION_CONTROLLER) {
1394 sc->led_count = 3;
1395 memset(max_brightness, 255, 3);
1396 use_color_names = 1;
1397 name_len = 0;
1398 name_fmt = "%s:%s";
1399 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1400 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
1401
1402 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1403 sc->led_count = 1;
1404 memset(use_hw_blink, 1, 4);
1405 use_color_names = 0;
1406 name_len = strlen("::sony#");
1407 name_fmt = "%s::sony%d";
1408 } else {
1409 sixaxis_set_leds_from_id(sc);
1410 sc->led_count = 4;
1411 memset(use_hw_blink, 1, 4);
1412 use_color_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);
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_color_names)
1429 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_name_str[n]) + 2;
1430
1431 led = devm_kzalloc(&hdev->dev, 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 return -ENOMEM;
1435 }
1436
1437 name = (void *)(&led[1]);
1438 if (use_color_names)
1439 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1440 color_name_str[n]);
1441 else
1442 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
1443 led->name = name;
1444 led->brightness = sc->led_state[n];
1445 led->max_brightness = max_brightness[n];
1446 led->flags = LED_CORE_SUSPENDRESUME;
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 = devm_led_classdev_register(&hdev->dev, led);
1456 if (ret) {
1457 hid_err(hdev, "Failed to register LED %d\n", n);
1458 return ret;
1459 }
1460 }
1461
1462 return 0;
1463}
1464
1465static void sixaxis_send_output_report(struct sony_sc *sc)
1466{
1467 static const union sixaxis_output_report_01 default_report = {
1468 .buf = {
1469 0x01,
1470 0x01, 0xff, 0x00, 0xff, 0x00,
1471 0x00, 0x00, 0x00, 0x00, 0x00,
1472 0xff, 0x27, 0x10, 0x00, 0x32,
1473 0xff, 0x27, 0x10, 0x00, 0x32,
1474 0xff, 0x27, 0x10, 0x00, 0x32,
1475 0xff, 0x27, 0x10, 0x00, 0x32,
1476 0x00, 0x00, 0x00, 0x00, 0x00
1477 }
1478 };
1479 struct sixaxis_output_report *report =
1480 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1481 int n;
1482
1483 /* Initialize the report with default values */
1484 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
1485
1486#ifdef CONFIG_SONY_FF
1487 report->rumble.right_motor_on = sc->right ? 1 : 0;
1488 report->rumble.left_motor_force = sc->left;
1489#endif
1490
1491 report->leds_bitmap |= sc->led_state[0] << 1;
1492 report->leds_bitmap |= sc->led_state[1] << 2;
1493 report->leds_bitmap |= sc->led_state[2] << 3;
1494 report->leds_bitmap |= sc->led_state[3] << 4;
1495
1496 /* Set flag for all leds off, required for 3rd party INTEC controller */
1497 if ((report->leds_bitmap & 0x1E) == 0)
1498 report->leds_bitmap |= 0x20;
1499
1500 /*
1501 * The LEDs in the report are indexed in reverse order to their
1502 * corresponding light on the controller.
1503 * Index 0 = LED 4, index 1 = LED 3, etc...
1504 *
1505 * In the case of both delay values being zero (blinking disabled) the
1506 * default report values should be used or the controller LED will be
1507 * always off.
1508 */
1509 for (n = 0; n < 4; n++) {
1510 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1511 report->led[3 - n].duty_off = sc->led_delay_off[n];
1512 report->led[3 - n].duty_on = sc->led_delay_on[n];
1513 }
1514 }
1515
1516 /* SHANWAN controllers require output reports via intr channel */
1517 if (sc->quirks & SHANWAN_GAMEPAD)
1518 hid_hw_output_report(sc->hdev, (u8 *)report,
1519 sizeof(struct sixaxis_output_report));
1520 else
1521 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
1522 sizeof(struct sixaxis_output_report),
1523 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
1524}
1525
1526static void motion_send_output_report(struct sony_sc *sc)
1527{
1528 struct hid_device *hdev = sc->hdev;
1529 struct motion_output_report_02 *report =
1530 (struct motion_output_report_02 *)sc->output_report_dmabuf;
1531
1532 memset(report, 0, MOTION_REPORT_0x02_SIZE);
1533
1534 report->type = 0x02; /* set leds */
1535 report->r = sc->led_state[0];
1536 report->g = sc->led_state[1];
1537 report->b = sc->led_state[2];
1538
1539#ifdef CONFIG_SONY_FF
1540 report->rumble = max(sc->right, sc->left);
1541#endif
1542
1543 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
1544}
1545
1546#ifdef CONFIG_SONY_FF
1547static inline void sony_send_output_report(struct sony_sc *sc)
1548{
1549 if (sc->send_output_report)
1550 sc->send_output_report(sc);
1551}
1552#endif
1553
1554static void sony_state_worker(struct work_struct *work)
1555{
1556 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
1557
1558 sc->send_output_report(sc);
1559}
1560
1561static int sony_allocate_output_report(struct sony_sc *sc)
1562{
1563 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1564 (sc->quirks & NAVIGATION_CONTROLLER))
1565 sc->output_report_dmabuf =
1566 devm_kmalloc(&sc->hdev->dev,
1567 sizeof(union sixaxis_output_report_01),
1568 GFP_KERNEL);
1569 else if (sc->quirks & MOTION_CONTROLLER)
1570 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
1571 MOTION_REPORT_0x02_SIZE,
1572 GFP_KERNEL);
1573 else
1574 return 0;
1575
1576 if (!sc->output_report_dmabuf)
1577 return -ENOMEM;
1578
1579 return 0;
1580}
1581
1582#ifdef CONFIG_SONY_FF
1583static int sony_play_effect(struct input_dev *dev, void *data,
1584 struct ff_effect *effect)
1585{
1586 struct hid_device *hid = input_get_drvdata(dev);
1587 struct sony_sc *sc = hid_get_drvdata(hid);
1588
1589 if (effect->type != FF_RUMBLE)
1590 return 0;
1591
1592 sc->left = effect->u.rumble.strong_magnitude / 256;
1593 sc->right = effect->u.rumble.weak_magnitude / 256;
1594
1595 sony_schedule_work(sc, SONY_WORKER_STATE);
1596 return 0;
1597}
1598
1599static int sony_init_ff(struct sony_sc *sc)
1600{
1601 struct hid_input *hidinput;
1602 struct input_dev *input_dev;
1603
1604 if (list_empty(&sc->hdev->inputs)) {
1605 hid_err(sc->hdev, "no inputs found\n");
1606 return -ENODEV;
1607 }
1608 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
1609 input_dev = hidinput->input;
1610
1611 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1612 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1613}
1614
1615#else
1616static int sony_init_ff(struct sony_sc *sc)
1617{
1618 return 0;
1619}
1620
1621#endif
1622
1623static int sony_battery_get_property(struct power_supply *psy,
1624 enum power_supply_property psp,
1625 union power_supply_propval *val)
1626{
1627 struct sony_sc *sc = power_supply_get_drvdata(psy);
1628 unsigned long flags;
1629 int ret = 0;
1630 u8 battery_capacity;
1631 int battery_status;
1632
1633 spin_lock_irqsave(&sc->lock, flags);
1634 battery_capacity = sc->battery_capacity;
1635 battery_status = sc->battery_status;
1636 spin_unlock_irqrestore(&sc->lock, flags);
1637
1638 switch (psp) {
1639 case POWER_SUPPLY_PROP_PRESENT:
1640 val->intval = 1;
1641 break;
1642 case POWER_SUPPLY_PROP_SCOPE:
1643 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1644 break;
1645 case POWER_SUPPLY_PROP_CAPACITY:
1646 val->intval = battery_capacity;
1647 break;
1648 case POWER_SUPPLY_PROP_STATUS:
1649 val->intval = battery_status;
1650 break;
1651 default:
1652 ret = -EINVAL;
1653 break;
1654 }
1655 return ret;
1656}
1657
1658static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
1659{
1660 const char *battery_str_fmt = append_dev_id ?
1661 "sony_controller_battery_%pMR_%i" :
1662 "sony_controller_battery_%pMR";
1663 struct power_supply_config psy_cfg = { .drv_data = sc, };
1664 struct hid_device *hdev = sc->hdev;
1665 int ret;
1666
1667 /*
1668 * Set the default battery level to 100% to avoid low battery warnings
1669 * if the battery is polled before the first device report is received.
1670 */
1671 sc->battery_capacity = 100;
1672
1673 sc->battery_desc.properties = sony_battery_props;
1674 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
1675 sc->battery_desc.get_property = sony_battery_get_property;
1676 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
1677 sc->battery_desc.use_for_apm = 0;
1678 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
1679 battery_str_fmt, sc->mac_address, sc->device_id);
1680 if (!sc->battery_desc.name)
1681 return -ENOMEM;
1682
1683 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
1684 &psy_cfg);
1685 if (IS_ERR(sc->battery)) {
1686 ret = PTR_ERR(sc->battery);
1687 hid_err(hdev, "Unable to register battery device\n");
1688 return ret;
1689 }
1690
1691 power_supply_powers(sc->battery, &hdev->dev);
1692 return 0;
1693}
1694
1695/*
1696 * If a controller is plugged in via USB while already connected via Bluetooth
1697 * it will show up as two devices. A global list of connected controllers and
1698 * their MAC addresses is maintained to ensure that a device is only connected
1699 * once.
1700 *
1701 * Some USB-only devices masquerade as Sixaxis controllers and all have the
1702 * same dummy Bluetooth address, so a comparison of the connection type is
1703 * required. Devices are only rejected in the case where two devices have
1704 * matching Bluetooth addresses on different bus types.
1705 */
1706static inline int sony_compare_connection_type(struct sony_sc *sc0,
1707 struct sony_sc *sc1)
1708{
1709 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
1710 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
1711
1712 return sc0_not_bt == sc1_not_bt;
1713}
1714
1715static int sony_check_add_dev_list(struct sony_sc *sc)
1716{
1717 struct sony_sc *entry;
1718 unsigned long flags;
1719 int ret;
1720
1721 spin_lock_irqsave(&sony_dev_list_lock, flags);
1722
1723 list_for_each_entry(entry, &sony_device_list, list_node) {
1724 ret = memcmp(sc->mac_address, entry->mac_address,
1725 sizeof(sc->mac_address));
1726 if (!ret) {
1727 if (sony_compare_connection_type(sc, entry)) {
1728 ret = 1;
1729 } else {
1730 ret = -EEXIST;
1731 hid_info(sc->hdev,
1732 "controller with MAC address %pMR already connected\n",
1733 sc->mac_address);
1734 }
1735 goto unlock;
1736 }
1737 }
1738
1739 ret = 0;
1740 list_add(&(sc->list_node), &sony_device_list);
1741
1742unlock:
1743 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1744 return ret;
1745}
1746
1747static void sony_remove_dev_list(struct sony_sc *sc)
1748{
1749 unsigned long flags;
1750
1751 if (sc->list_node.next) {
1752 spin_lock_irqsave(&sony_dev_list_lock, flags);
1753 list_del(&(sc->list_node));
1754 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1755 }
1756}
1757
1758static int sony_get_bt_devaddr(struct sony_sc *sc)
1759{
1760 int ret;
1761
1762 /* HIDP stores the device MAC address as a string in the uniq field. */
1763 ret = strlen(sc->hdev->uniq);
1764 if (ret != 17)
1765 return -EINVAL;
1766
1767 ret = sscanf(sc->hdev->uniq,
1768 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1769 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1770 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1771
1772 if (ret != 6)
1773 return -EINVAL;
1774
1775 return 0;
1776}
1777
1778static int sony_check_add(struct sony_sc *sc)
1779{
1780 u8 *buf = NULL;
1781 int n, ret;
1782
1783 if ((sc->quirks & MOTION_CONTROLLER_BT) ||
1784 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
1785 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1786 /*
1787 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1788 * address from the uniq string where HIDP stores it.
1789 * As uniq cannot be guaranteed to be a MAC address in all cases
1790 * a failure of this function should not prevent the connection.
1791 */
1792 if (sony_get_bt_devaddr(sc) < 0) {
1793 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1794 return 0;
1795 }
1796 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
1797 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
1798 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
1799 if (!buf)
1800 return -ENOMEM;
1801
1802 /*
1803 * The MAC address of a Sixaxis controller connected via USB can
1804 * be retrieved with feature report 0xf2. The address begins at
1805 * offset 4.
1806 */
1807 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
1808 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
1809 HID_REQ_GET_REPORT);
1810
1811 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
1812 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1813 ret = ret < 0 ? ret : -EINVAL;
1814 goto out_free;
1815 }
1816
1817 /*
1818 * The Sixaxis device MAC in the report is big-endian and must
1819 * be byte-swapped.
1820 */
1821 for (n = 0; n < 6; n++)
1822 sc->mac_address[5-n] = buf[4+n];
1823
1824 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
1825 "%pMR", sc->mac_address);
1826 } else {
1827 return 0;
1828 }
1829
1830 ret = sony_check_add_dev_list(sc);
1831
1832out_free:
1833
1834 kfree(buf);
1835
1836 return ret;
1837}
1838
1839static int sony_set_device_id(struct sony_sc *sc)
1840{
1841 int ret;
1842
1843 /*
1844 * Only Sixaxis controllers get an id.
1845 * All others are set to -1.
1846 */
1847 if (sc->quirks & SIXAXIS_CONTROLLER) {
1848 ret = ida_alloc(&sony_device_id_allocator, GFP_KERNEL);
1849 if (ret < 0) {
1850 sc->device_id = -1;
1851 return ret;
1852 }
1853 sc->device_id = ret;
1854 } else {
1855 sc->device_id = -1;
1856 }
1857
1858 return 0;
1859}
1860
1861static void sony_release_device_id(struct sony_sc *sc)
1862{
1863 if (sc->device_id >= 0) {
1864 ida_free(&sony_device_id_allocator, sc->device_id);
1865 sc->device_id = -1;
1866 }
1867}
1868
1869static inline void sony_init_output_report(struct sony_sc *sc,
1870 void (*send_output_report)(struct sony_sc *))
1871{
1872 sc->send_output_report = send_output_report;
1873
1874 if (!sc->state_worker_initialized)
1875 INIT_WORK(&sc->state_worker, sony_state_worker);
1876
1877 sc->state_worker_initialized = 1;
1878}
1879
1880static inline void sony_cancel_work_sync(struct sony_sc *sc)
1881{
1882 unsigned long flags;
1883
1884 if (sc->state_worker_initialized) {
1885 spin_lock_irqsave(&sc->lock, flags);
1886 sc->state_worker_initialized = 0;
1887 spin_unlock_irqrestore(&sc->lock, flags);
1888 cancel_work_sync(&sc->state_worker);
1889 }
1890}
1891
1892static int sony_input_configured(struct hid_device *hdev,
1893 struct hid_input *hidinput)
1894{
1895 struct sony_sc *sc = hid_get_drvdata(hdev);
1896 int append_dev_id;
1897 int ret;
1898
1899 ret = sony_set_device_id(sc);
1900 if (ret < 0) {
1901 hid_err(hdev, "failed to allocate the device id\n");
1902 goto err_stop;
1903 }
1904
1905 ret = append_dev_id = sony_check_add(sc);
1906 if (ret < 0)
1907 goto err_stop;
1908
1909 ret = sony_allocate_output_report(sc);
1910 if (ret < 0) {
1911 hid_err(hdev, "failed to allocate the output report buffer\n");
1912 goto err_stop;
1913 }
1914
1915 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
1916 /*
1917 * The Sony Sixaxis does not handle HID Output Reports on the
1918 * Interrupt EP like it could, so we need to force HID Output
1919 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1920 *
1921 * There is also another issue about HID Output Reports via USB,
1922 * the Sixaxis does not want the report_id as part of the data
1923 * packet, so we have to discard buf[0] when sending the actual
1924 * control message, even for numbered reports, humpf!
1925 *
1926 * Additionally, the Sixaxis on USB isn't properly initialized
1927 * until the PS logo button is pressed and as such won't retain
1928 * any state set by an output report, so the initial
1929 * configuration report is deferred until the first input
1930 * report arrives.
1931 */
1932 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1933 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1934 sc->defer_initialization = 1;
1935
1936 ret = sixaxis_set_operational_usb(hdev);
1937 if (ret < 0) {
1938 hid_err(hdev, "Failed to set controller into operational mode\n");
1939 goto err_stop;
1940 }
1941
1942 sony_init_output_report(sc, sixaxis_send_output_report);
1943 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
1944 /*
1945 * The Navigation controller wants output reports sent on the ctrl
1946 * endpoint when connected via Bluetooth.
1947 */
1948 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1949
1950 ret = sixaxis_set_operational_bt(hdev);
1951 if (ret < 0) {
1952 hid_err(hdev, "Failed to set controller into operational mode\n");
1953 goto err_stop;
1954 }
1955
1956 sony_init_output_report(sc, sixaxis_send_output_report);
1957 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1958 /*
1959 * The Sony Sixaxis does not handle HID Output Reports on the
1960 * Interrupt EP and the device only becomes active when the
1961 * PS button is pressed. See comment for Navigation controller
1962 * above for more details.
1963 */
1964 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1965 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
1966 sc->defer_initialization = 1;
1967
1968 ret = sixaxis_set_operational_usb(hdev);
1969 if (ret < 0) {
1970 hid_err(hdev, "Failed to set controller into operational mode\n");
1971 goto err_stop;
1972 }
1973
1974 ret = sony_register_sensors(sc);
1975 if (ret) {
1976 hid_err(sc->hdev,
1977 "Unable to initialize motion sensors: %d\n", ret);
1978 goto err_stop;
1979 }
1980
1981 sony_init_output_report(sc, sixaxis_send_output_report);
1982 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
1983 /*
1984 * The Sixaxis wants output reports sent on the ctrl endpoint
1985 * when connected via Bluetooth.
1986 */
1987 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1988
1989 ret = sixaxis_set_operational_bt(hdev);
1990 if (ret < 0) {
1991 hid_err(hdev, "Failed to set controller into operational mode\n");
1992 goto err_stop;
1993 }
1994
1995 ret = sony_register_sensors(sc);
1996 if (ret) {
1997 hid_err(sc->hdev,
1998 "Unable to initialize motion sensors: %d\n", ret);
1999 goto err_stop;
2000 }
2001
2002 sony_init_output_report(sc, sixaxis_send_output_report);
2003 } else if (sc->quirks & NSG_MRXU_REMOTE) {
2004 /*
2005 * The NSG-MRxU touchpad supports 2 touches and has a
2006 * resolution of 1667x1868
2007 */
2008 ret = sony_register_touchpad(sc, 2,
2009 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2010 if (ret) {
2011 hid_err(sc->hdev,
2012 "Unable to initialize multi-touch slots: %d\n",
2013 ret);
2014 goto err_stop;
2015 }
2016
2017 } else if (sc->quirks & MOTION_CONTROLLER) {
2018 sony_init_output_report(sc, motion_send_output_report);
2019 }
2020
2021 if (sc->quirks & SONY_LED_SUPPORT) {
2022 ret = sony_leds_init(sc);
2023 if (ret < 0)
2024 goto err_stop;
2025 }
2026
2027 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2028 ret = sony_battery_probe(sc, append_dev_id);
2029 if (ret < 0)
2030 goto err_stop;
2031
2032 /* Open the device to receive reports with battery info */
2033 ret = hid_hw_open(hdev);
2034 if (ret < 0) {
2035 hid_err(hdev, "hw open failed\n");
2036 goto err_stop;
2037 }
2038 }
2039
2040 if (sc->quirks & SONY_FF_SUPPORT) {
2041 ret = sony_init_ff(sc);
2042 if (ret < 0)
2043 goto err_close;
2044 }
2045
2046 return 0;
2047err_close:
2048 hid_hw_close(hdev);
2049err_stop:
2050 sony_cancel_work_sync(sc);
2051 sony_remove_dev_list(sc);
2052 sony_release_device_id(sc);
2053 return ret;
2054}
2055
2056static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2057{
2058 int ret;
2059 unsigned long quirks = id->driver_data;
2060 struct sony_sc *sc;
2061 struct usb_device *usbdev;
2062 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2063
2064 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2065 quirks |= FUTUREMAX_DANCE_MAT;
2066
2067 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") ||
2068 !strcmp(hdev->name, "ShanWan PS(R) Ga`epad"))
2069 quirks |= SHANWAN_GAMEPAD;
2070
2071 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2072 if (sc == NULL) {
2073 hid_err(hdev, "can't alloc sony descriptor\n");
2074 return -ENOMEM;
2075 }
2076
2077 spin_lock_init(&sc->lock);
2078
2079 sc->quirks = quirks;
2080 hid_set_drvdata(hdev, sc);
2081 sc->hdev = hdev;
2082
2083 ret = hid_parse(hdev);
2084 if (ret) {
2085 hid_err(hdev, "parse failed\n");
2086 return ret;
2087 }
2088
2089 if (sc->quirks & VAIO_RDESC_CONSTANT)
2090 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2091 else if (sc->quirks & SIXAXIS_CONTROLLER)
2092 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2093
2094 /* Patch the hw version on DS3 compatible devices, so applications can
2095 * distinguish between the default HID mappings and the mappings defined
2096 * by the Linux game controller spec. This is important for the SDL2
2097 * library, which has a game controller database, which uses device ids
2098 * in combination with version as a key.
2099 */
2100 if (sc->quirks & SIXAXIS_CONTROLLER)
2101 hdev->version |= 0x8000;
2102
2103 ret = hid_hw_start(hdev, connect_mask);
2104 if (ret) {
2105 hid_err(hdev, "hw start failed\n");
2106 return ret;
2107 }
2108
2109 /* sony_input_configured can fail, but this doesn't result
2110 * in hid_hw_start failures (intended). Check whether
2111 * the HID layer claimed the device else fail.
2112 * We don't know the actual reason for the failure, most
2113 * likely it is due to EEXIST in case of double connection
2114 * of USB and Bluetooth, but could have been due to ENOMEM
2115 * or other reasons as well.
2116 */
2117 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2118 hid_err(hdev, "failed to claim input\n");
2119 ret = -ENODEV;
2120 goto err;
2121 }
2122
2123 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
2124 if (!hid_is_usb(hdev)) {
2125 ret = -EINVAL;
2126 goto err;
2127 }
2128
2129 usbdev = to_usb_device(sc->hdev->dev.parent->parent);
2130
2131 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
2132 if (!sc->ghl_urb) {
2133 ret = -ENOMEM;
2134 goto err;
2135 }
2136
2137 if (sc->quirks & GHL_GUITAR_PS3WIIU)
2138 ret = ghl_init_urb(sc, usbdev, ghl_ps3wiiu_magic_data,
2139 ARRAY_SIZE(ghl_ps3wiiu_magic_data));
2140 else if (sc->quirks & GHL_GUITAR_PS4)
2141 ret = ghl_init_urb(sc, usbdev, ghl_ps4_magic_data,
2142 ARRAY_SIZE(ghl_ps4_magic_data));
2143 if (ret) {
2144 hid_err(hdev, "error preparing URB\n");
2145 goto err;
2146 }
2147
2148 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
2149 mod_timer(&sc->ghl_poke_timer,
2150 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
2151 }
2152
2153 return ret;
2154
2155err:
2156 usb_free_urb(sc->ghl_urb);
2157
2158 hid_hw_stop(hdev);
2159 return ret;
2160}
2161
2162static void sony_remove(struct hid_device *hdev)
2163{
2164 struct sony_sc *sc = hid_get_drvdata(hdev);
2165
2166 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
2167 del_timer_sync(&sc->ghl_poke_timer);
2168 usb_free_urb(sc->ghl_urb);
2169 }
2170
2171 hid_hw_close(hdev);
2172
2173 sony_cancel_work_sync(sc);
2174
2175 sony_remove_dev_list(sc);
2176
2177 sony_release_device_id(sc);
2178
2179 hid_hw_stop(hdev);
2180}
2181
2182#ifdef CONFIG_PM
2183
2184static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2185{
2186#ifdef CONFIG_SONY_FF
2187
2188 /* On suspend stop any running force-feedback events */
2189 if (SONY_FF_SUPPORT) {
2190 struct sony_sc *sc = hid_get_drvdata(hdev);
2191
2192 sc->left = sc->right = 0;
2193 sony_send_output_report(sc);
2194 }
2195
2196#endif
2197 return 0;
2198}
2199
2200static int sony_resume(struct hid_device *hdev)
2201{
2202 struct sony_sc *sc = hid_get_drvdata(hdev);
2203
2204 /*
2205 * The Sixaxis and navigation controllers on USB need to be
2206 * reinitialized on resume or they won't behave properly.
2207 */
2208 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2209 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2210 sixaxis_set_operational_usb(sc->hdev);
2211 sc->defer_initialization = 1;
2212 }
2213
2214 return 0;
2215}
2216
2217#endif
2218
2219static const struct hid_device_id sony_devices[] = {
2220 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2221 .driver_data = SIXAXIS_CONTROLLER_USB },
2222 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2223 .driver_data = NAVIGATION_CONTROLLER_USB },
2224 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
2225 .driver_data = NAVIGATION_CONTROLLER_BT },
2226 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2227 .driver_data = MOTION_CONTROLLER_USB },
2228 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
2229 .driver_data = MOTION_CONTROLLER_BT },
2230 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2231 .driver_data = SIXAXIS_CONTROLLER_BT },
2232 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2233 .driver_data = VAIO_RDESC_CONSTANT },
2234 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2235 .driver_data = VAIO_RDESC_CONSTANT },
2236 /*
2237 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2238 * Logitech joystick from the device descriptor.
2239 */
2240 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2241 .driver_data = BUZZ_CONTROLLER },
2242 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2243 .driver_data = BUZZ_CONTROLLER },
2244 /* PS3 BD Remote Control */
2245 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2246 .driver_data = PS3REMOTE },
2247 /* Logitech Harmony Adapter for PS3 */
2248 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2249 .driver_data = PS3REMOTE },
2250 /* SMK-Link PS3 BD Remote Control */
2251 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2252 .driver_data = PS3REMOTE },
2253 /* Nyko Core Controller for PS3 */
2254 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2255 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
2256 /* SMK-Link NSG-MR5U Remote Control */
2257 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
2258 .driver_data = NSG_MR5U_REMOTE_BT },
2259 /* SMK-Link NSG-MR7U Remote Control */
2260 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
2261 .driver_data = NSG_MR7U_REMOTE_BT },
2262 /* Guitar Hero Live PS3 and Wii U guitar dongles */
2263 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
2264 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
2265 /* Guitar Hero PC Guitar Dongle */
2266 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_GUITAR_DONGLE),
2267 .driver_data = GH_GUITAR_CONTROLLER },
2268 /* Guitar Hero PS3 World Tour Guitar Dongle */
2269 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
2270 .driver_data = GH_GUITAR_CONTROLLER },
2271 /* Guitar Hero Live PS4 guitar dongles */
2272 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_PS4_GHLIVE_DONGLE),
2273 .driver_data = GHL_GUITAR_PS4 | GH_GUITAR_CONTROLLER },
2274 { }
2275};
2276MODULE_DEVICE_TABLE(hid, sony_devices);
2277
2278static struct hid_driver sony_driver = {
2279 .name = "sony",
2280 .id_table = sony_devices,
2281 .input_mapping = sony_mapping,
2282 .input_configured = sony_input_configured,
2283 .probe = sony_probe,
2284 .remove = sony_remove,
2285 .report_fixup = sony_report_fixup,
2286 .raw_event = sony_raw_event,
2287
2288#ifdef CONFIG_PM
2289 .suspend = sony_suspend,
2290 .resume = sony_resume,
2291 .reset_resume = sony_resume,
2292#endif
2293};
2294
2295static int __init sony_init(void)
2296{
2297 dbg_hid("Sony:%s\n", __func__);
2298
2299 return hid_register_driver(&sony_driver);
2300}
2301
2302static void __exit sony_exit(void)
2303{
2304 dbg_hid("Sony:%s\n", __func__);
2305
2306 hid_unregister_driver(&sony_driver);
2307 ida_destroy(&sony_device_id_allocator);
2308}
2309module_init(sony_init);
2310module_exit(sony_exit);
2311
2312MODULE_DESCRIPTION("HID driver for Sony / PS2 / PS3 / PS4 BD devices");
2313MODULE_LICENSE("GPL");