]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/hid/hid-sony.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
HID: sony: Use the controller Bluetooth MAC address as the unique value in the batter...
[mirror_ubuntu-zesty-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{
c4e1ddf2 1416 struct hid_device *hdev = sc->hdev;
d902f472 1417 int ret;
c4e1ddf2 1418
ad142b9e
FP		 1419 /*
1420 * Set the default battery level to 100% to avoid low battery warnings
d9a293a9
FP		 1421 * if the battery is polled before the first device report is received.
1422 */
1423 sc->battery_capacity = 100;
1424
d902f472
FP		 1425 sc->battery.properties = sony_battery_props;
1426 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1427 sc->battery.get_property = sony_battery_get_property;
1428 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1429 sc->battery.use_for_apm = 0;
314531f1
FP		 1430 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR",
1431 sc->mac_address);
d902f472
FP		 1432 if (!sc->battery.name)
1433 return -ENOMEM;
c4e1ddf2 1434
d902f472
FP		 1435 ret = power_supply_register(&hdev->dev, &sc->battery);
1436 if (ret) {
1437 hid_err(hdev, "Unable to register battery device\n");
1438 goto err_free;
1439 }
c4e1ddf2 1440
d902f472 1441 power_supply_powers(&sc->battery, &hdev->dev);
a08c22c0 1442 return 0;
d902f472
FP		 1443
1444err_free:
1445 kfree(sc->battery.name);
1446 sc->battery.name = NULL;
1447 return ret;
a08c22c0 1448}
9f323b68 1449
d902f472 1450static void sony_battery_remove(struct sony_sc *sc)
9f323b68 1451{
d902f472
FP		 1452 if (!sc->battery.name)
1453 return;
1454
1455 power_supply_unregister(&sc->battery);
1456 kfree(sc->battery.name);
1457 sc->battery.name = NULL;
9f323b68 1458}
a08c22c0 1459
e5606230
FP		 1460static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1461 int w, int h)
c4e1ddf2 1462{
e5606230
FP		 1463 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1464 struct hid_input, list);
1465 struct input_dev *input_dev = hidinput->input;
1466 int ret;
1467
1468 ret = input_mt_init_slots(input_dev, touch_count, 0);
1469 if (ret < 0) {
1470 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1471 return ret;
1472 }
c4e1ddf2 1473
e5606230
FP		 1474 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1475 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
c4e1ddf2 1476
e5606230
FP		 1477 return 0;
1478}
c4e1ddf2 1479
d2d782fc
FP		 1480/*
1481 * If a controller is plugged in via USB while already connected via Bluetooth
1482 * it will show up as two devices. A global list of connected controllers and
1483 * their MAC addresses is maintained to ensure that a device is only connected
1484 * once.
1485 */
1486static int sony_check_add_dev_list(struct sony_sc *sc)
1487{
1488 struct sony_sc *entry;
1489 unsigned long flags;
1490 int ret;
1491
1492 spin_lock_irqsave(&sony_dev_list_lock, flags);
1493
1494 list_for_each_entry(entry, &sony_device_list, list_node) {
1495 ret = memcmp(sc->mac_address, entry->mac_address,
1496 sizeof(sc->mac_address));
1497 if (!ret) {
1498 ret = -EEXIST;
1499 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1500 sc->mac_address);
1501 goto unlock;
c4e1ddf2
FP		 1502 }
1503 }
1504
d2d782fc
FP		 1505 ret = 0;
1506 list_add(&(sc->list_node), &sony_device_list);
c4e1ddf2 1507
d2d782fc
FP		 1508unlock:
1509 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1510 return ret;
1511}
1512
1513static void sony_remove_dev_list(struct sony_sc *sc)
1514{
1515 unsigned long flags;
c4e1ddf2 1516
d2d782fc
FP		 1517 if (sc->list_node.next) {
1518 spin_lock_irqsave(&sony_dev_list_lock, flags);
1519 list_del(&(sc->list_node));
1520 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1521 }
c4e1ddf2
FP		 1522}
1523
d2d782fc
FP		 1524static int sony_get_bt_devaddr(struct sony_sc *sc)
1525{
1526 int ret;
1527
1528 /* HIDP stores the device MAC address as a string in the uniq field. */
1529 ret = strlen(sc->hdev->uniq);
1530 if (ret != 17)
1531 return -EINVAL;
1532
1533 ret = sscanf(sc->hdev->uniq,
1534 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1535 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1536 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1537
1538 if (ret != 6)
1539 return -EINVAL;
1540
1541 return 0;
1542}
1543
1544static int sony_check_add(struct sony_sc *sc)
1545{
1546 int n, ret;
1547
1548 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1549 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1550 /*
1551 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1552 * address from the uniq string where HIDP stores it.
1553 * As uniq cannot be guaranteed to be a MAC address in all cases
1554 * a failure of this function should not prevent the connection.
1555 */
1556 if (sony_get_bt_devaddr(sc) < 0) {
1557 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1558 return 0;
1559 }
1560 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1561 __u8 buf[7];
1562
1563 /*
1564 * The MAC address of a DS4 controller connected via USB can be
1565 * retrieved with feature report 0x81. The address begins at
1566 * offset 1.
1567 */
1568 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1569 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1570
1571 if (ret != 7) {
1572 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1573 return ret < 0 ? ret : -EINVAL;
1574 }
1575
1576 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1577 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1578 __u8 buf[18];
1579
1580 /*
1581 * The MAC address of a Sixaxis controller connected via USB can
1582 * be retrieved with feature report 0xf2. The address begins at
1583 * offset 4.
1584 */
1585 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1586 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1587
1588 if (ret != 18) {
1589 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1590 return ret < 0 ? ret : -EINVAL;
1591 }
1592
1593 /*
1594 * The Sixaxis device MAC in the report is big-endian and must
1595 * be byte-swapped.
1596 */
1597 for (n = 0; n < 6; n++)
1598 sc->mac_address[5-n] = buf[4+n];
1599 } else {
1600 return 0;
1601 }
1602
1603 return sony_check_add_dev_list(sc);
1604}
1605
46262047
FP		 1606static inline void sony_init_work(struct sony_sc *sc,
1607 void (*worker)(struct work_struct *))
1608{
1609 if (!sc->worker_initialized)
1610 INIT_WORK(&sc->state_worker, worker);
1611
1612 sc->worker_initialized = 1;
1613}
1614
1615static inline void sony_cancel_work_sync(struct sony_sc *sc)
1616{
1617 if (sc->worker_initialized)
1618 cancel_work_sync(&sc->state_worker);
1619}
d2d782fc 1620
bd28ce00
JS		 1621static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1622{
1623 int ret;
cc6e0bbb
JK		 1624 unsigned long quirks = id->driver_data;
1625 struct sony_sc *sc;
f04d5140 1626 unsigned int connect_mask = HID_CONNECT_DEFAULT;
cc6e0bbb 1627
abf832bf 1628 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
cc6e0bbb 1629 if (sc == NULL) {
4291ee30 1630 hid_err(hdev, "can't alloc sony descriptor\n");
cc6e0bbb
JK		 1631 return -ENOMEM;
1632 }
1633
1634 sc->quirks = quirks;
1635 hid_set_drvdata(hdev, sc);
0a286ef2 1636 sc->hdev = hdev;
bd28ce00 1637
bd28ce00
JS		 1638 ret = hid_parse(hdev);
1639 if (ret) {
4291ee30 1640 hid_err(hdev, "parse failed\n");
abf832bf 1641 return ret;
bd28ce00
JS		 1642 }
1643
f04d5140
CL		 1644 if (sc->quirks & VAIO_RDESC_CONSTANT)
1645 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1646 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1647 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1648 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1649 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1650
1651 ret = hid_hw_start(hdev, connect_mask);
bd28ce00 1652 if (ret) {
4291ee30 1653 hid_err(hdev, "hw start failed\n");
abf832bf 1654 return ret;
bd28ce00
JS		 1655 }
1656
569b10a5 1657 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
e534a935
BT		 1658 /*
1659 * The Sony Sixaxis does not handle HID Output Reports on the
1660 * Interrupt EP like it could, so we need to force HID Output
1661 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1662 *
1663 * There is also another issue about HID Output Reports via USB,
1664 * the Sixaxis does not want the report_id as part of the data
1665 * packet, so we have to discard buf[0] when sending the actual
1666 * control message, even for numbered reports, humpf!
1667 */
1668 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1669 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
816651a7 1670 ret = sixaxis_set_operational_usb(hdev);
46262047 1671 sony_init_work(sc, sixaxis_state_worker);
fee4e2d5 1672 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2078b9bb
FP		 1673 /*
1674 * The Sixaxis wants output reports sent on the ctrl endpoint
1675 * when connected via Bluetooth.
1676 */
1677 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
816651a7 1678 ret = sixaxis_set_operational_bt(hdev);
46262047 1679 sony_init_work(sc, sixaxis_state_worker);
fee4e2d5 1680 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
68330d83 1681 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2078b9bb
FP		 1682 /*
1683 * The DualShock 4 wants output reports sent on the ctrl
1684 * endpoint when connected via Bluetooth.
1685 */
1686 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
68330d83
FP		 1687 ret = dualshock4_set_operational_bt(hdev);
1688 if (ret < 0) {
1689 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1690 goto err_stop;
1691 }
1692 }
ad142b9e
FP		 1693 /*
1694 * The Dualshock 4 touchpad supports 2 touches and has a
e5606230
FP		 1695 * resolution of 1920x940.
1696 */
1697 ret = sony_register_touchpad(sc, 2, 1920, 940);
c4e1ddf2
FP		 1698 if (ret < 0)
1699 goto err_stop;
1700
46262047 1701 sony_init_work(sc, dualshock4_state_worker);
0bd88dd3
FP		 1702 } else {
1703 ret = 0;
1704 }
f9ce7c28 1705
d2d782fc
FP		 1706 if (ret < 0)
1707 goto err_stop;
1708
1709 ret = sony_check_add(sc);
4dfdc464 1710 if (ret < 0)
bd28ce00
JS		 1711 goto err_stop;
1712
0a286ef2 1713 if (sc->quirks & SONY_LED_SUPPORT) {
fa57a810 1714 ret = sony_leds_init(sc);
0a286ef2
SE		 1715 if (ret < 0)
1716 goto err_stop;
1717 }
1718
d902f472
FP		 1719 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1720 ret = sony_battery_probe(sc);
1721 if (ret < 0)
1722 goto err_stop;
1723
1724 /* Open the device to receive reports with battery info */
1725 ret = hid_hw_open(hdev);
1726 if (ret < 0) {
1727 hid_err(hdev, "hw open failed\n");
1728 goto err_stop;
1729 }
1730 }
1731
c8de9dbb 1732 if (sc->quirks & SONY_FF_SUPPORT) {
fa57a810 1733 ret = sony_init_ff(sc);
c8de9dbb
FP		 1734 if (ret < 0)
1735 goto err_close;
5f5750d2 1736 }
a08c22c0 1737
bd28ce00 1738 return 0;
d902f472
FP		 1739err_close:
1740 hid_hw_close(hdev);
bd28ce00 1741err_stop:
0a286ef2 1742 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 1743 sony_leds_remove(sc);
d902f472
FP		 1744 if (sc->quirks & SONY_BATTERY_SUPPORT)
1745 sony_battery_remove(sc);
46262047 1746 sony_cancel_work_sync(sc);
d2d782fc 1747 sony_remove_dev_list(sc);
bd28ce00 1748 hid_hw_stop(hdev);
bd28ce00
JS		 1749 return ret;
1750}
1751
cc6e0bbb
JK		 1752static void sony_remove(struct hid_device *hdev)
1753{
f04d5140
CL		 1754 struct sony_sc *sc = hid_get_drvdata(hdev);
1755
0a286ef2 1756 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 1757 sony_leds_remove(sc);
f04d5140 1758
d902f472
FP		 1759 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1760 hid_hw_close(hdev);
1761 sony_battery_remove(sc);
1762 }
1763
46262047 1764 sony_cancel_work_sync(sc);
9f323b68 1765
d2d782fc 1766 sony_remove_dev_list(sc);
9f323b68 1767
cc6e0bbb 1768 hid_hw_stop(hdev);
cc6e0bbb
JK		 1769}
1770
bd28ce00 1771static const struct hid_device_id sony_devices[] = {
816651a7
AO		 1772 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1773 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4
JK		 1774 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1775 .driver_data = SIXAXIS_CONTROLLER_USB },
816651a7
AO		 1776 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1777 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 1778 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1779 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 1780 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1781 .driver_data = VAIO_RDESC_CONSTANT },
f04d5140
CL		 1782 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1783 * Logitech joystick from the device descriptor. */
1784 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1785 .driver_data = BUZZ_CONTROLLER },
1786 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1787 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 1788 /* PS3 BD Remote Control */
1789 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1790 .driver_data = PS3REMOTE },
1791 /* Logitech Harmony Adapter for PS3 */
1792 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1793 .driver_data = PS3REMOTE },
0bd88dd3
FP		 1794 /* Sony Dualshock 4 controllers for PS4 */
1795 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1796 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 1797 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1798 .driver_data = DUALSHOCK4_CONTROLLER_BT },
bd28ce00
JS		 1799 { }
1800};
1801MODULE_DEVICE_TABLE(hid, sony_devices);
1802
1803static struct hid_driver sony_driver = {
f04d5140
CL		 1804 .name = "sony",
1805 .id_table = sony_devices,
1806 .input_mapping = sony_mapping,
1807 .probe = sony_probe,
1808 .remove = sony_remove,
1809 .report_fixup = sony_report_fixup,
1810 .raw_event = sony_raw_event
bd28ce00 1811};
f425458e 1812module_hid_driver(sony_driver);
bd28ce00 1813
bd28ce00 1814MODULE_LICENSE("GPL");
ubuntu-zesty-kernel mirror