]> Git Repo - linux.git/blame - drivers/hid/hid-sony.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending
[linux.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 <[email protected]>
6 * Copyright (c) 2005 Michael Haboustak <[email protected]> for Concept2, Inc
bd28ce00 7 * Copyright (c) 2008 Jiri Slaby
078328da
JK		 8 * Copyright (c) 2012 David Dillow <[email protected]>
9 * Copyright (c) 2006-2013 Jiri Kosina
f04d5140 10 * Copyright (c) 2013 Colin Leitner <[email protected]>
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
f204828a
BT		 709 ret = hdev->hid_get_raw_report(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT);
710
bd28ce00 711 if (ret < 0)
4291ee30 712 hid_err(hdev, "can't set operational mode\n");
bd28ce00
JS		 713
714 kfree(buf);
715
716 return ret;
717}
718
816651a7 719static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 720{
fddb33f2 721 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
f9ce7c28
BN		 722 return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
723}
724
60781cf4 725static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
f04d5140
CL		 726{
727 struct list_head *report_list =
728 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
729 struct hid_report *report = list_entry(report_list->next,
730 struct hid_report, list);
731 __s32 *value = report->field[0]->value;
732
733 value[0] = 0x00;
60781cf4
FP		 734 value[1] = leds[0] ? 0xff : 0x00;
735 value[2] = leds[1] ? 0xff : 0x00;
736 value[3] = leds[2] ? 0xff : 0x00;
737 value[4] = leds[3] ? 0xff : 0x00;
f04d5140
CL		 738 value[5] = 0x00;
739 value[6] = 0x00;
740 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
741}
742
60781cf4 743static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
0a286ef2
SE		 744{
745 struct sony_sc *drv_data = hid_get_drvdata(hdev);
60781cf4 746 int n;
0a286ef2 747
60781cf4
FP		 748 BUG_ON(count > MAX_LEDS);
749
750 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
0a286ef2 751 buzz_set_leds(hdev, leds);
60781cf4 752 } else if ((drv_data->quirks & SIXAXIS_CONTROLLER_USB) ||
8ab1676b 753 (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB)) {
60781cf4
FP		 754 for (n = 0; n < count; n++)
755 drv_data->led_state[n] = leds[n];
0a286ef2
SE		 756 schedule_work(&drv_data->state_worker);
757 }
758}
759
c5382519 760static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 761 enum led_brightness value)
762{
763 struct device *dev = led->dev->parent;
764 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
765 struct sony_sc *drv_data;
f04d5140
CL		 766
767 int n;
768
769 drv_data = hid_get_drvdata(hdev);
2251b85f 770 if (!drv_data) {
f04d5140
CL		 771 hid_err(hdev, "No device data\n");
772 return;
773 }
f04d5140 774
60781cf4 775 for (n = 0; n < drv_data->led_count; n++) {
2251b85f 776 if (led == drv_data->leds[n]) {
60781cf4
FP		 777 if (value != drv_data->led_state[n]) {
778 drv_data->led_state[n] = value;
779 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
f04d5140
CL		 780 }
781 break;
782 }
783 }
784}
785
c5382519 786static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 787{
788 struct device *dev = led->dev->parent;
789 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
790 struct sony_sc *drv_data;
f04d5140
CL		 791
792 int n;
793 int on = 0;
794
795 drv_data = hid_get_drvdata(hdev);
2251b85f 796 if (!drv_data) {
f04d5140
CL		 797 hid_err(hdev, "No device data\n");
798 return LED_OFF;
799 }
f04d5140 800
60781cf4 801 for (n = 0; n < drv_data->led_count; n++) {
2251b85f 802 if (led == drv_data->leds[n]) {
60781cf4 803 on = !!(drv_data->led_state[n]);
f04d5140
CL		 804 break;
805 }
806 }
807
808 return on ? LED_FULL : LED_OFF;
809}
f04d5140 810
0a286ef2
SE		 811static void sony_leds_remove(struct hid_device *hdev)
812{
813 struct sony_sc *drv_data;
814 struct led_classdev *led;
815 int n;
816
817 drv_data = hid_get_drvdata(hdev);
818 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
819
60781cf4 820 for (n = 0; n < drv_data->led_count; n++) {
0a286ef2
SE		 821 led = drv_data->leds[n];
822 drv_data->leds[n] = NULL;
823 if (!led)
824 continue;
825 led_classdev_unregister(led);
826 kfree(led);
827 }
60781cf4
FP		 828
829 drv_data->led_count = 0;
0a286ef2
SE		 830}
831
c5382519 832static int sony_leds_init(struct hid_device *hdev)
f04d5140
CL		 833{
834 struct sony_sc *drv_data;
40e32ee6 835 int n, ret = 0;
60781cf4 836 int max_brightness;
61ebca93 837 int use_colors;
40e32ee6
JK		 838 struct led_classdev *led;
839 size_t name_sz;
840 char *name;
0a286ef2
SE		 841 size_t name_len;
842 const char *name_fmt;
61ebca93 843 static const char * const color_str[] = { "red", "green", "blue" };
60781cf4 844 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
f04d5140
CL		 845
846 drv_data = hid_get_drvdata(hdev);
0a286ef2
SE		 847 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
848
849 if (drv_data->quirks & BUZZ_CONTROLLER) {
61ebca93
FP		 850 drv_data->led_count = 4;
851 max_brightness = 1;
852 use_colors = 0;
0a286ef2
SE		 853 name_len = strlen("::buzz#");
854 name_fmt = "%s::buzz%d";
855 /* Validate expected report characteristics. */
856 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
857 return -ENODEV;
61ebca93 858 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER_USB) {
60781cf4
FP		 859 drv_data->led_count = 3;
860 max_brightness = 255;
61ebca93
FP		 861 use_colors = 1;
862 name_len = 0;
863 name_fmt = "%s:%s";
60781cf4
FP		 864 } else {
865 drv_data->led_count = 4;
866 max_brightness = 1;
61ebca93
FP		 867 use_colors = 0;
868 name_len = strlen("::sony#");
869 name_fmt = "%s::sony%d";
60781cf4
FP		 870 }
871
f04d5140
CL		 872 /* Clear LEDs as we have no way of reading their initial state. This is
873 * only relevant if the driver is loaded after somebody actively set the
874 * LEDs to on */
60781cf4 875 sony_set_leds(hdev, initial_values, drv_data->led_count);
f04d5140 876
0a286ef2 877 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 878
60781cf4 879 for (n = 0; n < drv_data->led_count; n++) {
61ebca93
FP		 880
881 if (use_colors)
882 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
883
40e32ee6
JK		 884 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
885 if (!led) {
886 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
8cd5fcda 887 ret = -ENOMEM;
40e32ee6
JK		 888 goto error_leds;
889 }
f04d5140 890
40e32ee6 891 name = (void *)(&led[1]);
61ebca93
FP		 892 if (use_colors)
893 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
894 else
895 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6
JK		 896 led->name = name;
897 led->brightness = 0;
60781cf4 898 led->max_brightness = max_brightness;
c5382519
SE		 899 led->brightness_get = sony_led_get_brightness;
900 led->brightness_set = sony_led_set_brightness;
f04d5140 901
8cd5fcda
JL		 902 ret = led_classdev_register(&hdev->dev, led);
903 if (ret) {
40e32ee6
JK		 904 hid_err(hdev, "Failed to register LED %d\n", n);
905 kfree(led);
906 goto error_leds;
f04d5140 907 }
40e32ee6 908
2251b85f 909 drv_data->leds[n] = led;
f04d5140 910 }
f04d5140
CL		 911
912 return ret;
913
f04d5140 914error_leds:
0a286ef2 915 sony_leds_remove(hdev);
f04d5140 916
f04d5140 917 return ret;
f04d5140
CL		 918}
919
cad665a2 920static void sixaxis_state_worker(struct work_struct *work)
a08c22c0 921{
92b5c411 922 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
a08c22c0
SE		 923 unsigned char buf[] = {
924 0x01,
925 0x00, 0xff, 0x00, 0xff, 0x00,
0a286ef2 926 0x00, 0x00, 0x00, 0x00, 0x00,
a08c22c0
SE		 927 0xff, 0x27, 0x10, 0x00, 0x32,
928 0xff, 0x27, 0x10, 0x00, 0x32,
929 0xff, 0x27, 0x10, 0x00, 0x32,
930 0xff, 0x27, 0x10, 0x00, 0x32,
931 0x00, 0x00, 0x00, 0x00, 0x00
932 };
9f323b68 933
0a286ef2 934#ifdef CONFIG_SONY_FF
0bd88dd3 935 buf[3] = sc->right ? 1 : 0;
9f323b68 936 buf[5] = sc->left;
0a286ef2
SE		 937#endif
938
60781cf4
FP		 939 buf[10] |= sc->led_state[0] << 1;
940 buf[10] |= sc->led_state[1] << 2;
941 buf[10] |= sc->led_state[2] << 3;
942 buf[10] |= sc->led_state[3] << 4;
9f323b68
SE		 943
944 sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf),
945 HID_OUTPUT_REPORT);
946}
947
0bd88dd3
FP		 948static void dualshock4_state_worker(struct work_struct *work)
949{
950 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
0da8ea65 951 struct hid_device *hdev = sc->hdev;
c4e1ddf2
FP		 952 struct hid_report *report = sc->output_report;
953 __s32 *value = report->field[0]->value;
0da8ea65 954
0da8ea65 955 value[0] = 0x03;
0bd88dd3
FP		 956
957#ifdef CONFIG_SONY_FF
0da8ea65
FP		 958 value[3] = sc->right;
959 value[4] = sc->left;
0bd88dd3
FP		 960#endif
961
0da8ea65
FP		 962 value[5] = sc->led_state[0];
963 value[6] = sc->led_state[1];
964 value[7] = sc->led_state[2];
60781cf4 965
0da8ea65 966 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
0bd88dd3
FP		 967}
968
0a286ef2 969#ifdef CONFIG_SONY_FF
9f323b68
SE		 970static int sony_play_effect(struct input_dev *dev, void *data,
971 struct ff_effect *effect)
972{
a08c22c0 973 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 974 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 975
976 if (effect->type != FF_RUMBLE)
977 return 0;
978
9f323b68 979 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 980 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 981
92b5c411 982 schedule_work(&sc->state_worker);
9f323b68 983 return 0;
a08c22c0
SE		 984}
985
986static int sony_init_ff(struct hid_device *hdev)
987{
988 struct hid_input *hidinput = list_entry(hdev->inputs.next,
989 struct hid_input, list);
990 struct input_dev *input_dev = hidinput->input;
991
992 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
993 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
994}
995
9f323b68
SE		 996static void sony_destroy_ff(struct hid_device *hdev)
997{
998 struct sony_sc *sc = hid_get_drvdata(hdev);
999
92b5c411 1000 cancel_work_sync(&sc->state_worker);
9f323b68
SE		 1001}
1002
a08c22c0
SE		 1003#else
1004static int sony_init_ff(struct hid_device *hdev)
1005{
1006 return 0;
1007}
9f323b68
SE		 1008
1009static void sony_destroy_ff(struct hid_device *hdev)
1010{
1011}
a08c22c0
SE		 1012#endif
1013
c4e1ddf2
FP		 1014static int sony_set_output_report(struct sony_sc *sc, int req_id, int req_size)
1015{
1016 struct list_head *head, *list;
1017 struct hid_report *report;
1018 struct hid_device *hdev = sc->hdev;
1019
1020 list = &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1021
1022 list_for_each(head, list) {
1023 report = list_entry(head, struct hid_report, list);
1024
1025 if (report->id == req_id) {
1026 if (report->size < req_size) {
1027 hid_err(hdev, "Output report 0x%02x (%i bits) is smaller than requested size (%i bits)\n",
1028 req_id, report->size, req_size);
1029 return -EINVAL;
1030 }
1031 sc->output_report = report;
1032 return 0;
1033 }
1034 }
1035
1036 hid_err(hdev, "Unable to locate output report 0x%02x\n", req_id);
1037
1038 return -EINVAL;
1039}
1040
bd28ce00
JS		 1041static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1042{
1043 int ret;
cc6e0bbb
JK		 1044 unsigned long quirks = id->driver_data;
1045 struct sony_sc *sc;
f04d5140 1046 unsigned int connect_mask = HID_CONNECT_DEFAULT;
cc6e0bbb 1047
abf832bf 1048 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
cc6e0bbb 1049 if (sc == NULL) {
4291ee30 1050 hid_err(hdev, "can't alloc sony descriptor\n");
cc6e0bbb
JK		 1051 return -ENOMEM;
1052 }
1053
1054 sc->quirks = quirks;
1055 hid_set_drvdata(hdev, sc);
0a286ef2 1056 sc->hdev = hdev;
bd28ce00 1057
bd28ce00
JS		 1058 ret = hid_parse(hdev);
1059 if (ret) {
4291ee30 1060 hid_err(hdev, "parse failed\n");
abf832bf 1061 return ret;
bd28ce00
JS		 1062 }
1063
f04d5140
CL		 1064 if (sc->quirks & VAIO_RDESC_CONSTANT)
1065 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1066 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1067 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1068 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1069 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1070
1071 ret = hid_hw_start(hdev, connect_mask);
bd28ce00 1072 if (ret) {
4291ee30 1073 hid_err(hdev, "hw start failed\n");
abf832bf 1074 return ret;
bd28ce00
JS		 1075 }
1076
569b10a5
AO		 1077 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1078 hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
816651a7 1079 ret = sixaxis_set_operational_usb(hdev);
cad665a2 1080 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
569b10a5 1081 }
816651a7
AO		 1082 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1083 ret = sixaxis_set_operational_bt(hdev);
8ab1676b 1084 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
c4e1ddf2
FP		 1085 /* Report 5 (31 bytes) is used to send data to the controller via USB */
1086 ret = sony_set_output_report(sc, 0x05, 248);
1087 if (ret < 0)
1088 goto err_stop;
1089
0bd88dd3
FP		 1090 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1091 } else {
1092 ret = 0;
1093 }
f9ce7c28 1094
4dfdc464 1095 if (ret < 0)
bd28ce00
JS		 1096 goto err_stop;
1097
0a286ef2
SE		 1098 if (sc->quirks & SONY_LED_SUPPORT) {
1099 ret = sony_leds_init(hdev);
1100 if (ret < 0)
1101 goto err_stop;
1102 }
1103
a08c22c0
SE		 1104 ret = sony_init_ff(hdev);
1105 if (ret < 0)
1106 goto err_stop;
1107
bd28ce00
JS		 1108 return 0;
1109err_stop:
0a286ef2
SE		 1110 if (sc->quirks & SONY_LED_SUPPORT)
1111 sony_leds_remove(hdev);
bd28ce00 1112 hid_hw_stop(hdev);
bd28ce00
JS		 1113 return ret;
1114}
1115
cc6e0bbb
JK		 1116static void sony_remove(struct hid_device *hdev)
1117{
f04d5140
CL		 1118 struct sony_sc *sc = hid_get_drvdata(hdev);
1119
0a286ef2 1120 if (sc->quirks & SONY_LED_SUPPORT)
c5382519 1121 sony_leds_remove(hdev);
f04d5140 1122
9f323b68
SE		 1123 sony_destroy_ff(hdev);
1124
cc6e0bbb 1125 hid_hw_stop(hdev);
cc6e0bbb
JK		 1126}
1127
bd28ce00 1128static const struct hid_device_id sony_devices[] = {
816651a7
AO		 1129 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1130 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4
JK		 1131 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
1132 .driver_data = SIXAXIS_CONTROLLER_USB },
816651a7
AO		 1133 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1134 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 1135 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
1136 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 1137 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1138 .driver_data = VAIO_RDESC_CONSTANT },
f04d5140
CL		 1139 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1140 * Logitech joystick from the device descriptor. */
1141 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1142 .driver_data = BUZZ_CONTROLLER },
1143 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1144 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 1145 /* PS3 BD Remote Control */
1146 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1147 .driver_data = PS3REMOTE },
1148 /* Logitech Harmony Adapter for PS3 */
1149 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1150 .driver_data = PS3REMOTE },
0bd88dd3
FP		 1151 /* Sony Dualshock 4 controllers for PS4 */
1152 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1153 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 1154 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 1155 .driver_data = DUALSHOCK4_CONTROLLER_BT },
bd28ce00
JS		 1156 { }
1157};
1158MODULE_DEVICE_TABLE(hid, sony_devices);
1159
1160static struct hid_driver sony_driver = {
f04d5140
CL		 1161 .name = "sony",
1162 .id_table = sony_devices,
1163 .input_mapping = sony_mapping,
1164 .probe = sony_probe,
1165 .remove = sony_remove,
1166 .report_fixup = sony_report_fixup,
1167 .raw_event = sony_raw_event
bd28ce00 1168};
f425458e 1169module_hid_driver(sony_driver);
bd28ce00 1170
bd28ce00 1171MODULE_LICENSE("GPL");
Empty description
This page took 0.787451 seconds and 4 git commands to generate.