blob: 310436a54a3f308157a272d56d6624c3dd3c98c1 [file] [log] [blame]
Jiri Slabybd28ce02008-06-25 23:47:04 +02001/*
Frank Praznik077147a2014-09-14 11:56:39 -04002 * HID driver for Sony / PS2 / PS3 / PS4 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>
Frank Praznik077147a2014-09-14 11:56:39 -040011 * Copyright (c) 2014 Frank Praznik <frank.praznik@gmail.com>
Jiri Slabybd28ce02008-06-25 23:47:04 +020012 */
13
14/*
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the Free
17 * Software Foundation; either version 2 of the License, or (at your option)
18 * any later version.
19 */
20
Frank Praznikad142b92014-02-20 11:36:00 -050021/*
22 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
Jiri Kosina078328d2013-06-13 12:03:49 +020023 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
24 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
25 *
26 * There will be no PIN request from the device.
27 */
28
Jiri Slabybd28ce02008-06-25 23:47:04 +020029#include <linux/device.h>
30#include <linux/hid.h>
31#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Jiri Kosina40e32ee2013-05-28 11:22:09 +020033#include <linux/leds.h>
Frank Praznikd902f472014-01-27 10:17:36 -050034#include <linux/power_supply.h>
35#include <linux/spinlock.h>
Frank Praznikd2d782f2014-02-20 11:36:03 -050036#include <linux/list.h>
Frank Praznik80250872014-04-14 10:11:35 -040037#include <linux/idr.h>
Frank Praznike5606232014-01-27 10:17:37 -050038#include <linux/input/mt.h>
Jiri Slabybd28ce02008-06-25 23:47:04 +020039
40#include "hid-ids.h"
41
Frank Praznik6c79c182014-01-16 21:43:03 -050042#define VAIO_RDESC_CONSTANT BIT(0)
43#define SIXAXIS_CONTROLLER_USB BIT(1)
44#define SIXAXIS_CONTROLLER_BT BIT(2)
45#define BUZZ_CONTROLLER BIT(3)
46#define PS3REMOTE BIT(4)
Frank Praznik8ab16762014-01-16 21:42:31 -050047#define DUALSHOCK4_CONTROLLER_USB BIT(5)
48#define DUALSHOCK4_CONTROLLER_BT BIT(6)
Simon Woodb3bca322015-06-09 21:27:04 -060049#define MOTION_CONTROLLER_USB BIT(7)
50#define MOTION_CONTROLLER_BT BIT(8)
Simon Wood4545ee02015-06-17 00:08:52 -060051#define NAVIGATION_CONTROLLER_USB BIT(9)
52#define NAVIGATION_CONTROLLER_BT BIT(10)
Scott Moreau74500cc2016-01-13 07:40:42 -070053#define SINO_LITE_CONTROLLER BIT(11)
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +020054
Frank Praznikfee4e2d2014-02-18 17:22:01 -050055#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
Simon Woodb3bca322015-06-09 21:27:04 -060056#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
Simon Wood4545ee02015-06-17 00:08:52 -060057#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
58 NAVIGATION_CONTROLLER_BT)
Frank Praznik68330d82014-02-05 20:03:49 -050059#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
60 DUALSHOCK4_CONTROLLER_BT)
Frank Praznikfee4e2d2014-02-18 17:22:01 -050061#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
Simon Wood4545ee02015-06-17 00:08:52 -060062 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
63 NAVIGATION_CONTROLLER)
Simon Wood12e9a6d72015-06-09 21:27:05 -060064#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
Simon Wood4545ee02015-06-17 00:08:52 -060065 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
Frank Praznikc5e0c1c2015-05-05 20:47:30 -040066#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
67 MOTION_CONTROLLER)
Frank Praznik60781cf2014-01-11 15:13:15 -050068
69#define MAX_LEDS 4
Sven Eckelmann0a286ef2013-11-19 20:26:32 +010070
Frank Praznik4c3e8292015-05-05 20:47:33 -040071/*
72 * The Sixaxis reports both digital and analog values for each button on the
73 * controller except for Start, Select and the PS button. The controller ends
74 * up reporting 27 axes which causes them to spill over into the multi-touch
75 * axis values. Additionally, the controller only has 20 actual, physical axes
76 * so there are several unused axes in between the used ones.
77 */
Pavel Machek1adf9042016-02-09 13:55:08 +010078static u8 sixaxis_rdesc[] = {
Antonio Ospitefb705a62014-06-24 13:28:42 +020079 0x05, 0x01, /* Usage Page (Desktop), */
Frank Praznik4c3e8292015-05-05 20:47:33 -040080 0x09, 0x04, /* Usage (Joystick), */
Antonio Ospitefb705a62014-06-24 13:28:42 +020081 0xA1, 0x01, /* Collection (Application), */
82 0xA1, 0x02, /* Collection (Logical), */
83 0x85, 0x01, /* Report ID (1), */
84 0x75, 0x08, /* Report Size (8), */
85 0x95, 0x01, /* Report Count (1), */
86 0x15, 0x00, /* Logical Minimum (0), */
87 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
88 0x81, 0x03, /* Input (Constant, Variable), */
89 0x75, 0x01, /* Report Size (1), */
90 0x95, 0x13, /* Report Count (19), */
91 0x15, 0x00, /* Logical Minimum (0), */
92 0x25, 0x01, /* Logical Maximum (1), */
93 0x35, 0x00, /* Physical Minimum (0), */
94 0x45, 0x01, /* Physical Maximum (1), */
95 0x05, 0x09, /* Usage Page (Button), */
96 0x19, 0x01, /* Usage Minimum (01h), */
97 0x29, 0x13, /* Usage Maximum (13h), */
98 0x81, 0x02, /* Input (Variable), */
99 0x75, 0x01, /* Report Size (1), */
100 0x95, 0x0D, /* Report Count (13), */
101 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
102 0x81, 0x03, /* Input (Constant, Variable), */
103 0x15, 0x00, /* Logical Minimum (0), */
104 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
105 0x05, 0x01, /* Usage Page (Desktop), */
106 0x09, 0x01, /* Usage (Pointer), */
107 0xA1, 0x00, /* Collection (Physical), */
108 0x75, 0x08, /* Report Size (8), */
109 0x95, 0x04, /* Report Count (4), */
110 0x35, 0x00, /* Physical Minimum (0), */
111 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
112 0x09, 0x30, /* Usage (X), */
113 0x09, 0x31, /* Usage (Y), */
114 0x09, 0x32, /* Usage (Z), */
115 0x09, 0x35, /* Usage (Rz), */
116 0x81, 0x02, /* Input (Variable), */
117 0xC0, /* End Collection, */
118 0x05, 0x01, /* Usage Page (Desktop), */
119 0x95, 0x13, /* Report Count (19), */
120 0x09, 0x01, /* Usage (Pointer), */
121 0x81, 0x02, /* Input (Variable), */
122 0x95, 0x0C, /* Report Count (12), */
123 0x81, 0x01, /* Input (Constant), */
124 0x75, 0x10, /* Report Size (16), */
125 0x95, 0x04, /* Report Count (4), */
126 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */
127 0x46, 0xFF, 0x03, /* Physical Maximum (1023), */
128 0x09, 0x01, /* Usage (Pointer), */
129 0x81, 0x02, /* Input (Variable), */
130 0xC0, /* End Collection, */
131 0xA1, 0x02, /* Collection (Logical), */
132 0x85, 0x02, /* Report ID (2), */
133 0x75, 0x08, /* Report Size (8), */
134 0x95, 0x30, /* Report Count (48), */
135 0x09, 0x01, /* Usage (Pointer), */
136 0xB1, 0x02, /* Feature (Variable), */
137 0xC0, /* End Collection, */
138 0xA1, 0x02, /* Collection (Logical), */
139 0x85, 0xEE, /* Report ID (238), */
140 0x75, 0x08, /* Report Size (8), */
141 0x95, 0x30, /* Report Count (48), */
142 0x09, 0x01, /* Usage (Pointer), */
143 0xB1, 0x02, /* Feature (Variable), */
144 0xC0, /* End Collection, */
145 0xA1, 0x02, /* Collection (Logical), */
146 0x85, 0xEF, /* Report ID (239), */
147 0x75, 0x08, /* Report Size (8), */
148 0x95, 0x30, /* Report Count (48), */
149 0x09, 0x01, /* Usage (Pointer), */
150 0xB1, 0x02, /* Feature (Variable), */
151 0xC0, /* End Collection, */
152 0xC0 /* End Collection */
Mauro Carvalho Chehabe57a67d2012-12-14 20:57:34 -0200153};
154
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400155/* PS/3 Motion controller */
Pavel Machek1adf9042016-02-09 13:55:08 +0100156static u8 motion_rdesc[] = {
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400157 0x05, 0x01, /* Usage Page (Desktop), */
158 0x09, 0x04, /* Usage (Joystick), */
159 0xA1, 0x01, /* Collection (Application), */
160 0xA1, 0x02, /* Collection (Logical), */
161 0x85, 0x01, /* Report ID (1), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400162 0x75, 0x01, /* Report Size (1), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600163 0x95, 0x15, /* Report Count (21), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400164 0x15, 0x00, /* Logical Minimum (0), */
165 0x25, 0x01, /* Logical Maximum (1), */
166 0x35, 0x00, /* Physical Minimum (0), */
167 0x45, 0x01, /* Physical Maximum (1), */
168 0x05, 0x09, /* Usage Page (Button), */
169 0x19, 0x01, /* Usage Minimum (01h), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600170 0x29, 0x15, /* Usage Maximum (15h), */
171 0x81, 0x02, /* Input (Variable), * Buttons */
172 0x95, 0x0B, /* Report Count (11), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400173 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600174 0x81, 0x03, /* Input (Constant, Variable), * Padding */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400175 0x15, 0x00, /* Logical Minimum (0), */
176 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
177 0x05, 0x01, /* Usage Page (Desktop), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400178 0xA1, 0x00, /* Collection (Physical), */
179 0x75, 0x08, /* Report Size (8), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600180 0x95, 0x01, /* Report Count (1), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400181 0x35, 0x00, /* Physical Minimum (0), */
182 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
183 0x09, 0x30, /* Usage (X), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600184 0x81, 0x02, /* Input (Variable), * Trigger */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400185 0xC0, /* End Collection, */
Simon Wood8b2513c2015-06-09 21:27:07 -0600186 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
187 0x75, 0x08, /* Report Size (8), */
188 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
189 0x81, 0x02, /* Input (Variable), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400190 0x05, 0x01, /* Usage Page (Desktop), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400191 0x75, 0x10, /* Report Size (16), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600192 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
193 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
194 0x95, 0x03, /* Report Count (3), * 3x Accels */
195 0x09, 0x33, /* Usage (rX), */
196 0x09, 0x34, /* Usage (rY), */
197 0x09, 0x35, /* Usage (rZ), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400198 0x81, 0x02, /* Input (Variable), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600199 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
200 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
201 0x81, 0x02, /* Input (Variable), */
202 0x05, 0x01, /* Usage Page (Desktop), */
203 0x09, 0x01, /* Usage (Pointer), */
204 0x95, 0x03, /* Report Count (3), * 3x Gyros */
205 0x81, 0x02, /* Input (Variable), */
206 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
207 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
208 0x81, 0x02, /* Input (Variable), */
209 0x75, 0x0C, /* Report Size (12), */
210 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
211 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
212 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
213 0x81, 0x02, /* Input (Variable), */
214 0x75, 0x08, /* Report Size (8), */
215 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
216 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
217 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
218 0x81, 0x02, /* Input (Variable), */
219 0x75, 0x08, /* Report Size (8), */
220 0x95, 0x30, /* Report Count (48), */
221 0x09, 0x01, /* Usage (Pointer), */
222 0x91, 0x02, /* Output (Variable), */
223 0x75, 0x08, /* Report Size (8), */
224 0x95, 0x30, /* Report Count (48), */
225 0x09, 0x01, /* Usage (Pointer), */
226 0xB1, 0x02, /* Feature (Variable), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400227 0xC0, /* End Collection, */
228 0xA1, 0x02, /* Collection (Logical), */
229 0x85, 0x02, /* Report ID (2), */
230 0x75, 0x08, /* Report Size (8), */
231 0x95, 0x30, /* Report Count (48), */
232 0x09, 0x01, /* Usage (Pointer), */
233 0xB1, 0x02, /* Feature (Variable), */
234 0xC0, /* End Collection, */
235 0xA1, 0x02, /* Collection (Logical), */
236 0x85, 0xEE, /* Report ID (238), */
237 0x75, 0x08, /* Report Size (8), */
238 0x95, 0x30, /* Report Count (48), */
239 0x09, 0x01, /* Usage (Pointer), */
240 0xB1, 0x02, /* Feature (Variable), */
241 0xC0, /* End Collection, */
242 0xA1, 0x02, /* Collection (Logical), */
243 0x85, 0xEF, /* Report ID (239), */
244 0x75, 0x08, /* Report Size (8), */
245 0x95, 0x30, /* Report Count (48), */
246 0x09, 0x01, /* Usage (Pointer), */
247 0xB1, 0x02, /* Feature (Variable), */
248 0xC0, /* End Collection, */
249 0xC0 /* End Collection */
250};
251
Simon Woodb2723eb2015-06-17 00:08:53 -0600252/* PS/3 Navigation controller */
Pavel Machek1adf9042016-02-09 13:55:08 +0100253static u8 navigation_rdesc[] = {
Simon Woodb2723eb2015-06-17 00:08:53 -0600254 0x05, 0x01, /* Usage Page (Desktop), */
Antonio Ospited5421762016-01-28 18:23:43 +0100255 0x09, 0x04, /* Usage (Joystick), */
Simon Woodb2723eb2015-06-17 00:08:53 -0600256 0xA1, 0x01, /* Collection (Application), */
257 0xA1, 0x02, /* Collection (Logical), */
258 0x85, 0x01, /* Report ID (1), */
259 0x75, 0x08, /* Report Size (8), */
260 0x95, 0x01, /* Report Count (1), */
261 0x15, 0x00, /* Logical Minimum (0), */
262 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
263 0x81, 0x03, /* Input (Constant, Variable), */
264 0x75, 0x01, /* Report Size (1), */
265 0x95, 0x13, /* Report Count (19), */
266 0x15, 0x00, /* Logical Minimum (0), */
267 0x25, 0x01, /* Logical Maximum (1), */
268 0x35, 0x00, /* Physical Minimum (0), */
269 0x45, 0x01, /* Physical Maximum (1), */
270 0x05, 0x09, /* Usage Page (Button), */
271 0x19, 0x01, /* Usage Minimum (01h), */
272 0x29, 0x13, /* Usage Maximum (13h), */
273 0x81, 0x02, /* Input (Variable), */
274 0x75, 0x01, /* Report Size (1), */
275 0x95, 0x0D, /* Report Count (13), */
276 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
277 0x81, 0x03, /* Input (Constant, Variable), */
278 0x15, 0x00, /* Logical Minimum (0), */
279 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
280 0x05, 0x01, /* Usage Page (Desktop), */
281 0x09, 0x01, /* Usage (Pointer), */
282 0xA1, 0x00, /* Collection (Physical), */
283 0x75, 0x08, /* Report Size (8), */
284 0x95, 0x02, /* Report Count (2), */
285 0x35, 0x00, /* Physical Minimum (0), */
286 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
287 0x09, 0x30, /* Usage (X), */
288 0x09, 0x31, /* Usage (Y), */
289 0x81, 0x02, /* Input (Variable), */
290 0xC0, /* End Collection, */
291 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
292 0x95, 0x06, /* Report Count (6), */
293 0x81, 0x03, /* Input (Constant, Variable), */
294 0x05, 0x01, /* Usage Page (Desktop), */
295 0x75, 0x08, /* Report Size (8), */
296 0x95, 0x05, /* Report Count (5), */
297 0x09, 0x01, /* Usage (Pointer), */
298 0x81, 0x02, /* Input (Variable), */
299 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
Simon Wood2259b5bb2015-07-10 00:10:21 -0600300 0x95, 0x01, /* Report Count (1), */
301 0x81, 0x02, /* Input (Variable), */
302 0x05, 0x01, /* Usage Page (Desktop), */
303 0x95, 0x01, /* Report Count (1), */
304 0x09, 0x01, /* Usage (Pointer), */
305 0x81, 0x02, /* Input (Variable), */
306 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
307 0x95, 0x1E, /* Report Count (24), */
Simon Woodb2723eb2015-06-17 00:08:53 -0600308 0x81, 0x02, /* Input (Variable), */
309 0x75, 0x08, /* Report Size (8), */
310 0x95, 0x30, /* Report Count (48), */
311 0x09, 0x01, /* Usage (Pointer), */
312 0x91, 0x02, /* Output (Variable), */
313 0x75, 0x08, /* Report Size (8), */
314 0x95, 0x30, /* Report Count (48), */
315 0x09, 0x01, /* Usage (Pointer), */
316 0xB1, 0x02, /* Feature (Variable), */
317 0xC0, /* End Collection, */
318 0xA1, 0x02, /* Collection (Logical), */
319 0x85, 0x02, /* Report ID (2), */
320 0x75, 0x08, /* Report Size (8), */
321 0x95, 0x30, /* Report Count (48), */
322 0x09, 0x01, /* Usage (Pointer), */
323 0xB1, 0x02, /* Feature (Variable), */
324 0xC0, /* End Collection, */
325 0xA1, 0x02, /* Collection (Logical), */
326 0x85, 0xEE, /* Report ID (238), */
327 0x75, 0x08, /* Report Size (8), */
328 0x95, 0x30, /* Report Count (48), */
329 0x09, 0x01, /* Usage (Pointer), */
330 0xB1, 0x02, /* Feature (Variable), */
331 0xC0, /* End Collection, */
332 0xA1, 0x02, /* Collection (Logical), */
333 0x85, 0xEF, /* Report ID (239), */
334 0x75, 0x08, /* Report Size (8), */
335 0x95, 0x30, /* Report Count (48), */
336 0x09, 0x01, /* Usage (Pointer), */
337 0xB1, 0x02, /* Feature (Variable), */
338 0xC0, /* End Collection, */
339 0xC0 /* End Collection */
340};
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400341
Frank Praznikad142b92014-02-20 11:36:00 -0500342/*
343 * The default descriptor doesn't provide mapping for the accelerometers
Frank Praznik58d70272014-01-20 12:27:01 -0500344 * or orientation sensors. This fixed descriptor maps the accelerometers
345 * to usage values 0x40, 0x41 and 0x42 and maps the orientation sensors
346 * to usage values 0x43, 0x44 and 0x45.
347 */
Frank Prazniked19d8c2014-01-16 21:43:12 -0500348static u8 dualshock4_usb_rdesc[] = {
Frank Praznik58d70272014-01-20 12:27:01 -0500349 0x05, 0x01, /* Usage Page (Desktop), */
350 0x09, 0x05, /* Usage (Gamepad), */
351 0xA1, 0x01, /* Collection (Application), */
352 0x85, 0x01, /* Report ID (1), */
353 0x09, 0x30, /* Usage (X), */
354 0x09, 0x31, /* Usage (Y), */
355 0x09, 0x32, /* Usage (Z), */
356 0x09, 0x35, /* Usage (Rz), */
357 0x15, 0x00, /* Logical Minimum (0), */
358 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
359 0x75, 0x08, /* Report Size (8), */
360 0x95, 0x04, /* Report Count (4), */
361 0x81, 0x02, /* Input (Variable), */
362 0x09, 0x39, /* Usage (Hat Switch), */
363 0x15, 0x00, /* Logical Minimum (0), */
364 0x25, 0x07, /* Logical Maximum (7), */
365 0x35, 0x00, /* Physical Minimum (0), */
366 0x46, 0x3B, 0x01, /* Physical Maximum (315), */
367 0x65, 0x14, /* Unit (Degrees), */
368 0x75, 0x04, /* Report Size (4), */
369 0x95, 0x01, /* Report Count (1), */
370 0x81, 0x42, /* Input (Variable, Null State), */
371 0x65, 0x00, /* Unit, */
372 0x05, 0x09, /* Usage Page (Button), */
373 0x19, 0x01, /* Usage Minimum (01h), */
374 0x29, 0x0E, /* Usage Maximum (0Eh), */
375 0x15, 0x00, /* Logical Minimum (0), */
376 0x25, 0x01, /* Logical Maximum (1), */
377 0x75, 0x01, /* Report Size (1), */
378 0x95, 0x0E, /* Report Count (14), */
379 0x81, 0x02, /* Input (Variable), */
380 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
381 0x09, 0x20, /* Usage (20h), */
382 0x75, 0x06, /* Report Size (6), */
383 0x95, 0x01, /* Report Count (1), */
384 0x15, 0x00, /* Logical Minimum (0), */
Frank Praznikfb291cb2014-09-14 11:56:38 -0400385 0x25, 0x3F, /* Logical Maximum (63), */
Frank Praznik58d70272014-01-20 12:27:01 -0500386 0x81, 0x02, /* Input (Variable), */
387 0x05, 0x01, /* Usage Page (Desktop), */
388 0x09, 0x33, /* Usage (Rx), */
389 0x09, 0x34, /* Usage (Ry), */
390 0x15, 0x00, /* Logical Minimum (0), */
391 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
392 0x75, 0x08, /* Report Size (8), */
393 0x95, 0x02, /* Report Count (2), */
394 0x81, 0x02, /* Input (Variable), */
395 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
396 0x09, 0x21, /* Usage (21h), */
397 0x95, 0x03, /* Report Count (3), */
398 0x81, 0x02, /* Input (Variable), */
399 0x05, 0x01, /* Usage Page (Desktop), */
400 0x19, 0x40, /* Usage Minimum (40h), */
401 0x29, 0x42, /* Usage Maximum (42h), */
402 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
403 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
404 0x75, 0x10, /* Report Size (16), */
405 0x95, 0x03, /* Report Count (3), */
406 0x81, 0x02, /* Input (Variable), */
407 0x19, 0x43, /* Usage Minimum (43h), */
408 0x29, 0x45, /* Usage Maximum (45h), */
Frank Praznikfb291cb2014-09-14 11:56:38 -0400409 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
410 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
Frank Praznik58d70272014-01-20 12:27:01 -0500411 0x95, 0x03, /* Report Count (3), */
412 0x81, 0x02, /* Input (Variable), */
413 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
414 0x09, 0x21, /* Usage (21h), */
415 0x15, 0x00, /* Logical Minimum (0), */
Frank Praznikfb291cb2014-09-14 11:56:38 -0400416 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
Frank Praznik58d70272014-01-20 12:27:01 -0500417 0x75, 0x08, /* Report Size (8), */
418 0x95, 0x27, /* Report Count (39), */
419 0x81, 0x02, /* Input (Variable), */
420 0x85, 0x05, /* Report ID (5), */
421 0x09, 0x22, /* Usage (22h), */
422 0x95, 0x1F, /* Report Count (31), */
423 0x91, 0x02, /* Output (Variable), */
424 0x85, 0x04, /* Report ID (4), */
425 0x09, 0x23, /* Usage (23h), */
426 0x95, 0x24, /* Report Count (36), */
427 0xB1, 0x02, /* Feature (Variable), */
428 0x85, 0x02, /* Report ID (2), */
429 0x09, 0x24, /* Usage (24h), */
430 0x95, 0x24, /* Report Count (36), */
431 0xB1, 0x02, /* Feature (Variable), */
432 0x85, 0x08, /* Report ID (8), */
433 0x09, 0x25, /* Usage (25h), */
434 0x95, 0x03, /* Report Count (3), */
435 0xB1, 0x02, /* Feature (Variable), */
436 0x85, 0x10, /* Report ID (16), */
437 0x09, 0x26, /* Usage (26h), */
438 0x95, 0x04, /* Report Count (4), */
439 0xB1, 0x02, /* Feature (Variable), */
440 0x85, 0x11, /* Report ID (17), */
441 0x09, 0x27, /* Usage (27h), */
442 0x95, 0x02, /* Report Count (2), */
443 0xB1, 0x02, /* Feature (Variable), */
444 0x85, 0x12, /* Report ID (18), */
445 0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
446 0x09, 0x21, /* Usage (21h), */
447 0x95, 0x0F, /* Report Count (15), */
448 0xB1, 0x02, /* Feature (Variable), */
449 0x85, 0x13, /* Report ID (19), */
450 0x09, 0x22, /* Usage (22h), */
451 0x95, 0x16, /* Report Count (22), */
452 0xB1, 0x02, /* Feature (Variable), */
453 0x85, 0x14, /* Report ID (20), */
454 0x06, 0x05, 0xFF, /* Usage Page (FF05h), */
455 0x09, 0x20, /* Usage (20h), */
456 0x95, 0x10, /* Report Count (16), */
457 0xB1, 0x02, /* Feature (Variable), */
458 0x85, 0x15, /* Report ID (21), */
459 0x09, 0x21, /* Usage (21h), */
460 0x95, 0x2C, /* Report Count (44), */
461 0xB1, 0x02, /* Feature (Variable), */
462 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
463 0x85, 0x80, /* Report ID (128), */
464 0x09, 0x20, /* Usage (20h), */
465 0x95, 0x06, /* Report Count (6), */
466 0xB1, 0x02, /* Feature (Variable), */
467 0x85, 0x81, /* Report ID (129), */
468 0x09, 0x21, /* Usage (21h), */
469 0x95, 0x06, /* Report Count (6), */
470 0xB1, 0x02, /* Feature (Variable), */
471 0x85, 0x82, /* Report ID (130), */
472 0x09, 0x22, /* Usage (22h), */
473 0x95, 0x05, /* Report Count (5), */
474 0xB1, 0x02, /* Feature (Variable), */
475 0x85, 0x83, /* Report ID (131), */
476 0x09, 0x23, /* Usage (23h), */
477 0x95, 0x01, /* Report Count (1), */
478 0xB1, 0x02, /* Feature (Variable), */
479 0x85, 0x84, /* Report ID (132), */
480 0x09, 0x24, /* Usage (24h), */
481 0x95, 0x04, /* Report Count (4), */
482 0xB1, 0x02, /* Feature (Variable), */
483 0x85, 0x85, /* Report ID (133), */
484 0x09, 0x25, /* Usage (25h), */
485 0x95, 0x06, /* Report Count (6), */
486 0xB1, 0x02, /* Feature (Variable), */
487 0x85, 0x86, /* Report ID (134), */
488 0x09, 0x26, /* Usage (26h), */
489 0x95, 0x06, /* Report Count (6), */
490 0xB1, 0x02, /* Feature (Variable), */
491 0x85, 0x87, /* Report ID (135), */
492 0x09, 0x27, /* Usage (27h), */
493 0x95, 0x23, /* Report Count (35), */
494 0xB1, 0x02, /* Feature (Variable), */
495 0x85, 0x88, /* Report ID (136), */
496 0x09, 0x28, /* Usage (28h), */
497 0x95, 0x22, /* Report Count (34), */
498 0xB1, 0x02, /* Feature (Variable), */
499 0x85, 0x89, /* Report ID (137), */
500 0x09, 0x29, /* Usage (29h), */
501 0x95, 0x02, /* Report Count (2), */
502 0xB1, 0x02, /* Feature (Variable), */
503 0x85, 0x90, /* Report ID (144), */
504 0x09, 0x30, /* Usage (30h), */
505 0x95, 0x05, /* Report Count (5), */
506 0xB1, 0x02, /* Feature (Variable), */
507 0x85, 0x91, /* Report ID (145), */
508 0x09, 0x31, /* Usage (31h), */
509 0x95, 0x03, /* Report Count (3), */
510 0xB1, 0x02, /* Feature (Variable), */
511 0x85, 0x92, /* Report ID (146), */
512 0x09, 0x32, /* Usage (32h), */
513 0x95, 0x03, /* Report Count (3), */
514 0xB1, 0x02, /* Feature (Variable), */
515 0x85, 0x93, /* Report ID (147), */
516 0x09, 0x33, /* Usage (33h), */
517 0x95, 0x0C, /* Report Count (12), */
518 0xB1, 0x02, /* Feature (Variable), */
519 0x85, 0xA0, /* Report ID (160), */
520 0x09, 0x40, /* Usage (40h), */
521 0x95, 0x06, /* Report Count (6), */
522 0xB1, 0x02, /* Feature (Variable), */
523 0x85, 0xA1, /* Report ID (161), */
524 0x09, 0x41, /* Usage (41h), */
525 0x95, 0x01, /* Report Count (1), */
526 0xB1, 0x02, /* Feature (Variable), */
527 0x85, 0xA2, /* Report ID (162), */
528 0x09, 0x42, /* Usage (42h), */
529 0x95, 0x01, /* Report Count (1), */
530 0xB1, 0x02, /* Feature (Variable), */
531 0x85, 0xA3, /* Report ID (163), */
532 0x09, 0x43, /* Usage (43h), */
533 0x95, 0x30, /* Report Count (48), */
534 0xB1, 0x02, /* Feature (Variable), */
535 0x85, 0xA4, /* Report ID (164), */
536 0x09, 0x44, /* Usage (44h), */
537 0x95, 0x0D, /* Report Count (13), */
538 0xB1, 0x02, /* Feature (Variable), */
539 0x85, 0xA5, /* Report ID (165), */
540 0x09, 0x45, /* Usage (45h), */
541 0x95, 0x15, /* Report Count (21), */
542 0xB1, 0x02, /* Feature (Variable), */
543 0x85, 0xA6, /* Report ID (166), */
544 0x09, 0x46, /* Usage (46h), */
545 0x95, 0x15, /* Report Count (21), */
546 0xB1, 0x02, /* Feature (Variable), */
547 0x85, 0xF0, /* Report ID (240), */
548 0x09, 0x47, /* Usage (47h), */
549 0x95, 0x3F, /* Report Count (63), */
550 0xB1, 0x02, /* Feature (Variable), */
551 0x85, 0xF1, /* Report ID (241), */
552 0x09, 0x48, /* Usage (48h), */
553 0x95, 0x3F, /* Report Count (63), */
554 0xB1, 0x02, /* Feature (Variable), */
555 0x85, 0xF2, /* Report ID (242), */
556 0x09, 0x49, /* Usage (49h), */
557 0x95, 0x0F, /* Report Count (15), */
558 0xB1, 0x02, /* Feature (Variable), */
559 0x85, 0xA7, /* Report ID (167), */
560 0x09, 0x4A, /* Usage (4Ah), */
561 0x95, 0x01, /* Report Count (1), */
562 0xB1, 0x02, /* Feature (Variable), */
563 0x85, 0xA8, /* Report ID (168), */
564 0x09, 0x4B, /* Usage (4Bh), */
565 0x95, 0x01, /* Report Count (1), */
566 0xB1, 0x02, /* Feature (Variable), */
567 0x85, 0xA9, /* Report ID (169), */
568 0x09, 0x4C, /* Usage (4Ch), */
569 0x95, 0x08, /* Report Count (8), */
570 0xB1, 0x02, /* Feature (Variable), */
571 0x85, 0xAA, /* Report ID (170), */
572 0x09, 0x4E, /* Usage (4Eh), */
573 0x95, 0x01, /* Report Count (1), */
574 0xB1, 0x02, /* Feature (Variable), */
575 0x85, 0xAB, /* Report ID (171), */
576 0x09, 0x4F, /* Usage (4Fh), */
577 0x95, 0x39, /* Report Count (57), */
578 0xB1, 0x02, /* Feature (Variable), */
579 0x85, 0xAC, /* Report ID (172), */
580 0x09, 0x50, /* Usage (50h), */
581 0x95, 0x39, /* Report Count (57), */
582 0xB1, 0x02, /* Feature (Variable), */
583 0x85, 0xAD, /* Report ID (173), */
584 0x09, 0x51, /* Usage (51h), */
585 0x95, 0x0B, /* Report Count (11), */
586 0xB1, 0x02, /* Feature (Variable), */
587 0x85, 0xAE, /* Report ID (174), */
588 0x09, 0x52, /* Usage (52h), */
589 0x95, 0x01, /* Report Count (1), */
590 0xB1, 0x02, /* Feature (Variable), */
591 0x85, 0xAF, /* Report ID (175), */
592 0x09, 0x53, /* Usage (53h), */
593 0x95, 0x02, /* Report Count (2), */
594 0xB1, 0x02, /* Feature (Variable), */
595 0x85, 0xB0, /* Report ID (176), */
596 0x09, 0x54, /* Usage (54h), */
597 0x95, 0x3F, /* Report Count (63), */
598 0xB1, 0x02, /* Feature (Variable), */
599 0xC0 /* End Collection */
Frank Prazniked19d8c2014-01-16 21:43:12 -0500600};
601
Frank Praznikad142b92014-02-20 11:36:00 -0500602/*
603 * The default behavior of the Dualshock 4 is to send reports using report
Frank Praznik077147a2014-09-14 11:56:39 -0400604 * type 1 when running over Bluetooth. However, when feature report 2 is
605 * requested during the controller initialization it starts sending input
606 * reports in report 17. Since report 17 is undefined in the default HID
Frank Praznikd8296742014-02-05 20:03:45 -0500607 * descriptor the button and axis definitions must be moved to report 17 or
Frank Praznik077147a2014-09-14 11:56:39 -0400608 * the HID layer won't process the received input.
Frank Praznikd8296742014-02-05 20:03:45 -0500609 */
610static u8 dualshock4_bt_rdesc[] = {
611 0x05, 0x01, /* Usage Page (Desktop), */
612 0x09, 0x05, /* Usage (Gamepad), */
613 0xA1, 0x01, /* Collection (Application), */
614 0x85, 0x01, /* Report ID (1), */
615 0x75, 0x08, /* Report Size (8), */
616 0x95, 0x0A, /* Report Count (9), */
617 0x81, 0x02, /* Input (Variable), */
618 0x06, 0x04, 0xFF, /* Usage Page (FF04h), */
619 0x85, 0x02, /* Report ID (2), */
620 0x09, 0x24, /* Usage (24h), */
621 0x95, 0x24, /* Report Count (36), */
622 0xB1, 0x02, /* Feature (Variable), */
623 0x85, 0xA3, /* Report ID (163), */
624 0x09, 0x25, /* Usage (25h), */
625 0x95, 0x30, /* Report Count (48), */
626 0xB1, 0x02, /* Feature (Variable), */
627 0x85, 0x05, /* Report ID (5), */
628 0x09, 0x26, /* Usage (26h), */
629 0x95, 0x28, /* Report Count (40), */
630 0xB1, 0x02, /* Feature (Variable), */
631 0x85, 0x06, /* Report ID (6), */
632 0x09, 0x27, /* Usage (27h), */
633 0x95, 0x34, /* Report Count (52), */
634 0xB1, 0x02, /* Feature (Variable), */
635 0x85, 0x07, /* Report ID (7), */
636 0x09, 0x28, /* Usage (28h), */
637 0x95, 0x30, /* Report Count (48), */
638 0xB1, 0x02, /* Feature (Variable), */
639 0x85, 0x08, /* Report ID (8), */
640 0x09, 0x29, /* Usage (29h), */
641 0x95, 0x2F, /* Report Count (47), */
642 0xB1, 0x02, /* Feature (Variable), */
643 0x06, 0x03, 0xFF, /* Usage Page (FF03h), */
644 0x85, 0x03, /* Report ID (3), */
645 0x09, 0x21, /* Usage (21h), */
646 0x95, 0x26, /* Report Count (38), */
647 0xB1, 0x02, /* Feature (Variable), */
648 0x85, 0x04, /* Report ID (4), */
649 0x09, 0x22, /* Usage (22h), */
650 0x95, 0x2E, /* Report Count (46), */
651 0xB1, 0x02, /* Feature (Variable), */
652 0x85, 0xF0, /* Report ID (240), */
653 0x09, 0x47, /* Usage (47h), */
654 0x95, 0x3F, /* Report Count (63), */
655 0xB1, 0x02, /* Feature (Variable), */
656 0x85, 0xF1, /* Report ID (241), */
657 0x09, 0x48, /* Usage (48h), */
658 0x95, 0x3F, /* Report Count (63), */
659 0xB1, 0x02, /* Feature (Variable), */
660 0x85, 0xF2, /* Report ID (242), */
661 0x09, 0x49, /* Usage (49h), */
662 0x95, 0x0F, /* Report Count (15), */
663 0xB1, 0x02, /* Feature (Variable), */
664 0x85, 0x11, /* Report ID (17), */
665 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
666 0x09, 0x20, /* Usage (20h), */
667 0x95, 0x02, /* Report Count (2), */
668 0x81, 0x02, /* Input (Variable), */
669 0x05, 0x01, /* Usage Page (Desktop), */
670 0x09, 0x30, /* Usage (X), */
671 0x09, 0x31, /* Usage (Y), */
672 0x09, 0x32, /* Usage (Z), */
673 0x09, 0x35, /* Usage (Rz), */
674 0x15, 0x00, /* Logical Minimum (0), */
675 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
676 0x75, 0x08, /* Report Size (8), */
677 0x95, 0x04, /* Report Count (4), */
678 0x81, 0x02, /* Input (Variable), */
679 0x09, 0x39, /* Usage (Hat Switch), */
680 0x15, 0x00, /* Logical Minimum (0), */
681 0x25, 0x07, /* Logical Maximum (7), */
682 0x75, 0x04, /* Report Size (4), */
683 0x95, 0x01, /* Report Count (1), */
684 0x81, 0x42, /* Input (Variable, Null State), */
685 0x05, 0x09, /* Usage Page (Button), */
686 0x19, 0x01, /* Usage Minimum (01h), */
687 0x29, 0x0E, /* Usage Maximum (0Eh), */
688 0x15, 0x00, /* Logical Minimum (0), */
689 0x25, 0x01, /* Logical Maximum (1), */
690 0x75, 0x01, /* Report Size (1), */
691 0x95, 0x0E, /* Report Count (14), */
692 0x81, 0x02, /* Input (Variable), */
693 0x75, 0x06, /* Report Size (6), */
694 0x95, 0x01, /* Report Count (1), */
695 0x81, 0x01, /* Input (Constant), */
696 0x05, 0x01, /* Usage Page (Desktop), */
697 0x09, 0x33, /* Usage (Rx), */
698 0x09, 0x34, /* Usage (Ry), */
699 0x15, 0x00, /* Logical Minimum (0), */
700 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
701 0x75, 0x08, /* Report Size (8), */
702 0x95, 0x02, /* Report Count (2), */
703 0x81, 0x02, /* Input (Variable), */
704 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
705 0x09, 0x20, /* Usage (20h), */
706 0x95, 0x03, /* Report Count (3), */
707 0x81, 0x02, /* Input (Variable), */
708 0x05, 0x01, /* Usage Page (Desktop), */
709 0x19, 0x40, /* Usage Minimum (40h), */
710 0x29, 0x42, /* Usage Maximum (42h), */
711 0x16, 0x00, 0x80, /* Logical Minimum (-32768), */
712 0x26, 0x00, 0x7F, /* Logical Maximum (32767), */
713 0x75, 0x10, /* Report Size (16), */
714 0x95, 0x03, /* Report Count (3), */
715 0x81, 0x02, /* Input (Variable), */
716 0x19, 0x43, /* Usage Minimum (43h), */
717 0x29, 0x45, /* Usage Maximum (45h), */
Frank Praznikfb291cb2014-09-14 11:56:38 -0400718 0x16, 0x00, 0xE0, /* Logical Minimum (-8192), */
719 0x26, 0xFF, 0x1F, /* Logical Maximum (8191), */
Frank Praznikd8296742014-02-05 20:03:45 -0500720 0x95, 0x03, /* Report Count (3), */
721 0x81, 0x02, /* Input (Variable), */
722 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
723 0x09, 0x20, /* Usage (20h), */
724 0x15, 0x00, /* Logical Minimum (0), */
725 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
726 0x75, 0x08, /* Report Size (8), */
727 0x95, 0x31, /* Report Count (51), */
728 0x81, 0x02, /* Input (Variable), */
729 0x09, 0x21, /* Usage (21h), */
730 0x75, 0x08, /* Report Size (8), */
731 0x95, 0x4D, /* Report Count (77), */
732 0x91, 0x02, /* Output (Variable), */
733 0x85, 0x12, /* Report ID (18), */
734 0x09, 0x22, /* Usage (22h), */
735 0x95, 0x8D, /* Report Count (141), */
736 0x81, 0x02, /* Input (Variable), */
737 0x09, 0x23, /* Usage (23h), */
738 0x91, 0x02, /* Output (Variable), */
739 0x85, 0x13, /* Report ID (19), */
740 0x09, 0x24, /* Usage (24h), */
741 0x95, 0xCD, /* Report Count (205), */
742 0x81, 0x02, /* Input (Variable), */
743 0x09, 0x25, /* Usage (25h), */
744 0x91, 0x02, /* Output (Variable), */
745 0x85, 0x14, /* Report ID (20), */
746 0x09, 0x26, /* Usage (26h), */
747 0x96, 0x0D, 0x01, /* Report Count (269), */
748 0x81, 0x02, /* Input (Variable), */
749 0x09, 0x27, /* Usage (27h), */
750 0x91, 0x02, /* Output (Variable), */
751 0x85, 0x15, /* Report ID (21), */
752 0x09, 0x28, /* Usage (28h), */
753 0x96, 0x4D, 0x01, /* Report Count (333), */
754 0x81, 0x02, /* Input (Variable), */
755 0x09, 0x29, /* Usage (29h), */
756 0x91, 0x02, /* Output (Variable), */
757 0x85, 0x16, /* Report ID (22), */
758 0x09, 0x2A, /* Usage (2Ah), */
759 0x96, 0x8D, 0x01, /* Report Count (397), */
760 0x81, 0x02, /* Input (Variable), */
761 0x09, 0x2B, /* Usage (2Bh), */
762 0x91, 0x02, /* Output (Variable), */
763 0x85, 0x17, /* Report ID (23), */
764 0x09, 0x2C, /* Usage (2Ch), */
765 0x96, 0xCD, 0x01, /* Report Count (461), */
766 0x81, 0x02, /* Input (Variable), */
767 0x09, 0x2D, /* Usage (2Dh), */
768 0x91, 0x02, /* Output (Variable), */
769 0x85, 0x18, /* Report ID (24), */
770 0x09, 0x2E, /* Usage (2Eh), */
771 0x96, 0x0D, 0x02, /* Report Count (525), */
772 0x81, 0x02, /* Input (Variable), */
773 0x09, 0x2F, /* Usage (2Fh), */
774 0x91, 0x02, /* Output (Variable), */
775 0x85, 0x19, /* Report ID (25), */
776 0x09, 0x30, /* Usage (30h), */
777 0x96, 0x22, 0x02, /* Report Count (546), */
778 0x81, 0x02, /* Input (Variable), */
779 0x09, 0x31, /* Usage (31h), */
780 0x91, 0x02, /* Output (Variable), */
781 0x06, 0x80, 0xFF, /* Usage Page (FF80h), */
782 0x85, 0x82, /* Report ID (130), */
783 0x09, 0x22, /* Usage (22h), */
784 0x95, 0x3F, /* Report Count (63), */
785 0xB1, 0x02, /* Feature (Variable), */
786 0x85, 0x83, /* Report ID (131), */
787 0x09, 0x23, /* Usage (23h), */
788 0xB1, 0x02, /* Feature (Variable), */
789 0x85, 0x84, /* Report ID (132), */
790 0x09, 0x24, /* Usage (24h), */
791 0xB1, 0x02, /* Feature (Variable), */
792 0x85, 0x90, /* Report ID (144), */
793 0x09, 0x30, /* Usage (30h), */
794 0xB1, 0x02, /* Feature (Variable), */
795 0x85, 0x91, /* Report ID (145), */
796 0x09, 0x31, /* Usage (31h), */
797 0xB1, 0x02, /* Feature (Variable), */
798 0x85, 0x92, /* Report ID (146), */
799 0x09, 0x32, /* Usage (32h), */
800 0xB1, 0x02, /* Feature (Variable), */
801 0x85, 0x93, /* Report ID (147), */
802 0x09, 0x33, /* Usage (33h), */
803 0xB1, 0x02, /* Feature (Variable), */
804 0x85, 0xA0, /* Report ID (160), */
805 0x09, 0x40, /* Usage (40h), */
806 0xB1, 0x02, /* Feature (Variable), */
807 0x85, 0xA4, /* Report ID (164), */
808 0x09, 0x44, /* Usage (44h), */
809 0xB1, 0x02, /* Feature (Variable), */
810 0xC0 /* End Collection */
811};
812
Pavel Machek1adf9042016-02-09 13:55:08 +0100813static u8 ps3remote_rdesc[] = {
Jiri Kosina078328d2013-06-13 12:03:49 +0200814 0x05, 0x01, /* GUsagePage Generic Desktop */
815 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
816 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
817
818 /* Use collection 1 for joypad buttons */
819 0xA1, 0x02, /* MCollection Logical (interrelated data) */
820
Antonio Ospiteef916ef2016-02-09 13:55:07 +0100821 /*
822 * Ignore the 1st byte, maybe it is used for a controller
823 * number but it's not needed for correct operation
824 */
Jiri Kosina078328d2013-06-13 12:03:49 +0200825 0x75, 0x08, /* GReportSize 0x08 [8] */
826 0x95, 0x01, /* GReportCount 0x01 [1] */
827 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
828
Antonio Ospiteef916ef2016-02-09 13:55:07 +0100829 /*
830 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
831 * buttons multiple keypresses are allowed
832 */
Jiri Kosina078328d2013-06-13 12:03:49 +0200833 0x05, 0x09, /* GUsagePage Button */
834 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
835 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
836 0x14, /* GLogicalMinimum [0] */
837 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
838 0x75, 0x01, /* GReportSize 0x01 [1] */
839 0x95, 0x18, /* GReportCount 0x18 [24] */
840 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
841
842 0xC0, /* MEndCollection */
843
844 /* Use collection 2 for remote control buttons */
845 0xA1, 0x02, /* MCollection Logical (interrelated data) */
846
847 /* 5th byte is used for remote control buttons */
848 0x05, 0x09, /* GUsagePage Button */
849 0x18, /* LUsageMinimum [No button pressed] */
850 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
851 0x14, /* GLogicalMinimum [0] */
852 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
853 0x75, 0x08, /* GReportSize 0x08 [8] */
854 0x95, 0x01, /* GReportCount 0x01 [1] */
855 0x80, /* MInput */
856
Antonio Ospiteef916ef2016-02-09 13:55:07 +0100857 /*
858 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
859 * 0xff and 11th is for press indication
860 */
Jiri Kosina078328d2013-06-13 12:03:49 +0200861 0x75, 0x08, /* GReportSize 0x08 [8] */
862 0x95, 0x06, /* GReportCount 0x06 [6] */
863 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
864
865 /* 12th byte is for battery strength */
866 0x05, 0x06, /* GUsagePage Generic Device Controls */
867 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
868 0x14, /* GLogicalMinimum [0] */
869 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
870 0x75, 0x08, /* GReportSize 0x08 [8] */
871 0x95, 0x01, /* GReportCount 0x01 [1] */
872 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
873
874 0xC0, /* MEndCollection */
875
876 0xC0 /* MEndCollection [Game Pad] */
877};
878
879static const unsigned int ps3remote_keymap_joypad_buttons[] = {
880 [0x01] = KEY_SELECT,
881 [0x02] = BTN_THUMBL, /* L3 */
882 [0x03] = BTN_THUMBR, /* R3 */
883 [0x04] = BTN_START,
884 [0x05] = KEY_UP,
885 [0x06] = KEY_RIGHT,
886 [0x07] = KEY_DOWN,
887 [0x08] = KEY_LEFT,
888 [0x09] = BTN_TL2, /* L2 */
889 [0x0a] = BTN_TR2, /* R2 */
890 [0x0b] = BTN_TL, /* L1 */
891 [0x0c] = BTN_TR, /* R1 */
892 [0x0d] = KEY_OPTION, /* options/triangle */
893 [0x0e] = KEY_BACK, /* back/circle */
894 [0x0f] = BTN_0, /* cross */
895 [0x10] = KEY_SCREEN, /* view/square */
896 [0x11] = KEY_HOMEPAGE, /* PS button */
897 [0x14] = KEY_ENTER,
898};
899static const unsigned int ps3remote_keymap_remote_buttons[] = {
900 [0x00] = KEY_1,
901 [0x01] = KEY_2,
902 [0x02] = KEY_3,
903 [0x03] = KEY_4,
904 [0x04] = KEY_5,
905 [0x05] = KEY_6,
906 [0x06] = KEY_7,
907 [0x07] = KEY_8,
908 [0x08] = KEY_9,
909 [0x09] = KEY_0,
910 [0x0e] = KEY_ESC, /* return */
911 [0x0f] = KEY_CLEAR,
912 [0x16] = KEY_EJECTCD,
913 [0x1a] = KEY_MENU, /* top menu */
914 [0x28] = KEY_TIME,
915 [0x30] = KEY_PREVIOUS,
916 [0x31] = KEY_NEXT,
917 [0x32] = KEY_PLAY,
918 [0x33] = KEY_REWIND, /* scan back */
919 [0x34] = KEY_FORWARD, /* scan forward */
920 [0x38] = KEY_STOP,
921 [0x39] = KEY_PAUSE,
922 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
923 [0x60] = KEY_FRAMEBACK, /* slow/step back */
924 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
925 [0x63] = KEY_SUBTITLE,
926 [0x64] = KEY_AUDIO,
927 [0x65] = KEY_ANGLE,
928 [0x70] = KEY_INFO, /* display */
929 [0x80] = KEY_BLUE,
930 [0x81] = KEY_RED,
931 [0x82] = KEY_GREEN,
932 [0x83] = KEY_YELLOW,
933};
934
Colin Leitnerf04d5142013-05-27 23:41:05 +0200935static const unsigned int buzz_keymap[] = {
Frank Praznikad142b92014-02-20 11:36:00 -0500936 /*
937 * The controller has 4 remote buzzers, each with one LED and 5
Colin Leitnerf04d5142013-05-27 23:41:05 +0200938 * buttons.
Antonio Ospite09593e32016-02-09 13:55:06 +0100939 *
Colin Leitnerf04d5142013-05-27 23:41:05 +0200940 * We use the mapping chosen by the controller, which is:
941 *
942 * Key Offset
943 * -------------------
944 * Buzz 1
945 * Blue 5
946 * Orange 4
947 * Green 3
948 * Yellow 2
949 *
950 * So, for example, the orange button on the third buzzer is mapped to
951 * BTN_TRIGGER_HAPPY14
952 */
Antonio Ospite09593e32016-02-09 13:55:06 +0100953 [1] = BTN_TRIGGER_HAPPY1,
954 [2] = BTN_TRIGGER_HAPPY2,
955 [3] = BTN_TRIGGER_HAPPY3,
956 [4] = BTN_TRIGGER_HAPPY4,
957 [5] = BTN_TRIGGER_HAPPY5,
958 [6] = BTN_TRIGGER_HAPPY6,
959 [7] = BTN_TRIGGER_HAPPY7,
960 [8] = BTN_TRIGGER_HAPPY8,
961 [9] = BTN_TRIGGER_HAPPY9,
Colin Leitnerf04d5142013-05-27 23:41:05 +0200962 [10] = BTN_TRIGGER_HAPPY10,
963 [11] = BTN_TRIGGER_HAPPY11,
964 [12] = BTN_TRIGGER_HAPPY12,
965 [13] = BTN_TRIGGER_HAPPY13,
966 [14] = BTN_TRIGGER_HAPPY14,
967 [15] = BTN_TRIGGER_HAPPY15,
968 [16] = BTN_TRIGGER_HAPPY16,
969 [17] = BTN_TRIGGER_HAPPY17,
970 [18] = BTN_TRIGGER_HAPPY18,
971 [19] = BTN_TRIGGER_HAPPY19,
972 [20] = BTN_TRIGGER_HAPPY20,
973};
974
Frank Praznikd902f472014-01-27 10:17:36 -0500975static enum power_supply_property sony_battery_props[] = {
976 POWER_SUPPLY_PROP_PRESENT,
977 POWER_SUPPLY_PROP_CAPACITY,
978 POWER_SUPPLY_PROP_SCOPE,
979 POWER_SUPPLY_PROP_STATUS,
980};
981
Frank Praznik55d3b662014-04-14 10:11:32 -0400982struct sixaxis_led {
Pavel Machek1adf9042016-02-09 13:55:08 +0100983 u8 time_enabled; /* the total time the led is active (0xff means forever) */
984 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
985 u8 enabled;
986 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
987 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
Frank Praznik55d3b662014-04-14 10:11:32 -0400988} __packed;
989
990struct sixaxis_rumble {
Pavel Machek1adf9042016-02-09 13:55:08 +0100991 u8 padding;
992 u8 right_duration; /* Right motor duration (0xff means forever) */
993 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
994 u8 left_duration; /* Left motor duration (0xff means forever) */
995 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
Frank Praznik55d3b662014-04-14 10:11:32 -0400996} __packed;
997
998struct sixaxis_output_report {
Pavel Machek1adf9042016-02-09 13:55:08 +0100999 u8 report_id;
Frank Praznik55d3b662014-04-14 10:11:32 -04001000 struct sixaxis_rumble rumble;
Pavel Machek1adf9042016-02-09 13:55:08 +01001001 u8 padding[4];
1002 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
Frank Praznik55d3b662014-04-14 10:11:32 -04001003 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
1004 struct sixaxis_led _reserved; /* LED5, not actually soldered */
1005} __packed;
1006
1007union sixaxis_output_report_01 {
1008 struct sixaxis_output_report data;
Pavel Machek1adf9042016-02-09 13:55:08 +01001009 u8 buf[36];
Frank Praznik55d3b662014-04-14 10:11:32 -04001010};
1011
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001012struct motion_output_report_02 {
1013 u8 type, zero;
1014 u8 r, g, b;
1015 u8 zero2;
1016 u8 rumble;
1017};
1018
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001019#define DS4_REPORT_0x02_SIZE 37
1020#define DS4_REPORT_0x05_SIZE 32
1021#define DS4_REPORT_0x11_SIZE 78
1022#define DS4_REPORT_0x81_SIZE 7
Antonio Ospite29b691a2015-02-16 18:12:21 +01001023#define SIXAXIS_REPORT_0xF2_SIZE 17
Antonio Ospitea85d67b2015-02-16 18:12:22 +01001024#define SIXAXIS_REPORT_0xF5_SIZE 8
Simon Wood41d2d422015-06-09 21:27:06 -06001025#define MOTION_REPORT_0x02_SIZE 49
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001026
Jiri Kosina8b402c92015-02-23 11:15:44 +01001027static DEFINE_SPINLOCK(sony_dev_list_lock);
Frank Praznikd2d782f2014-02-20 11:36:03 -05001028static LIST_HEAD(sony_device_list);
Frank Praznik80250872014-04-14 10:11:35 -04001029static DEFINE_IDA(sony_device_id_allocator);
Frank Praznikd2d782f2014-02-20 11:36:03 -05001030
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001031struct sony_sc {
Frank Praznikd902f472014-01-27 10:17:36 -05001032 spinlock_t lock;
Frank Praznikd2d782f2014-02-20 11:36:03 -05001033 struct list_head list_node;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001034 struct hid_device *hdev;
Frank Praznik60781cf2014-01-11 15:13:15 -05001035 struct led_classdev *leds[MAX_LEDS];
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001036 unsigned long quirks;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001037 struct work_struct state_worker;
Antonio Ospite09593e32016-02-09 13:55:06 +01001038 void (*send_output_report)(struct sony_sc *);
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001039 struct power_supply *battery;
1040 struct power_supply_desc battery_desc;
Frank Praznik80250872014-04-14 10:11:35 -04001041 int device_id;
Pavel Machek1adf9042016-02-09 13:55:08 +01001042 u8 *output_report_dmabuf;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001043
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001044#ifdef CONFIG_SONY_FF
Pavel Machek1adf9042016-02-09 13:55:08 +01001045 u8 left;
1046 u8 right;
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001047#endif
1048
Pavel Machek1adf9042016-02-09 13:55:08 +01001049 u8 mac_address[6];
1050 u8 worker_initialized;
1051 u8 cable_state;
1052 u8 battery_charging;
1053 u8 battery_capacity;
1054 u8 led_state[MAX_LEDS];
1055 u8 resume_led_state[MAX_LEDS];
1056 u8 led_delay_on[MAX_LEDS];
1057 u8 led_delay_off[MAX_LEDS];
1058 u8 led_count;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001059};
1060
Pavel Machek1adf9042016-02-09 13:55:08 +01001061static u8 *sixaxis_fixup(struct hid_device *hdev, u8 *rdesc,
Antonio Ospitec607fb82014-06-24 13:28:41 +02001062 unsigned int *rsize)
1063{
1064 *rsize = sizeof(sixaxis_rdesc);
1065 return sixaxis_rdesc;
1066}
1067
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001068static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
1069 unsigned int *rsize)
1070{
1071 *rsize = sizeof(motion_rdesc);
1072 return motion_rdesc;
1073}
1074
Simon Woodb2723eb2015-06-17 00:08:53 -06001075static u8 *navigation_fixup(struct hid_device *hdev, u8 *rdesc,
1076 unsigned int *rsize)
1077{
1078 *rsize = sizeof(navigation_rdesc);
1079 return navigation_rdesc;
1080}
1081
Pavel Machek1adf9042016-02-09 13:55:08 +01001082static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
Jiri Kosina078328d2013-06-13 12:03:49 +02001083 unsigned int *rsize)
1084{
1085 *rsize = sizeof(ps3remote_rdesc);
1086 return ps3remote_rdesc;
1087}
1088
1089static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
1090 struct hid_field *field, struct hid_usage *usage,
1091 unsigned long **bit, int *max)
1092{
1093 unsigned int key = usage->hid & HID_USAGE;
1094
1095 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1096 return -1;
1097
1098 switch (usage->collection_index) {
1099 case 1:
1100 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
1101 return -1;
1102
1103 key = ps3remote_keymap_joypad_buttons[key];
1104 if (!key)
1105 return -1;
1106 break;
1107 case 2:
1108 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
1109 return -1;
1110
1111 key = ps3remote_keymap_remote_buttons[key];
1112 if (!key)
1113 return -1;
1114 break;
1115 default:
1116 return -1;
1117 }
1118
1119 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1120 return 1;
1121}
1122
Pavel Machek1adf9042016-02-09 13:55:08 +01001123static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
Nikolai Kondrashov73e40082010-08-06 23:03:06 +04001124 unsigned int *rsize)
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001125{
1126 struct sony_sc *sc = hid_get_drvdata(hdev);
1127
Scott Moreau74500cc2016-01-13 07:40:42 -07001128 if (sc->quirks & SINO_LITE_CONTROLLER)
1129 return rdesc;
1130
Fernando Luis Vázquez Cao99d24902013-01-22 15:20:38 +09001131 /*
1132 * Some Sony RF receivers wrongly declare the mouse pointer as a
1133 * a constant non-data variable.
1134 */
1135 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
1136 /* usage page: generic desktop controls */
1137 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
1138 /* usage: mouse */
1139 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
1140 /* input (usage page for x,y axes): constant, variable, relative */
1141 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
Fernando Luis Vázquez Caoa4649182013-01-15 19:40:48 +09001142 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
Fernando Luis Vázquez Cao99d24902013-01-22 15:20:38 +09001143 /* input: data, variable, relative */
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001144 rdesc[55] = 0x06;
1145 }
Simon Wood61ab44b2011-06-10 12:00:26 +02001146
Frank Prazniked19d8c2014-01-16 21:43:12 -05001147 /*
1148 * The default Dualshock 4 USB descriptor doesn't assign
1149 * the gyroscope values to corresponding axes so we need a
1150 * modified one.
1151 */
Frank Praznikb71b5572015-11-06 15:35:53 -05001152 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
Frank Prazniked19d8c2014-01-16 21:43:12 -05001153 hid_info(hdev, "Using modified Dualshock 4 report descriptor with gyroscope axes\n");
1154 rdesc = dualshock4_usb_rdesc;
1155 *rsize = sizeof(dualshock4_usb_rdesc);
Frank Praznikb71b5572015-11-06 15:35:53 -05001156 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
Frank Praznikd8296742014-02-05 20:03:45 -05001157 hid_info(hdev, "Using modified Dualshock 4 Bluetooth report descriptor\n");
1158 rdesc = dualshock4_bt_rdesc;
1159 *rsize = sizeof(dualshock4_bt_rdesc);
Frank Prazniked19d8c2014-01-16 21:43:12 -05001160 }
1161
Antonio Ospitec607fb82014-06-24 13:28:41 +02001162 if (sc->quirks & SIXAXIS_CONTROLLER)
1163 return sixaxis_fixup(hdev, rdesc, rsize);
Jiri Kosina078328d2013-06-13 12:03:49 +02001164
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001165 if (sc->quirks & MOTION_CONTROLLER)
1166 return motion_fixup(hdev, rdesc, rsize);
1167
Simon Wood4545ee02015-06-17 00:08:52 -06001168 if (sc->quirks & NAVIGATION_CONTROLLER)
Simon Woodb2723eb2015-06-17 00:08:53 -06001169 return navigation_fixup(hdev, rdesc, rsize);
Simon Wood4545ee02015-06-17 00:08:52 -06001170
Jiri Kosina078328d2013-06-13 12:03:49 +02001171 if (sc->quirks & PS3REMOTE)
1172 return ps3remote_fixup(hdev, rdesc, rsize);
1173
Nikolai Kondrashov73e40082010-08-06 23:03:06 +04001174 return rdesc;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02001175}
1176
Pavel Machek1adf9042016-02-09 13:55:08 +01001177static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
Frank Praznikd902f472014-01-27 10:17:36 -05001178{
Pavel Machek1adf9042016-02-09 13:55:08 +01001179 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
Frank Praznikd902f472014-01-27 10:17:36 -05001180 unsigned long flags;
Simon Wood12e9a6d72015-06-09 21:27:05 -06001181 int offset;
Pavel Machek1adf9042016-02-09 13:55:08 +01001182 u8 cable_state, battery_capacity, battery_charging;
Frank Praznikd902f472014-01-27 10:17:36 -05001183
Frank Praznikad142b92014-02-20 11:36:00 -05001184 /*
1185 * The sixaxis is charging if the battery value is 0xee
Frank Praznikd902f472014-01-27 10:17:36 -05001186 * and it is fully charged if the value is 0xef.
1187 * It does not report the actual level while charging so it
1188 * is set to 100% while charging is in progress.
1189 */
Simon Wood12e9a6d72015-06-09 21:27:05 -06001190 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1191
1192 if (rd[offset] >= 0xee) {
Frank Praznikd902f472014-01-27 10:17:36 -05001193 battery_capacity = 100;
Simon Wood12e9a6d72015-06-09 21:27:05 -06001194 battery_charging = !(rd[offset] & 0x01);
Frank Praznik9fddd742014-08-29 13:11:52 -04001195 cable_state = 1;
Frank Praznikd902f472014-01-27 10:17:36 -05001196 } else {
Pavel Machek1adf9042016-02-09 13:55:08 +01001197 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
Frank Praznikac3c9a92014-02-20 11:36:02 -05001198 battery_capacity = sixaxis_battery_capacity[index];
Frank Praznikd902f472014-01-27 10:17:36 -05001199 battery_charging = 0;
Frank Praznik9fddd742014-08-29 13:11:52 -04001200 cable_state = 0;
Frank Praznikd902f472014-01-27 10:17:36 -05001201 }
Frank Praznikd902f472014-01-27 10:17:36 -05001202
1203 spin_lock_irqsave(&sc->lock, flags);
1204 sc->cable_state = cable_state;
1205 sc->battery_capacity = battery_capacity;
1206 sc->battery_charging = battery_charging;
1207 spin_unlock_irqrestore(&sc->lock, flags);
1208}
1209
Pavel Machek1adf9042016-02-09 13:55:08 +01001210static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
Frank Praznikd902f472014-01-27 10:17:36 -05001211{
Frank Praznike5606232014-01-27 10:17:37 -05001212 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1213 struct hid_input, list);
1214 struct input_dev *input_dev = hidinput->input;
Frank Praznikd902f472014-01-27 10:17:36 -05001215 unsigned long flags;
Frank Praznik6c5f8602014-02-05 20:03:47 -05001216 int n, offset;
Pavel Machek1adf9042016-02-09 13:55:08 +01001217 u8 cable_state, battery_capacity, battery_charging;
Frank Praznikd902f472014-01-27 10:17:36 -05001218
Frank Praznikad142b92014-02-20 11:36:00 -05001219 /*
1220 * Battery and touchpad data starts at byte 30 in the USB report and
Frank Praznik6c5f8602014-02-05 20:03:47 -05001221 * 32 in Bluetooth report.
1222 */
1223 offset = (sc->quirks & DUALSHOCK4_CONTROLLER_USB) ? 30 : 32;
1224
Frank Praznikad142b92014-02-20 11:36:00 -05001225 /*
1226 * The lower 4 bits of byte 30 contain the battery level
Frank Praznikd902f472014-01-27 10:17:36 -05001227 * and the 5th bit contains the USB cable state.
1228 */
Frank Praznik6c5f8602014-02-05 20:03:47 -05001229 cable_state = (rd[offset] >> 4) & 0x01;
1230 battery_capacity = rd[offset] & 0x0F;
Frank Praznikd902f472014-01-27 10:17:36 -05001231
Frank Praznikad142b92014-02-20 11:36:00 -05001232 /*
1233 * When a USB power source is connected the battery level ranges from
Frank Praznik6c5f8602014-02-05 20:03:47 -05001234 * 0 to 10, and when running on battery power it ranges from 0 to 9.
1235 * A battery level above 10 when plugged in means charge completed.
Frank Praznikd902f472014-01-27 10:17:36 -05001236 */
Frank Praznik6c5f8602014-02-05 20:03:47 -05001237 if (!cable_state || battery_capacity > 10)
Frank Praznikd902f472014-01-27 10:17:36 -05001238 battery_charging = 0;
1239 else
1240 battery_charging = 1;
1241
Frank Praznik6c5f8602014-02-05 20:03:47 -05001242 if (!cable_state)
1243 battery_capacity++;
Frank Praznikd902f472014-01-27 10:17:36 -05001244 if (battery_capacity > 10)
Frank Praznik6c5f8602014-02-05 20:03:47 -05001245 battery_capacity = 10;
1246
Frank Praznikd902f472014-01-27 10:17:36 -05001247 battery_capacity *= 10;
1248
1249 spin_lock_irqsave(&sc->lock, flags);
1250 sc->cable_state = cable_state;
1251 sc->battery_capacity = battery_capacity;
1252 sc->battery_charging = battery_charging;
1253 spin_unlock_irqrestore(&sc->lock, flags);
Frank Praznike5606232014-01-27 10:17:37 -05001254
Frank Praznik6c5f8602014-02-05 20:03:47 -05001255 offset += 5;
1256
Frank Praznikad142b92014-02-20 11:36:00 -05001257 /*
1258 * The Dualshock 4 multi-touch trackpad data starts at offset 35 on USB
Frank Praznik6c5f8602014-02-05 20:03:47 -05001259 * and 37 on Bluetooth.
Frank Praznike5606232014-01-27 10:17:37 -05001260 * The first 7 bits of the first byte is a counter and bit 8 is a touch
1261 * indicator that is 0 when pressed and 1 when not pressed.
1262 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1263 * The data for the second touch is in the same format and immediatly
1264 * follows the data for the first.
1265 */
1266 for (n = 0; n < 2; n++) {
Pavel Machek1adf9042016-02-09 13:55:08 +01001267 u16 x, y;
Frank Praznike5606232014-01-27 10:17:37 -05001268
1269 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1270 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1271
1272 input_mt_slot(input_dev, n);
1273 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
1274 !(rd[offset] >> 7));
1275 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1276 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1277
1278 offset += 4;
1279 }
Frank Praznikd902f472014-01-27 10:17:36 -05001280}
1281
Simon Woodc9e4d872011-06-10 12:00:27 +02001282static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
Pavel Machek1adf9042016-02-09 13:55:08 +01001283 u8 *rd, int size)
Simon Woodc9e4d872011-06-10 12:00:27 +02001284{
1285 struct sony_sc *sc = hid_get_drvdata(hdev);
1286
Frank Praznikad142b92014-02-20 11:36:00 -05001287 /*
1288 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
Simon Woodc9e4d872011-06-10 12:00:27 +02001289 * has to be BYTE_SWAPPED before passing up to joystick interface
1290 */
Frank Praznikfee4e2d2014-02-18 17:22:01 -05001291 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
Frank Praznik8f5f0bc2015-07-23 19:01:16 -04001292 /*
1293 * When connected via Bluetooth the Sixaxis occasionally sends
1294 * a report with the second byte 0xff and the rest zeroed.
1295 *
1296 * This report does not reflect the actual state of the
1297 * controller must be ignored to avoid generating false input
1298 * events.
1299 */
1300 if (rd[1] == 0xff)
1301 return -EINVAL;
1302
Simon Woodc9e4d872011-06-10 12:00:27 +02001303 swap(rd[41], rd[42]);
1304 swap(rd[43], rd[44]);
1305 swap(rd[45], rd[46]);
1306 swap(rd[47], rd[48]);
Frank Praznikd902f472014-01-27 10:17:36 -05001307
1308 sixaxis_parse_report(sc, rd, size);
Simon Wood12e9a6d72015-06-09 21:27:05 -06001309 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1310 sixaxis_parse_report(sc, rd, size);
Simon Wood4545ee02015-06-17 00:08:52 -06001311 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1312 size == 49) {
1313 sixaxis_parse_report(sc, rd, size);
Frank Praznik68330d82014-02-05 20:03:49 -05001314 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1315 size == 64) || ((sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1316 && rd[0] == 0x11 && size == 78)) {
Frank Praznikd902f472014-01-27 10:17:36 -05001317 dualshock4_parse_report(sc, rd, size);
Simon Woodc9e4d872011-06-10 12:00:27 +02001318 }
1319
1320 return 0;
1321}
1322
Colin Leitnerf04d5142013-05-27 23:41:05 +02001323static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1324 struct hid_field *field, struct hid_usage *usage,
1325 unsigned long **bit, int *max)
1326{
1327 struct sony_sc *sc = hid_get_drvdata(hdev);
1328
1329 if (sc->quirks & BUZZ_CONTROLLER) {
1330 unsigned int key = usage->hid & HID_USAGE;
1331
1332 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1333 return -1;
1334
1335 switch (usage->collection_index) {
1336 case 1:
1337 if (key >= ARRAY_SIZE(buzz_keymap))
1338 return -1;
1339
1340 key = buzz_keymap[key];
1341 if (!key)
1342 return -1;
1343 break;
1344 default:
1345 return -1;
1346 }
1347
1348 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1349 return 1;
1350 }
1351
Jiri Kosina078328d2013-06-13 12:03:49 +02001352 if (sc->quirks & PS3REMOTE)
1353 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1354
Benjamin Tissoires6f498012013-07-24 16:53:07 +02001355 /* Let hid-core decide for the others */
1356 return 0;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001357}
1358
Frank Praznikce8efc32014-09-18 21:15:01 -04001359static int sony_register_touchpad(struct hid_input *hi, int touch_count,
1360 int w, int h)
1361{
1362 struct input_dev *input_dev = hi->input;
1363 int ret;
1364
1365 ret = input_mt_init_slots(input_dev, touch_count, 0);
1366 if (ret < 0)
1367 return ret;
1368
1369 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, w, 0, 0);
1370 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, h, 0, 0);
1371
1372 return 0;
1373}
1374
Dmitry Torokhov91543012015-09-29 15:52:59 -07001375static int sony_input_configured(struct hid_device *hdev,
Frank Praznikce8efc32014-09-18 21:15:01 -04001376 struct hid_input *hidinput)
1377{
1378 struct sony_sc *sc = hid_get_drvdata(hdev);
Dmitry Torokhov91543012015-09-29 15:52:59 -07001379 int ret;
Frank Praznikce8efc32014-09-18 21:15:01 -04001380
1381 /*
1382 * The Dualshock 4 touchpad supports 2 touches and has a
Frank Praznik981c5b42014-09-24 09:38:19 -04001383 * resolution of 1920x942 (44.86 dots/mm).
Frank Praznikce8efc32014-09-18 21:15:01 -04001384 */
1385 if (sc->quirks & DUALSHOCK4_CONTROLLER) {
Dmitry Torokhov91543012015-09-29 15:52:59 -07001386 ret = sony_register_touchpad(hidinput, 2, 1920, 942);
1387 if (ret) {
Frank Praznikce8efc32014-09-18 21:15:01 -04001388 hid_err(sc->hdev,
Dmitry Torokhov91543012015-09-29 15:52:59 -07001389 "Unable to initialize multi-touch slots: %d\n",
1390 ret);
1391 return ret;
1392 }
Frank Praznikce8efc32014-09-18 21:15:01 -04001393 }
Dmitry Torokhov91543012015-09-29 15:52:59 -07001394
1395 return 0;
Frank Praznikce8efc32014-09-18 21:15:01 -04001396}
1397
Antonio Ospite5710fab2011-02-20 18:26:45 +01001398/*
Jiri Slabybd28ce02008-06-25 23:47:04 +02001399 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1400 * to "operational". Without this, the ps3 controller will not report any
1401 * events.
1402 */
Antonio Ospite816651a2010-05-03 22:15:55 +02001403static int sixaxis_set_operational_usb(struct hid_device *hdev)
Jiri Slabybd28ce02008-06-25 23:47:04 +02001404{
Antonio Ospitea85d67b2015-02-16 18:12:22 +01001405 const int buf_size =
1406 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
Pavel Machek1adf9042016-02-09 13:55:08 +01001407 u8 *buf;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001408 int ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001409
Antonio Ospite2e701a32015-02-16 18:12:24 +01001410 buf = kmalloc(buf_size, GFP_KERNEL);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001411 if (!buf)
1412 return -ENOMEM;
1413
Antonio Ospitea85d67b2015-02-16 18:12:22 +01001414 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1415 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001416 if (ret < 0) {
1417 hid_err(hdev, "can't set operational mode: step 1\n");
1418 goto out;
1419 }
Benjamin Tissoiresf204828a2013-09-11 22:12:25 +02001420
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001421 /*
1422 * Some compatible controllers like the Speedlink Strike FX and
1423 * Gasia need another query plus an USB interrupt to get operational.
1424 */
Antonio Ospitea85d67b2015-02-16 18:12:22 +01001425 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1426 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001427 if (ret < 0) {
1428 hid_err(hdev, "can't set operational mode: step 2\n");
1429 goto out;
1430 }
1431
1432 ret = hid_hw_output_report(hdev, buf, 1);
Benjamin Tissoires19f4c2b2016-01-08 17:58:49 +01001433 if (ret < 0) {
1434 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1435 ret = 0;
1436 }
Jiri Slabybd28ce02008-06-25 23:47:04 +02001437
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001438out:
Jiri Slabybd28ce02008-06-25 23:47:04 +02001439 kfree(buf);
1440
1441 return ret;
1442}
1443
Antonio Ospite816651a2010-05-03 22:15:55 +02001444static int sixaxis_set_operational_bt(struct hid_device *hdev)
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00001445{
Pavel Machek1adf9042016-02-09 13:55:08 +01001446 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1447 u8 *buf;
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001448 int ret;
1449
1450 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1451 if (!buf)
1452 return -ENOMEM;
1453
1454 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
Benjamin Tissoiresb0dd72a2014-02-10 12:58:54 -05001455 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001456
1457 kfree(buf);
1458
1459 return ret;
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00001460}
1461
Frank Praznikad142b92014-02-20 11:36:00 -05001462/*
1463 * Requesting feature report 0x02 in Bluetooth mode changes the state of the
Frank Praznik68330d82014-02-05 20:03:49 -05001464 * controller so that it sends full input reports of type 0x11.
1465 */
1466static int dualshock4_set_operational_bt(struct hid_device *hdev)
1467{
Pavel Machek1adf9042016-02-09 13:55:08 +01001468 u8 *buf;
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001469 int ret;
Frank Praznik68330d82014-02-05 20:03:49 -05001470
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001471 buf = kmalloc(DS4_REPORT_0x02_SIZE, GFP_KERNEL);
1472 if (!buf)
1473 return -ENOMEM;
1474
1475 ret = hid_hw_raw_request(hdev, 0x02, buf, DS4_REPORT_0x02_SIZE,
Frank Praznik68330d82014-02-05 20:03:49 -05001476 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001477
1478 kfree(buf);
1479
1480 return ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001481}
1482
Frank Praznik221399b2015-05-05 20:47:32 -04001483static void sixaxis_set_leds_from_id(struct sony_sc *sc)
Frank Praznik80250872014-04-14 10:11:35 -04001484{
Pavel Machek1adf9042016-02-09 13:55:08 +01001485 static const u8 sixaxis_leds[10][4] = {
Frank Praznik80250872014-04-14 10:11:35 -04001486 { 0x01, 0x00, 0x00, 0x00 },
1487 { 0x00, 0x01, 0x00, 0x00 },
1488 { 0x00, 0x00, 0x01, 0x00 },
1489 { 0x00, 0x00, 0x00, 0x01 },
1490 { 0x01, 0x00, 0x00, 0x01 },
1491 { 0x00, 0x01, 0x00, 0x01 },
1492 { 0x00, 0x00, 0x01, 0x01 },
1493 { 0x01, 0x00, 0x01, 0x01 },
1494 { 0x00, 0x01, 0x01, 0x01 },
1495 { 0x01, 0x01, 0x01, 0x01 }
1496 };
1497
Frank Praznik221399b2015-05-05 20:47:32 -04001498 int id = sc->device_id;
1499
1500 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
Frank Praznik80250872014-04-14 10:11:35 -04001501
1502 if (id < 0)
1503 return;
1504
1505 id %= 10;
Frank Praznik221399b2015-05-05 20:47:32 -04001506 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
Frank Praznik80250872014-04-14 10:11:35 -04001507}
1508
Frank Praznik221399b2015-05-05 20:47:32 -04001509static void dualshock4_set_leds_from_id(struct sony_sc *sc)
Frank Praznik80250872014-04-14 10:11:35 -04001510{
1511 /* The first 4 color/index entries match what the PS4 assigns */
Pavel Machek1adf9042016-02-09 13:55:08 +01001512 static const u8 color_code[7][3] = {
Frank Praznik80250872014-04-14 10:11:35 -04001513 /* Blue */ { 0x00, 0x00, 0x01 },
1514 /* Red */ { 0x01, 0x00, 0x00 },
1515 /* Green */ { 0x00, 0x01, 0x00 },
1516 /* Pink */ { 0x02, 0x00, 0x01 },
1517 /* Orange */ { 0x02, 0x01, 0x00 },
1518 /* Teal */ { 0x00, 0x01, 0x01 },
1519 /* White */ { 0x01, 0x01, 0x01 }
1520 };
1521
Frank Praznik221399b2015-05-05 20:47:32 -04001522 int id = sc->device_id;
1523
1524 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
Frank Praznik80250872014-04-14 10:11:35 -04001525
1526 if (id < 0)
1527 return;
1528
1529 id %= 7;
Frank Praznik221399b2015-05-05 20:47:32 -04001530 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
Frank Praznik80250872014-04-14 10:11:35 -04001531}
1532
Frank Praznik221399b2015-05-05 20:47:32 -04001533static void buzz_set_leds(struct sony_sc *sc)
Colin Leitnerf04d5142013-05-27 23:41:05 +02001534{
Frank Praznik221399b2015-05-05 20:47:32 -04001535 struct hid_device *hdev = sc->hdev;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001536 struct list_head *report_list =
1537 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1538 struct hid_report *report = list_entry(report_list->next,
1539 struct hid_report, list);
Pavel Machek1adf9042016-02-09 13:55:08 +01001540 s32 *value = report->field[0]->value;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001541
Frank Praznik221399b2015-05-05 20:47:32 -04001542 BUILD_BUG_ON(MAX_LEDS < 4);
1543
Colin Leitnerf04d5142013-05-27 23:41:05 +02001544 value[0] = 0x00;
Frank Praznik221399b2015-05-05 20:47:32 -04001545 value[1] = sc->led_state[0] ? 0xff : 0x00;
1546 value[2] = sc->led_state[1] ? 0xff : 0x00;
1547 value[3] = sc->led_state[2] ? 0xff : 0x00;
1548 value[4] = sc->led_state[3] ? 0xff : 0x00;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001549 value[5] = 0x00;
1550 value[6] = 0x00;
1551 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1552}
1553
Frank Praznik221399b2015-05-05 20:47:32 -04001554static void sony_set_leds(struct sony_sc *sc)
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001555{
Frank Praznik221399b2015-05-05 20:47:32 -04001556 if (!(sc->quirks & BUZZ_CONTROLLER))
Frank Praznikfa57a812014-04-14 10:11:33 -04001557 schedule_work(&sc->state_worker);
Frank Praznik221399b2015-05-05 20:47:32 -04001558 else
1559 buzz_set_leds(sc);
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001560}
1561
Sven Eckelmannc5382512013-11-19 20:26:30 +01001562static void sony_led_set_brightness(struct led_classdev *led,
Colin Leitnerf04d5142013-05-27 23:41:05 +02001563 enum led_brightness value)
1564{
1565 struct device *dev = led->dev->parent;
Geliang Tangee79a8f2015-12-27 17:25:21 +08001566 struct hid_device *hdev = to_hid_device(dev);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001567 struct sony_sc *drv_data;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001568
1569 int n;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001570 int force_update;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001571
1572 drv_data = hid_get_drvdata(hdev);
Sven Eckelmann2251b852013-11-19 20:26:31 +01001573 if (!drv_data) {
Colin Leitnerf04d5142013-05-27 23:41:05 +02001574 hid_err(hdev, "No device data\n");
1575 return;
1576 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02001577
Frank Praznikb3ed4582014-04-14 10:11:36 -04001578 /*
1579 * The Sixaxis on USB will override any LED settings sent to it
1580 * and keep flashing all of the LEDs until the PS button is pressed.
1581 * Updates, even if redundant, must be always be sent to the
1582 * controller to avoid having to toggle the state of an LED just to
1583 * stop the flashing later on.
1584 */
1585 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1586
Frank Praznik60781cf2014-01-11 15:13:15 -05001587 for (n = 0; n < drv_data->led_count; n++) {
Frank Praznikb3ed4582014-04-14 10:11:36 -04001588 if (led == drv_data->leds[n] && (force_update ||
1589 (value != drv_data->led_state[n] ||
1590 drv_data->led_delay_on[n] ||
1591 drv_data->led_delay_off[n]))) {
1592
1593 drv_data->led_state[n] = value;
1594
1595 /* Setting the brightness stops the blinking */
1596 drv_data->led_delay_on[n] = 0;
1597 drv_data->led_delay_off[n] = 0;
1598
Frank Praznik221399b2015-05-05 20:47:32 -04001599 sony_set_leds(drv_data);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001600 break;
1601 }
1602 }
1603}
1604
Sven Eckelmannc5382512013-11-19 20:26:30 +01001605static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
Colin Leitnerf04d5142013-05-27 23:41:05 +02001606{
1607 struct device *dev = led->dev->parent;
Geliang Tangee79a8f2015-12-27 17:25:21 +08001608 struct hid_device *hdev = to_hid_device(dev);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001609 struct sony_sc *drv_data;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001610
1611 int n;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001612
1613 drv_data = hid_get_drvdata(hdev);
Sven Eckelmann2251b852013-11-19 20:26:31 +01001614 if (!drv_data) {
Colin Leitnerf04d5142013-05-27 23:41:05 +02001615 hid_err(hdev, "No device data\n");
1616 return LED_OFF;
1617 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02001618
Frank Praznik60781cf2014-01-11 15:13:15 -05001619 for (n = 0; n < drv_data->led_count; n++) {
Simon Wood7db75042014-02-05 12:34:18 -07001620 if (led == drv_data->leds[n])
1621 return drv_data->led_state[n];
Colin Leitnerf04d5142013-05-27 23:41:05 +02001622 }
1623
Simon Wood7db75042014-02-05 12:34:18 -07001624 return LED_OFF;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001625}
Colin Leitnerf04d5142013-05-27 23:41:05 +02001626
Frank Praznikb3ed4582014-04-14 10:11:36 -04001627static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1628 unsigned long *delay_off)
1629{
1630 struct device *dev = led->dev->parent;
Geliang Tangee79a8f2015-12-27 17:25:21 +08001631 struct hid_device *hdev = to_hid_device(dev);
Frank Praznikb3ed4582014-04-14 10:11:36 -04001632 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1633 int n;
Pavel Machek1adf9042016-02-09 13:55:08 +01001634 u8 new_on, new_off;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001635
1636 if (!drv_data) {
1637 hid_err(hdev, "No device data\n");
1638 return -EINVAL;
1639 }
1640
1641 /* Max delay is 255 deciseconds or 2550 milliseconds */
1642 if (*delay_on > 2550)
1643 *delay_on = 2550;
1644 if (*delay_off > 2550)
1645 *delay_off = 2550;
1646
1647 /* Blink at 1 Hz if both values are zero */
1648 if (!*delay_on && !*delay_off)
1649 *delay_on = *delay_off = 500;
1650
1651 new_on = *delay_on / 10;
1652 new_off = *delay_off / 10;
1653
1654 for (n = 0; n < drv_data->led_count; n++) {
1655 if (led == drv_data->leds[n])
1656 break;
1657 }
1658
1659 /* This LED is not registered on this device */
1660 if (n >= drv_data->led_count)
1661 return -EINVAL;
1662
1663 /* Don't schedule work if the values didn't change */
1664 if (new_on != drv_data->led_delay_on[n] ||
1665 new_off != drv_data->led_delay_off[n]) {
1666 drv_data->led_delay_on[n] = new_on;
1667 drv_data->led_delay_off[n] = new_off;
1668 schedule_work(&drv_data->state_worker);
1669 }
1670
1671 return 0;
1672}
1673
Frank Praznikfa57a812014-04-14 10:11:33 -04001674static void sony_leds_remove(struct sony_sc *sc)
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001675{
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001676 struct led_classdev *led;
1677 int n;
1678
Frank Praznikfa57a812014-04-14 10:11:33 -04001679 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001680
Frank Praznikfa57a812014-04-14 10:11:33 -04001681 for (n = 0; n < sc->led_count; n++) {
1682 led = sc->leds[n];
1683 sc->leds[n] = NULL;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001684 if (!led)
1685 continue;
1686 led_classdev_unregister(led);
1687 kfree(led);
1688 }
Frank Praznik60781cf2014-01-11 15:13:15 -05001689
Frank Praznikfa57a812014-04-14 10:11:33 -04001690 sc->led_count = 0;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001691}
1692
Frank Praznikfa57a812014-04-14 10:11:33 -04001693static int sony_leds_init(struct sony_sc *sc)
Colin Leitnerf04d5142013-05-27 23:41:05 +02001694{
Frank Praznikfa57a812014-04-14 10:11:33 -04001695 struct hid_device *hdev = sc->hdev;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001696 int n, ret = 0;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001697 int use_ds4_names;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001698 struct led_classdev *led;
1699 size_t name_sz;
1700 char *name;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001701 size_t name_len;
1702 const char *name_fmt;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001703 static const char * const ds4_name_str[] = { "red", "green", "blue",
1704 "global" };
Pavel Machek1adf9042016-02-09 13:55:08 +01001705 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1706 u8 use_hw_blink[MAX_LEDS] = { 0 };
Colin Leitnerf04d5142013-05-27 23:41:05 +02001707
Frank Praznikfa57a812014-04-14 10:11:33 -04001708 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
Colin Leitnerf04d5142013-05-27 23:41:05 +02001709
Frank Praznikfa57a812014-04-14 10:11:33 -04001710 if (sc->quirks & BUZZ_CONTROLLER) {
1711 sc->led_count = 4;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001712 use_ds4_names = 0;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001713 name_len = strlen("::buzz#");
1714 name_fmt = "%s::buzz%d";
1715 /* Validate expected report characteristics. */
1716 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1717 return -ENODEV;
Frank Praznikfa57a812014-04-14 10:11:33 -04001718 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
Frank Praznik221399b2015-05-05 20:47:32 -04001719 dualshock4_set_leds_from_id(sc);
1720 sc->led_state[3] = 1;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001721 sc->led_count = 4;
1722 memset(max_brightness, 255, 3);
1723 use_hw_blink[3] = 1;
1724 use_ds4_names = 1;
Frank Praznik61ebca92014-01-20 12:27:02 -05001725 name_len = 0;
1726 name_fmt = "%s:%s";
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001727 } else if (sc->quirks & MOTION_CONTROLLER) {
1728 sc->led_count = 3;
1729 memset(max_brightness, 255, 3);
1730 use_ds4_names = 1;
1731 name_len = 0;
1732 name_fmt = "%s:%s";
Simon Wood4545ee02015-06-17 00:08:52 -06001733 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
Pavel Machek1adf9042016-02-09 13:55:08 +01001734 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
Simon Wood4545ee02015-06-17 00:08:52 -06001735
1736 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1737 sc->led_count = 1;
1738 memset(use_hw_blink, 1, 4);
1739 use_ds4_names = 0;
1740 name_len = strlen("::sony#");
1741 name_fmt = "%s::sony%d";
Frank Praznik60781cf2014-01-11 15:13:15 -05001742 } else {
Frank Praznik221399b2015-05-05 20:47:32 -04001743 sixaxis_set_leds_from_id(sc);
Frank Praznikfa57a812014-04-14 10:11:33 -04001744 sc->led_count = 4;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001745 memset(use_hw_blink, 1, 4);
1746 use_ds4_names = 0;
Frank Praznik61ebca92014-01-20 12:27:02 -05001747 name_len = strlen("::sony#");
1748 name_fmt = "%s::sony%d";
Frank Praznik60781cf2014-01-11 15:13:15 -05001749 }
1750
Frank Praznikad142b92014-02-20 11:36:00 -05001751 /*
1752 * Clear LEDs as we have no way of reading their initial state. This is
Colin Leitnerf04d5142013-05-27 23:41:05 +02001753 * only relevant if the driver is loaded after somebody actively set the
Frank Praznikad142b92014-02-20 11:36:00 -05001754 * LEDs to on
1755 */
Frank Praznik221399b2015-05-05 20:47:32 -04001756 sony_set_leds(sc);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001757
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001758 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001759
Frank Praznikfa57a812014-04-14 10:11:33 -04001760 for (n = 0; n < sc->led_count; n++) {
Frank Praznik61ebca92014-01-20 12:27:02 -05001761
Frank Praznikb3ed4582014-04-14 10:11:36 -04001762 if (use_ds4_names)
1763 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
Frank Praznik61ebca92014-01-20 12:27:02 -05001764
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001765 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1766 if (!led) {
1767 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
Julia Lawall8cd5fcd2013-12-29 23:47:27 +01001768 ret = -ENOMEM;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001769 goto error_leds;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001770 }
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001771
1772 name = (void *)(&led[1]);
Frank Praznikb3ed4582014-04-14 10:11:36 -04001773 if (use_ds4_names)
1774 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1775 ds4_name_str[n]);
Frank Praznik61ebca92014-01-20 12:27:02 -05001776 else
1777 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001778 led->name = name;
Frank Praznik221399b2015-05-05 20:47:32 -04001779 led->brightness = sc->led_state[n];
Frank Praznikb3ed4582014-04-14 10:11:36 -04001780 led->max_brightness = max_brightness[n];
Sven Eckelmannc5382512013-11-19 20:26:30 +01001781 led->brightness_get = sony_led_get_brightness;
1782 led->brightness_set = sony_led_set_brightness;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001783
Frank Praznikb3ed4582014-04-14 10:11:36 -04001784 if (use_hw_blink[n])
1785 led->blink_set = sony_led_blink_set;
1786
Frank Praznik80250872014-04-14 10:11:35 -04001787 sc->leds[n] = led;
1788
Julia Lawall8cd5fcd2013-12-29 23:47:27 +01001789 ret = led_classdev_register(&hdev->dev, led);
1790 if (ret) {
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001791 hid_err(hdev, "Failed to register LED %d\n", n);
Frank Praznik80250872014-04-14 10:11:35 -04001792 sc->leds[n] = NULL;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02001793 kfree(led);
1794 goto error_leds;
1795 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02001796 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02001797
1798 return ret;
1799
Colin Leitnerf04d5142013-05-27 23:41:05 +02001800error_leds:
Frank Praznikfa57a812014-04-14 10:11:33 -04001801 sony_leds_remove(sc);
Colin Leitnerf04d5142013-05-27 23:41:05 +02001802
Colin Leitnerf04d5142013-05-27 23:41:05 +02001803 return ret;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001804}
1805
Frank Praznikd8aaccd2015-11-11 09:49:37 -05001806static void sixaxis_send_output_report(struct sony_sc *sc)
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001807{
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001808 static const union sixaxis_output_report_01 default_report = {
Frank Praznik55d3b662014-04-14 10:11:32 -04001809 .buf = {
1810 0x01,
Scott Moreauad07b7a2016-01-13 07:40:43 -07001811 0x01, 0xff, 0x00, 0xff, 0x00,
Frank Praznik55d3b662014-04-14 10:11:32 -04001812 0x00, 0x00, 0x00, 0x00, 0x00,
1813 0xff, 0x27, 0x10, 0x00, 0x32,
1814 0xff, 0x27, 0x10, 0x00, 0x32,
1815 0xff, 0x27, 0x10, 0x00, 0x32,
1816 0xff, 0x27, 0x10, 0x00, 0x32,
1817 0x00, 0x00, 0x00, 0x00, 0x00
1818 }
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001819 };
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001820 struct sixaxis_output_report *report =
1821 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1822 int n;
1823
1824 /* Initialize the report with default values */
1825 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001826
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001827#ifdef CONFIG_SONY_FF
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001828 report->rumble.right_motor_on = sc->right ? 1 : 0;
1829 report->rumble.left_motor_force = sc->left;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001830#endif
1831
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001832 report->leds_bitmap |= sc->led_state[0] << 1;
1833 report->leds_bitmap |= sc->led_state[1] << 2;
1834 report->leds_bitmap |= sc->led_state[2] << 3;
1835 report->leds_bitmap |= sc->led_state[3] << 4;
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001836
Simon Wood88f65762014-04-14 10:11:37 -04001837 /* Set flag for all leds off, required for 3rd party INTEC controller */
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001838 if ((report->leds_bitmap & 0x1E) == 0)
1839 report->leds_bitmap |= 0x20;
Simon Wood88f65762014-04-14 10:11:37 -04001840
Frank Praznikb3ed4582014-04-14 10:11:36 -04001841 /*
1842 * The LEDs in the report are indexed in reverse order to their
1843 * corresponding light on the controller.
1844 * Index 0 = LED 4, index 1 = LED 3, etc...
1845 *
1846 * In the case of both delay values being zero (blinking disabled) the
1847 * default report values should be used or the controller LED will be
1848 * always off.
1849 */
1850 for (n = 0; n < 4; n++) {
1851 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001852 report->led[3 - n].duty_off = sc->led_delay_off[n];
1853 report->led[3 - n].duty_on = sc->led_delay_on[n];
Frank Praznikb3ed4582014-04-14 10:11:36 -04001854 }
1855 }
1856
Pavel Machek1adf9042016-02-09 13:55:08 +01001857 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001858 sizeof(struct sixaxis_output_report),
1859 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001860}
1861
Frank Praznikd8aaccd2015-11-11 09:49:37 -05001862static void dualshock4_send_output_report(struct sony_sc *sc)
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001863{
Frank Praznik0da8ea62014-01-16 21:42:51 -05001864 struct hid_device *hdev = sc->hdev;
Pavel Machek1adf9042016-02-09 13:55:08 +01001865 u8 *buf = sc->output_report_dmabuf;
Frank Praznik48220232014-02-05 20:03:44 -05001866 int offset;
Frank Praznik0da8ea62014-01-16 21:42:51 -05001867
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001868 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001869 memset(buf, 0, DS4_REPORT_0x05_SIZE);
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001870 buf[0] = 0x05;
Frank Praznikb3ed4582014-04-14 10:11:36 -04001871 buf[1] = 0xFF;
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001872 offset = 4;
1873 } else {
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001874 memset(buf, 0, DS4_REPORT_0x11_SIZE);
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001875 buf[0] = 0x11;
Rostislav Pehlivanov824deff2015-07-28 08:38:47 +01001876 buf[1] = 0x80;
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001877 buf[3] = 0x0F;
1878 offset = 6;
1879 }
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001880
1881#ifdef CONFIG_SONY_FF
Frank Praznik48220232014-02-05 20:03:44 -05001882 buf[offset++] = sc->right;
1883 buf[offset++] = sc->left;
1884#else
1885 offset += 2;
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001886#endif
1887
Frank Praznikb3ed4582014-04-14 10:11:36 -04001888 /* LED 3 is the global control */
1889 if (sc->led_state[3]) {
1890 buf[offset++] = sc->led_state[0];
1891 buf[offset++] = sc->led_state[1];
1892 buf[offset++] = sc->led_state[2];
1893 } else {
1894 offset += 3;
1895 }
1896
1897 /* If both delay values are zero the DualShock 4 disables blinking. */
1898 buf[offset++] = sc->led_delay_on[3];
1899 buf[offset++] = sc->led_delay_off[3];
Frank Praznik60781cf2014-01-11 15:13:15 -05001900
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001901 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001902 hid_hw_output_report(hdev, buf, DS4_REPORT_0x05_SIZE);
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001903 else
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001904 hid_hw_raw_request(hdev, 0x11, buf, DS4_REPORT_0x11_SIZE,
Frank Praznikfdcf105d2014-02-05 20:03:46 -05001905 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001906}
1907
Frank Praznikd8aaccd2015-11-11 09:49:37 -05001908static void motion_send_output_report(struct sony_sc *sc)
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001909{
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001910 struct hid_device *hdev = sc->hdev;
1911 struct motion_output_report_02 *report =
1912 (struct motion_output_report_02 *)sc->output_report_dmabuf;
1913
Simon Wood41d2d422015-06-09 21:27:06 -06001914 memset(report, 0, MOTION_REPORT_0x02_SIZE);
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001915
1916 report->type = 0x02; /* set leds */
1917 report->r = sc->led_state[0];
1918 report->g = sc->led_state[1];
1919 report->b = sc->led_state[2];
1920
1921#ifdef CONFIG_SONY_FF
1922 report->rumble = max(sc->right, sc->left);
1923#endif
1924
Pavel Machek1adf9042016-02-09 13:55:08 +01001925 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001926}
1927
Frank Praznikdecd9462015-11-11 09:49:38 -05001928static inline void sony_send_output_report(struct sony_sc *sc)
1929{
1930 if (sc->send_output_report)
1931 sc->send_output_report(sc);
1932}
1933
Frank Praznikd8aaccd2015-11-11 09:49:37 -05001934static void sony_state_worker(struct work_struct *work)
1935{
1936 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
Antonio Ospiteef916ef2016-02-09 13:55:07 +01001937
Frank Praznikd8aaccd2015-11-11 09:49:37 -05001938 sc->send_output_report(sc);
1939}
1940
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001941static int sony_allocate_output_report(struct sony_sc *sc)
1942{
Simon Wood4545ee02015-06-17 00:08:52 -06001943 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
1944 (sc->quirks & NAVIGATION_CONTROLLER))
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001945 sc->output_report_dmabuf =
1946 kmalloc(sizeof(union sixaxis_output_report_01),
1947 GFP_KERNEL);
1948 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
1949 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x11_SIZE,
1950 GFP_KERNEL);
1951 else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB)
1952 sc->output_report_dmabuf = kmalloc(DS4_REPORT_0x05_SIZE,
1953 GFP_KERNEL);
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04001954 else if (sc->quirks & MOTION_CONTROLLER)
Simon Wood41d2d422015-06-09 21:27:06 -06001955 sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
1956 GFP_KERNEL);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001957 else
1958 return 0;
1959
1960 if (!sc->output_report_dmabuf)
1961 return -ENOMEM;
1962
1963 return 0;
1964}
1965
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001966#ifdef CONFIG_SONY_FF
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001967static int sony_play_effect(struct input_dev *dev, void *data,
1968 struct ff_effect *effect)
1969{
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001970 struct hid_device *hid = input_get_drvdata(dev);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001971 struct sony_sc *sc = hid_get_drvdata(hid);
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001972
1973 if (effect->type != FF_RUMBLE)
1974 return 0;
1975
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001976 sc->left = effect->u.rumble.strong_magnitude / 256;
Frank Praznik0bd88dd2014-01-11 15:12:42 -05001977 sc->right = effect->u.rumble.weak_magnitude / 256;
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001978
Sven Eckelmann92b5c412013-11-19 20:26:28 +01001979 schedule_work(&sc->state_worker);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001980 return 0;
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001981}
1982
Frank Praznikfa57a812014-04-14 10:11:33 -04001983static int sony_init_ff(struct sony_sc *sc)
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001984{
Frank Praznikfa57a812014-04-14 10:11:33 -04001985 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001986 struct hid_input, list);
1987 struct input_dev *input_dev = hidinput->input;
1988
1989 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
1990 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
1991}
1992
1993#else
Frank Praznikfa57a812014-04-14 10:11:33 -04001994static int sony_init_ff(struct sony_sc *sc)
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001995{
1996 return 0;
1997}
Sven Eckelmann9f323b62013-11-17 20:38:21 +01001998
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01001999#endif
2000
Frank Praznikd902f472014-01-27 10:17:36 -05002001static int sony_battery_get_property(struct power_supply *psy,
2002 enum power_supply_property psp,
2003 union power_supply_propval *val)
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002004{
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002005 struct sony_sc *sc = power_supply_get_drvdata(psy);
Frank Praznikd902f472014-01-27 10:17:36 -05002006 unsigned long flags;
2007 int ret = 0;
2008 u8 battery_charging, battery_capacity, cable_state;
2009
2010 spin_lock_irqsave(&sc->lock, flags);
2011 battery_charging = sc->battery_charging;
2012 battery_capacity = sc->battery_capacity;
2013 cable_state = sc->cable_state;
2014 spin_unlock_irqrestore(&sc->lock, flags);
2015
2016 switch (psp) {
2017 case POWER_SUPPLY_PROP_PRESENT:
2018 val->intval = 1;
2019 break;
2020 case POWER_SUPPLY_PROP_SCOPE:
2021 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2022 break;
2023 case POWER_SUPPLY_PROP_CAPACITY:
2024 val->intval = battery_capacity;
2025 break;
2026 case POWER_SUPPLY_PROP_STATUS:
2027 if (battery_charging)
2028 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2029 else
2030 if (battery_capacity == 100 && cable_state)
2031 val->intval = POWER_SUPPLY_STATUS_FULL;
2032 else
2033 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2034 break;
2035 default:
2036 ret = -EINVAL;
2037 break;
2038 }
2039 return ret;
2040}
2041
2042static int sony_battery_probe(struct sony_sc *sc)
2043{
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002044 struct power_supply_config psy_cfg = { .drv_data = sc, };
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002045 struct hid_device *hdev = sc->hdev;
Frank Praznikd902f472014-01-27 10:17:36 -05002046 int ret;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002047
Frank Praznikad142b92014-02-20 11:36:00 -05002048 /*
2049 * Set the default battery level to 100% to avoid low battery warnings
Frank Praznikd9a293a2014-02-05 20:03:48 -05002050 * if the battery is polled before the first device report is received.
2051 */
2052 sc->battery_capacity = 100;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002053
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002054 sc->battery_desc.properties = sony_battery_props;
2055 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2056 sc->battery_desc.get_property = sony_battery_get_property;
2057 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2058 sc->battery_desc.use_for_apm = 0;
2059 sc->battery_desc.name = kasprintf(GFP_KERNEL,
2060 "sony_controller_battery_%pMR",
2061 sc->mac_address);
2062 if (!sc->battery_desc.name)
Frank Praznikd902f472014-01-27 10:17:36 -05002063 return -ENOMEM;
2064
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002065 sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
2066 &psy_cfg);
2067 if (IS_ERR(sc->battery)) {
2068 ret = PTR_ERR(sc->battery);
Frank Praznikd902f472014-01-27 10:17:36 -05002069 hid_err(hdev, "Unable to register battery device\n");
2070 goto err_free;
2071 }
2072
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002073 power_supply_powers(sc->battery, &hdev->dev);
Frank Praznikd902f472014-01-27 10:17:36 -05002074 return 0;
2075
2076err_free:
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002077 kfree(sc->battery_desc.name);
2078 sc->battery_desc.name = NULL;
Frank Praznikd902f472014-01-27 10:17:36 -05002079 return ret;
2080}
2081
2082static void sony_battery_remove(struct sony_sc *sc)
2083{
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002084 if (!sc->battery_desc.name)
Frank Praznikd902f472014-01-27 10:17:36 -05002085 return;
2086
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002087 power_supply_unregister(sc->battery);
2088 kfree(sc->battery_desc.name);
2089 sc->battery_desc.name = NULL;
Frank Praznikd902f472014-01-27 10:17:36 -05002090}
2091
Frank Praznikd2d782f2014-02-20 11:36:03 -05002092/*
2093 * If a controller is plugged in via USB while already connected via Bluetooth
2094 * it will show up as two devices. A global list of connected controllers and
2095 * their MAC addresses is maintained to ensure that a device is only connected
2096 * once.
2097 */
2098static int sony_check_add_dev_list(struct sony_sc *sc)
2099{
2100 struct sony_sc *entry;
2101 unsigned long flags;
2102 int ret;
2103
2104 spin_lock_irqsave(&sony_dev_list_lock, flags);
2105
2106 list_for_each_entry(entry, &sony_device_list, list_node) {
2107 ret = memcmp(sc->mac_address, entry->mac_address,
2108 sizeof(sc->mac_address));
2109 if (!ret) {
2110 ret = -EEXIST;
2111 hid_info(sc->hdev, "controller with MAC address %pMR already connected\n",
2112 sc->mac_address);
2113 goto unlock;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002114 }
2115 }
2116
Frank Praznikd2d782f2014-02-20 11:36:03 -05002117 ret = 0;
2118 list_add(&(sc->list_node), &sony_device_list);
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002119
Frank Praznikd2d782f2014-02-20 11:36:03 -05002120unlock:
2121 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2122 return ret;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002123}
2124
Frank Praznikd2d782f2014-02-20 11:36:03 -05002125static void sony_remove_dev_list(struct sony_sc *sc)
2126{
2127 unsigned long flags;
2128
2129 if (sc->list_node.next) {
2130 spin_lock_irqsave(&sony_dev_list_lock, flags);
2131 list_del(&(sc->list_node));
2132 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2133 }
2134}
2135
2136static int sony_get_bt_devaddr(struct sony_sc *sc)
2137{
2138 int ret;
2139
2140 /* HIDP stores the device MAC address as a string in the uniq field. */
2141 ret = strlen(sc->hdev->uniq);
2142 if (ret != 17)
2143 return -EINVAL;
2144
2145 ret = sscanf(sc->hdev->uniq,
2146 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2147 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2148 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2149
2150 if (ret != 6)
2151 return -EINVAL;
2152
2153 return 0;
2154}
2155
2156static int sony_check_add(struct sony_sc *sc)
2157{
Pavel Machek1adf9042016-02-09 13:55:08 +01002158 u8 *buf = NULL;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002159 int n, ret;
2160
2161 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
Simon Wood12e9a6d72015-06-09 21:27:05 -06002162 (sc->quirks & MOTION_CONTROLLER_BT) ||
Simon Wood4545ee02015-06-17 00:08:52 -06002163 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
Frank Praznikd2d782f2014-02-20 11:36:03 -05002164 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2165 /*
2166 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2167 * address from the uniq string where HIDP stores it.
2168 * As uniq cannot be guaranteed to be a MAC address in all cases
2169 * a failure of this function should not prevent the connection.
2170 */
2171 if (sony_get_bt_devaddr(sc) < 0) {
2172 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2173 return 0;
2174 }
2175 } else if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002176 buf = kmalloc(DS4_REPORT_0x81_SIZE, GFP_KERNEL);
2177 if (!buf)
2178 return -ENOMEM;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002179
2180 /*
2181 * The MAC address of a DS4 controller connected via USB can be
2182 * retrieved with feature report 0x81. The address begins at
2183 * offset 1.
2184 */
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002185 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2186 DS4_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2187 HID_REQ_GET_REPORT);
Frank Praznikd2d782f2014-02-20 11:36:03 -05002188
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002189 if (ret != DS4_REPORT_0x81_SIZE) {
Frank Praznikd2d782f2014-02-20 11:36:03 -05002190 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002191 ret = ret < 0 ? ret : -EINVAL;
2192 goto out_free;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002193 }
2194
2195 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
Simon Wood4545ee02015-06-17 00:08:52 -06002196 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2197 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002198 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2199 if (!buf)
2200 return -ENOMEM;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002201
2202 /*
2203 * The MAC address of a Sixaxis controller connected via USB can
2204 * be retrieved with feature report 0xf2. The address begins at
2205 * offset 4.
2206 */
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002207 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2208 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2209 HID_REQ_GET_REPORT);
Frank Praznikd2d782f2014-02-20 11:36:03 -05002210
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002211 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
Frank Praznikd2d782f2014-02-20 11:36:03 -05002212 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002213 ret = ret < 0 ? ret : -EINVAL;
2214 goto out_free;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002215 }
2216
2217 /*
2218 * The Sixaxis device MAC in the report is big-endian and must
2219 * be byte-swapped.
2220 */
2221 for (n = 0; n < 6; n++)
2222 sc->mac_address[5-n] = buf[4+n];
2223 } else {
2224 return 0;
2225 }
2226
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002227 ret = sony_check_add_dev_list(sc);
2228
2229out_free:
2230
2231 kfree(buf);
2232
2233 return ret;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002234}
2235
Frank Praznik80250872014-04-14 10:11:35 -04002236static int sony_set_device_id(struct sony_sc *sc)
2237{
2238 int ret;
2239
2240 /*
2241 * Only DualShock 4 or Sixaxis controllers get an id.
2242 * All others are set to -1.
2243 */
2244 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2245 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2246 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2247 GFP_KERNEL);
2248 if (ret < 0) {
2249 sc->device_id = -1;
2250 return ret;
2251 }
2252 sc->device_id = ret;
2253 } else {
2254 sc->device_id = -1;
2255 }
2256
2257 return 0;
2258}
2259
2260static void sony_release_device_id(struct sony_sc *sc)
2261{
2262 if (sc->device_id >= 0) {
2263 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2264 sc->device_id = -1;
2265 }
2266}
2267
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002268static inline void sony_init_output_report(struct sony_sc *sc,
Antonio Ospite09593e32016-02-09 13:55:06 +01002269 void (*send_output_report)(struct sony_sc *))
Frank Praznik46262042014-04-14 10:11:31 -04002270{
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002271 sc->send_output_report = send_output_report;
2272
Frank Praznik46262042014-04-14 10:11:31 -04002273 if (!sc->worker_initialized)
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002274 INIT_WORK(&sc->state_worker, sony_state_worker);
Frank Praznik46262042014-04-14 10:11:31 -04002275
2276 sc->worker_initialized = 1;
2277}
2278
2279static inline void sony_cancel_work_sync(struct sony_sc *sc)
2280{
2281 if (sc->worker_initialized)
2282 cancel_work_sync(&sc->state_worker);
2283}
Frank Praznikd2d782f2014-02-20 11:36:03 -05002284
Jiri Slabybd28ce02008-06-25 23:47:04 +02002285static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2286{
2287 int ret;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02002288 unsigned long quirks = id->driver_data;
2289 struct sony_sc *sc;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002290 unsigned int connect_mask = HID_CONNECT_DEFAULT;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02002291
Benjamin Tissoiresabf832b2013-07-24 19:38:04 +02002292 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02002293 if (sc == NULL) {
Joe Perches4291ee32010-12-09 19:29:03 -08002294 hid_err(hdev, "can't alloc sony descriptor\n");
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02002295 return -ENOMEM;
2296 }
2297
Frank Praznikb94993f2015-02-22 20:42:46 -05002298 spin_lock_init(&sc->lock);
2299
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02002300 sc->quirks = quirks;
2301 hid_set_drvdata(hdev, sc);
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002302 sc->hdev = hdev;
Jiri Slabybd28ce02008-06-25 23:47:04 +02002303
Jiri Slabybd28ce02008-06-25 23:47:04 +02002304 ret = hid_parse(hdev);
2305 if (ret) {
Joe Perches4291ee32010-12-09 19:29:03 -08002306 hid_err(hdev, "parse failed\n");
Benjamin Tissoiresabf832b2013-07-24 19:38:04 +02002307 return ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02002308 }
2309
Colin Leitnerf04d5142013-05-27 23:41:05 +02002310 if (sc->quirks & VAIO_RDESC_CONSTANT)
2311 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
Antonio Ospite50764652014-06-24 13:28:40 +02002312 else if (sc->quirks & SIXAXIS_CONTROLLER)
Colin Leitnerf04d5142013-05-27 23:41:05 +02002313 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2314
2315 ret = hid_hw_start(hdev, connect_mask);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002316 if (ret) {
Joe Perches4291ee32010-12-09 19:29:03 -08002317 hid_err(hdev, "hw start failed\n");
Benjamin Tissoiresabf832b2013-07-24 19:38:04 +02002318 return ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02002319 }
2320
Frank Praznik80250872014-04-14 10:11:35 -04002321 ret = sony_set_device_id(sc);
2322 if (ret < 0) {
2323 hid_err(hdev, "failed to allocate the device id\n");
2324 goto err_stop;
2325 }
2326
Frank Praznik131a8a92015-05-05 20:47:28 -04002327 ret = sony_allocate_output_report(sc);
2328 if (ret < 0) {
2329 hid_err(hdev, "failed to allocate the output report buffer\n");
2330 goto err_stop;
2331 }
2332
Simon Wood4545ee02015-06-17 00:08:52 -06002333 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2334 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
Benjamin Tissoirese534a932014-03-08 22:52:42 -05002335 /*
2336 * The Sony Sixaxis does not handle HID Output Reports on the
2337 * Interrupt EP like it could, so we need to force HID Output
2338 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2339 *
2340 * There is also another issue about HID Output Reports via USB,
2341 * the Sixaxis does not want the report_id as part of the data
2342 * packet, so we have to discard buf[0] when sending the actual
2343 * control message, even for numbered reports, humpf!
2344 */
2345 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2346 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
Antonio Ospite816651a2010-05-03 22:15:55 +02002347 ret = sixaxis_set_operational_usb(hdev);
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002348 sony_init_output_report(sc, sixaxis_send_output_report);
Simon Wood4545ee02015-06-17 00:08:52 -06002349 } else if ((sc->quirks & SIXAXIS_CONTROLLER_BT) ||
2350 (sc->quirks & NAVIGATION_CONTROLLER_BT)) {
Frank Praznik2078b9b2014-03-15 09:41:16 -04002351 /*
2352 * The Sixaxis wants output reports sent on the ctrl endpoint
2353 * when connected via Bluetooth.
2354 */
2355 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
Antonio Ospite816651a2010-05-03 22:15:55 +02002356 ret = sixaxis_set_operational_bt(hdev);
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002357 sony_init_output_report(sc, sixaxis_send_output_report);
Frank Praznikfee4e2d2014-02-18 17:22:01 -05002358 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
Frank Praznik68330d82014-02-05 20:03:49 -05002359 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
Frank Praznik2078b9b2014-03-15 09:41:16 -04002360 /*
2361 * The DualShock 4 wants output reports sent on the ctrl
2362 * endpoint when connected via Bluetooth.
2363 */
2364 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
Frank Praznik68330d82014-02-05 20:03:49 -05002365 ret = dualshock4_set_operational_bt(hdev);
2366 if (ret < 0) {
2367 hid_err(hdev, "failed to set the Dualshock 4 operational mode\n");
2368 goto err_stop;
2369 }
2370 }
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002371
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002372 sony_init_output_report(sc, dualshock4_send_output_report);
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002373 } else if (sc->quirks & MOTION_CONTROLLER) {
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002374 sony_init_output_report(sc, motion_send_output_report);
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002375 } else {
2376 ret = 0;
2377 }
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00002378
Jiri Kosina4dfdc462008-12-30 00:49:59 +01002379 if (ret < 0)
Jiri Slabybd28ce02008-06-25 23:47:04 +02002380 goto err_stop;
2381
Frank Praznikd2d782f2014-02-20 11:36:03 -05002382 ret = sony_check_add(sc);
2383 if (ret < 0)
2384 goto err_stop;
2385
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002386 if (sc->quirks & SONY_LED_SUPPORT) {
Frank Praznikfa57a812014-04-14 10:11:33 -04002387 ret = sony_leds_init(sc);
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002388 if (ret < 0)
2389 goto err_stop;
2390 }
2391
Frank Praznikd902f472014-01-27 10:17:36 -05002392 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2393 ret = sony_battery_probe(sc);
2394 if (ret < 0)
2395 goto err_stop;
2396
2397 /* Open the device to receive reports with battery info */
2398 ret = hid_hw_open(hdev);
2399 if (ret < 0) {
2400 hid_err(hdev, "hw open failed\n");
2401 goto err_stop;
2402 }
2403 }
2404
Frank Praznikc8de9db2014-02-20 11:36:01 -05002405 if (sc->quirks & SONY_FF_SUPPORT) {
Frank Praznikfa57a812014-04-14 10:11:33 -04002406 ret = sony_init_ff(sc);
Frank Praznikc8de9db2014-02-20 11:36:01 -05002407 if (ret < 0)
2408 goto err_close;
Frank Praznik5f5750d2014-02-19 13:09:22 -05002409 }
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002410
Jiri Slabybd28ce02008-06-25 23:47:04 +02002411 return 0;
Frank Praznikd902f472014-01-27 10:17:36 -05002412err_close:
2413 hid_hw_close(hdev);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002414err_stop:
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002415 if (sc->quirks & SONY_LED_SUPPORT)
Frank Praznikfa57a812014-04-14 10:11:33 -04002416 sony_leds_remove(sc);
Frank Praznikd902f472014-01-27 10:17:36 -05002417 if (sc->quirks & SONY_BATTERY_SUPPORT)
2418 sony_battery_remove(sc);
Frank Praznik46262042014-04-14 10:11:31 -04002419 sony_cancel_work_sync(sc);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002420 kfree(sc->output_report_dmabuf);
Frank Praznikd2d782f2014-02-20 11:36:03 -05002421 sony_remove_dev_list(sc);
Frank Praznik80250872014-04-14 10:11:35 -04002422 sony_release_device_id(sc);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002423 hid_hw_stop(hdev);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002424 return ret;
2425}
2426
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02002427static void sony_remove(struct hid_device *hdev)
2428{
Colin Leitnerf04d5142013-05-27 23:41:05 +02002429 struct sony_sc *sc = hid_get_drvdata(hdev);
2430
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002431 if (sc->quirks & SONY_LED_SUPPORT)
Frank Praznikfa57a812014-04-14 10:11:33 -04002432 sony_leds_remove(sc);
Colin Leitnerf04d5142013-05-27 23:41:05 +02002433
Frank Praznikd902f472014-01-27 10:17:36 -05002434 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2435 hid_hw_close(hdev);
2436 sony_battery_remove(sc);
2437 }
2438
Frank Praznik46262042014-04-14 10:11:31 -04002439 sony_cancel_work_sync(sc);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002440
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002441 kfree(sc->output_report_dmabuf);
2442
Frank Praznikd2d782f2014-02-20 11:36:03 -05002443 sony_remove_dev_list(sc);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002444
Frank Praznik80250872014-04-14 10:11:35 -04002445 sony_release_device_id(sc);
2446
Jiri Slabybd28ce02008-06-25 23:47:04 +02002447 hid_hw_stop(hdev);
2448}
2449
Frank Praznikdecd9462015-11-11 09:49:38 -05002450#ifdef CONFIG_PM
2451
2452static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2453{
2454 /*
2455 * On suspend save the current LED state,
2456 * stop running force-feedback and blank the LEDS.
Antonio Ospite09593e32016-02-09 13:55:06 +01002457 */
Frank Praznikdecd9462015-11-11 09:49:38 -05002458 if (SONY_LED_SUPPORT || SONY_FF_SUPPORT) {
2459 struct sony_sc *sc = hid_get_drvdata(hdev);
2460
2461#ifdef CONFIG_SONY_FF
2462 sc->left = sc->right = 0;
2463#endif
2464
2465 memcpy(sc->resume_led_state, sc->led_state,
2466 sizeof(sc->resume_led_state));
2467 memset(sc->led_state, 0, sizeof(sc->led_state));
2468
2469 sony_send_output_report(sc);
2470 }
2471
2472 return 0;
2473}
2474
2475static int sony_resume(struct hid_device *hdev)
2476{
2477 /* Restore the state of controller LEDs on resume */
2478 if (SONY_LED_SUPPORT) {
2479 struct sony_sc *sc = hid_get_drvdata(hdev);
2480
2481 memcpy(sc->led_state, sc->resume_led_state,
2482 sizeof(sc->led_state));
2483
2484 /*
2485 * The Sixaxis and navigation controllers on USB need to be
2486 * reinitialized on resume or they won't behave properly.
2487 */
2488 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2489 (sc->quirks & NAVIGATION_CONTROLLER_USB))
2490 sixaxis_set_operational_usb(sc->hdev);
2491
2492 sony_set_leds(sc);
2493 }
2494
2495 return 0;
2496}
2497
2498#endif
2499
Jiri Slabybd28ce02008-06-25 23:47:04 +02002500static const struct hid_device_id sony_devices[] = {
2501 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2502 .driver_data = SIXAXIS_CONTROLLER_USB },
2503 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
Simon Wood4545ee02015-06-17 00:08:52 -06002504 .driver_data = NAVIGATION_CONTROLLER_USB },
Simon Wood6eabaaa2015-06-17 00:08:51 -06002505 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
Simon Wood4545ee02015-06-17 00:08:52 -06002506 .driver_data = NAVIGATION_CONTROLLER_BT },
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002507 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
Simon Woodb3bca322015-06-09 21:27:04 -06002508 .driver_data = MOTION_CONTROLLER_USB },
Simon Wooda4afa852015-06-03 09:45:19 -06002509 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
Simon Woodb3bca322015-06-09 21:27:04 -06002510 .driver_data = MOTION_CONTROLLER_BT },
Jiri Slabybd28ce02008-06-25 23:47:04 +02002511 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2512 .driver_data = SIXAXIS_CONTROLLER_BT },
2513 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2514 .driver_data = VAIO_RDESC_CONSTANT },
2515 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2516 .driver_data = VAIO_RDESC_CONSTANT },
Antonio Ospiteef916ef2016-02-09 13:55:07 +01002517 /*
2518 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2519 * Logitech joystick from the device descriptor.
2520 */
Jiri Slabybd28ce02008-06-25 23:47:04 +02002521 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2522 .driver_data = BUZZ_CONTROLLER },
2523 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2524 .driver_data = BUZZ_CONTROLLER },
2525 /* PS3 BD Remote Control */
2526 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2527 .driver_data = PS3REMOTE },
2528 /* Logitech Harmony Adapter for PS3 */
2529 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2530 .driver_data = PS3REMOTE },
Frank Praznik68a49e52014-11-12 14:52:28 -05002531 /* SMK-Link PS3 BD Remote Control */
2532 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2533 .driver_data = PS3REMOTE },
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002534 /* Sony Dualshock 4 controllers for PS4 */
2535 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
Frank Praznik8ab16762014-01-16 21:42:31 -05002536 .driver_data = DUALSHOCK4_CONTROLLER_USB },
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002537 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
Frank Praznik8ab16762014-01-16 21:42:31 -05002538 .driver_data = DUALSHOCK4_CONTROLLER_BT },
Scott Moreau74500cc2016-01-13 07:40:42 -07002539 /* Nyko Core Controller for PS3 */
2540 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2541 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
Jiri Slabybd28ce02008-06-25 23:47:04 +02002542 { }
2543};
2544MODULE_DEVICE_TABLE(hid, sony_devices);
2545
2546static struct hid_driver sony_driver = {
Frank Praznikce8efc32014-09-18 21:15:01 -04002547 .name = "sony",
2548 .id_table = sony_devices,
2549 .input_mapping = sony_mapping,
2550 .input_configured = sony_input_configured,
2551 .probe = sony_probe,
2552 .remove = sony_remove,
2553 .report_fixup = sony_report_fixup,
Frank Praznikdecd9462015-11-11 09:49:38 -05002554 .raw_event = sony_raw_event,
2555
2556#ifdef CONFIG_PM
2557 .suspend = sony_suspend,
2558 .resume = sony_resume,
2559 .reset_resume = sony_resume,
2560#endif
Jiri Slabybd28ce02008-06-25 23:47:04 +02002561};
Frank Praznik80250872014-04-14 10:11:35 -04002562
2563static int __init sony_init(void)
2564{
2565 dbg_hid("Sony:%s\n", __func__);
2566
2567 return hid_register_driver(&sony_driver);
2568}
2569
2570static void __exit sony_exit(void)
2571{
2572 dbg_hid("Sony:%s\n", __func__);
2573
Frank Praznik80250872014-04-14 10:11:35 -04002574 hid_unregister_driver(&sony_driver);
Antonio Ospite6c400652015-02-16 22:58:24 +01002575 ida_destroy(&sony_device_id_allocator);
Frank Praznik80250872014-04-14 10:11:35 -04002576}
2577module_init(sony_init);
2578module_exit(sony_exit);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002579
2580MODULE_LICENSE("GPL");