blob: 60ec2b29d54de49e0b19c57cc57288efa47af7a3 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Jiri Slabybd28ce02008-06-25 23:47:04 +02002/*
Frank Praznik077147a2014-09-14 11:56:39 -04003 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
Jiri Slabybd28ce02008-06-25 23:47:04 +02004 *
5 * Copyright (c) 1999 Andreas Gal
6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
Jiri Slabybd28ce02008-06-25 23:47:04 +02008 * Copyright (c) 2008 Jiri Slaby
Jiri Kosina078328d2013-06-13 12:03:49 +02009 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
10 * Copyright (c) 2006-2013 Jiri Kosina
Colin Leitnerf04d5142013-05-27 23:41:05 +020011 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
Frank Praznikc4425c82016-09-22 20:18:10 -040012 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
Todd Kelnerb7289cb2018-02-17 16:47:10 -070013 * Copyright (c) 2018 Todd Kelner
Daniel Nguyena4bfe132021-08-10 10:09:32 -040014 * Copyright (c) 2020-2021 Pascal Giard <pascal.giard@etsmtl.ca>
Sanjay Govind32e411d2020-12-04 18:45:27 +130015 * Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
Daniel Nguyena4bfe132021-08-10 10:09:32 -040016 * Copyright (c) 2021 Daniel Nguyen <daniel.nguyen.1@ens.etsmtl.ca>
Jiri Slabybd28ce02008-06-25 23:47:04 +020017 */
18
19/*
Jiri Slabybd28ce02008-06-25 23:47:04 +020020 */
21
Frank Praznikad142b92014-02-20 11:36:00 -050022/*
23 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
Jiri Kosina078328d2013-06-13 12:03:49 +020024 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
25 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
26 *
27 * There will be no PIN request from the device.
28 */
29
Jiri Slabybd28ce02008-06-25 23:47:04 +020030#include <linux/device.h>
31#include <linux/hid.h>
32#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Jiri Kosina40e32ee2013-05-28 11:22:09 +020034#include <linux/leds.h>
Frank Praznikd902f472014-01-27 10:17:36 -050035#include <linux/power_supply.h>
36#include <linux/spinlock.h>
Frank Praznikd2d782f2014-02-20 11:36:03 -050037#include <linux/list.h>
Frank Praznik80250872014-04-14 10:11:35 -040038#include <linux/idr.h>
Frank Praznike5606232014-01-27 10:17:37 -050039#include <linux/input/mt.h>
Roderick Colenbrander49b9ca62016-10-07 12:39:36 -070040#include <linux/crc32.h>
Pascal Giardcc894ac2020-11-25 22:02:30 -050041#include <linux/usb.h>
42#include <linux/timer.h>
Roderick Colenbrander49b9ca62016-10-07 12:39:36 -070043#include <asm/unaligned.h>
Jiri Slabybd28ce02008-06-25 23:47:04 +020044
45#include "hid-ids.h"
46
Frank Praznik6c79c182014-01-16 21:43:03 -050047#define VAIO_RDESC_CONSTANT BIT(0)
48#define SIXAXIS_CONTROLLER_USB BIT(1)
49#define SIXAXIS_CONTROLLER_BT BIT(2)
50#define BUZZ_CONTROLLER BIT(3)
51#define PS3REMOTE BIT(4)
Frank Praznik8ab16762014-01-16 21:42:31 -050052#define DUALSHOCK4_CONTROLLER_USB BIT(5)
53#define DUALSHOCK4_CONTROLLER_BT BIT(6)
Roderick Colenbrander35f436c2017-03-07 15:45:04 -080054#define DUALSHOCK4_DONGLE BIT(7)
55#define MOTION_CONTROLLER_USB BIT(8)
56#define MOTION_CONTROLLER_BT BIT(9)
57#define NAVIGATION_CONTROLLER_USB BIT(10)
58#define NAVIGATION_CONTROLLER_BT BIT(11)
59#define SINO_LITE_CONTROLLER BIT(12)
60#define FUTUREMAX_DANCE_MAT BIT(13)
Todd Kelnerb7289cb2018-02-17 16:47:10 -070061#define NSG_MR5U_REMOTE_BT BIT(14)
62#define NSG_MR7U_REMOTE_BT BIT(15)
Hongye Yuan69481052019-01-09 09:18:08 +080063#define SHANWAN_GAMEPAD BIT(16)
Sanjay Govind32e411d2020-12-04 18:45:27 +130064#define GH_GUITAR_CONTROLLER BIT(17)
65#define GHL_GUITAR_PS3WIIU BIT(18)
Daniel Nguyena4bfe132021-08-10 10:09:32 -040066#define GHL_GUITAR_PS4 BIT(19)
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +020067
Frank Praznikfee4e2d2014-02-18 17:22:01 -050068#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
Simon Woodb3bca322015-06-09 21:27:04 -060069#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
Simon Wood4545ee02015-06-17 00:08:52 -060070#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
71 NAVIGATION_CONTROLLER_BT)
Frank Praznik68330d82014-02-05 20:03:49 -050072#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
Roderick Colenbrander35f436c2017-03-07 15:45:04 -080073 DUALSHOCK4_CONTROLLER_BT | \
74 DUALSHOCK4_DONGLE)
Frank Praznikfee4e2d2014-02-18 17:22:01 -050075#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
Simon Wood4545ee02015-06-17 00:08:52 -060076 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
77 NAVIGATION_CONTROLLER)
Simon Wood12e9a6d72015-06-09 21:27:05 -060078#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
Simon Wood4545ee02015-06-17 00:08:52 -060079 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
Frank Praznikc5e0c1c2015-05-05 20:47:30 -040080#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
81 MOTION_CONTROLLER)
Frank Praznik0f398232016-09-22 20:18:08 -040082#define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
83 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
Todd Kelnerb7289cb2018-02-17 16:47:10 -070084#define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
Frank Praznik60781cf2014-01-11 15:13:15 -050085
86#define MAX_LEDS 4
Todd Kelnerb7289cb2018-02-17 16:47:10 -070087#define NSG_MRXU_MAX_X 1667
88#define NSG_MRXU_MAX_Y 1868
Sven Eckelmann0a286ef2013-11-19 20:26:32 +010089
Daniel Nguyena4bfe132021-08-10 10:09:32 -040090/* The PS3/Wii U dongles require a poke every 10 seconds, but the PS4
91 * requires one every 8 seconds. Using 8 seconds for all for simplicity.
92 */
93#define GHL_GUITAR_POKE_INTERVAL 8 /* In seconds */
Sanjay Govind32e411d2020-12-04 18:45:27 +130094#define GUITAR_TILT_USAGE 44
Pascal Giardcc894ac2020-11-25 22:02:30 -050095
Daniel Nguyena4bfe132021-08-10 10:09:32 -040096/* Magic data taken from GHLtarUtility:
Pascal Giardcc894ac2020-11-25 22:02:30 -050097 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
98 * Note: The Wii U and PS3 dongles happen to share the same!
99 */
Pascal Giardcc894ac2020-11-25 22:02:30 -0500100static const char ghl_ps3wiiu_magic_data[] = {
101 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
102};
Mauro Carvalho Chehabe57a67d2012-12-14 20:57:34 -0200103
Daniel Nguyena4bfe132021-08-10 10:09:32 -0400104/* Magic data for the PS4 dongles sniffed with a USB protocol
105 * analyzer.
106 */
107static const char ghl_ps4_magic_data[] = {
108 0x30, 0x02, 0x08, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00
109};
110
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400111/* PS/3 Motion controller */
Pavel Machek1adf9042016-02-09 13:55:08 +0100112static u8 motion_rdesc[] = {
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400113 0x05, 0x01, /* Usage Page (Desktop), */
114 0x09, 0x04, /* Usage (Joystick), */
115 0xA1, 0x01, /* Collection (Application), */
116 0xA1, 0x02, /* Collection (Logical), */
117 0x85, 0x01, /* Report ID (1), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400118 0x75, 0x01, /* Report Size (1), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600119 0x95, 0x15, /* Report Count (21), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400120 0x15, 0x00, /* Logical Minimum (0), */
121 0x25, 0x01, /* Logical Maximum (1), */
122 0x35, 0x00, /* Physical Minimum (0), */
123 0x45, 0x01, /* Physical Maximum (1), */
124 0x05, 0x09, /* Usage Page (Button), */
125 0x19, 0x01, /* Usage Minimum (01h), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600126 0x29, 0x15, /* Usage Maximum (15h), */
127 0x81, 0x02, /* Input (Variable), * Buttons */
128 0x95, 0x0B, /* Report Count (11), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400129 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600130 0x81, 0x03, /* Input (Constant, Variable), * Padding */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400131 0x15, 0x00, /* Logical Minimum (0), */
132 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
133 0x05, 0x01, /* Usage Page (Desktop), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400134 0xA1, 0x00, /* Collection (Physical), */
135 0x75, 0x08, /* Report Size (8), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600136 0x95, 0x01, /* Report Count (1), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400137 0x35, 0x00, /* Physical Minimum (0), */
138 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
139 0x09, 0x30, /* Usage (X), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600140 0x81, 0x02, /* Input (Variable), * Trigger */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400141 0xC0, /* End Collection, */
Simon Wood8b2513c2015-06-09 21:27:07 -0600142 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
143 0x75, 0x08, /* Report Size (8), */
144 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
145 0x81, 0x02, /* Input (Variable), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400146 0x05, 0x01, /* Usage Page (Desktop), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400147 0x75, 0x10, /* Report Size (16), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600148 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
149 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
150 0x95, 0x03, /* Report Count (3), * 3x Accels */
151 0x09, 0x33, /* Usage (rX), */
152 0x09, 0x34, /* Usage (rY), */
153 0x09, 0x35, /* Usage (rZ), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400154 0x81, 0x02, /* Input (Variable), */
Simon Wood8b2513c2015-06-09 21:27:07 -0600155 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
156 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
157 0x81, 0x02, /* Input (Variable), */
158 0x05, 0x01, /* Usage Page (Desktop), */
159 0x09, 0x01, /* Usage (Pointer), */
160 0x95, 0x03, /* Report Count (3), * 3x Gyros */
161 0x81, 0x02, /* Input (Variable), */
162 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
163 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
164 0x81, 0x02, /* Input (Variable), */
165 0x75, 0x0C, /* Report Size (12), */
166 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
167 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
168 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
169 0x81, 0x02, /* Input (Variable), */
170 0x75, 0x08, /* Report Size (8), */
171 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
172 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
173 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
174 0x81, 0x02, /* Input (Variable), */
175 0x75, 0x08, /* Report Size (8), */
176 0x95, 0x30, /* Report Count (48), */
177 0x09, 0x01, /* Usage (Pointer), */
178 0x91, 0x02, /* Output (Variable), */
179 0x75, 0x08, /* Report Size (8), */
180 0x95, 0x30, /* Report Count (48), */
181 0x09, 0x01, /* Usage (Pointer), */
182 0xB1, 0x02, /* Feature (Variable), */
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400183 0xC0, /* End Collection, */
184 0xA1, 0x02, /* Collection (Logical), */
185 0x85, 0x02, /* Report ID (2), */
186 0x75, 0x08, /* Report Size (8), */
187 0x95, 0x30, /* Report Count (48), */
188 0x09, 0x01, /* Usage (Pointer), */
189 0xB1, 0x02, /* Feature (Variable), */
190 0xC0, /* End Collection, */
191 0xA1, 0x02, /* Collection (Logical), */
192 0x85, 0xEE, /* Report ID (238), */
193 0x75, 0x08, /* Report Size (8), */
194 0x95, 0x30, /* Report Count (48), */
195 0x09, 0x01, /* Usage (Pointer), */
196 0xB1, 0x02, /* Feature (Variable), */
197 0xC0, /* End Collection, */
198 0xA1, 0x02, /* Collection (Logical), */
199 0x85, 0xEF, /* Report ID (239), */
200 0x75, 0x08, /* Report Size (8), */
201 0x95, 0x30, /* Report Count (48), */
202 0x09, 0x01, /* Usage (Pointer), */
203 0xB1, 0x02, /* Feature (Variable), */
204 0xC0, /* End Collection, */
205 0xC0 /* End Collection */
206};
207
Pavel Machek1adf9042016-02-09 13:55:08 +0100208static u8 ps3remote_rdesc[] = {
Jiri Kosina078328d2013-06-13 12:03:49 +0200209 0x05, 0x01, /* GUsagePage Generic Desktop */
210 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
211 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
212
213 /* Use collection 1 for joypad buttons */
214 0xA1, 0x02, /* MCollection Logical (interrelated data) */
215
Antonio Ospiteef916ef2016-02-09 13:55:07 +0100216 /*
217 * Ignore the 1st byte, maybe it is used for a controller
218 * number but it's not needed for correct operation
219 */
Jiri Kosina078328d2013-06-13 12:03:49 +0200220 0x75, 0x08, /* GReportSize 0x08 [8] */
221 0x95, 0x01, /* GReportCount 0x01 [1] */
222 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
223
Antonio Ospiteef916ef2016-02-09 13:55:07 +0100224 /*
225 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
226 * buttons multiple keypresses are allowed
227 */
Jiri Kosina078328d2013-06-13 12:03:49 +0200228 0x05, 0x09, /* GUsagePage Button */
229 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
230 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
231 0x14, /* GLogicalMinimum [0] */
232 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
233 0x75, 0x01, /* GReportSize 0x01 [1] */
234 0x95, 0x18, /* GReportCount 0x18 [24] */
235 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
236
237 0xC0, /* MEndCollection */
238
239 /* Use collection 2 for remote control buttons */
240 0xA1, 0x02, /* MCollection Logical (interrelated data) */
241
242 /* 5th byte is used for remote control buttons */
243 0x05, 0x09, /* GUsagePage Button */
244 0x18, /* LUsageMinimum [No button pressed] */
245 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
246 0x14, /* GLogicalMinimum [0] */
247 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
248 0x75, 0x08, /* GReportSize 0x08 [8] */
249 0x95, 0x01, /* GReportCount 0x01 [1] */
250 0x80, /* MInput */
251
Antonio Ospiteef916ef2016-02-09 13:55:07 +0100252 /*
253 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
254 * 0xff and 11th is for press indication
255 */
Jiri Kosina078328d2013-06-13 12:03:49 +0200256 0x75, 0x08, /* GReportSize 0x08 [8] */
257 0x95, 0x06, /* GReportCount 0x06 [6] */
258 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
259
260 /* 12th byte is for battery strength */
261 0x05, 0x06, /* GUsagePage Generic Device Controls */
262 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
263 0x14, /* GLogicalMinimum [0] */
264 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
265 0x75, 0x08, /* GReportSize 0x08 [8] */
266 0x95, 0x01, /* GReportCount 0x01 [1] */
267 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
268
269 0xC0, /* MEndCollection */
270
271 0xC0 /* MEndCollection [Game Pad] */
272};
273
274static const unsigned int ps3remote_keymap_joypad_buttons[] = {
275 [0x01] = KEY_SELECT,
276 [0x02] = BTN_THUMBL, /* L3 */
277 [0x03] = BTN_THUMBR, /* R3 */
278 [0x04] = BTN_START,
279 [0x05] = KEY_UP,
280 [0x06] = KEY_RIGHT,
281 [0x07] = KEY_DOWN,
282 [0x08] = KEY_LEFT,
283 [0x09] = BTN_TL2, /* L2 */
284 [0x0a] = BTN_TR2, /* R2 */
285 [0x0b] = BTN_TL, /* L1 */
286 [0x0c] = BTN_TR, /* R1 */
287 [0x0d] = KEY_OPTION, /* options/triangle */
288 [0x0e] = KEY_BACK, /* back/circle */
289 [0x0f] = BTN_0, /* cross */
290 [0x10] = KEY_SCREEN, /* view/square */
291 [0x11] = KEY_HOMEPAGE, /* PS button */
292 [0x14] = KEY_ENTER,
293};
294static const unsigned int ps3remote_keymap_remote_buttons[] = {
295 [0x00] = KEY_1,
296 [0x01] = KEY_2,
297 [0x02] = KEY_3,
298 [0x03] = KEY_4,
299 [0x04] = KEY_5,
300 [0x05] = KEY_6,
301 [0x06] = KEY_7,
302 [0x07] = KEY_8,
303 [0x08] = KEY_9,
304 [0x09] = KEY_0,
305 [0x0e] = KEY_ESC, /* return */
306 [0x0f] = KEY_CLEAR,
307 [0x16] = KEY_EJECTCD,
308 [0x1a] = KEY_MENU, /* top menu */
309 [0x28] = KEY_TIME,
310 [0x30] = KEY_PREVIOUS,
311 [0x31] = KEY_NEXT,
312 [0x32] = KEY_PLAY,
313 [0x33] = KEY_REWIND, /* scan back */
314 [0x34] = KEY_FORWARD, /* scan forward */
315 [0x38] = KEY_STOP,
316 [0x39] = KEY_PAUSE,
317 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
318 [0x60] = KEY_FRAMEBACK, /* slow/step back */
319 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
320 [0x63] = KEY_SUBTITLE,
321 [0x64] = KEY_AUDIO,
322 [0x65] = KEY_ANGLE,
323 [0x70] = KEY_INFO, /* display */
324 [0x80] = KEY_BLUE,
325 [0x81] = KEY_RED,
326 [0x82] = KEY_GREEN,
327 [0x83] = KEY_YELLOW,
328};
329
Colin Leitnerf04d5142013-05-27 23:41:05 +0200330static const unsigned int buzz_keymap[] = {
Frank Praznikad142b92014-02-20 11:36:00 -0500331 /*
332 * The controller has 4 remote buzzers, each with one LED and 5
Colin Leitnerf04d5142013-05-27 23:41:05 +0200333 * buttons.
Antonio Ospite09593e32016-02-09 13:55:06 +0100334 *
Colin Leitnerf04d5142013-05-27 23:41:05 +0200335 * We use the mapping chosen by the controller, which is:
336 *
337 * Key Offset
338 * -------------------
339 * Buzz 1
340 * Blue 5
341 * Orange 4
342 * Green 3
343 * Yellow 2
344 *
345 * So, for example, the orange button on the third buzzer is mapped to
346 * BTN_TRIGGER_HAPPY14
347 */
Antonio Ospite09593e32016-02-09 13:55:06 +0100348 [1] = BTN_TRIGGER_HAPPY1,
349 [2] = BTN_TRIGGER_HAPPY2,
350 [3] = BTN_TRIGGER_HAPPY3,
351 [4] = BTN_TRIGGER_HAPPY4,
352 [5] = BTN_TRIGGER_HAPPY5,
353 [6] = BTN_TRIGGER_HAPPY6,
354 [7] = BTN_TRIGGER_HAPPY7,
355 [8] = BTN_TRIGGER_HAPPY8,
356 [9] = BTN_TRIGGER_HAPPY9,
Colin Leitnerf04d5142013-05-27 23:41:05 +0200357 [10] = BTN_TRIGGER_HAPPY10,
358 [11] = BTN_TRIGGER_HAPPY11,
359 [12] = BTN_TRIGGER_HAPPY12,
360 [13] = BTN_TRIGGER_HAPPY13,
361 [14] = BTN_TRIGGER_HAPPY14,
362 [15] = BTN_TRIGGER_HAPPY15,
363 [16] = BTN_TRIGGER_HAPPY16,
364 [17] = BTN_TRIGGER_HAPPY17,
365 [18] = BTN_TRIGGER_HAPPY18,
366 [19] = BTN_TRIGGER_HAPPY19,
367 [20] = BTN_TRIGGER_HAPPY20,
368};
369
Roderick Colenbranderb8f09702017-03-24 15:17:46 -0700370/* The Navigation controller is a partial DS3 and uses the same HID report
371 * and hence the same keymap indices, however not not all axes/buttons
372 * are physically present. We use the same axis and button mapping as
373 * the DS3, which uses the Linux gamepad spec.
374 */
375static const unsigned int navigation_absmap[] = {
376 [0x30] = ABS_X,
377 [0x31] = ABS_Y,
378 [0x33] = ABS_Z, /* L2 */
379};
380
381/* Buttons not physically available on the device, but still available
382 * in the reports are explicitly set to 0 for documentation purposes.
383 */
384static const unsigned int navigation_keymap[] = {
385 [0x01] = 0, /* Select */
386 [0x02] = BTN_THUMBL, /* L3 */
387 [0x03] = 0, /* R3 */
388 [0x04] = 0, /* Start */
389 [0x05] = BTN_DPAD_UP, /* Up */
390 [0x06] = BTN_DPAD_RIGHT, /* Right */
391 [0x07] = BTN_DPAD_DOWN, /* Down */
392 [0x08] = BTN_DPAD_LEFT, /* Left */
393 [0x09] = BTN_TL2, /* L2 */
394 [0x0a] = 0, /* R2 */
395 [0x0b] = BTN_TL, /* L1 */
396 [0x0c] = 0, /* R1 */
397 [0x0d] = BTN_NORTH, /* Triangle */
398 [0x0e] = BTN_EAST, /* Circle */
399 [0x0f] = BTN_SOUTH, /* Cross */
400 [0x10] = BTN_WEST, /* Square */
401 [0x11] = BTN_MODE, /* PS */
402};
403
Roderick Colenbrandere19a2672017-03-07 15:45:08 -0800404static const unsigned int sixaxis_absmap[] = {
405 [0x30] = ABS_X,
406 [0x31] = ABS_Y,
407 [0x32] = ABS_RX, /* right stick X */
408 [0x35] = ABS_RY, /* right stick Y */
409};
410
411static const unsigned int sixaxis_keymap[] = {
412 [0x01] = BTN_SELECT, /* Select */
413 [0x02] = BTN_THUMBL, /* L3 */
414 [0x03] = BTN_THUMBR, /* R3 */
415 [0x04] = BTN_START, /* Start */
416 [0x05] = BTN_DPAD_UP, /* Up */
417 [0x06] = BTN_DPAD_RIGHT, /* Right */
418 [0x07] = BTN_DPAD_DOWN, /* Down */
419 [0x08] = BTN_DPAD_LEFT, /* Left */
420 [0x09] = BTN_TL2, /* L2 */
421 [0x0a] = BTN_TR2, /* R2 */
422 [0x0b] = BTN_TL, /* L1 */
423 [0x0c] = BTN_TR, /* R1 */
424 [0x0d] = BTN_NORTH, /* Triangle */
425 [0x0e] = BTN_EAST, /* Circle */
426 [0x0f] = BTN_SOUTH, /* Cross */
427 [0x10] = BTN_WEST, /* Square */
428 [0x11] = BTN_MODE, /* PS */
429};
430
Roderick Colenbrander9131f8c2016-11-23 14:07:08 -0800431static const unsigned int ds4_absmap[] = {
432 [0x30] = ABS_X,
433 [0x31] = ABS_Y,
434 [0x32] = ABS_RX, /* right stick X */
435 [0x33] = ABS_Z, /* L2 */
436 [0x34] = ABS_RZ, /* R2 */
437 [0x35] = ABS_RY, /* right stick Y */
438};
439
440static const unsigned int ds4_keymap[] = {
441 [0x1] = BTN_WEST, /* Square */
442 [0x2] = BTN_SOUTH, /* Cross */
443 [0x3] = BTN_EAST, /* Circle */
444 [0x4] = BTN_NORTH, /* Triangle */
445 [0x5] = BTN_TL, /* L1 */
446 [0x6] = BTN_TR, /* R1 */
447 [0x7] = BTN_TL2, /* L2 */
448 [0x8] = BTN_TR2, /* R2 */
449 [0x9] = BTN_SELECT, /* Share */
450 [0xa] = BTN_START, /* Options */
451 [0xb] = BTN_THUMBL, /* L3 */
452 [0xc] = BTN_THUMBR, /* R3 */
453 [0xd] = BTN_MODE, /* PS */
454};
455
Roderick Colenbranderd03ae2e2017-03-07 15:45:03 -0800456static const struct {int x; int y; } ds4_hat_mapping[] = {
457 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
458 {0, 0}
459};
Roderick Colenbrander9131f8c2016-11-23 14:07:08 -0800460
Frank Praznikd902f472014-01-27 10:17:36 -0500461static enum power_supply_property sony_battery_props[] = {
462 POWER_SUPPLY_PROP_PRESENT,
463 POWER_SUPPLY_PROP_CAPACITY,
464 POWER_SUPPLY_PROP_SCOPE,
465 POWER_SUPPLY_PROP_STATUS,
466};
467
Frank Praznik55d3b662014-04-14 10:11:32 -0400468struct sixaxis_led {
Pavel Machek1adf9042016-02-09 13:55:08 +0100469 u8 time_enabled; /* the total time the led is active (0xff means forever) */
470 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
471 u8 enabled;
472 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
473 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
Frank Praznik55d3b662014-04-14 10:11:32 -0400474} __packed;
475
476struct sixaxis_rumble {
Pavel Machek1adf9042016-02-09 13:55:08 +0100477 u8 padding;
478 u8 right_duration; /* Right motor duration (0xff means forever) */
479 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
480 u8 left_duration; /* Left motor duration (0xff means forever) */
481 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
Frank Praznik55d3b662014-04-14 10:11:32 -0400482} __packed;
483
484struct sixaxis_output_report {
Pavel Machek1adf9042016-02-09 13:55:08 +0100485 u8 report_id;
Frank Praznik55d3b662014-04-14 10:11:32 -0400486 struct sixaxis_rumble rumble;
Pavel Machek1adf9042016-02-09 13:55:08 +0100487 u8 padding[4];
488 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
Frank Praznik55d3b662014-04-14 10:11:32 -0400489 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
490 struct sixaxis_led _reserved; /* LED5, not actually soldered */
491} __packed;
492
493union sixaxis_output_report_01 {
494 struct sixaxis_output_report data;
Pavel Machek1adf9042016-02-09 13:55:08 +0100495 u8 buf[36];
Frank Praznik55d3b662014-04-14 10:11:32 -0400496};
497
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400498struct motion_output_report_02 {
499 u8 type, zero;
500 u8 r, g, b;
501 u8 zero2;
502 u8 rumble;
503};
504
Roderick Colenbrander2c159de2016-10-07 12:39:35 -0700505#define DS4_FEATURE_REPORT_0x02_SIZE 37
Roderick Colenbrander55a07d62017-03-07 15:45:01 -0800506#define DS4_FEATURE_REPORT_0x05_SIZE 41
Roderick Colenbrander2c159de2016-10-07 12:39:35 -0700507#define DS4_FEATURE_REPORT_0x81_SIZE 7
Roderick Colenbrander169f15a2017-12-19 11:04:43 -0800508#define DS4_FEATURE_REPORT_0xA3_SIZE 49
Roderick Colenbrander49b9ca62016-10-07 12:39:36 -0700509#define DS4_INPUT_REPORT_0x11_SIZE 78
Roderick Colenbrander2c159de2016-10-07 12:39:35 -0700510#define DS4_OUTPUT_REPORT_0x05_SIZE 32
511#define DS4_OUTPUT_REPORT_0x11_SIZE 78
Antonio Ospite29b691a2015-02-16 18:12:21 +0100512#define SIXAXIS_REPORT_0xF2_SIZE 17
Antonio Ospitea85d67b2015-02-16 18:12:22 +0100513#define SIXAXIS_REPORT_0xF5_SIZE 8
Simon Wood41d2d422015-06-09 21:27:06 -0600514#define MOTION_REPORT_0x02_SIZE 49
Frank Praznik9b2b5c92014-11-12 14:10:09 -0500515
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -0700516/* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
517 * additional +2.
518 */
Roderick Colenbranderd03ae2e2017-03-07 15:45:03 -0800519#define DS4_INPUT_REPORT_AXIS_OFFSET 1
Roderick Colenbranderac797b92016-11-23 14:07:07 -0800520#define DS4_INPUT_REPORT_BUTTON_OFFSET 5
Roderick Colenbrander80786eb2017-03-07 15:45:02 -0800521#define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
Roderick Colenbrander227c0112017-03-07 15:45:00 -0800522#define DS4_INPUT_REPORT_GYRO_X_OFFSET 13
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -0700523#define DS4_INPUT_REPORT_BATTERY_OFFSET 30
524#define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
525
Roderick Colenbrander510c8b72017-03-07 15:45:10 -0800526#define SENSOR_SUFFIX " Motion Sensors"
Roderick Colenbranderac797b92016-11-23 14:07:07 -0800527#define DS4_TOUCHPAD_SUFFIX " Touchpad"
528
Roderick Colenbrander77b499e2017-03-24 15:17:49 -0700529/* Default to 4ms poll interval, which is same as USB (not adjustable). */
530#define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
531#define DS4_BT_MAX_POLL_INTERVAL_MS 62
Roderick Colenbrander55a07d62017-03-07 15:45:01 -0800532#define DS4_GYRO_RES_PER_DEG_S 1024
533#define DS4_ACC_RES_PER_G 8192
534
Roderick Colenbrander510c8b72017-03-07 15:45:10 -0800535#define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
536#define SIXAXIS_ACC_RES_PER_G 113
537
Jiri Kosina8b402c92015-02-23 11:15:44 +0100538static DEFINE_SPINLOCK(sony_dev_list_lock);
Frank Praznikd2d782f2014-02-20 11:36:03 -0500539static LIST_HEAD(sony_device_list);
Frank Praznik80250872014-04-14 10:11:35 -0400540static DEFINE_IDA(sony_device_id_allocator);
Frank Praznikd2d782f2014-02-20 11:36:03 -0500541
Roderick Colenbrander55a07d62017-03-07 15:45:01 -0800542/* Used for calibration of DS4 accelerometer and gyro. */
543struct ds4_calibration_data {
544 int abs_code;
545 short bias;
546 /* Calibration requires scaling against a sensitivity value, which is a
547 * float. Store sensitivity as a fraction to limit floating point
548 * calculations until final calibration.
549 */
550 int sens_numer;
551 int sens_denom;
552};
553
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -0800554enum ds4_dongle_state {
555 DONGLE_DISCONNECTED,
556 DONGLE_CALIBRATING,
557 DONGLE_CONNECTED,
558 DONGLE_DISABLED
559};
560
Roderick Colenbranderb5322732017-03-07 15:45:05 -0800561enum sony_worker {
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -0800562 SONY_WORKER_STATE,
563 SONY_WORKER_HOTPLUG
Roderick Colenbranderb5322732017-03-07 15:45:05 -0800564};
565
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200566struct sony_sc {
Frank Praznikd902f472014-01-27 10:17:36 -0500567 spinlock_t lock;
Frank Praznikd2d782f2014-02-20 11:36:03 -0500568 struct list_head list_node;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +0100569 struct hid_device *hdev;
Roderick Colenbranderac797b92016-11-23 14:07:07 -0800570 struct input_dev *touchpad;
Roderick Colenbrander227c0112017-03-07 15:45:00 -0800571 struct input_dev *sensor_dev;
Frank Praznik60781cf2014-01-11 15:13:15 -0500572 struct led_classdev *leds[MAX_LEDS];
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200573 unsigned long quirks;
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -0800574 struct work_struct hotplug_worker;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +0100575 struct work_struct state_worker;
Antonio Ospite09593e32016-02-09 13:55:06 +0100576 void (*send_output_report)(struct sony_sc *);
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100577 struct power_supply *battery;
578 struct power_supply_desc battery_desc;
Frank Praznik80250872014-04-14 10:11:35 -0400579 int device_id;
Roderick Colenbrander169f15a2017-12-19 11:04:43 -0800580 unsigned fw_version;
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -0800581 bool fw_version_created;
Roderick Colenbrander169f15a2017-12-19 11:04:43 -0800582 unsigned hw_version;
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -0800583 bool hw_version_created;
Pavel Machek1adf9042016-02-09 13:55:08 +0100584 u8 *output_report_dmabuf;
Colin Leitnerf04d5142013-05-27 23:41:05 +0200585
Sven Eckelmann9f323b62013-11-17 20:38:21 +0100586#ifdef CONFIG_SONY_FF
Pavel Machek1adf9042016-02-09 13:55:08 +0100587 u8 left;
588 u8 right;
Sven Eckelmann9f323b62013-11-17 20:38:21 +0100589#endif
590
Pavel Machek1adf9042016-02-09 13:55:08 +0100591 u8 mac_address[6];
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -0800592 u8 hotplug_worker_initialized;
Roderick Colenbranderb5322732017-03-07 15:45:05 -0800593 u8 state_worker_initialized;
Frank Praznik2a242932016-09-22 20:18:09 -0400594 u8 defer_initialization;
Pavel Machek1adf9042016-02-09 13:55:08 +0100595 u8 battery_capacity;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -0800596 int battery_status;
Pavel Machek1adf9042016-02-09 13:55:08 +0100597 u8 led_state[MAX_LEDS];
Pavel Machek1adf9042016-02-09 13:55:08 +0100598 u8 led_delay_on[MAX_LEDS];
599 u8 led_delay_off[MAX_LEDS];
600 u8 led_count;
Roderick Colenbrander80786eb2017-03-07 15:45:02 -0800601
602 bool timestamp_initialized;
603 u16 prev_timestamp;
604 unsigned int timestamp_us;
605
Roderick Colenbrander77b499e2017-03-24 15:17:49 -0700606 u8 ds4_bt_poll_interval;
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -0800607 enum ds4_dongle_state ds4_dongle_state;
Roderick Colenbrander55a07d62017-03-07 15:45:01 -0800608 /* DS4 calibration data */
609 struct ds4_calibration_data ds4_calib_data[6];
Pascal Giardcc894ac2020-11-25 22:02:30 -0500610 /* GH Live */
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400611 struct urb *ghl_urb;
Pascal Giardcc894ac2020-11-25 22:02:30 -0500612 struct timer_list ghl_poke_timer;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200613};
614
Roderick Colenbrander405182c2016-12-08 19:09:52 -0800615static void sony_set_leds(struct sony_sc *sc);
616
Roderick Colenbranderb5322732017-03-07 15:45:05 -0800617static inline void sony_schedule_work(struct sony_sc *sc,
618 enum sony_worker which)
Frank Praznik2a242932016-09-22 20:18:09 -0400619{
Roderick Colenbrandere0f69742019-08-02 15:50:19 -0700620 unsigned long flags;
621
Roderick Colenbranderb5322732017-03-07 15:45:05 -0800622 switch (which) {
623 case SONY_WORKER_STATE:
Roderick Colenbrandere0f69742019-08-02 15:50:19 -0700624 spin_lock_irqsave(&sc->lock, flags);
625 if (!sc->defer_initialization && sc->state_worker_initialized)
Roderick Colenbranderb5322732017-03-07 15:45:05 -0800626 schedule_work(&sc->state_worker);
Roderick Colenbrandere0f69742019-08-02 15:50:19 -0700627 spin_unlock_irqrestore(&sc->lock, flags);
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -0800628 break;
629 case SONY_WORKER_HOTPLUG:
630 if (sc->hotplug_worker_initialized)
631 schedule_work(&sc->hotplug_worker);
632 break;
Roderick Colenbranderb5322732017-03-07 15:45:05 -0800633 }
Frank Praznik2a242932016-09-22 20:18:09 -0400634}
635
Pascal Giardcc894ac2020-11-25 22:02:30 -0500636static void ghl_magic_poke_cb(struct urb *urb)
637{
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400638 struct sony_sc *sc = urb->context;
639
640 if (urb->status < 0)
641 hid_err(sc->hdev, "URB transfer failed : %d", urb->status);
642
643 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
Pascal Giardcc894ac2020-11-25 22:02:30 -0500644}
645
646static void ghl_magic_poke(struct timer_list *t)
647{
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400648 int ret;
Pascal Giardcc894ac2020-11-25 22:02:30 -0500649 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
650
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400651 ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC);
652 if (ret < 0)
653 hid_err(sc->hdev, "usb_submit_urb failed: %d", ret);
654}
Pascal Giardcc894ac2020-11-25 22:02:30 -0500655
Daniel Nguyena4bfe132021-08-10 10:09:32 -0400656static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev,
657 const char ghl_magic_data[], u16 poke_size)
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400658{
659 struct usb_ctrlrequest *cr;
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400660 u8 *databuf;
661 unsigned int pipe;
Daniel Nguyena4bfe132021-08-10 10:09:32 -0400662 u16 ghl_magic_value = (((HID_OUTPUT_REPORT + 1) << 8) | ghl_magic_data[0]);
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400663
Pascal Giardcc894ac2020-11-25 22:02:30 -0500664 pipe = usb_sndctrlpipe(usbdev, 0);
665
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400666 cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
667 if (cr == NULL)
668 return -ENOMEM;
Pascal Giardcc894ac2020-11-25 22:02:30 -0500669
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400670 databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
671 if (databuf == NULL)
672 return -ENOMEM;
Pascal Giardcc894ac2020-11-25 22:02:30 -0500673
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400674 cr->bRequestType =
Pascal Giardcc894ac2020-11-25 22:02:30 -0500675 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400676 cr->bRequest = USB_REQ_SET_CONFIGURATION;
Daniel Nguyena4bfe132021-08-10 10:09:32 -0400677 cr->wValue = cpu_to_le16(ghl_magic_value);
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400678 cr->wIndex = 0;
679 cr->wLength = cpu_to_le16(poke_size);
Daniel Nguyena4bfe132021-08-10 10:09:32 -0400680 memcpy(databuf, ghl_magic_data, poke_size);
Pascal Giardcc894ac2020-11-25 22:02:30 -0500681 usb_fill_control_urb(
Pascal Giardfb1a79a2021-06-04 12:10:23 -0400682 sc->ghl_urb, usbdev, pipe,
683 (unsigned char *) cr, databuf, poke_size,
684 ghl_magic_poke_cb, sc);
685 return 0;
Pascal Giardcc894ac2020-11-25 22:02:30 -0500686}
687
688static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
689 struct hid_field *field, struct hid_usage *usage,
690 unsigned long **bit, int *max)
691{
692 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
693 unsigned int abs = usage->hid & HID_USAGE;
694
Sanjay Govind32e411d2020-12-04 18:45:27 +1300695 if (abs == GUITAR_TILT_USAGE) {
Pascal Giardcc894ac2020-11-25 22:02:30 -0500696 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
697 return 1;
698 }
699 }
700 return 0;
701}
702
Roderick Colenbrander77b499e2017-03-24 15:17:49 -0700703static ssize_t ds4_show_poll_interval(struct device *dev,
704 struct device_attribute
705 *attr, char *buf)
Antonio Ospitec607fb82014-06-24 13:28:41 +0200706{
Roderick Colenbrander77b499e2017-03-24 15:17:49 -0700707 struct hid_device *hdev = to_hid_device(dev);
708 struct sony_sc *sc = hid_get_drvdata(hdev);
709
710 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
Antonio Ospitec607fb82014-06-24 13:28:41 +0200711}
712
Roderick Colenbrander77b499e2017-03-24 15:17:49 -0700713static ssize_t ds4_store_poll_interval(struct device *dev,
714 struct device_attribute *attr,
715 const char *buf, size_t count)
716{
717 struct hid_device *hdev = to_hid_device(dev);
718 struct sony_sc *sc = hid_get_drvdata(hdev);
719 unsigned long flags;
720 u8 interval;
721
722 if (kstrtou8(buf, 0, &interval))
723 return -EINVAL;
724
725 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
726 return -EINVAL;
727
728 spin_lock_irqsave(&sc->lock, flags);
729 sc->ds4_bt_poll_interval = interval;
730 spin_unlock_irqrestore(&sc->lock, flags);
731
732 sony_schedule_work(sc, SONY_WORKER_STATE);
733
734 return count;
735}
736
737static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
738 ds4_store_poll_interval);
739
Roderick Colenbrander169f15a2017-12-19 11:04:43 -0800740static ssize_t sony_show_firmware_version(struct device *dev,
741 struct device_attribute
742 *attr, char *buf)
743{
744 struct hid_device *hdev = to_hid_device(dev);
745 struct sony_sc *sc = hid_get_drvdata(hdev);
746
747 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
748}
749
750static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
751
752static ssize_t sony_show_hardware_version(struct device *dev,
753 struct device_attribute
754 *attr, char *buf)
755{
756 struct hid_device *hdev = to_hid_device(dev);
757 struct sony_sc *sc = hid_get_drvdata(hdev);
758
759 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
760}
761
762static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
Roderick Colenbrander77b499e2017-03-24 15:17:49 -0700763
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400764static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
765 unsigned int *rsize)
766{
767 *rsize = sizeof(motion_rdesc);
768 return motion_rdesc;
769}
770
Pavel Machek1adf9042016-02-09 13:55:08 +0100771static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
Jiri Kosina078328d2013-06-13 12:03:49 +0200772 unsigned int *rsize)
773{
774 *rsize = sizeof(ps3remote_rdesc);
775 return ps3remote_rdesc;
776}
777
778static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
779 struct hid_field *field, struct hid_usage *usage,
780 unsigned long **bit, int *max)
781{
782 unsigned int key = usage->hid & HID_USAGE;
783
784 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
785 return -1;
786
787 switch (usage->collection_index) {
788 case 1:
789 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
790 return -1;
791
792 key = ps3remote_keymap_joypad_buttons[key];
793 if (!key)
794 return -1;
795 break;
796 case 2:
797 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
798 return -1;
799
800 key = ps3remote_keymap_remote_buttons[key];
801 if (!key)
802 return -1;
803 break;
804 default:
805 return -1;
806 }
807
808 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
809 return 1;
810}
811
Roderick Colenbranderb8f09702017-03-24 15:17:46 -0700812static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
813 struct hid_field *field, struct hid_usage *usage,
814 unsigned long **bit, int *max)
815{
816 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
817 unsigned int key = usage->hid & HID_USAGE;
818
819 if (key >= ARRAY_SIZE(sixaxis_keymap))
820 return -1;
821
822 key = navigation_keymap[key];
823 if (!key)
824 return -1;
825
826 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
827 return 1;
828 } else if (usage->hid == HID_GD_POINTER) {
829 /* See comment in sixaxis_mapping, basically the L2 (and R2)
830 * triggers are reported through GD Pointer.
831 * In addition we ignore any analog button 'axes' and only
832 * support digital buttons.
833 */
834 switch (usage->usage_index) {
835 case 8: /* L2 */
836 usage->hid = HID_GD_Z;
837 break;
838 default:
839 return -1;
840 }
841
842 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
843 return 1;
844 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
845 unsigned int abs = usage->hid & HID_USAGE;
846
847 if (abs >= ARRAY_SIZE(navigation_absmap))
848 return -1;
849
850 abs = navigation_absmap[abs];
851
852 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
853 return 1;
854 }
855
856 return -1;
857}
858
859
Roderick Colenbrandere19a2672017-03-07 15:45:08 -0800860static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
861 struct hid_field *field, struct hid_usage *usage,
862 unsigned long **bit, int *max)
863{
864 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
865 unsigned int key = usage->hid & HID_USAGE;
866
867 if (key >= ARRAY_SIZE(sixaxis_keymap))
868 return -1;
869
870 key = sixaxis_keymap[key];
871 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
872 return 1;
873 } else if (usage->hid == HID_GD_POINTER) {
874 /* The DS3 provides analog values for most buttons and even
875 * for HAT axes through GD Pointer. L2 and R2 are reported
876 * among these as well instead of as GD Z / RZ. Remap L2
877 * and R2 and ignore other analog 'button axes' as there is
878 * no good way for reporting them.
879 */
880 switch (usage->usage_index) {
881 case 8: /* L2 */
882 usage->hid = HID_GD_Z;
883 break;
884 case 9: /* R2 */
885 usage->hid = HID_GD_RZ;
886 break;
887 default:
888 return -1;
889 }
890
891 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
892 return 1;
893 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
894 unsigned int abs = usage->hid & HID_USAGE;
895
896 if (abs >= ARRAY_SIZE(sixaxis_absmap))
897 return -1;
898
899 abs = sixaxis_absmap[abs];
900
901 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
902 return 1;
903 }
904
905 return -1;
906}
907
Roderick Colenbrander9131f8c2016-11-23 14:07:08 -0800908static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
909 struct hid_field *field, struct hid_usage *usage,
910 unsigned long **bit, int *max)
911{
912 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
913 unsigned int key = usage->hid & HID_USAGE;
914
915 if (key >= ARRAY_SIZE(ds4_keymap))
916 return -1;
917
918 key = ds4_keymap[key];
919 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
920 return 1;
921 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
922 unsigned int abs = usage->hid & HID_USAGE;
923
924 /* Let the HID parser deal with the HAT. */
925 if (usage->hid == HID_GD_HATSWITCH)
926 return 0;
927
928 if (abs >= ARRAY_SIZE(ds4_absmap))
929 return -1;
930
931 abs = ds4_absmap[abs];
932 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
933 return 1;
934 }
935
936 return 0;
937}
938
Pavel Machek1adf9042016-02-09 13:55:08 +0100939static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
Nikolai Kondrashov73e40082010-08-06 23:03:06 +0400940 unsigned int *rsize)
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200941{
942 struct sony_sc *sc = hid_get_drvdata(hdev);
943
Mikko Perttunen4ba1eee2016-07-21 19:54:48 +0300944 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
Scott Moreau74500cc2016-01-13 07:40:42 -0700945 return rdesc;
946
Fernando Luis Vázquez Cao99d24902013-01-22 15:20:38 +0900947 /*
948 * Some Sony RF receivers wrongly declare the mouse pointer as a
949 * a constant non-data variable.
950 */
951 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
952 /* usage page: generic desktop controls */
953 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
954 /* usage: mouse */
955 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
956 /* input (usage page for x,y axes): constant, variable, relative */
957 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
Fernando Luis Vázquez Caoa4649182013-01-15 19:40:48 +0900958 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
Fernando Luis Vázquez Cao99d24902013-01-22 15:20:38 +0900959 /* input: data, variable, relative */
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200960 rdesc[55] = 0x06;
961 }
Simon Wood61ab44b2011-06-10 12:00:26 +0200962
Frank Praznikc5e0c1c2015-05-05 20:47:30 -0400963 if (sc->quirks & MOTION_CONTROLLER)
964 return motion_fixup(hdev, rdesc, rsize);
965
Jiri Kosina078328d2013-06-13 12:03:49 +0200966 if (sc->quirks & PS3REMOTE)
967 return ps3remote_fixup(hdev, rdesc, rsize);
968
Scott Shumatee72455b2020-05-13 13:39:26 -0500969 /*
970 * Some knock-off USB dongles incorrectly report their button count
971 * as 13 instead of 16 causing three non-functional buttons.
972 */
973 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
974 /* Report Count (13) */
975 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
976 /* Usage Maximum (13) */
977 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
978 /* Report Count (3) */
979 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
980 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
981 rdesc[24] = 0x10;
982 rdesc[38] = 0x10;
983 rdesc[44] = 0x00;
984 }
985
Nikolai Kondrashov73e40082010-08-06 23:03:06 +0400986 return rdesc;
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +0200987}
988
Pavel Machek1adf9042016-02-09 13:55:08 +0100989static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
Frank Praznikd902f472014-01-27 10:17:36 -0500990{
Pavel Machek1adf9042016-02-09 13:55:08 +0100991 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
Frank Praznikd902f472014-01-27 10:17:36 -0500992 unsigned long flags;
Simon Wood12e9a6d72015-06-09 21:27:05 -0600993 int offset;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -0800994 u8 battery_capacity;
995 int battery_status;
Frank Praznikd902f472014-01-27 10:17:36 -0500996
Frank Praznikad142b92014-02-20 11:36:00 -0500997 /*
998 * The sixaxis is charging if the battery value is 0xee
Frank Praznikd902f472014-01-27 10:17:36 -0500999 * and it is fully charged if the value is 0xef.
1000 * It does not report the actual level while charging so it
1001 * is set to 100% while charging is in progress.
1002 */
Simon Wood12e9a6d72015-06-09 21:27:05 -06001003 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1004
1005 if (rd[offset] >= 0xee) {
Frank Praznikd902f472014-01-27 10:17:36 -05001006 battery_capacity = 100;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001007 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
Frank Praznikd902f472014-01-27 10:17:36 -05001008 } else {
Pavel Machek1adf9042016-02-09 13:55:08 +01001009 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
Frank Praznikac3c9a92014-02-20 11:36:02 -05001010 battery_capacity = sixaxis_battery_capacity[index];
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001011 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
Frank Praznikd902f472014-01-27 10:17:36 -05001012 }
Frank Praznikd902f472014-01-27 10:17:36 -05001013
1014 spin_lock_irqsave(&sc->lock, flags);
Frank Praznikd902f472014-01-27 10:17:36 -05001015 sc->battery_capacity = battery_capacity;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001016 sc->battery_status = battery_status;
Frank Praznikd902f472014-01-27 10:17:36 -05001017 spin_unlock_irqrestore(&sc->lock, flags);
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08001018
1019 if (sc->quirks & SIXAXIS_CONTROLLER) {
1020 int val;
1021
1022 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
1023 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
1024 input_report_abs(sc->sensor_dev, ABS_X, val);
1025
1026 /* Y and Z are swapped and inversed */
1027 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
1028 input_report_abs(sc->sensor_dev, ABS_Y, val);
1029
1030 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
1031 input_report_abs(sc->sensor_dev, ABS_Z, val);
1032
1033 input_sync(sc->sensor_dev);
1034 }
Frank Praznikd902f472014-01-27 10:17:36 -05001035}
1036
Pavel Machek1adf9042016-02-09 13:55:08 +01001037static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
Frank Praznikd902f472014-01-27 10:17:36 -05001038{
Roderick Colenbranderd03ae2e2017-03-07 15:45:03 -08001039 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1040 struct hid_input, list);
1041 struct input_dev *input_dev = hidinput->input;
Frank Praznikd902f472014-01-27 10:17:36 -05001042 unsigned long flags;
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001043 int n, m, offset, num_touch_data, max_touch_data;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001044 u8 cable_state, battery_capacity;
1045 int battery_status;
Roderick Colenbrander80786eb2017-03-07 15:45:02 -08001046 u16 timestamp;
Frank Praznikd902f472014-01-27 10:17:36 -05001047
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001048 /* When using Bluetooth the header is 2 bytes longer, so skip these. */
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001049 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
Frank Praznik6c5f8602014-02-05 20:03:47 -05001050
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001051 /* Second bit of third button byte is for the touchpad button. */
1052 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
1053 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1054
Frank Praznikad142b92014-02-20 11:36:00 -05001055 /*
Roderick Colenbranderd03ae2e2017-03-07 15:45:03 -08001056 * The default behavior of the Dualshock 4 is to send reports using
1057 * report type 1 when running over Bluetooth. However, when feature
1058 * report 2 is requested during the controller initialization it starts
1059 * sending input reports in report 17. Since report 17 is undefined
1060 * in the default HID descriptor, the HID layer won't generate events.
1061 * While it is possible (and this was done before) to fixup the HID
1062 * descriptor to add this mapping, it was better to do this manually.
1063 * The reason is there were various pieces software both open and closed
1064 * source, relying on the descriptors to be the same across various
1065 * operating systems. If the descriptors wouldn't match some
1066 * applications e.g. games on Wine would not be able to function due
1067 * to different descriptors, which such applications are not parsing.
1068 */
1069 if (rd[0] == 17) {
1070 int value;
1071
1072 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
1073 input_report_abs(input_dev, ABS_X, rd[offset]);
1074 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
1075 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
1076 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
1077
1078 value = rd[offset+4] & 0xf;
1079 if (value > 7)
1080 value = 8; /* Center 0, 0 */
1081 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
1082 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
1083
1084 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
1085 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
1086 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
1087 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
1088
1089 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
1090 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
1091 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
1092 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
1093 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
1094 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
1095 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
1096 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
1097
1098 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
1099
1100 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
1101 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
1102
1103 input_sync(input_dev);
1104 }
1105
Roderick Colenbrander80786eb2017-03-07 15:45:02 -08001106 /* Convert timestamp (in 5.33us unit) to timestamp_us */
1107 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
1108 timestamp = get_unaligned_le16(&rd[offset]);
1109 if (!sc->timestamp_initialized) {
1110 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1111 sc->timestamp_initialized = true;
1112 } else {
1113 u16 delta;
1114
1115 if (sc->prev_timestamp > timestamp)
1116 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1117 else
1118 delta = timestamp - sc->prev_timestamp;
1119 sc->timestamp_us += (delta * 16) / 3;
1120 }
1121 sc->prev_timestamp = timestamp;
1122 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1123
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001124 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001125 for (n = 0; n < 6; n++) {
1126 /* Store data in int for more precision during mult_frac. */
1127 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1128 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001129
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001130 /* High precision is needed during calibration, but the
1131 * calibrated values are within 32-bit.
1132 * Note: we swap numerator 'x' and 'numer' in mult_frac for
1133 * precision reasons so we don't need 64-bit.
1134 */
1135 int calib_data = mult_frac(calib->sens_numer,
1136 raw_data - calib->bias,
1137 calib->sens_denom);
1138
1139 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1140 offset += 2;
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001141 }
1142 input_sync(sc->sensor_dev);
1143
Frank Praznikad142b92014-02-20 11:36:00 -05001144 /*
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001145 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
Frank Praznikd902f472014-01-27 10:17:36 -05001146 * and the 5th bit contains the USB cable state.
1147 */
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001148 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
Frank Praznik6c5f8602014-02-05 20:03:47 -05001149 cable_state = (rd[offset] >> 4) & 0x01;
Frank Praznikd902f472014-01-27 10:17:36 -05001150
Frank Praznikad142b92014-02-20 11:36:00 -05001151 /*
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001152 * Interpretation of the battery_capacity data depends on the cable state.
1153 * When no cable is connected (bit4 is 0):
1154 * - 0:10: percentage in units of 10%.
1155 * When a cable is plugged in:
1156 * - 0-10: percentage in units of 10%.
1157 * - 11: battery is full
1158 * - 14: not charging due to Voltage or temperature error
1159 * - 15: charge error
Frank Praznikd902f472014-01-27 10:17:36 -05001160 */
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001161 if (cable_state) {
1162 u8 battery_data = rd[offset] & 0xf;
Frank Praznikd902f472014-01-27 10:17:36 -05001163
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001164 if (battery_data < 10) {
1165 /* Take the mid-point for each battery capacity value,
1166 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
1167 * This matches official platform behavior, which does
1168 * the same.
1169 */
1170 battery_capacity = battery_data * 10 + 5;
1171 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1172 } else if (battery_data == 10) {
1173 battery_capacity = 100;
1174 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1175 } else if (battery_data == 11) {
1176 battery_capacity = 100;
1177 battery_status = POWER_SUPPLY_STATUS_FULL;
1178 } else { /* 14, 15 and undefined values */
1179 battery_capacity = 0;
1180 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1181 }
1182 } else {
1183 u8 battery_data = rd[offset] & 0xf;
Frank Praznik6c5f8602014-02-05 20:03:47 -05001184
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001185 if (battery_data < 10)
1186 battery_capacity = battery_data * 10 + 5;
1187 else /* 10 */
1188 battery_capacity = 100;
1189
1190 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1191 }
Frank Praznikd902f472014-01-27 10:17:36 -05001192
1193 spin_lock_irqsave(&sc->lock, flags);
Frank Praznikd902f472014-01-27 10:17:36 -05001194 sc->battery_capacity = battery_capacity;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08001195 sc->battery_status = battery_status;
Frank Praznikd902f472014-01-27 10:17:36 -05001196 spin_unlock_irqrestore(&sc->lock, flags);
Frank Praznike5606232014-01-27 10:17:37 -05001197
Frank Praznikad142b92014-02-20 11:36:00 -05001198 /*
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001199 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1200 * and 35 on Bluetooth.
1201 * The first byte indicates the number of touch data in the report.
1202 * Trackpad data starts 2 bytes later (e.g. 35 for USB).
Frank Praznike5606232014-01-27 10:17:37 -05001203 */
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001204 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001205 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001206 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1207 num_touch_data = rd[offset];
1208 else
1209 num_touch_data = 1;
1210 offset += 1;
Frank Praznike5606232014-01-27 10:17:37 -05001211
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001212 for (m = 0; m < num_touch_data; m++) {
1213 /* Skip past timestamp */
1214 offset += 1;
Frank Praznike5606232014-01-27 10:17:37 -05001215
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001216 /*
1217 * The first 7 bits of the first byte is a counter and bit 8 is
1218 * a touch indicator that is 0 when pressed and 1 when not
1219 * pressed.
1220 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1221 * The data for the second touch is in the same format and
1222 * immediately follows the data for the first.
1223 */
1224 for (n = 0; n < 2; n++) {
1225 u16 x, y;
1226 bool active;
Frank Praznike5606232014-01-27 10:17:37 -05001227
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001228 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1229 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1230
1231 active = !(rd[offset] >> 7);
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001232 input_mt_slot(sc->touchpad, n);
1233 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001234
1235 if (active) {
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001236 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1237 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
Roderick Colenbrandercdc1c022016-10-07 12:39:38 -07001238 }
1239
1240 offset += 4;
1241 }
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001242 input_mt_sync_frame(sc->touchpad);
1243 input_sync(sc->touchpad);
Frank Praznike5606232014-01-27 10:17:37 -05001244 }
Frank Praznikd902f472014-01-27 10:17:36 -05001245}
1246
Todd Kelnerb7289cb2018-02-17 16:47:10 -07001247static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1248{
1249 int n, offset, relx, rely;
1250 u8 active;
1251
1252 /*
1253 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
1254 * the touch-related data starts at offset 2.
1255 * For the first byte, bit 0 is set when touchpad button is pressed.
1256 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
1257 * This drag key is mapped to BTN_LEFT. It is operational only when a
1258 * touch point is active.
1259 * Bit 4 is set when only the first touch point is active.
1260 * Bit 6 is set when only the second touch point is active.
1261 * Bits 5 and 7 are set when both touch points are active.
1262 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
1263 * The following byte, offset 5, has the touch width and length.
1264 * Bits 0-4=X (width), bits 5-7=Y (length).
1265 * A signed relative X coordinate is at offset 6.
1266 * The bytes at offset 7-9 are the second touch X/Y coordinates.
1267 * Offset 10 has the second touch width and length.
1268 * Offset 11 has the relative Y coordinate.
1269 */
1270 offset = 1;
1271
1272 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1273 active = (rd[offset] >> 4);
1274 relx = (s8) rd[offset+5];
1275 rely = ((s8) rd[offset+10]) * -1;
1276
1277 offset++;
1278
1279 for (n = 0; n < 2; n++) {
1280 u16 x, y;
1281 u8 contactx, contacty;
1282
1283 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1284 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1285
1286 input_mt_slot(sc->touchpad, n);
1287 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1288
1289 if (active & 0x03) {
1290 contactx = rd[offset+3] & 0x0F;
1291 contacty = rd[offset+3] >> 4;
1292 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1293 max(contactx, contacty));
1294 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1295 min(contactx, contacty));
1296 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1297 (bool) (contactx > contacty));
1298 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1299 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1300 NSG_MRXU_MAX_Y - y);
1301 /*
1302 * The relative coordinates belong to the first touch
1303 * point, when present, or to the second touch point
1304 * when the first is not active.
1305 */
1306 if ((n == 0) || ((n == 1) && (active & 0x01))) {
1307 input_report_rel(sc->touchpad, REL_X, relx);
1308 input_report_rel(sc->touchpad, REL_Y, rely);
1309 }
1310 }
1311
1312 offset += 5;
1313 active >>= 2;
1314 }
1315
1316 input_mt_sync_frame(sc->touchpad);
1317
1318 input_sync(sc->touchpad);
1319}
1320
Simon Woodc9e4d872011-06-10 12:00:27 +02001321static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
Pavel Machek1adf9042016-02-09 13:55:08 +01001322 u8 *rd, int size)
Simon Woodc9e4d872011-06-10 12:00:27 +02001323{
1324 struct sony_sc *sc = hid_get_drvdata(hdev);
1325
Frank Praznikad142b92014-02-20 11:36:00 -05001326 /*
1327 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
Simon Woodc9e4d872011-06-10 12:00:27 +02001328 * has to be BYTE_SWAPPED before passing up to joystick interface
1329 */
Frank Praznikfee4e2d2014-02-18 17:22:01 -05001330 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
Frank Praznik8f5f0bc2015-07-23 19:01:16 -04001331 /*
1332 * When connected via Bluetooth the Sixaxis occasionally sends
1333 * a report with the second byte 0xff and the rest zeroed.
1334 *
1335 * This report does not reflect the actual state of the
1336 * controller must be ignored to avoid generating false input
1337 * events.
1338 */
1339 if (rd[1] == 0xff)
1340 return -EINVAL;
1341
Simon Woodc9e4d872011-06-10 12:00:27 +02001342 swap(rd[41], rd[42]);
1343 swap(rd[43], rd[44]);
1344 swap(rd[45], rd[46]);
1345 swap(rd[47], rd[48]);
Frank Praznikd902f472014-01-27 10:17:36 -05001346
1347 sixaxis_parse_report(sc, rd, size);
Simon Wood12e9a6d72015-06-09 21:27:05 -06001348 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1349 sixaxis_parse_report(sc, rd, size);
Simon Wood4545ee02015-06-17 00:08:52 -06001350 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1351 size == 49) {
1352 sixaxis_parse_report(sc, rd, size);
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001353 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1354 size == 64) {
1355 dualshock4_parse_report(sc, rd, size);
1356 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1357 size == 78)) {
1358 /* CRC check */
1359 u8 bthdr = 0xA1;
1360 u32 crc;
1361 u32 report_crc;
Roderick Colenbrander49b9ca62016-10-07 12:39:36 -07001362
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001363 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1364 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1365 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1366 if (crc != report_crc) {
1367 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1368 report_crc, crc);
1369 return -EILSEQ;
Roderick Colenbrander49b9ca62016-10-07 12:39:36 -07001370 }
Roderick Colenbrander405182c2016-12-08 19:09:52 -08001371
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001372 dualshock4_parse_report(sc, rd, size);
1373 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1374 size == 64) {
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08001375 unsigned long flags;
1376 enum ds4_dongle_state dongle_state;
1377
Roderick Colenbrander405182c2016-12-08 19:09:52 -08001378 /*
1379 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1380 * if a DS4 is actually connected (indicated by '0').
1381 * For non-dongle, this bit is always 0 (connected).
1382 */
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001383 bool connected = (rd[31] & 0x04) ? false : true;
Roderick Colenbrander405182c2016-12-08 19:09:52 -08001384
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08001385 spin_lock_irqsave(&sc->lock, flags);
1386 dongle_state = sc->ds4_dongle_state;
1387 spin_unlock_irqrestore(&sc->lock, flags);
1388
1389 /*
1390 * The dongle always sends input reports even when no
1391 * DS4 is attached. When a DS4 is connected, we need to
1392 * obtain calibration data before we can use it.
1393 * The code below tracks dongle state and kicks of
1394 * calibration when needed and only allows us to process
1395 * input if a DS4 is actually connected.
1396 */
1397 if (dongle_state == DONGLE_DISCONNECTED && connected) {
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001398 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1399 sony_set_leds(sc);
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08001400
1401 spin_lock_irqsave(&sc->lock, flags);
1402 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1403 spin_unlock_irqrestore(&sc->lock, flags);
1404
1405 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1406
1407 /* Don't process the report since we don't have
1408 * calibration data, but let hidraw have it anyway.
1409 */
1410 return 0;
1411 } else if ((dongle_state == DONGLE_CONNECTED ||
1412 dongle_state == DONGLE_DISABLED) && !connected) {
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001413 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08001414
1415 spin_lock_irqsave(&sc->lock, flags);
1416 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1417 spin_unlock_irqrestore(&sc->lock, flags);
1418
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001419 /* Return 0, so hidraw can get the report. */
1420 return 0;
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08001421 } else if (dongle_state == DONGLE_CALIBRATING ||
1422 dongle_state == DONGLE_DISABLED ||
1423 dongle_state == DONGLE_DISCONNECTED) {
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001424 /* Return 0, so hidraw can get the report. */
1425 return 0;
Roderick Colenbrander405182c2016-12-08 19:09:52 -08001426 }
1427
Frank Praznikd902f472014-01-27 10:17:36 -05001428 dualshock4_parse_report(sc, rd, size);
Todd Kelnerb7289cb2018-02-17 16:47:10 -07001429
1430 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1431 nsg_mrxu_parse_report(sc, rd, size);
1432 return 1;
Simon Woodc9e4d872011-06-10 12:00:27 +02001433 }
1434
Frank Praznik2a242932016-09-22 20:18:09 -04001435 if (sc->defer_initialization) {
1436 sc->defer_initialization = 0;
Roderick Colenbranderb5322732017-03-07 15:45:05 -08001437 sony_schedule_work(sc, SONY_WORKER_STATE);
Frank Praznik2a242932016-09-22 20:18:09 -04001438 }
1439
Simon Woodc9e4d872011-06-10 12:00:27 +02001440 return 0;
1441}
1442
Colin Leitnerf04d5142013-05-27 23:41:05 +02001443static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1444 struct hid_field *field, struct hid_usage *usage,
1445 unsigned long **bit, int *max)
1446{
1447 struct sony_sc *sc = hid_get_drvdata(hdev);
1448
1449 if (sc->quirks & BUZZ_CONTROLLER) {
1450 unsigned int key = usage->hid & HID_USAGE;
1451
1452 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1453 return -1;
1454
1455 switch (usage->collection_index) {
1456 case 1:
1457 if (key >= ARRAY_SIZE(buzz_keymap))
1458 return -1;
1459
1460 key = buzz_keymap[key];
1461 if (!key)
1462 return -1;
1463 break;
1464 default:
1465 return -1;
1466 }
1467
1468 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1469 return 1;
1470 }
1471
Jiri Kosina078328d2013-06-13 12:03:49 +02001472 if (sc->quirks & PS3REMOTE)
1473 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1474
Roderick Colenbranderb8f09702017-03-24 15:17:46 -07001475 if (sc->quirks & NAVIGATION_CONTROLLER)
1476 return navigation_mapping(hdev, hi, field, usage, bit, max);
1477
Roderick Colenbrandere19a2672017-03-07 15:45:08 -08001478 if (sc->quirks & SIXAXIS_CONTROLLER)
1479 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
Roderick Colenbrander9131f8c2016-11-23 14:07:08 -08001480
1481 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1482 return ds4_mapping(hdev, hi, field, usage, bit, max);
1483
Sanjay Govind32e411d2020-12-04 18:45:27 +13001484 if (sc->quirks & GH_GUITAR_CONTROLLER)
Pascal Giardcc894ac2020-11-25 22:02:30 -05001485 return guitar_mapping(hdev, hi, field, usage, bit, max);
Roderick Colenbrandere19a2672017-03-07 15:45:08 -08001486
Benjamin Tissoires6f498012013-07-24 16:53:07 +02001487 /* Let hid-core decide for the others */
1488 return 0;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001489}
1490
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001491static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
Todd Kelnerb7289cb2018-02-17 16:47:10 -07001492 int w, int h, int touch_major, int touch_minor, int orientation)
Frank Praznikce8efc32014-09-18 21:15:01 -04001493{
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001494 size_t name_sz;
1495 char *name;
Frank Praznikce8efc32014-09-18 21:15:01 -04001496 int ret;
1497
Hanno Zullacc070a82018-06-14 16:29:08 +02001498 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001499 if (!sc->touchpad)
1500 return -ENOMEM;
Frank Praznikce8efc32014-09-18 21:15:01 -04001501
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001502 input_set_drvdata(sc->touchpad, sc);
1503 sc->touchpad->dev.parent = &sc->hdev->dev;
1504 sc->touchpad->phys = sc->hdev->phys;
1505 sc->touchpad->uniq = sc->hdev->uniq;
1506 sc->touchpad->id.bustype = sc->hdev->bus;
1507 sc->touchpad->id.vendor = sc->hdev->vendor;
1508 sc->touchpad->id.product = sc->hdev->product;
1509 sc->touchpad->id.version = sc->hdev->version;
1510
1511 /* Append a suffix to the controller name as there are various
1512 * DS4 compatible non-Sony devices with different names.
1513 */
1514 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
Hanno Zullacc070a82018-06-14 16:29:08 +02001515 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1516 if (!name)
1517 return -ENOMEM;
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001518 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1519 sc->touchpad->name = name;
1520
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001521 /* We map the button underneath the touchpad to BTN_LEFT. */
1522 __set_bit(EV_KEY, sc->touchpad->evbit);
1523 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1524 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1525
1526 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1527 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1528
Todd Kelnerb7289cb2018-02-17 16:47:10 -07001529 if (touch_major > 0) {
1530 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1531 0, touch_major, 0, 0);
1532 if (touch_minor > 0)
1533 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1534 0, touch_minor, 0, 0);
1535 if (orientation > 0)
1536 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1537 0, orientation, 0, 0);
1538 }
1539
1540 if (sc->quirks & NSG_MRXU_REMOTE) {
1541 __set_bit(EV_REL, sc->touchpad->evbit);
1542 }
1543
1544 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1545 if (ret < 0)
Hanno Zullacc070a82018-06-14 16:29:08 +02001546 return ret;
Todd Kelnerb7289cb2018-02-17 16:47:10 -07001547
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001548 ret = input_register_device(sc->touchpad);
1549 if (ret < 0)
Hanno Zullacc070a82018-06-14 16:29:08 +02001550 return ret;
Frank Praznikce8efc32014-09-18 21:15:01 -04001551
1552 return 0;
Roderick Colenbranderac797b92016-11-23 14:07:07 -08001553}
Frank Praznikce8efc32014-09-18 21:15:01 -04001554
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001555static int sony_register_sensors(struct sony_sc *sc)
1556{
1557 size_t name_sz;
1558 char *name;
1559 int ret;
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001560 int range;
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001561
Hanno Zullaea4a5fd2018-06-14 16:30:02 +02001562 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001563 if (!sc->sensor_dev)
1564 return -ENOMEM;
1565
1566 input_set_drvdata(sc->sensor_dev, sc);
1567 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1568 sc->sensor_dev->phys = sc->hdev->phys;
1569 sc->sensor_dev->uniq = sc->hdev->uniq;
1570 sc->sensor_dev->id.bustype = sc->hdev->bus;
1571 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1572 sc->sensor_dev->id.product = sc->hdev->product;
1573 sc->sensor_dev->id.version = sc->hdev->version;
1574
1575 /* Append a suffix to the controller name as there are various
1576 * DS4 compatible non-Sony devices with different names.
1577 */
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08001578 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
Hanno Zullaea4a5fd2018-06-14 16:30:02 +02001579 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1580 if (!name)
1581 return -ENOMEM;
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08001582 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001583 sc->sensor_dev->name = name;
1584
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08001585 if (sc->quirks & SIXAXIS_CONTROLLER) {
1586 /* For the DS3 we only support the accelerometer, which works
1587 * quite well even without calibration. The device also has
1588 * a 1-axis gyro, but it is very difficult to manage from within
1589 * the driver even to get data, the sensor is inaccurate and
1590 * the behavior is very different between hardware revisions.
1591 */
1592 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1593 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1594 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1595 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1596 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1597 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1598 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1599 range = DS4_ACC_RES_PER_G*4;
1600 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1601 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1602 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1603 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1604 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1605 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001606
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08001607 range = DS4_GYRO_RES_PER_DEG_S*2048;
1608 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1609 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1610 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1611 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1612 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1613 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001614
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08001615 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1616 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1617 }
1618
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001619 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1620
1621 ret = input_register_device(sc->sensor_dev);
1622 if (ret < 0)
Hanno Zullaea4a5fd2018-06-14 16:30:02 +02001623 return ret;
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001624
1625 return 0;
Roderick Colenbrander227c0112017-03-07 15:45:00 -08001626}
1627
Antonio Ospite5710fab2011-02-20 18:26:45 +01001628/*
Jiri Slabybd28ce02008-06-25 23:47:04 +02001629 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1630 * to "operational". Without this, the ps3 controller will not report any
1631 * events.
1632 */
Antonio Ospite816651a2010-05-03 22:15:55 +02001633static int sixaxis_set_operational_usb(struct hid_device *hdev)
Jiri Slabybd28ce02008-06-25 23:47:04 +02001634{
Hongye Yuan69481052019-01-09 09:18:08 +08001635 struct sony_sc *sc = hid_get_drvdata(hdev);
Antonio Ospitea85d67b2015-02-16 18:12:22 +01001636 const int buf_size =
1637 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
Pavel Machek1adf9042016-02-09 13:55:08 +01001638 u8 *buf;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001639 int ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001640
Antonio Ospite2e701a32015-02-16 18:12:24 +01001641 buf = kmalloc(buf_size, GFP_KERNEL);
Jiri Slabybd28ce02008-06-25 23:47:04 +02001642 if (!buf)
1643 return -ENOMEM;
1644
Antonio Ospitea85d67b2015-02-16 18:12:22 +01001645 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1646 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001647 if (ret < 0) {
1648 hid_err(hdev, "can't set operational mode: step 1\n");
1649 goto out;
1650 }
Benjamin Tissoiresf204828a2013-09-11 22:12:25 +02001651
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001652 /*
1653 * Some compatible controllers like the Speedlink Strike FX and
1654 * Gasia need another query plus an USB interrupt to get operational.
1655 */
Antonio Ospitea85d67b2015-02-16 18:12:22 +01001656 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1657 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001658 if (ret < 0) {
1659 hid_err(hdev, "can't set operational mode: step 2\n");
1660 goto out;
1661 }
1662
Bastien Nocera492ca832017-11-07 15:24:47 +01001663 /*
1664 * But the USB interrupt would cause SHANWAN controllers to
Hongye Yuan69481052019-01-09 09:18:08 +08001665 * start rumbling non-stop, so skip step 3 for these controllers.
Bastien Nocera492ca832017-11-07 15:24:47 +01001666 */
Hongye Yuan69481052019-01-09 09:18:08 +08001667 if (sc->quirks & SHANWAN_GAMEPAD)
1668 goto out;
1669
1670 ret = hid_hw_output_report(hdev, buf, 1);
1671 if (ret < 0) {
1672 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1673 ret = 0;
Benjamin Tissoires19f4c2b2016-01-08 17:58:49 +01001674 }
Jiri Slabybd28ce02008-06-25 23:47:04 +02001675
Lauri Kasanena7de9b82015-02-16 15:06:59 +02001676out:
Jiri Slabybd28ce02008-06-25 23:47:04 +02001677 kfree(buf);
1678
1679 return ret;
1680}
1681
Antonio Ospite816651a2010-05-03 22:15:55 +02001682static int sixaxis_set_operational_bt(struct hid_device *hdev)
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00001683{
Pavel Machek1adf9042016-02-09 13:55:08 +01001684 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1685 u8 *buf;
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001686 int ret;
1687
1688 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1689 if (!buf)
1690 return -ENOMEM;
1691
1692 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
Benjamin Tissoiresb0dd72a2014-02-10 12:58:54 -05001693 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001694
1695 kfree(buf);
1696
1697 return ret;
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00001698}
1699
Frank Praznikad142b92014-02-20 11:36:00 -05001700/*
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001701 * Request DS4 calibration data for the motion sensors.
1702 * For Bluetooth this also affects the operating mode (see below).
Frank Praznik68330d82014-02-05 20:03:49 -05001703 */
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001704static int dualshock4_get_calibration_data(struct sony_sc *sc)
Frank Praznik68330d82014-02-05 20:03:49 -05001705{
Pavel Machek1adf9042016-02-09 13:55:08 +01001706 u8 *buf;
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001707 int ret;
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001708 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1709 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1710 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1711 short gyro_speed_plus, gyro_speed_minus;
1712 short acc_x_plus, acc_x_minus;
1713 short acc_y_plus, acc_y_minus;
1714 short acc_z_plus, acc_z_minus;
1715 int speed_2x;
1716 int range_2g;
Frank Praznik68330d82014-02-05 20:03:49 -05001717
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001718 /* For Bluetooth we use a different request, which supports CRC.
1719 * Note: in Bluetooth mode feature report 0x02 also changes the state
1720 * of the controller, so that it sends input reports of type 0x11.
1721 */
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001722 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
Roderick Colenbranderf5dc93b2020-11-09 23:22:28 -08001723 int retries;
1724
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001725 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1726 if (!buf)
1727 return -ENOMEM;
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001728
Roderick Colenbranderf5dc93b2020-11-09 23:22:28 -08001729 /* We should normally receive the feature report data we asked
1730 * for, but hidraw applications such as Steam can issue feature
1731 * reports as well. In particular for Dongle reconnects, Steam
1732 * and this function are competing resulting in often receiving
1733 * data for a different HID report, so retry a few times.
1734 */
1735 for (retries = 0; retries < 3; retries++) {
1736 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1737 DS4_FEATURE_REPORT_0x02_SIZE,
1738 HID_FEATURE_REPORT,
1739 HID_REQ_GET_REPORT);
1740 if (ret < 0)
1741 goto err_stop;
1742
1743 if (buf[0] != 0x02) {
1744 if (retries < 2) {
1745 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1746 continue;
1747 } else {
1748 ret = -EILSEQ;
1749 goto err_stop;
1750 }
1751 } else {
1752 break;
1753 }
1754 }
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001755 } else {
1756 u8 bthdr = 0xA3;
1757 u32 crc;
1758 u32 report_crc;
1759 int retries;
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001760
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001761 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1762 if (!buf)
1763 return -ENOMEM;
1764
1765 for (retries = 0; retries < 3; retries++) {
1766 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1767 DS4_FEATURE_REPORT_0x05_SIZE,
1768 HID_FEATURE_REPORT,
1769 HID_REQ_GET_REPORT);
1770 if (ret < 0)
1771 goto err_stop;
1772
1773 /* CRC check */
1774 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1775 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1776 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1777 if (crc != report_crc) {
1778 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1779 report_crc, crc);
1780 if (retries < 2) {
1781 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1782 continue;
1783 } else {
1784 ret = -EILSEQ;
1785 goto err_stop;
1786 }
1787 } else {
1788 break;
1789 }
1790 }
1791 }
1792
1793 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1794 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1795 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1796 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1797 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1798 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1799 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1800 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1801 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1802 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1803 } else {
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08001804 /* BT + Dongle */
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08001805 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1806 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1807 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1808 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1809 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1810 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1811 }
1812 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1813 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1814 acc_x_plus = get_unaligned_le16(&buf[23]);
1815 acc_x_minus = get_unaligned_le16(&buf[25]);
1816 acc_y_plus = get_unaligned_le16(&buf[27]);
1817 acc_y_minus = get_unaligned_le16(&buf[29]);
1818 acc_z_plus = get_unaligned_le16(&buf[31]);
1819 acc_z_minus = get_unaligned_le16(&buf[33]);
1820
1821 /* Set gyroscope calibration and normalization parameters.
1822 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1823 */
1824 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1825 sc->ds4_calib_data[0].abs_code = ABS_RX;
1826 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1827 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1828 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1829
1830 sc->ds4_calib_data[1].abs_code = ABS_RY;
1831 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1832 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1833 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1834
1835 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1836 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1837 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1838 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1839
1840 /* Set accelerometer calibration and normalization parameters.
1841 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1842 */
1843 range_2g = acc_x_plus - acc_x_minus;
1844 sc->ds4_calib_data[3].abs_code = ABS_X;
1845 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1846 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1847 sc->ds4_calib_data[3].sens_denom = range_2g;
1848
1849 range_2g = acc_y_plus - acc_y_minus;
1850 sc->ds4_calib_data[4].abs_code = ABS_Y;
1851 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1852 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1853 sc->ds4_calib_data[4].sens_denom = range_2g;
1854
1855 range_2g = acc_z_plus - acc_z_minus;
1856 sc->ds4_calib_data[5].abs_code = ABS_Z;
1857 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1858 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1859 sc->ds4_calib_data[5].sens_denom = range_2g;
1860
1861err_stop:
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001862 kfree(buf);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05001863 return ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02001864}
1865
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08001866static void dualshock4_calibration_work(struct work_struct *work)
1867{
1868 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1869 unsigned long flags;
1870 enum ds4_dongle_state dongle_state;
1871 int ret;
1872
1873 ret = dualshock4_get_calibration_data(sc);
1874 if (ret < 0) {
1875 /* This call is very unlikely to fail for the dongle. When it
1876 * fails we are probably in a very bad state, so mark the
1877 * dongle as disabled. We will re-enable the dongle if a new
1878 * DS4 hotplug is detect from sony_raw_event as any issues
1879 * are likely resolved then (the dongle is quite stupid).
1880 */
1881 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1882 dongle_state = DONGLE_DISABLED;
1883 } else {
1884 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1885 dongle_state = DONGLE_CONNECTED;
1886 }
1887
1888 spin_lock_irqsave(&sc->lock, flags);
1889 sc->ds4_dongle_state = dongle_state;
1890 spin_unlock_irqrestore(&sc->lock, flags);
1891}
1892
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08001893static int dualshock4_get_version_info(struct sony_sc *sc)
1894{
1895 u8 *buf;
1896 int ret;
1897
1898 buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1899 if (!buf)
1900 return -ENOMEM;
1901
1902 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1903 DS4_FEATURE_REPORT_0xA3_SIZE,
1904 HID_FEATURE_REPORT,
1905 HID_REQ_GET_REPORT);
1906 if (ret < 0) {
1907 kfree(buf);
1908 return ret;
1909 }
1910
1911 sc->hw_version = get_unaligned_le16(&buf[35]);
1912 sc->fw_version = get_unaligned_le16(&buf[41]);
1913
1914 kfree(buf);
1915 return 0;
1916}
1917
Frank Praznik221399b2015-05-05 20:47:32 -04001918static void sixaxis_set_leds_from_id(struct sony_sc *sc)
Frank Praznik80250872014-04-14 10:11:35 -04001919{
Pavel Machek1adf9042016-02-09 13:55:08 +01001920 static const u8 sixaxis_leds[10][4] = {
Frank Praznik80250872014-04-14 10:11:35 -04001921 { 0x01, 0x00, 0x00, 0x00 },
1922 { 0x00, 0x01, 0x00, 0x00 },
1923 { 0x00, 0x00, 0x01, 0x00 },
1924 { 0x00, 0x00, 0x00, 0x01 },
1925 { 0x01, 0x00, 0x00, 0x01 },
1926 { 0x00, 0x01, 0x00, 0x01 },
1927 { 0x00, 0x00, 0x01, 0x01 },
1928 { 0x01, 0x00, 0x01, 0x01 },
1929 { 0x00, 0x01, 0x01, 0x01 },
1930 { 0x01, 0x01, 0x01, 0x01 }
1931 };
1932
Frank Praznik221399b2015-05-05 20:47:32 -04001933 int id = sc->device_id;
1934
1935 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
Frank Praznik80250872014-04-14 10:11:35 -04001936
1937 if (id < 0)
1938 return;
1939
1940 id %= 10;
Frank Praznik221399b2015-05-05 20:47:32 -04001941 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
Frank Praznik80250872014-04-14 10:11:35 -04001942}
1943
Frank Praznik221399b2015-05-05 20:47:32 -04001944static void dualshock4_set_leds_from_id(struct sony_sc *sc)
Frank Praznik80250872014-04-14 10:11:35 -04001945{
1946 /* The first 4 color/index entries match what the PS4 assigns */
Pavel Machek1adf9042016-02-09 13:55:08 +01001947 static const u8 color_code[7][3] = {
Roderick Colenbrander39254a12017-03-24 15:17:47 -07001948 /* Blue */ { 0x00, 0x00, 0x40 },
1949 /* Red */ { 0x40, 0x00, 0x00 },
1950 /* Green */ { 0x00, 0x40, 0x00 },
1951 /* Pink */ { 0x20, 0x00, 0x20 },
Frank Praznik80250872014-04-14 10:11:35 -04001952 /* Orange */ { 0x02, 0x01, 0x00 },
1953 /* Teal */ { 0x00, 0x01, 0x01 },
1954 /* White */ { 0x01, 0x01, 0x01 }
1955 };
1956
Frank Praznik221399b2015-05-05 20:47:32 -04001957 int id = sc->device_id;
1958
1959 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
Frank Praznik80250872014-04-14 10:11:35 -04001960
1961 if (id < 0)
1962 return;
1963
1964 id %= 7;
Frank Praznik221399b2015-05-05 20:47:32 -04001965 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
Frank Praznik80250872014-04-14 10:11:35 -04001966}
1967
Frank Praznik221399b2015-05-05 20:47:32 -04001968static void buzz_set_leds(struct sony_sc *sc)
Colin Leitnerf04d5142013-05-27 23:41:05 +02001969{
Frank Praznik221399b2015-05-05 20:47:32 -04001970 struct hid_device *hdev = sc->hdev;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001971 struct list_head *report_list =
1972 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1973 struct hid_report *report = list_entry(report_list->next,
1974 struct hid_report, list);
Pavel Machek1adf9042016-02-09 13:55:08 +01001975 s32 *value = report->field[0]->value;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001976
Frank Praznik221399b2015-05-05 20:47:32 -04001977 BUILD_BUG_ON(MAX_LEDS < 4);
1978
Colin Leitnerf04d5142013-05-27 23:41:05 +02001979 value[0] = 0x00;
Frank Praznik221399b2015-05-05 20:47:32 -04001980 value[1] = sc->led_state[0] ? 0xff : 0x00;
1981 value[2] = sc->led_state[1] ? 0xff : 0x00;
1982 value[3] = sc->led_state[2] ? 0xff : 0x00;
1983 value[4] = sc->led_state[3] ? 0xff : 0x00;
Colin Leitnerf04d5142013-05-27 23:41:05 +02001984 value[5] = 0x00;
1985 value[6] = 0x00;
1986 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1987}
1988
Frank Praznik221399b2015-05-05 20:47:32 -04001989static void sony_set_leds(struct sony_sc *sc)
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001990{
Frank Praznik221399b2015-05-05 20:47:32 -04001991 if (!(sc->quirks & BUZZ_CONTROLLER))
Roderick Colenbranderb5322732017-03-07 15:45:05 -08001992 sony_schedule_work(sc, SONY_WORKER_STATE);
Frank Praznik221399b2015-05-05 20:47:32 -04001993 else
1994 buzz_set_leds(sc);
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01001995}
1996
Sven Eckelmannc5382512013-11-19 20:26:30 +01001997static void sony_led_set_brightness(struct led_classdev *led,
Colin Leitnerf04d5142013-05-27 23:41:05 +02001998 enum led_brightness value)
1999{
2000 struct device *dev = led->dev->parent;
Geliang Tangee79a8f2015-12-27 17:25:21 +08002001 struct hid_device *hdev = to_hid_device(dev);
Colin Leitnerf04d5142013-05-27 23:41:05 +02002002 struct sony_sc *drv_data;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002003
2004 int n;
Frank Praznikb3ed4582014-04-14 10:11:36 -04002005 int force_update;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002006
2007 drv_data = hid_get_drvdata(hdev);
Sven Eckelmann2251b852013-11-19 20:26:31 +01002008 if (!drv_data) {
Colin Leitnerf04d5142013-05-27 23:41:05 +02002009 hid_err(hdev, "No device data\n");
2010 return;
2011 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02002012
Frank Praznikb3ed4582014-04-14 10:11:36 -04002013 /*
2014 * The Sixaxis on USB will override any LED settings sent to it
2015 * and keep flashing all of the LEDs until the PS button is pressed.
2016 * Updates, even if redundant, must be always be sent to the
2017 * controller to avoid having to toggle the state of an LED just to
2018 * stop the flashing later on.
2019 */
2020 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
2021
Frank Praznik60781cf2014-01-11 15:13:15 -05002022 for (n = 0; n < drv_data->led_count; n++) {
Frank Praznikb3ed4582014-04-14 10:11:36 -04002023 if (led == drv_data->leds[n] && (force_update ||
2024 (value != drv_data->led_state[n] ||
2025 drv_data->led_delay_on[n] ||
2026 drv_data->led_delay_off[n]))) {
2027
2028 drv_data->led_state[n] = value;
2029
2030 /* Setting the brightness stops the blinking */
2031 drv_data->led_delay_on[n] = 0;
2032 drv_data->led_delay_off[n] = 0;
2033
Frank Praznik221399b2015-05-05 20:47:32 -04002034 sony_set_leds(drv_data);
Colin Leitnerf04d5142013-05-27 23:41:05 +02002035 break;
2036 }
2037 }
2038}
2039
Sven Eckelmannc5382512013-11-19 20:26:30 +01002040static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
Colin Leitnerf04d5142013-05-27 23:41:05 +02002041{
2042 struct device *dev = led->dev->parent;
Geliang Tangee79a8f2015-12-27 17:25:21 +08002043 struct hid_device *hdev = to_hid_device(dev);
Colin Leitnerf04d5142013-05-27 23:41:05 +02002044 struct sony_sc *drv_data;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002045
2046 int n;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002047
2048 drv_data = hid_get_drvdata(hdev);
Sven Eckelmann2251b852013-11-19 20:26:31 +01002049 if (!drv_data) {
Colin Leitnerf04d5142013-05-27 23:41:05 +02002050 hid_err(hdev, "No device data\n");
2051 return LED_OFF;
2052 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02002053
Frank Praznik60781cf2014-01-11 15:13:15 -05002054 for (n = 0; n < drv_data->led_count; n++) {
Simon Wood7db75042014-02-05 12:34:18 -07002055 if (led == drv_data->leds[n])
2056 return drv_data->led_state[n];
Colin Leitnerf04d5142013-05-27 23:41:05 +02002057 }
2058
Simon Wood7db75042014-02-05 12:34:18 -07002059 return LED_OFF;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002060}
Colin Leitnerf04d5142013-05-27 23:41:05 +02002061
Frank Praznikb3ed4582014-04-14 10:11:36 -04002062static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
2063 unsigned long *delay_off)
2064{
2065 struct device *dev = led->dev->parent;
Geliang Tangee79a8f2015-12-27 17:25:21 +08002066 struct hid_device *hdev = to_hid_device(dev);
Frank Praznikb3ed4582014-04-14 10:11:36 -04002067 struct sony_sc *drv_data = hid_get_drvdata(hdev);
2068 int n;
Pavel Machek1adf9042016-02-09 13:55:08 +01002069 u8 new_on, new_off;
Frank Praznikb3ed4582014-04-14 10:11:36 -04002070
2071 if (!drv_data) {
2072 hid_err(hdev, "No device data\n");
2073 return -EINVAL;
2074 }
2075
2076 /* Max delay is 255 deciseconds or 2550 milliseconds */
2077 if (*delay_on > 2550)
2078 *delay_on = 2550;
2079 if (*delay_off > 2550)
2080 *delay_off = 2550;
2081
2082 /* Blink at 1 Hz if both values are zero */
2083 if (!*delay_on && !*delay_off)
2084 *delay_on = *delay_off = 500;
2085
2086 new_on = *delay_on / 10;
2087 new_off = *delay_off / 10;
2088
2089 for (n = 0; n < drv_data->led_count; n++) {
2090 if (led == drv_data->leds[n])
2091 break;
2092 }
2093
2094 /* This LED is not registered on this device */
2095 if (n >= drv_data->led_count)
2096 return -EINVAL;
2097
2098 /* Don't schedule work if the values didn't change */
2099 if (new_on != drv_data->led_delay_on[n] ||
2100 new_off != drv_data->led_delay_off[n]) {
2101 drv_data->led_delay_on[n] = new_on;
2102 drv_data->led_delay_off[n] = new_off;
Roderick Colenbranderb5322732017-03-07 15:45:05 -08002103 sony_schedule_work(drv_data, SONY_WORKER_STATE);
Frank Praznikb3ed4582014-04-14 10:11:36 -04002104 }
2105
2106 return 0;
2107}
2108
Frank Praznikfa57a812014-04-14 10:11:33 -04002109static int sony_leds_init(struct sony_sc *sc)
Colin Leitnerf04d5142013-05-27 23:41:05 +02002110{
Frank Praznikfa57a812014-04-14 10:11:33 -04002111 struct hid_device *hdev = sc->hdev;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002112 int n, ret = 0;
Frank Praznikb3ed4582014-04-14 10:11:36 -04002113 int use_ds4_names;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002114 struct led_classdev *led;
2115 size_t name_sz;
2116 char *name;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002117 size_t name_len;
2118 const char *name_fmt;
Frank Praznikb3ed4582014-04-14 10:11:36 -04002119 static const char * const ds4_name_str[] = { "red", "green", "blue",
2120 "global" };
Pavel Machek1adf9042016-02-09 13:55:08 +01002121 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
2122 u8 use_hw_blink[MAX_LEDS] = { 0 };
Colin Leitnerf04d5142013-05-27 23:41:05 +02002123
Frank Praznikfa57a812014-04-14 10:11:33 -04002124 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
Colin Leitnerf04d5142013-05-27 23:41:05 +02002125
Frank Praznikfa57a812014-04-14 10:11:33 -04002126 if (sc->quirks & BUZZ_CONTROLLER) {
2127 sc->led_count = 4;
Frank Praznikb3ed4582014-04-14 10:11:36 -04002128 use_ds4_names = 0;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002129 name_len = strlen("::buzz#");
2130 name_fmt = "%s::buzz%d";
2131 /* Validate expected report characteristics. */
2132 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
2133 return -ENODEV;
Frank Praznikfa57a812014-04-14 10:11:33 -04002134 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
Frank Praznik221399b2015-05-05 20:47:32 -04002135 dualshock4_set_leds_from_id(sc);
2136 sc->led_state[3] = 1;
Frank Praznikb3ed4582014-04-14 10:11:36 -04002137 sc->led_count = 4;
2138 memset(max_brightness, 255, 3);
2139 use_hw_blink[3] = 1;
2140 use_ds4_names = 1;
Frank Praznik61ebca92014-01-20 12:27:02 -05002141 name_len = 0;
2142 name_fmt = "%s:%s";
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002143 } else if (sc->quirks & MOTION_CONTROLLER) {
2144 sc->led_count = 3;
2145 memset(max_brightness, 255, 3);
2146 use_ds4_names = 1;
2147 name_len = 0;
2148 name_fmt = "%s:%s";
Simon Wood4545ee02015-06-17 00:08:52 -06002149 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
Pavel Machek1adf9042016-02-09 13:55:08 +01002150 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
Simon Wood4545ee02015-06-17 00:08:52 -06002151
2152 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2153 sc->led_count = 1;
2154 memset(use_hw_blink, 1, 4);
2155 use_ds4_names = 0;
2156 name_len = strlen("::sony#");
2157 name_fmt = "%s::sony%d";
Frank Praznik60781cf2014-01-11 15:13:15 -05002158 } else {
Frank Praznik221399b2015-05-05 20:47:32 -04002159 sixaxis_set_leds_from_id(sc);
Frank Praznikfa57a812014-04-14 10:11:33 -04002160 sc->led_count = 4;
Frank Praznikb3ed4582014-04-14 10:11:36 -04002161 memset(use_hw_blink, 1, 4);
2162 use_ds4_names = 0;
Frank Praznik61ebca92014-01-20 12:27:02 -05002163 name_len = strlen("::sony#");
2164 name_fmt = "%s::sony%d";
Frank Praznik60781cf2014-01-11 15:13:15 -05002165 }
2166
Frank Praznikad142b92014-02-20 11:36:00 -05002167 /*
2168 * Clear LEDs as we have no way of reading their initial state. This is
Colin Leitnerf04d5142013-05-27 23:41:05 +02002169 * only relevant if the driver is loaded after somebody actively set the
Frank Praznikad142b92014-02-20 11:36:00 -05002170 * LEDs to on
2171 */
Frank Praznik221399b2015-05-05 20:47:32 -04002172 sony_set_leds(sc);
Colin Leitnerf04d5142013-05-27 23:41:05 +02002173
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002174 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002175
Frank Praznikfa57a812014-04-14 10:11:33 -04002176 for (n = 0; n < sc->led_count; n++) {
Frank Praznik61ebca92014-01-20 12:27:02 -05002177
Frank Praznikb3ed4582014-04-14 10:11:36 -04002178 if (use_ds4_names)
2179 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
Frank Praznik61ebca92014-01-20 12:27:02 -05002180
Hanno Zullaf2d98e22018-06-14 16:30:46 +02002181 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002182 if (!led) {
2183 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
Hanno Zullaf2d98e22018-06-14 16:30:46 +02002184 return -ENOMEM;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002185 }
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002186
2187 name = (void *)(&led[1]);
Frank Praznikb3ed4582014-04-14 10:11:36 -04002188 if (use_ds4_names)
2189 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2190 ds4_name_str[n]);
Frank Praznik61ebca92014-01-20 12:27:02 -05002191 else
2192 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002193 led->name = name;
Frank Praznik221399b2015-05-05 20:47:32 -04002194 led->brightness = sc->led_state[n];
Frank Praznikb3ed4582014-04-14 10:11:36 -04002195 led->max_brightness = max_brightness[n];
Frank Praznik765a1072017-02-08 13:58:43 -05002196 led->flags = LED_CORE_SUSPENDRESUME;
Sven Eckelmannc5382512013-11-19 20:26:30 +01002197 led->brightness_get = sony_led_get_brightness;
2198 led->brightness_set = sony_led_set_brightness;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002199
Frank Praznikb3ed4582014-04-14 10:11:36 -04002200 if (use_hw_blink[n])
2201 led->blink_set = sony_led_blink_set;
2202
Frank Praznik80250872014-04-14 10:11:35 -04002203 sc->leds[n] = led;
2204
Hanno Zullaf2d98e22018-06-14 16:30:46 +02002205 ret = devm_led_classdev_register(&hdev->dev, led);
Julia Lawall8cd5fcd2013-12-29 23:47:27 +01002206 if (ret) {
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002207 hid_err(hdev, "Failed to register LED %d\n", n);
Hanno Zullaf2d98e22018-06-14 16:30:46 +02002208 return ret;
Jiri Kosina40e32ee2013-05-28 11:22:09 +02002209 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02002210 }
Colin Leitnerf04d5142013-05-27 23:41:05 +02002211
Hanno Zullaf2d98e22018-06-14 16:30:46 +02002212 return 0;
Colin Leitnerf04d5142013-05-27 23:41:05 +02002213}
2214
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002215static void sixaxis_send_output_report(struct sony_sc *sc)
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002216{
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002217 static const union sixaxis_output_report_01 default_report = {
Frank Praznik55d3b662014-04-14 10:11:32 -04002218 .buf = {
2219 0x01,
Scott Moreauad07b7a2016-01-13 07:40:43 -07002220 0x01, 0xff, 0x00, 0xff, 0x00,
Frank Praznik55d3b662014-04-14 10:11:32 -04002221 0x00, 0x00, 0x00, 0x00, 0x00,
2222 0xff, 0x27, 0x10, 0x00, 0x32,
2223 0xff, 0x27, 0x10, 0x00, 0x32,
2224 0xff, 0x27, 0x10, 0x00, 0x32,
2225 0xff, 0x27, 0x10, 0x00, 0x32,
2226 0x00, 0x00, 0x00, 0x00, 0x00
2227 }
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002228 };
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002229 struct sixaxis_output_report *report =
2230 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2231 int n;
2232
2233 /* Initialize the report with default values */
2234 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002235
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002236#ifdef CONFIG_SONY_FF
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002237 report->rumble.right_motor_on = sc->right ? 1 : 0;
2238 report->rumble.left_motor_force = sc->left;
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002239#endif
2240
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002241 report->leds_bitmap |= sc->led_state[0] << 1;
2242 report->leds_bitmap |= sc->led_state[1] << 2;
2243 report->leds_bitmap |= sc->led_state[2] << 3;
2244 report->leds_bitmap |= sc->led_state[3] << 4;
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002245
Simon Wood88f65762014-04-14 10:11:37 -04002246 /* Set flag for all leds off, required for 3rd party INTEC controller */
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002247 if ((report->leds_bitmap & 0x1E) == 0)
2248 report->leds_bitmap |= 0x20;
Simon Wood88f65762014-04-14 10:11:37 -04002249
Frank Praznikb3ed4582014-04-14 10:11:36 -04002250 /*
2251 * The LEDs in the report are indexed in reverse order to their
2252 * corresponding light on the controller.
2253 * Index 0 = LED 4, index 1 = LED 3, etc...
2254 *
2255 * In the case of both delay values being zero (blinking disabled) the
2256 * default report values should be used or the controller LED will be
2257 * always off.
2258 */
2259 for (n = 0; n < 4; n++) {
2260 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002261 report->led[3 - n].duty_off = sc->led_delay_off[n];
2262 report->led[3 - n].duty_on = sc->led_delay_on[n];
Frank Praznikb3ed4582014-04-14 10:11:36 -04002263 }
2264 }
2265
Hongye Yuand03213f2019-01-09 09:18:09 +08002266 /* SHANWAN controllers require output reports via intr channel */
2267 if (sc->quirks & SHANWAN_GAMEPAD)
2268 hid_hw_output_report(sc->hdev, (u8 *)report,
2269 sizeof(struct sixaxis_output_report));
2270 else
2271 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2272 sizeof(struct sixaxis_output_report),
2273 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002274}
2275
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002276static void dualshock4_send_output_report(struct sony_sc *sc)
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002277{
Frank Praznik0da8ea62014-01-16 21:42:51 -05002278 struct hid_device *hdev = sc->hdev;
Pavel Machek1adf9042016-02-09 13:55:08 +01002279 u8 *buf = sc->output_report_dmabuf;
Frank Praznik48220232014-02-05 20:03:44 -05002280 int offset;
Frank Praznik0da8ea62014-01-16 21:42:51 -05002281
Frank Praznikc4425c82016-09-22 20:18:10 -04002282 /*
Roderick Colenbrander77b499e2017-03-24 15:17:49 -07002283 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2284 * control the interval at which Dualshock 4 reports data:
2285 * 0x00 - 1ms
2286 * 0x01 - 1ms
2287 * 0x02 - 2ms
2288 * 0x3E - 62ms
2289 * 0x3F - disabled
Frank Praznikc4425c82016-09-22 20:18:10 -04002290 */
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08002291 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
Roderick Colenbrander2c159de2016-10-07 12:39:35 -07002292 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
Frank Praznikfdcf105d2014-02-05 20:03:46 -05002293 buf[0] = 0x05;
Roderick Colenbrander5caceb02017-03-24 15:17:48 -07002294 buf[1] = 0x07; /* blink + LEDs + motor */
Frank Praznikfdcf105d2014-02-05 20:03:46 -05002295 offset = 4;
2296 } else {
Roderick Colenbrander2c159de2016-10-07 12:39:35 -07002297 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
Frank Praznikfdcf105d2014-02-05 20:03:46 -05002298 buf[0] = 0x11;
Roderick Colenbrander77b499e2017-03-24 15:17:49 -07002299 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
Roderick Colenbrander5caceb02017-03-24 15:17:48 -07002300 buf[3] = 0x07; /* blink + LEDs + motor */
Frank Praznikfdcf105d2014-02-05 20:03:46 -05002301 offset = 6;
2302 }
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002303
2304#ifdef CONFIG_SONY_FF
Frank Praznik48220232014-02-05 20:03:44 -05002305 buf[offset++] = sc->right;
2306 buf[offset++] = sc->left;
2307#else
2308 offset += 2;
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002309#endif
2310
Frank Praznikb3ed4582014-04-14 10:11:36 -04002311 /* LED 3 is the global control */
2312 if (sc->led_state[3]) {
2313 buf[offset++] = sc->led_state[0];
2314 buf[offset++] = sc->led_state[1];
2315 buf[offset++] = sc->led_state[2];
2316 } else {
2317 offset += 3;
2318 }
2319
2320 /* If both delay values are zero the DualShock 4 disables blinking. */
2321 buf[offset++] = sc->led_delay_on[3];
2322 buf[offset++] = sc->led_delay_off[3];
Frank Praznik60781cf2014-01-11 15:13:15 -05002323
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08002324 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
Roderick Colenbrander2c159de2016-10-07 12:39:35 -07002325 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
Roderick Colenbrandere7ef53a2016-10-07 12:39:37 -07002326 else {
2327 /* CRC generation */
2328 u8 bthdr = 0xA2;
2329 u32 crc;
2330
2331 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2332 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2333 put_unaligned_le32(crc, &buf[74]);
2334 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2335 }
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002336}
2337
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002338static void motion_send_output_report(struct sony_sc *sc)
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002339{
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002340 struct hid_device *hdev = sc->hdev;
2341 struct motion_output_report_02 *report =
2342 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2343
Simon Wood41d2d422015-06-09 21:27:06 -06002344 memset(report, 0, MOTION_REPORT_0x02_SIZE);
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002345
2346 report->type = 0x02; /* set leds */
2347 report->r = sc->led_state[0];
2348 report->g = sc->led_state[1];
2349 report->b = sc->led_state[2];
2350
2351#ifdef CONFIG_SONY_FF
2352 report->rumble = max(sc->right, sc->left);
2353#endif
2354
Pavel Machek1adf9042016-02-09 13:55:08 +01002355 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002356}
2357
Frank Praznikdecd9462015-11-11 09:49:38 -05002358static inline void sony_send_output_report(struct sony_sc *sc)
2359{
2360 if (sc->send_output_report)
2361 sc->send_output_report(sc);
2362}
2363
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002364static void sony_state_worker(struct work_struct *work)
2365{
2366 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
Antonio Ospiteef916ef2016-02-09 13:55:07 +01002367
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002368 sc->send_output_report(sc);
2369}
2370
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002371static int sony_allocate_output_report(struct sony_sc *sc)
2372{
Simon Wood4545ee02015-06-17 00:08:52 -06002373 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2374 (sc->quirks & NAVIGATION_CONTROLLER))
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002375 sc->output_report_dmabuf =
Hanno Zullaea58c332018-06-14 16:32:16 +02002376 devm_kmalloc(&sc->hdev->dev,
2377 sizeof(union sixaxis_output_report_01),
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002378 GFP_KERNEL);
2379 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
Hanno Zullaea58c332018-06-14 16:32:16 +02002380 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2381 DS4_OUTPUT_REPORT_0x11_SIZE,
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002382 GFP_KERNEL);
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08002383 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
Hanno Zullaea58c332018-06-14 16:32:16 +02002384 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2385 DS4_OUTPUT_REPORT_0x05_SIZE,
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002386 GFP_KERNEL);
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002387 else if (sc->quirks & MOTION_CONTROLLER)
Hanno Zullaea58c332018-06-14 16:32:16 +02002388 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2389 MOTION_REPORT_0x02_SIZE,
Simon Wood41d2d422015-06-09 21:27:06 -06002390 GFP_KERNEL);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002391 else
2392 return 0;
2393
2394 if (!sc->output_report_dmabuf)
2395 return -ENOMEM;
2396
2397 return 0;
2398}
2399
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002400#ifdef CONFIG_SONY_FF
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002401static int sony_play_effect(struct input_dev *dev, void *data,
2402 struct ff_effect *effect)
2403{
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002404 struct hid_device *hid = input_get_drvdata(dev);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002405 struct sony_sc *sc = hid_get_drvdata(hid);
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002406
2407 if (effect->type != FF_RUMBLE)
2408 return 0;
2409
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002410 sc->left = effect->u.rumble.strong_magnitude / 256;
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002411 sc->right = effect->u.rumble.weak_magnitude / 256;
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002412
Roderick Colenbranderb5322732017-03-07 15:45:05 -08002413 sony_schedule_work(sc, SONY_WORKER_STATE);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002414 return 0;
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002415}
2416
Frank Praznikfa57a812014-04-14 10:11:33 -04002417static int sony_init_ff(struct sony_sc *sc)
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002418{
Alan Sternd9d4b1e2019-10-03 14:53:59 -04002419 struct hid_input *hidinput;
2420 struct input_dev *input_dev;
2421
2422 if (list_empty(&sc->hdev->inputs)) {
2423 hid_err(sc->hdev, "no inputs found\n");
2424 return -ENODEV;
2425 }
2426 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2427 input_dev = hidinput->input;
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002428
2429 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2430 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2431}
2432
2433#else
Frank Praznikfa57a812014-04-14 10:11:33 -04002434static int sony_init_ff(struct sony_sc *sc)
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002435{
2436 return 0;
2437}
Sven Eckelmann9f323b62013-11-17 20:38:21 +01002438
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002439#endif
2440
Frank Praznikd902f472014-01-27 10:17:36 -05002441static int sony_battery_get_property(struct power_supply *psy,
2442 enum power_supply_property psp,
2443 union power_supply_propval *val)
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002444{
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002445 struct sony_sc *sc = power_supply_get_drvdata(psy);
Frank Praznikd902f472014-01-27 10:17:36 -05002446 unsigned long flags;
2447 int ret = 0;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08002448 u8 battery_capacity;
2449 int battery_status;
Frank Praznikd902f472014-01-27 10:17:36 -05002450
2451 spin_lock_irqsave(&sc->lock, flags);
Frank Praznikd902f472014-01-27 10:17:36 -05002452 battery_capacity = sc->battery_capacity;
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08002453 battery_status = sc->battery_status;
Frank Praznikd902f472014-01-27 10:17:36 -05002454 spin_unlock_irqrestore(&sc->lock, flags);
2455
2456 switch (psp) {
2457 case POWER_SUPPLY_PROP_PRESENT:
2458 val->intval = 1;
2459 break;
2460 case POWER_SUPPLY_PROP_SCOPE:
2461 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2462 break;
2463 case POWER_SUPPLY_PROP_CAPACITY:
2464 val->intval = battery_capacity;
2465 break;
2466 case POWER_SUPPLY_PROP_STATUS:
Roderick Colenbrandera76a6c12020-11-09 23:22:27 -08002467 val->intval = battery_status;
Frank Praznikd902f472014-01-27 10:17:36 -05002468 break;
2469 default:
2470 ret = -EINVAL;
2471 break;
2472 }
2473 return ret;
2474}
2475
Frank Praznik0f398232016-09-22 20:18:08 -04002476static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
Frank Praznikd902f472014-01-27 10:17:36 -05002477{
Frank Praznik0f398232016-09-22 20:18:08 -04002478 const char *battery_str_fmt = append_dev_id ?
2479 "sony_controller_battery_%pMR_%i" :
2480 "sony_controller_battery_%pMR";
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002481 struct power_supply_config psy_cfg = { .drv_data = sc, };
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002482 struct hid_device *hdev = sc->hdev;
Frank Praznikd902f472014-01-27 10:17:36 -05002483 int ret;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002484
Frank Praznikad142b92014-02-20 11:36:00 -05002485 /*
2486 * Set the default battery level to 100% to avoid low battery warnings
Frank Praznikd9a293a2014-02-05 20:03:48 -05002487 * if the battery is polled before the first device report is received.
2488 */
2489 sc->battery_capacity = 100;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002490
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002491 sc->battery_desc.properties = sony_battery_props;
2492 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2493 sc->battery_desc.get_property = sony_battery_get_property;
2494 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2495 sc->battery_desc.use_for_apm = 0;
Hanno Zulla8082d3f2018-06-14 16:31:36 +02002496 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2497 battery_str_fmt, sc->mac_address, sc->device_id);
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002498 if (!sc->battery_desc.name)
Frank Praznikd902f472014-01-27 10:17:36 -05002499 return -ENOMEM;
2500
Hanno Zulla8082d3f2018-06-14 16:31:36 +02002501 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002502 &psy_cfg);
2503 if (IS_ERR(sc->battery)) {
2504 ret = PTR_ERR(sc->battery);
Frank Praznikd902f472014-01-27 10:17:36 -05002505 hid_err(hdev, "Unable to register battery device\n");
Hanno Zulla8082d3f2018-06-14 16:31:36 +02002506 return ret;
Frank Praznikd902f472014-01-27 10:17:36 -05002507 }
2508
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01002509 power_supply_powers(sc->battery, &hdev->dev);
Frank Praznikd902f472014-01-27 10:17:36 -05002510 return 0;
Frank Praznikd902f472014-01-27 10:17:36 -05002511}
2512
Frank Praznikd2d782f2014-02-20 11:36:03 -05002513/*
2514 * If a controller is plugged in via USB while already connected via Bluetooth
2515 * it will show up as two devices. A global list of connected controllers and
2516 * their MAC addresses is maintained to ensure that a device is only connected
2517 * once.
Frank Praznik0f398232016-09-22 20:18:08 -04002518 *
2519 * Some USB-only devices masquerade as Sixaxis controllers and all have the
2520 * same dummy Bluetooth address, so a comparison of the connection type is
2521 * required. Devices are only rejected in the case where two devices have
2522 * matching Bluetooth addresses on different bus types.
Frank Praznikd2d782f2014-02-20 11:36:03 -05002523 */
Frank Praznik0f398232016-09-22 20:18:08 -04002524static inline int sony_compare_connection_type(struct sony_sc *sc0,
2525 struct sony_sc *sc1)
2526{
2527 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2528 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2529
2530 return sc0_not_bt == sc1_not_bt;
2531}
2532
Frank Praznikd2d782f2014-02-20 11:36:03 -05002533static int sony_check_add_dev_list(struct sony_sc *sc)
2534{
2535 struct sony_sc *entry;
2536 unsigned long flags;
2537 int ret;
2538
2539 spin_lock_irqsave(&sony_dev_list_lock, flags);
2540
2541 list_for_each_entry(entry, &sony_device_list, list_node) {
2542 ret = memcmp(sc->mac_address, entry->mac_address,
2543 sizeof(sc->mac_address));
2544 if (!ret) {
Frank Praznik0f398232016-09-22 20:18:08 -04002545 if (sony_compare_connection_type(sc, entry)) {
2546 ret = 1;
2547 } else {
2548 ret = -EEXIST;
2549 hid_info(sc->hdev,
2550 "controller with MAC address %pMR already connected\n",
Frank Praznikd2d782f2014-02-20 11:36:03 -05002551 sc->mac_address);
Frank Praznik0f398232016-09-22 20:18:08 -04002552 }
Frank Praznikd2d782f2014-02-20 11:36:03 -05002553 goto unlock;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002554 }
2555 }
2556
Frank Praznikd2d782f2014-02-20 11:36:03 -05002557 ret = 0;
2558 list_add(&(sc->list_node), &sony_device_list);
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002559
Frank Praznikd2d782f2014-02-20 11:36:03 -05002560unlock:
2561 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2562 return ret;
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002563}
2564
Frank Praznikd2d782f2014-02-20 11:36:03 -05002565static void sony_remove_dev_list(struct sony_sc *sc)
2566{
2567 unsigned long flags;
2568
2569 if (sc->list_node.next) {
2570 spin_lock_irqsave(&sony_dev_list_lock, flags);
2571 list_del(&(sc->list_node));
2572 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2573 }
2574}
2575
2576static int sony_get_bt_devaddr(struct sony_sc *sc)
2577{
2578 int ret;
2579
2580 /* HIDP stores the device MAC address as a string in the uniq field. */
2581 ret = strlen(sc->hdev->uniq);
2582 if (ret != 17)
2583 return -EINVAL;
2584
2585 ret = sscanf(sc->hdev->uniq,
2586 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2587 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2588 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2589
2590 if (ret != 6)
2591 return -EINVAL;
2592
2593 return 0;
2594}
2595
2596static int sony_check_add(struct sony_sc *sc)
2597{
Pavel Machek1adf9042016-02-09 13:55:08 +01002598 u8 *buf = NULL;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002599 int n, ret;
2600
2601 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
Simon Wood12e9a6d72015-06-09 21:27:05 -06002602 (sc->quirks & MOTION_CONTROLLER_BT) ||
Simon Wood4545ee02015-06-17 00:08:52 -06002603 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
Frank Praznikd2d782f2014-02-20 11:36:03 -05002604 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2605 /*
2606 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2607 * address from the uniq string where HIDP stores it.
2608 * As uniq cannot be guaranteed to be a MAC address in all cases
2609 * a failure of this function should not prevent the connection.
2610 */
2611 if (sony_get_bt_devaddr(sc) < 0) {
2612 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2613 return 0;
2614 }
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08002615 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
Roderick Colenbrander2c159de2016-10-07 12:39:35 -07002616 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002617 if (!buf)
2618 return -ENOMEM;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002619
2620 /*
2621 * The MAC address of a DS4 controller connected via USB can be
2622 * retrieved with feature report 0x81. The address begins at
2623 * offset 1.
2624 */
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002625 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
Roderick Colenbrander2c159de2016-10-07 12:39:35 -07002626 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002627 HID_REQ_GET_REPORT);
Frank Praznikd2d782f2014-02-20 11:36:03 -05002628
Roderick Colenbrander2c159de2016-10-07 12:39:35 -07002629 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
Frank Praznikd2d782f2014-02-20 11:36:03 -05002630 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002631 ret = ret < 0 ? ret : -EINVAL;
2632 goto out_free;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002633 }
2634
2635 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
Roderick Colenbranderc70d5f72016-12-08 19:09:51 -08002636
2637 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
Andy Shevchenko648d4932017-12-11 15:06:12 +02002638 "%pMR", sc->mac_address);
Simon Wood4545ee02015-06-17 00:08:52 -06002639 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2640 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002641 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2642 if (!buf)
2643 return -ENOMEM;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002644
2645 /*
2646 * The MAC address of a Sixaxis controller connected via USB can
2647 * be retrieved with feature report 0xf2. The address begins at
2648 * offset 4.
2649 */
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002650 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2651 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2652 HID_REQ_GET_REPORT);
Frank Praznikd2d782f2014-02-20 11:36:03 -05002653
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002654 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
Frank Praznikd2d782f2014-02-20 11:36:03 -05002655 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002656 ret = ret < 0 ? ret : -EINVAL;
2657 goto out_free;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002658 }
2659
2660 /*
2661 * The Sixaxis device MAC in the report is big-endian and must
2662 * be byte-swapped.
2663 */
2664 for (n = 0; n < 6; n++)
2665 sc->mac_address[5-n] = buf[4+n];
Roderick Colenbrander5a144be2017-03-24 15:17:45 -07002666
2667 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
Andy Shevchenko648d4932017-12-11 15:06:12 +02002668 "%pMR", sc->mac_address);
Frank Praznikd2d782f2014-02-20 11:36:03 -05002669 } else {
2670 return 0;
2671 }
2672
Frank Praznik9b2b5c92014-11-12 14:10:09 -05002673 ret = sony_check_add_dev_list(sc);
2674
2675out_free:
2676
2677 kfree(buf);
2678
2679 return ret;
Frank Praznikd2d782f2014-02-20 11:36:03 -05002680}
2681
Frank Praznik80250872014-04-14 10:11:35 -04002682static int sony_set_device_id(struct sony_sc *sc)
2683{
2684 int ret;
2685
2686 /*
2687 * Only DualShock 4 or Sixaxis controllers get an id.
2688 * All others are set to -1.
2689 */
2690 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2691 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2692 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2693 GFP_KERNEL);
2694 if (ret < 0) {
2695 sc->device_id = -1;
2696 return ret;
2697 }
2698 sc->device_id = ret;
2699 } else {
2700 sc->device_id = -1;
2701 }
2702
2703 return 0;
2704}
2705
2706static void sony_release_device_id(struct sony_sc *sc)
2707{
2708 if (sc->device_id >= 0) {
2709 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2710 sc->device_id = -1;
2711 }
2712}
2713
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002714static inline void sony_init_output_report(struct sony_sc *sc,
Antonio Ospite09593e32016-02-09 13:55:06 +01002715 void (*send_output_report)(struct sony_sc *))
Frank Praznik46262042014-04-14 10:11:31 -04002716{
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002717 sc->send_output_report = send_output_report;
2718
Roderick Colenbranderb5322732017-03-07 15:45:05 -08002719 if (!sc->state_worker_initialized)
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002720 INIT_WORK(&sc->state_worker, sony_state_worker);
Frank Praznik46262042014-04-14 10:11:31 -04002721
Roderick Colenbranderb5322732017-03-07 15:45:05 -08002722 sc->state_worker_initialized = 1;
Frank Praznik46262042014-04-14 10:11:31 -04002723}
2724
2725static inline void sony_cancel_work_sync(struct sony_sc *sc)
2726{
Roderick Colenbrandere0f69742019-08-02 15:50:19 -07002727 unsigned long flags;
2728
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08002729 if (sc->hotplug_worker_initialized)
2730 cancel_work_sync(&sc->hotplug_worker);
Roderick Colenbrandere0f69742019-08-02 15:50:19 -07002731 if (sc->state_worker_initialized) {
2732 spin_lock_irqsave(&sc->lock, flags);
2733 sc->state_worker_initialized = 0;
2734 spin_unlock_irqrestore(&sc->lock, flags);
Frank Praznik46262042014-04-14 10:11:31 -04002735 cancel_work_sync(&sc->state_worker);
Roderick Colenbrandere0f69742019-08-02 15:50:19 -07002736 }
Frank Praznik46262042014-04-14 10:11:31 -04002737}
Frank Praznikd2d782f2014-02-20 11:36:03 -05002738
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002739static int sony_input_configured(struct hid_device *hdev,
2740 struct hid_input *hidinput)
Jiri Slabybd28ce02008-06-25 23:47:04 +02002741{
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002742 struct sony_sc *sc = hid_get_drvdata(hdev);
Frank Praznik0f398232016-09-22 20:18:08 -04002743 int append_dev_id;
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002744 int ret;
Jiri Slabybd28ce02008-06-25 23:47:04 +02002745
Frank Praznik80250872014-04-14 10:11:35 -04002746 ret = sony_set_device_id(sc);
2747 if (ret < 0) {
2748 hid_err(hdev, "failed to allocate the device id\n");
2749 goto err_stop;
2750 }
2751
Roderick Colenbranderdf848bc2017-03-07 15:45:11 -08002752 ret = append_dev_id = sony_check_add(sc);
2753 if (ret < 0)
2754 goto err_stop;
2755
Frank Praznik131a8a92015-05-05 20:47:28 -04002756 ret = sony_allocate_output_report(sc);
2757 if (ret < 0) {
2758 hid_err(hdev, "failed to allocate the output report buffer\n");
2759 goto err_stop;
2760 }
2761
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08002762 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
Benjamin Tissoirese534a932014-03-08 22:52:42 -05002763 /*
2764 * The Sony Sixaxis does not handle HID Output Reports on the
2765 * Interrupt EP like it could, so we need to force HID Output
2766 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2767 *
2768 * There is also another issue about HID Output Reports via USB,
2769 * the Sixaxis does not want the report_id as part of the data
2770 * packet, so we have to discard buf[0] when sending the actual
2771 * control message, even for numbered reports, humpf!
Frank Praznik2a242932016-09-22 20:18:09 -04002772 *
2773 * Additionally, the Sixaxis on USB isn't properly initialized
2774 * until the PS logo button is pressed and as such won't retain
2775 * any state set by an output report, so the initial
2776 * configuration report is deferred until the first input
2777 * report arrives.
Benjamin Tissoirese534a932014-03-08 22:52:42 -05002778 */
2779 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2780 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
Frank Praznik2a242932016-09-22 20:18:09 -04002781 sc->defer_initialization = 1;
Roderick Colenbrander80ecc482017-03-07 15:45:09 -08002782
Antonio Ospite816651a2010-05-03 22:15:55 +02002783 ret = sixaxis_set_operational_usb(hdev);
Roderick Colenbrander80ecc482017-03-07 15:45:09 -08002784 if (ret < 0) {
2785 hid_err(hdev, "Failed to set controller into operational mode\n");
2786 goto err_stop;
2787 }
2788
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002789 sony_init_output_report(sc, sixaxis_send_output_report);
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08002790 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2791 /*
2792 * The Navigation controller wants output reports sent on the ctrl
2793 * endpoint when connected via Bluetooth.
2794 */
2795 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2796
2797 ret = sixaxis_set_operational_bt(hdev);
2798 if (ret < 0) {
2799 hid_err(hdev, "Failed to set controller into operational mode\n");
2800 goto err_stop;
2801 }
2802
2803 sony_init_output_report(sc, sixaxis_send_output_report);
2804 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2805 /*
2806 * The Sony Sixaxis does not handle HID Output Reports on the
2807 * Interrupt EP and the device only becomes active when the
2808 * PS button is pressed. See comment for Navigation controller
2809 * above for more details.
2810 */
2811 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2812 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2813 sc->defer_initialization = 1;
2814
2815 ret = sixaxis_set_operational_usb(hdev);
2816 if (ret < 0) {
2817 hid_err(hdev, "Failed to set controller into operational mode\n");
2818 goto err_stop;
2819 }
2820
2821 ret = sony_register_sensors(sc);
2822 if (ret) {
2823 hid_err(sc->hdev,
2824 "Unable to initialize motion sensors: %d\n", ret);
2825 goto err_stop;
2826 }
2827
2828 sony_init_output_report(sc, sixaxis_send_output_report);
2829 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
Frank Praznik2078b9bb2014-03-15 09:41:16 -04002830 /*
2831 * The Sixaxis wants output reports sent on the ctrl endpoint
2832 * when connected via Bluetooth.
2833 */
2834 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
Roderick Colenbrander80ecc482017-03-07 15:45:09 -08002835
Antonio Ospite816651a2010-05-03 22:15:55 +02002836 ret = sixaxis_set_operational_bt(hdev);
Roderick Colenbrander80ecc482017-03-07 15:45:09 -08002837 if (ret < 0) {
2838 hid_err(hdev, "Failed to set controller into operational mode\n");
2839 goto err_stop;
2840 }
2841
Roderick Colenbrander510c8b72017-03-07 15:45:10 -08002842 ret = sony_register_sensors(sc);
2843 if (ret) {
2844 hid_err(sc->hdev,
2845 "Unable to initialize motion sensors: %d\n", ret);
2846 goto err_stop;
2847 }
2848
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002849 sony_init_output_report(sc, sixaxis_send_output_report);
Frank Praznikfee4e2d2014-02-18 17:22:01 -05002850 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
Roderick Colenbrander55a07d62017-03-07 15:45:01 -08002851 ret = dualshock4_get_calibration_data(sc);
2852 if (ret < 0) {
2853 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2854 goto err_stop;
Frank Praznik68330d82014-02-05 20:03:49 -05002855 }
Frank Praznikc4e1ddf2014-01-17 14:46:26 -05002856
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08002857 ret = dualshock4_get_version_info(sc);
2858 if (ret < 0) {
2859 hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2860 goto err_stop;
2861 }
2862
2863 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2864 if (ret) {
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08002865 hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2866 goto err_stop;
2867 }
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -08002868 sc->fw_version_created = true;
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08002869
2870 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2871 if (ret) {
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08002872 hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2873 goto err_stop;
2874 }
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -08002875 sc->hw_version_created = true;
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08002876
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002877 /*
2878 * The Dualshock 4 touchpad supports 2 touches and has a
2879 * resolution of 1920x942 (44.86 dots/mm).
2880 */
Todd Kelnerb7289cb2018-02-17 16:47:10 -07002881 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002882 if (ret) {
2883 hid_err(sc->hdev,
2884 "Unable to initialize multi-touch slots: %d\n",
2885 ret);
Roderick Colenbrander2b6579d2016-12-08 19:09:50 -08002886 goto err_stop;
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002887 }
2888
Roderick Colenbrander227c0112017-03-07 15:45:00 -08002889 ret = sony_register_sensors(sc);
2890 if (ret) {
2891 hid_err(sc->hdev,
2892 "Unable to initialize motion sensors: %d\n", ret);
2893 goto err_stop;
2894 }
2895
Roderick Colenbrander77b499e2017-03-24 15:17:49 -07002896 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2897 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2898 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2899 if (ret)
2900 hid_warn(sc->hdev,
2901 "can't create sysfs bt_poll_interval attribute err: %d\n",
2902 ret);
2903 }
2904
Roderick Colenbranderf2f47c32017-03-07 15:45:06 -08002905 if (sc->quirks & DUALSHOCK4_DONGLE) {
2906 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2907 sc->hotplug_worker_initialized = 1;
2908 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2909 }
2910
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002911 sony_init_output_report(sc, dualshock4_send_output_report);
Todd Kelnerb7289cb2018-02-17 16:47:10 -07002912 } else if (sc->quirks & NSG_MRXU_REMOTE) {
2913 /*
2914 * The NSG-MRxU touchpad supports 2 touches and has a
2915 * resolution of 1667x1868
2916 */
2917 ret = sony_register_touchpad(sc, 2,
2918 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2919 if (ret) {
2920 hid_err(sc->hdev,
2921 "Unable to initialize multi-touch slots: %d\n",
2922 ret);
2923 goto err_stop;
2924 }
2925
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04002926 } else if (sc->quirks & MOTION_CONTROLLER) {
Frank Praznikd8aaccd2015-11-11 09:49:37 -05002927 sony_init_output_report(sc, motion_send_output_report);
Frank Praznik0bd88dd2014-01-11 15:12:42 -05002928 } else {
2929 ret = 0;
2930 }
Bastien Noceraf9ce7c22010-01-20 12:01:53 +00002931
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002932 if (sc->quirks & SONY_LED_SUPPORT) {
Frank Praznikfa57a812014-04-14 10:11:33 -04002933 ret = sony_leds_init(sc);
Sven Eckelmann0a286ef2013-11-19 20:26:32 +01002934 if (ret < 0)
2935 goto err_stop;
2936 }
2937
Frank Praznikd902f472014-01-27 10:17:36 -05002938 if (sc->quirks & SONY_BATTERY_SUPPORT) {
Frank Praznik0f398232016-09-22 20:18:08 -04002939 ret = sony_battery_probe(sc, append_dev_id);
Frank Praznikd902f472014-01-27 10:17:36 -05002940 if (ret < 0)
2941 goto err_stop;
2942
2943 /* Open the device to receive reports with battery info */
2944 ret = hid_hw_open(hdev);
2945 if (ret < 0) {
2946 hid_err(hdev, "hw open failed\n");
2947 goto err_stop;
2948 }
2949 }
2950
Frank Praznikc8de9db2014-02-20 11:36:01 -05002951 if (sc->quirks & SONY_FF_SUPPORT) {
Frank Praznikfa57a812014-04-14 10:11:33 -04002952 ret = sony_init_ff(sc);
Frank Praznikc8de9db2014-02-20 11:36:01 -05002953 if (ret < 0)
2954 goto err_close;
Frank Praznik5f5750d2014-02-19 13:09:22 -05002955 }
Sven Eckelmanna08c22c2013-11-09 19:25:57 +01002956
Jiri Slabybd28ce02008-06-25 23:47:04 +02002957 return 0;
Frank Praznikd902f472014-01-27 10:17:36 -05002958err_close:
2959 hid_hw_close(hdev);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002960err_stop:
Roderick Colenbrander77b499e2017-03-24 15:17:49 -07002961 /* Piggy back on the default ds4_bt_ poll_interval to determine
2962 * if we need to remove the file as we don't know for sure if we
2963 * executed that logic.
2964 */
2965 if (sc->ds4_bt_poll_interval)
2966 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -08002967 if (sc->fw_version_created)
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08002968 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -08002969 if (sc->hw_version_created)
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08002970 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
Frank Praznik46262042014-04-14 10:11:31 -04002971 sony_cancel_work_sync(sc);
Frank Praznikd2d782f2014-02-20 11:36:03 -05002972 sony_remove_dev_list(sc);
Frank Praznik80250872014-04-14 10:11:35 -04002973 sony_release_device_id(sc);
Jiri Slabybd28ce02008-06-25 23:47:04 +02002974 return ret;
2975}
2976
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002977static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2978{
2979 int ret;
2980 unsigned long quirks = id->driver_data;
2981 struct sony_sc *sc;
Pascal Giardfb1a79a2021-06-04 12:10:23 -04002982 struct usb_device *usbdev;
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002983 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2984
2985 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2986 quirks |= FUTUREMAX_DANCE_MAT;
2987
Ulrich Spörleinbab94e972021-08-14 17:52:14 +02002988 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") ||
2989 !strcmp(hdev->name, "ShanWan PS(R) Ga`epad"))
Hongye Yuan69481052019-01-09 09:18:08 +08002990 quirks |= SHANWAN_GAMEPAD;
2991
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07002992 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2993 if (sc == NULL) {
2994 hid_err(hdev, "can't alloc sony descriptor\n");
2995 return -ENOMEM;
2996 }
2997
2998 spin_lock_init(&sc->lock);
2999
3000 sc->quirks = quirks;
3001 hid_set_drvdata(hdev, sc);
3002 sc->hdev = hdev;
3003
3004 ret = hid_parse(hdev);
3005 if (ret) {
3006 hid_err(hdev, "parse failed\n");
3007 return ret;
3008 }
3009
3010 if (sc->quirks & VAIO_RDESC_CONSTANT)
3011 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3012 else if (sc->quirks & SIXAXIS_CONTROLLER)
3013 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3014
Roderick Colenbrandere19a2672017-03-07 15:45:08 -08003015 /* Patch the hw version on DS3/4 compatible devices, so applications can
Roderick Colenbrander9131f8c2016-11-23 14:07:08 -08003016 * distinguish between the default HID mappings and the mappings defined
3017 * by the Linux game controller spec. This is important for the SDL2
3018 * library, which has a game controller database, which uses device ids
3019 * in combination with version as a key.
3020 */
Roderick Colenbrandere19a2672017-03-07 15:45:08 -08003021 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
Roderick Colenbrander9131f8c2016-11-23 14:07:08 -08003022 hdev->version |= 0x8000;
3023
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07003024 ret = hid_hw_start(hdev, connect_mask);
3025 if (ret) {
3026 hid_err(hdev, "hw start failed\n");
3027 return ret;
3028 }
3029
Roderick Colenbrander4f967f62016-11-23 14:07:06 -08003030 /* sony_input_configured can fail, but this doesn't result
3031 * in hid_hw_start failures (intended). Check whether
3032 * the HID layer claimed the device else fail.
3033 * We don't know the actual reason for the failure, most
3034 * likely it is due to EEXIST in case of double connection
3035 * of USB and Bluetooth, but could have been due to ENOMEM
3036 * or other reasons as well.
3037 */
3038 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
3039 hid_err(hdev, "failed to claim input\n");
Benjamin Tissoires79981932021-12-02 10:53:31 +01003040 ret = -ENODEV;
3041 goto err;
Roderick Colenbrander4f967f62016-11-23 14:07:06 -08003042 }
3043
Daniel Nguyena4bfe132021-08-10 10:09:32 -04003044 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
Benjamin Tissoires79981932021-12-02 10:53:31 +01003045 if (!hid_is_usb(hdev)) {
3046 ret = -EINVAL;
3047 goto err;
3048 }
Greg Kroah-Hartman93020952021-12-01 19:35:03 +01003049
3050 usbdev = to_usb_device(sc->hdev->dev.parent->parent);
3051
Pascal Giardfb1a79a2021-06-04 12:10:23 -04003052 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
Benjamin Tissoires79981932021-12-02 10:53:31 +01003053 if (!sc->ghl_urb) {
3054 ret = -ENOMEM;
3055 goto err;
3056 }
Daniel Nguyena4bfe132021-08-10 10:09:32 -04003057
3058 if (sc->quirks & GHL_GUITAR_PS3WIIU)
3059 ret = ghl_init_urb(sc, usbdev, ghl_ps3wiiu_magic_data,
3060 ARRAY_SIZE(ghl_ps3wiiu_magic_data));
3061 else if (sc->quirks & GHL_GUITAR_PS4)
3062 ret = ghl_init_urb(sc, usbdev, ghl_ps4_magic_data,
3063 ARRAY_SIZE(ghl_ps4_magic_data));
Pascal Giardfb1a79a2021-06-04 12:10:23 -04003064 if (ret) {
3065 hid_err(hdev, "error preparing URB\n");
Benjamin Tissoires79981932021-12-02 10:53:31 +01003066 goto err;
Pascal Giardfb1a79a2021-06-04 12:10:23 -04003067 }
3068
Pascal Giardcc894ac2020-11-25 22:02:30 -05003069 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
3070 mod_timer(&sc->ghl_poke_timer,
3071 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
3072 }
3073
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07003074 return ret;
Benjamin Tissoires79981932021-12-02 10:53:31 +01003075
3076err:
3077 hid_hw_stop(hdev);
3078 return ret;
Roderick Colenbrandere1bc84d2016-10-07 12:39:34 -07003079}
3080
Jiri Kosinacc6e0bb2008-10-23 12:58:38 +02003081static void sony_remove(struct hid_device *hdev)
3082{
Colin Leitnerf04d5142013-05-27 23:41:05 +02003083 struct sony_sc *sc = hid_get_drvdata(hdev);
3084
Daniel Nguyena4bfe132021-08-10 10:09:32 -04003085 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
Pascal Giardcc894ac2020-11-25 22:02:30 -05003086 del_timer_sync(&sc->ghl_poke_timer);
Pascal Giardfb1a79a2021-06-04 12:10:23 -04003087 usb_free_urb(sc->ghl_urb);
3088 }
Pascal Giardcc894ac2020-11-25 22:02:30 -05003089
Roderick Colenbranderac797b92016-11-23 14:07:07 -08003090 hid_hw_close(hdev);
3091
Roderick Colenbrander77b499e2017-03-24 15:17:49 -07003092 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
3093 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
3094
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -08003095 if (sc->fw_version_created)
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08003096 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
3097
Roderick Colenbrander1a8212e2020-11-09 23:22:29 -08003098 if (sc->hw_version_created)
Roderick Colenbrander169f15a2017-12-19 11:04:43 -08003099 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
3100
Frank Praznik46262042014-04-14 10:11:31 -04003101 sony_cancel_work_sync(sc);
Sven Eckelmann9f323b62013-11-17 20:38:21 +01003102
Frank Praznikd2d782f2014-02-20 11:36:03 -05003103 sony_remove_dev_list(sc);
Jiri Slabybd28ce02008-06-25 23:47:04 +02003104
Frank Praznik80250872014-04-14 10:11:35 -04003105 sony_release_device_id(sc);
3106
Jiri Slabybd28ce02008-06-25 23:47:04 +02003107 hid_hw_stop(hdev);
3108}
3109
Frank Praznikdecd9462015-11-11 09:49:38 -05003110#ifdef CONFIG_PM
3111
3112static int sony_suspend(struct hid_device *hdev, pm_message_t message)
3113{
Frank Praznik765a1072017-02-08 13:58:43 -05003114#ifdef CONFIG_SONY_FF
3115
3116 /* On suspend stop any running force-feedback events */
3117 if (SONY_FF_SUPPORT) {
Frank Praznikdecd9462015-11-11 09:49:38 -05003118 struct sony_sc *sc = hid_get_drvdata(hdev);
3119
Frank Praznikdecd9462015-11-11 09:49:38 -05003120 sc->left = sc->right = 0;
Frank Praznikdecd9462015-11-11 09:49:38 -05003121 sony_send_output_report(sc);
3122 }
3123
Frank Praznik765a1072017-02-08 13:58:43 -05003124#endif
Frank Praznikdecd9462015-11-11 09:49:38 -05003125 return 0;
3126}
3127
3128static int sony_resume(struct hid_device *hdev)
3129{
Frank Praznik765a1072017-02-08 13:58:43 -05003130 struct sony_sc *sc = hid_get_drvdata(hdev);
Frank Praznikdecd9462015-11-11 09:49:38 -05003131
Frank Praznik765a1072017-02-08 13:58:43 -05003132 /*
3133 * The Sixaxis and navigation controllers on USB need to be
3134 * reinitialized on resume or they won't behave properly.
3135 */
3136 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
3137 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
3138 sixaxis_set_operational_usb(sc->hdev);
3139 sc->defer_initialization = 1;
Frank Praznikdecd9462015-11-11 09:49:38 -05003140 }
3141
3142 return 0;
3143}
3144
3145#endif
3146
Jiri Slabybd28ce02008-06-25 23:47:04 +02003147static const struct hid_device_id sony_devices[] = {
3148 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3149 .driver_data = SIXAXIS_CONTROLLER_USB },
3150 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
Simon Wood4545ee02015-06-17 00:08:52 -06003151 .driver_data = NAVIGATION_CONTROLLER_USB },
Simon Wood6eabaaa2015-06-17 00:08:51 -06003152 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
Simon Wood4545ee02015-06-17 00:08:52 -06003153 .driver_data = NAVIGATION_CONTROLLER_BT },
Frank Praznikc5e0c1c2015-05-05 20:47:30 -04003154 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
Simon Woodb3bca322015-06-09 21:27:04 -06003155 .driver_data = MOTION_CONTROLLER_USB },
Simon Wooda4afa852015-06-03 09:45:19 -06003156 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
Simon Woodb3bca322015-06-09 21:27:04 -06003157 .driver_data = MOTION_CONTROLLER_BT },
Jiri Slabybd28ce02008-06-25 23:47:04 +02003158 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3159 .driver_data = SIXAXIS_CONTROLLER_BT },
3160 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
3161 .driver_data = VAIO_RDESC_CONSTANT },
3162 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
3163 .driver_data = VAIO_RDESC_CONSTANT },
Antonio Ospiteef916ef2016-02-09 13:55:07 +01003164 /*
3165 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
3166 * Logitech joystick from the device descriptor.
3167 */
Jiri Slabybd28ce02008-06-25 23:47:04 +02003168 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
3169 .driver_data = BUZZ_CONTROLLER },
3170 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
3171 .driver_data = BUZZ_CONTROLLER },
3172 /* PS3 BD Remote Control */
3173 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
3174 .driver_data = PS3REMOTE },
3175 /* Logitech Harmony Adapter for PS3 */
3176 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
3177 .driver_data = PS3REMOTE },
Frank Praznik68a49e52014-11-12 14:52:28 -05003178 /* SMK-Link PS3 BD Remote Control */
3179 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
3180 .driver_data = PS3REMOTE },
Frank Praznik0bd88dd2014-01-11 15:12:42 -05003181 /* Sony Dualshock 4 controllers for PS4 */
3182 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
Frank Praznik8ab16762014-01-16 21:42:31 -05003183 .driver_data = DUALSHOCK4_CONTROLLER_USB },
Frank Praznik0bd88dd2014-01-11 15:12:42 -05003184 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
Frank Praznik8ab16762014-01-16 21:42:31 -05003185 .driver_data = DUALSHOCK4_CONTROLLER_BT },
Roderick Colenbrandercf1015d2016-10-07 12:39:40 -07003186 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3187 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3188 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3189 .driver_data = DUALSHOCK4_CONTROLLER_BT },
Roderick Colenbranderde66a1a2016-11-23 14:07:11 -08003190 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
Roderick Colenbrander35f436c2017-03-07 15:45:04 -08003191 .driver_data = DUALSHOCK4_DONGLE },
Scott Moreau74500cc2016-01-13 07:40:42 -07003192 /* Nyko Core Controller for PS3 */
3193 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
3194 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
Todd Kelnerb7289cb2018-02-17 16:47:10 -07003195 /* SMK-Link NSG-MR5U Remote Control */
3196 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3197 .driver_data = NSG_MR5U_REMOTE_BT },
3198 /* SMK-Link NSG-MR7U Remote Control */
3199 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3200 .driver_data = NSG_MR7U_REMOTE_BT },
Pascal Giardcc894ac2020-11-25 22:02:30 -05003201 /* Guitar Hero Live PS3 and Wii U guitar dongles */
Sanjay Govind32e411d2020-12-04 18:45:27 +13003202 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
3203 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
3204 /* Guitar Hero PC Guitar Dongle */
Daniel Nguyena4bfe132021-08-10 10:09:32 -04003205 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_GUITAR_DONGLE),
Sanjay Govind32e411d2020-12-04 18:45:27 +13003206 .driver_data = GH_GUITAR_CONTROLLER },
3207 /* Guitar Hero PS3 World Tour Guitar Dongle */
3208 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
3209 .driver_data = GH_GUITAR_CONTROLLER },
Daniel Nguyena4bfe132021-08-10 10:09:32 -04003210 /* Guitar Hero Live PS4 guitar dongles */
3211 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_PS4_GHLIVE_DONGLE),
3212 .driver_data = GHL_GUITAR_PS4 | GH_GUITAR_CONTROLLER },
Jiri Slabybd28ce02008-06-25 23:47:04 +02003213 { }
3214};
3215MODULE_DEVICE_TABLE(hid, sony_devices);
3216
3217static struct hid_driver sony_driver = {
Frank Praznikce8efc32014-09-18 21:15:01 -04003218 .name = "sony",
3219 .id_table = sony_devices,
3220 .input_mapping = sony_mapping,
3221 .input_configured = sony_input_configured,
3222 .probe = sony_probe,
3223 .remove = sony_remove,
3224 .report_fixup = sony_report_fixup,
Frank Praznikdecd9462015-11-11 09:49:38 -05003225 .raw_event = sony_raw_event,
3226
3227#ifdef CONFIG_PM
3228 .suspend = sony_suspend,
3229 .resume = sony_resume,
3230 .reset_resume = sony_resume,
3231#endif
Jiri Slabybd28ce02008-06-25 23:47:04 +02003232};
Frank Praznik80250872014-04-14 10:11:35 -04003233
3234static int __init sony_init(void)
3235{
3236 dbg_hid("Sony:%s\n", __func__);
3237
3238 return hid_register_driver(&sony_driver);
3239}
3240
3241static void __exit sony_exit(void)
3242{
3243 dbg_hid("Sony:%s\n", __func__);
3244
Frank Praznik80250872014-04-14 10:11:35 -04003245 hid_unregister_driver(&sony_driver);
Antonio Ospite6c400652015-02-16 22:58:24 +01003246 ida_destroy(&sony_device_id_allocator);
Frank Praznik80250872014-04-14 10:11:35 -04003247}
3248module_init(sony_init);
3249module_exit(sony_exit);
Jiri Slabybd28ce02008-06-25 23:47:04 +02003250
3251MODULE_LICENSE("GPL");