]> 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: logitech-dj: remove hid_output_raw_report call
[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
078328da
JK		 20/* NOTE: in order for the Sony PS3 BD Remote Control to be found by
21 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
22 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
23 *
24 * There will be no PIN request from the device.
25 */
26
bd28ce00
JS		 27#include <linux/device.h>
28#include <linux/hid.h>
29#include <linux/module.h>
5a0e3ad6 30#include <linux/slab.h>
bd28ce00 31#include <linux/usb.h>
40e32ee6 32#include <linux/leds.h>
bd28ce00
JS		 33
34#include "hid-ids.h"
35
6c79c18c
FP		 36#define VAIO_RDESC_CONSTANT BIT(0)
37#define SIXAXIS_CONTROLLER_USB BIT(1)
38#define SIXAXIS_CONTROLLER_BT BIT(2)
39#define BUZZ_CONTROLLER BIT(3)
40#define PS3REMOTE BIT(4)
8ab1676b
FP		 41#define DUALSHOCK4_CONTROLLER_USB BIT(5)
42#define DUALSHOCK4_CONTROLLER_BT BIT(6)
cc6e0bbb 43
8ab1676b 44#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER_USB | BUZZ_CONTROLLER | DUALSHOCK4_CONTROLLER_USB)
60781cf4
FP		 45
46#define MAX_LEDS 4
0a286ef2 47
61ab44be
SW		 48static const u8 sixaxis_rdesc_fixup[] = {
49 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
50 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
51 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
52};
53
e57a67da
MCC		 54static const u8 sixaxis_rdesc_fixup2[] = {
55 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
56 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
57 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
58 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
59 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
60 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
61 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
62 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
63 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
64 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
65 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
66 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
67 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
68 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
69 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
70 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
71 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
72 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
73 0xb1, 0x02, 0xc0, 0xc0,
74};
75
58d7027b
FP		 76/* The default descriptor doesn't provide mapping for the accelerometers
77 * or orientation sensors. This fixed descriptor maps the accelerometers
78 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
79 * to usage values 0x43, 0x44 and 0x45.
80 */
ed19d8cf 81static u8 dualshock4_usb_rdesc[] = {
58d7027b
FP		 82 0x05, 0x01, /* Usage Page (Desktop), */
83 0x09, 0x05, /* Usage (Gamepad), */
84 0xA1, 0x01, /* Collection (Application), */
85 0x85, 0x01, /* Report ID (1), */
86 0x09, 0x30, /* Usage (X), */
87 0x09, 0x31, /* Usage (Y), */
88 0x09, 0x32, /* Usage (Z), */
89 0x09, 0x35, /* Usage (Rz), */
90 0x15, 0x00, /* Logical Minimum (0), */
91 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
92 0x75, 0x08, /* Report Size (8), */
93 0x95, 0x04, /* Report Count (4), */
94 0x81, 0x02, /* Input (Variable), */
95 0x09, 0x39, /* Usage (Hat Switch), */
96 0x15, 0x00, /* Logical Minimum (0), */
97 0x25, 0x07, /* Logical Maximum (7), */
98 0x35, 0x00, /* Physical Minimum (0), */
99 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
100 0x65, 0x14, /* Unit (Degrees), */
101 0x75, 0x04, /* Report Size (4), */
102 0x95, 0x01, /* Report Count (1), */
103 0x81, 0x42, /* Input (Variable, Null State), */
104 0x65, 0x00, /* Unit, */
105 0x05, 0x09, /* Usage Page (Button), */
106 0x19, 0x01, /* Usage Minimum (01h), */
107 0x29, 0x0E, /* Usage Maximum (0Eh), */
108 0x15, 0x00, /* Logical Minimum (0), */
109 0x25, 0x01, /* Logical Maximum (1), */
110 0x75, 0x01, /* Report Size (1), */
111 0x95, 0x0E, /* Report Count (14), */
112 0x81, 0x02, /* Input (Variable), */
113 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
114 0x09, 0x20, /* Usage (20h), */
115 0x75, 0x06, /* Report Size (6), */
116 0x95, 0x01, /* Report Count (1), */
117 0x15, 0x00, /* Logical Minimum (0), */
118 0x25, 0x7F, /* Logical Maximum (127), */
119 0x81, 0x02, /* Input (Variable), */
120 0x05, 0x01, /* Usage Page (Desktop), */
121 0x09, 0x33, /* Usage (Rx), */
122 0x09, 0x34, /* Usage (Ry), */
123 0x15, 0x00, /* Logical Minimum (0), */
124 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
125 0x75, 0x08, /* Report Size (8), */
126 0x95, 0x02, /* Report Count (2), */
127 0x81, 0x02, /* Input (Variable), */
128 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
129 0x09, 0x21, /* Usage (21h), */
130 0x95, 0x03, /* Report Count (3), */
131 0x81, 0x02, /* Input (Variable), */
132 0x05, 0x01, /* Usage Page (Desktop), */
133 0x19, 0x40, /* Usage Minimum (40h), */
134 0x29, 0x42, /* Usage Maximum (42h), */
135 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
136 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
137 0x75, 0x10, /* Report Size (16), */
138 0x95, 0x03, /* Report Count (3), */
139 0x81, 0x02, /* Input (Variable), */
140 0x19, 0x43, /* Usage Minimum (43h), */
141 0x29, 0x45, /* Usage Maximum (45h), */
142 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
143 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
144 0x95, 0x03, /* Report Count (3), */
145 0x81, 0x02, /* Input (Variable), */
146 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
147 0x09, 0x21, /* Usage (21h), */
148 0x15, 0x00, /* Logical Minimum (0), */
149 0x25, 0xFF, /* Logical Maximum (255), */
150 0x75, 0x08, /* Report Size (8), */
151 0x95, 0x27, /* Report Count (39), */
152 0x81, 0x02, /* Input (Variable), */
153 0x85, 0x05, /* Report ID (5), */
154 0x09, 0x22, /* Usage (22h), */
155 0x95, 0x1F, /* Report Count (31), */
156 0x91, 0x02, /* Output (Variable), */
157 0x85, 0x04, /* Report ID (4), */
158 0x09, 0x23, /* Usage (23h), */
159 0x95, 0x24, /* Report Count (36), */
160 0xB1, 0x02, /* Feature (Variable), */
161 0x85, 0x02, /* Report ID (2), */
162 0x09, 0x24, /* Usage (24h), */
163 0x95, 0x24, /* Report Count (36), */
164 0xB1, 0x02, /* Feature (Variable), */
165 0x85, 0x08, /* Report ID (8), */
166 0x09, 0x25, /* Usage (25h), */
167 0x95, 0x03, /* Report Count (3), */
168 0xB1, 0x02, /* Feature (Variable), */
169 0x85, 0x10, /* Report ID (16), */
170 0x09, 0x26, /* Usage (26h), */
171 0x95, 0x04, /* Report Count (4), */
172 0xB1, 0x02, /* Feature (Variable), */
173 0x85, 0x11, /* Report ID (17), */
174 0x09, 0x27, /* Usage (27h), */
175 0x95, 0x02, /* Report Count (2), */
176 0xB1, 0x02, /* Feature (Variable), */
177 0x85, 0x12, /* Report ID (18), */
178 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
179 0x09, 0x21, /* Usage (21h), */
180 0x95, 0x0F, /* Report Count (15), */
181 0xB1, 0x02, /* Feature (Variable), */
182 0x85, 0x13, /* Report ID (19), */
183 0x09, 0x22, /* Usage (22h), */
184 0x95, 0x16, /* Report Count (22), */
185 0xB1, 0x02, /* Feature (Variable), */
186 0x85, 0x14, /* Report ID (20), */
187 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
188 0x09, 0x20, /* Usage (20h), */
189 0x95, 0x10, /* Report Count (16), */
190 0xB1, 0x02, /* Feature (Variable), */
191 0x85, 0x15, /* Report ID (21), */
192 0x09, 0x21, /* Usage (21h), */
193 0x95, 0x2C, /* Report Count (44), */
194 0xB1, 0x02, /* Feature (Variable), */
195 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
196 0x85, 0x80, /* Report ID (128), */
197 0x09, 0x20, /* Usage (20h), */
198 0x95, 0x06, /* Report Count (6), */
199 0xB1, 0x02, /* Feature (Variable), */
200 0x85, 0x81, /* Report ID (129), */
201 0x09, 0x21, /* Usage (21h), */
202 0x95, 0x06, /* Report Count (6), */
203 0xB1, 0x02, /* Feature (Variable), */
204 0x85, 0x82, /* Report ID (130), */
205 0x09, 0x22, /* Usage (22h), */
206 0x95, 0x05, /* Report Count (5), */
207 0xB1, 0x02, /* Feature (Variable), */
208 0x85, 0x83, /* Report ID (131), */
209 0x09, 0x23, /* Usage (23h), */
210 0x95, 0x01, /* Report Count (1), */
211 0xB1, 0x02, /* Feature (Variable), */
212 0x85, 0x84, /* Report ID (132), */
213 0x09, 0x24, /* Usage (24h), */
214 0x95, 0x04, /* Report Count (4), */
215 0xB1, 0x02, /* Feature (Variable), */
216 0x85, 0x85, /* Report ID (133), */
217 0x09, 0x25, /* Usage (25h), */
218 0x95, 0x06, /* Report Count (6), */
219 0xB1, 0x02, /* Feature (Variable), */
220 0x85, 0x86, /* Report ID (134), */
221 0x09, 0x26, /* Usage (26h), */
222 0x95, 0x06, /* Report Count (6), */
223 0xB1, 0x02, /* Feature (Variable), */
224 0x85, 0x87, /* Report ID (135), */
225 0x09, 0x27, /* Usage (27h), */
226 0x95, 0x23, /* Report Count (35), */
227 0xB1, 0x02, /* Feature (Variable), */
228 0x85, 0x88, /* Report ID (136), */
229 0x09, 0x28, /* Usage (28h), */
230 0x95, 0x22, /* Report Count (34), */
231 0xB1, 0x02, /* Feature (Variable), */
232 0x85, 0x89, /* Report ID (137), */
233 0x09, 0x29, /* Usage (29h), */
234 0x95, 0x02, /* Report Count (2), */
235 0xB1, 0x02, /* Feature (Variable), */
236 0x85, 0x90, /* Report ID (144), */
237 0x09, 0x30, /* Usage (30h), */
238 0x95, 0x05, /* Report Count (5), */
239 0xB1, 0x02, /* Feature (Variable), */
240 0x85, 0x91, /* Report ID (145), */
241 0x09, 0x31, /* Usage (31h), */
242 0x95, 0x03, /* Report Count (3), */
243 0xB1, 0x02, /* Feature (Variable), */
244 0x85, 0x92, /* Report ID (146), */
245 0x09, 0x32, /* Usage (32h), */
246 0x95, 0x03, /* Report Count (3), */
247 0xB1, 0x02, /* Feature (Variable), */
248 0x85, 0x93, /* Report ID (147), */
249 0x09, 0x33, /* Usage (33h), */
250 0x95, 0x0C, /* Report Count (12), */
251 0xB1, 0x02, /* Feature (Variable), */
252 0x85, 0xA0, /* Report ID (160), */
253 0x09, 0x40, /* Usage (40h), */
254 0x95, 0x06, /* Report Count (6), */
255 0xB1, 0x02, /* Feature (Variable), */
256 0x85, 0xA1, /* Report ID (161), */
257 0x09, 0x41, /* Usage (41h), */
258 0x95, 0x01, /* Report Count (1), */
259 0xB1, 0x02, /* Feature (Variable), */
260 0x85, 0xA2, /* Report ID (162), */
261 0x09, 0x42, /* Usage (42h), */
262 0x95, 0x01, /* Report Count (1), */
263 0xB1, 0x02, /* Feature (Variable), */
264 0x85, 0xA3, /* Report ID (163), */
265 0x09, 0x43, /* Usage (43h), */
266 0x95, 0x30, /* Report Count (48), */
267 0xB1, 0x02, /* Feature (Variable), */
268 0x85, 0xA4, /* Report ID (164), */
269 0x09, 0x44, /* Usage (44h), */
270 0x95, 0x0D, /* Report Count (13), */
271 0xB1, 0x02, /* Feature (Variable), */
272 0x85, 0xA5, /* Report ID (165), */
273 0x09, 0x45, /* Usage (45h), */
274 0x95, 0x15, /* Report Count (21), */
275 0xB1, 0x02, /* Feature (Variable), */
276 0x85, 0xA6, /* Report ID (166), */
277 0x09, 0x46, /* Usage (46h), */
278 0x95, 0x15, /* Report Count (21), */
279 0xB1, 0x02, /* Feature (Variable), */
280 0x85, 0xF0, /* Report ID (240), */
281 0x09, 0x47, /* Usage (47h), */
282 0x95, 0x3F, /* Report Count (63), */
283 0xB1, 0x02, /* Feature (Variable), */
284 0x85, 0xF1, /* Report ID (241), */
285 0x09, 0x48, /* Usage (48h), */
286 0x95, 0x3F, /* Report Count (63), */
287 0xB1, 0x02, /* Feature (Variable), */
288 0x85, 0xF2, /* Report ID (242), */
289 0x09, 0x49, /* Usage (49h), */
290 0x95, 0x0F, /* Report Count (15), */
291 0xB1, 0x02, /* Feature (Variable), */
292 0x85, 0xA7, /* Report ID (167), */
293 0x09, 0x4A, /* Usage (4Ah), */
294 0x95, 0x01, /* Report Count (1), */
295 0xB1, 0x02, /* Feature (Variable), */
296 0x85, 0xA8, /* Report ID (168), */
297 0x09, 0x4B, /* Usage (4Bh), */
298 0x95, 0x01, /* Report Count (1), */
299 0xB1, 0x02, /* Feature (Variable), */
300 0x85, 0xA9, /* Report ID (169), */
301 0x09, 0x4C, /* Usage (4Ch), */
302 0x95, 0x08, /* Report Count (8), */
303 0xB1, 0x02, /* Feature (Variable), */
304 0x85, 0xAA, /* Report ID (170), */
305 0x09, 0x4E, /* Usage (4Eh), */
306 0x95, 0x01, /* Report Count (1), */
307 0xB1, 0x02, /* Feature (Variable), */
308 0x85, 0xAB, /* Report ID (171), */
309 0x09, 0x4F, /* Usage (4Fh), */
310 0x95, 0x39, /* Report Count (57), */
311 0xB1, 0x02, /* Feature (Variable), */
312 0x85, 0xAC, /* Report ID (172), */
313 0x09, 0x50, /* Usage (50h), */
314 0x95, 0x39, /* Report Count (57), */
315 0xB1, 0x02, /* Feature (Variable), */
316 0x85, 0xAD, /* Report ID (173), */
317 0x09, 0x51, /* Usage (51h), */
318 0x95, 0x0B, /* Report Count (11), */
319 0xB1, 0x02, /* Feature (Variable), */
320 0x85, 0xAE, /* Report ID (174), */
321 0x09, 0x52, /* Usage (52h), */
322 0x95, 0x01, /* Report Count (1), */
323 0xB1, 0x02, /* Feature (Variable), */
324 0x85, 0xAF, /* Report ID (175), */
325 0x09, 0x53, /* Usage (53h), */
326 0x95, 0x02, /* Report Count (2), */
327 0xB1, 0x02, /* Feature (Variable), */
328 0x85, 0xB0, /* Report ID (176), */
329 0x09, 0x54, /* Usage (54h), */
330 0x95, 0x3F, /* Report Count (63), */
331 0xB1, 0x02, /* Feature (Variable), */
332 0xC0 /* End Collection */
ed19d8cf
FP		 333};
334
078328da
JK		 335static __u8 ps3remote_rdesc[] = {
336 0x05, 0x01, /* GUsagePage Generic Desktop */
337 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
338 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
339
340 /* Use collection 1 for joypad buttons */
341 0xA1, 0x02, /* MCollection Logical (interrelated data) */
342
343 /* Ignore the 1st byte, maybe it is used for a controller
344 * number but it's not needed for correct operation */
345 0x75, 0x08, /* GReportSize 0x08 [8] */
346 0x95, 0x01, /* GReportCount 0x01 [1] */
347 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
348
349 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
350 * buttons multiple keypresses are allowed */
351 0x05, 0x09, /* GUsagePage Button */
352 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
353 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
354 0x14, /* GLogicalMinimum [0] */
355 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
356 0x75, 0x01, /* GReportSize 0x01 [1] */
357 0x95, 0x18, /* GReportCount 0x18 [24] */
358 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
359
360 0xC0, /* MEndCollection */
361
362 /* Use collection 2 for remote control buttons */
363 0xA1, 0x02, /* MCollection Logical (interrelated data) */
364
365 /* 5th byte is used for remote control buttons */
366 0x05, 0x09, /* GUsagePage Button */
367 0x18, /* LUsageMinimum [No button pressed] */
368 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
369 0x14, /* GLogicalMinimum [0] */
370 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
371 0x75, 0x08, /* GReportSize 0x08 [8] */
372 0x95, 0x01, /* GReportCount 0x01 [1] */
373 0x80, /* MInput */
374
375 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
376 * 0xff and 11th is for press indication */
377 0x75, 0x08, /* GReportSize 0x08 [8] */
378 0x95, 0x06, /* GReportCount 0x06 [6] */
379 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
380
381 /* 12th byte is for battery strength */
382 0x05, 0x06, /* GUsagePage Generic Device Controls */
383 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
384 0x14, /* GLogicalMinimum [0] */
385 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
386 0x75, 0x08, /* GReportSize 0x08 [8] */
387 0x95, 0x01, /* GReportCount 0x01 [1] */
388 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
389
390 0xC0, /* MEndCollection */
391
392 0xC0 /* MEndCollection [Game Pad] */
393};
394
395static const unsigned int ps3remote_keymap_joypad_buttons[] = {
396 [0x01] = KEY_SELECT,
397 [0x02] = BTN_THUMBL, /* L3 */
398 [0x03] = BTN_THUMBR, /* R3 */
399 [0x04] = BTN_START,
400 [0x05] = KEY_UP,
401 [0x06] = KEY_RIGHT,
402 [0x07] = KEY_DOWN,
403 [0x08] = KEY_LEFT,
404 [0x09] = BTN_TL2, /* L2 */
405 [0x0a] = BTN_TR2, /* R2 */
406 [0x0b] = BTN_TL, /* L1 */
407 [0x0c] = BTN_TR, /* R1 */
408 [0x0d] = KEY_OPTION, /* options/triangle */
409 [0x0e] = KEY_BACK, /* back/circle */
410 [0x0f] = BTN_0, /* cross */
411 [0x10] = KEY_SCREEN, /* view/square */
412 [0x11] = KEY_HOMEPAGE, /* PS button */
413 [0x14] = KEY_ENTER,
414};
415static const unsigned int ps3remote_keymap_remote_buttons[] = {
416 [0x00] = KEY_1,
417 [0x01] = KEY_2,
418 [0x02] = KEY_3,
419 [0x03] = KEY_4,
420 [0x04] = KEY_5,
421 [0x05] = KEY_6,
422 [0x06] = KEY_7,
423 [0x07] = KEY_8,
424 [0x08] = KEY_9,
425 [0x09] = KEY_0,
426 [0x0e] = KEY_ESC, /* return */
427 [0x0f] = KEY_CLEAR,
428 [0x16] = KEY_EJECTCD,
429 [0x1a] = KEY_MENU, /* top menu */
430 [0x28] = KEY_TIME,
431 [0x30] = KEY_PREVIOUS,
432 [0x31] = KEY_NEXT,
433 [0x32] = KEY_PLAY,
434 [0x33] = KEY_REWIND, /* scan back */
435 [0x34] = KEY_FORWARD, /* scan forward */
436 [0x38] = KEY_STOP,
437 [0x39] = KEY_PAUSE,
438 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
439 [0x60] = KEY_FRAMEBACK, /* slow/step back */
440 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
441 [0x63] = KEY_SUBTITLE,
442 [0x64] = KEY_AUDIO,
443 [0x65] = KEY_ANGLE,
444 [0x70] = KEY_INFO, /* display */
445 [0x80] = KEY_BLUE,
446 [0x81] = KEY_RED,
447 [0x82] = KEY_GREEN,
448 [0x83] = KEY_YELLOW,
449};
450
f04d5140
CL		 451static const unsigned int buzz_keymap[] = {
452 /* The controller has 4 remote buzzers, each with one LED and 5
453 * buttons.
454 *
455 * We use the mapping chosen by the controller, which is:
456 *
457 * Key Offset
458 * -------------------
459 * Buzz 1
460 * Blue 5
461 * Orange 4
462 * Green 3
463 * Yellow 2
464 *
465 * So, for example, the orange button on the third buzzer is mapped to
466 * BTN_TRIGGER_HAPPY14
467 */
468 [ 1] = BTN_TRIGGER_HAPPY1,
469 [ 2] = BTN_TRIGGER_HAPPY2,
470 [ 3] = BTN_TRIGGER_HAPPY3,
471 [ 4] = BTN_TRIGGER_HAPPY4,
472 [ 5] = BTN_TRIGGER_HAPPY5,
473 [ 6] = BTN_TRIGGER_HAPPY6,
474 [ 7] = BTN_TRIGGER_HAPPY7,
475 [ 8] = BTN_TRIGGER_HAPPY8,
476 [ 9] = BTN_TRIGGER_HAPPY9,
477 [10] = BTN_TRIGGER_HAPPY10,
478 [11] = BTN_TRIGGER_HAPPY11,
479 [12] = BTN_TRIGGER_HAPPY12,
480 [13] = BTN_TRIGGER_HAPPY13,
481 [14] = BTN_TRIGGER_HAPPY14,
482 [15] = BTN_TRIGGER_HAPPY15,
483 [16] = BTN_TRIGGER_HAPPY16,
484 [17] = BTN_TRIGGER_HAPPY17,
485 [18] = BTN_TRIGGER_HAPPY18,
486 [19] = BTN_TRIGGER_HAPPY19,
487 [20] = BTN_TRIGGER_HAPPY20,
488};
489
cc6e0bbb 490struct sony_sc {
0a286ef2 491 struct hid_device *hdev;
60781cf4 492 struct led_classdev *leds[MAX_LEDS];
c4e1ddf2 493 struct hid_report *output_report;
cc6e0bbb 494 unsigned long quirks;
0a286ef2 495 struct work_struct state_worker;
f04d5140 496
9f323b68 497#ifdef CONFIG_SONY_FF
9f323b68
SE		 498 __u8 left;
499 __u8 right;
500#endif
501
60781cf4
FP		 502 __u8 led_state[MAX_LEDS];
503 __u8 led_count;
cc6e0bbb
JK		 504};
505
078328da
JK		 506static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
507 unsigned int *rsize)
508{
509 *rsize = sizeof(ps3remote_rdesc);
510 return ps3remote_rdesc;
511}
512
513static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
514 struct hid_field *field, struct hid_usage *usage,
515 unsigned long **bit, int *max)
516{
517 unsigned int key = usage->hid & HID_USAGE;
518
519 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
520 return -1;
521
522 switch (usage->collection_index) {
523 case 1:
524 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
525 return -1;
526
527 key = ps3remote_keymap_joypad_buttons[key];
528 if (!key)
529 return -1;
530 break;
531 case 2:
532 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
533 return -1;
534
535 key = ps3remote_keymap_remote_buttons[key];
536 if (!key)
537 return -1;
538 break;
539 default:
540 return -1;
541 }
542
543 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
544 return 1;
545}
546
547
cc6e0bbb 548/* Sony Vaio VGX has wrongly mouse pointer declared as constant */
73e4008d
NK		 549static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
550 unsigned int *rsize)
cc6e0bbb
JK		 551{
552 struct sony_sc *sc = hid_get_drvdata(hdev);
553
99d24902
FLVC		 554 /*
555 * Some Sony RF receivers wrongly declare the mouse pointer as a
556 * a constant non-data variable.
557 */
558 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
559 /* usage page: generic desktop controls */
560 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
561 /* usage: mouse */
562 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
563 /* input (usage page for x,y axes): constant, variable, relative */
564 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
a4649184 565 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 566 /* input: data, variable, relative */
cc6e0bbb
JK		 567 rdesc[55] = 0x06;
568 }
61ab44be 569
ed19d8cf
FP		 570 /*
571 * The default Dualshock 4 USB descriptor doesn't assign
572 * the gyroscope values to corresponding axes so we need a
573 * modified one.
574 */
575 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
576 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
577 rdesc = dualshock4_usb_rdesc;
578 *rsize = sizeof(dualshock4_usb_rdesc);
579 }
580
61ab44be
SW		 581 /* The HID descriptor exposed over BT has a trailing zero byte */
582 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
583 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
584 rdesc[83] == 0x75) {
585 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
586 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
587 sizeof(sixaxis_rdesc_fixup));
e57a67da
MCC		 588 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
589 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
590 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
591 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
592 *rsize = sizeof(sixaxis_rdesc_fixup2);
593 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
61ab44be 594 }
078328da
JK		 595
596 if (sc->quirks & PS3REMOTE)
597 return ps3remote_fixup(hdev, rdesc, rsize);
598
73e4008d 599 return rdesc;
cc6e0bbb
JK		 600}
601
c9e4d877
SW		 602static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
603 __u8 *rd, int size)
604{
605 struct sony_sc *sc = hid_get_drvdata(hdev);
606
607 /* Sixaxis HID report has acclerometers/gyro with MSByte first, this
608 * has to be BYTE_SWAPPED before passing up to joystick interface
609 */
610 if ((sc->quirks & (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)) &&
611 rd[0] == 0x01 && size == 49) {
612 swap(rd[41], rd[42]);
613 swap(rd[43], rd[44]);
614 swap(rd[45], rd[46]);
615 swap(rd[47], rd[48]);
616 }
617
618 return 0;
619}
620
f04d5140
CL		 621static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
622 struct hid_field *field, struct hid_usage *usage,
623 unsigned long **bit, int *max)
624{
625 struct sony_sc *sc = hid_get_drvdata(hdev);
626
627 if (sc->quirks & BUZZ_CONTROLLER) {
628 unsigned int key = usage->hid & HID_USAGE;
629
630 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
631 return -1;
632
633 switch (usage->collection_index) {
634 case 1:
635 if (key >= ARRAY_SIZE(buzz_keymap))
636 return -1;
637
638 key = buzz_keymap[key];
639 if (!key)
640 return -1;
641 break;
642 default:
643 return -1;
644 }
645
646 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
647 return 1;
648 }
649
078328da
JK		 650 if (sc->quirks & PS3REMOTE)
651 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
652
6f498018
BT		 653 /* Let hid-core decide for the others */
654 return 0;
f04d5140
CL		 655}
656
5710fabf
AO		 657/*
658 * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
659 * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
660 * so we need to override that forcing HID Output Reports on the Control EP.
661 *
662 * There is also another issue about HID Output Reports via USB, the Sixaxis
663 * does not want the report_id as part of the data packet, so we have to
664 * discard buf[0] when sending the actual control message, even for numbered
665 * reports, humpf!
666 */
569b10a5
AO		 667static int sixaxis_usb_output_raw_report(struct hid_device *hid, __u8 *buf,
668 size_t count, unsigned char report_type)
669{
670 struct usb_interface *intf = to_usb_interface(hid->dev.parent);
671 struct usb_device *dev = interface_to_usbdev(intf);
672 struct usb_host_interface *interface = intf->cur_altsetting;
673 int report_id = buf[0];
674 int ret;
675
5710fabf
AO		 676 if (report_type == HID_OUTPUT_REPORT) {
677 /* Don't send the Report ID */
678 buf++;
679 count--;
680 }
681
569b10a5
AO		 682 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
683 HID_REQ_SET_REPORT,
684 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
685 ((report_type + 1) << 8) | report_id,
686 interface->desc.bInterfaceNumber, buf, count,
687 USB_CTRL_SET_TIMEOUT);
688
5710fabf
AO		 689 /* Count also the Report ID, in case of an Output report. */
690 if (ret > 0 && report_type == HID_OUTPUT_REPORT)
691 ret++;
692
569b10a5
AO		 693 return ret;
694}
695
bd28ce00
JS		 696/*
697 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
698 * to "operational". Without this, the ps3 controller will not report any
699 * events.
700 */
816651a7 701static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 702{
bd28ce00
JS		 703 int ret;
704 char *buf = kmalloc(18, GFP_KERNEL);
705
706 if (!buf)
707 return -ENOMEM;
708
cafebc05
BT		 709 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
710 HID_REQ_GET_REPORT);
f204828a 711
bd28ce00 712 if (ret < 0)
4291ee30 713 hid_err(hdev, "can't set operational mode\n");
bd28ce00
JS		 714
715 kfree(buf);
716
717 return ret;
718}
719
816651a7 720static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 721{
fddb33f2 722 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
7e845d46
BT		 723 return hid_output_raw_report(hdev, buf, sizeof(buf),
724 HID_FEATURE_REPORT);
f9ce7c28
BN		 725}
726
60781cf4 727static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
f04d5140
CL		 728{
729 struct list_head *report_list =
730 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
731 struct hid_report *report = list_entry(report_list->next,
732 struct hid_report, list);
733 __s32 *value = report->field[0]->value;
734
735 value[0] = 0x00;
60781cf4
FP		 736 value[1] = leds[0] ? 0xff : 0x00;
737 value[2] = leds[1] ? 0xff : 0x00;
738 value[3] = leds[2] ? 0xff : 0x00;
739 value[4] = leds[3] ? 0xff : 0x00;
f04d5140
CL		 740 value[5] = 0x00;
741 value[6] = 0x00;
742 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
743}
744
60781cf4 745static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
0a286ef2
SE		 746{
747 struct sony_sc *drv_data = hid_get_drvdata(hdev);
60781cf4 748 int n;
0a286ef2 749
60781cf4
FP		 750 BUG_ON(count > MAX_LEDS);
751
752 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
0a286ef2 753 buzz_set_leds(hdev, leds);
60781cf4 754 } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) ||
8ab1676b 755 (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
60781cf4
FP		 756 for (n = 0; n < count; n++)
757 drv_data->led_state[n] = leds[n];
0a286ef2
SE		 758 schedule_work(&drv_data->state_worker);
759 }
760}
761
c5382519 762static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 763 enum led_brightness value)
764{
765 struct device *dev = led->dev->parent;
766 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
767 struct sony_sc *drv_data;
f04d5140
CL		 768
769 int n;
770
771 drv_data = hid_get_drvdata(hdev);
2251b85f 772 if (!drv_data) {
f04d5140
CL		 773 hid_err(hdev, "No device data\n");
774 return;
775 }
f04d5140 776
60781cf4 777 for (n = 0; n < drv_data->led_count; n++) {
2251b85f 778 if (led == drv_data->leds[n]) {
60781cf4
FP		 779 if (value != drv_data->led_state[n]) {
780 drv_data->led_state[n] = value;
781 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
f04d5140
CL		 782 }
783 break;
784 }
785 }
786}
787
c5382519 788static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 789{
790 struct device *dev = led->dev->parent;
791 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
792 struct sony_sc *drv_data;
f04d5140
CL		 793
794 int n;
795 int on = 0;
796
797 drv_data = hid_get_drvdata(hdev);
2251b85f 798 if (!drv_data) {
f04d5140
CL		 799 hid_err(hdev, "No device data\n");
800 return LED_OFF;
801 }
f04d5140 802
60781cf4 803 for (n = 0; n < drv_data->led_count; n++) {
2251b85f 804 if (led == drv_data->leds[n]) {
60781cf4 805 on = !!(drv_data->led_state[n]);
f04d5140
CL		 806 break;
807 }
808 }
809
810 return on ? LED_FULL : LED_OFF;
811}
f04d5140 812
0a286ef2
SE		 813static void sony_leds_remove(struct hid_device *hdev)
814{
815 struct sony_sc *drv_data;
816 struct led_classdev *led;
817 int n;
818
819 drv_data = hid_get_drvdata(hdev);
820 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
821
60781cf4 822 for (n = 0; n < drv_data->led_count; n++) {
0a286ef2
SE		 823 led = drv_data->leds[n];
824 drv_data->leds[n] = NULL;
825 if (!led)
826 continue;
827 led_classdev_unregister(led);
828 kfree(led);
829 }
60781cf4
FP		 830
831 drv_data->led_count = 0;
0a286ef2
SE		 832}
833
c5382519 834static int sony_leds_init(struct hid_device *hdev)
f04d5140
CL		 835{
836 struct sony_sc *drv_data;
40e32ee6 837 int n, ret = 0;
60781cf4 838 int max_brightness;
61ebca93 839 int use_colors;
40e32ee6
JK		 840 struct led_classdev *led;
841 size_t name_sz;
842 char *name;
0a286ef2
SE		 843 size_t name_len;
844 const char *name_fmt;
61ebca93 845 static const char * const color_str[] = { "red", "green", "blue" };
60781cf4 846 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
f04d5140
CL		 847
848 drv_data = hid_get_drvdata(hdev);
0a286ef2
SE		 849 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
850
851 if (drv_data->quirks & BUZZ_CONTROLLER) {
61ebca93
FP		 852 drv_data->led_count = 4;
853 max_brightness = 1;
854 use_colors = 0;
0a286ef2
SE		 855 name_len = strlen("::buzz#");
856 name_fmt = "%s::buzz%d";
857 /* Validate expected report characteristics. */
858 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
859 return -ENODEV;
61ebca93 860 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) {
60781cf4
FP		 861 drv_data->led_count = 3;
862 max_brightness = 255;
61ebca93
FP		 863 use_colors = 1;
864 name_len = 0;
865 name_fmt = "%s:%s";
60781cf4
FP		 866 } else {
867 drv_data->led_count = 4;
868 max_brightness = 1;
61ebca93
FP		 869 use_colors = 0;
870 name_len = strlen("::sony#");
871 name_fmt = "%s::sony%d";
60781cf4
FP		 872 }
873
f04d5140
CL		 874 /* Clear LEDs as we have no way of reading their initial state. This is
875 * only relevant if the driver is loaded after somebody actively set the
876 * LEDs to on */
60781cf4 877 sony_set_leds(hdev, initial_values, drv_data->led_count);
f04d5140 878
0a286ef2 879 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 880
60781cf4 881 for (n = 0; n < drv_data->led_count; n++) {
61ebca93
FP		 882
883 if (use_colors)
884 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
885
40e32ee6
JK		 886 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
887 if (!led) {
888 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
8cd5fcda 889 ret = -ENOMEM;
40e32ee6
JK		 890 goto error_leds;
891 }
f04d5140 892
40e32ee6 893 name = (void *)(&led[1]);
61ebca93
FP		 894 if (use_colors)
895 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
896 else
897 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6
JK		 898 led->name = name;
899 led->brightness = 0;
60781cf4 900 led->max_brightness = max_brightness;
c5382519
SE		 901 led->brightness_get = sony_led_get_brightness;
902 led->brightness_set = sony_led_set_brightness;
f04d5140 903
8cd5fcda
JL		 904 ret = led_classdev_register(&hdev->dev, led);
905 if (ret) {
40e32ee6
JK		 906 hid_err(hdev, "Failed to register LED %d\n", n);
907 kfree(led);
908 goto error_leds;
f04d5140 909 }
40e32ee6 910
2251b85f 911 drv_data->leds[n] = led;
f04d5140 912 }
f04d5140
CL		 913
914 return ret;
915
f04d5140 916error_leds:
0a286ef2 917 sony_leds_remove(hdev);
f04d5140 918
f04d5140 919 return ret;
f04d5140
CL		 920}
921
cad665a2 922static void sixaxis_state_worker(struct work_struct *work)
a08c22c0 923{
92b5c411 924 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
a08c22c0
SE		 925 unsigned char buf[] = {
926 0x01,
927 0x00, 0xff, 0x00, 0xff, 0x00,
0a286ef2 928 0x00, 0x00, 0x00, 0x00, 0x00,
a08c22c0
SE		 929 0xff, 0x27, 0x10, 0x00, 0x32,
930 0xff, 0x27, 0x10, 0x00, 0x32,
931 0xff, 0x27, 0x10, 0x00, 0x32,
932 0xff, 0x27, 0x10, 0x00, 0x32,
933 0x00, 0x00, 0x00, 0x00, 0x00
934 };
9f323b68 935
0a286ef2 936#ifdef CONFIG_SONY_FF
0bd88dd3 937 buf[3] = sc->right ? 1 : 0;
9f323b68 938 buf[5] = sc->left;
0a286ef2
SE		 939#endif
940
60781cf4
FP		 941 buf[10] |= sc->led_state[0] << 1;
942 buf[10] |= sc->led_state[1] << 2;
943 buf[10] |= sc->led_state[2] << 3;
944 buf[10] |= sc->led_state[3] << 4;
9f323b68 945
7e845d46 946 hid_output_raw_report(sc->hdev, buf, sizeof(buf), HID_OUTPUT_REPORT);
9f323b68
SE		 947}
948
0bd88dd3
FP		 949static void dualshock4_state_worker(struct work_struct *work)
950{
951 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
0da8ea65 952 struct hid_device *hdev = sc->hdev;
c4e1ddf2
FP		 953 struct hid_report *report = sc->output_report;
954 __s32 *value = report->field[0]->value;
0da8ea65 955
0da8ea65 956 value[0] = 0x03;
0bd88dd3
FP		 957
958#ifdef CONFIG_SONY_FF
0da8ea65
FP		 959 value[3] = sc->right;
960 value[4] = sc->left;
0bd88dd3
FP		 961#endif
962
0da8ea65
FP		 963 value[5] = sc->led_state[0];
964 value[6] = sc->led_state[1];
965 value[7] = sc->led_state[2];
60781cf4 966
0da8ea65 967 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
0bd88dd3
FP		 968}
969
0a286ef2 970#ifdef CONFIG_SONY_FF
9f323b68
SE		 971static int sony_play_effect(struct input_dev *dev, void *data,
972 struct ff_effect *effect)
973{
a08c22c0 974 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 975 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 976
977 if (effect->type != FF_RUMBLE)
978 return 0;
979
9f323b68 980 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 981 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 982
92b5c411 983 schedule_work(&sc->state_worker);
9f323b68 984 return 0;
a08c22c0
SE		 985}
986
987static int sony_init_ff(struct hid_device *hdev)
988{
989 struct hid_input *hidinput = list_entry(hdev->inputs.next,
990 struct hid_input, list);
991 struct input_dev *input_dev = hidinput->input;
992
993 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
994 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
995}
996
9f323b68
SE		 997static void sony_destroy_ff(struct hid_device *hdev)
998{
999 struct sony_sc *sc = hid_get_drvdata(hdev);
1000
92b5c411 1001 cancel_work_sync(&sc->state_worker);
9f323b68
SE		 1002}
1003
a08c22c0
SE		 1004#else
1005static int sony_init_ff(struct hid_device *hdev)
1006{
1007 return 0;
1008}
9f323b68
SE		 1009
1010static void sony_destroy_ff(struct hid_device *hdev)
1011{
1012}
a08c22c0
SE		 1013#endif
1014
c4e1ddf2
FP		 1015static int sony_set_output_report(struct sony_sc *sc, int req_id, int req_size)
1016{
1017 struct list_head *head, *list;
1018 struct hid_report *report;
1019 struct hid_device *hdev = sc->hdev;
1020
1021 list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1022
1023 list_for_each(head, list) {
1024 report = list_entry(head, struct hid_report, list);
1025
1026 if (report->id == req_id) {
1027 if (report->size < req_size) {
1028 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n",
1029 req_id, report->size, req_size);
1030 return -EINVAL;
1031 }
1032 sc->output_report = report;
1033 return 0;
1034 }
1035 }
1036
1037 hid_err(hdev, "Unable to locate output report 0x%02x\n", req_id);
1038
1039 return -EINVAL;
1040}
1041
bd28ce00
JS		 1042static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1043{
1044 int ret;
cc6e0bbb
JK		 1045 unsigned long quirks = id->driver_data;
1046 struct sony_sc *sc;
f04d5140 1047 unsigned int connect_mask = HID_CONNECT_DEFAULT;
cc6e0bbb 1048
abf832bf 1049 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
cc6e0bbb 1050 if (sc == NULL) {
4291ee30 1051 hid_err(hdev, "can't alloc sony descriptor\n");
cc6e0bbb
JK		 1052 return -ENOMEM;
1053 }
1054
1055 sc->quirks = quirks;
1056 hid_set_drvdata(hdev, sc);
0a286ef2 1057 sc->hdev = hdev;
bd28ce00 1058
bd28ce00
JS		 1059 ret = hid_parse(hdev);
1060 if (ret) {
4291ee30 1061 hid_err(hdev, "parse failed\n");
abf832bf 1062 return ret;
bd28ce00
JS		 1063 }
1064
f04d5140
CL		 1065 if (sc->quirks & VAIO_RDESC_CONSTANT)
1066 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1067 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1068 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1069 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1070 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1071
1072 ret = hid_hw_start(hdev, connect_mask);
bd28ce00 1073 if (ret) {
4291ee30 1074 hid_err(hdev, "hw start failed\n");
abf832bf 1075 return ret;
bd28ce00
JS		 1076 }
1077
569b10a5
AO		 1078 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1079 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
816651a7 1080 ret = sixaxis_set_operational_usb(hdev);
cad665a2 1081 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
569b10a5 1082 }
816651a7
AO		 1083 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1084 ret = sixaxis_set_operational_bt(hdev);
8ab1676b 1085 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
c4e1ddf2
FP		 1086 /* Report 5 (31 bytes) is used to send data to the controller via USB */
1087 ret = sony_set_output_report(sc, 0x05, 248);
1088 if (ret < 0)
1089 goto err_stop;
1090
0bd88dd3
FP		 1091 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1092 } else {
1093 ret = 0;
1094 }
f9ce7c28 1095
4dfdc464 1096 if (ret < 0)
bd28ce00
JS		 1097 goto err_stop;
1098
0a286ef2
SE		 1099 if (sc->quirks & SONY_LED_SUPPORT) {
1100 ret = sony_leds_init(hdev);
1101 if (ret < 0)
1102 goto err_stop;
1103 }
1104
a08c22c0
SE		 1105 ret = sony_init_ff(hdev);
1106 if (ret < 0)
1107 goto err_stop;
1108
bd28ce00
JS		 1109 return 0;
1110err_stop:
0a286ef2
SE		 1111 if (sc->quirks & SONY_LED_SUPPORT)
1112 sony_leds_remove(hdev);
bd28ce00 1113 hid_hw_stop(hdev);
bd28ce00
JS		 1114 return ret;
1115}
1116
cc6e0bbb
JK		 1117static void sony_remove(struct hid_device *hdev)
1118{
f04d5140
CL		 1119 struct sony_sc *sc = hid_get_drvdata(hdev);
1120
0a286ef2 1121 if (sc->quirks & SONY_LED_SUPPORT)
c5382519 1122 sony_leds_remove(hdev);
f04d5140 1123
9f323b68
SE		 1124 sony_destroy_ff(hdev);
1125
cc6e0bbb 1126 hid_hw_stop(hdev);
cc6e0bbb
JK		 1127}
1128
bd28ce00 1129static const struct hid_device_id sony_devices[] = {
816651a7
AO		 1130 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1131 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4
JK		 1132 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1133 .driver_data = SIXAXIS_CONTROLLER_USB },
816651a7
AO		 1134 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1135 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 1136 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1137 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 1138 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1139 .driver_data = VAIO_RDESC_CONSTANT },
f04d5140
CL		 1140 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1141 * Logitech joystick from the device descriptor. */
1142 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1143 .driver_data = BUZZ_CONTROLLER },
1144 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1145 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 1146 /* PS3 BD Remote Control */
1147 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1148 .driver_data = PS3REMOTE },
1149 /* Logitech Harmony Adapter for PS3 */
1150 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1151 .driver_data = PS3REMOTE },
0bd88dd3
FP		 1152 /* Sony Dualshock 4 controllers for PS4 */
1153 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1154 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 1155 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1156 .driver_data = DUALSHOCK4_CONTROLLER_BT },
bd28ce00
JS		 1157 { }
1158};
1159MODULE_DEVICE_TABLE(hid, sony_devices);
1160
1161static struct hid_driver sony_driver = {
f04d5140
CL		 1162 .name = "sony",
1163 .id_table = sony_devices,
1164 .input_mapping = sony_mapping,
1165 .probe = sony_probe,
1166 .remove = sony_remove,
1167 .report_fixup = sony_report_fixup,
1168 .raw_event = sony_raw_event
bd28ce00 1169};
f425458e 1170module_hid_driver(sony_driver);
bd28ce00 1171
bd28ce00 1172MODULE_LICENSE("GPL");
ubuntu-zesty-kernel mirror