]> 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
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...
[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>
8025087a 36#include <linux/idr.h>
e5606230 37#include <linux/input/mt.h>
bd28ce00
JS		 38
39#include "hid-ids.h"
40
6c79c18c
FP		 41#define VAIO_RDESC_CONSTANT BIT(0)
42#define SIXAXIS_CONTROLLER_USB BIT(1)
43#define SIXAXIS_CONTROLLER_BT BIT(2)
44#define BUZZ_CONTROLLER BIT(3)
45#define PS3REMOTE BIT(4)
8ab1676b
FP		 46#define DUALSHOCK4_CONTROLLER_USB BIT(5)
47#define DUALSHOCK4_CONTROLLER_BT BIT(6)
cc6e0bbb 48
fee4e2d5 49#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
68330d83
FP		 50#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
51 DUALSHOCK4_CONTROLLER_BT)
fee4e2d5 52#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
68330d83 53 DUALSHOCK4_CONTROLLER)
fee4e2d5 54#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
c8de9dbb 55#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
60781cf4
FP		 56
57#define MAX_LEDS 4
0a286ef2 58
61ab44be
SW		 59static const u8 sixaxis_rdesc_fixup[] = {
60 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
61 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
62 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
63};
64
e57a67da
MCC		 65static const u8 sixaxis_rdesc_fixup2[] = {
66 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
67 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
68 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
69 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
70 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
71 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
72 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
73 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
74 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
75 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
76 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
77 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
78 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
79 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
80 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
81 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
82 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
83 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
84 0xb1, 0x02, 0xc0, 0xc0,
85};
86
ad142b9e
FP		 87/*
88 * The default descriptor doesn't provide mapping for the accelerometers
58d7027b
FP		 89 * or orientation sensors. This fixed descriptor maps the accelerometers
90 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
91 * to usage values 0x43, 0x44 and 0x45.
92 */
ed19d8cf 93static u8 dualshock4_usb_rdesc[] = {
58d7027b
FP		 94 0x05, 0x01, /* Usage Page (Desktop), */
95 0x09, 0x05, /* Usage (Gamepad), */
96 0xA1, 0x01, /* Collection (Application), */
97 0x85, 0x01, /* Report ID (1), */
98 0x09, 0x30, /* Usage (X), */
99 0x09, 0x31, /* Usage (Y), */
100 0x09, 0x32, /* Usage (Z), */
101 0x09, 0x35, /* Usage (Rz), */
102 0x15, 0x00, /* Logical Minimum (0), */
103 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
104 0x75, 0x08, /* Report Size (8), */
105 0x95, 0x04, /* Report Count (4), */
106 0x81, 0x02, /* Input (Variable), */
107 0x09, 0x39, /* Usage (Hat Switch), */
108 0x15, 0x00, /* Logical Minimum (0), */
109 0x25, 0x07, /* Logical Maximum (7), */
110 0x35, 0x00, /* Physical Minimum (0), */
111 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
112 0x65, 0x14, /* Unit (Degrees), */
113 0x75, 0x04, /* Report Size (4), */
114 0x95, 0x01, /* Report Count (1), */
115 0x81, 0x42, /* Input (Variable, Null State), */
116 0x65, 0x00, /* Unit, */
117 0x05, 0x09, /* Usage Page (Button), */
118 0x19, 0x01, /* Usage Minimum (01h), */
119 0x29, 0x0E, /* Usage Maximum (0Eh), */
120 0x15, 0x00, /* Logical Minimum (0), */
121 0x25, 0x01, /* Logical Maximum (1), */
122 0x75, 0x01, /* Report Size (1), */
123 0x95, 0x0E, /* Report Count (14), */
124 0x81, 0x02, /* Input (Variable), */
125 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
126 0x09, 0x20, /* Usage (20h), */
127 0x75, 0x06, /* Report Size (6), */
128 0x95, 0x01, /* Report Count (1), */
129 0x15, 0x00, /* Logical Minimum (0), */
130 0x25, 0x7F, /* Logical Maximum (127), */
131 0x81, 0x02, /* Input (Variable), */
132 0x05, 0x01, /* Usage Page (Desktop), */
133 0x09, 0x33, /* Usage (Rx), */
134 0x09, 0x34, /* Usage (Ry), */
135 0x15, 0x00, /* Logical Minimum (0), */
136 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
137 0x75, 0x08, /* Report Size (8), */
138 0x95, 0x02, /* Report Count (2), */
139 0x81, 0x02, /* Input (Variable), */
140 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
141 0x09, 0x21, /* Usage (21h), */
142 0x95, 0x03, /* Report Count (3), */
143 0x81, 0x02, /* Input (Variable), */
144 0x05, 0x01, /* Usage Page (Desktop), */
145 0x19, 0x40, /* Usage Minimum (40h), */
146 0x29, 0x42, /* Usage Maximum (42h), */
147 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
148 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
149 0x75, 0x10, /* Report Size (16), */
150 0x95, 0x03, /* Report Count (3), */
151 0x81, 0x02, /* Input (Variable), */
152 0x19, 0x43, /* Usage Minimum (43h), */
153 0x29, 0x45, /* Usage Maximum (45h), */
154 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
155 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
156 0x95, 0x03, /* Report Count (3), */
157 0x81, 0x02, /* Input (Variable), */
158 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
159 0x09, 0x21, /* Usage (21h), */
160 0x15, 0x00, /* Logical Minimum (0), */
161 0x25, 0xFF, /* Logical Maximum (255), */
162 0x75, 0x08, /* Report Size (8), */
163 0x95, 0x27, /* Report Count (39), */
164 0x81, 0x02, /* Input (Variable), */
165 0x85, 0x05, /* Report ID (5), */
166 0x09, 0x22, /* Usage (22h), */
167 0x95, 0x1F, /* Report Count (31), */
168 0x91, 0x02, /* Output (Variable), */
169 0x85, 0x04, /* Report ID (4), */
170 0x09, 0x23, /* Usage (23h), */
171 0x95, 0x24, /* Report Count (36), */
172 0xB1, 0x02, /* Feature (Variable), */
173 0x85, 0x02, /* Report ID (2), */
174 0x09, 0x24, /* Usage (24h), */
175 0x95, 0x24, /* Report Count (36), */
176 0xB1, 0x02, /* Feature (Variable), */
177 0x85, 0x08, /* Report ID (8), */
178 0x09, 0x25, /* Usage (25h), */
179 0x95, 0x03, /* Report Count (3), */
180 0xB1, 0x02, /* Feature (Variable), */
181 0x85, 0x10, /* Report ID (16), */
182 0x09, 0x26, /* Usage (26h), */
183 0x95, 0x04, /* Report Count (4), */
184 0xB1, 0x02, /* Feature (Variable), */
185 0x85, 0x11, /* Report ID (17), */
186 0x09, 0x27, /* Usage (27h), */
187 0x95, 0x02, /* Report Count (2), */
188 0xB1, 0x02, /* Feature (Variable), */
189 0x85, 0x12, /* Report ID (18), */
190 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
191 0x09, 0x21, /* Usage (21h), */
192 0x95, 0x0F, /* Report Count (15), */
193 0xB1, 0x02, /* Feature (Variable), */
194 0x85, 0x13, /* Report ID (19), */
195 0x09, 0x22, /* Usage (22h), */
196 0x95, 0x16, /* Report Count (22), */
197 0xB1, 0x02, /* Feature (Variable), */
198 0x85, 0x14, /* Report ID (20), */
199 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
200 0x09, 0x20, /* Usage (20h), */
201 0x95, 0x10, /* Report Count (16), */
202 0xB1, 0x02, /* Feature (Variable), */
203 0x85, 0x15, /* Report ID (21), */
204 0x09, 0x21, /* Usage (21h), */
205 0x95, 0x2C, /* Report Count (44), */
206 0xB1, 0x02, /* Feature (Variable), */
207 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
208 0x85, 0x80, /* Report ID (128), */
209 0x09, 0x20, /* Usage (20h), */
210 0x95, 0x06, /* Report Count (6), */
211 0xB1, 0x02, /* Feature (Variable), */
212 0x85, 0x81, /* Report ID (129), */
213 0x09, 0x21, /* Usage (21h), */
214 0x95, 0x06, /* Report Count (6), */
215 0xB1, 0x02, /* Feature (Variable), */
216 0x85, 0x82, /* Report ID (130), */
217 0x09, 0x22, /* Usage (22h), */
218 0x95, 0x05, /* Report Count (5), */
219 0xB1, 0x02, /* Feature (Variable), */
220 0x85, 0x83, /* Report ID (131), */
221 0x09, 0x23, /* Usage (23h), */
222 0x95, 0x01, /* Report Count (1), */
223 0xB1, 0x02, /* Feature (Variable), */
224 0x85, 0x84, /* Report ID (132), */
225 0x09, 0x24, /* Usage (24h), */
226 0x95, 0x04, /* Report Count (4), */
227 0xB1, 0x02, /* Feature (Variable), */
228 0x85, 0x85, /* Report ID (133), */
229 0x09, 0x25, /* Usage (25h), */
230 0x95, 0x06, /* Report Count (6), */
231 0xB1, 0x02, /* Feature (Variable), */
232 0x85, 0x86, /* Report ID (134), */
233 0x09, 0x26, /* Usage (26h), */
234 0x95, 0x06, /* Report Count (6), */
235 0xB1, 0x02, /* Feature (Variable), */
236 0x85, 0x87, /* Report ID (135), */
237 0x09, 0x27, /* Usage (27h), */
238 0x95, 0x23, /* Report Count (35), */
239 0xB1, 0x02, /* Feature (Variable), */
240 0x85, 0x88, /* Report ID (136), */
241 0x09, 0x28, /* Usage (28h), */
242 0x95, 0x22, /* Report Count (34), */
243 0xB1, 0x02, /* Feature (Variable), */
244 0x85, 0x89, /* Report ID (137), */
245 0x09, 0x29, /* Usage (29h), */
246 0x95, 0x02, /* Report Count (2), */
247 0xB1, 0x02, /* Feature (Variable), */
248 0x85, 0x90, /* Report ID (144), */
249 0x09, 0x30, /* Usage (30h), */
250 0x95, 0x05, /* Report Count (5), */
251 0xB1, 0x02, /* Feature (Variable), */
252 0x85, 0x91, /* Report ID (145), */
253 0x09, 0x31, /* Usage (31h), */
254 0x95, 0x03, /* Report Count (3), */
255 0xB1, 0x02, /* Feature (Variable), */
256 0x85, 0x92, /* Report ID (146), */
257 0x09, 0x32, /* Usage (32h), */
258 0x95, 0x03, /* Report Count (3), */
259 0xB1, 0x02, /* Feature (Variable), */
260 0x85, 0x93, /* Report ID (147), */
261 0x09, 0x33, /* Usage (33h), */
262 0x95, 0x0C, /* Report Count (12), */
263 0xB1, 0x02, /* Feature (Variable), */
264 0x85, 0xA0, /* Report ID (160), */
265 0x09, 0x40, /* Usage (40h), */
266 0x95, 0x06, /* Report Count (6), */
267 0xB1, 0x02, /* Feature (Variable), */
268 0x85, 0xA1, /* Report ID (161), */
269 0x09, 0x41, /* Usage (41h), */
270 0x95, 0x01, /* Report Count (1), */
271 0xB1, 0x02, /* Feature (Variable), */
272 0x85, 0xA2, /* Report ID (162), */
273 0x09, 0x42, /* Usage (42h), */
274 0x95, 0x01, /* Report Count (1), */
275 0xB1, 0x02, /* Feature (Variable), */
276 0x85, 0xA3, /* Report ID (163), */
277 0x09, 0x43, /* Usage (43h), */
278 0x95, 0x30, /* Report Count (48), */
279 0xB1, 0x02, /* Feature (Variable), */
280 0x85, 0xA4, /* Report ID (164), */
281 0x09, 0x44, /* Usage (44h), */
282 0x95, 0x0D, /* Report Count (13), */
283 0xB1, 0x02, /* Feature (Variable), */
284 0x85, 0xA5, /* Report ID (165), */
285 0x09, 0x45, /* Usage (45h), */
286 0x95, 0x15, /* Report Count (21), */
287 0xB1, 0x02, /* Feature (Variable), */
288 0x85, 0xA6, /* Report ID (166), */
289 0x09, 0x46, /* Usage (46h), */
290 0x95, 0x15, /* Report Count (21), */
291 0xB1, 0x02, /* Feature (Variable), */
292 0x85, 0xF0, /* Report ID (240), */
293 0x09, 0x47, /* Usage (47h), */
294 0x95, 0x3F, /* Report Count (63), */
295 0xB1, 0x02, /* Feature (Variable), */
296 0x85, 0xF1, /* Report ID (241), */
297 0x09, 0x48, /* Usage (48h), */
298 0x95, 0x3F, /* Report Count (63), */
299 0xB1, 0x02, /* Feature (Variable), */
300 0x85, 0xF2, /* Report ID (242), */
301 0x09, 0x49, /* Usage (49h), */
302 0x95, 0x0F, /* Report Count (15), */
303 0xB1, 0x02, /* Feature (Variable), */
304 0x85, 0xA7, /* Report ID (167), */
305 0x09, 0x4A, /* Usage (4Ah), */
306 0x95, 0x01, /* Report Count (1), */
307 0xB1, 0x02, /* Feature (Variable), */
308 0x85, 0xA8, /* Report ID (168), */
309 0x09, 0x4B, /* Usage (4Bh), */
310 0x95, 0x01, /* Report Count (1), */
311 0xB1, 0x02, /* Feature (Variable), */
312 0x85, 0xA9, /* Report ID (169), */
313 0x09, 0x4C, /* Usage (4Ch), */
314 0x95, 0x08, /* Report Count (8), */
315 0xB1, 0x02, /* Feature (Variable), */
316 0x85, 0xAA, /* Report ID (170), */
317 0x09, 0x4E, /* Usage (4Eh), */
318 0x95, 0x01, /* Report Count (1), */
319 0xB1, 0x02, /* Feature (Variable), */
320 0x85, 0xAB, /* Report ID (171), */
321 0x09, 0x4F, /* Usage (4Fh), */
322 0x95, 0x39, /* Report Count (57), */
323 0xB1, 0x02, /* Feature (Variable), */
324 0x85, 0xAC, /* Report ID (172), */
325 0x09, 0x50, /* Usage (50h), */
326 0x95, 0x39, /* Report Count (57), */
327 0xB1, 0x02, /* Feature (Variable), */
328 0x85, 0xAD, /* Report ID (173), */
329 0x09, 0x51, /* Usage (51h), */
330 0x95, 0x0B, /* Report Count (11), */
331 0xB1, 0x02, /* Feature (Variable), */
332 0x85, 0xAE, /* Report ID (174), */
333 0x09, 0x52, /* Usage (52h), */
334 0x95, 0x01, /* Report Count (1), */
335 0xB1, 0x02, /* Feature (Variable), */
336 0x85, 0xAF, /* Report ID (175), */
337 0x09, 0x53, /* Usage (53h), */
338 0x95, 0x02, /* Report Count (2), */
339 0xB1, 0x02, /* Feature (Variable), */
340 0x85, 0xB0, /* Report ID (176), */
341 0x09, 0x54, /* Usage (54h), */
342 0x95, 0x3F, /* Report Count (63), */
343 0xB1, 0x02, /* Feature (Variable), */
344 0xC0 /* End Collection */
ed19d8cf
FP		 345};
346
ad142b9e
FP		 347/*
348 * The default behavior of the Dualshock 4 is to send reports using report
d829674d
FP		 349 * type 1 when running over Bluetooth. However, as soon as it receives a
350 * report of type 17 to set the LEDs or rumble it starts returning it's state
351 * in report 17 instead of 1. Since report 17 is undefined in the default HID
352 * descriptor the button and axis definitions must be moved to report 17 or
353 * the HID layer won't process the received input once a report is sent.
354 */
355static u8 dualshock4_bt_rdesc[] = {
356 0x05, 0x01, /* Usage Page (Desktop), */
357 0x09, 0x05, /* Usage (Gamepad), */
358 0xA1, 0x01, /* Collection (Application), */
359 0x85, 0x01, /* Report ID (1), */
360 0x75, 0x08, /* Report Size (8), */
361 0x95, 0x0A, /* Report Count (9), */
362 0x81, 0x02, /* Input (Variable), */
363 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
364 0x85, 0x02, /* Report ID (2), */
365 0x09, 0x24, /* Usage (24h), */
366 0x95, 0x24, /* Report Count (36), */
367 0xB1, 0x02, /* Feature (Variable), */
368 0x85, 0xA3, /* Report ID (163), */
369 0x09, 0x25, /* Usage (25h), */
370 0x95, 0x30, /* Report Count (48), */
371 0xB1, 0x02, /* Feature (Variable), */
372 0x85, 0x05, /* Report ID (5), */
373 0x09, 0x26, /* Usage (26h), */
374 0x95, 0x28, /* Report Count (40), */
375 0xB1, 0x02, /* Feature (Variable), */
376 0x85, 0x06, /* Report ID (6), */
377 0x09, 0x27, /* Usage (27h), */
378 0x95, 0x34, /* Report Count (52), */
379 0xB1, 0x02, /* Feature (Variable), */
380 0x85, 0x07, /* Report ID (7), */
381 0x09, 0x28, /* Usage (28h), */
382 0x95, 0x30, /* Report Count (48), */
383 0xB1, 0x02, /* Feature (Variable), */
384 0x85, 0x08, /* Report ID (8), */
385 0x09, 0x29, /* Usage (29h), */
386 0x95, 0x2F, /* Report Count (47), */
387 0xB1, 0x02, /* Feature (Variable), */
388 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
389 0x85, 0x03, /* Report ID (3), */
390 0x09, 0x21, /* Usage (21h), */
391 0x95, 0x26, /* Report Count (38), */
392 0xB1, 0x02, /* Feature (Variable), */
393 0x85, 0x04, /* Report ID (4), */
394 0x09, 0x22, /* Usage (22h), */
395 0x95, 0x2E, /* Report Count (46), */
396 0xB1, 0x02, /* Feature (Variable), */
397 0x85, 0xF0, /* Report ID (240), */
398 0x09, 0x47, /* Usage (47h), */
399 0x95, 0x3F, /* Report Count (63), */
400 0xB1, 0x02, /* Feature (Variable), */
401 0x85, 0xF1, /* Report ID (241), */
402 0x09, 0x48, /* Usage (48h), */
403 0x95, 0x3F, /* Report Count (63), */
404 0xB1, 0x02, /* Feature (Variable), */
405 0x85, 0xF2, /* Report ID (242), */
406 0x09, 0x49, /* Usage (49h), */
407 0x95, 0x0F, /* Report Count (15), */
408 0xB1, 0x02, /* Feature (Variable), */
409 0x85, 0x11, /* Report ID (17), */
410 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
411 0x09, 0x20, /* Usage (20h), */
412 0x95, 0x02, /* Report Count (2), */
413 0x81, 0x02, /* Input (Variable), */
414 0x05, 0x01, /* Usage Page (Desktop), */
415 0x09, 0x30, /* Usage (X), */
416 0x09, 0x31, /* Usage (Y), */
417 0x09, 0x32, /* Usage (Z), */
418 0x09, 0x35, /* Usage (Rz), */
419 0x15, 0x00, /* Logical Minimum (0), */
420 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
421 0x75, 0x08, /* Report Size (8), */
422 0x95, 0x04, /* Report Count (4), */
423 0x81, 0x02, /* Input (Variable), */
424 0x09, 0x39, /* Usage (Hat Switch), */
425 0x15, 0x00, /* Logical Minimum (0), */
426 0x25, 0x07, /* Logical Maximum (7), */
427 0x75, 0x04, /* Report Size (4), */
428 0x95, 0x01, /* Report Count (1), */
429 0x81, 0x42, /* Input (Variable, Null State), */
430 0x05, 0x09, /* Usage Page (Button), */
431 0x19, 0x01, /* Usage Minimum (01h), */
432 0x29, 0x0E, /* Usage Maximum (0Eh), */
433 0x15, 0x00, /* Logical Minimum (0), */
434 0x25, 0x01, /* Logical Maximum (1), */
435 0x75, 0x01, /* Report Size (1), */
436 0x95, 0x0E, /* Report Count (14), */
437 0x81, 0x02, /* Input (Variable), */
438 0x75, 0x06, /* Report Size (6), */
439 0x95, 0x01, /* Report Count (1), */
440 0x81, 0x01, /* Input (Constant), */
441 0x05, 0x01, /* Usage Page (Desktop), */
442 0x09, 0x33, /* Usage (Rx), */
443 0x09, 0x34, /* Usage (Ry), */
444 0x15, 0x00, /* Logical Minimum (0), */
445 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
446 0x75, 0x08, /* Report Size (8), */
447 0x95, 0x02, /* Report Count (2), */
448 0x81, 0x02, /* Input (Variable), */
449 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
450 0x09, 0x20, /* Usage (20h), */
451 0x95, 0x03, /* Report Count (3), */
452 0x81, 0x02, /* Input (Variable), */
453 0x05, 0x01, /* Usage Page (Desktop), */
454 0x19, 0x40, /* Usage Minimum (40h), */
455 0x29, 0x42, /* Usage Maximum (42h), */
456 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
457 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
458 0x75, 0x10, /* Report Size (16), */
459 0x95, 0x03, /* Report Count (3), */
460 0x81, 0x02, /* Input (Variable), */
461 0x19, 0x43, /* Usage Minimum (43h), */
462 0x29, 0x45, /* Usage Maximum (45h), */
463 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
464 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
465 0x95, 0x03, /* Report Count (3), */
466 0x81, 0x02, /* Input (Variable), */
467 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
468 0x09, 0x20, /* Usage (20h), */
469 0x15, 0x00, /* Logical Minimum (0), */
470 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
471 0x75, 0x08, /* Report Size (8), */
472 0x95, 0x31, /* Report Count (51), */
473 0x81, 0x02, /* Input (Variable), */
474 0x09, 0x21, /* Usage (21h), */
475 0x75, 0x08, /* Report Size (8), */
476 0x95, 0x4D, /* Report Count (77), */
477 0x91, 0x02, /* Output (Variable), */
478 0x85, 0x12, /* Report ID (18), */
479 0x09, 0x22, /* Usage (22h), */
480 0x95, 0x8D, /* Report Count (141), */
481 0x81, 0x02, /* Input (Variable), */
482 0x09, 0x23, /* Usage (23h), */
483 0x91, 0x02, /* Output (Variable), */
484 0x85, 0x13, /* Report ID (19), */
485 0x09, 0x24, /* Usage (24h), */
486 0x95, 0xCD, /* Report Count (205), */
487 0x81, 0x02, /* Input (Variable), */
488 0x09, 0x25, /* Usage (25h), */
489 0x91, 0x02, /* Output (Variable), */
490 0x85, 0x14, /* Report ID (20), */
491 0x09, 0x26, /* Usage (26h), */
492 0x96, 0x0D, 0x01, /* Report Count (269), */
493 0x81, 0x02, /* Input (Variable), */
494 0x09, 0x27, /* Usage (27h), */
495 0x91, 0x02, /* Output (Variable), */
496 0x85, 0x15, /* Report ID (21), */
497 0x09, 0x28, /* Usage (28h), */
498 0x96, 0x4D, 0x01, /* Report Count (333), */
499 0x81, 0x02, /* Input (Variable), */
500 0x09, 0x29, /* Usage (29h), */
501 0x91, 0x02, /* Output (Variable), */
502 0x85, 0x16, /* Report ID (22), */
503 0x09, 0x2A, /* Usage (2Ah), */
504 0x96, 0x8D, 0x01, /* Report Count (397), */
505 0x81, 0x02, /* Input (Variable), */
506 0x09, 0x2B, /* Usage (2Bh), */
507 0x91, 0x02, /* Output (Variable), */
508 0x85, 0x17, /* Report ID (23), */
509 0x09, 0x2C, /* Usage (2Ch), */
510 0x96, 0xCD, 0x01, /* Report Count (461), */
511 0x81, 0x02, /* Input (Variable), */
512 0x09, 0x2D, /* Usage (2Dh), */
513 0x91, 0x02, /* Output (Variable), */
514 0x85, 0x18, /* Report ID (24), */
515 0x09, 0x2E, /* Usage (2Eh), */
516 0x96, 0x0D, 0x02, /* Report Count (525), */
517 0x81, 0x02, /* Input (Variable), */
518 0x09, 0x2F, /* Usage (2Fh), */
519 0x91, 0x02, /* Output (Variable), */
520 0x85, 0x19, /* Report ID (25), */
521 0x09, 0x30, /* Usage (30h), */
522 0x96, 0x22, 0x02, /* Report Count (546), */
523 0x81, 0x02, /* Input (Variable), */
524 0x09, 0x31, /* Usage (31h), */
525 0x91, 0x02, /* Output (Variable), */
526 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
527 0x85, 0x82, /* Report ID (130), */
528 0x09, 0x22, /* Usage (22h), */
529 0x95, 0x3F, /* Report Count (63), */
530 0xB1, 0x02, /* Feature (Variable), */
531 0x85, 0x83, /* Report ID (131), */
532 0x09, 0x23, /* Usage (23h), */
533 0xB1, 0x02, /* Feature (Variable), */
534 0x85, 0x84, /* Report ID (132), */
535 0x09, 0x24, /* Usage (24h), */
536 0xB1, 0x02, /* Feature (Variable), */
537 0x85, 0x90, /* Report ID (144), */
538 0x09, 0x30, /* Usage (30h), */
539 0xB1, 0x02, /* Feature (Variable), */
540 0x85, 0x91, /* Report ID (145), */
541 0x09, 0x31, /* Usage (31h), */
542 0xB1, 0x02, /* Feature (Variable), */
543 0x85, 0x92, /* Report ID (146), */
544 0x09, 0x32, /* Usage (32h), */
545 0xB1, 0x02, /* Feature (Variable), */
546 0x85, 0x93, /* Report ID (147), */
547 0x09, 0x33, /* Usage (33h), */
548 0xB1, 0x02, /* Feature (Variable), */
549 0x85, 0xA0, /* Report ID (160), */
550 0x09, 0x40, /* Usage (40h), */
551 0xB1, 0x02, /* Feature (Variable), */
552 0x85, 0xA4, /* Report ID (164), */
553 0x09, 0x44, /* Usage (44h), */
554 0xB1, 0x02, /* Feature (Variable), */
555 0xC0 /* End Collection */
556};
557
078328da
JK		 558static __u8 ps3remote_rdesc[] = {
559 0x05, 0x01, /* GUsagePage Generic Desktop */
560 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
561 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
562
563 /* Use collection 1 for joypad buttons */
564 0xA1, 0x02, /* MCollection Logical (interrelated data) */
565
566 /* Ignore the 1st byte, maybe it is used for a controller
567 * number but it's not needed for correct operation */
568 0x75, 0x08, /* GReportSize 0x08 [8] */
569 0x95, 0x01, /* GReportCount 0x01 [1] */
570 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
571
572 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
573 * buttons multiple keypresses are allowed */
574 0x05, 0x09, /* GUsagePage Button */
575 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
576 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
577 0x14, /* GLogicalMinimum [0] */
578 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
579 0x75, 0x01, /* GReportSize 0x01 [1] */
580 0x95, 0x18, /* GReportCount 0x18 [24] */
581 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
582
583 0xC0, /* MEndCollection */
584
585 /* Use collection 2 for remote control buttons */
586 0xA1, 0x02, /* MCollection Logical (interrelated data) */
587
588 /* 5th byte is used for remote control buttons */
589 0x05, 0x09, /* GUsagePage Button */
590 0x18, /* LUsageMinimum [No button pressed] */
591 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
592 0x14, /* GLogicalMinimum [0] */
593 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
594 0x75, 0x08, /* GReportSize 0x08 [8] */
595 0x95, 0x01, /* GReportCount 0x01 [1] */
596 0x80, /* MInput */
597
598 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
599 * 0xff and 11th is for press indication */
600 0x75, 0x08, /* GReportSize 0x08 [8] */
601 0x95, 0x06, /* GReportCount 0x06 [6] */
602 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
603
604 /* 12th byte is for battery strength */
605 0x05, 0x06, /* GUsagePage Generic Device Controls */
606 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
607 0x14, /* GLogicalMinimum [0] */
608 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
609 0x75, 0x08, /* GReportSize 0x08 [8] */
610 0x95, 0x01, /* GReportCount 0x01 [1] */
611 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
612
613 0xC0, /* MEndCollection */
614
615 0xC0 /* MEndCollection [Game Pad] */
616};
617
618static const unsigned int ps3remote_keymap_joypad_buttons[] = {
619 [0x01] = KEY_SELECT,
620 [0x02] = BTN_THUMBL, /* L3 */
621 [0x03] = BTN_THUMBR, /* R3 */
622 [0x04] = BTN_START,
623 [0x05] = KEY_UP,
624 [0x06] = KEY_RIGHT,
625 [0x07] = KEY_DOWN,
626 [0x08] = KEY_LEFT,
627 [0x09] = BTN_TL2, /* L2 */
628 [0x0a] = BTN_TR2, /* R2 */
629 [0x0b] = BTN_TL, /* L1 */
630 [0x0c] = BTN_TR, /* R1 */
631 [0x0d] = KEY_OPTION, /* options/triangle */
632 [0x0e] = KEY_BACK, /* back/circle */
633 [0x0f] = BTN_0, /* cross */
634 [0x10] = KEY_SCREEN, /* view/square */
635 [0x11] = KEY_HOMEPAGE, /* PS button */
636 [0x14] = KEY_ENTER,
637};
638static const unsigned int ps3remote_keymap_remote_buttons[] = {
639 [0x00] = KEY_1,
640 [0x01] = KEY_2,
641 [0x02] = KEY_3,
642 [0x03] = KEY_4,
643 [0x04] = KEY_5,
644 [0x05] = KEY_6,
645 [0x06] = KEY_7,
646 [0x07] = KEY_8,
647 [0x08] = KEY_9,
648 [0x09] = KEY_0,
649 [0x0e] = KEY_ESC, /* return */
650 [0x0f] = KEY_CLEAR,
651 [0x16] = KEY_EJECTCD,
652 [0x1a] = KEY_MENU, /* top menu */
653 [0x28] = KEY_TIME,
654 [0x30] = KEY_PREVIOUS,
655 [0x31] = KEY_NEXT,
656 [0x32] = KEY_PLAY,
657 [0x33] = KEY_REWIND, /* scan back */
658 [0x34] = KEY_FORWARD, /* scan forward */
659 [0x38] = KEY_STOP,
660 [0x39] = KEY_PAUSE,
661 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
662 [0x60] = KEY_FRAMEBACK, /* slow/step back */
663 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
664 [0x63] = KEY_SUBTITLE,
665 [0x64] = KEY_AUDIO,
666 [0x65] = KEY_ANGLE,
667 [0x70] = KEY_INFO, /* display */
668 [0x80] = KEY_BLUE,
669 [0x81] = KEY_RED,
670 [0x82] = KEY_GREEN,
671 [0x83] = KEY_YELLOW,
672};
673
f04d5140 674static const unsigned int buzz_keymap[] = {
ad142b9e
FP		 675 /*
676 * The controller has 4 remote buzzers, each with one LED and 5
f04d5140
CL		 677 * buttons.
678 *
679 * We use the mapping chosen by the controller, which is:
680 *
681 * Key Offset
682 * -------------------
683 * Buzz 1
684 * Blue 5
685 * Orange 4
686 * Green 3
687 * Yellow 2
688 *
689 * So, for example, the orange button on the third buzzer is mapped to
690 * BTN_TRIGGER_HAPPY14
691 */
692 [ 1] = BTN_TRIGGER_HAPPY1,
693 [ 2] = BTN_TRIGGER_HAPPY2,
694 [ 3] = BTN_TRIGGER_HAPPY3,
695 [ 4] = BTN_TRIGGER_HAPPY4,
696 [ 5] = BTN_TRIGGER_HAPPY5,
697 [ 6] = BTN_TRIGGER_HAPPY6,
698 [ 7] = BTN_TRIGGER_HAPPY7,
699 [ 8] = BTN_TRIGGER_HAPPY8,
700 [ 9] = BTN_TRIGGER_HAPPY9,
701 [10] = BTN_TRIGGER_HAPPY10,
702 [11] = BTN_TRIGGER_HAPPY11,
703 [12] = BTN_TRIGGER_HAPPY12,
704 [13] = BTN_TRIGGER_HAPPY13,
705 [14] = BTN_TRIGGER_HAPPY14,
706 [15] = BTN_TRIGGER_HAPPY15,
707 [16] = BTN_TRIGGER_HAPPY16,
708 [17] = BTN_TRIGGER_HAPPY17,
709 [18] = BTN_TRIGGER_HAPPY18,
710 [19] = BTN_TRIGGER_HAPPY19,
711 [20] = BTN_TRIGGER_HAPPY20,
712};
713
d902f472
FP		 714static enum power_supply_property sony_battery_props[] = {
715 POWER_SUPPLY_PROP_PRESENT,
716 POWER_SUPPLY_PROP_CAPACITY,
717 POWER_SUPPLY_PROP_SCOPE,
718 POWER_SUPPLY_PROP_STATUS,
719};
720
55d3b664
FP		 721struct sixaxis_led {
722 __u8 time_enabled; /* the total time the led is active (0xff means forever) */
723 __u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
724 __u8 enabled;
725 __u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
726 __u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
727} __packed;
728
729struct sixaxis_rumble {
730 __u8 padding;
731 __u8 right_duration; /* Right motor duration (0xff means forever) */
732 __u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
733 __u8 left_duration; /* Left motor duration (0xff means forever) */
734 __u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
735} __packed;
736
737struct sixaxis_output_report {
738 __u8 report_id;
739 struct sixaxis_rumble rumble;
740 __u8 padding[4];
741 __u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
742 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
743 struct sixaxis_led _reserved; /* LED5, not actually soldered */
744} __packed;
745
746union sixaxis_output_report_01 {
747 struct sixaxis_output_report data;
748 __u8 buf[36];
749};
750
d2d782fc
FP		 751static spinlock_t sony_dev_list_lock;
752static LIST_HEAD(sony_device_list);
8025087a 753static DEFINE_IDA(sony_device_id_allocator);
d2d782fc 754
cc6e0bbb 755struct sony_sc {
d902f472 756 spinlock_t lock;
d2d782fc 757 struct list_head list_node;
0a286ef2 758 struct hid_device *hdev;
60781cf4 759 struct led_classdev *leds[MAX_LEDS];
cc6e0bbb 760 unsigned long quirks;
0a286ef2 761 struct work_struct state_worker;
d902f472 762 struct power_supply battery;
8025087a 763 int device_id;
f04d5140 764
9f323b68 765#ifdef CONFIG_SONY_FF
9f323b68
SE		 766 __u8 left;
767 __u8 right;
768#endif
769
d2d782fc 770 __u8 mac_address[6];
5f5750d2 771 __u8 worker_initialized;
d902f472
FP		 772 __u8 cable_state;
773 __u8 battery_charging;
774 __u8 battery_capacity;
60781cf4 775 __u8 led_state[MAX_LEDS];
b3ed458c
FP		 776 __u8 led_delay_on[MAX_LEDS];
777 __u8 led_delay_off[MAX_LEDS];
60781cf4 778 __u8 led_count;
cc6e0bbb
JK		 779};
780
078328da
JK		 781static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
782 unsigned int *rsize)
783{
784 *rsize = sizeof(ps3remote_rdesc);
785 return ps3remote_rdesc;
786}
787
788static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
789 struct hid_field *field, struct hid_usage *usage,
790 unsigned long **bit, int *max)
791{
792 unsigned int key = usage->hid & HID_USAGE;
793
794 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
795 return -1;
796
797 switch (usage->collection_index) {
798 case 1:
799 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
800 return -1;
801
802 key = ps3remote_keymap_joypad_buttons[key];
803 if (!key)
804 return -1;
805 break;
806 case 2:
807 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
808 return -1;
809
810 key = ps3remote_keymap_remote_buttons[key];
811 if (!key)
812 return -1;
813 break;
814 default:
815 return -1;
816 }
817
818 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
819 return 1;
820}
821
822
cc6e0bbb 823/* Sony Vaio VGX has wrongly mouse pointer declared as constant */
73e4008d
NK		 824static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
825 unsigned int *rsize)
cc6e0bbb
JK		 826{
827 struct sony_sc *sc = hid_get_drvdata(hdev);
828
99d24902
FLVC		 829 /*
830 * Some Sony RF receivers wrongly declare the mouse pointer as a
831 * a constant non-data variable.
832 */
833 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
834 /* usage page: generic desktop controls */
835 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
836 /* usage: mouse */
837 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
838 /* input (usage page for x,y axes): constant, variable, relative */
839 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
a4649184 840 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 841 /* input: data, variable, relative */
cc6e0bbb
JK		 842 rdesc[55] = 0x06;
843 }
61ab44be 844
ed19d8cf
FP		 845 /*
846 * The default Dualshock 4 USB descriptor doesn't assign
847 * the gyroscope values to corresponding axes so we need a
848 * modified one.
849 */
850 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
851 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
852 rdesc = dualshock4_usb_rdesc;
853 *rsize = sizeof(dualshock4_usb_rdesc);
d829674d
FP		 854 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
855 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
856 rdesc = dualshock4_bt_rdesc;
857 *rsize = sizeof(dualshock4_bt_rdesc);
ed19d8cf
FP		 858 }
859
61ab44be
SW		 860 /* The HID descriptor exposed over BT has a trailing zero byte */
861 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
862 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
863 rdesc[83] == 0x75) {
864 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
865 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
866 sizeof(sixaxis_rdesc_fixup));
e57a67da
MCC		 867 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
868 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
869 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
870 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
871 *rsize = sizeof(sixaxis_rdesc_fixup2);
872 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
61ab44be 873 }
078328da
JK		 874
875 if (sc->quirks & PS3REMOTE)
876 return ps3remote_fixup(hdev, rdesc, rsize);
877
73e4008d 878 return rdesc;
cc6e0bbb
JK		 879}
880
d902f472
FP		 881static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
882{
883 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
884 unsigned long flags;
885 __u8 cable_state, battery_capacity, battery_charging;
886
ad142b9e
FP		 887 /*
888 * The sixaxis is charging if the battery value is 0xee
d902f472
FP		 889 * and it is fully charged if the value is 0xef.
890 * It does not report the actual level while charging so it
891 * is set to 100% while charging is in progress.
892 */
893 if (rd[30] >= 0xee) {
894 battery_capacity = 100;
a43e94a3 895 battery_charging = !(rd[30] & 0x01);
d902f472 896 } else {
ac3c9a94
FP		 897 __u8 index = rd[30] <= 5 ? rd[30] : 5;
898 battery_capacity = sixaxis_battery_capacity[index];
d902f472
FP		 899 battery_charging = 0;
900 }
914c5783 901 cable_state = !(rd[31] & 0x04);
d902f472
FP		 902
903 spin_lock_irqsave(&sc->lock, flags);
904 sc->cable_state = cable_state;
905 sc->battery_capacity = battery_capacity;
906 sc->battery_charging = battery_charging;
907 spin_unlock_irqrestore(&sc->lock, flags);
908}
909
910static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
911{
e5606230
FP		 912 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
913 struct hid_input, list);
914 struct input_dev *input_dev = hidinput->input;
d902f472 915 unsigned long flags;
6c5f860d 916 int n, offset;
d902f472
FP		 917 __u8 cable_state, battery_capacity, battery_charging;
918
ad142b9e
FP		 919 /*
920 * Battery and touchpad data starts at byte 30 in the USB report and
6c5f860d
FP		 921 * 32 in Bluetooth report.
922 */
923 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
924
ad142b9e
FP		 925 /*
926 * The lower 4 bits of byte 30 contain the battery level
d902f472
FP		 927 * and the 5th bit contains the USB cable state.
928 */
6c5f860d
FP		 929 cable_state = (rd[offset] >> 4) & 0x01;
930 battery_capacity = rd[offset] & 0x0F;
d902f472 931
ad142b9e
FP		 932 /*
933 * When a USB power source is connected the battery level ranges from
6c5f860d
FP		 934 * 0 to 10, and when running on battery power it ranges from 0 to 9.
935 * A battery level above 10 when plugged in means charge completed.
d902f472 936 */
6c5f860d 937 if (!cable_state || battery_capacity > 10)
d902f472
FP		 938 battery_charging = 0;
939 else
940 battery_charging = 1;
941
6c5f860d
FP		 942 if (!cable_state)
943 battery_capacity++;
d902f472 944 if (battery_capacity > 10)
6c5f860d
FP		 945 battery_capacity = 10;
946
d902f472
FP		 947 battery_capacity *= 10;
948
949 spin_lock_irqsave(&sc->lock, flags);
950 sc->cable_state = cable_state;
951 sc->battery_capacity = battery_capacity;
952 sc->battery_charging = battery_charging;
953 spin_unlock_irqrestore(&sc->lock, flags);
e5606230 954
6c5f860d
FP		 955 offset += 5;
956
ad142b9e
FP		 957 /*
958 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
6c5f860d 959 * and 37 on Bluetooth.
e5606230
FP		 960 * The first 7 bits of the first byte is a counter and bit 8 is a touch
961 * indicator that is 0 when pressed and 1 when not pressed.
962 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
963 * The data for the second touch is in the same format and immediatly
964 * follows the data for the first.
965 */
966 for (n = 0; n < 2; n++) {
967 __u16 x, y;
968
969 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
970 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
971
972 input_mt_slot(input_dev, n);
973 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
974 !(rd[offset] >> 7));
975 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
976 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
977
978 offset += 4;
979 }
d902f472
FP		 980}
981
c9e4d877
SW		 982static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
983 __u8 *rd, int size)
984{
985 struct sony_sc *sc = hid_get_drvdata(hdev);
986
ad142b9e
FP		 987 /*
988 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
c9e4d877
SW		 989 * has to be BYTE_SWAPPED before passing up to joystick interface
990 */
fee4e2d5 991 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
c9e4d877
SW		 992 swap(rd[41], rd[42]);
993 swap(rd[43], rd[44]);
994 swap(rd[45], rd[46]);
995 swap(rd[47], rd[48]);
d902f472
FP		 996
997 sixaxis_parse_report(sc, rd, size);
68330d83
FP		 998 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
999 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1000 && rd[0] == 0x11 && size == 78)) {
d902f472 1001 dualshock4_parse_report(sc, rd, size);
c9e4d877
SW		 1002 }
1003
1004 return 0;
1005}
1006
f04d5140
CL		 1007static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1008 struct hid_field *field, struct hid_usage *usage,
1009 unsigned long **bit, int *max)
1010{
1011 struct sony_sc *sc = hid_get_drvdata(hdev);
1012
1013 if (sc->quirks & BUZZ_CONTROLLER) {
1014 unsigned int key = usage->hid & HID_USAGE;
1015
1016 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1017 return -1;
1018
1019 switch (usage->collection_index) {
1020 case 1:
1021 if (key >= ARRAY_SIZE(buzz_keymap))
1022 return -1;
1023
1024 key = buzz_keymap[key];
1025 if (!key)
1026 return -1;
1027 break;
1028 default:
1029 return -1;
1030 }
1031
1032 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1033 return 1;
1034 }
1035
078328da
JK		 1036 if (sc->quirks & PS3REMOTE)
1037 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1038
6f498018
BT		 1039 /* Let hid-core decide for the others */
1040 return 0;
f04d5140
CL		 1041}
1042
bd28ce00
JS		 1043/*
1044 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1045 * to "operational". Without this, the ps3 controller will not report any
1046 * events.
1047 */
816651a7 1048static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 1049{
bd28ce00
JS		 1050 int ret;
1051 char *buf = kmalloc(18, GFP_KERNEL);
1052
1053 if (!buf)
1054 return -ENOMEM;
1055
cafebc05
BT		 1056 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1057 HID_REQ_GET_REPORT);
f204828a 1058
bd28ce00 1059 if (ret < 0)
4291ee30 1060 hid_err(hdev, "can't set operational mode\n");
bd28ce00
JS		 1061
1062 kfree(buf);
1063
1064 return ret;
1065}
1066
816651a7 1067static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 1068{
fddb33f2 1069 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
b0dd72aa
BT		 1070 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
1071 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
f9ce7c28
BN		 1072}
1073
ad142b9e
FP		 1074/*
1075 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
68330d83
FP		 1076 * controller so that it sends full input reports of type 0x11.
1077 */
1078static int dualshock4_set_operational_bt(struct hid_device *hdev)
1079{
1080 __u8 buf[37] = { 0 };
1081
1082 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf),
1083 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
f9ce7c28
BN		 1084}
1085
8025087a
FP		 1086static void sixaxis_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1087{
1088 static const __u8 sixaxis_leds[10][4] = {
1089 { 0x01, 0x00, 0x00, 0x00 },
1090 { 0x00, 0x01, 0x00, 0x00 },
1091 { 0x00, 0x00, 0x01, 0x00 },
1092 { 0x00, 0x00, 0x00, 0x01 },
1093 { 0x01, 0x00, 0x00, 0x01 },
1094 { 0x00, 0x01, 0x00, 0x01 },
1095 { 0x00, 0x00, 0x01, 0x01 },
1096 { 0x01, 0x00, 0x01, 0x01 },
1097 { 0x00, 0x01, 0x01, 0x01 },
1098 { 0x01, 0x01, 0x01, 0x01 }
1099 };
1100
1101 BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1102
1103 if (id < 0)
1104 return;
1105
1106 id %= 10;
1107 memcpy(values, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1108}
1109
1110static void dualshock4_set_leds_from_id(int id, __u8 values[MAX_LEDS])
1111{
1112 /* The first 4 color/index entries match what the PS4 assigns */
1113 static const __u8 color_code[7][3] = {
1114 /* Blue */ { 0x00, 0x00, 0x01 },
1115 /* Red */ { 0x01, 0x00, 0x00 },
1116 /* Green */ { 0x00, 0x01, 0x00 },
1117 /* Pink */ { 0x02, 0x00, 0x01 },
1118 /* Orange */ { 0x02, 0x01, 0x00 },
1119 /* Teal */ { 0x00, 0x01, 0x01 },
1120 /* White */ { 0x01, 0x01, 0x01 }
1121 };
1122
1123 BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1124
1125 if (id < 0)
1126 return;
1127
1128 id %= 7;
1129 memcpy(values, color_code[id], sizeof(color_code[id]));
1130}
1131
60781cf4 1132static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
f04d5140
CL		 1133{
1134 struct list_head *report_list =
1135 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1136 struct hid_report *report = list_entry(report_list->next,
1137 struct hid_report, list);
1138 __s32 *value = report->field[0]->value;
1139
1140 value[0] = 0x00;
60781cf4
FP		 1141 value[1] = leds[0] ? 0xff : 0x00;
1142 value[2] = leds[1] ? 0xff : 0x00;
1143 value[3] = leds[2] ? 0xff : 0x00;
1144 value[4] = leds[3] ? 0xff : 0x00;
f04d5140
CL		 1145 value[5] = 0x00;
1146 value[6] = 0x00;
1147 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1148}
1149
fa57a810 1150static void sony_set_leds(struct sony_sc *sc, const __u8 *leds, int count)
0a286ef2 1151{
60781cf4 1152 int n;
0a286ef2 1153
60781cf4
FP		 1154 BUG_ON(count > MAX_LEDS);
1155
fa57a810
FP		 1156 if (sc->quirks & BUZZ_CONTROLLER && count == 4) {
1157 buzz_set_leds(sc->hdev, leds);
fee4e2d5 1158 } else {
60781cf4 1159 for (n = 0; n < count; n++)
fa57a810
FP		 1160 sc->led_state[n] = leds[n];
1161 schedule_work(&sc->state_worker);
0a286ef2
SE		 1162 }
1163}
1164
c5382519 1165static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 1166 enum led_brightness value)
1167{
1168 struct device *dev = led->dev->parent;
1169 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1170 struct sony_sc *drv_data;
f04d5140
CL		 1171
1172 int n;
b3ed458c 1173 int force_update;
f04d5140
CL		 1174
1175 drv_data = hid_get_drvdata(hdev);
2251b85f 1176 if (!drv_data) {
f04d5140
CL		 1177 hid_err(hdev, "No device data\n");
1178 return;
1179 }
f04d5140 1180
b3ed458c
FP		 1181 /*
1182 * The Sixaxis on USB will override any LED settings sent to it
1183 * and keep flashing all of the LEDs until the PS button is pressed.
1184 * Updates, even if redundant, must be always be sent to the
1185 * controller to avoid having to toggle the state of an LED just to
1186 * stop the flashing later on.
1187 */
1188 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1189
60781cf4 1190 for (n = 0; n < drv_data->led_count; n++) {
b3ed458c
FP		 1191 if (led == drv_data->leds[n] && (force_update ||
1192 (value != drv_data->led_state[n] ||
1193 drv_data->led_delay_on[n] ||
1194 drv_data->led_delay_off[n]))) {
1195
1196 drv_data->led_state[n] = value;
1197
1198 /* Setting the brightness stops the blinking */
1199 drv_data->led_delay_on[n] = 0;
1200 drv_data->led_delay_off[n] = 0;
1201
1202 sony_set_leds(drv_data, drv_data->led_state,
1203 drv_data->led_count);
f04d5140
CL		 1204 break;
1205 }
1206 }
1207}
1208
c5382519 1209static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 1210{
1211 struct device *dev = led->dev->parent;
1212 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1213 struct sony_sc *drv_data;
f04d5140
CL		 1214
1215 int n;
f04d5140
CL		 1216
1217 drv_data = hid_get_drvdata(hdev);
2251b85f 1218 if (!drv_data) {
f04d5140
CL		 1219 hid_err(hdev, "No device data\n");
1220 return LED_OFF;
1221 }
f04d5140 1222
60781cf4 1223 for (n = 0; n < drv_data->led_count; n++) {
7db7504a
SW		 1224 if (led == drv_data->leds[n])
1225 return drv_data->led_state[n];
f04d5140
CL		 1226 }
1227
7db7504a 1228 return LED_OFF;
f04d5140 1229}
f04d5140 1230
b3ed458c
FP		 1231static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1232 unsigned long *delay_off)
1233{
1234 struct device *dev = led->dev->parent;
1235 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1236 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1237 int n;
1238 __u8 new_on, new_off;
1239
1240 if (!drv_data) {
1241 hid_err(hdev, "No device data\n");
1242 return -EINVAL;
1243 }
1244
1245 /* Max delay is 255 deciseconds or 2550 milliseconds */
1246 if (*delay_on > 2550)
1247 *delay_on = 2550;
1248 if (*delay_off > 2550)
1249 *delay_off = 2550;
1250
1251 /* Blink at 1 Hz if both values are zero */
1252 if (!*delay_on && !*delay_off)
1253 *delay_on = *delay_off = 500;
1254
1255 new_on = *delay_on / 10;
1256 new_off = *delay_off / 10;
1257
1258 for (n = 0; n < drv_data->led_count; n++) {
1259 if (led == drv_data->leds[n])
1260 break;
1261 }
1262
1263 /* This LED is not registered on this device */
1264 if (n >= drv_data->led_count)
1265 return -EINVAL;
1266
1267 /* Don't schedule work if the values didn't change */
1268 if (new_on != drv_data->led_delay_on[n] ||
1269 new_off != drv_data->led_delay_off[n]) {
1270 drv_data->led_delay_on[n] = new_on;
1271 drv_data->led_delay_off[n] = new_off;
1272 schedule_work(&drv_data->state_worker);
1273 }
1274
1275 return 0;
1276}
1277
fa57a810 1278static void sony_leds_remove(struct sony_sc *sc)
0a286ef2 1279{
0a286ef2
SE		 1280 struct led_classdev *led;
1281 int n;
1282
fa57a810 1283 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1284
fa57a810
FP		 1285 for (n = 0; n < sc->led_count; n++) {
1286 led = sc->leds[n];
1287 sc->leds[n] = NULL;
0a286ef2
SE		 1288 if (!led)
1289 continue;
1290 led_classdev_unregister(led);
1291 kfree(led);
1292 }
60781cf4 1293
fa57a810 1294 sc->led_count = 0;
0a286ef2
SE		 1295}
1296
fa57a810 1297static int sony_leds_init(struct sony_sc *sc)
f04d5140 1298{
fa57a810 1299 struct hid_device *hdev = sc->hdev;
40e32ee6 1300 int n, ret = 0;
b3ed458c 1301 int use_ds4_names;
40e32ee6
JK		 1302 struct led_classdev *led;
1303 size_t name_sz;
1304 char *name;
0a286ef2
SE		 1305 size_t name_len;
1306 const char *name_fmt;
b3ed458c
FP		 1307 static const char * const ds4_name_str[] = { "red", "green", "blue",
1308 "global" };
8025087a 1309 __u8 initial_values[MAX_LEDS] = { 0 };
b3ed458c
FP		 1310 __u8 max_brightness[MAX_LEDS] = { 1 };
1311 __u8 use_hw_blink[MAX_LEDS] = { 0 };
f04d5140 1312
fa57a810 1313 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1314
fa57a810
FP		 1315 if (sc->quirks & BUZZ_CONTROLLER) {
1316 sc->led_count = 4;
b3ed458c 1317 use_ds4_names = 0;
0a286ef2
SE		 1318 name_len = strlen("::buzz#");
1319 name_fmt = "%s::buzz%d";
1320 /* Validate expected report characteristics. */
1321 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1322 return -ENODEV;
fa57a810 1323 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
8025087a 1324 dualshock4_set_leds_from_id(sc->device_id, initial_values);
b3ed458c
FP		 1325 initial_values[3] = 1;
1326 sc->led_count = 4;
1327 memset(max_brightness, 255, 3);
1328 use_hw_blink[3] = 1;
1329 use_ds4_names = 1;
61ebca93
FP		 1330 name_len = 0;
1331 name_fmt = "%s:%s";
60781cf4 1332 } else {
8025087a 1333 sixaxis_set_leds_from_id(sc->device_id, initial_values);
fa57a810 1334 sc->led_count = 4;
b3ed458c
FP		 1335 memset(use_hw_blink, 1, 4);
1336 use_ds4_names = 0;
61ebca93
FP		 1337 name_len = strlen("::sony#");
1338 name_fmt = "%s::sony%d";
60781cf4
FP		 1339 }
1340
ad142b9e
FP		 1341 /*
1342 * Clear LEDs as we have no way of reading their initial state. This is
f04d5140 1343 * only relevant if the driver is loaded after somebody actively set the
ad142b9e
FP		 1344 * LEDs to on
1345 */
fa57a810 1346 sony_set_leds(sc, initial_values, sc->led_count);
f04d5140 1347
0a286ef2 1348 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 1349
fa57a810 1350 for (n = 0; n < sc->led_count; n++) {
61ebca93 1351
b3ed458c
FP		 1352 if (use_ds4_names)
1353 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
61ebca93 1354
40e32ee6
JK		 1355 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1356 if (!led) {
1357 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
8cd5fcda 1358 ret = -ENOMEM;
40e32ee6
JK		 1359 goto error_leds;
1360 }
f04d5140 1361
40e32ee6 1362 name = (void *)(&led[1]);
b3ed458c
FP		 1363 if (use_ds4_names)
1364 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1365 ds4_name_str[n]);
61ebca93
FP		 1366 else
1367 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6 1368 led->name = name;
8025087a 1369 led->brightness = initial_values[n];
b3ed458c 1370 led->max_brightness = max_brightness[n];
c5382519
SE		 1371 led->brightness_get = sony_led_get_brightness;
1372 led->brightness_set = sony_led_set_brightness;
f04d5140 1373
b3ed458c
FP		 1374 if (use_hw_blink[n])
1375 led->blink_set = sony_led_blink_set;
1376
8025087a
FP		 1377 sc->leds[n] = led;
1378
8cd5fcda
JL		 1379 ret = led_classdev_register(&hdev->dev, led);
1380 if (ret) {
40e32ee6 1381 hid_err(hdev, "Failed to register LED %d\n", n);
8025087a 1382 sc->leds[n] = NULL;
40e32ee6
JK		 1383 kfree(led);
1384 goto error_leds;
f04d5140
CL		 1385 }
1386 }
f04d5140
CL		 1387
1388 return ret;
1389
f04d5140 1390error_leds:
fa57a810 1391 sony_leds_remove(sc);
f04d5140 1392
f04d5140 1393 return ret;
f04d5140
CL		 1394}
1395
cad665a2 1396static void sixaxis_state_worker(struct work_struct *work)
a08c22c0 1397{
92b5c411 1398 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
b3ed458c 1399 int n;
55d3b664
FP		 1400 union sixaxis_output_report_01 report = {
1401 .buf = {
1402 0x01,
1403 0x00, 0xff, 0x00, 0xff, 0x00,
1404 0x00, 0x00, 0x00, 0x00, 0x00,
1405 0xff, 0x27, 0x10, 0x00, 0x32,
1406 0xff, 0x27, 0x10, 0x00, 0x32,
1407 0xff, 0x27, 0x10, 0x00, 0x32,
1408 0xff, 0x27, 0x10, 0x00, 0x32,
1409 0x00, 0x00, 0x00, 0x00, 0x00
1410 }
a08c22c0 1411 };
9f323b68 1412
0a286ef2 1413#ifdef CONFIG_SONY_FF
55d3b664
FP		 1414 report.data.rumble.right_motor_on = sc->right ? 1 : 0;
1415 report.data.rumble.left_motor_force = sc->left;
0a286ef2
SE		 1416#endif
1417
55d3b664
FP		 1418 report.data.leds_bitmap |= sc->led_state[0] << 1;
1419 report.data.leds_bitmap |= sc->led_state[1] << 2;
1420 report.data.leds_bitmap |= sc->led_state[2] << 3;
1421 report.data.leds_bitmap |= sc->led_state[3] << 4;
9f323b68 1422
88f6576f
SW		 1423 /* Set flag for all leds off, required for 3rd party INTEC controller */
1424 if ((report.data.leds_bitmap & 0x1E) == 0)
1425 report.data.leds_bitmap |= 0x20;
1426
b3ed458c
FP		 1427 /*
1428 * The LEDs in the report are indexed in reverse order to their
1429 * corresponding light on the controller.
1430 * Index 0 = LED 4, index 1 = LED 3, etc...
1431 *
1432 * In the case of both delay values being zero (blinking disabled) the
1433 * default report values should be used or the controller LED will be
1434 * always off.
1435 */
1436 for (n = 0; n < 4; n++) {
1437 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
1438 report.data.led[3 - n].duty_off = sc->led_delay_off[n];
1439 report.data.led[3 - n].duty_on = sc->led_delay_on[n];
1440 }
1441 }
1442
55d3b664
FP		 1443 hid_hw_raw_request(sc->hdev, report.data.report_id, report.buf,
1444 sizeof(report), HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
9f323b68
SE		 1445}
1446
0bd88dd3
FP		 1447static void dualshock4_state_worker(struct work_struct *work)
1448{
1449 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
0da8ea65 1450 struct hid_device *hdev = sc->hdev;
48220237
FP		 1451 int offset;
1452
fdcf105d 1453 __u8 buf[78] = { 0 };
0da8ea65 1454
fdcf105d
FP		 1455 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1456 buf[0] = 0x05;
b3ed458c 1457 buf[1] = 0xFF;
fdcf105d
FP		 1458 offset = 4;
1459 } else {
1460 buf[0] = 0x11;
1461 buf[1] = 0xB0;
1462 buf[3] = 0x0F;
1463 offset = 6;
1464 }
0bd88dd3
FP		 1465
1466#ifdef CONFIG_SONY_FF
48220237
FP		 1467 buf[offset++] = sc->right;
1468 buf[offset++] = sc->left;
1469#else
1470 offset += 2;
0bd88dd3
FP		 1471#endif
1472
b3ed458c
FP		 1473 /* LED 3 is the global control */
1474 if (sc->led_state[3]) {
1475 buf[offset++] = sc->led_state[0];
1476 buf[offset++] = sc->led_state[1];
1477 buf[offset++] = sc->led_state[2];
1478 } else {
1479 offset += 3;
1480 }
1481
1482 /* If both delay values are zero the DualShock 4 disables blinking. */
1483 buf[offset++] = sc->led_delay_on[3];
1484 buf[offset++] = sc->led_delay_off[3];
60781cf4 1485
fdcf105d
FP		 1486 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1487 hid_hw_output_report(hdev, buf, 32);
1488 else
1489 hid_hw_raw_request(hdev, 0x11, buf, 78,
1490 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
0bd88dd3
FP		 1491}
1492
0a286ef2 1493#ifdef CONFIG_SONY_FF
9f323b68
SE		 1494static int sony_play_effect(struct input_dev *dev, void *data,
1495 struct ff_effect *effect)
1496{
a08c22c0 1497 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 1498 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 1499
1500 if (effect->type != FF_RUMBLE)
1501 return 0;
1502
9f323b68 1503 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 1504 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 1505
92b5c411 1506 schedule_work(&sc->state_worker);
9f323b68 1507 return 0;
a08c22c0
SE		 1508}
1509
fa57a810 1510static int sony_init_ff(struct sony_sc *sc)
a08c22c0 1511{
fa57a810 1512 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
a08c22c0
SE		 1513 struct hid_input, list);
1514 struct input_dev *input_dev = hidinput->input;
1515
1516 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1517 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1518}
1519
1520#else
fa57a810 1521static int sony_init_ff(struct sony_sc *sc)
a08c22c0
SE		 1522{
1523 return 0;
1524}
9f323b68 1525
a08c22c0
SE		 1526#endif
1527
d902f472
FP		 1528static int sony_battery_get_property(struct power_supply *psy,
1529 enum power_supply_property psp,
1530 union power_supply_propval *val)
1531{
1532 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1533 unsigned long flags;
1534 int ret = 0;
1535 u8 battery_charging, battery_capacity, cable_state;
1536
1537 spin_lock_irqsave(&sc->lock, flags);
1538 battery_charging = sc->battery_charging;
1539 battery_capacity = sc->battery_capacity;
1540 cable_state = sc->cable_state;
1541 spin_unlock_irqrestore(&sc->lock, flags);
1542
1543 switch (psp) {
1544 case POWER_SUPPLY_PROP_PRESENT:
1545 val->intval = 1;
1546 break;
1547 case POWER_SUPPLY_PROP_SCOPE:
1548 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1549 break;
1550 case POWER_SUPPLY_PROP_CAPACITY:
1551 val->intval = battery_capacity;
1552 break;
1553 case POWER_SUPPLY_PROP_STATUS:
1554 if (battery_charging)
1555 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1556 else
1557 if (battery_capacity == 100 && cable_state)
1558 val->intval = POWER_SUPPLY_STATUS_FULL;
1559 else
1560 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1561 break;
1562 default:
1563 ret = -EINVAL;
1564 break;
1565 }
1566 return ret;
9f323b68
SE		 1567}
1568
d902f472 1569static int sony_battery_probe(struct sony_sc *sc)
c4e1ddf2 1570{
c4e1ddf2 1571 struct hid_device *hdev = sc->hdev;
d902f472 1572 int ret;
c4e1ddf2 1573
ad142b9e
FP		 1574 /*
1575 * Set the default battery level to 100% to avoid low battery warnings
d9a293a9
FP		 1576 * if the battery is polled before the first device report is received.
1577 */
1578 sc->battery_capacity = 100;
1579
d902f472
FP		 1580 sc->battery.properties = sony_battery_props;
1581 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1582 sc->battery.get_property = sony_battery_get_property;
1583 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1584 sc->battery.use_for_apm = 0;
314531f1
FP		 1585 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%pMR",
1586 sc->mac_address);
d902f472
FP		 1587 if (!sc->battery.name)
1588 return -ENOMEM;
c4e1ddf2 1589
d902f472
FP		 1590 ret = power_supply_register(&hdev->dev, &sc->battery);
1591 if (ret) {
1592 hid_err(hdev, "Unable to register battery device\n");
1593 goto err_free;
1594 }
c4e1ddf2 1595
d902f472 1596 power_supply_powers(&sc->battery, &hdev->dev);
a08c22c0 1597 return 0;
d902f472
FP		 1598
1599err_free:
1600 kfree(sc->battery.name);
1601 sc->battery.name = NULL;
1602 return ret;
a08c22c0 1603}
9f323b68 1604
d902f472 1605static void sony_battery_remove(struct sony_sc *sc)
9f323b68 1606{
d902f472
FP		 1607 if (!sc->battery.name)
1608 return;
1609
1610 power_supply_unregister(&sc->battery);
1611 kfree(sc->battery.name);
1612 sc->battery.name = NULL;
9f323b68 1613}
a08c22c0 1614
e5606230
FP		 1615static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1616 int w, int h)
c4e1ddf2 1617{
e5606230
FP		 1618 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1619 struct hid_input, list);
1620 struct input_dev *input_dev = hidinput->input;
1621 int ret;
1622
1623 ret = input_mt_init_slots(input_dev, touch_count, 0);
1624 if (ret < 0) {
1625 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1626 return ret;
1627 }
c4e1ddf2 1628
e5606230
FP		 1629 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1630 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
c4e1ddf2 1631
e5606230
FP		 1632 return 0;
1633}
c4e1ddf2 1634
d2d782fc
FP		 1635/*
1636 * If a controller is plugged in via USB while already connected via Bluetooth
1637 * it will show up as two devices. A global list of connected controllers and
1638 * their MAC addresses is maintained to ensure that a device is only connected
1639 * once.
1640 */
1641static int sony_check_add_dev_list(struct sony_sc *sc)
1642{
1643 struct sony_sc *entry;
1644 unsigned long flags;
1645 int ret;
1646
1647 spin_lock_irqsave(&sony_dev_list_lock, flags);
1648
1649 list_for_each_entry(entry, &sony_device_list, list_node) {
1650 ret = memcmp(sc->mac_address, entry->mac_address,
1651 sizeof(sc->mac_address));
1652 if (!ret) {
1653 ret = -EEXIST;
1654 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1655 sc->mac_address);
1656 goto unlock;
c4e1ddf2
FP		 1657 }
1658 }
1659
d2d782fc
FP		 1660 ret = 0;
1661 list_add(&(sc->list_node), &sony_device_list);
c4e1ddf2 1662
d2d782fc
FP		 1663unlock:
1664 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1665 return ret;
1666}
1667
1668static void sony_remove_dev_list(struct sony_sc *sc)
1669{
1670 unsigned long flags;
c4e1ddf2 1671
d2d782fc
FP		 1672 if (sc->list_node.next) {
1673 spin_lock_irqsave(&sony_dev_list_lock, flags);
1674 list_del(&(sc->list_node));
1675 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1676 }
c4e1ddf2
FP		 1677}
1678
d2d782fc
FP		 1679static int sony_get_bt_devaddr(struct sony_sc *sc)
1680{
1681 int ret;
1682
1683 /* HIDP stores the device MAC address as a string in the uniq field. */
1684 ret = strlen(sc->hdev->uniq);
1685 if (ret != 17)
1686 return -EINVAL;
1687
1688 ret = sscanf(sc->hdev->uniq,
1689 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1690 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1691 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1692
1693 if (ret != 6)
1694 return -EINVAL;
1695
1696 return 0;
1697}
1698
1699static int sony_check_add(struct sony_sc *sc)
1700{
1701 int n, ret;
1702
1703 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1704 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1705 /*
1706 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1707 * address from the uniq string where HIDP stores it.
1708 * As uniq cannot be guaranteed to be a MAC address in all cases
1709 * a failure of this function should not prevent the connection.
1710 */
1711 if (sony_get_bt_devaddr(sc) < 0) {
1712 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1713 return 0;
1714 }
1715 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1716 __u8 buf[7];
1717
1718 /*
1719 * The MAC address of a DS4 controller connected via USB can be
1720 * retrieved with feature report 0x81. The address begins at
1721 * offset 1.
1722 */
1723 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1724 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1725
1726 if (ret != 7) {
1727 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1728 return ret < 0 ? ret : -EINVAL;
1729 }
1730
1731 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1732 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1733 __u8 buf[18];
1734
1735 /*
1736 * The MAC address of a Sixaxis controller connected via USB can
1737 * be retrieved with feature report 0xf2. The address begins at
1738 * offset 4.
1739 */
1740 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1741 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1742
1743 if (ret != 18) {
1744 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1745 return ret < 0 ? ret : -EINVAL;
1746 }
1747
1748 /*
1749 * The Sixaxis device MAC in the report is big-endian and must
1750 * be byte-swapped.
1751 */
1752 for (n = 0; n < 6; n++)
1753 sc->mac_address[5-n] = buf[4+n];
1754 } else {
1755 return 0;
1756 }
1757
1758 return sony_check_add_dev_list(sc);
1759}
1760
8025087a
FP		 1761static int sony_set_device_id(struct sony_sc *sc)
1762{
1763 int ret;
1764
1765 /*
1766 * Only DualShock 4 or Sixaxis controllers get an id.
1767 * All others are set to -1.
1768 */
1769 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1770 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
1771 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
1772 GFP_KERNEL);
1773 if (ret < 0) {
1774 sc->device_id = -1;
1775 return ret;
1776 }
1777 sc->device_id = ret;
1778 } else {
1779 sc->device_id = -1;
1780 }
1781
1782 return 0;
1783}
1784
1785static void sony_release_device_id(struct sony_sc *sc)
1786{
1787 if (sc->device_id >= 0) {
1788 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
1789 sc->device_id = -1;
1790 }
1791}
1792
46262047
FP		 1793static inline void sony_init_work(struct sony_sc *sc,
1794 void (*worker)(struct work_struct *))
1795{
1796 if (!sc->worker_initialized)
1797 INIT_WORK(&sc->state_worker, worker);
1798
1799 sc->worker_initialized = 1;
1800}
1801
1802static inline void sony_cancel_work_sync(struct sony_sc *sc)
1803{
1804 if (sc->worker_initialized)
1805 cancel_work_sync(&sc->state_worker);
1806}
d2d782fc 1807
bd28ce00
JS		 1808static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1809{
1810 int ret;
cc6e0bbb
JK		 1811 unsigned long quirks = id->driver_data;
1812 struct sony_sc *sc;
f04d5140 1813 unsigned int connect_mask = HID_CONNECT_DEFAULT;
cc6e0bbb 1814
abf832bf 1815 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
cc6e0bbb 1816 if (sc == NULL) {
4291ee30 1817 hid_err(hdev, "can't alloc sony descriptor\n");
cc6e0bbb
JK		 1818 return -ENOMEM;
1819 }
1820
1821 sc->quirks = quirks;
1822 hid_set_drvdata(hdev, sc);
0a286ef2 1823 sc->hdev = hdev;
bd28ce00 1824
bd28ce00
JS		 1825 ret = hid_parse(hdev);
1826 if (ret) {
4291ee30 1827 hid_err(hdev, "parse failed\n");
abf832bf 1828 return ret;
bd28ce00
JS		 1829 }
1830
f04d5140
CL		 1831 if (sc->quirks & VAIO_RDESC_CONSTANT)
1832 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1833 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1834 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1835 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1836 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1837
1838 ret = hid_hw_start(hdev, connect_mask);
bd28ce00 1839 if (ret) {
4291ee30 1840 hid_err(hdev, "hw start failed\n");
abf832bf 1841 return ret;
bd28ce00
JS		 1842 }
1843
8025087a
FP		 1844 ret = sony_set_device_id(sc);
1845 if (ret < 0) {
1846 hid_err(hdev, "failed to allocate the device id\n");
1847 goto err_stop;
1848 }
1849
569b10a5 1850 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
e534a935
BT		 1851 /*
1852 * The Sony Sixaxis does not handle HID Output Reports on the
1853 * Interrupt EP like it could, so we need to force HID Output
1854 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1855 *
1856 * There is also another issue about HID Output Reports via USB,
1857 * the Sixaxis does not want the report_id as part of the data
1858 * packet, so we have to discard buf[0] when sending the actual
1859 * control message, even for numbered reports, humpf!
1860 */
1861 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1862 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
816651a7 1863 ret = sixaxis_set_operational_usb(hdev);
46262047 1864 sony_init_work(sc, sixaxis_state_worker);
fee4e2d5 1865 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2078b9bb
FP		 1866 /*
1867 * The Sixaxis wants output reports sent on the ctrl endpoint
1868 * when connected via Bluetooth.
1869 */
1870 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
816651a7 1871 ret = sixaxis_set_operational_bt(hdev);
46262047 1872 sony_init_work(sc, sixaxis_state_worker);
fee4e2d5 1873 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
68330d83 1874 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2078b9bb
FP		 1875 /*
1876 * The DualShock 4 wants output reports sent on the ctrl
1877 * endpoint when connected via Bluetooth.
1878 */
1879 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
68330d83
FP		 1880 ret = dualshock4_set_operational_bt(hdev);
1881 if (ret < 0) {
1882 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1883 goto err_stop;
1884 }
1885 }
ad142b9e
FP		 1886 /*
1887 * The Dualshock 4 touchpad supports 2 touches and has a
e5606230
FP		 1888 * resolution of 1920x940.
1889 */
1890 ret = sony_register_touchpad(sc, 2, 1920, 940);
c4e1ddf2
FP		 1891 if (ret < 0)
1892 goto err_stop;
1893
46262047 1894 sony_init_work(sc, dualshock4_state_worker);
0bd88dd3
FP		 1895 } else {
1896 ret = 0;
1897 }
f9ce7c28 1898
d2d782fc
FP		 1899 if (ret < 0)
1900 goto err_stop;
1901
1902 ret = sony_check_add(sc);
4dfdc464 1903 if (ret < 0)
bd28ce00
JS		 1904 goto err_stop;
1905
0a286ef2 1906 if (sc->quirks & SONY_LED_SUPPORT) {
fa57a810 1907 ret = sony_leds_init(sc);
0a286ef2
SE		 1908 if (ret < 0)
1909 goto err_stop;
1910 }
1911
d902f472
FP		 1912 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1913 ret = sony_battery_probe(sc);
1914 if (ret < 0)
1915 goto err_stop;
1916
1917 /* Open the device to receive reports with battery info */
1918 ret = hid_hw_open(hdev);
1919 if (ret < 0) {
1920 hid_err(hdev, "hw open failed\n");
1921 goto err_stop;
1922 }
1923 }
1924
c8de9dbb 1925 if (sc->quirks & SONY_FF_SUPPORT) {
fa57a810 1926 ret = sony_init_ff(sc);
c8de9dbb
FP		 1927 if (ret < 0)
1928 goto err_close;
5f5750d2 1929 }
a08c22c0 1930
bd28ce00 1931 return 0;
d902f472
FP		 1932err_close:
1933 hid_hw_close(hdev);
bd28ce00 1934err_stop:
0a286ef2 1935 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 1936 sony_leds_remove(sc);
d902f472
FP		 1937 if (sc->quirks & SONY_BATTERY_SUPPORT)
1938 sony_battery_remove(sc);
46262047 1939 sony_cancel_work_sync(sc);
d2d782fc 1940 sony_remove_dev_list(sc);
8025087a 1941 sony_release_device_id(sc);
bd28ce00 1942 hid_hw_stop(hdev);
bd28ce00
JS		 1943 return ret;
1944}
1945
cc6e0bbb
JK		 1946static void sony_remove(struct hid_device *hdev)
1947{
f04d5140
CL		 1948 struct sony_sc *sc = hid_get_drvdata(hdev);
1949
0a286ef2 1950 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 1951 sony_leds_remove(sc);
f04d5140 1952
d902f472
FP		 1953 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1954 hid_hw_close(hdev);
1955 sony_battery_remove(sc);
1956 }
1957
46262047 1958 sony_cancel_work_sync(sc);
9f323b68 1959
d2d782fc 1960 sony_remove_dev_list(sc);
9f323b68 1961
8025087a
FP		 1962 sony_release_device_id(sc);
1963
cc6e0bbb 1964 hid_hw_stop(hdev);
cc6e0bbb
JK		 1965}
1966
bd28ce00 1967static const struct hid_device_id sony_devices[] = {
816651a7
AO		 1968 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1969 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4
JK		 1970 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1971 .driver_data = SIXAXIS_CONTROLLER_USB },
816651a7
AO		 1972 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1973 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 1974 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1975 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 1976 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1977 .driver_data = VAIO_RDESC_CONSTANT },
f04d5140
CL		 1978 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1979 * Logitech joystick from the device descriptor. */
1980 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1981 .driver_data = BUZZ_CONTROLLER },
1982 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1983 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 1984 /* PS3 BD Remote Control */
1985 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1986 .driver_data = PS3REMOTE },
1987 /* Logitech Harmony Adapter for PS3 */
1988 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1989 .driver_data = PS3REMOTE },
0bd88dd3
FP		 1990 /* Sony Dualshock 4 controllers for PS4 */
1991 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1992 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 1993 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1994 .driver_data = DUALSHOCK4_CONTROLLER_BT },
bd28ce00
JS		 1995 { }
1996};
1997MODULE_DEVICE_TABLE(hid, sony_devices);
1998
1999static struct hid_driver sony_driver = {
f04d5140
CL		 2000 .name = "sony",
2001 .id_table = sony_devices,
2002 .input_mapping = sony_mapping,
2003 .probe = sony_probe,
2004 .remove = sony_remove,
2005 .report_fixup = sony_report_fixup,
2006 .raw_event = sony_raw_event
bd28ce00 2007};
8025087a
FP		 2008
2009static int __init sony_init(void)
2010{
2011 dbg_hid("Sony:%s\n", __func__);
2012
2013 return hid_register_driver(&sony_driver);
2014}
2015
2016static void __exit sony_exit(void)
2017{
2018 dbg_hid("Sony:%s\n", __func__);
2019
2020 ida_destroy(&sony_device_id_allocator);
2021 hid_unregister_driver(&sony_driver);
2022}
2023module_init(sony_init);
2024module_exit(sony_exit);
bd28ce00 2025
bd28ce00 2026MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror