]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/hid/hid-sony.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
HID: sony: Convert startup and shutdown functions to use a uniform parameter type
[mirror_ubuntu-artful-kernel.git] / drivers / hid / hid-sony.c
CommitLineData
bd28ce00 1/*
078328da 2 * HID driver for Sony / PS2 / PS3 BD devices.
bd28ce00
JS		 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
bd28ce00 7 * Copyright (c) 2008 Jiri Slaby
078328da
JK		 8 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
f04d5140 10 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
bd28ce00
JS		 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
ad142b9e
FP		 20/*
21 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
078328da
JK		 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
bd28ce00
JS		 28#include <linux/device.h>
29#include <linux/hid.h>
30#include <linux/module.h>
5a0e3ad6 31#include <linux/slab.h>
40e32ee6 32#include <linux/leds.h>
d902f472
FP		 33#include <linux/power_supply.h>
34#include <linux/spinlock.h>
d2d782fc 35#include <linux/list.h>
e5606230 36#include <linux/input/mt.h>
bd28ce00
JS		 37
38#include "hid-ids.h"
39
6c79c18c
FP		 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)
8ab1676b
FP		 45#define DUALSHOCK4_CONTROLLER_USB BIT(5)
46#define DUALSHOCK4_CONTROLLER_BT BIT(6)
cc6e0bbb 47
fee4e2d5 48#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
68330d83
FP		 49#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
50 DUALSHOCK4_CONTROLLER_BT)
fee4e2d5 51#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
68330d83 52 DUALSHOCK4_CONTROLLER)
fee4e2d5 53#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
c8de9dbb 54#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
60781cf4
FP		 55
56#define MAX_LEDS 4
0a286ef2 57
61ab44be
SW		 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
e57a67da
MCC		 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
ad142b9e
FP		 86/*
87 * The default descriptor doesn't provide mapping for the accelerometers
58d7027b
FP		 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 */
ed19d8cf 92static u8 dualshock4_usb_rdesc[] = {
58d7027b
FP		 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 */
ed19d8cf
FP		 344};
345
ad142b9e
FP		 346/*
347 * The default behavior of the Dualshock 4 is to send reports using report
d829674d
FP		 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
078328da
JK		 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
f04d5140 673static const unsigned int buzz_keymap[] = {
ad142b9e
FP		 674 /*
675 * The controller has 4 remote buzzers, each with one LED and 5
f04d5140
CL		 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
d902f472
FP		 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
55d3b664
FP		 720struct sixaxis_led {
721 __u8 time_enabled; /* the total time the led is active (0xff means forever) */
722 __u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
723 __u8 enabled;
724 __u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
725 __u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
726} __packed;
727
728struct sixaxis_rumble {
729 __u8 padding;
730 __u8 right_duration; /* Right motor duration (0xff means forever) */
731 __u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
732 __u8 left_duration; /* Left motor duration (0xff means forever) */
733 __u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
734} __packed;
735
736struct sixaxis_output_report {
737 __u8 report_id;
738 struct sixaxis_rumble rumble;
739 __u8 padding[4];
740 __u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
741 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
742 struct sixaxis_led _reserved; /* LED5, not actually soldered */
743} __packed;
744
745union sixaxis_output_report_01 {
746 struct sixaxis_output_report data;
747 __u8 buf[36];
748};
749
d2d782fc
FP		 750static spinlock_t sony_dev_list_lock;
751static LIST_HEAD(sony_device_list);
752
cc6e0bbb 753struct sony_sc {
d902f472 754 spinlock_t lock;
d2d782fc 755 struct list_head list_node;
0a286ef2 756 struct hid_device *hdev;
60781cf4 757 struct led_classdev *leds[MAX_LEDS];
cc6e0bbb 758 unsigned long quirks;
0a286ef2 759 struct work_struct state_worker;
d902f472 760 struct power_supply battery;
f04d5140 761
9f323b68 762#ifdef CONFIG_SONY_FF
9f323b68
SE		 763 __u8 left;
764 __u8 right;
765#endif
766
d2d782fc 767 __u8 mac_address[6];
5f5750d2 768 __u8 worker_initialized;
d902f472
FP		 769 __u8 cable_state;
770 __u8 battery_charging;
771 __u8 battery_capacity;
60781cf4
FP		 772 __u8 led_state[MAX_LEDS];
773 __u8 led_count;
cc6e0bbb
JK		 774};
775
078328da
JK		 776static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
777 unsigned int *rsize)
778{
779 *rsize = sizeof(ps3remote_rdesc);
780 return ps3remote_rdesc;
781}
782
783static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
784 struct hid_field *field, struct hid_usage *usage,
785 unsigned long **bit, int *max)
786{
787 unsigned int key = usage->hid & HID_USAGE;
788
789 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
790 return -1;
791
792 switch (usage->collection_index) {
793 case 1:
794 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
795 return -1;
796
797 key = ps3remote_keymap_joypad_buttons[key];
798 if (!key)
799 return -1;
800 break;
801 case 2:
802 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
803 return -1;
804
805 key = ps3remote_keymap_remote_buttons[key];
806 if (!key)
807 return -1;
808 break;
809 default:
810 return -1;
811 }
812
813 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
814 return 1;
815}
816
817
cc6e0bbb 818/* Sony Vaio VGX has wrongly mouse pointer declared as constant */
73e4008d
NK		 819static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
820 unsigned int *rsize)
cc6e0bbb
JK		 821{
822 struct sony_sc *sc = hid_get_drvdata(hdev);
823
99d24902
FLVC		 824 /*
825 * Some Sony RF receivers wrongly declare the mouse pointer as a
826 * a constant non-data variable.
827 */
828 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
829 /* usage page: generic desktop controls */
830 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
831 /* usage: mouse */
832 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
833 /* input (usage page for x,y axes): constant, variable, relative */
834 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
a4649184 835 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 836 /* input: data, variable, relative */
cc6e0bbb
JK		 837 rdesc[55] = 0x06;
838 }
61ab44be 839
ed19d8cf
FP		 840 /*
841 * The default Dualshock 4 USB descriptor doesn't assign
842 * the gyroscope values to corresponding axes so we need a
843 * modified one.
844 */
845 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
846 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
847 rdesc = dualshock4_usb_rdesc;
848 *rsize = sizeof(dualshock4_usb_rdesc);
d829674d
FP		 849 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
850 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
851 rdesc = dualshock4_bt_rdesc;
852 *rsize = sizeof(dualshock4_bt_rdesc);
ed19d8cf
FP		 853 }
854
61ab44be
SW		 855 /* The HID descriptor exposed over BT has a trailing zero byte */
856 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
857 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
858 rdesc[83] == 0x75) {
859 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
860 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
861 sizeof(sixaxis_rdesc_fixup));
e57a67da
MCC		 862 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
863 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
864 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
865 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
866 *rsize = sizeof(sixaxis_rdesc_fixup2);
867 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
61ab44be 868 }
078328da
JK		 869
870 if (sc->quirks & PS3REMOTE)
871 return ps3remote_fixup(hdev, rdesc, rsize);
872
73e4008d 873 return rdesc;
cc6e0bbb
JK		 874}
875
d902f472
FP		 876static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
877{
878 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
879 unsigned long flags;
880 __u8 cable_state, battery_capacity, battery_charging;
881
ad142b9e
FP		 882 /*
883 * The sixaxis is charging if the battery value is 0xee
d902f472
FP		 884 * and it is fully charged if the value is 0xef.
885 * It does not report the actual level while charging so it
886 * is set to 100% while charging is in progress.
887 */
888 if (rd[30] >= 0xee) {
889 battery_capacity = 100;
a43e94a3 890 battery_charging = !(rd[30] & 0x01);
d902f472 891 } else {
ac3c9a94
FP		 892 __u8 index = rd[30] <= 5 ? rd[30] : 5;
893 battery_capacity = sixaxis_battery_capacity[index];
d902f472
FP		 894 battery_charging = 0;
895 }
914c5783 896 cable_state = !(rd[31] & 0x04);
d902f472
FP		 897
898 spin_lock_irqsave(&sc->lock, flags);
899 sc->cable_state = cable_state;
900 sc->battery_capacity = battery_capacity;
901 sc->battery_charging = battery_charging;
902 spin_unlock_irqrestore(&sc->lock, flags);
903}
904
905static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
906{
e5606230
FP		 907 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
908 struct hid_input, list);
909 struct input_dev *input_dev = hidinput->input;
d902f472 910 unsigned long flags;
6c5f860d 911 int n, offset;
d902f472
FP		 912 __u8 cable_state, battery_capacity, battery_charging;
913
ad142b9e
FP		 914 /*
915 * Battery and touchpad data starts at byte 30 in the USB report and
6c5f860d
FP		 916 * 32 in Bluetooth report.
917 */
918 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
919
ad142b9e
FP		 920 /*
921 * The lower 4 bits of byte 30 contain the battery level
d902f472
FP		 922 * and the 5th bit contains the USB cable state.
923 */
6c5f860d
FP		 924 cable_state = (rd[offset] >> 4) & 0x01;
925 battery_capacity = rd[offset] & 0x0F;
d902f472 926
ad142b9e
FP		 927 /*
928 * When a USB power source is connected the battery level ranges from
6c5f860d
FP		 929 * 0 to 10, and when running on battery power it ranges from 0 to 9.
930 * A battery level above 10 when plugged in means charge completed.
d902f472 931 */
6c5f860d 932 if (!cable_state || battery_capacity > 10)
d902f472
FP		 933 battery_charging = 0;
934 else
935 battery_charging = 1;
936
6c5f860d
FP		 937 if (!cable_state)
938 battery_capacity++;
d902f472 939 if (battery_capacity > 10)
6c5f860d
FP		 940 battery_capacity = 10;
941
d902f472
FP		 942 battery_capacity *= 10;
943
944 spin_lock_irqsave(&sc->lock, flags);
945 sc->cable_state = cable_state;
946 sc->battery_capacity = battery_capacity;
947 sc->battery_charging = battery_charging;
948 spin_unlock_irqrestore(&sc->lock, flags);
e5606230 949
6c5f860d
FP		 950 offset += 5;
951
ad142b9e
FP		 952 /*
953 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
6c5f860d 954 * and 37 on Bluetooth.
e5606230
FP		 955 * The first 7 bits of the first byte is a counter and bit 8 is a touch
956 * indicator that is 0 when pressed and 1 when not pressed.
957 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
958 * The data for the second touch is in the same format and immediatly
959 * follows the data for the first.
960 */
961 for (n = 0; n < 2; n++) {
962 __u16 x, y;
963
964 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
965 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
966
967 input_mt_slot(input_dev, n);
968 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
969 !(rd[offset] >> 7));
970 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
971 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
972
973 offset += 4;
974 }
d902f472
FP		 975}
976
c9e4d877
SW		 977static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
978 __u8 *rd, int size)
979{
980 struct sony_sc *sc = hid_get_drvdata(hdev);
981
ad142b9e
FP		 982 /*
983 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
c9e4d877
SW		 984 * has to be BYTE_SWAPPED before passing up to joystick interface
985 */
fee4e2d5 986 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
c9e4d877
SW		 987 swap(rd[41], rd[42]);
988 swap(rd[43], rd[44]);
989 swap(rd[45], rd[46]);
990 swap(rd[47], rd[48]);
d902f472
FP		 991
992 sixaxis_parse_report(sc, rd, size);
68330d83
FP		 993 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
994 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
995 && rd[0] == 0x11 && size == 78)) {
d902f472 996 dualshock4_parse_report(sc, rd, size);
c9e4d877
SW		 997 }
998
999 return 0;
1000}
1001
f04d5140
CL		 1002static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1003 struct hid_field *field, struct hid_usage *usage,
1004 unsigned long **bit, int *max)
1005{
1006 struct sony_sc *sc = hid_get_drvdata(hdev);
1007
1008 if (sc->quirks & BUZZ_CONTROLLER) {
1009 unsigned int key = usage->hid & HID_USAGE;
1010
1011 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1012 return -1;
1013
1014 switch (usage->collection_index) {
1015 case 1:
1016 if (key >= ARRAY_SIZE(buzz_keymap))
1017 return -1;
1018
1019 key = buzz_keymap[key];
1020 if (!key)
1021 return -1;
1022 break;
1023 default:
1024 return -1;
1025 }
1026
1027 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1028 return 1;
1029 }
1030
078328da
JK		 1031 if (sc->quirks & PS3REMOTE)
1032 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1033
6f498018
BT		 1034 /* Let hid-core decide for the others */
1035 return 0;
f04d5140
CL		 1036}
1037
bd28ce00
JS		 1038/*
1039 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1040 * to "operational". Without this, the ps3 controller will not report any
1041 * events.
1042 */
816651a7 1043static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 1044{
bd28ce00
JS		 1045 int ret;
1046 char *buf = kmalloc(18, GFP_KERNEL);
1047
1048 if (!buf)
1049 return -ENOMEM;
1050
cafebc05
BT		 1051 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1052 HID_REQ_GET_REPORT);
f204828a 1053
bd28ce00 1054 if (ret < 0)
4291ee30 1055 hid_err(hdev, "can't set operational mode\n");
bd28ce00
JS		 1056
1057 kfree(buf);
1058
1059 return ret;
1060}
1061
816651a7 1062static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 1063{
fddb33f2 1064 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
b0dd72aa
BT		 1065 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
1066 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
f9ce7c28
BN		 1067}
1068
ad142b9e
FP		 1069/*
1070 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
68330d83
FP		 1071 * controller so that it sends full input reports of type 0x11.
1072 */
1073static int dualshock4_set_operational_bt(struct hid_device *hdev)
1074{
1075 __u8 buf[37] = { 0 };
1076
1077 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf),
1078 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
f9ce7c28
BN		 1079}
1080
60781cf4 1081static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
f04d5140
CL		 1082{
1083 struct list_head *report_list =
1084 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1085 struct hid_report *report = list_entry(report_list->next,
1086 struct hid_report, list);
1087 __s32 *value = report->field[0]->value;
1088
1089 value[0] = 0x00;
60781cf4
FP		 1090 value[1] = leds[0] ? 0xff : 0x00;
1091 value[2] = leds[1] ? 0xff : 0x00;
1092 value[3] = leds[2] ? 0xff : 0x00;
1093 value[4] = leds[3] ? 0xff : 0x00;
f04d5140
CL		 1094 value[5] = 0x00;
1095 value[6] = 0x00;
1096 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1097}
1098
fa57a810 1099static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count)
0a286ef2 1100{
60781cf4 1101 int n;
0a286ef2 1102
60781cf4
FP		 1103 BUG_ON(count > MAX_LEDS);
1104
fa57a810
FP		 1105 if (sc->quirks & BUZZ_CONTROLLER && count == 4) {
1106 buzz_set_leds(sc->hdev, leds);
fee4e2d5 1107 } else {
60781cf4 1108 for (n = 0; n < count; n++)
fa57a810
FP		 1109 sc->led_state[n] = leds[n];
1110 schedule_work(&sc->state_worker);
0a286ef2
SE		 1111 }
1112}
1113
c5382519 1114static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 1115 enum led_brightness value)
1116{
1117 struct device *dev = led->dev->parent;
1118 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1119 struct sony_sc *drv_data;
f04d5140
CL		 1120
1121 int n;
1122
1123 drv_data = hid_get_drvdata(hdev);
2251b85f 1124 if (!drv_data) {
f04d5140
CL		 1125 hid_err(hdev, "No device data\n");
1126 return;
1127 }
f04d5140 1128
60781cf4 1129 for (n = 0; n < drv_data->led_count; n++) {
2251b85f 1130 if (led == drv_data->leds[n]) {
60781cf4
FP		 1131 if (value != drv_data->led_state[n]) {
1132 drv_data->led_state[n] = value;
fa57a810
FP		 1133 sony_set_leds(drv_data, drv_data->led_state,
1134 drv_data->led_count);
f04d5140
CL		 1135 }
1136 break;
1137 }
1138 }
1139}
1140
c5382519 1141static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 1142{
1143 struct device *dev = led->dev->parent;
1144 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1145 struct sony_sc *drv_data;
f04d5140
CL		 1146
1147 int n;
f04d5140
CL		 1148
1149 drv_data = hid_get_drvdata(hdev);
2251b85f 1150 if (!drv_data) {
f04d5140
CL		 1151 hid_err(hdev, "No device data\n");
1152 return LED_OFF;
1153 }
f04d5140 1154
60781cf4 1155 for (n = 0; n < drv_data->led_count; n++) {
7db7504a
SW		 1156 if (led == drv_data->leds[n])
1157 return drv_data->led_state[n];
f04d5140
CL		 1158 }
1159
7db7504a 1160 return LED_OFF;
f04d5140 1161}
f04d5140 1162
fa57a810 1163static void sony_leds_remove(struct sony_sc *sc)
0a286ef2 1164{
0a286ef2
SE		 1165 struct led_classdev *led;
1166 int n;
1167
fa57a810 1168 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1169
fa57a810
FP		 1170 for (n = 0; n < sc->led_count; n++) {
1171 led = sc->leds[n];
1172 sc->leds[n] = NULL;
0a286ef2
SE		 1173 if (!led)
1174 continue;
1175 led_classdev_unregister(led);
1176 kfree(led);
1177 }
60781cf4 1178
fa57a810 1179 sc->led_count = 0;
0a286ef2
SE		 1180}
1181
fa57a810 1182static int sony_leds_init(struct sony_sc *sc)
f04d5140 1183{
fa57a810 1184 struct hid_device *hdev = sc->hdev;
40e32ee6 1185 int n, ret = 0;
60781cf4 1186 int max_brightness;
61ebca93 1187 int use_colors;
40e32ee6
JK		 1188 struct led_classdev *led;
1189 size_t name_sz;
1190 char *name;
0a286ef2
SE		 1191 size_t name_len;
1192 const char *name_fmt;
61ebca93 1193 static const char * const color_str[] = { "red", "green", "blue" };
60781cf4 1194 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
f04d5140 1195
fa57a810 1196 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1197
fa57a810
FP		 1198 if (sc->quirks & BUZZ_CONTROLLER) {
1199 sc->led_count = 4;
61ebca93
FP		 1200 max_brightness = 1;
1201 use_colors = 0;
0a286ef2
SE		 1202 name_len = strlen("::buzz#");
1203 name_fmt = "%s::buzz%d";
1204 /* Validate expected report characteristics. */
1205 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1206 return -ENODEV;
fa57a810
FP		 1207 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1208 sc->led_count = 3;
60781cf4 1209 max_brightness = 255;
61ebca93
FP		 1210 use_colors = 1;
1211 name_len = 0;
1212 name_fmt = "%s:%s";
60781cf4 1213 } else {
fa57a810 1214 sc->led_count = 4;
60781cf4 1215 max_brightness = 1;
61ebca93
FP		 1216 use_colors = 0;
1217 name_len = strlen("::sony#");
1218 name_fmt = "%s::sony%d";
60781cf4
FP		 1219 }
1220
ad142b9e
FP		 1221 /*
1222 * Clear LEDs as we have no way of reading their initial state. This is
f04d5140 1223 * only relevant if the driver is loaded after somebody actively set the
ad142b9e
FP		 1224 * LEDs to on
1225 */
fa57a810 1226 sony_set_leds(sc, initial_values, sc->led_count);
f04d5140 1227
0a286ef2 1228 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 1229
fa57a810 1230 for (n = 0; n < sc->led_count; n++) {
61ebca93
FP		 1231
1232 if (use_colors)
1233 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
1234
40e32ee6
JK		 1235 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1236 if (!led) {
1237 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
8cd5fcda 1238 ret = -ENOMEM;
40e32ee6
JK		 1239 goto error_leds;
1240 }
f04d5140 1241
40e32ee6 1242 name = (void *)(&led[1]);
61ebca93
FP		 1243 if (use_colors)
1244 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
1245 else
1246 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6
JK		 1247 led->name = name;
1248 led->brightness = 0;
60781cf4 1249 led->max_brightness = max_brightness;
c5382519
SE		 1250 led->brightness_get = sony_led_get_brightness;
1251 led->brightness_set = sony_led_set_brightness;
f04d5140 1252
8cd5fcda
JL		 1253 ret = led_classdev_register(&hdev->dev, led);
1254 if (ret) {
40e32ee6
JK		 1255 hid_err(hdev, "Failed to register LED %d\n", n);
1256 kfree(led);
1257 goto error_leds;
f04d5140 1258 }
40e32ee6 1259
fa57a810 1260 sc->leds[n] = led;
f04d5140 1261 }
f04d5140
CL		 1262
1263 return ret;
1264
f04d5140 1265error_leds:
fa57a810 1266 sony_leds_remove(sc);
f04d5140 1267
f04d5140 1268 return ret;
f04d5140
CL		 1269}
1270
cad665a2 1271static void sixaxis_state_worker(struct work_struct *work)
a08c22c0 1272{
92b5c411 1273 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
55d3b664
FP		 1274 union sixaxis_output_report_01 report = {
1275 .buf = {
1276 0x01,
1277 0x00, 0xff, 0x00, 0xff, 0x00,
1278 0x00, 0x00, 0x00, 0x00, 0x00,
1279 0xff, 0x27, 0x10, 0x00, 0x32,
1280 0xff, 0x27, 0x10, 0x00, 0x32,
1281 0xff, 0x27, 0x10, 0x00, 0x32,
1282 0xff, 0x27, 0x10, 0x00, 0x32,
1283 0x00, 0x00, 0x00, 0x00, 0x00
1284 }
a08c22c0 1285 };
9f323b68 1286
0a286ef2 1287#ifdef CONFIG_SONY_FF
55d3b664
FP		 1288 report.data.rumble.right_motor_on = sc->right ? 1 : 0;
1289 report.data.rumble.left_motor_force = sc->left;
0a286ef2
SE		 1290#endif
1291
55d3b664
FP		 1292 report.data.leds_bitmap |= sc->led_state[0] << 1;
1293 report.data.leds_bitmap |= sc->led_state[1] << 2;
1294 report.data.leds_bitmap |= sc->led_state[2] << 3;
1295 report.data.leds_bitmap |= sc->led_state[3] << 4;
9f323b68 1296
55d3b664
FP		 1297 hid_hw_raw_request(sc->hdev, report.data.report_id, report.buf,
1298 sizeof(report), HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
9f323b68
SE		 1299}
1300
0bd88dd3
FP		 1301static void dualshock4_state_worker(struct work_struct *work)
1302{
1303 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
0da8ea65 1304 struct hid_device *hdev = sc->hdev;
48220237
FP		 1305 int offset;
1306
fdcf105d 1307 __u8 buf[78] = { 0 };
0da8ea65 1308
fdcf105d
FP		 1309 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1310 buf[0] = 0x05;
1311 buf[1] = 0x03;
1312 offset = 4;
1313 } else {
1314 buf[0] = 0x11;
1315 buf[1] = 0xB0;
1316 buf[3] = 0x0F;
1317 offset = 6;
1318 }
0bd88dd3
FP		 1319
1320#ifdef CONFIG_SONY_FF
48220237
FP		 1321 buf[offset++] = sc->right;
1322 buf[offset++] = sc->left;
1323#else
1324 offset += 2;
0bd88dd3
FP		 1325#endif
1326
48220237
FP		 1327 buf[offset++] = sc->led_state[0];
1328 buf[offset++] = sc->led_state[1];
1329 buf[offset++] = sc->led_state[2];
60781cf4 1330
fdcf105d
FP		 1331 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1332 hid_hw_output_report(hdev, buf, 32);
1333 else
1334 hid_hw_raw_request(hdev, 0x11, buf, 78,
1335 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
0bd88dd3
FP		 1336}
1337
0a286ef2 1338#ifdef CONFIG_SONY_FF
9f323b68
SE		 1339static int sony_play_effect(struct input_dev *dev, void *data,
1340 struct ff_effect *effect)
1341{
a08c22c0 1342 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 1343 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 1344
1345 if (effect->type != FF_RUMBLE)
1346 return 0;
1347
9f323b68 1348 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 1349 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 1350
92b5c411 1351 schedule_work(&sc->state_worker);
9f323b68 1352 return 0;
a08c22c0
SE		 1353}
1354
fa57a810 1355static int sony_init_ff(struct sony_sc *sc)
a08c22c0 1356{
fa57a810 1357 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
a08c22c0
SE		 1358 struct hid_input, list);
1359 struct input_dev *input_dev = hidinput->input;
1360
1361 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1362 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1363}
1364
1365#else
fa57a810 1366static int sony_init_ff(struct sony_sc *sc)
a08c22c0
SE		 1367{
1368 return 0;
1369}
9f323b68 1370
a08c22c0
SE		 1371#endif
1372
d902f472
FP		 1373static int sony_battery_get_property(struct power_supply *psy,
1374 enum power_supply_property psp,
1375 union power_supply_propval *val)
1376{
1377 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1378 unsigned long flags;
1379 int ret = 0;
1380 u8 battery_charging, battery_capacity, cable_state;
1381
1382 spin_lock_irqsave(&sc->lock, flags);
1383 battery_charging = sc->battery_charging;
1384 battery_capacity = sc->battery_capacity;
1385 cable_state = sc->cable_state;
1386 spin_unlock_irqrestore(&sc->lock, flags);
1387
1388 switch (psp) {
1389 case POWER_SUPPLY_PROP_PRESENT:
1390 val->intval = 1;
1391 break;
1392 case POWER_SUPPLY_PROP_SCOPE:
1393 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1394 break;
1395 case POWER_SUPPLY_PROP_CAPACITY:
1396 val->intval = battery_capacity;
1397 break;
1398 case POWER_SUPPLY_PROP_STATUS:
1399 if (battery_charging)
1400 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1401 else
1402 if (battery_capacity == 100 && cable_state)
1403 val->intval = POWER_SUPPLY_STATUS_FULL;
1404 else
1405 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1406 break;
1407 default:
1408 ret = -EINVAL;
1409 break;
1410 }
1411 return ret;
9f323b68
SE		 1412}
1413
d902f472 1414static int sony_battery_probe(struct sony_sc *sc)
c4e1ddf2 1415{
d902f472
FP		 1416 static atomic_t power_id_seq = ATOMIC_INIT(0);
1417 unsigned long power_id;
c4e1ddf2 1418 struct hid_device *hdev = sc->hdev;
d902f472 1419 int ret;
c4e1ddf2 1420
ad142b9e
FP		 1421 /*
1422 * Set the default battery level to 100% to avoid low battery warnings
d9a293a9
FP		 1423 * if the battery is polled before the first device report is received.
1424 */
1425 sc->battery_capacity = 100;
1426
d902f472
FP		 1427 power_id = (unsigned long)atomic_inc_return(&power_id_seq);
1428
1429 sc->battery.properties = sony_battery_props;
1430 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1431 sc->battery.get_property = sony_battery_get_property;
1432 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1433 sc->battery.use_for_apm = 0;
1434 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%lu",
1435 power_id);
1436 if (!sc->battery.name)
1437 return -ENOMEM;
c4e1ddf2 1438
d902f472
FP		 1439 ret = power_supply_register(&hdev->dev, &sc->battery);
1440 if (ret) {
1441 hid_err(hdev, "Unable to register battery device\n");
1442 goto err_free;
1443 }
c4e1ddf2 1444
d902f472 1445 power_supply_powers(&sc->battery, &hdev->dev);
a08c22c0 1446 return 0;
d902f472
FP		 1447
1448err_free:
1449 kfree(sc->battery.name);
1450 sc->battery.name = NULL;
1451 return ret;
a08c22c0 1452}
9f323b68 1453
d902f472 1454static void sony_battery_remove(struct sony_sc *sc)
9f323b68 1455{
d902f472
FP		 1456 if (!sc->battery.name)
1457 return;
1458
1459 power_supply_unregister(&sc->battery);
1460 kfree(sc->battery.name);
1461 sc->battery.name = NULL;
9f323b68 1462}
a08c22c0 1463
e5606230
FP		 1464static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1465 int w, int h)
c4e1ddf2 1466{
e5606230
FP		 1467 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1468 struct hid_input, list);
1469 struct input_dev *input_dev = hidinput->input;
1470 int ret;
1471
1472 ret = input_mt_init_slots(input_dev, touch_count, 0);
1473 if (ret < 0) {
1474 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1475 return ret;
1476 }
c4e1ddf2 1477
e5606230
FP		 1478 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1479 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
c4e1ddf2 1480
e5606230
FP		 1481 return 0;
1482}
c4e1ddf2 1483
d2d782fc
FP		 1484/*
1485 * If a controller is plugged in via USB while already connected via Bluetooth
1486 * it will show up as two devices. A global list of connected controllers and
1487 * their MAC addresses is maintained to ensure that a device is only connected
1488 * once.
1489 */
1490static int sony_check_add_dev_list(struct sony_sc *sc)
1491{
1492 struct sony_sc *entry;
1493 unsigned long flags;
1494 int ret;
1495
1496 spin_lock_irqsave(&sony_dev_list_lock, flags);
1497
1498 list_for_each_entry(entry, &sony_device_list, list_node) {
1499 ret = memcmp(sc->mac_address, entry->mac_address,
1500 sizeof(sc->mac_address));
1501 if (!ret) {
1502 ret = -EEXIST;
1503 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1504 sc->mac_address);
1505 goto unlock;
c4e1ddf2
FP		 1506 }
1507 }
1508
d2d782fc
FP		 1509 ret = 0;
1510 list_add(&(sc->list_node), &sony_device_list);
c4e1ddf2 1511
d2d782fc
FP		 1512unlock:
1513 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1514 return ret;
1515}
1516
1517static void sony_remove_dev_list(struct sony_sc *sc)
1518{
1519 unsigned long flags;
c4e1ddf2 1520
d2d782fc
FP		 1521 if (sc->list_node.next) {
1522 spin_lock_irqsave(&sony_dev_list_lock, flags);
1523 list_del(&(sc->list_node));
1524 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1525 }
c4e1ddf2
FP		 1526}
1527
d2d782fc
FP		 1528static int sony_get_bt_devaddr(struct sony_sc *sc)
1529{
1530 int ret;
1531
1532 /* HIDP stores the device MAC address as a string in the uniq field. */
1533 ret = strlen(sc->hdev->uniq);
1534 if (ret != 17)
1535 return -EINVAL;
1536
1537 ret = sscanf(sc->hdev->uniq,
1538 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1539 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1540 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1541
1542 if (ret != 6)
1543 return -EINVAL;
1544
1545 return 0;
1546}
1547
1548static int sony_check_add(struct sony_sc *sc)
1549{
1550 int n, ret;
1551
1552 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1553 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1554 /*
1555 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1556 * address from the uniq string where HIDP stores it.
1557 * As uniq cannot be guaranteed to be a MAC address in all cases
1558 * a failure of this function should not prevent the connection.
1559 */
1560 if (sony_get_bt_devaddr(sc) < 0) {
1561 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1562 return 0;
1563 }
1564 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1565 __u8 buf[7];
1566
1567 /*
1568 * The MAC address of a DS4 controller connected via USB can be
1569 * retrieved with feature report 0x81. The address begins at
1570 * offset 1.
1571 */
1572 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1573 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1574
1575 if (ret != 7) {
1576 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1577 return ret < 0 ? ret : -EINVAL;
1578 }
1579
1580 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1581 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1582 __u8 buf[18];
1583
1584 /*
1585 * The MAC address of a Sixaxis controller connected via USB can
1586 * be retrieved with feature report 0xf2. The address begins at
1587 * offset 4.
1588 */
1589 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1590 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1591
1592 if (ret != 18) {
1593 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1594 return ret < 0 ? ret : -EINVAL;
1595 }
1596
1597 /*
1598 * The Sixaxis device MAC in the report is big-endian and must
1599 * be byte-swapped.
1600 */
1601 for (n = 0; n < 6; n++)
1602 sc->mac_address[5-n] = buf[4+n];
1603 } else {
1604 return 0;
1605 }
1606
1607 return sony_check_add_dev_list(sc);
1608}
1609
46262047
FP		 1610static inline void sony_init_work(struct sony_sc *sc,
1611 void (*worker)(struct work_struct *))
1612{
1613 if (!sc->worker_initialized)
1614 INIT_WORK(&sc->state_worker, worker);
1615
1616 sc->worker_initialized = 1;
1617}
1618
1619static inline void sony_cancel_work_sync(struct sony_sc *sc)
1620{
1621 if (sc->worker_initialized)
1622 cancel_work_sync(&sc->state_worker);
1623}
d2d782fc 1624
bd28ce00
JS		 1625static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1626{
1627 int ret;
cc6e0bbb
JK		 1628 unsigned long quirks = id->driver_data;
1629 struct sony_sc *sc;
f04d5140 1630 unsigned int connect_mask = HID_CONNECT_DEFAULT;
cc6e0bbb 1631
abf832bf 1632 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
cc6e0bbb 1633 if (sc == NULL) {
4291ee30 1634 hid_err(hdev, "can't alloc sony descriptor\n");
cc6e0bbb
JK		 1635 return -ENOMEM;
1636 }
1637
1638 sc->quirks = quirks;
1639 hid_set_drvdata(hdev, sc);
0a286ef2 1640 sc->hdev = hdev;
bd28ce00 1641
bd28ce00
JS		 1642 ret = hid_parse(hdev);
1643 if (ret) {
4291ee30 1644 hid_err(hdev, "parse failed\n");
abf832bf 1645 return ret;
bd28ce00
JS		 1646 }
1647
f04d5140
CL		 1648 if (sc->quirks & VAIO_RDESC_CONSTANT)
1649 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1650 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1651 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1652 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1653 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1654
1655 ret = hid_hw_start(hdev, connect_mask);
bd28ce00 1656 if (ret) {
4291ee30 1657 hid_err(hdev, "hw start failed\n");
abf832bf 1658 return ret;
bd28ce00
JS		 1659 }
1660
569b10a5 1661 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
e534a935
BT		 1662 /*
1663 * The Sony Sixaxis does not handle HID Output Reports on the
1664 * Interrupt EP like it could, so we need to force HID Output
1665 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1666 *
1667 * There is also another issue about HID Output Reports via USB,
1668 * the Sixaxis does not want the report_id as part of the data
1669 * packet, so we have to discard buf[0] when sending the actual
1670 * control message, even for numbered reports, humpf!
1671 */
1672 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1673 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
816651a7 1674 ret = sixaxis_set_operational_usb(hdev);
46262047 1675 sony_init_work(sc, sixaxis_state_worker);
fee4e2d5 1676 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2078b9bb
FP		 1677 /*
1678 * The Sixaxis wants output reports sent on the ctrl endpoint
1679 * when connected via Bluetooth.
1680 */
1681 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
816651a7 1682 ret = sixaxis_set_operational_bt(hdev);
46262047 1683 sony_init_work(sc, sixaxis_state_worker);
fee4e2d5 1684 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
68330d83 1685 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2078b9bb
FP		 1686 /*
1687 * The DualShock 4 wants output reports sent on the ctrl
1688 * endpoint when connected via Bluetooth.
1689 */
1690 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
68330d83
FP		 1691 ret = dualshock4_set_operational_bt(hdev);
1692 if (ret < 0) {
1693 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1694 goto err_stop;
1695 }
1696 }
ad142b9e
FP		 1697 /*
1698 * The Dualshock 4 touchpad supports 2 touches and has a
e5606230
FP		 1699 * resolution of 1920x940.
1700 */
1701 ret = sony_register_touchpad(sc, 2, 1920, 940);
c4e1ddf2
FP		 1702 if (ret < 0)
1703 goto err_stop;
1704
46262047 1705 sony_init_work(sc, dualshock4_state_worker);
0bd88dd3
FP		 1706 } else {
1707 ret = 0;
1708 }
f9ce7c28 1709
d2d782fc
FP		 1710 if (ret < 0)
1711 goto err_stop;
1712
1713 ret = sony_check_add(sc);
4dfdc464 1714 if (ret < 0)
bd28ce00
JS		 1715 goto err_stop;
1716
0a286ef2 1717 if (sc->quirks & SONY_LED_SUPPORT) {
fa57a810 1718 ret = sony_leds_init(sc);
0a286ef2
SE		 1719 if (ret < 0)
1720 goto err_stop;
1721 }
1722
d902f472
FP		 1723 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1724 ret = sony_battery_probe(sc);
1725 if (ret < 0)
1726 goto err_stop;
1727
1728 /* Open the device to receive reports with battery info */
1729 ret = hid_hw_open(hdev);
1730 if (ret < 0) {
1731 hid_err(hdev, "hw open failed\n");
1732 goto err_stop;
1733 }
1734 }
1735
c8de9dbb 1736 if (sc->quirks & SONY_FF_SUPPORT) {
fa57a810 1737 ret = sony_init_ff(sc);
c8de9dbb
FP		 1738 if (ret < 0)
1739 goto err_close;
5f5750d2 1740 }
a08c22c0 1741
bd28ce00 1742 return 0;
d902f472
FP		 1743err_close:
1744 hid_hw_close(hdev);
bd28ce00 1745err_stop:
0a286ef2 1746 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 1747 sony_leds_remove(sc);
d902f472
FP		 1748 if (sc->quirks & SONY_BATTERY_SUPPORT)
1749 sony_battery_remove(sc);
46262047 1750 sony_cancel_work_sync(sc);
d2d782fc 1751 sony_remove_dev_list(sc);
bd28ce00 1752 hid_hw_stop(hdev);
bd28ce00
JS		 1753 return ret;
1754}
1755
cc6e0bbb
JK		 1756static void sony_remove(struct hid_device *hdev)
1757{
f04d5140
CL		 1758 struct sony_sc *sc = hid_get_drvdata(hdev);
1759
0a286ef2 1760 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 1761 sony_leds_remove(sc);
f04d5140 1762
d902f472
FP		 1763 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1764 hid_hw_close(hdev);
1765 sony_battery_remove(sc);
1766 }
1767
46262047 1768 sony_cancel_work_sync(sc);
9f323b68 1769
d2d782fc 1770 sony_remove_dev_list(sc);
9f323b68 1771
cc6e0bbb 1772 hid_hw_stop(hdev);
cc6e0bbb
JK		 1773}
1774
bd28ce00 1775static const struct hid_device_id sony_devices[] = {
816651a7
AO		 1776 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1777 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4
JK		 1778 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1779 .driver_data = SIXAXIS_CONTROLLER_USB },
816651a7
AO		 1780 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1781 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 1782 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1783 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 1784 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1785 .driver_data = VAIO_RDESC_CONSTANT },
f04d5140
CL		 1786 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1787 * Logitech joystick from the device descriptor. */
1788 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1789 .driver_data = BUZZ_CONTROLLER },
1790 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1791 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 1792 /* PS3 BD Remote Control */
1793 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1794 .driver_data = PS3REMOTE },
1795 /* Logitech Harmony Adapter for PS3 */
1796 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1797 .driver_data = PS3REMOTE },
0bd88dd3
FP		 1798 /* Sony Dualshock 4 controllers for PS4 */
1799 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1800 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 1801 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1802 .driver_data = DUALSHOCK4_CONTROLLER_BT },
bd28ce00
JS		 1803 { }
1804};
1805MODULE_DEVICE_TABLE(hid, sony_devices);
1806
1807static struct hid_driver sony_driver = {
f04d5140
CL		 1808 .name = "sony",
1809 .id_table = sony_devices,
1810 .input_mapping = sony_mapping,
1811 .probe = sony_probe,
1812 .remove = sony_remove,
1813 .report_fixup = sony_report_fixup,
1814 .raw_event = sony_raw_event
bd28ce00 1815};
f425458e 1816module_hid_driver(sony_driver);
bd28ce00 1817
bd28ce00 1818MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror