blob: 69204afea7a48384d7bda840808b5c66b0988b60 [file] [log] [blame]
Jiri Slabybd28ce02008-06-25 23:47:04 +02001/*
Jiri Kosina078328d2013-06-13 12:03:49 +02002 * HID driver for Sony / PS2 / PS3 BD devices.
Jiri Slabybd28ce02008-06-25 23:47:04 +02003 *
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
Jiri Slabybd28ce02008-06-25 23:47:04 +02007 * Copyright (c) 2008 Jiri Slaby
Jiri Kosina078328d2013-06-13 12:03:49 +02008 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
9 * Copyright (c) 2006-2013 Jiri Kosina
Colin Leitnerf04d5142013-05-27 23:41:05 +020010 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
Jiri Slabybd28ce02008-06-25 23:47:04 +020011 */
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
Frank Praznikad142b92014-02-20 11:36:00 -050020/*
21 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
Jiri Kosina078328d2013-06-13 12:03:49 +020022 * 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
Jiri Slabybd28ce02008-06-25 23:47:04 +020028#include <linux/device.h>
29#include <linux/hid.h>
30#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
Jiri Kosina40e32ee2013-05-28 11:22:09 +020032#include <linux/leds.h>
Frank Praznikd902f472014-01-27 10:17:36 -050033#include <linux/power_supply.h>
34#include <linux/spinlock.h>
Frank Praznikd2d782f2014-02-20 11:36:03 -050035#include <linux/list.h>
Frank Praznike5606232014-01-27 10:17:37 -050036#include <linux/input/mt.h>
Jiri Slabybd28ce02008-06-25 23:47:04 +020037
38#include "hid-ids.h"
39
Frank Praznik6c79c182014-01-16 21:43:03 -050040#define VAIO_RDESC_CONSTANT BIT(0)
41#define SIXAXIS_CONTROLLER_USB BIT(1)
42#define SIXAXIS_CONTROLLER_BT BIT(2)
43#define BUZZ_CONTROLLER BIT(3)
44#define PS3REMOTE BIT(4)
Frank Praznik8ab16762014-01-16 21:42:31 -050045#define DUALSHOCK4_CONTROLLER_USB BIT(5)
46#define DUALSHOCK4_CONTROLLER_BT BIT(6)
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +020047
Frank Praznikfee4e2d2014-02-18 17:22:01 -050048#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
Frank Praznik68330d82014-02-05 20:03:49 -050049#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
50 DUALSHOCK4_CONTROLLER_BT)
Frank Praznikfee4e2d2014-02-18 17:22:01 -050051#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
Frank Praznik68330d82014-02-05 20:03:49 -050052 DUALSHOCK4_CONTROLLER)
Frank Praznikfee4e2d2014-02-18 17:22:01 -050053#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
Frank Praznikc8de9db2014-02-20 11:36:01 -050054#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER)
Frank Praznik60781cf2014-01-11 15:13:15 -050055
56#define MAX_LEDS 4
Sven Eckelmann0a286ef2013-11-19 20:26:32 +010057
Simon Wood61ab44b2011-06-10 12:00:26 +020058static const u8 sixaxis_rdesc_fixup[] = {
59 0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
60 0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
61 0x03, 0x46, 0xFF, 0x03, 0x09, 0x01, 0x81, 0x02
62};
63
Mauro Carvalho Chehabe57a67d2012-12-14 20:57:34 -020064static const u8 sixaxis_rdesc_fixup2[] = {
65 0x05, 0x01, 0x09, 0x04, 0xa1, 0x01, 0xa1, 0x02,
66 0x85, 0x01, 0x75, 0x08, 0x95, 0x01, 0x15, 0x00,
67 0x26, 0xff, 0x00, 0x81, 0x03, 0x75, 0x01, 0x95,
68 0x13, 0x15, 0x00, 0x25, 0x01, 0x35, 0x00, 0x45,
69 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x13, 0x81,
70 0x02, 0x75, 0x01, 0x95, 0x0d, 0x06, 0x00, 0xff,
71 0x81, 0x03, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05,
72 0x01, 0x09, 0x01, 0xa1, 0x00, 0x75, 0x08, 0x95,
73 0x04, 0x35, 0x00, 0x46, 0xff, 0x00, 0x09, 0x30,
74 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x81, 0x02,
75 0xc0, 0x05, 0x01, 0x95, 0x13, 0x09, 0x01, 0x81,
76 0x02, 0x95, 0x0c, 0x81, 0x01, 0x75, 0x10, 0x95,
77 0x04, 0x26, 0xff, 0x03, 0x46, 0xff, 0x03, 0x09,
78 0x01, 0x81, 0x02, 0xc0, 0xa1, 0x02, 0x85, 0x02,
79 0x75, 0x08, 0x95, 0x30, 0x09, 0x01, 0xb1, 0x02,
80 0xc0, 0xa1, 0x02, 0x85, 0xee, 0x75, 0x08, 0x95,
81 0x30, 0x09, 0x01, 0xb1, 0x02, 0xc0, 0xa1, 0x02,
82 0x85, 0xef, 0x75, 0x08, 0x95, 0x30, 0x09, 0x01,
83 0xb1, 0x02, 0xc0, 0xc0,
84};
85
Frank Praznikad142b92014-02-20 11:36:00 -050086/*
87 * The default descriptor doesn't provide mapping for the accelerometers
Frank Praznik58d70272014-01-20 12:27:01 -050088 * or orientation sensors. This fixed descriptor maps the accelerometers
89 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
90 * to usage values 0x43, 0x44 and 0x45.
91 */
Frank Prazniked19d8c2014-01-16 21:43:12 -050092static u8 dualshock4_usb_rdesc[] = {
Frank Praznik58d70272014-01-20 12:27:01 -050093 0x05, 0x01, /* Usage Page (Desktop), */
94 0x09, 0x05, /* Usage (Gamepad), */
95 0xA1, 0x01, /* Collection (Application), */
96 0x85, 0x01, /* Report ID (1), */
97 0x09, 0x30, /* Usage (X), */
98 0x09, 0x31, /* Usage (Y), */
99 0x09, 0x32, /* Usage (Z), */
100 0x09, 0x35, /* Usage (Rz), */
101 0x15, 0x00, /* Logical Minimum (0), */
102 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
103 0x75, 0x08, /* Report Size (8), */
104 0x95, 0x04, /* Report Count (4), */
105 0x81, 0x02, /* Input (Variable), */
106 0x09, 0x39, /* Usage (Hat Switch), */
107 0x15, 0x00, /* Logical Minimum (0), */
108 0x25, 0x07, /* Logical Maximum (7), */
109 0x35, 0x00, /* Physical Minimum (0), */
110 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
111 0x65, 0x14, /* Unit (Degrees), */
112 0x75, 0x04, /* Report Size (4), */
113 0x95, 0x01, /* Report Count (1), */
114 0x81, 0x42, /* Input (Variable, Null State), */
115 0x65, 0x00, /* Unit, */
116 0x05, 0x09, /* Usage Page (Button), */
117 0x19, 0x01, /* Usage Minimum (01h), */
118 0x29, 0x0E, /* Usage Maximum (0Eh), */
119 0x15, 0x00, /* Logical Minimum (0), */
120 0x25, 0x01, /* Logical Maximum (1), */
121 0x75, 0x01, /* Report Size (1), */
122 0x95, 0x0E, /* Report Count (14), */
123 0x81, 0x02, /* Input (Variable), */
124 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
125 0x09, 0x20, /* Usage (20h), */
126 0x75, 0x06, /* Report Size (6), */
127 0x95, 0x01, /* Report Count (1), */
128 0x15, 0x00, /* Logical Minimum (0), */
129 0x25, 0x7F, /* Logical Maximum (127), */
130 0x81, 0x02, /* Input (Variable), */
131 0x05, 0x01, /* Usage Page (Desktop), */
132 0x09, 0x33, /* Usage (Rx), */
133 0x09, 0x34, /* Usage (Ry), */
134 0x15, 0x00, /* Logical Minimum (0), */
135 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
136 0x75, 0x08, /* Report Size (8), */
137 0x95, 0x02, /* Report Count (2), */
138 0x81, 0x02, /* Input (Variable), */
139 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
140 0x09, 0x21, /* Usage (21h), */
141 0x95, 0x03, /* Report Count (3), */
142 0x81, 0x02, /* Input (Variable), */
143 0x05, 0x01, /* Usage Page (Desktop), */
144 0x19, 0x40, /* Usage Minimum (40h), */
145 0x29, 0x42, /* Usage Maximum (42h), */
146 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
147 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
148 0x75, 0x10, /* Report Size (16), */
149 0x95, 0x03, /* Report Count (3), */
150 0x81, 0x02, /* Input (Variable), */
151 0x19, 0x43, /* Usage Minimum (43h), */
152 0x29, 0x45, /* Usage Maximum (45h), */
153 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
154 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
155 0x95, 0x03, /* Report Count (3), */
156 0x81, 0x02, /* Input (Variable), */
157 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
158 0x09, 0x21, /* Usage (21h), */
159 0x15, 0x00, /* Logical Minimum (0), */
160 0x25, 0xFF, /* Logical Maximum (255), */
161 0x75, 0x08, /* Report Size (8), */
162 0x95, 0x27, /* Report Count (39), */
163 0x81, 0x02, /* Input (Variable), */
164 0x85, 0x05, /* Report ID (5), */
165 0x09, 0x22, /* Usage (22h), */
166 0x95, 0x1F, /* Report Count (31), */
167 0x91, 0x02, /* Output (Variable), */
168 0x85, 0x04, /* Report ID (4), */
169 0x09, 0x23, /* Usage (23h), */
170 0x95, 0x24, /* Report Count (36), */
171 0xB1, 0x02, /* Feature (Variable), */
172 0x85, 0x02, /* Report ID (2), */
173 0x09, 0x24, /* Usage (24h), */
174 0x95, 0x24, /* Report Count (36), */
175 0xB1, 0x02, /* Feature (Variable), */
176 0x85, 0x08, /* Report ID (8), */
177 0x09, 0x25, /* Usage (25h), */
178 0x95, 0x03, /* Report Count (3), */
179 0xB1, 0x02, /* Feature (Variable), */
180 0x85, 0x10, /* Report ID (16), */
181 0x09, 0x26, /* Usage (26h), */
182 0x95, 0x04, /* Report Count (4), */
183 0xB1, 0x02, /* Feature (Variable), */
184 0x85, 0x11, /* Report ID (17), */
185 0x09, 0x27, /* Usage (27h), */
186 0x95, 0x02, /* Report Count (2), */
187 0xB1, 0x02, /* Feature (Variable), */
188 0x85, 0x12, /* Report ID (18), */
189 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
190 0x09, 0x21, /* Usage (21h), */
191 0x95, 0x0F, /* Report Count (15), */
192 0xB1, 0x02, /* Feature (Variable), */
193 0x85, 0x13, /* Report ID (19), */
194 0x09, 0x22, /* Usage (22h), */
195 0x95, 0x16, /* Report Count (22), */
196 0xB1, 0x02, /* Feature (Variable), */
197 0x85, 0x14, /* Report ID (20), */
198 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
199 0x09, 0x20, /* Usage (20h), */
200 0x95, 0x10, /* Report Count (16), */
201 0xB1, 0x02, /* Feature (Variable), */
202 0x85, 0x15, /* Report ID (21), */
203 0x09, 0x21, /* Usage (21h), */
204 0x95, 0x2C, /* Report Count (44), */
205 0xB1, 0x02, /* Feature (Variable), */
206 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
207 0x85, 0x80, /* Report ID (128), */
208 0x09, 0x20, /* Usage (20h), */
209 0x95, 0x06, /* Report Count (6), */
210 0xB1, 0x02, /* Feature (Variable), */
211 0x85, 0x81, /* Report ID (129), */
212 0x09, 0x21, /* Usage (21h), */
213 0x95, 0x06, /* Report Count (6), */
214 0xB1, 0x02, /* Feature (Variable), */
215 0x85, 0x82, /* Report ID (130), */
216 0x09, 0x22, /* Usage (22h), */
217 0x95, 0x05, /* Report Count (5), */
218 0xB1, 0x02, /* Feature (Variable), */
219 0x85, 0x83, /* Report ID (131), */
220 0x09, 0x23, /* Usage (23h), */
221 0x95, 0x01, /* Report Count (1), */
222 0xB1, 0x02, /* Feature (Variable), */
223 0x85, 0x84, /* Report ID (132), */
224 0x09, 0x24, /* Usage (24h), */
225 0x95, 0x04, /* Report Count (4), */
226 0xB1, 0x02, /* Feature (Variable), */
227 0x85, 0x85, /* Report ID (133), */
228 0x09, 0x25, /* Usage (25h), */
229 0x95, 0x06, /* Report Count (6), */
230 0xB1, 0x02, /* Feature (Variable), */
231 0x85, 0x86, /* Report ID (134), */
232 0x09, 0x26, /* Usage (26h), */
233 0x95, 0x06, /* Report Count (6), */
234 0xB1, 0x02, /* Feature (Variable), */
235 0x85, 0x87, /* Report ID (135), */
236 0x09, 0x27, /* Usage (27h), */
237 0x95, 0x23, /* Report Count (35), */
238 0xB1, 0x02, /* Feature (Variable), */
239 0x85, 0x88, /* Report ID (136), */
240 0x09, 0x28, /* Usage (28h), */
241 0x95, 0x22, /* Report Count (34), */
242 0xB1, 0x02, /* Feature (Variable), */
243 0x85, 0x89, /* Report ID (137), */
244 0x09, 0x29, /* Usage (29h), */
245 0x95, 0x02, /* Report Count (2), */
246 0xB1, 0x02, /* Feature (Variable), */
247 0x85, 0x90, /* Report ID (144), */
248 0x09, 0x30, /* Usage (30h), */
249 0x95, 0x05, /* Report Count (5), */
250 0xB1, 0x02, /* Feature (Variable), */
251 0x85, 0x91, /* Report ID (145), */
252 0x09, 0x31, /* Usage (31h), */
253 0x95, 0x03, /* Report Count (3), */
254 0xB1, 0x02, /* Feature (Variable), */
255 0x85, 0x92, /* Report ID (146), */
256 0x09, 0x32, /* Usage (32h), */
257 0x95, 0x03, /* Report Count (3), */
258 0xB1, 0x02, /* Feature (Variable), */
259 0x85, 0x93, /* Report ID (147), */
260 0x09, 0x33, /* Usage (33h), */
261 0x95, 0x0C, /* Report Count (12), */
262 0xB1, 0x02, /* Feature (Variable), */
263 0x85, 0xA0, /* Report ID (160), */
264 0x09, 0x40, /* Usage (40h), */
265 0x95, 0x06, /* Report Count (6), */
266 0xB1, 0x02, /* Feature (Variable), */
267 0x85, 0xA1, /* Report ID (161), */
268 0x09, 0x41, /* Usage (41h), */
269 0x95, 0x01, /* Report Count (1), */
270 0xB1, 0x02, /* Feature (Variable), */
271 0x85, 0xA2, /* Report ID (162), */
272 0x09, 0x42, /* Usage (42h), */
273 0x95, 0x01, /* Report Count (1), */
274 0xB1, 0x02, /* Feature (Variable), */
275 0x85, 0xA3, /* Report ID (163), */
276 0x09, 0x43, /* Usage (43h), */
277 0x95, 0x30, /* Report Count (48), */
278 0xB1, 0x02, /* Feature (Variable), */
279 0x85, 0xA4, /* Report ID (164), */
280 0x09, 0x44, /* Usage (44h), */
281 0x95, 0x0D, /* Report Count (13), */
282 0xB1, 0x02, /* Feature (Variable), */
283 0x85, 0xA5, /* Report ID (165), */
284 0x09, 0x45, /* Usage (45h), */
285 0x95, 0x15, /* Report Count (21), */
286 0xB1, 0x02, /* Feature (Variable), */
287 0x85, 0xA6, /* Report ID (166), */
288 0x09, 0x46, /* Usage (46h), */
289 0x95, 0x15, /* Report Count (21), */
290 0xB1, 0x02, /* Feature (Variable), */
291 0x85, 0xF0, /* Report ID (240), */
292 0x09, 0x47, /* Usage (47h), */
293 0x95, 0x3F, /* Report Count (63), */
294 0xB1, 0x02, /* Feature (Variable), */
295 0x85, 0xF1, /* Report ID (241), */
296 0x09, 0x48, /* Usage (48h), */
297 0x95, 0x3F, /* Report Count (63), */
298 0xB1, 0x02, /* Feature (Variable), */
299 0x85, 0xF2, /* Report ID (242), */
300 0x09, 0x49, /* Usage (49h), */
301 0x95, 0x0F, /* Report Count (15), */
302 0xB1, 0x02, /* Feature (Variable), */
303 0x85, 0xA7, /* Report ID (167), */
304 0x09, 0x4A, /* Usage (4Ah), */
305 0x95, 0x01, /* Report Count (1), */
306 0xB1, 0x02, /* Feature (Variable), */
307 0x85, 0xA8, /* Report ID (168), */
308 0x09, 0x4B, /* Usage (4Bh), */
309 0x95, 0x01, /* Report Count (1), */
310 0xB1, 0x02, /* Feature (Variable), */
311 0x85, 0xA9, /* Report ID (169), */
312 0x09, 0x4C, /* Usage (4Ch), */
313 0x95, 0x08, /* Report Count (8), */
314 0xB1, 0x02, /* Feature (Variable), */
315 0x85, 0xAA, /* Report ID (170), */
316 0x09, 0x4E, /* Usage (4Eh), */
317 0x95, 0x01, /* Report Count (1), */
318 0xB1, 0x02, /* Feature (Variable), */
319 0x85, 0xAB, /* Report ID (171), */
320 0x09, 0x4F, /* Usage (4Fh), */
321 0x95, 0x39, /* Report Count (57), */
322 0xB1, 0x02, /* Feature (Variable), */
323 0x85, 0xAC, /* Report ID (172), */
324 0x09, 0x50, /* Usage (50h), */
325 0x95, 0x39, /* Report Count (57), */
326 0xB1, 0x02, /* Feature (Variable), */
327 0x85, 0xAD, /* Report ID (173), */
328 0x09, 0x51, /* Usage (51h), */
329 0x95, 0x0B, /* Report Count (11), */
330 0xB1, 0x02, /* Feature (Variable), */
331 0x85, 0xAE, /* Report ID (174), */
332 0x09, 0x52, /* Usage (52h), */
333 0x95, 0x01, /* Report Count (1), */
334 0xB1, 0x02, /* Feature (Variable), */
335 0x85, 0xAF, /* Report ID (175), */
336 0x09, 0x53, /* Usage (53h), */
337 0x95, 0x02, /* Report Count (2), */
338 0xB1, 0x02, /* Feature (Variable), */
339 0x85, 0xB0, /* Report ID (176), */
340 0x09, 0x54, /* Usage (54h), */
341 0x95, 0x3F, /* Report Count (63), */
342 0xB1, 0x02, /* Feature (Variable), */
343 0xC0 /* End Collection */
Frank Prazniked19d8c2014-01-16 21:43:12 -0500344};
345
Frank Praznikad142b92014-02-20 11:36:00 -0500346/*
347 * The default behavior of the Dualshock 4 is to send reports using report
Frank Praznikd8296742014-02-05 20:03:45 -0500348 * type 1 when running over Bluetooth. However, as soon as it receives a
349 * report of type 17 to set the LEDs or rumble it starts returning it's state
350 * in report 17 instead of 1. Since report 17 is undefined in the default HID
351 * descriptor the button and axis definitions must be moved to report 17 or
352 * the HID layer won't process the received input once a report is sent.
353 */
354static u8 dualshock4_bt_rdesc[] = {
355 0x05, 0x01, /* Usage Page (Desktop), */
356 0x09, 0x05, /* Usage (Gamepad), */
357 0xA1, 0x01, /* Collection (Application), */
358 0x85, 0x01, /* Report ID (1), */
359 0x75, 0x08, /* Report Size (8), */
360 0x95, 0x0A, /* Report Count (9), */
361 0x81, 0x02, /* Input (Variable), */
362 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
363 0x85, 0x02, /* Report ID (2), */
364 0x09, 0x24, /* Usage (24h), */
365 0x95, 0x24, /* Report Count (36), */
366 0xB1, 0x02, /* Feature (Variable), */
367 0x85, 0xA3, /* Report ID (163), */
368 0x09, 0x25, /* Usage (25h), */
369 0x95, 0x30, /* Report Count (48), */
370 0xB1, 0x02, /* Feature (Variable), */
371 0x85, 0x05, /* Report ID (5), */
372 0x09, 0x26, /* Usage (26h), */
373 0x95, 0x28, /* Report Count (40), */
374 0xB1, 0x02, /* Feature (Variable), */
375 0x85, 0x06, /* Report ID (6), */
376 0x09, 0x27, /* Usage (27h), */
377 0x95, 0x34, /* Report Count (52), */
378 0xB1, 0x02, /* Feature (Variable), */
379 0x85, 0x07, /* Report ID (7), */
380 0x09, 0x28, /* Usage (28h), */
381 0x95, 0x30, /* Report Count (48), */
382 0xB1, 0x02, /* Feature (Variable), */
383 0x85, 0x08, /* Report ID (8), */
384 0x09, 0x29, /* Usage (29h), */
385 0x95, 0x2F, /* Report Count (47), */
386 0xB1, 0x02, /* Feature (Variable), */
387 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
388 0x85, 0x03, /* Report ID (3), */
389 0x09, 0x21, /* Usage (21h), */
390 0x95, 0x26, /* Report Count (38), */
391 0xB1, 0x02, /* Feature (Variable), */
392 0x85, 0x04, /* Report ID (4), */
393 0x09, 0x22, /* Usage (22h), */
394 0x95, 0x2E, /* Report Count (46), */
395 0xB1, 0x02, /* Feature (Variable), */
396 0x85, 0xF0, /* Report ID (240), */
397 0x09, 0x47, /* Usage (47h), */
398 0x95, 0x3F, /* Report Count (63), */
399 0xB1, 0x02, /* Feature (Variable), */
400 0x85, 0xF1, /* Report ID (241), */
401 0x09, 0x48, /* Usage (48h), */
402 0x95, 0x3F, /* Report Count (63), */
403 0xB1, 0x02, /* Feature (Variable), */
404 0x85, 0xF2, /* Report ID (242), */
405 0x09, 0x49, /* Usage (49h), */
406 0x95, 0x0F, /* Report Count (15), */
407 0xB1, 0x02, /* Feature (Variable), */
408 0x85, 0x11, /* Report ID (17), */
409 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
410 0x09, 0x20, /* Usage (20h), */
411 0x95, 0x02, /* Report Count (2), */
412 0x81, 0x02, /* Input (Variable), */
413 0x05, 0x01, /* Usage Page (Desktop), */
414 0x09, 0x30, /* Usage (X), */
415 0x09, 0x31, /* Usage (Y), */
416 0x09, 0x32, /* Usage (Z), */
417 0x09, 0x35, /* Usage (Rz), */
418 0x15, 0x00, /* Logical Minimum (0), */
419 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
420 0x75, 0x08, /* Report Size (8), */
421 0x95, 0x04, /* Report Count (4), */
422 0x81, 0x02, /* Input (Variable), */
423 0x09, 0x39, /* Usage (Hat Switch), */
424 0x15, 0x00, /* Logical Minimum (0), */
425 0x25, 0x07, /* Logical Maximum (7), */
426 0x75, 0x04, /* Report Size (4), */
427 0x95, 0x01, /* Report Count (1), */
428 0x81, 0x42, /* Input (Variable, Null State), */
429 0x05, 0x09, /* Usage Page (Button), */
430 0x19, 0x01, /* Usage Minimum (01h), */
431 0x29, 0x0E, /* Usage Maximum (0Eh), */
432 0x15, 0x00, /* Logical Minimum (0), */
433 0x25, 0x01, /* Logical Maximum (1), */
434 0x75, 0x01, /* Report Size (1), */
435 0x95, 0x0E, /* Report Count (14), */
436 0x81, 0x02, /* Input (Variable), */
437 0x75, 0x06, /* Report Size (6), */
438 0x95, 0x01, /* Report Count (1), */
439 0x81, 0x01, /* Input (Constant), */
440 0x05, 0x01, /* Usage Page (Desktop), */
441 0x09, 0x33, /* Usage (Rx), */
442 0x09, 0x34, /* Usage (Ry), */
443 0x15, 0x00, /* Logical Minimum (0), */
444 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
445 0x75, 0x08, /* Report Size (8), */
446 0x95, 0x02, /* Report Count (2), */
447 0x81, 0x02, /* Input (Variable), */
448 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
449 0x09, 0x20, /* Usage (20h), */
450 0x95, 0x03, /* Report Count (3), */
451 0x81, 0x02, /* Input (Variable), */
452 0x05, 0x01, /* Usage Page (Desktop), */
453 0x19, 0x40, /* Usage Minimum (40h), */
454 0x29, 0x42, /* Usage Maximum (42h), */
455 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
456 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
457 0x75, 0x10, /* Report Size (16), */
458 0x95, 0x03, /* Report Count (3), */
459 0x81, 0x02, /* Input (Variable), */
460 0x19, 0x43, /* Usage Minimum (43h), */
461 0x29, 0x45, /* Usage Maximum (45h), */
462 0x16, 0xFF, 0xBF, /* Logical Minimum (-16385), */
463 0x26, 0x00, 0x40, /* Logical Maximum (16384), */
464 0x95, 0x03, /* Report Count (3), */
465 0x81, 0x02, /* Input (Variable), */
466 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
467 0x09, 0x20, /* Usage (20h), */
468 0x15, 0x00, /* Logical Minimum (0), */
469 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
470 0x75, 0x08, /* Report Size (8), */
471 0x95, 0x31, /* Report Count (51), */
472 0x81, 0x02, /* Input (Variable), */
473 0x09, 0x21, /* Usage (21h), */
474 0x75, 0x08, /* Report Size (8), */
475 0x95, 0x4D, /* Report Count (77), */
476 0x91, 0x02, /* Output (Variable), */
477 0x85, 0x12, /* Report ID (18), */
478 0x09, 0x22, /* Usage (22h), */
479 0x95, 0x8D, /* Report Count (141), */
480 0x81, 0x02, /* Input (Variable), */
481 0x09, 0x23, /* Usage (23h), */
482 0x91, 0x02, /* Output (Variable), */
483 0x85, 0x13, /* Report ID (19), */
484 0x09, 0x24, /* Usage (24h), */
485 0x95, 0xCD, /* Report Count (205), */
486 0x81, 0x02, /* Input (Variable), */
487 0x09, 0x25, /* Usage (25h), */
488 0x91, 0x02, /* Output (Variable), */
489 0x85, 0x14, /* Report ID (20), */
490 0x09, 0x26, /* Usage (26h), */
491 0x96, 0x0D, 0x01, /* Report Count (269), */
492 0x81, 0x02, /* Input (Variable), */
493 0x09, 0x27, /* Usage (27h), */
494 0x91, 0x02, /* Output (Variable), */
495 0x85, 0x15, /* Report ID (21), */
496 0x09, 0x28, /* Usage (28h), */
497 0x96, 0x4D, 0x01, /* Report Count (333), */
498 0x81, 0x02, /* Input (Variable), */
499 0x09, 0x29, /* Usage (29h), */
500 0x91, 0x02, /* Output (Variable), */
501 0x85, 0x16, /* Report ID (22), */
502 0x09, 0x2A, /* Usage (2Ah), */
503 0x96, 0x8D, 0x01, /* Report Count (397), */
504 0x81, 0x02, /* Input (Variable), */
505 0x09, 0x2B, /* Usage (2Bh), */
506 0x91, 0x02, /* Output (Variable), */
507 0x85, 0x17, /* Report ID (23), */
508 0x09, 0x2C, /* Usage (2Ch), */
509 0x96, 0xCD, 0x01, /* Report Count (461), */
510 0x81, 0x02, /* Input (Variable), */
511 0x09, 0x2D, /* Usage (2Dh), */
512 0x91, 0x02, /* Output (Variable), */
513 0x85, 0x18, /* Report ID (24), */
514 0x09, 0x2E, /* Usage (2Eh), */
515 0x96, 0x0D, 0x02, /* Report Count (525), */
516 0x81, 0x02, /* Input (Variable), */
517 0x09, 0x2F, /* Usage (2Fh), */
518 0x91, 0x02, /* Output (Variable), */
519 0x85, 0x19, /* Report ID (25), */
520 0x09, 0x30, /* Usage (30h), */
521 0x96, 0x22, 0x02, /* Report Count (546), */
522 0x81, 0x02, /* Input (Variable), */
523 0x09, 0x31, /* Usage (31h), */
524 0x91, 0x02, /* Output (Variable), */
525 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
526 0x85, 0x82, /* Report ID (130), */
527 0x09, 0x22, /* Usage (22h), */
528 0x95, 0x3F, /* Report Count (63), */
529 0xB1, 0x02, /* Feature (Variable), */
530 0x85, 0x83, /* Report ID (131), */
531 0x09, 0x23, /* Usage (23h), */
532 0xB1, 0x02, /* Feature (Variable), */
533 0x85, 0x84, /* Report ID (132), */
534 0x09, 0x24, /* Usage (24h), */
535 0xB1, 0x02, /* Feature (Variable), */
536 0x85, 0x90, /* Report ID (144), */
537 0x09, 0x30, /* Usage (30h), */
538 0xB1, 0x02, /* Feature (Variable), */
539 0x85, 0x91, /* Report ID (145), */
540 0x09, 0x31, /* Usage (31h), */
541 0xB1, 0x02, /* Feature (Variable), */
542 0x85, 0x92, /* Report ID (146), */
543 0x09, 0x32, /* Usage (32h), */
544 0xB1, 0x02, /* Feature (Variable), */
545 0x85, 0x93, /* Report ID (147), */
546 0x09, 0x33, /* Usage (33h), */
547 0xB1, 0x02, /* Feature (Variable), */
548 0x85, 0xA0, /* Report ID (160), */
549 0x09, 0x40, /* Usage (40h), */
550 0xB1, 0x02, /* Feature (Variable), */
551 0x85, 0xA4, /* Report ID (164), */
552 0x09, 0x44, /* Usage (44h), */
553 0xB1, 0x02, /* Feature (Variable), */
554 0xC0 /* End Collection */
555};
556
Jiri Kosina078328d2013-06-13 12:03:49 +0200557static __u8 ps3remote_rdesc[] = {
558 0x05, 0x01, /* GUsagePage Generic Desktop */
559 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
560 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
561
562 /* Use collection 1 for joypad buttons */
563 0xA1, 0x02, /* MCollection Logical (interrelated data) */
564
565 /* Ignore the 1st byte, maybe it is used for a controller
566 * number but it's not needed for correct operation */
567 0x75, 0x08, /* GReportSize 0x08 [8] */
568 0x95, 0x01, /* GReportCount 0x01 [1] */
569 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
570
571 /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
572 * buttons multiple keypresses are allowed */
573 0x05, 0x09, /* GUsagePage Button */
574 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
575 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
576 0x14, /* GLogicalMinimum [0] */
577 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
578 0x75, 0x01, /* GReportSize 0x01 [1] */
579 0x95, 0x18, /* GReportCount 0x18 [24] */
580 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
581
582 0xC0, /* MEndCollection */
583
584 /* Use collection 2 for remote control buttons */
585 0xA1, 0x02, /* MCollection Logical (interrelated data) */
586
587 /* 5th byte is used for remote control buttons */
588 0x05, 0x09, /* GUsagePage Button */
589 0x18, /* LUsageMinimum [No button pressed] */
590 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
591 0x14, /* GLogicalMinimum [0] */
592 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
593 0x75, 0x08, /* GReportSize 0x08 [8] */
594 0x95, 0x01, /* GReportCount 0x01 [1] */
595 0x80, /* MInput */
596
597 /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
598 * 0xff and 11th is for press indication */
599 0x75, 0x08, /* GReportSize 0x08 [8] */
600 0x95, 0x06, /* GReportCount 0x06 [6] */
601 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
602
603 /* 12th byte is for battery strength */
604 0x05, 0x06, /* GUsagePage Generic Device Controls */
605 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
606 0x14, /* GLogicalMinimum [0] */
607 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
608 0x75, 0x08, /* GReportSize 0x08 [8] */
609 0x95, 0x01, /* GReportCount 0x01 [1] */
610 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
611
612 0xC0, /* MEndCollection */
613
614 0xC0 /* MEndCollection [Game Pad] */
615};
616
617static const unsigned int ps3remote_keymap_joypad_buttons[] = {
618 [0x01] = KEY_SELECT,
619 [0x02] = BTN_THUMBL, /* L3 */
620 [0x03] = BTN_THUMBR, /* R3 */
621 [0x04] = BTN_START,
622 [0x05] = KEY_UP,
623 [0x06] = KEY_RIGHT,
624 [0x07] = KEY_DOWN,
625 [0x08] = KEY_LEFT,
626 [0x09] = BTN_TL2, /* L2 */
627 [0x0a] = BTN_TR2, /* R2 */
628 [0x0b] = BTN_TL, /* L1 */
629 [0x0c] = BTN_TR, /* R1 */
630 [0x0d] = KEY_OPTION, /* options/triangle */
631 [0x0e] = KEY_BACK, /* back/circle */
632 [0x0f] = BTN_0, /* cross */
633 [0x10] = KEY_SCREEN, /* view/square */
634 [0x11] = KEY_HOMEPAGE, /* PS button */
635 [0x14] = KEY_ENTER,
636};
637static const unsigned int ps3remote_keymap_remote_buttons[] = {
638 [0x00] = KEY_1,
639 [0x01] = KEY_2,
640 [0x02] = KEY_3,
641 [0x03] = KEY_4,
642 [0x04] = KEY_5,
643 [0x05] = KEY_6,
644 [0x06] = KEY_7,
645 [0x07] = KEY_8,
646 [0x08] = KEY_9,
647 [0x09] = KEY_0,
648 [0x0e] = KEY_ESC, /* return */
649 [0x0f] = KEY_CLEAR,
650 [0x16] = KEY_EJECTCD,
651 [0x1a] = KEY_MENU, /* top menu */
652 [0x28] = KEY_TIME,
653 [0x30] = KEY_PREVIOUS,
654 [0x31] = KEY_NEXT,
655 [0x32] = KEY_PLAY,
656 [0x33] = KEY_REWIND, /* scan back */
657 [0x34] = KEY_FORWARD, /* scan forward */
658 [0x38] = KEY_STOP,
659 [0x39] = KEY_PAUSE,
660 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
661 [0x60] = KEY_FRAMEBACK, /* slow/step back */
662 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
663 [0x63] = KEY_SUBTITLE,
664 [0x64] = KEY_AUDIO,
665 [0x65] = KEY_ANGLE,
666 [0x70] = KEY_INFO, /* display */
667 [0x80] = KEY_BLUE,
668 [0x81] = KEY_RED,
669 [0x82] = KEY_GREEN,
670 [0x83] = KEY_YELLOW,
671};
672
Colin Leitnerf04d5142013-05-27 23:41:05 +0200673static const unsigned int buzz_keymap[] = {
Frank Praznikad142b92014-02-20 11:36:00 -0500674 /*
675 * The controller has 4 remote buzzers, each with one LED and 5
Colin Leitnerf04d5142013-05-27 23:41:05 +0200676 * buttons.
677 *
678 * We use the mapping chosen by the controller, which is:
679 *
680 * Key Offset
681 * -------------------
682 * Buzz 1
683 * Blue 5
684 * Orange 4
685 * Green 3
686 * Yellow 2
687 *
688 * So, for example, the orange button on the third buzzer is mapped to
689 * BTN_TRIGGER_HAPPY14
690 */
691 [ 1] = BTN_TRIGGER_HAPPY1,
692 [ 2] = BTN_TRIGGER_HAPPY2,
693 [ 3] = BTN_TRIGGER_HAPPY3,
694 [ 4] = BTN_TRIGGER_HAPPY4,
695 [ 5] = BTN_TRIGGER_HAPPY5,
696 [ 6] = BTN_TRIGGER_HAPPY6,
697 [ 7] = BTN_TRIGGER_HAPPY7,
698 [ 8] = BTN_TRIGGER_HAPPY8,
699 [ 9] = BTN_TRIGGER_HAPPY9,
700 [10] = BTN_TRIGGER_HAPPY10,
701 [11] = BTN_TRIGGER_HAPPY11,
702 [12] = BTN_TRIGGER_HAPPY12,
703 [13] = BTN_TRIGGER_HAPPY13,
704 [14] = BTN_TRIGGER_HAPPY14,
705 [15] = BTN_TRIGGER_HAPPY15,
706 [16] = BTN_TRIGGER_HAPPY16,
707 [17] = BTN_TRIGGER_HAPPY17,
708 [18] = BTN_TRIGGER_HAPPY18,
709 [19] = BTN_TRIGGER_HAPPY19,
710 [20] = BTN_TRIGGER_HAPPY20,
711};
712
Frank Praznikd902f472014-01-27 10:17:36 -0500713static enum power_supply_property sony_battery_props[] = {
714 POWER_SUPPLY_PROP_PRESENT,
715 POWER_SUPPLY_PROP_CAPACITY,
716 POWER_SUPPLY_PROP_SCOPE,
717 POWER_SUPPLY_PROP_STATUS,
718};
719
Frank Praznikd2d782f2014-02-20 11:36:03 -0500720static spinlock_t sony_dev_list_lock;
721static LIST_HEAD(sony_device_list);
722
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200723struct sony_sc {
Frank Praznikd902f472014-01-27 10:17:36 -0500724 spinlock_t lock;
Frank Praznikd2d782f2014-02-20 11:36:03 -0500725 struct list_head list_node;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +0100726 struct hid_device *hdev;
Frank Praznik60781cf2014-01-11 15:13:15 -0500727 struct led_classdev *leds[MAX_LEDS];
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200728 unsigned long quirks;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +0100729 struct work_struct state_worker;
Frank Praznikd902f472014-01-27 10:17:36 -0500730 struct power_supply battery;
Colin Leitnerf04d5142013-05-27 23:41:05 +0200731
Sven Eckelmann9f323b62013-11-17 20:38:21 +0100732#ifdef CONFIG_SONY_FF
Sven Eckelmann9f323b62013-11-17 20:38:21 +0100733 __u8 left;
734 __u8 right;
735#endif
736
Frank Praznikd2d782f2014-02-20 11:36:03 -0500737 __u8 mac_address[6];
Frank Praznik5f5750d2014-02-19 13:09:22 -0500738 __u8 worker_initialized;
Frank Praznikd902f472014-01-27 10:17:36 -0500739 __u8 cable_state;
740 __u8 battery_charging;
741 __u8 battery_capacity;
Frank Praznik60781cf2014-01-11 15:13:15 -0500742 __u8 led_state[MAX_LEDS];
743 __u8 led_count;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200744};
745
Jiri Kosina078328d2013-06-13 12:03:49 +0200746static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
747 unsigned int *rsize)
748{
749 *rsize = sizeof(ps3remote_rdesc);
750 return ps3remote_rdesc;
751}
752
753static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
754 struct hid_field *field, struct hid_usage *usage,
755 unsigned long **bit, int *max)
756{
757 unsigned int key = usage->hid & HID_USAGE;
758
759 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
760 return -1;
761
762 switch (usage->collection_index) {
763 case 1:
764 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
765 return -1;
766
767 key = ps3remote_keymap_joypad_buttons[key];
768 if (!key)
769 return -1;
770 break;
771 case 2:
772 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
773 return -1;
774
775 key = ps3remote_keymap_remote_buttons[key];
776 if (!key)
777 return -1;
778 break;
779 default:
780 return -1;
781 }
782
783 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
784 return 1;
785}
786
787
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200788/* Sony Vaio VGX has wrongly mouse pointer declared as constant */
Nikolai Kondrashov73e40082010-08-06 23:03:06 +0400789static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
790 unsigned int *rsize)
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200791{
792 struct sony_sc *sc = hid_get_drvdata(hdev);
793
Fernando Luis Vázquez Cao99d24902013-01-22 15:20:38 +0900794 /*
795 * Some Sony RF receivers wrongly declare the mouse pointer as a
796 * a constant non-data variable.
797 */
798 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
799 /* usage page: generic desktop controls */
800 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
801 /* usage: mouse */
802 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
803 /* input (usage page for x,y axes): constant, variable, relative */
804 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
Fernando Luis Vázquez Caoa46491842013-01-15 19:40:48 +0900805 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
Fernando Luis Vázquez Cao99d24902013-01-22 15:20:38 +0900806 /* input: data, variable, relative */
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200807 rdesc[55] = 0x06;
808 }
Simon Wood61ab44b2011-06-10 12:00:26 +0200809
Frank Prazniked19d8c2014-01-16 21:43:12 -0500810 /*
811 * The default Dualshock 4 USB descriptor doesn't assign
812 * the gyroscope values to corresponding axes so we need a
813 * modified one.
814 */
815 if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && *rsize == 467) {
816 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
817 rdesc = dualshock4_usb_rdesc;
818 *rsize = sizeof(dualshock4_usb_rdesc);
Frank Praznikd8296742014-02-05 20:03:45 -0500819 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && *rsize == 357) {
820 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
821 rdesc = dualshock4_bt_rdesc;
822 *rsize = sizeof(dualshock4_bt_rdesc);
Frank Prazniked19d8c2014-01-16 21:43:12 -0500823 }
824
Simon Wood61ab44b2011-06-10 12:00:26 +0200825 /* The HID descriptor exposed over BT has a trailing zero byte */
826 if ((((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize == 148) ||
827 ((sc->quirks & SIXAXIS_CONTROLLER_BT) && *rsize == 149)) &&
828 rdesc[83] == 0x75) {
829 hid_info(hdev, "Fixing up Sony Sixaxis report descriptor\n");
830 memcpy((void *)&rdesc[83], (void *)&sixaxis_rdesc_fixup,
831 sizeof(sixaxis_rdesc_fixup));
Mauro Carvalho Chehabe57a67d2012-12-14 20:57:34 -0200832 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB &&
833 *rsize > sizeof(sixaxis_rdesc_fixup2)) {
834 hid_info(hdev, "Sony Sixaxis clone detected. Using original report descriptor (size: %d clone; %d new)\n",
835 *rsize, (int)sizeof(sixaxis_rdesc_fixup2));
836 *rsize = sizeof(sixaxis_rdesc_fixup2);
837 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
Simon Wood61ab44b2011-06-10 12:00:26 +0200838 }
Jiri Kosina078328d2013-06-13 12:03:49 +0200839
840 if (sc->quirks & PS3REMOTE)
841 return ps3remote_fixup(hdev, rdesc, rsize);
842
Nikolai Kondrashov73e40082010-08-06 23:03:06 +0400843 return rdesc;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200844}
845
Frank Praznikd902f472014-01-27 10:17:36 -0500846static void sixaxis_parse_report(struct sony_sc *sc, __u8 *rd, int size)
847{
848 static const __u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
849 unsigned long flags;
850 __u8 cable_state, battery_capacity, battery_charging;
851
Frank Praznikad142b92014-02-20 11:36:00 -0500852 /*
853 * The sixaxis is charging if the battery value is 0xee
Frank Praznikd902f472014-01-27 10:17:36 -0500854 * and it is fully charged if the value is 0xef.
855 * It does not report the actual level while charging so it
856 * is set to 100% while charging is in progress.
857 */
858 if (rd[30] >= 0xee) {
859 battery_capacity = 100;
Frank Praznika43e94a2014-02-15 13:35:42 -0500860 battery_charging = !(rd[30] & 0x01);
Frank Praznikd902f472014-01-27 10:17:36 -0500861 } else {
Frank Praznikac3c9a92014-02-20 11:36:02 -0500862 __u8 index = rd[30] <= 5 ? rd[30] : 5;
863 battery_capacity = sixaxis_battery_capacity[index];
Frank Praznikd902f472014-01-27 10:17:36 -0500864 battery_charging = 0;
865 }
Frank Praznik914c5782014-03-15 09:41:15 -0400866 cable_state = !(rd[31] & 0x04);
Frank Praznikd902f472014-01-27 10:17:36 -0500867
868 spin_lock_irqsave(&sc->lock, flags);
869 sc->cable_state = cable_state;
870 sc->battery_capacity = battery_capacity;
871 sc->battery_charging = battery_charging;
872 spin_unlock_irqrestore(&sc->lock, flags);
873}
874
875static void dualshock4_parse_report(struct sony_sc *sc, __u8 *rd, int size)
876{
Frank Praznike5606232014-01-27 10:17:37 -0500877 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
878 struct hid_input, list);
879 struct input_dev *input_dev = hidinput->input;
Frank Praznikd902f472014-01-27 10:17:36 -0500880 unsigned long flags;
Frank Praznik6c5f8602014-02-05 20:03:47 -0500881 int n, offset;
Frank Praznikd902f472014-01-27 10:17:36 -0500882 __u8 cable_state, battery_capacity, battery_charging;
883
Frank Praznikad142b92014-02-20 11:36:00 -0500884 /*
885 * Battery and touchpad data starts at byte 30 in the USB report and
Frank Praznik6c5f8602014-02-05 20:03:47 -0500886 * 32 in Bluetooth report.
887 */
888 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
889
Frank Praznikad142b92014-02-20 11:36:00 -0500890 /*
891 * The lower 4 bits of byte 30 contain the battery level
Frank Praznikd902f472014-01-27 10:17:36 -0500892 * and the 5th bit contains the USB cable state.
893 */
Frank Praznik6c5f8602014-02-05 20:03:47 -0500894 cable_state = (rd[offset] >> 4) & 0x01;
895 battery_capacity = rd[offset] & 0x0F;
Frank Praznikd902f472014-01-27 10:17:36 -0500896
Frank Praznikad142b92014-02-20 11:36:00 -0500897 /*
898 * When a USB power source is connected the battery level ranges from
Frank Praznik6c5f8602014-02-05 20:03:47 -0500899 * 0 to 10, and when running on battery power it ranges from 0 to 9.
900 * A battery level above 10 when plugged in means charge completed.
Frank Praznikd902f472014-01-27 10:17:36 -0500901 */
Frank Praznik6c5f8602014-02-05 20:03:47 -0500902 if (!cable_state || battery_capacity > 10)
Frank Praznikd902f472014-01-27 10:17:36 -0500903 battery_charging = 0;
904 else
905 battery_charging = 1;
906
Frank Praznik6c5f8602014-02-05 20:03:47 -0500907 if (!cable_state)
908 battery_capacity++;
Frank Praznikd902f472014-01-27 10:17:36 -0500909 if (battery_capacity > 10)
Frank Praznik6c5f8602014-02-05 20:03:47 -0500910 battery_capacity = 10;
911
Frank Praznikd902f472014-01-27 10:17:36 -0500912 battery_capacity *= 10;
913
914 spin_lock_irqsave(&sc->lock, flags);
915 sc->cable_state = cable_state;
916 sc->battery_capacity = battery_capacity;
917 sc->battery_charging = battery_charging;
918 spin_unlock_irqrestore(&sc->lock, flags);
Frank Praznike5606232014-01-27 10:17:37 -0500919
Frank Praznik6c5f8602014-02-05 20:03:47 -0500920 offset += 5;
921
Frank Praznikad142b92014-02-20 11:36:00 -0500922 /*
923 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
Frank Praznik6c5f8602014-02-05 20:03:47 -0500924 * and 37 on Bluetooth.
Frank Praznike5606232014-01-27 10:17:37 -0500925 * The first 7 bits of the first byte is a counter and bit 8 is a touch
926 * indicator that is 0 when pressed and 1 when not pressed.
927 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
928 * The data for the second touch is in the same format and immediatly
929 * follows the data for the first.
930 */
931 for (n = 0; n < 2; n++) {
932 __u16 x, y;
933
934 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
935 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
936
937 input_mt_slot(input_dev, n);
938 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
939 !(rd[offset] >> 7));
940 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
941 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
942
943 offset += 4;
944 }
Frank Praznikd902f472014-01-27 10:17:36 -0500945}
946
Simon Woodc9e4d872011-06-10 12:00:27 +0200947static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
948 __u8 *rd, int size)
949{
950 struct sony_sc *sc = hid_get_drvdata(hdev);
951
Frank Praznikad142b92014-02-20 11:36:00 -0500952 /*
953 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
Simon Woodc9e4d872011-06-10 12:00:27 +0200954 * has to be BYTE_SWAPPED before passing up to joystick interface
955 */
Frank Praznikfee4e2d2014-02-18 17:22:01 -0500956 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
Simon Woodc9e4d872011-06-10 12:00:27 +0200957 swap(rd[41], rd[42]);
958 swap(rd[43], rd[44]);
959 swap(rd[45], rd[46]);
960 swap(rd[47], rd[48]);
Frank Praznikd902f472014-01-27 10:17:36 -0500961
962 sixaxis_parse_report(sc, rd, size);
Frank Praznik68330d82014-02-05 20:03:49 -0500963 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
964 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
965 && rd[0] == 0x11 && size == 78)) {
Frank Praznikd902f472014-01-27 10:17:36 -0500966 dualshock4_parse_report(sc, rd, size);
Simon Woodc9e4d872011-06-10 12:00:27 +0200967 }
968
969 return 0;
970}
971
Colin Leitnerf04d5142013-05-27 23:41:05 +0200972static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
973 struct hid_field *field, struct hid_usage *usage,
974 unsigned long **bit, int *max)
975{
976 struct sony_sc *sc = hid_get_drvdata(hdev);
977
978 if (sc->quirks & BUZZ_CONTROLLER) {
979 unsigned int key = usage->hid & HID_USAGE;
980
981 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
982 return -1;
983
984 switch (usage->collection_index) {
985 case 1:
986 if (key >= ARRAY_SIZE(buzz_keymap))
987 return -1;
988
989 key = buzz_keymap[key];
990 if (!key)
991 return -1;
992 break;
993 default:
994 return -1;
995 }
996
997 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
998 return 1;
999 }
1000
Jiri Kosina078328d2013-06-13 12:03:49 +02001001 if (sc->quirks & PS3REMOTE)
1002 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1003
Benjamin Tissoires6f498012013-07-24 16:53:07 +02001004 /* Let hid-core decide for the others */
1005 return 0;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001006}
1007
Antonio Ospite5710fab2011-02-20 18:26:45 +01001008/*
Jiri Slabybd28ce02008-06-25 23:47:04 +02001009 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1010 * to "operational". Without this, the ps3 controller will not report any
1011 * events.
1012 */
Antonio Ospite816651a2010-05-03 22:15:55 +02001013static int sixaxis_set_operational_usb(struct hid_device *hdev)
Jiri Slabybd28ce02008-06-25 23:47:04 +02001014{
Jiri Slabybd28ce02008-06-25 23:47:04 +02001015 int ret;
1016 char *buf = kmalloc(18, GFP_KERNEL);
1017
1018 if (!buf)
1019 return -ENOMEM;
1020
Benjamin Tissoirescafebc02014-02-05 16:33:22 -05001021 ret = hid_hw_raw_request(hdev, 0xf2, buf, 17, HID_FEATURE_REPORT,
1022 HID_REQ_GET_REPORT);
Benjamin Tissoiresf204828a2013-09-11 22:12:25 +02001023
Jiri Slabybd28ce02008-06-25 23:47:04 +02001024 if (ret < 0)
Joe Perches4291ee32010-12-09 19:29:03 -08001025 hid_err(hdev, "can't set operational mode\n");
Jiri Slabybd28ce02008-06-25 23:47:04 +02001026
1027 kfree(buf);
1028
1029 return ret;
1030}
1031
Antonio Ospite816651a2010-05-03 22:15:55 +02001032static int sixaxis_set_operational_bt(struct hid_device *hdev)
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00001033{
Antonio Ospitefddb33f2010-05-03 17:19:03 +02001034 unsigned char buf[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
Benjamin Tissoiresb0dd72a2014-02-10 12:58:54 -05001035 return hid_hw_raw_request(hdev, buf[0], buf, sizeof(buf),
1036 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00001037}
1038
Frank Praznikad142b92014-02-20 11:36:00 -05001039/*
1040 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
Frank Praznik68330d82014-02-05 20:03:49 -05001041 * controller so that it sends full input reports of type 0x11.
1042 */
1043static int dualshock4_set_operational_bt(struct hid_device *hdev)
1044{
1045 __u8 buf[37] = { 0 };
1046
1047 return hid_hw_raw_request(hdev, 0x02, buf, sizeof(buf),
1048 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001049}
1050
Frank Praznik60781cf2014-01-11 15:13:15 -05001051static void buzz_set_leds(struct hid_device *hdev, const __u8 *leds)
Colin Leitnerf04d5142013-05-27 23:41:05 +02001052{
1053 struct list_head *report_list =
1054 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1055 struct hid_report *report = list_entry(report_list->next,
1056 struct hid_report, list);
1057 __s32 *value = report->field[0]->value;
1058
1059 value[0] = 0x00;
Frank Praznik60781cf2014-01-11 15:13:15 -05001060 value[1] = leds[0] ? 0xff : 0x00;
1061 value[2] = leds[1] ? 0xff : 0x00;
1062 value[3] = leds[2] ? 0xff : 0x00;
1063 value[4] = leds[3] ? 0xff : 0x00;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001064 value[5] = 0x00;
1065 value[6] = 0x00;
1066 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1067}
1068
Frank Praznik60781cf2014-01-11 15:13:15 -05001069static void sony_set_leds(struct hid_device *hdev, const __u8 *leds, int count)
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001070{
1071 struct sony_sc *drv_data = hid_get_drvdata(hdev);
Frank Praznik60781cf2014-01-11 15:13:15 -05001072 int n;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001073
Frank Praznik60781cf2014-01-11 15:13:15 -05001074 BUG_ON(count > MAX_LEDS);
1075
1076 if (drv_data->quirks & BUZZ_CONTROLLER && count == 4) {
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001077 buzz_set_leds(hdev, leds);
Frank Praznikfee4e2d2014-02-18 17:22:01 -05001078 } else {
Frank Praznik60781cf2014-01-11 15:13:15 -05001079 for (n = 0; n < count; n++)
1080 drv_data->led_state[n] = leds[n];
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001081 schedule_work(&drv_data->state_worker);
1082 }
1083}
1084
Sven Eckelmannc5382512013-11-19 20:26:30 +01001085static void sony_led_set_brightness(struct led_classdev *led,
Colin Leitnerf04d5142013-05-27 23:41:05 +02001086 enum led_brightness value)
1087{
1088 struct device *dev = led->dev->parent;
1089 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1090 struct sony_sc *drv_data;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001091
1092 int n;
1093
1094 drv_data = hid_get_drvdata(hdev);
Sven Eckelmann2251b852013-11-19 20:26:31 +01001095 if (!drv_data) {
Colin Leitnerf04d5142013-05-27 23:41:05 +02001096 hid_err(hdev, "No device data\n");
1097 return;
1098 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02001099
Frank Praznik60781cf2014-01-11 15:13:15 -05001100 for (n = 0; n < drv_data->led_count; n++) {
Sven Eckelmann2251b852013-11-19 20:26:31 +01001101 if (led == drv_data->leds[n]) {
Frank Praznik60781cf2014-01-11 15:13:15 -05001102 if (value != drv_data->led_state[n]) {
1103 drv_data->led_state[n] = value;
1104 sony_set_leds(hdev, drv_data->led_state, drv_data->led_count);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001105 }
1106 break;
1107 }
1108 }
1109}
1110
Sven Eckelmannc5382512013-11-19 20:26:30 +01001111static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
Colin Leitnerf04d5142013-05-27 23:41:05 +02001112{
1113 struct device *dev = led->dev->parent;
1114 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1115 struct sony_sc *drv_data;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001116
1117 int n;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001118
1119 drv_data = hid_get_drvdata(hdev);
Sven Eckelmann2251b852013-11-19 20:26:31 +01001120 if (!drv_data) {
Colin Leitnerf04d5142013-05-27 23:41:05 +02001121 hid_err(hdev, "No device data\n");
1122 return LED_OFF;
1123 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02001124
Frank Praznik60781cf2014-01-11 15:13:15 -05001125 for (n = 0; n < drv_data->led_count; n++) {
Simon Wood7db75042014-02-05 12:34:18 -07001126 if (led == drv_data->leds[n])
1127 return drv_data->led_state[n];
Colin Leitnerf04d5142013-05-27 23:41:05 +02001128 }
1129
Simon Wood7db75042014-02-05 12:34:18 -07001130 return LED_OFF;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001131}
Colin Leitnerf04d5142013-05-27 23:41:05 +02001132
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001133static void sony_leds_remove(struct hid_device *hdev)
1134{
1135 struct sony_sc *drv_data;
1136 struct led_classdev *led;
1137 int n;
1138
1139 drv_data = hid_get_drvdata(hdev);
1140 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
1141
Frank Praznik60781cf2014-01-11 15:13:15 -05001142 for (n = 0; n < drv_data->led_count; n++) {
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001143 led = drv_data->leds[n];
1144 drv_data->leds[n] = NULL;
1145 if (!led)
1146 continue;
1147 led_classdev_unregister(led);
1148 kfree(led);
1149 }
Frank Praznik60781cf2014-01-11 15:13:15 -05001150
1151 drv_data->led_count = 0;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001152}
1153
Sven Eckelmannc5382512013-11-19 20:26:30 +01001154static int sony_leds_init(struct hid_device *hdev)
Colin Leitnerf04d5142013-05-27 23:41:05 +02001155{
1156 struct sony_sc *drv_data;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001157 int n, ret = 0;
Frank Praznik60781cf2014-01-11 15:13:15 -05001158 int max_brightness;
Frank Praznik61ebca92014-01-20 12:27:02 -05001159 int use_colors;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001160 struct led_classdev *led;
1161 size_t name_sz;
1162 char *name;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001163 size_t name_len;
1164 const char *name_fmt;
Frank Praznik61ebca92014-01-20 12:27:02 -05001165 static const char * const color_str[] = { "red", "green", "blue" };
Frank Praznik60781cf2014-01-11 15:13:15 -05001166 static const __u8 initial_values[MAX_LEDS] = { 0x00, 0x00, 0x00, 0x00 };
Colin Leitnerf04d5142013-05-27 23:41:05 +02001167
1168 drv_data = hid_get_drvdata(hdev);
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001169 BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));
Colin Leitnerf04d5142013-05-27 23:41:05 +02001170
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001171 if (drv_data->quirks & BUZZ_CONTROLLER) {
Frank Praznik61ebca92014-01-20 12:27:02 -05001172 drv_data->led_count = 4;
1173 max_brightness = 1;
1174 use_colors = 0;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001175 name_len = strlen("::buzz#");
1176 name_fmt = "%s::buzz%d";
1177 /* Validate expected report characteristics. */
1178 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1179 return -ENODEV;
Frank Praznik68330d82014-02-05 20:03:49 -05001180 } else if (drv_data->quirks & DUALSHOCK4_CONTROLLER) {
Frank Praznik60781cf2014-01-11 15:13:15 -05001181 drv_data->led_count = 3;
1182 max_brightness = 255;
Frank Praznik61ebca92014-01-20 12:27:02 -05001183 use_colors = 1;
1184 name_len = 0;
1185 name_fmt = "%s:%s";
Frank Praznik60781cf2014-01-11 15:13:15 -05001186 } else {
1187 drv_data->led_count = 4;
1188 max_brightness = 1;
Frank Praznik61ebca92014-01-20 12:27:02 -05001189 use_colors = 0;
1190 name_len = strlen("::sony#");
1191 name_fmt = "%s::sony%d";
Frank Praznik60781cf2014-01-11 15:13:15 -05001192 }
1193
Frank Praznikad142b92014-02-20 11:36:00 -05001194 /*
1195 * Clear LEDs as we have no way of reading their initial state. This is
Colin Leitnerf04d5142013-05-27 23:41:05 +02001196 * only relevant if the driver is loaded after somebody actively set the
Frank Praznikad142b92014-02-20 11:36:00 -05001197 * LEDs to on
1198 */
Frank Praznik60781cf2014-01-11 15:13:15 -05001199 sony_set_leds(hdev, initial_values, drv_data->led_count);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001200
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001201 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001202
Frank Praznik60781cf2014-01-11 15:13:15 -05001203 for (n = 0; n < drv_data->led_count; n++) {
Frank Praznik61ebca92014-01-20 12:27:02 -05001204
1205 if (use_colors)
1206 name_sz = strlen(dev_name(&hdev->dev)) + strlen(color_str[n]) + 2;
1207
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001208 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1209 if (!led) {
1210 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
Julia Lawall8cd5fcd2013-12-29 23:47:27 +01001211 ret = -ENOMEM;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001212 goto error_leds;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001213 }
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001214
1215 name = (void *)(&led[1]);
Frank Praznik61ebca92014-01-20 12:27:02 -05001216 if (use_colors)
1217 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), color_str[n]);
1218 else
1219 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001220 led->name = name;
1221 led->brightness = 0;
Frank Praznik60781cf2014-01-11 15:13:15 -05001222 led->max_brightness = max_brightness;
Sven Eckelmannc5382512013-11-19 20:26:30 +01001223 led->brightness_get = sony_led_get_brightness;
1224 led->brightness_set = sony_led_set_brightness;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001225
Julia Lawall8cd5fcd2013-12-29 23:47:27 +01001226 ret = led_classdev_register(&hdev->dev, led);
1227 if (ret) {
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001228 hid_err(hdev, "Failed to register LED %d\n", n);
1229 kfree(led);
1230 goto error_leds;
1231 }
1232
Sven Eckelmann2251b852013-11-19 20:26:31 +01001233 drv_data->leds[n] = led;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001234 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02001235
1236 return ret;
1237
Colin Leitnerf04d5142013-05-27 23:41:05 +02001238error_leds:
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001239 sony_leds_remove(hdev);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001240
Colin Leitnerf04d5142013-05-27 23:41:05 +02001241 return ret;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001242}
1243
Frank Praznikcad665a2014-01-11 15:13:54 -05001244static void sixaxis_state_worker(struct work_struct *work)
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001245{
Sven Eckelmann92b5c412013-11-19 20:26:28 +01001246 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001247 unsigned char buf[] = {
1248 0x01,
1249 0x00, 0xff, 0x00, 0xff, 0x00,
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001250 0x00, 0x00, 0x00, 0x00, 0x00,
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001251 0xff, 0x27, 0x10, 0x00, 0x32,
1252 0xff, 0x27, 0x10, 0x00, 0x32,
1253 0xff, 0x27, 0x10, 0x00, 0x32,
1254 0xff, 0x27, 0x10, 0x00, 0x32,
1255 0x00, 0x00, 0x00, 0x00, 0x00
1256 };
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001257
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001258#ifdef CONFIG_SONY_FF
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001259 buf[3] = sc->right ? 1 : 0;
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001260 buf[5] = sc->left;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001261#endif
1262
Frank Praznik60781cf2014-01-11 15:13:15 -05001263 buf[10] |= sc->led_state[0] << 1;
1264 buf[10] |= sc->led_state[1] << 2;
1265 buf[10] |= sc->led_state[2] << 3;
1266 buf[10] |= sc->led_state[3] << 4;
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001267
Benjamin Tissoirese534a932014-03-08 22:52:42 -05001268 hid_hw_raw_request(sc->hdev, 0x01, buf, sizeof(buf), HID_OUTPUT_REPORT,
1269 HID_REQ_SET_REPORT);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001270}
1271
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001272static void dualshock4_state_worker(struct work_struct *work)
1273{
1274 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
Frank Praznik0da8ea62014-01-16 21:42:51 -05001275 struct hid_device *hdev = sc->hdev;
Frank Praznik48220232014-02-05 20:03:44 -05001276 int offset;
Frank Praznik0da8ea62014-01-16 21:42:51 -05001277
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001278 __u8 buf[78] = { 0 };
Frank Praznik48220232014-02-05 20:03:44 -05001279
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001280 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1281 buf[0] = 0x05;
1282 buf[1] = 0x03;
1283 offset = 4;
1284 } else {
1285 buf[0] = 0x11;
1286 buf[1] = 0xB0;
1287 buf[3] = 0x0F;
1288 offset = 6;
1289 }
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001290
1291#ifdef CONFIG_SONY_FF
Frank Praznik48220232014-02-05 20:03:44 -05001292 buf[offset++] = sc->right;
1293 buf[offset++] = sc->left;
1294#else
1295 offset += 2;
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001296#endif
1297
Frank Praznik48220232014-02-05 20:03:44 -05001298 buf[offset++] = sc->led_state[0];
1299 buf[offset++] = sc->led_state[1];
1300 buf[offset++] = sc->led_state[2];
Frank Praznik60781cf2014-01-11 15:13:15 -05001301
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001302 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1303 hid_hw_output_report(hdev, buf, 32);
1304 else
1305 hid_hw_raw_request(hdev, 0x11, buf, 78,
1306 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001307}
1308
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001309#ifdef CONFIG_SONY_FF
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001310static int sony_play_effect(struct input_dev *dev, void *data,
1311 struct ff_effect *effect)
1312{
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001313 struct hid_device *hid = input_get_drvdata(dev);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001314 struct sony_sc *sc = hid_get_drvdata(hid);
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001315
1316 if (effect->type != FF_RUMBLE)
1317 return 0;
1318
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001319 sc->left = effect->u.rumble.strong_magnitude / 256;
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001320 sc->right = effect->u.rumble.weak_magnitude / 256;
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001321
Sven Eckelmann92b5c412013-11-19 20:26:28 +01001322 schedule_work(&sc->state_worker);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001323 return 0;
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001324}
1325
1326static int sony_init_ff(struct hid_device *hdev)
1327{
1328 struct hid_input *hidinput = list_entry(hdev->inputs.next,
1329 struct hid_input, list);
1330 struct input_dev *input_dev = hidinput->input;
1331
1332 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1333 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1334}
1335
1336#else
1337static int sony_init_ff(struct hid_device *hdev)
1338{
1339 return 0;
1340}
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001341
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001342#endif
1343
Frank Praznikd902f472014-01-27 10:17:36 -05001344static int sony_battery_get_property(struct power_supply *psy,
1345 enum power_supply_property psp,
1346 union power_supply_propval *val)
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001347{
Frank Praznikd902f472014-01-27 10:17:36 -05001348 struct sony_sc *sc = container_of(psy, struct sony_sc, battery);
1349 unsigned long flags;
1350 int ret = 0;
1351 u8 battery_charging, battery_capacity, cable_state;
1352
1353 spin_lock_irqsave(&sc->lock, flags);
1354 battery_charging = sc->battery_charging;
1355 battery_capacity = sc->battery_capacity;
1356 cable_state = sc->cable_state;
1357 spin_unlock_irqrestore(&sc->lock, flags);
1358
1359 switch (psp) {
1360 case POWER_SUPPLY_PROP_PRESENT:
1361 val->intval = 1;
1362 break;
1363 case POWER_SUPPLY_PROP_SCOPE:
1364 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
1365 break;
1366 case POWER_SUPPLY_PROP_CAPACITY:
1367 val->intval = battery_capacity;
1368 break;
1369 case POWER_SUPPLY_PROP_STATUS:
1370 if (battery_charging)
1371 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1372 else
1373 if (battery_capacity == 100 && cable_state)
1374 val->intval = POWER_SUPPLY_STATUS_FULL;
1375 else
1376 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1377 break;
1378 default:
1379 ret = -EINVAL;
1380 break;
1381 }
1382 return ret;
1383}
1384
1385static int sony_battery_probe(struct sony_sc *sc)
1386{
1387 static atomic_t power_id_seq = ATOMIC_INIT(0);
1388 unsigned long power_id;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001389 struct hid_device *hdev = sc->hdev;
Frank Praznikd902f472014-01-27 10:17:36 -05001390 int ret;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001391
Frank Praznikad142b92014-02-20 11:36:00 -05001392 /*
1393 * Set the default battery level to 100% to avoid low battery warnings
Frank Praznikd9a293a2014-02-05 20:03:48 -05001394 * if the battery is polled before the first device report is received.
1395 */
1396 sc->battery_capacity = 100;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001397
Frank Praznikd902f472014-01-27 10:17:36 -05001398 power_id = (unsigned long)atomic_inc_return(&power_id_seq);
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001399
Frank Praznikd902f472014-01-27 10:17:36 -05001400 sc->battery.properties = sony_battery_props;
1401 sc->battery.num_properties = ARRAY_SIZE(sony_battery_props);
1402 sc->battery.get_property = sony_battery_get_property;
1403 sc->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1404 sc->battery.use_for_apm = 0;
1405 sc->battery.name = kasprintf(GFP_KERNEL, "sony_controller_battery_%lu",
1406 power_id);
1407 if (!sc->battery.name)
1408 return -ENOMEM;
1409
1410 ret = power_supply_register(&hdev->dev, &sc->battery);
1411 if (ret) {
1412 hid_err(hdev, "Unable to register battery device\n");
1413 goto err_free;
1414 }
1415
1416 power_supply_powers(&sc->battery, &hdev->dev);
1417 return 0;
1418
1419err_free:
1420 kfree(sc->battery.name);
1421 sc->battery.name = NULL;
1422 return ret;
1423}
1424
1425static void sony_battery_remove(struct sony_sc *sc)
1426{
1427 if (!sc->battery.name)
1428 return;
1429
1430 power_supply_unregister(&sc->battery);
1431 kfree(sc->battery.name);
1432 sc->battery.name = NULL;
1433}
1434
Frank Praznike5606232014-01-27 10:17:37 -05001435static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1436 int w, int h)
1437{
1438 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1439 struct hid_input, list);
1440 struct input_dev *input_dev = hidinput->input;
1441 int ret;
1442
1443 ret = input_mt_init_slots(input_dev, touch_count, 0);
1444 if (ret < 0) {
1445 hid_err(sc->hdev, "Unable to initialize multi-touch slots\n");
1446 return ret;
1447 }
1448
1449 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1450 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1451
1452 return 0;
1453}
1454
Frank Praznikd2d782f2014-02-20 11:36:03 -05001455/*
1456 * If a controller is plugged in via USB while already connected via Bluetooth
1457 * it will show up as two devices. A global list of connected controllers and
1458 * their MAC addresses is maintained to ensure that a device is only connected
1459 * once.
1460 */
1461static int sony_check_add_dev_list(struct sony_sc *sc)
1462{
1463 struct sony_sc *entry;
1464 unsigned long flags;
1465 int ret;
1466
1467 spin_lock_irqsave(&sony_dev_list_lock, flags);
1468
1469 list_for_each_entry(entry, &sony_device_list, list_node) {
1470 ret = memcmp(sc->mac_address, entry->mac_address,
1471 sizeof(sc->mac_address));
1472 if (!ret) {
1473 ret = -EEXIST;
1474 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
1475 sc->mac_address);
1476 goto unlock;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001477 }
1478 }
1479
Frank Praznikd2d782f2014-02-20 11:36:03 -05001480 ret = 0;
1481 list_add(&(sc->list_node), &sony_device_list);
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001482
Frank Praznikd2d782f2014-02-20 11:36:03 -05001483unlock:
1484 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1485 return ret;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001486}
1487
Frank Praznikd2d782f2014-02-20 11:36:03 -05001488static void sony_remove_dev_list(struct sony_sc *sc)
1489{
1490 unsigned long flags;
1491
1492 if (sc->list_node.next) {
1493 spin_lock_irqsave(&sony_dev_list_lock, flags);
1494 list_del(&(sc->list_node));
1495 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
1496 }
1497}
1498
1499static int sony_get_bt_devaddr(struct sony_sc *sc)
1500{
1501 int ret;
1502
1503 /* HIDP stores the device MAC address as a string in the uniq field. */
1504 ret = strlen(sc->hdev->uniq);
1505 if (ret != 17)
1506 return -EINVAL;
1507
1508 ret = sscanf(sc->hdev->uniq,
1509 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1510 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
1511 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
1512
1513 if (ret != 6)
1514 return -EINVAL;
1515
1516 return 0;
1517}
1518
1519static int sony_check_add(struct sony_sc *sc)
1520{
1521 int n, ret;
1522
1523 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
1524 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
1525 /*
1526 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
1527 * address from the uniq string where HIDP stores it.
1528 * As uniq cannot be guaranteed to be a MAC address in all cases
1529 * a failure of this function should not prevent the connection.
1530 */
1531 if (sony_get_bt_devaddr(sc) < 0) {
1532 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
1533 return 0;
1534 }
1535 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1536 __u8 buf[7];
1537
1538 /*
1539 * The MAC address of a DS4 controller connected via USB can be
1540 * retrieved with feature report 0x81. The address begins at
1541 * offset 1.
1542 */
1543 ret = hid_hw_raw_request(sc->hdev, 0x81, buf, sizeof(buf),
1544 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1545
1546 if (ret != 7) {
1547 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
1548 return ret < 0 ? ret : -EINVAL;
1549 }
1550
1551 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
1552 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
1553 __u8 buf[18];
1554
1555 /*
1556 * The MAC address of a Sixaxis controller connected via USB can
1557 * be retrieved with feature report 0xf2. The address begins at
1558 * offset 4.
1559 */
1560 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf, sizeof(buf),
1561 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1562
1563 if (ret != 18) {
1564 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
1565 return ret < 0 ? ret : -EINVAL;
1566 }
1567
1568 /*
1569 * The Sixaxis device MAC in the report is big-endian and must
1570 * be byte-swapped.
1571 */
1572 for (n = 0; n < 6; n++)
1573 sc->mac_address[5-n] = buf[4+n];
1574 } else {
1575 return 0;
1576 }
1577
1578 return sony_check_add_dev_list(sc);
1579}
1580
1581
Jiri Slabybd28ce02008-06-25 23:47:04 +02001582static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
1583{
1584 int ret;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001585 unsigned long quirks = id->driver_data;
1586 struct sony_sc *sc;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001587 unsigned int connect_mask = HID_CONNECT_DEFAULT;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001588
Benjamin Tissoiresabf832b2013-07-24 19:38:04 +02001589 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001590 if (sc == NULL) {
Joe Perches4291ee32010-12-09 19:29:03 -08001591 hid_err(hdev, "can't alloc sony descriptor\n");
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001592 return -ENOMEM;
1593 }
1594
1595 sc->quirks = quirks;
1596 hid_set_drvdata(hdev, sc);
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001597 sc->hdev = hdev;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001598
Jiri Slabybd28ce02008-06-25 23:47:04 +02001599 ret = hid_parse(hdev);
1600 if (ret) {
Joe Perches4291ee32010-12-09 19:29:03 -08001601 hid_err(hdev, "parse failed\n");
Benjamin Tissoiresabf832b2013-07-24 19:38:04 +02001602 return ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001603 }
1604
Colin Leitnerf04d5142013-05-27 23:41:05 +02001605 if (sc->quirks & VAIO_RDESC_CONSTANT)
1606 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1607 else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
1608 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1609 else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
1610 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1611
1612 ret = hid_hw_start(hdev, connect_mask);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001613 if (ret) {
Joe Perches4291ee32010-12-09 19:29:03 -08001614 hid_err(hdev, "hw start failed\n");
Benjamin Tissoiresabf832b2013-07-24 19:38:04 +02001615 return ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001616 }
1617
Antonio Ospite569b10a2010-10-19 16:13:10 +02001618 if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
Benjamin Tissoirese534a932014-03-08 22:52:42 -05001619 /*
1620 * The Sony Sixaxis does not handle HID Output Reports on the
1621 * Interrupt EP like it could, so we need to force HID Output
1622 * Reports to use HID_REQ_SET_REPORT on the Control EP.
1623 *
1624 * There is also another issue about HID Output Reports via USB,
1625 * the Sixaxis does not want the report_id as part of the data
1626 * packet, so we have to discard buf[0] when sending the actual
1627 * control message, even for numbered reports, humpf!
1628 */
1629 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
1630 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
Antonio Ospite816651a2010-05-03 22:15:55 +02001631 ret = sixaxis_set_operational_usb(hdev);
Frank Praznik5f5750d2014-02-19 13:09:22 -05001632 sc->worker_initialized = 1;
Frank Praznikcad665a2014-01-11 15:13:54 -05001633 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
Frank Praznikfee4e2d2014-02-18 17:22:01 -05001634 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
Frank Praznik2078b9bb2014-03-15 09:41:16 -04001635 /*
1636 * The Sixaxis wants output reports sent on the ctrl endpoint
1637 * when connected via Bluetooth.
1638 */
1639 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
Antonio Ospite816651a2010-05-03 22:15:55 +02001640 ret = sixaxis_set_operational_bt(hdev);
Frank Praznikc8de9db2014-02-20 11:36:01 -05001641 sc->worker_initialized = 1;
Frank Praznikfee4e2d2014-02-18 17:22:01 -05001642 INIT_WORK(&sc->state_worker, sixaxis_state_worker);
1643 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
Frank Praznik68330d82014-02-05 20:03:49 -05001644 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
Frank Praznik2078b9bb2014-03-15 09:41:16 -04001645 /*
1646 * The DualShock 4 wants output reports sent on the ctrl
1647 * endpoint when connected via Bluetooth.
1648 */
1649 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
Frank Praznik68330d82014-02-05 20:03:49 -05001650 ret = dualshock4_set_operational_bt(hdev);
1651 if (ret < 0) {
1652 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
1653 goto err_stop;
1654 }
1655 }
Frank Praznikad142b92014-02-20 11:36:00 -05001656 /*
1657 * The Dualshock 4 touchpad supports 2 touches and has a
Frank Praznike5606232014-01-27 10:17:37 -05001658 * resolution of 1920x940.
1659 */
1660 ret = sony_register_touchpad(sc, 2, 1920, 940);
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05001661 if (ret < 0)
1662 goto err_stop;
1663
Frank Praznik5f5750d2014-02-19 13:09:22 -05001664 sc->worker_initialized = 1;
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001665 INIT_WORK(&sc->state_worker, dualshock4_state_worker);
1666 } else {
1667 ret = 0;
1668 }
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00001669
Jiri Kosina4dfdc462008-12-30 00:49:59 +01001670 if (ret < 0)
Jiri Slabybd28ce02008-06-25 23:47:04 +02001671 goto err_stop;
1672
Frank Praznikd2d782f2014-02-20 11:36:03 -05001673 ret = sony_check_add(sc);
1674 if (ret < 0)
1675 goto err_stop;
1676
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001677 if (sc->quirks & SONY_LED_SUPPORT) {
1678 ret = sony_leds_init(hdev);
1679 if (ret < 0)
1680 goto err_stop;
1681 }
1682
Frank Praznikd902f472014-01-27 10:17:36 -05001683 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1684 ret = sony_battery_probe(sc);
1685 if (ret < 0)
1686 goto err_stop;
1687
1688 /* Open the device to receive reports with battery info */
1689 ret = hid_hw_open(hdev);
1690 if (ret < 0) {
1691 hid_err(hdev, "hw open failed\n");
1692 goto err_stop;
1693 }
1694 }
1695
Frank Praznikc8de9db2014-02-20 11:36:01 -05001696 if (sc->quirks & SONY_FF_SUPPORT) {
1697 ret = sony_init_ff(hdev);
1698 if (ret < 0)
1699 goto err_close;
Frank Praznik5f5750d2014-02-19 13:09:22 -05001700 }
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001701
Jiri Slabybd28ce02008-06-25 23:47:04 +02001702 return 0;
Frank Praznikd902f472014-01-27 10:17:36 -05001703err_close:
1704 hid_hw_close(hdev);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001705err_stop:
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001706 if (sc->quirks & SONY_LED_SUPPORT)
1707 sony_leds_remove(hdev);
Frank Praznikd902f472014-01-27 10:17:36 -05001708 if (sc->quirks & SONY_BATTERY_SUPPORT)
1709 sony_battery_remove(sc);
Frank Praznikc8de9db2014-02-20 11:36:01 -05001710 if (sc->worker_initialized)
1711 cancel_work_sync(&sc->state_worker);
Frank Praznikd2d782f2014-02-20 11:36:03 -05001712 sony_remove_dev_list(sc);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001713 hid_hw_stop(hdev);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001714 return ret;
1715}
1716
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001717static void sony_remove(struct hid_device *hdev)
1718{
Colin Leitnerf04d5142013-05-27 23:41:05 +02001719 struct sony_sc *sc = hid_get_drvdata(hdev);
1720
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001721 if (sc->quirks & SONY_LED_SUPPORT)
Sven Eckelmannc5382512013-11-19 20:26:30 +01001722 sony_leds_remove(hdev);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001723
Frank Praznik5f5750d2014-02-19 13:09:22 -05001724 if (sc->worker_initialized)
1725 cancel_work_sync(&sc->state_worker);
Frank Praznikd902f472014-01-27 10:17:36 -05001726 if (sc->quirks & SONY_BATTERY_SUPPORT) {
1727 hid_hw_close(hdev);
1728 sony_battery_remove(sc);
1729 }
1730
Frank Praznikc8de9db2014-02-20 11:36:01 -05001731 if (sc->worker_initialized)
1732 cancel_work_sync(&sc->state_worker);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001733
Frank Praznikd2d782f2014-02-20 11:36:03 -05001734 sony_remove_dev_list(sc);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001735
Colin Leitnerf04d5142013-05-27 23:41:05 +02001736 hid_hw_stop(hdev);
1737}
1738
1739static const struct hid_device_id sony_devices[] = {
1740 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
1741 .driver_data = SIXAXIS_CONTROLLER_USB },
1742 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
Jiri Slabybd28ce02008-06-25 23:47:04 +02001743 .driver_data = SIXAXIS_CONTROLLER_USB },
H Hartley Sweetenf4254582012-12-17 15:28:26 -07001744 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
Jiri Slabybd28ce02008-06-25 23:47:04 +02001745 .driver_data = SIXAXIS_CONTROLLER_BT },
Jiri Slabybd28ce02008-06-25 23:47:04 +02001746 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
Jiri Slabybd28ce02008-06-25 23:47:04 +02001747 .driver_data = VAIO_RDESC_CONSTANT },
1748 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
1749 .driver_data = VAIO_RDESC_CONSTANT },
1750 /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
1751 * Logitech joystick from the device descriptor. */
1752 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
1753 .driver_data = BUZZ_CONTROLLER },
1754 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
1755 .driver_data = BUZZ_CONTROLLER },
1756 /* PS3 BD Remote Control */
1757 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
1758 .driver_data = PS3REMOTE },
1759 /* Logitech Harmony Adapter for PS3 */
1760 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
1761 .driver_data = PS3REMOTE },
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001762 /* Sony Dualshock 4 controllers for PS4 */
1763 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
Frank Praznik8ab16762014-01-16 21:42:31 -05001764 .driver_data = DUALSHOCK4_CONTROLLER_USB },
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001765 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
Frank Praznik8ab16762014-01-16 21:42:31 -05001766 .driver_data = DUALSHOCK4_CONTROLLER_BT },
Jiri Slabybd28ce02008-06-25 23:47:04 +02001767 { }
1768};
1769MODULE_DEVICE_TABLE(hid, sony_devices);
1770
1771static struct hid_driver sony_driver = {
1772 .name = "sony",
1773 .id_table = sony_devices,
1774 .input_mapping = sony_mapping,
1775 .probe = sony_probe,
1776 .remove = sony_remove,
1777 .report_fixup = sony_report_fixup,
1778 .raw_event = sony_raw_event
1779};
1780module_hid_driver(sony_driver);
1781
1782MODULE_LICENSE("GPL");