projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
[linux-block.git] / drivers / hid / hid-sony.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
bd28ce00 2/*
077147a3 3 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
bd28ce00
JS		 4 *
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
bd28ce00 8 * Copyright (c) 2008 Jiri Slaby
078328da
JK		 9 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
10 * Copyright (c) 2006-2013 Jiri Kosina
f04d5140 11 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
c4425c8f 12 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
b7289cb1 13 * Copyright (c) 2018 Todd Kelner
cc894ac5 14 * Copyright (c) 2020 Pascal Giard <pascal.giard@etsmtl.ca>
32e411d0 15 * Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
bd28ce00
JS		 16 */
17
18/*
bd28ce00
JS		 19 */
20
ad142b9e
FP		 21/*
22 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
078328da
JK		 23 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
24 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
25 *
26 * There will be no PIN request from the device.
27 */
28
bd28ce00
JS		 29#include <linux/device.h>
30#include <linux/hid.h>
31#include <linux/module.h>
5a0e3ad6 32#include <linux/slab.h>
40e32ee6 33#include <linux/leds.h>
d902f472
FP		 34#include <linux/power_supply.h>
35#include <linux/spinlock.h>
d2d782fc 36#include <linux/list.h>
8025087a 37#include <linux/idr.h>
e5606230 38#include <linux/input/mt.h>
49b9ca6c 39#include <linux/crc32.h>
cc894ac5
PG		 40#include <linux/usb.h>
41#include <linux/timer.h>
49b9ca6c 42#include <asm/unaligned.h>
bd28ce00
JS		 43
44#include "hid-ids.h"
45
6c79c18c
FP		 46#define VAIO_RDESC_CONSTANT BIT(0)
47#define SIXAXIS_CONTROLLER_USB BIT(1)
48#define SIXAXIS_CONTROLLER_BT BIT(2)
49#define BUZZ_CONTROLLER BIT(3)
50#define PS3REMOTE BIT(4)
8ab1676b
FP		 51#define DUALSHOCK4_CONTROLLER_USB BIT(5)
52#define DUALSHOCK4_CONTROLLER_BT BIT(6)
35f436c3
RC		 53#define DUALSHOCK4_DONGLE BIT(7)
54#define MOTION_CONTROLLER_USB BIT(8)
55#define MOTION_CONTROLLER_BT BIT(9)
56#define NAVIGATION_CONTROLLER_USB BIT(10)
57#define NAVIGATION_CONTROLLER_BT BIT(11)
58#define SINO_LITE_CONTROLLER BIT(12)
59#define FUTUREMAX_DANCE_MAT BIT(13)
b7289cb1
TK		 60#define NSG_MR5U_REMOTE_BT BIT(14)
61#define NSG_MR7U_REMOTE_BT BIT(15)
69481059 62#define SHANWAN_GAMEPAD BIT(16)
32e411d0
SG		 63#define GH_GUITAR_CONTROLLER BIT(17)
64#define GHL_GUITAR_PS3WIIU BIT(18)
cc6e0bbb 65
fee4e2d5 66#define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
b3bca326 67#define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
4545ee0a
SW		 68#define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
69 NAVIGATION_CONTROLLER_BT)
68330d83 70#define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
35f436c3
RC		 71 DUALSHOCK4_CONTROLLER_BT | \
72 DUALSHOCK4_DONGLE)
fee4e2d5 73#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
4545ee0a
SW		 74 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
75 NAVIGATION_CONTROLLER)
12e9a6d7 76#define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
4545ee0a 77 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
c5e0c1c4
FP		 78#define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
79 MOTION_CONTROLLER)
0f398230
FP		 80#define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
81 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
b7289cb1 82#define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
60781cf4
FP		 83
84#define MAX_LEDS 4
b7289cb1
TK		 85#define NSG_MRXU_MAX_X 1667
86#define NSG_MRXU_MAX_Y 1868
0a286ef2 87
cc894ac5 88#define GHL_GUITAR_POKE_INTERVAL 10 /* In seconds */
32e411d0 89#define GUITAR_TILT_USAGE 44
cc894ac5
PG		 90
91/* Magic value and data taken from GHLtarUtility:
92 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
93 * Note: The Wii U and PS3 dongles happen to share the same!
94 */
95static const u16 ghl_ps3wiiu_magic_value = 0x201;
96static const char ghl_ps3wiiu_magic_data[] = {
97 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
98};
e57a67da 99
c5e0c1c4 100/* PS/3 Motion controller */
1adf904e 101static u8 motion_rdesc[] = {
c5e0c1c4
FP		 102 0x05, 0x01, /* Usage Page (Desktop), */
103 0x09, 0x04, /* Usage (Joystick), */
104 0xA1, 0x01, /* Collection (Application), */
105 0xA1, 0x02, /* Collection (Logical), */
106 0x85, 0x01, /* Report ID (1), */
c5e0c1c4 107 0x75, 0x01, /* Report Size (1), */
8b2513c3 108 0x95, 0x15, /* Report Count (21), */
c5e0c1c4
FP		 109 0x15, 0x00, /* Logical Minimum (0), */
110 0x25, 0x01, /* Logical Maximum (1), */
111 0x35, 0x00, /* Physical Minimum (0), */
112 0x45, 0x01, /* Physical Maximum (1), */
113 0x05, 0x09, /* Usage Page (Button), */
114 0x19, 0x01, /* Usage Minimum (01h), */
8b2513c3
SW		 115 0x29, 0x15, /* Usage Maximum (15h), */
116 0x81, 0x02, /* Input (Variable), * Buttons */
117 0x95, 0x0B, /* Report Count (11), */
c5e0c1c4 118 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
8b2513c3 119 0x81, 0x03, /* Input (Constant, Variable), * Padding */
c5e0c1c4
FP		 120 0x15, 0x00, /* Logical Minimum (0), */
121 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
122 0x05, 0x01, /* Usage Page (Desktop), */
c5e0c1c4
FP		 123 0xA1, 0x00, /* Collection (Physical), */
124 0x75, 0x08, /* Report Size (8), */
8b2513c3 125 0x95, 0x01, /* Report Count (1), */
c5e0c1c4
FP		 126 0x35, 0x00, /* Physical Minimum (0), */
127 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
128 0x09, 0x30, /* Usage (X), */
8b2513c3 129 0x81, 0x02, /* Input (Variable), * Trigger */
c5e0c1c4 130 0xC0, /* End Collection, */
8b2513c3
SW		 131 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
132 0x75, 0x08, /* Report Size (8), */
133 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
c5e0c1c4 134 0x81, 0x02, /* Input (Variable), */
8b2513c3 135 0x05, 0x01, /* Usage Page (Desktop), */
c5e0c1c4 136 0x75, 0x10, /* Report Size (16), */
8b2513c3
SW		 137 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
138 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
139 0x95, 0x03, /* Report Count (3), * 3x Accels */
140 0x09, 0x33, /* Usage (rX), */
141 0x09, 0x34, /* Usage (rY), */
142 0x09, 0x35, /* Usage (rZ), */
143 0x81, 0x02, /* Input (Variable), */
144 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
145 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
146 0x81, 0x02, /* Input (Variable), */
147 0x05, 0x01, /* Usage Page (Desktop), */
c5e0c1c4 148 0x09, 0x01, /* Usage (Pointer), */
8b2513c3
SW		 149 0x95, 0x03, /* Report Count (3), * 3x Gyros */
150 0x81, 0x02, /* Input (Variable), */
151 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
152 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
c5e0c1c4 153 0x81, 0x02, /* Input (Variable), */
8b2513c3
SW		 154 0x75, 0x0C, /* Report Size (12), */
155 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
156 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
157 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
158 0x81, 0x02, /* Input (Variable), */
159 0x75, 0x08, /* Report Size (8), */
160 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
161 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
162 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
163 0x81, 0x02, /* Input (Variable), */
164 0x75, 0x08, /* Report Size (8), */
165 0x95, 0x30, /* Report Count (48), */
166 0x09, 0x01, /* Usage (Pointer), */
167 0x91, 0x02, /* Output (Variable), */
168 0x75, 0x08, /* Report Size (8), */
169 0x95, 0x30, /* Report Count (48), */
170 0x09, 0x01, /* Usage (Pointer), */
171 0xB1, 0x02, /* Feature (Variable), */
c5e0c1c4
FP		 172 0xC0, /* End Collection, */
173 0xA1, 0x02, /* Collection (Logical), */
174 0x85, 0x02, /* Report ID (2), */
175 0x75, 0x08, /* Report Size (8), */
176 0x95, 0x30, /* Report Count (48), */
177 0x09, 0x01, /* Usage (Pointer), */
178 0xB1, 0x02, /* Feature (Variable), */
179 0xC0, /* End Collection, */
180 0xA1, 0x02, /* Collection (Logical), */
181 0x85, 0xEE, /* Report ID (238), */
182 0x75, 0x08, /* Report Size (8), */
183 0x95, 0x30, /* Report Count (48), */
184 0x09, 0x01, /* Usage (Pointer), */
185 0xB1, 0x02, /* Feature (Variable), */
186 0xC0, /* End Collection, */
187 0xA1, 0x02, /* Collection (Logical), */
188 0x85, 0xEF, /* Report ID (239), */
189 0x75, 0x08, /* Report Size (8), */
190 0x95, 0x30, /* Report Count (48), */
191 0x09, 0x01, /* Usage (Pointer), */
192 0xB1, 0x02, /* Feature (Variable), */
193 0xC0, /* End Collection, */
194 0xC0 /* End Collection */
195};
196
1adf904e 197static u8 ps3remote_rdesc[] = {
078328da
JK		 198 0x05, 0x01, /* GUsagePage Generic Desktop */
199 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
200 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
201
202 /* Use collection 1 for joypad buttons */
203 0xA1, 0x02, /* MCollection Logical (interrelated data) */
204
ef916ef5
AO		 205 /*
206 * Ignore the 1st byte, maybe it is used for a controller
207 * number but it's not needed for correct operation
208 */
078328da
JK		 209 0x75, 0x08, /* GReportSize 0x08 [8] */
210 0x95, 0x01, /* GReportCount 0x01 [1] */
211 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
212
ef916ef5
AO		 213 /*
214 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
215 * buttons multiple keypresses are allowed
216 */
078328da
JK		 217 0x05, 0x09, /* GUsagePage Button */
218 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
219 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
220 0x14, /* GLogicalMinimum [0] */
221 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
222 0x75, 0x01, /* GReportSize 0x01 [1] */
223 0x95, 0x18, /* GReportCount 0x18 [24] */
224 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
225
226 0xC0, /* MEndCollection */
227
228 /* Use collection 2 for remote control buttons */
229 0xA1, 0x02, /* MCollection Logical (interrelated data) */
230
231 /* 5th byte is used for remote control buttons */
232 0x05, 0x09, /* GUsagePage Button */
233 0x18, /* LUsageMinimum [No button pressed] */
234 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
235 0x14, /* GLogicalMinimum [0] */
236 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
237 0x75, 0x08, /* GReportSize 0x08 [8] */
238 0x95, 0x01, /* GReportCount 0x01 [1] */
239 0x80, /* MInput */
240
ef916ef5
AO		 241 /*
242 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
243 * 0xff and 11th is for press indication
244 */
078328da
JK		 245 0x75, 0x08, /* GReportSize 0x08 [8] */
246 0x95, 0x06, /* GReportCount 0x06 [6] */
247 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
248
249 /* 12th byte is for battery strength */
250 0x05, 0x06, /* GUsagePage Generic Device Controls */
251 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
252 0x14, /* GLogicalMinimum [0] */
253 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
254 0x75, 0x08, /* GReportSize 0x08 [8] */
255 0x95, 0x01, /* GReportCount 0x01 [1] */
256 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
257
258 0xC0, /* MEndCollection */
259
260 0xC0 /* MEndCollection [Game Pad] */
261};
262
263static const unsigned int ps3remote_keymap_joypad_buttons[] = {
264 [0x01] = KEY_SELECT,
265 [0x02] = BTN_THUMBL, /* L3 */
266 [0x03] = BTN_THUMBR, /* R3 */
267 [0x04] = BTN_START,
268 [0x05] = KEY_UP,
269 [0x06] = KEY_RIGHT,
270 [0x07] = KEY_DOWN,
271 [0x08] = KEY_LEFT,
272 [0x09] = BTN_TL2, /* L2 */
273 [0x0a] = BTN_TR2, /* R2 */
274 [0x0b] = BTN_TL, /* L1 */
275 [0x0c] = BTN_TR, /* R1 */
276 [0x0d] = KEY_OPTION, /* options/triangle */
277 [0x0e] = KEY_BACK, /* back/circle */
278 [0x0f] = BTN_0, /* cross */
279 [0x10] = KEY_SCREEN, /* view/square */
280 [0x11] = KEY_HOMEPAGE, /* PS button */
281 [0x14] = KEY_ENTER,
282};
283static const unsigned int ps3remote_keymap_remote_buttons[] = {
284 [0x00] = KEY_1,
285 [0x01] = KEY_2,
286 [0x02] = KEY_3,
287 [0x03] = KEY_4,
288 [0x04] = KEY_5,
289 [0x05] = KEY_6,
290 [0x06] = KEY_7,
291 [0x07] = KEY_8,
292 [0x08] = KEY_9,
293 [0x09] = KEY_0,
294 [0x0e] = KEY_ESC, /* return */
295 [0x0f] = KEY_CLEAR,
296 [0x16] = KEY_EJECTCD,
297 [0x1a] = KEY_MENU, /* top menu */
298 [0x28] = KEY_TIME,
299 [0x30] = KEY_PREVIOUS,
300 [0x31] = KEY_NEXT,
301 [0x32] = KEY_PLAY,
302 [0x33] = KEY_REWIND, /* scan back */
303 [0x34] = KEY_FORWARD, /* scan forward */
304 [0x38] = KEY_STOP,
305 [0x39] = KEY_PAUSE,
306 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
307 [0x60] = KEY_FRAMEBACK, /* slow/step back */
308 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
309 [0x63] = KEY_SUBTITLE,
310 [0x64] = KEY_AUDIO,
311 [0x65] = KEY_ANGLE,
312 [0x70] = KEY_INFO, /* display */
313 [0x80] = KEY_BLUE,
314 [0x81] = KEY_RED,
315 [0x82] = KEY_GREEN,
316 [0x83] = KEY_YELLOW,
317};
318
f04d5140 319static const unsigned int buzz_keymap[] = {
ad142b9e
FP		 320 /*
321 * The controller has 4 remote buzzers, each with one LED and 5
f04d5140 322 * buttons.
09593e38 323 *
f04d5140
CL		 324 * We use the mapping chosen by the controller, which is:
325 *
326 * Key Offset
327 * -------------------
328 * Buzz 1
329 * Blue 5
330 * Orange 4
331 * Green 3
332 * Yellow 2
333 *
334 * So, for example, the orange button on the third buzzer is mapped to
335 * BTN_TRIGGER_HAPPY14
336 */
09593e38
AO		 337 [1] = BTN_TRIGGER_HAPPY1,
338 [2] = BTN_TRIGGER_HAPPY2,
339 [3] = BTN_TRIGGER_HAPPY3,
340 [4] = BTN_TRIGGER_HAPPY4,
341 [5] = BTN_TRIGGER_HAPPY5,
342 [6] = BTN_TRIGGER_HAPPY6,
343 [7] = BTN_TRIGGER_HAPPY7,
344 [8] = BTN_TRIGGER_HAPPY8,
345 [9] = BTN_TRIGGER_HAPPY9,
f04d5140
CL		 346 [10] = BTN_TRIGGER_HAPPY10,
347 [11] = BTN_TRIGGER_HAPPY11,
348 [12] = BTN_TRIGGER_HAPPY12,
349 [13] = BTN_TRIGGER_HAPPY13,
350 [14] = BTN_TRIGGER_HAPPY14,
351 [15] = BTN_TRIGGER_HAPPY15,
352 [16] = BTN_TRIGGER_HAPPY16,
353 [17] = BTN_TRIGGER_HAPPY17,
354 [18] = BTN_TRIGGER_HAPPY18,
355 [19] = BTN_TRIGGER_HAPPY19,
356 [20] = BTN_TRIGGER_HAPPY20,
357};
358
b8f0970d
RC		 359/* The Navigation controller is a partial DS3 and uses the same HID report
360 * and hence the same keymap indices, however not not all axes/buttons
361 * are physically present. We use the same axis and button mapping as
362 * the DS3, which uses the Linux gamepad spec.
363 */
364static const unsigned int navigation_absmap[] = {
365 [0x30] = ABS_X,
366 [0x31] = ABS_Y,
367 [0x33] = ABS_Z, /* L2 */
368};
369
370/* Buttons not physically available on the device, but still available
371 * in the reports are explicitly set to 0 for documentation purposes.
372 */
373static const unsigned int navigation_keymap[] = {
374 [0x01] = 0, /* Select */
375 [0x02] = BTN_THUMBL, /* L3 */
376 [0x03] = 0, /* R3 */
377 [0x04] = 0, /* Start */
378 [0x05] = BTN_DPAD_UP, /* Up */
379 [0x06] = BTN_DPAD_RIGHT, /* Right */
380 [0x07] = BTN_DPAD_DOWN, /* Down */
381 [0x08] = BTN_DPAD_LEFT, /* Left */
382 [0x09] = BTN_TL2, /* L2 */
383 [0x0a] = 0, /* R2 */
384 [0x0b] = BTN_TL, /* L1 */
385 [0x0c] = 0, /* R1 */
386 [0x0d] = BTN_NORTH, /* Triangle */
387 [0x0e] = BTN_EAST, /* Circle */
388 [0x0f] = BTN_SOUTH, /* Cross */
389 [0x10] = BTN_WEST, /* Square */
390 [0x11] = BTN_MODE, /* PS */
391};
392
e19a267b
RC		 393static const unsigned int sixaxis_absmap[] = {
394 [0x30] = ABS_X,
395 [0x31] = ABS_Y,
396 [0x32] = ABS_RX, /* right stick X */
397 [0x35] = ABS_RY, /* right stick Y */
398};
399
400static const unsigned int sixaxis_keymap[] = {
401 [0x01] = BTN_SELECT, /* Select */
402 [0x02] = BTN_THUMBL, /* L3 */
403 [0x03] = BTN_THUMBR, /* R3 */
404 [0x04] = BTN_START, /* Start */
405 [0x05] = BTN_DPAD_UP, /* Up */
406 [0x06] = BTN_DPAD_RIGHT, /* Right */
407 [0x07] = BTN_DPAD_DOWN, /* Down */
408 [0x08] = BTN_DPAD_LEFT, /* Left */
409 [0x09] = BTN_TL2, /* L2 */
410 [0x0a] = BTN_TR2, /* R2 */
411 [0x0b] = BTN_TL, /* L1 */
412 [0x0c] = BTN_TR, /* R1 */
413 [0x0d] = BTN_NORTH, /* Triangle */
414 [0x0e] = BTN_EAST, /* Circle */
415 [0x0f] = BTN_SOUTH, /* Cross */
416 [0x10] = BTN_WEST, /* Square */
417 [0x11] = BTN_MODE, /* PS */
418};
419
9131f8cc
RC		 420static const unsigned int ds4_absmap[] = {
421 [0x30] = ABS_X,
422 [0x31] = ABS_Y,
423 [0x32] = ABS_RX, /* right stick X */
424 [0x33] = ABS_Z, /* L2 */
425 [0x34] = ABS_RZ, /* R2 */
426 [0x35] = ABS_RY, /* right stick Y */
427};
428
429static const unsigned int ds4_keymap[] = {
430 [0x1] = BTN_WEST, /* Square */
431 [0x2] = BTN_SOUTH, /* Cross */
432 [0x3] = BTN_EAST, /* Circle */
433 [0x4] = BTN_NORTH, /* Triangle */
434 [0x5] = BTN_TL, /* L1 */
435 [0x6] = BTN_TR, /* R1 */
436 [0x7] = BTN_TL2, /* L2 */
437 [0x8] = BTN_TR2, /* R2 */
438 [0x9] = BTN_SELECT, /* Share */
439 [0xa] = BTN_START, /* Options */
440 [0xb] = BTN_THUMBL, /* L3 */
441 [0xc] = BTN_THUMBR, /* R3 */
442 [0xd] = BTN_MODE, /* PS */
443};
444
d03ae2e1
RC		 445static const struct {int x; int y; } ds4_hat_mapping[] = {
446 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
447 {0, 0}
448};
9131f8cc 449
d902f472
FP		 450static enum power_supply_property sony_battery_props[] = {
451 POWER_SUPPLY_PROP_PRESENT,
452 POWER_SUPPLY_PROP_CAPACITY,
453 POWER_SUPPLY_PROP_SCOPE,
454 POWER_SUPPLY_PROP_STATUS,
455};
456
55d3b664 457struct sixaxis_led {
1adf904e
PM		 458 u8 time_enabled; /* the total time the led is active (0xff means forever) */
459 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
460 u8 enabled;
461 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
462 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
55d3b664
FP		 463} __packed;
464
465struct sixaxis_rumble {
1adf904e
PM		 466 u8 padding;
467 u8 right_duration; /* Right motor duration (0xff means forever) */
468 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
469 u8 left_duration; /* Left motor duration (0xff means forever) */
470 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
55d3b664
FP		 471} __packed;
472
473struct sixaxis_output_report {
1adf904e 474 u8 report_id;
55d3b664 475 struct sixaxis_rumble rumble;
1adf904e
PM		 476 u8 padding[4];
477 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
55d3b664
FP		 478 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
479 struct sixaxis_led _reserved; /* LED5, not actually soldered */
480} __packed;
481
482union sixaxis_output_report_01 {
483 struct sixaxis_output_report data;
1adf904e 484 u8 buf[36];
55d3b664
FP		 485};
486
c5e0c1c4
FP		 487struct motion_output_report_02 {
488 u8 type, zero;
489 u8 r, g, b;
490 u8 zero2;
491 u8 rumble;
492};
493
2c159de0 494#define DS4_FEATURE_REPORT_0x02_SIZE 37
55a07d62 495#define DS4_FEATURE_REPORT_0x05_SIZE 41
2c159de0 496#define DS4_FEATURE_REPORT_0x81_SIZE 7
169f15ab 497#define DS4_FEATURE_REPORT_0xA3_SIZE 49
49b9ca6c 498#define DS4_INPUT_REPORT_0x11_SIZE 78
2c159de0
RC		 499#define DS4_OUTPUT_REPORT_0x05_SIZE 32
500#define DS4_OUTPUT_REPORT_0x11_SIZE 78
29b691a8 501#define SIXAXIS_REPORT_0xF2_SIZE 17
a85d67b5 502#define SIXAXIS_REPORT_0xF5_SIZE 8
41d2d425 503#define MOTION_REPORT_0x02_SIZE 49
9b2b5c9a 504
cdc1c021
RC		 505/* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
506 * additional +2.
507 */
d03ae2e1 508#define DS4_INPUT_REPORT_AXIS_OFFSET 1
ac797b95 509#define DS4_INPUT_REPORT_BUTTON_OFFSET 5
80786eb9 510#define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
227c011b 511#define DS4_INPUT_REPORT_GYRO_X_OFFSET 13
cdc1c021
RC		 512#define DS4_INPUT_REPORT_BATTERY_OFFSET 30
513#define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
514
510c8b7c 515#define SENSOR_SUFFIX " Motion Sensors"
ac797b95
RC		 516#define DS4_TOUCHPAD_SUFFIX " Touchpad"
517
77b499e7
RC		 518/* Default to 4ms poll interval, which is same as USB (not adjustable). */
519#define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
520#define DS4_BT_MAX_POLL_INTERVAL_MS 62
55a07d62
RC		 521#define DS4_GYRO_RES_PER_DEG_S 1024
522#define DS4_ACC_RES_PER_G 8192
523
510c8b7c
RC		 524#define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
525#define SIXAXIS_ACC_RES_PER_G 113
526
8b402c92 527static DEFINE_SPINLOCK(sony_dev_list_lock);
d2d782fc 528static LIST_HEAD(sony_device_list);
8025087a 529static DEFINE_IDA(sony_device_id_allocator);
d2d782fc 530
55a07d62
RC		 531/* Used for calibration of DS4 accelerometer and gyro. */
532struct ds4_calibration_data {
533 int abs_code;
534 short bias;
535 /* Calibration requires scaling against a sensitivity value, which is a
536 * float. Store sensitivity as a fraction to limit floating point
537 * calculations until final calibration.
538 */
539 int sens_numer;
540 int sens_denom;
541};
542
f2f47c38
RC		 543enum ds4_dongle_state {
544 DONGLE_DISCONNECTED,
545 DONGLE_CALIBRATING,
546 DONGLE_CONNECTED,
547 DONGLE_DISABLED
548};
549
b5322736 550enum sony_worker {
f2f47c38
RC		 551 SONY_WORKER_STATE,
552 SONY_WORKER_HOTPLUG
b5322736
RC		 553};
554
cc6e0bbb 555struct sony_sc {
d902f472 556 spinlock_t lock;
d2d782fc 557 struct list_head list_node;
0a286ef2 558 struct hid_device *hdev;
ac797b95 559 struct input_dev *touchpad;
227c011b 560 struct input_dev *sensor_dev;
60781cf4 561 struct led_classdev *leds[MAX_LEDS];
cc6e0bbb 562 unsigned long quirks;
f2f47c38 563 struct work_struct hotplug_worker;
0a286ef2 564 struct work_struct state_worker;
09593e38 565 void (*send_output_report)(struct sony_sc *);
297d716f
KK		 566 struct power_supply *battery;
567 struct power_supply_desc battery_desc;
8025087a 568 int device_id;
169f15ab 569 unsigned fw_version;
1a8212e8 570 bool fw_version_created;
169f15ab 571 unsigned hw_version;
1a8212e8 572 bool hw_version_created;
1adf904e 573 u8 *output_report_dmabuf;
f04d5140 574
9f323b68 575#ifdef CONFIG_SONY_FF
1adf904e
PM		 576 u8 left;
577 u8 right;
9f323b68
SE		 578#endif
579
1adf904e 580 u8 mac_address[6];
f2f47c38 581 u8 hotplug_worker_initialized;
b5322736 582 u8 state_worker_initialized;
2a242932 583 u8 defer_initialization;
1adf904e 584 u8 battery_capacity;
a76a6c18 585 int battery_status;
1adf904e 586 u8 led_state[MAX_LEDS];
1adf904e
PM		 587 u8 led_delay_on[MAX_LEDS];
588 u8 led_delay_off[MAX_LEDS];
589 u8 led_count;
80786eb9
RC		 590
591 bool timestamp_initialized;
592 u16 prev_timestamp;
593 unsigned int timestamp_us;
594
77b499e7 595 u8 ds4_bt_poll_interval;
f2f47c38 596 enum ds4_dongle_state ds4_dongle_state;
55a07d62
RC		 597 /* DS4 calibration data */
598 struct ds4_calibration_data ds4_calib_data[6];
cc894ac5
PG		 599 /* GH Live */
600 struct timer_list ghl_poke_timer;
601 struct usb_ctrlrequest *ghl_cr;
602 u8 *ghl_databuf;
cc6e0bbb
JK		 603};
604
405182c2
RC		 605static void sony_set_leds(struct sony_sc *sc);
606
b5322736
RC		 607static inline void sony_schedule_work(struct sony_sc *sc,
608 enum sony_worker which)
2a242932 609{
e0f6974a
RC		 610 unsigned long flags;
611
b5322736
RC		 612 switch (which) {
613 case SONY_WORKER_STATE:
e0f6974a
RC		 614 spin_lock_irqsave(&sc->lock, flags);
615 if (!sc->defer_initialization && sc->state_worker_initialized)
b5322736 616 schedule_work(&sc->state_worker);
e0f6974a 617 spin_unlock_irqrestore(&sc->lock, flags);
f2f47c38
RC		 618 break;
619 case SONY_WORKER_HOTPLUG:
620 if (sc->hotplug_worker_initialized)
621 schedule_work(&sc->hotplug_worker);
622 break;
b5322736 623 }
2a242932
FP		 624}
625
cc894ac5
PG		 626static void ghl_magic_poke_cb(struct urb *urb)
627{
628 if (urb) {
629 /* Free sc->ghl_cr and sc->ghl_databuf allocated in
630 * ghl_magic_poke()
631 */
632 kfree(urb->setup_packet);
633 kfree(urb->transfer_buffer);
634 }
635}
636
637static void ghl_magic_poke(struct timer_list *t)
638{
639 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
640
641 int ret;
642 unsigned int pipe;
643 struct urb *urb;
644 struct usb_device *usbdev = to_usb_device(sc->hdev->dev.parent->parent);
645 const u16 poke_size =
646 ARRAY_SIZE(ghl_ps3wiiu_magic_data);
647
648 pipe = usb_sndctrlpipe(usbdev, 0);
649
650 if (!sc->ghl_cr) {
651 sc->ghl_cr = kzalloc(sizeof(*sc->ghl_cr), GFP_ATOMIC);
652 if (!sc->ghl_cr)
653 goto resched;
654 }
655
656 if (!sc->ghl_databuf) {
657 sc->ghl_databuf = kzalloc(poke_size, GFP_ATOMIC);
658 if (!sc->ghl_databuf)
659 goto resched;
660 }
661
662 urb = usb_alloc_urb(0, GFP_ATOMIC);
663 if (!urb)
664 goto resched;
665
666 sc->ghl_cr->bRequestType =
667 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
668 sc->ghl_cr->bRequest = USB_REQ_SET_CONFIGURATION;
669 sc->ghl_cr->wValue = cpu_to_le16(ghl_ps3wiiu_magic_value);
670 sc->ghl_cr->wIndex = 0;
671 sc->ghl_cr->wLength = cpu_to_le16(poke_size);
672 memcpy(sc->ghl_databuf, ghl_ps3wiiu_magic_data, poke_size);
673
674 usb_fill_control_urb(
675 urb, usbdev, pipe,
676 (unsigned char *) sc->ghl_cr, sc->ghl_databuf,
677 poke_size, ghl_magic_poke_cb, NULL);
678 ret = usb_submit_urb(urb, GFP_ATOMIC);
679 if (ret < 0) {
680 kfree(sc->ghl_databuf);
681 kfree(sc->ghl_cr);
682 }
683 usb_free_urb(urb);
684
685resched:
686 /* Reschedule for next time */
687 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
688}
689
690static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
691 struct hid_field *field, struct hid_usage *usage,
692 unsigned long **bit, int *max)
693{
694 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
695 unsigned int abs = usage->hid & HID_USAGE;
696
32e411d0 697 if (abs == GUITAR_TILT_USAGE) {
cc894ac5
PG		 698 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
699 return 1;
700 }
701 }
702 return 0;
703}
704
77b499e7
RC		 705static ssize_t ds4_show_poll_interval(struct device *dev,
706 struct device_attribute
707 *attr, char *buf)
c607fb8d 708{
77b499e7
RC		 709 struct hid_device *hdev = to_hid_device(dev);
710 struct sony_sc *sc = hid_get_drvdata(hdev);
711
712 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
c607fb8d
AO		 713}
714
77b499e7
RC		 715static ssize_t ds4_store_poll_interval(struct device *dev,
716 struct device_attribute *attr,
717 const char *buf, size_t count)
c5e0c1c4 718{
77b499e7
RC		 719 struct hid_device *hdev = to_hid_device(dev);
720 struct sony_sc *sc = hid_get_drvdata(hdev);
721 unsigned long flags;
722 u8 interval;
723
724 if (kstrtou8(buf, 0, &interval))
725 return -EINVAL;
726
727 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
728 return -EINVAL;
729
730 spin_lock_irqsave(&sc->lock, flags);
731 sc->ds4_bt_poll_interval = interval;
732 spin_unlock_irqrestore(&sc->lock, flags);
733
734 sony_schedule_work(sc, SONY_WORKER_STATE);
735
736 return count;
c5e0c1c4
FP		 737}
738
77b499e7
RC		 739static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
740 ds4_store_poll_interval);
741
169f15ab
RC		 742static ssize_t sony_show_firmware_version(struct device *dev,
743 struct device_attribute
744 *attr, char *buf)
745{
746 struct hid_device *hdev = to_hid_device(dev);
747 struct sony_sc *sc = hid_get_drvdata(hdev);
748
749 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
750}
751
752static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
753
754static ssize_t sony_show_hardware_version(struct device *dev,
755 struct device_attribute
756 *attr, char *buf)
757{
758 struct hid_device *hdev = to_hid_device(dev);
759 struct sony_sc *sc = hid_get_drvdata(hdev);
760
761 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
762}
763
764static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
77b499e7 765
c5e0c1c4 766static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
b2723eb7
SW		 767 unsigned int *rsize)
768{
c5e0c1c4
FP		 769 *rsize = sizeof(motion_rdesc);
770 return motion_rdesc;
b2723eb7
SW		 771}
772
1adf904e 773static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
078328da
JK		 774 unsigned int *rsize)
775{
776 *rsize = sizeof(ps3remote_rdesc);
777 return ps3remote_rdesc;
778}
779
780static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
781 struct hid_field *field, struct hid_usage *usage,
782 unsigned long **bit, int *max)
783{
784 unsigned int key = usage->hid & HID_USAGE;
785
786 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
787 return -1;
788
789 switch (usage->collection_index) {
790 case 1:
791 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
792 return -1;
793
794 key = ps3remote_keymap_joypad_buttons[key];
795 if (!key)
796 return -1;
797 break;
798 case 2:
799 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
800 return -1;
801
802 key = ps3remote_keymap_remote_buttons[key];
803 if (!key)
804 return -1;
805 break;
806 default:
807 return -1;
808 }
809
810 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
811 return 1;
812}
813
b8f0970d
RC		 814static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
815 struct hid_field *field, struct hid_usage *usage,
816 unsigned long **bit, int *max)
817{
818 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
819 unsigned int key = usage->hid & HID_USAGE;
820
821 if (key >= ARRAY_SIZE(sixaxis_keymap))
822 return -1;
823
824 key = navigation_keymap[key];
825 if (!key)
826 return -1;
827
828 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
829 return 1;
830 } else if (usage->hid == HID_GD_POINTER) {
831 /* See comment in sixaxis_mapping, basically the L2 (and R2)
832 * triggers are reported through GD Pointer.
833 * In addition we ignore any analog button 'axes' and only
834 * support digital buttons.
835 */
836 switch (usage->usage_index) {
837 case 8: /* L2 */
838 usage->hid = HID_GD_Z;
839 break;
840 default:
841 return -1;
842 }
843
844 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
845 return 1;
846 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
847 unsigned int abs = usage->hid & HID_USAGE;
848
849 if (abs >= ARRAY_SIZE(navigation_absmap))
850 return -1;
851
852 abs = navigation_absmap[abs];
853
854 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
855 return 1;
856 }
857
858 return -1;
859}
860
861
e19a267b
RC		 862static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
863 struct hid_field *field, struct hid_usage *usage,
864 unsigned long **bit, int *max)
865{
866 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
867 unsigned int key = usage->hid & HID_USAGE;
868
869 if (key >= ARRAY_SIZE(sixaxis_keymap))
870 return -1;
871
872 key = sixaxis_keymap[key];
873 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
874 return 1;
875 } else if (usage->hid == HID_GD_POINTER) {
876 /* The DS3 provides analog values for most buttons and even
877 * for HAT axes through GD Pointer. L2 and R2 are reported
878 * among these as well instead of as GD Z / RZ. Remap L2
879 * and R2 and ignore other analog 'button axes' as there is
880 * no good way for reporting them.
881 */
882 switch (usage->usage_index) {
883 case 8: /* L2 */
884 usage->hid = HID_GD_Z;
885 break;
886 case 9: /* R2 */
887 usage->hid = HID_GD_RZ;
888 break;
889 default:
890 return -1;
891 }
892
893 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
894 return 1;
895 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
896 unsigned int abs = usage->hid & HID_USAGE;
897
898 if (abs >= ARRAY_SIZE(sixaxis_absmap))
899 return -1;
900
901 abs = sixaxis_absmap[abs];
902
903 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
904 return 1;
905 }
906
907 return -1;
908}
909
9131f8cc
RC		 910static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
911 struct hid_field *field, struct hid_usage *usage,
912 unsigned long **bit, int *max)
913{
914 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
915 unsigned int key = usage->hid & HID_USAGE;
916
917 if (key >= ARRAY_SIZE(ds4_keymap))
918 return -1;
919
920 key = ds4_keymap[key];
921 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
922 return 1;
923 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
924 unsigned int abs = usage->hid & HID_USAGE;
925
926 /* Let the HID parser deal with the HAT. */
927 if (usage->hid == HID_GD_HATSWITCH)
928 return 0;
929
930 if (abs >= ARRAY_SIZE(ds4_absmap))
931 return -1;
932
933 abs = ds4_absmap[abs];
934 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
935 return 1;
936 }
937
938 return 0;
939}
940
1adf904e 941static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
73e4008d 942 unsigned int *rsize)
cc6e0bbb
JK		 943{
944 struct sony_sc *sc = hid_get_drvdata(hdev);
945
4ba1eeeb 946 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
74500cc8
SM		 947 return rdesc;
948
99d24902
FLVC		 949 /*
950 * Some Sony RF receivers wrongly declare the mouse pointer as a
951 * a constant non-data variable.
952 */
953 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
954 /* usage page: generic desktop controls */
955 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
956 /* usage: mouse */
957 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
958 /* input (usage page for x,y axes): constant, variable, relative */
959 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
a4649184 960 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 961 /* input: data, variable, relative */
cc6e0bbb
JK		 962 rdesc[55] = 0x06;
963 }
61ab44be 964
c5e0c1c4
FP		 965 if (sc->quirks & MOTION_CONTROLLER)
966 return motion_fixup(hdev, rdesc, rsize);
967
078328da
JK		 968 if (sc->quirks & PS3REMOTE)
969 return ps3remote_fixup(hdev, rdesc, rsize);
970
e72455b8
SS		 971 /*
972 * Some knock-off USB dongles incorrectly report their button count
973 * as 13 instead of 16 causing three non-functional buttons.
974 */
975 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
976 /* Report Count (13) */
977 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
978 /* Usage Maximum (13) */
979 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
980 /* Report Count (3) */
981 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
982 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
983 rdesc[24] = 0x10;
984 rdesc[38] = 0x10;
985 rdesc[44] = 0x00;
986 }
987
73e4008d 988 return rdesc;
cc6e0bbb
JK		 989}
990
1adf904e 991static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
d902f472 992{
1adf904e 993 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
d902f472 994 unsigned long flags;
12e9a6d7 995 int offset;
a76a6c18
RC		 996 u8 battery_capacity;
997 int battery_status;
d902f472 998
ad142b9e
FP		 999 /*
1000 * The sixaxis is charging if the battery value is 0xee
d902f472
FP		 1001 * and it is fully charged if the value is 0xef.
1002 * It does not report the actual level while charging so it
1003 * is set to 100% while charging is in progress.
1004 */
12e9a6d7
SW		 1005 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1006
1007 if (rd[offset] >= 0xee) {
d902f472 1008 battery_capacity = 100;
a76a6c18 1009 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
d902f472 1010 } else {
1adf904e 1011 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
ac3c9a94 1012 battery_capacity = sixaxis_battery_capacity[index];
a76a6c18 1013 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
d902f472 1014 }
d902f472
FP		 1015
1016 spin_lock_irqsave(&sc->lock, flags);
d902f472 1017 sc->battery_capacity = battery_capacity;
a76a6c18 1018 sc->battery_status = battery_status;
d902f472 1019 spin_unlock_irqrestore(&sc->lock, flags);
510c8b7c
RC		 1020
1021 if (sc->quirks & SIXAXIS_CONTROLLER) {
1022 int val;
1023
1024 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
1025 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
1026 input_report_abs(sc->sensor_dev, ABS_X, val);
1027
1028 /* Y and Z are swapped and inversed */
1029 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
1030 input_report_abs(sc->sensor_dev, ABS_Y, val);
1031
1032 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
1033 input_report_abs(sc->sensor_dev, ABS_Z, val);
1034
1035 input_sync(sc->sensor_dev);
1036 }
d902f472
FP		 1037}
1038
1adf904e 1039static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
d902f472 1040{
d03ae2e1
RC		 1041 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1042 struct hid_input, list);
1043 struct input_dev *input_dev = hidinput->input;
d902f472 1044 unsigned long flags;
cdc1c021 1045 int n, m, offset, num_touch_data, max_touch_data;
a76a6c18
RC		 1046 u8 cable_state, battery_capacity;
1047 int battery_status;
80786eb9 1048 u16 timestamp;
d902f472 1049
cdc1c021 1050 /* When using Bluetooth the header is 2 bytes longer, so skip these. */
35f436c3 1051 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
6c5f860d 1052
ac797b95
RC		 1053 /* Second bit of third button byte is for the touchpad button. */
1054 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
1055 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1056
d03ae2e1
RC		 1057 /*
1058 * The default behavior of the Dualshock 4 is to send reports using
1059 * report type 1 when running over Bluetooth. However, when feature
1060 * report 2 is requested during the controller initialization it starts
1061 * sending input reports in report 17. Since report 17 is undefined
1062 * in the default HID descriptor, the HID layer won't generate events.
1063 * While it is possible (and this was done before) to fixup the HID
1064 * descriptor to add this mapping, it was better to do this manually.
1065 * The reason is there were various pieces software both open and closed
1066 * source, relying on the descriptors to be the same across various
1067 * operating systems. If the descriptors wouldn't match some
1068 * applications e.g. games on Wine would not be able to function due
1069 * to different descriptors, which such applications are not parsing.
1070 */
1071 if (rd[0] == 17) {
1072 int value;
1073
1074 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
1075 input_report_abs(input_dev, ABS_X, rd[offset]);
1076 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
1077 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
1078 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
1079
1080 value = rd[offset+4] & 0xf;
1081 if (value > 7)
1082 value = 8; /* Center 0, 0 */
1083 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
1084 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
1085
1086 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
1087 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
1088 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
1089 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
1090
1091 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
1092 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
1093 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
1094 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
1095 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
1096 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
1097 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
1098 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
1099
1100 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
1101
1102 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
1103 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
1104
1105 input_sync(input_dev);
1106 }
1107
80786eb9
RC		 1108 /* Convert timestamp (in 5.33us unit) to timestamp_us */
1109 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
1110 timestamp = get_unaligned_le16(&rd[offset]);
1111 if (!sc->timestamp_initialized) {
1112 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1113 sc->timestamp_initialized = true;
1114 } else {
1115 u16 delta;
1116
1117 if (sc->prev_timestamp > timestamp)
1118 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1119 else
1120 delta = timestamp - sc->prev_timestamp;
1121 sc->timestamp_us += (delta * 16) / 3;
1122 }
1123 sc->prev_timestamp = timestamp;
1124 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1125
227c011b 1126 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
55a07d62
RC		 1127 for (n = 0; n < 6; n++) {
1128 /* Store data in int for more precision during mult_frac. */
1129 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1130 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1131
1132 /* High precision is needed during calibration, but the
1133 * calibrated values are within 32-bit.
1134 * Note: we swap numerator 'x' and 'numer' in mult_frac for
1135 * precision reasons so we don't need 64-bit.
1136 */
1137 int calib_data = mult_frac(calib->sens_numer,
1138 raw_data - calib->bias,
1139 calib->sens_denom);
227c011b 1140
55a07d62
RC		 1141 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1142 offset += 2;
227c011b
RC		 1143 }
1144 input_sync(sc->sensor_dev);
1145
ad142b9e 1146 /*
cdc1c021 1147 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
d902f472
FP		 1148 * and the 5th bit contains the USB cable state.
1149 */
cdc1c021 1150 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
6c5f860d 1151 cable_state = (rd[offset] >> 4) & 0x01;
d902f472 1152
ad142b9e 1153 /*
a76a6c18
RC		 1154 * Interpretation of the battery_capacity data depends on the cable state.
1155 * When no cable is connected (bit4 is 0):
1156 * - 0:10: percentage in units of 10%.
1157 * When a cable is plugged in:
1158 * - 0-10: percentage in units of 10%.
1159 * - 11: battery is full
1160 * - 14: not charging due to Voltage or temperature error
1161 * - 15: charge error
d902f472 1162 */
a76a6c18
RC		 1163 if (cable_state) {
1164 u8 battery_data = rd[offset] & 0xf;
1165
1166 if (battery_data < 10) {
1167 /* Take the mid-point for each battery capacity value,
1168 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
1169 * This matches official platform behavior, which does
1170 * the same.
1171 */
1172 battery_capacity = battery_data * 10 + 5;
1173 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1174 } else if (battery_data == 10) {
1175 battery_capacity = 100;
1176 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1177 } else if (battery_data == 11) {
1178 battery_capacity = 100;
1179 battery_status = POWER_SUPPLY_STATUS_FULL;
1180 } else { /* 14, 15 and undefined values */
1181 battery_capacity = 0;
1182 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1183 }
1184 } else {
1185 u8 battery_data = rd[offset] & 0xf;
d902f472 1186
a76a6c18
RC		 1187 if (battery_data < 10)
1188 battery_capacity = battery_data * 10 + 5;
1189 else /* 10 */
1190 battery_capacity = 100;
6c5f860d 1191
a76a6c18
RC		 1192 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1193 }
d902f472
FP		 1194
1195 spin_lock_irqsave(&sc->lock, flags);
d902f472 1196 sc->battery_capacity = battery_capacity;
a76a6c18 1197 sc->battery_status = battery_status;
d902f472 1198 spin_unlock_irqrestore(&sc->lock, flags);
e5606230 1199
ad142b9e 1200 /*
cdc1c021
RC		 1201 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1202 * and 35 on Bluetooth.
1203 * The first byte indicates the number of touch data in the report.
1204 * Trackpad data starts 2 bytes later (e.g. 35 for USB).
e5606230 1205 */
cdc1c021 1206 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
35f436c3 1207 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
cdc1c021
RC		 1208 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1209 num_touch_data = rd[offset];
1210 else
1211 num_touch_data = 1;
1212 offset += 1;
e5606230 1213
cdc1c021
RC		 1214 for (m = 0; m < num_touch_data; m++) {
1215 /* Skip past timestamp */
1216 offset += 1;
e5606230 1217
cdc1c021
RC		 1218 /*
1219 * The first 7 bits of the first byte is a counter and bit 8 is
1220 * a touch indicator that is 0 when pressed and 1 when not
1221 * pressed.
1222 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1223 * The data for the second touch is in the same format and
1224 * immediately follows the data for the first.
1225 */
1226 for (n = 0; n < 2; n++) {
1227 u16 x, y;
1228 bool active;
1229
1230 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1231 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1232
1233 active = !(rd[offset] >> 7);
ac797b95
RC		 1234 input_mt_slot(sc->touchpad, n);
1235 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
cdc1c021
RC		 1236
1237 if (active) {
ac797b95
RC		 1238 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1239 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
cdc1c021
RC		 1240 }
1241
1242 offset += 4;
1243 }
ac797b95
RC		 1244 input_mt_sync_frame(sc->touchpad);
1245 input_sync(sc->touchpad);
e5606230 1246 }
d902f472
FP		 1247}
1248
b7289cb1
TK		 1249static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1250{
1251 int n, offset, relx, rely;
1252 u8 active;
1253
1254 /*
1255 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
1256 * the touch-related data starts at offset 2.
1257 * For the first byte, bit 0 is set when touchpad button is pressed.
1258 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
1259 * This drag key is mapped to BTN_LEFT. It is operational only when a
1260 * touch point is active.
1261 * Bit 4 is set when only the first touch point is active.
1262 * Bit 6 is set when only the second touch point is active.
1263 * Bits 5 and 7 are set when both touch points are active.
1264 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
1265 * The following byte, offset 5, has the touch width and length.
1266 * Bits 0-4=X (width), bits 5-7=Y (length).
1267 * A signed relative X coordinate is at offset 6.
1268 * The bytes at offset 7-9 are the second touch X/Y coordinates.
1269 * Offset 10 has the second touch width and length.
1270 * Offset 11 has the relative Y coordinate.
1271 */
1272 offset = 1;
1273
1274 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1275 active = (rd[offset] >> 4);
1276 relx = (s8) rd[offset+5];
1277 rely = ((s8) rd[offset+10]) * -1;
1278
1279 offset++;
1280
1281 for (n = 0; n < 2; n++) {
1282 u16 x, y;
1283 u8 contactx, contacty;
1284
1285 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1286 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1287
1288 input_mt_slot(sc->touchpad, n);
1289 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1290
1291 if (active & 0x03) {
1292 contactx = rd[offset+3] & 0x0F;
1293 contacty = rd[offset+3] >> 4;
1294 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1295 max(contactx, contacty));
1296 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1297 min(contactx, contacty));
1298 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1299 (bool) (contactx > contacty));
1300 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1301 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1302 NSG_MRXU_MAX_Y - y);
1303 /*
1304 * The relative coordinates belong to the first touch
1305 * point, when present, or to the second touch point
1306 * when the first is not active.
1307 */
1308 if ((n == 0) || ((n == 1) && (active & 0x01))) {
1309 input_report_rel(sc->touchpad, REL_X, relx);
1310 input_report_rel(sc->touchpad, REL_Y, rely);
1311 }
1312 }
1313
1314 offset += 5;
1315 active >>= 2;
1316 }
1317
1318 input_mt_sync_frame(sc->touchpad);
1319
1320 input_sync(sc->touchpad);
1321}
1322
c9e4d877 1323static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1adf904e 1324 u8 *rd, int size)
c9e4d877
SW		 1325{
1326 struct sony_sc *sc = hid_get_drvdata(hdev);
1327
ad142b9e
FP		 1328 /*
1329 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
c9e4d877
SW		 1330 * has to be BYTE_SWAPPED before passing up to joystick interface
1331 */
fee4e2d5 1332 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
8f5f0bc2
FP		 1333 /*
1334 * When connected via Bluetooth the Sixaxis occasionally sends
1335 * a report with the second byte 0xff and the rest zeroed.
1336 *
1337 * This report does not reflect the actual state of the
1338 * controller must be ignored to avoid generating false input
1339 * events.
1340 */
1341 if (rd[1] == 0xff)
1342 return -EINVAL;
1343
c9e4d877
SW		 1344 swap(rd[41], rd[42]);
1345 swap(rd[43], rd[44]);
1346 swap(rd[45], rd[46]);
1347 swap(rd[47], rd[48]);
d902f472 1348
12e9a6d7
SW		 1349 sixaxis_parse_report(sc, rd, size);
1350 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
d902f472 1351 sixaxis_parse_report(sc, rd, size);
4545ee0a
SW		 1352 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1353 size == 49) {
1354 sixaxis_parse_report(sc, rd, size);
35f436c3
RC		 1355 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1356 size == 64) {
1357 dualshock4_parse_report(sc, rd, size);
1358 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1359 size == 78)) {
1360 /* CRC check */
1361 u8 bthdr = 0xA1;
1362 u32 crc;
1363 u32 report_crc;
49b9ca6c 1364
35f436c3
RC		 1365 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1366 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1367 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1368 if (crc != report_crc) {
1369 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1370 report_crc, crc);
1371 return -EILSEQ;
49b9ca6c 1372 }
405182c2 1373
35f436c3
RC		 1374 dualshock4_parse_report(sc, rd, size);
1375 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1376 size == 64) {
f2f47c38
RC		 1377 unsigned long flags;
1378 enum ds4_dongle_state dongle_state;
1379
405182c2
RC		 1380 /*
1381 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1382 * if a DS4 is actually connected (indicated by '0').
1383 * For non-dongle, this bit is always 0 (connected).
1384 */
35f436c3
RC		 1385 bool connected = (rd[31] & 0x04) ? false : true;
1386
f2f47c38
RC		 1387 spin_lock_irqsave(&sc->lock, flags);
1388 dongle_state = sc->ds4_dongle_state;
1389 spin_unlock_irqrestore(&sc->lock, flags);
1390
1391 /*
1392 * The dongle always sends input reports even when no
1393 * DS4 is attached. When a DS4 is connected, we need to
1394 * obtain calibration data before we can use it.
1395 * The code below tracks dongle state and kicks of
1396 * calibration when needed and only allows us to process
1397 * input if a DS4 is actually connected.
1398 */
1399 if (dongle_state == DONGLE_DISCONNECTED && connected) {
35f436c3
RC		 1400 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1401 sony_set_leds(sc);
f2f47c38
RC		 1402
1403 spin_lock_irqsave(&sc->lock, flags);
1404 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1405 spin_unlock_irqrestore(&sc->lock, flags);
1406
1407 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1408
1409 /* Don't process the report since we don't have
1410 * calibration data, but let hidraw have it anyway.
1411 */
1412 return 0;
1413 } else if ((dongle_state == DONGLE_CONNECTED ||
1414 dongle_state == DONGLE_DISABLED) && !connected) {
35f436c3 1415 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
f2f47c38
RC		 1416
1417 spin_lock_irqsave(&sc->lock, flags);
1418 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1419 spin_unlock_irqrestore(&sc->lock, flags);
1420
35f436c3
RC		 1421 /* Return 0, so hidraw can get the report. */
1422 return 0;
f2f47c38
RC		 1423 } else if (dongle_state == DONGLE_CALIBRATING ||
1424 dongle_state == DONGLE_DISABLED ||
1425 dongle_state == DONGLE_DISCONNECTED) {
35f436c3
RC		 1426 /* Return 0, so hidraw can get the report. */
1427 return 0;
405182c2
RC		 1428 }
1429
d902f472 1430 dualshock4_parse_report(sc, rd, size);
b7289cb1
TK		 1431
1432 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1433 nsg_mrxu_parse_report(sc, rd, size);
1434 return 1;
c9e4d877
SW		 1435 }
1436
2a242932
FP		 1437 if (sc->defer_initialization) {
1438 sc->defer_initialization = 0;
b5322736 1439 sony_schedule_work(sc, SONY_WORKER_STATE);
2a242932
FP		 1440 }
1441
c9e4d877
SW		 1442 return 0;
1443}
1444
f04d5140
CL		 1445static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1446 struct hid_field *field, struct hid_usage *usage,
1447 unsigned long **bit, int *max)
1448{
1449 struct sony_sc *sc = hid_get_drvdata(hdev);
1450
1451 if (sc->quirks & BUZZ_CONTROLLER) {
1452 unsigned int key = usage->hid & HID_USAGE;
1453
1454 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1455 return -1;
1456
1457 switch (usage->collection_index) {
1458 case 1:
1459 if (key >= ARRAY_SIZE(buzz_keymap))
1460 return -1;
1461
1462 key = buzz_keymap[key];
1463 if (!key)
1464 return -1;
1465 break;
1466 default:
1467 return -1;
1468 }
1469
1470 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1471 return 1;
1472 }
1473
078328da
JK		 1474 if (sc->quirks & PS3REMOTE)
1475 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1476
b8f0970d
RC		 1477 if (sc->quirks & NAVIGATION_CONTROLLER)
1478 return navigation_mapping(hdev, hi, field, usage, bit, max);
1479
e19a267b
RC		 1480 if (sc->quirks & SIXAXIS_CONTROLLER)
1481 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
9131f8cc
RC		 1482
1483 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1484 return ds4_mapping(hdev, hi, field, usage, bit, max);
1485
32e411d0 1486 if (sc->quirks & GH_GUITAR_CONTROLLER)
cc894ac5 1487 return guitar_mapping(hdev, hi, field, usage, bit, max);
e19a267b 1488
6f498018
BT		 1489 /* Let hid-core decide for the others */
1490 return 0;
f04d5140
CL		 1491}
1492
ac797b95 1493static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
b7289cb1 1494 int w, int h, int touch_major, int touch_minor, int orientation)
ce8efc3b 1495{
ac797b95
RC		 1496 size_t name_sz;
1497 char *name;
ce8efc3b
FP		 1498 int ret;
1499
cc070a84 1500 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
ac797b95
RC		 1501 if (!sc->touchpad)
1502 return -ENOMEM;
1503
1504 input_set_drvdata(sc->touchpad, sc);
1505 sc->touchpad->dev.parent = &sc->hdev->dev;
1506 sc->touchpad->phys = sc->hdev->phys;
1507 sc->touchpad->uniq = sc->hdev->uniq;
1508 sc->touchpad->id.bustype = sc->hdev->bus;
1509 sc->touchpad->id.vendor = sc->hdev->vendor;
1510 sc->touchpad->id.product = sc->hdev->product;
1511 sc->touchpad->id.version = sc->hdev->version;
1512
1513 /* Append a suffix to the controller name as there are various
1514 * DS4 compatible non-Sony devices with different names.
1515 */
1516 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
cc070a84
HZ		 1517 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1518 if (!name)
1519 return -ENOMEM;
ac797b95
RC		 1520 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1521 sc->touchpad->name = name;
1522
ac797b95
RC		 1523 /* We map the button underneath the touchpad to BTN_LEFT. */
1524 __set_bit(EV_KEY, sc->touchpad->evbit);
1525 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1526 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
ce8efc3b 1527
ac797b95
RC		 1528 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1529 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1530
b7289cb1
TK		 1531 if (touch_major > 0) {
1532 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1533 0, touch_major, 0, 0);
1534 if (touch_minor > 0)
1535 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1536 0, touch_minor, 0, 0);
1537 if (orientation > 0)
1538 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1539 0, orientation, 0, 0);
1540 }
1541
1542 if (sc->quirks & NSG_MRXU_REMOTE) {
1543 __set_bit(EV_REL, sc->touchpad->evbit);
1544 }
1545
1546 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1547 if (ret < 0)
cc070a84 1548 return ret;
b7289cb1 1549
ac797b95
RC		 1550 ret = input_register_device(sc->touchpad);
1551 if (ret < 0)
cc070a84 1552 return ret;
ce8efc3b
FP		 1553
1554 return 0;
ac797b95 1555}
ce8efc3b 1556
227c011b
RC		 1557static int sony_register_sensors(struct sony_sc *sc)
1558{
1559 size_t name_sz;
1560 char *name;
1561 int ret;
55a07d62 1562 int range;
227c011b 1563
ea4a5fdc 1564 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
227c011b
RC		 1565 if (!sc->sensor_dev)
1566 return -ENOMEM;
1567
1568 input_set_drvdata(sc->sensor_dev, sc);
1569 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1570 sc->sensor_dev->phys = sc->hdev->phys;
1571 sc->sensor_dev->uniq = sc->hdev->uniq;
1572 sc->sensor_dev->id.bustype = sc->hdev->bus;
1573 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1574 sc->sensor_dev->id.product = sc->hdev->product;
1575 sc->sensor_dev->id.version = sc->hdev->version;
1576
1577 /* Append a suffix to the controller name as there are various
1578 * DS4 compatible non-Sony devices with different names.
1579 */
510c8b7c 1580 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
ea4a5fdc
HZ		 1581 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1582 if (!name)
1583 return -ENOMEM;
510c8b7c 1584 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
227c011b
RC		 1585 sc->sensor_dev->name = name;
1586
510c8b7c
RC		 1587 if (sc->quirks & SIXAXIS_CONTROLLER) {
1588 /* For the DS3 we only support the accelerometer, which works
1589 * quite well even without calibration. The device also has
1590 * a 1-axis gyro, but it is very difficult to manage from within
1591 * the driver even to get data, the sensor is inaccurate and
1592 * the behavior is very different between hardware revisions.
1593 */
1594 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1595 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1596 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1597 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1598 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1599 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1600 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1601 range = DS4_ACC_RES_PER_G*4;
1602 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1603 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1604 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1605 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1606 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1607 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1608
1609 range = DS4_GYRO_RES_PER_DEG_S*2048;
1610 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1611 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1612 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1613 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1614 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1615 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1616
1617 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1618 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1619 }
1620
227c011b
RC		 1621 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1622
1623 ret = input_register_device(sc->sensor_dev);
1624 if (ret < 0)
ea4a5fdc 1625 return ret;
227c011b
RC		 1626
1627 return 0;
227c011b
RC		 1628}
1629
bd28ce00
JS		 1630/*
1631 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1632 * to "operational". Without this, the ps3 controller will not report any
1633 * events.
1634 */
816651a7 1635static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 1636{
69481059 1637 struct sony_sc *sc = hid_get_drvdata(hdev);
a85d67b5
AO		 1638 const int buf_size =
1639 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1adf904e 1640 u8 *buf;
bd28ce00 1641 int ret;
bd28ce00 1642
2e701a35 1643 buf = kmalloc(buf_size, GFP_KERNEL);
bd28ce00
JS		 1644 if (!buf)
1645 return -ENOMEM;
1646
a85d67b5
AO		 1647 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1648 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1649 if (ret < 0) {
1650 hid_err(hdev, "can't set operational mode: step 1\n");
1651 goto out;
1652 }
f204828a 1653
a7de9b86
LK		 1654 /*
1655 * Some compatible controllers like the Speedlink Strike FX and
1656 * Gasia need another query plus an USB interrupt to get operational.
1657 */
a85d67b5
AO		 1658 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1659 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1660 if (ret < 0) {
1661 hid_err(hdev, "can't set operational mode: step 2\n");
1662 goto out;
1663 }
f204828a 1664
492ca83c
BN		 1665 /*
1666 * But the USB interrupt would cause SHANWAN controllers to
69481059 1667 * start rumbling non-stop, so skip step 3 for these controllers.
492ca83c 1668 */
69481059
HY		 1669 if (sc->quirks & SHANWAN_GAMEPAD)
1670 goto out;
1671
1672 ret = hid_hw_output_report(hdev, buf, 1);
1673 if (ret < 0) {
1674 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1675 ret = 0;
19f4c2ba 1676 }
bd28ce00 1677
a7de9b86 1678out:
bd28ce00
JS		 1679 kfree(buf);
1680
1681 return ret;
1682}
1683
816651a7 1684static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 1685{
1adf904e
PM		 1686 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1687 u8 *buf;
9b2b5c9a
FP		 1688 int ret;
1689
1690 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1691 if (!buf)
1692 return -ENOMEM;
1693
1694 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
b0dd72aa 1695 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
9b2b5c9a
FP		 1696
1697 kfree(buf);
1698
1699 return ret;
f9ce7c28
BN		 1700}
1701
ad142b9e 1702/*
55a07d62
RC		 1703 * Request DS4 calibration data for the motion sensors.
1704 * For Bluetooth this also affects the operating mode (see below).
68330d83 1705 */
55a07d62 1706static int dualshock4_get_calibration_data(struct sony_sc *sc)
68330d83 1707{
1adf904e 1708 u8 *buf;
9b2b5c9a 1709 int ret;
55a07d62
RC		 1710 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1711 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1712 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1713 short gyro_speed_plus, gyro_speed_minus;
1714 short acc_x_plus, acc_x_minus;
1715 short acc_y_plus, acc_y_minus;
1716 short acc_z_plus, acc_z_minus;
1717 int speed_2x;
1718 int range_2g;
1719
1720 /* For Bluetooth we use a different request, which supports CRC.
1721 * Note: in Bluetooth mode feature report 0x02 also changes the state
1722 * of the controller, so that it sends input reports of type 0x11.
1723 */
35f436c3 1724 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
f5dc93b7
RC		 1725 int retries;
1726
55a07d62
RC		 1727 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1728 if (!buf)
1729 return -ENOMEM;
68330d83 1730
f5dc93b7
RC		 1731 /* We should normally receive the feature report data we asked
1732 * for, but hidraw applications such as Steam can issue feature
1733 * reports as well. In particular for Dongle reconnects, Steam
1734 * and this function are competing resulting in often receiving
1735 * data for a different HID report, so retry a few times.
1736 */
1737 for (retries = 0; retries < 3; retries++) {
1738 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1739 DS4_FEATURE_REPORT_0x02_SIZE,
1740 HID_FEATURE_REPORT,
1741 HID_REQ_GET_REPORT);
1742 if (ret < 0)
1743 goto err_stop;
1744
1745 if (buf[0] != 0x02) {
1746 if (retries < 2) {
1747 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1748 continue;
1749 } else {
1750 ret = -EILSEQ;
1751 goto err_stop;
1752 }
1753 } else {
1754 break;
1755 }
1756 }
55a07d62
RC		 1757 } else {
1758 u8 bthdr = 0xA3;
1759 u32 crc;
1760 u32 report_crc;
1761 int retries;
9b2b5c9a 1762
55a07d62
RC		 1763 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1764 if (!buf)
1765 return -ENOMEM;
9b2b5c9a 1766
55a07d62
RC		 1767 for (retries = 0; retries < 3; retries++) {
1768 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1769 DS4_FEATURE_REPORT_0x05_SIZE,
1770 HID_FEATURE_REPORT,
1771 HID_REQ_GET_REPORT);
1772 if (ret < 0)
1773 goto err_stop;
9b2b5c9a 1774
55a07d62
RC		 1775 /* CRC check */
1776 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1777 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1778 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1779 if (crc != report_crc) {
1780 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1781 report_crc, crc);
1782 if (retries < 2) {
1783 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1784 continue;
1785 } else {
1786 ret = -EILSEQ;
1787 goto err_stop;
1788 }
1789 } else {
1790 break;
1791 }
1792 }
1793 }
9b2b5c9a 1794
55a07d62
RC		 1795 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1796 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1797 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1798 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1799 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1800 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1801 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1802 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1803 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1804 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1805 } else {
35f436c3 1806 /* BT + Dongle */
55a07d62
RC		 1807 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1808 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1809 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1810 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1811 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1812 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1813 }
1814 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1815 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1816 acc_x_plus = get_unaligned_le16(&buf[23]);
1817 acc_x_minus = get_unaligned_le16(&buf[25]);
1818 acc_y_plus = get_unaligned_le16(&buf[27]);
1819 acc_y_minus = get_unaligned_le16(&buf[29]);
1820 acc_z_plus = get_unaligned_le16(&buf[31]);
1821 acc_z_minus = get_unaligned_le16(&buf[33]);
1822
1823 /* Set gyroscope calibration and normalization parameters.
1824 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1825 */
1826 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1827 sc->ds4_calib_data[0].abs_code = ABS_RX;
1828 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1829 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1830 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1831
1832 sc->ds4_calib_data[1].abs_code = ABS_RY;
1833 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1834 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1835 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1836
1837 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1838 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1839 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1840 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1841
1842 /* Set accelerometer calibration and normalization parameters.
1843 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1844 */
1845 range_2g = acc_x_plus - acc_x_minus;
1846 sc->ds4_calib_data[3].abs_code = ABS_X;
1847 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1848 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1849 sc->ds4_calib_data[3].sens_denom = range_2g;
1850
1851 range_2g = acc_y_plus - acc_y_minus;
1852 sc->ds4_calib_data[4].abs_code = ABS_Y;
1853 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1854 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1855 sc->ds4_calib_data[4].sens_denom = range_2g;
1856
1857 range_2g = acc_z_plus - acc_z_minus;
1858 sc->ds4_calib_data[5].abs_code = ABS_Z;
1859 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1860 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1861 sc->ds4_calib_data[5].sens_denom = range_2g;
1862
1863err_stop:
1864 kfree(buf);
9b2b5c9a 1865 return ret;
f9ce7c28
BN		 1866}
1867
f2f47c38
RC		 1868static void dualshock4_calibration_work(struct work_struct *work)
1869{
1870 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1871 unsigned long flags;
1872 enum ds4_dongle_state dongle_state;
1873 int ret;
1874
1875 ret = dualshock4_get_calibration_data(sc);
1876 if (ret < 0) {
1877 /* This call is very unlikely to fail for the dongle. When it
1878 * fails we are probably in a very bad state, so mark the
1879 * dongle as disabled. We will re-enable the dongle if a new
1880 * DS4 hotplug is detect from sony_raw_event as any issues
1881 * are likely resolved then (the dongle is quite stupid).
1882 */
1883 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1884 dongle_state = DONGLE_DISABLED;
1885 } else {
1886 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1887 dongle_state = DONGLE_CONNECTED;
1888 }
1889
1890 spin_lock_irqsave(&sc->lock, flags);
1891 sc->ds4_dongle_state = dongle_state;
1892 spin_unlock_irqrestore(&sc->lock, flags);
1893}
1894
169f15ab
RC		 1895static int dualshock4_get_version_info(struct sony_sc *sc)
1896{
1897 u8 *buf;
1898 int ret;
1899
1900 buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1901 if (!buf)
1902 return -ENOMEM;
1903
1904 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1905 DS4_FEATURE_REPORT_0xA3_SIZE,
1906 HID_FEATURE_REPORT,
1907 HID_REQ_GET_REPORT);
1908 if (ret < 0) {
1909 kfree(buf);
1910 return ret;
1911 }
1912
1913 sc->hw_version = get_unaligned_le16(&buf[35]);
1914 sc->fw_version = get_unaligned_le16(&buf[41]);
1915
1916 kfree(buf);
1917 return 0;
1918}
1919
221399b3 1920static void sixaxis_set_leds_from_id(struct sony_sc *sc)
8025087a 1921{
1adf904e 1922 static const u8 sixaxis_leds[10][4] = {
8025087a
FP		 1923 { 0x01, 0x00, 0x00, 0x00 },
1924 { 0x00, 0x01, 0x00, 0x00 },
1925 { 0x00, 0x00, 0x01, 0x00 },
1926 { 0x00, 0x00, 0x00, 0x01 },
1927 { 0x01, 0x00, 0x00, 0x01 },
1928 { 0x00, 0x01, 0x00, 0x01 },
1929 { 0x00, 0x00, 0x01, 0x01 },
1930 { 0x01, 0x00, 0x01, 0x01 },
1931 { 0x00, 0x01, 0x01, 0x01 },
1932 { 0x01, 0x01, 0x01, 0x01 }
1933 };
1934
221399b3
FP		 1935 int id = sc->device_id;
1936
1937 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
8025087a
FP		 1938
1939 if (id < 0)
1940 return;
1941
1942 id %= 10;
221399b3 1943 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
8025087a
FP		 1944}
1945
221399b3 1946static void dualshock4_set_leds_from_id(struct sony_sc *sc)
8025087a
FP		 1947{
1948 /* The first 4 color/index entries match what the PS4 assigns */
1adf904e 1949 static const u8 color_code[7][3] = {
39254a13
RC		 1950 /* Blue */ { 0x00, 0x00, 0x40 },
1951 /* Red */ { 0x40, 0x00, 0x00 },
1952 /* Green */ { 0x00, 0x40, 0x00 },
1953 /* Pink */ { 0x20, 0x00, 0x20 },
8025087a
FP		 1954 /* Orange */ { 0x02, 0x01, 0x00 },
1955 /* Teal */ { 0x00, 0x01, 0x01 },
1956 /* White */ { 0x01, 0x01, 0x01 }
1957 };
1958
221399b3
FP		 1959 int id = sc->device_id;
1960
1961 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
8025087a
FP		 1962
1963 if (id < 0)
1964 return;
1965
1966 id %= 7;
221399b3 1967 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
8025087a
FP		 1968}
1969
221399b3 1970static void buzz_set_leds(struct sony_sc *sc)
f04d5140 1971{
221399b3 1972 struct hid_device *hdev = sc->hdev;
f04d5140
CL		 1973 struct list_head *report_list =
1974 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1975 struct hid_report *report = list_entry(report_list->next,
1976 struct hid_report, list);
1adf904e 1977 s32 *value = report->field[0]->value;
f04d5140 1978
221399b3
FP		 1979 BUILD_BUG_ON(MAX_LEDS < 4);
1980
f04d5140 1981 value[0] = 0x00;
221399b3
FP		 1982 value[1] = sc->led_state[0] ? 0xff : 0x00;
1983 value[2] = sc->led_state[1] ? 0xff : 0x00;
1984 value[3] = sc->led_state[2] ? 0xff : 0x00;
1985 value[4] = sc->led_state[3] ? 0xff : 0x00;
f04d5140
CL		 1986 value[5] = 0x00;
1987 value[6] = 0x00;
1988 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1989}
1990
221399b3 1991static void sony_set_leds(struct sony_sc *sc)
0a286ef2 1992{
221399b3 1993 if (!(sc->quirks & BUZZ_CONTROLLER))
b5322736 1994 sony_schedule_work(sc, SONY_WORKER_STATE);
221399b3
FP		 1995 else
1996 buzz_set_leds(sc);
0a286ef2
SE		 1997}
1998
c5382519 1999static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 2000 enum led_brightness value)
2001{
2002 struct device *dev = led->dev->parent;
ee79a8f8 2003 struct hid_device *hdev = to_hid_device(dev);
f04d5140 2004 struct sony_sc *drv_data;
f04d5140
CL		 2005
2006 int n;
b3ed458c 2007 int force_update;
f04d5140
CL		 2008
2009 drv_data = hid_get_drvdata(hdev);
2251b85f 2010 if (!drv_data) {
f04d5140
CL		 2011 hid_err(hdev, "No device data\n");
2012 return;
2013 }
f04d5140 2014
b3ed458c
FP		 2015 /*
2016 * The Sixaxis on USB will override any LED settings sent to it
2017 * and keep flashing all of the LEDs until the PS button is pressed.
2018 * Updates, even if redundant, must be always be sent to the
2019 * controller to avoid having to toggle the state of an LED just to
2020 * stop the flashing later on.
2021 */
2022 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
2023
60781cf4 2024 for (n = 0; n < drv_data->led_count; n++) {
b3ed458c
FP		 2025 if (led == drv_data->leds[n] && (force_update ||
2026 (value != drv_data->led_state[n] ||
2027 drv_data->led_delay_on[n] ||
2028 drv_data->led_delay_off[n]))) {
2029
2030 drv_data->led_state[n] = value;
2031
2032 /* Setting the brightness stops the blinking */
2033 drv_data->led_delay_on[n] = 0;
2034 drv_data->led_delay_off[n] = 0;
2035
221399b3 2036 sony_set_leds(drv_data);
f04d5140
CL		 2037 break;
2038 }
2039 }
2040}
2041
c5382519 2042static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 2043{
2044 struct device *dev = led->dev->parent;
ee79a8f8 2045 struct hid_device *hdev = to_hid_device(dev);
f04d5140 2046 struct sony_sc *drv_data;
f04d5140
CL		 2047
2048 int n;
f04d5140
CL		 2049
2050 drv_data = hid_get_drvdata(hdev);
2251b85f 2051 if (!drv_data) {
f04d5140
CL		 2052 hid_err(hdev, "No device data\n");
2053 return LED_OFF;
2054 }
f04d5140 2055
60781cf4 2056 for (n = 0; n < drv_data->led_count; n++) {
7db7504a
SW		 2057 if (led == drv_data->leds[n])
2058 return drv_data->led_state[n];
f04d5140
CL		 2059 }
2060
7db7504a 2061 return LED_OFF;
f04d5140 2062}
f04d5140 2063
b3ed458c
FP		 2064static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
2065 unsigned long *delay_off)
2066{
2067 struct device *dev = led->dev->parent;
ee79a8f8 2068 struct hid_device *hdev = to_hid_device(dev);
b3ed458c
FP		 2069 struct sony_sc *drv_data = hid_get_drvdata(hdev);
2070 int n;
1adf904e 2071 u8 new_on, new_off;
b3ed458c
FP		 2072
2073 if (!drv_data) {
2074 hid_err(hdev, "No device data\n");
2075 return -EINVAL;
2076 }
2077
2078 /* Max delay is 255 deciseconds or 2550 milliseconds */
2079 if (*delay_on > 2550)
2080 *delay_on = 2550;
2081 if (*delay_off > 2550)
2082 *delay_off = 2550;
2083
2084 /* Blink at 1 Hz if both values are zero */
2085 if (!*delay_on && !*delay_off)
2086 *delay_on = *delay_off = 500;
2087
2088 new_on = *delay_on / 10;
2089 new_off = *delay_off / 10;
2090
2091 for (n = 0; n < drv_data->led_count; n++) {
2092 if (led == drv_data->leds[n])
2093 break;
2094 }
2095
2096 /* This LED is not registered on this device */
2097 if (n >= drv_data->led_count)
2098 return -EINVAL;
2099
2100 /* Don't schedule work if the values didn't change */
2101 if (new_on != drv_data->led_delay_on[n] ||
2102 new_off != drv_data->led_delay_off[n]) {
2103 drv_data->led_delay_on[n] = new_on;
2104 drv_data->led_delay_off[n] = new_off;
b5322736 2105 sony_schedule_work(drv_data, SONY_WORKER_STATE);
b3ed458c
FP		 2106 }
2107
2108 return 0;
2109}
2110
fa57a810 2111static int sony_leds_init(struct sony_sc *sc)
f04d5140 2112{
fa57a810 2113 struct hid_device *hdev = sc->hdev;
40e32ee6 2114 int n, ret = 0;
b3ed458c 2115 int use_ds4_names;
40e32ee6
JK		 2116 struct led_classdev *led;
2117 size_t name_sz;
2118 char *name;
0a286ef2
SE		 2119 size_t name_len;
2120 const char *name_fmt;
b3ed458c
FP		 2121 static const char * const ds4_name_str[] = { "red", "green", "blue",
2122 "global" };
1adf904e
PM		 2123 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
2124 u8 use_hw_blink[MAX_LEDS] = { 0 };
f04d5140 2125
fa57a810 2126 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 2127
fa57a810
FP		 2128 if (sc->quirks & BUZZ_CONTROLLER) {
2129 sc->led_count = 4;
b3ed458c 2130 use_ds4_names = 0;
0a286ef2
SE		 2131 name_len = strlen("::buzz#");
2132 name_fmt = "%s::buzz%d";
2133 /* Validate expected report characteristics. */
2134 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
2135 return -ENODEV;
fa57a810 2136 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
221399b3
FP		 2137 dualshock4_set_leds_from_id(sc);
2138 sc->led_state[3] = 1;
b3ed458c
FP		 2139 sc->led_count = 4;
2140 memset(max_brightness, 255, 3);
2141 use_hw_blink[3] = 1;
2142 use_ds4_names = 1;
61ebca93
FP		 2143 name_len = 0;
2144 name_fmt = "%s:%s";
c5e0c1c4
FP		 2145 } else if (sc->quirks & MOTION_CONTROLLER) {
2146 sc->led_count = 3;
2147 memset(max_brightness, 255, 3);
2148 use_ds4_names = 1;
2149 name_len = 0;
2150 name_fmt = "%s:%s";
4545ee0a 2151 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1adf904e 2152 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
4545ee0a
SW		 2153
2154 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2155 sc->led_count = 1;
2156 memset(use_hw_blink, 1, 4);
2157 use_ds4_names = 0;
2158 name_len = strlen("::sony#");
2159 name_fmt = "%s::sony%d";
60781cf4 2160 } else {
221399b3 2161 sixaxis_set_leds_from_id(sc);
fa57a810 2162 sc->led_count = 4;
b3ed458c
FP		 2163 memset(use_hw_blink, 1, 4);
2164 use_ds4_names = 0;
61ebca93
FP		 2165 name_len = strlen("::sony#");
2166 name_fmt = "%s::sony%d";
60781cf4
FP		 2167 }
2168
ad142b9e
FP		 2169 /*
2170 * Clear LEDs as we have no way of reading their initial state. This is
f04d5140 2171 * only relevant if the driver is loaded after somebody actively set the
ad142b9e
FP		 2172 * LEDs to on
2173 */
221399b3 2174 sony_set_leds(sc);
f04d5140 2175
0a286ef2 2176 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 2177
fa57a810 2178 for (n = 0; n < sc->led_count; n++) {
61ebca93 2179
b3ed458c
FP		 2180 if (use_ds4_names)
2181 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
61ebca93 2182
f2d98e2c 2183 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
40e32ee6
JK		 2184 if (!led) {
2185 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
f2d98e2c 2186 return -ENOMEM;
40e32ee6 2187 }
f04d5140 2188
40e32ee6 2189 name = (void *)(&led[1]);
b3ed458c
FP		 2190 if (use_ds4_names)
2191 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2192 ds4_name_str[n]);
61ebca93
FP		 2193 else
2194 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6 2195 led->name = name;
221399b3 2196 led->brightness = sc->led_state[n];
b3ed458c 2197 led->max_brightness = max_brightness[n];
765a1077 2198 led->flags = LED_CORE_SUSPENDRESUME;
c5382519
SE		 2199 led->brightness_get = sony_led_get_brightness;
2200 led->brightness_set = sony_led_set_brightness;
f04d5140 2201
b3ed458c
FP		 2202 if (use_hw_blink[n])
2203 led->blink_set = sony_led_blink_set;
2204
8025087a
FP		 2205 sc->leds[n] = led;
2206
f2d98e2c 2207 ret = devm_led_classdev_register(&hdev->dev, led);
8cd5fcda 2208 if (ret) {
40e32ee6 2209 hid_err(hdev, "Failed to register LED %d\n", n);
f2d98e2c 2210 return ret;
f04d5140
CL		 2211 }
2212 }
f04d5140 2213
f2d98e2c 2214 return 0;
f04d5140
CL		 2215}
2216
d8aaccda 2217static void sixaxis_send_output_report(struct sony_sc *sc)
a08c22c0 2218{
9b2b5c9a 2219 static const union sixaxis_output_report_01 default_report = {
55d3b664
FP		 2220 .buf = {
2221 0x01,
ad07b7a6 2222 0x01, 0xff, 0x00, 0xff, 0x00,
55d3b664
FP		 2223 0x00, 0x00, 0x00, 0x00, 0x00,
2224 0xff, 0x27, 0x10, 0x00, 0x32,
2225 0xff, 0x27, 0x10, 0x00, 0x32,
2226 0xff, 0x27, 0x10, 0x00, 0x32,
2227 0xff, 0x27, 0x10, 0x00, 0x32,
2228 0x00, 0x00, 0x00, 0x00, 0x00
2229 }
a08c22c0 2230 };
9b2b5c9a
FP		 2231 struct sixaxis_output_report *report =
2232 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2233 int n;
2234
2235 /* Initialize the report with default values */
2236 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
9f323b68 2237
0a286ef2 2238#ifdef CONFIG_SONY_FF
9b2b5c9a
FP		 2239 report->rumble.right_motor_on = sc->right ? 1 : 0;
2240 report->rumble.left_motor_force = sc->left;
0a286ef2
SE		 2241#endif
2242
9b2b5c9a
FP		 2243 report->leds_bitmap |= sc->led_state[0] << 1;
2244 report->leds_bitmap |= sc->led_state[1] << 2;
2245 report->leds_bitmap |= sc->led_state[2] << 3;
2246 report->leds_bitmap |= sc->led_state[3] << 4;
9f323b68 2247
88f6576f 2248 /* Set flag for all leds off, required for 3rd party INTEC controller */
9b2b5c9a
FP		 2249 if ((report->leds_bitmap & 0x1E) == 0)
2250 report->leds_bitmap |= 0x20;
88f6576f 2251
b3ed458c
FP		 2252 /*
2253 * The LEDs in the report are indexed in reverse order to their
2254 * corresponding light on the controller.
2255 * Index 0 = LED 4, index 1 = LED 3, etc...
2256 *
2257 * In the case of both delay values being zero (blinking disabled) the
2258 * default report values should be used or the controller LED will be
2259 * always off.
2260 */
2261 for (n = 0; n < 4; n++) {
2262 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
9b2b5c9a
FP		 2263 report->led[3 - n].duty_off = sc->led_delay_off[n];
2264 report->led[3 - n].duty_on = sc->led_delay_on[n];
b3ed458c
FP		 2265 }
2266 }
2267
d03213f1
HY		 2268 /* SHANWAN controllers require output reports via intr channel */
2269 if (sc->quirks & SHANWAN_GAMEPAD)
2270 hid_hw_output_report(sc->hdev, (u8 *)report,
2271 sizeof(struct sixaxis_output_report));
2272 else
2273 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2274 sizeof(struct sixaxis_output_report),
2275 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
9f323b68
SE		 2276}
2277
d8aaccda 2278static void dualshock4_send_output_report(struct sony_sc *sc)
0bd88dd3 2279{
0da8ea65 2280 struct hid_device *hdev = sc->hdev;
1adf904e 2281 u8 *buf = sc->output_report_dmabuf;
48220237
FP		 2282 int offset;
2283
c4425c8f 2284 /*
77b499e7
RC		 2285 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2286 * control the interval at which Dualshock 4 reports data:
2287 * 0x00 - 1ms
2288 * 0x01 - 1ms
2289 * 0x02 - 2ms
2290 * 0x3E - 62ms
2291 * 0x3F - disabled
c4425c8f 2292 */
35f436c3 2293 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2c159de0 2294 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
fdcf105d 2295 buf[0] = 0x05;
5caceb06 2296 buf[1] = 0x07; /* blink + LEDs + motor */
fdcf105d
FP		 2297 offset = 4;
2298 } else {
2c159de0 2299 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
fdcf105d 2300 buf[0] = 0x11;
77b499e7 2301 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
5caceb06 2302 buf[3] = 0x07; /* blink + LEDs + motor */
fdcf105d
FP		 2303 offset = 6;
2304 }
0bd88dd3
FP		 2305
2306#ifdef CONFIG_SONY_FF
48220237
FP		 2307 buf[offset++] = sc->right;
2308 buf[offset++] = sc->left;
2309#else
2310 offset += 2;
0bd88dd3
FP		 2311#endif
2312
b3ed458c
FP		 2313 /* LED 3 is the global control */
2314 if (sc->led_state[3]) {
2315 buf[offset++] = sc->led_state[0];
2316 buf[offset++] = sc->led_state[1];
2317 buf[offset++] = sc->led_state[2];
2318 } else {
2319 offset += 3;
2320 }
2321
2322 /* If both delay values are zero the DualShock 4 disables blinking. */
2323 buf[offset++] = sc->led_delay_on[3];
2324 buf[offset++] = sc->led_delay_off[3];
60781cf4 2325
35f436c3 2326 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2c159de0 2327 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
e7ef53ad
RC		 2328 else {
2329 /* CRC generation */
2330 u8 bthdr = 0xA2;
2331 u32 crc;
2332
2333 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2334 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2335 put_unaligned_le32(crc, &buf[74]);
2336 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2337 }
0bd88dd3
FP		 2338}
2339
d8aaccda 2340static void motion_send_output_report(struct sony_sc *sc)
c5e0c1c4 2341{
c5e0c1c4
FP		 2342 struct hid_device *hdev = sc->hdev;
2343 struct motion_output_report_02 *report =
2344 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2345
41d2d425 2346 memset(report, 0, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 2347
2348 report->type = 0x02; /* set leds */
2349 report->r = sc->led_state[0];
2350 report->g = sc->led_state[1];
2351 report->b = sc->led_state[2];
2352
2353#ifdef CONFIG_SONY_FF
2354 report->rumble = max(sc->right, sc->left);
2355#endif
2356
1adf904e 2357 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 2358}
2359
decd946c
FP		 2360static inline void sony_send_output_report(struct sony_sc *sc)
2361{
2362 if (sc->send_output_report)
2363 sc->send_output_report(sc);
2364}
2365
d8aaccda
FP		 2366static void sony_state_worker(struct work_struct *work)
2367{
2368 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
ef916ef5 2369
d8aaccda
FP		 2370 sc->send_output_report(sc);
2371}
2372
9b2b5c9a
FP		 2373static int sony_allocate_output_report(struct sony_sc *sc)
2374{
4545ee0a
SW		 2375 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2376 (sc->quirks & NAVIGATION_CONTROLLER))
9b2b5c9a 2377 sc->output_report_dmabuf =
ea58c33d
HZ		 2378 devm_kmalloc(&sc->hdev->dev,
2379 sizeof(union sixaxis_output_report_01),
9b2b5c9a
FP		 2380 GFP_KERNEL);
2381 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
ea58c33d
HZ		 2382 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2383 DS4_OUTPUT_REPORT_0x11_SIZE,
9b2b5c9a 2384 GFP_KERNEL);
35f436c3 2385 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
ea58c33d
HZ		 2386 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2387 DS4_OUTPUT_REPORT_0x05_SIZE,
9b2b5c9a 2388 GFP_KERNEL);
c5e0c1c4 2389 else if (sc->quirks & MOTION_CONTROLLER)
ea58c33d
HZ		 2390 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2391 MOTION_REPORT_0x02_SIZE,
41d2d425 2392 GFP_KERNEL);
9b2b5c9a
FP		 2393 else
2394 return 0;
2395
2396 if (!sc->output_report_dmabuf)
2397 return -ENOMEM;
2398
2399 return 0;
2400}
2401
0a286ef2 2402#ifdef CONFIG_SONY_FF
9f323b68
SE		 2403static int sony_play_effect(struct input_dev *dev, void *data,
2404 struct ff_effect *effect)
2405{
a08c22c0 2406 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 2407 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 2408
2409 if (effect->type != FF_RUMBLE)
2410 return 0;
2411
9f323b68 2412 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 2413 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 2414
b5322736 2415 sony_schedule_work(sc, SONY_WORKER_STATE);
9f323b68 2416 return 0;
a08c22c0
SE		 2417}
2418
fa57a810 2419static int sony_init_ff(struct sony_sc *sc)
a08c22c0 2420{
d9d4b1e4
AS		 2421 struct hid_input *hidinput;
2422 struct input_dev *input_dev;
2423
2424 if (list_empty(&sc->hdev->inputs)) {
2425 hid_err(sc->hdev, "no inputs found\n");
2426 return -ENODEV;
2427 }
2428 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2429 input_dev = hidinput->input;
a08c22c0
SE		 2430
2431 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2432 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2433}
2434
2435#else
fa57a810 2436static int sony_init_ff(struct sony_sc *sc)
a08c22c0
SE		 2437{
2438 return 0;
2439}
9f323b68 2440
a08c22c0
SE		 2441#endif
2442
d902f472
FP		 2443static int sony_battery_get_property(struct power_supply *psy,
2444 enum power_supply_property psp,
2445 union power_supply_propval *val)
2446{
297d716f 2447 struct sony_sc *sc = power_supply_get_drvdata(psy);
d902f472
FP		 2448 unsigned long flags;
2449 int ret = 0;
a76a6c18
RC		 2450 u8 battery_capacity;
2451 int battery_status;
d902f472
FP		 2452
2453 spin_lock_irqsave(&sc->lock, flags);
d902f472 2454 battery_capacity = sc->battery_capacity;
a76a6c18 2455 battery_status = sc->battery_status;
d902f472
FP		 2456 spin_unlock_irqrestore(&sc->lock, flags);
2457
2458 switch (psp) {
2459 case POWER_SUPPLY_PROP_PRESENT:
2460 val->intval = 1;
2461 break;
2462 case POWER_SUPPLY_PROP_SCOPE:
2463 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2464 break;
2465 case POWER_SUPPLY_PROP_CAPACITY:
2466 val->intval = battery_capacity;
2467 break;
2468 case POWER_SUPPLY_PROP_STATUS:
a76a6c18 2469 val->intval = battery_status;
d902f472
FP		 2470 break;
2471 default:
2472 ret = -EINVAL;
2473 break;
2474 }
2475 return ret;
9f323b68
SE		 2476}
2477
0f398230 2478static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
c4e1ddf2 2479{
0f398230
FP		 2480 const char *battery_str_fmt = append_dev_id ?
2481 "sony_controller_battery_%pMR_%i" :
2482 "sony_controller_battery_%pMR";
297d716f 2483 struct power_supply_config psy_cfg = { .drv_data = sc, };
c4e1ddf2 2484 struct hid_device *hdev = sc->hdev;
d902f472 2485 int ret;
c4e1ddf2 2486
ad142b9e
FP		 2487 /*
2488 * Set the default battery level to 100% to avoid low battery warnings
d9a293a9
FP		 2489 * if the battery is polled before the first device report is received.
2490 */
2491 sc->battery_capacity = 100;
2492
297d716f
KK		 2493 sc->battery_desc.properties = sony_battery_props;
2494 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2495 sc->battery_desc.get_property = sony_battery_get_property;
2496 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2497 sc->battery_desc.use_for_apm = 0;
8082d3f0
HZ		 2498 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2499 battery_str_fmt, sc->mac_address, sc->device_id);
297d716f 2500 if (!sc->battery_desc.name)
d902f472 2501 return -ENOMEM;
c4e1ddf2 2502
8082d3f0 2503 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
297d716f
KK		 2504 &psy_cfg);
2505 if (IS_ERR(sc->battery)) {
2506 ret = PTR_ERR(sc->battery);
d902f472 2507 hid_err(hdev, "Unable to register battery device\n");
8082d3f0 2508 return ret;
d902f472 2509 }
c4e1ddf2 2510
297d716f 2511 power_supply_powers(sc->battery, &hdev->dev);
a08c22c0 2512 return 0;
9f323b68 2513}
a08c22c0 2514
d2d782fc
FP		 2515/*
2516 * If a controller is plugged in via USB while already connected via Bluetooth
2517 * it will show up as two devices. A global list of connected controllers and
2518 * their MAC addresses is maintained to ensure that a device is only connected
2519 * once.
0f398230
FP		 2520 *
2521 * Some USB-only devices masquerade as Sixaxis controllers and all have the
2522 * same dummy Bluetooth address, so a comparison of the connection type is
2523 * required. Devices are only rejected in the case where two devices have
2524 * matching Bluetooth addresses on different bus types.
d2d782fc 2525 */
0f398230
FP		 2526static inline int sony_compare_connection_type(struct sony_sc *sc0,
2527 struct sony_sc *sc1)
2528{
2529 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2530 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2531
2532 return sc0_not_bt == sc1_not_bt;
2533}
2534
d2d782fc
FP		 2535static int sony_check_add_dev_list(struct sony_sc *sc)
2536{
2537 struct sony_sc *entry;
2538 unsigned long flags;
2539 int ret;
2540
2541 spin_lock_irqsave(&sony_dev_list_lock, flags);
2542
2543 list_for_each_entry(entry, &sony_device_list, list_node) {
2544 ret = memcmp(sc->mac_address, entry->mac_address,
2545 sizeof(sc->mac_address));
2546 if (!ret) {
0f398230
FP		 2547 if (sony_compare_connection_type(sc, entry)) {
2548 ret = 1;
2549 } else {
2550 ret = -EEXIST;
2551 hid_info(sc->hdev,
2552 "controller with MAC address %pMR already connected\n",
d2d782fc 2553 sc->mac_address);
0f398230 2554 }
d2d782fc 2555 goto unlock;
c4e1ddf2
FP		 2556 }
2557 }
2558
d2d782fc
FP		 2559 ret = 0;
2560 list_add(&(sc->list_node), &sony_device_list);
c4e1ddf2 2561
d2d782fc
FP		 2562unlock:
2563 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2564 return ret;
2565}
2566
2567static void sony_remove_dev_list(struct sony_sc *sc)
2568{
2569 unsigned long flags;
c4e1ddf2 2570
d2d782fc
FP		 2571 if (sc->list_node.next) {
2572 spin_lock_irqsave(&sony_dev_list_lock, flags);
2573 list_del(&(sc->list_node));
2574 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2575 }
c4e1ddf2
FP		 2576}
2577
d2d782fc
FP		 2578static int sony_get_bt_devaddr(struct sony_sc *sc)
2579{
2580 int ret;
2581
2582 /* HIDP stores the device MAC address as a string in the uniq field. */
2583 ret = strlen(sc->hdev->uniq);
2584 if (ret != 17)
2585 return -EINVAL;
2586
2587 ret = sscanf(sc->hdev->uniq,
2588 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2589 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2590 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2591
2592 if (ret != 6)
2593 return -EINVAL;
2594
2595 return 0;
2596}
2597
2598static int sony_check_add(struct sony_sc *sc)
2599{
1adf904e 2600 u8 *buf = NULL;
d2d782fc
FP		 2601 int n, ret;
2602
2603 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
12e9a6d7 2604 (sc->quirks & MOTION_CONTROLLER_BT) ||
4545ee0a 2605 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
d2d782fc
FP		 2606 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2607 /*
2608 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2609 * address from the uniq string where HIDP stores it.
2610 * As uniq cannot be guaranteed to be a MAC address in all cases
2611 * a failure of this function should not prevent the connection.
2612 */
2613 if (sony_get_bt_devaddr(sc) < 0) {
2614 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2615 return 0;
2616 }
35f436c3 2617 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2c159de0 2618 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
9b2b5c9a
FP		 2619 if (!buf)
2620 return -ENOMEM;
d2d782fc
FP		 2621
2622 /*
2623 * The MAC address of a DS4 controller connected via USB can be
2624 * retrieved with feature report 0x81. The address begins at
2625 * offset 1.
2626 */
9b2b5c9a 2627 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2c159de0 2628 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
9b2b5c9a 2629 HID_REQ_GET_REPORT);
d2d782fc 2630
2c159de0 2631 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
d2d782fc 2632 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
9b2b5c9a
FP		 2633 ret = ret < 0 ? ret : -EINVAL;
2634 goto out_free;
d2d782fc
FP		 2635 }
2636
2637 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
c70d5f70
RC		 2638
2639 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
648d4932 2640 "%pMR", sc->mac_address);
4545ee0a
SW		 2641 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2642 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
9b2b5c9a
FP		 2643 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2644 if (!buf)
2645 return -ENOMEM;
d2d782fc
FP		 2646
2647 /*
2648 * The MAC address of a Sixaxis controller connected via USB can
2649 * be retrieved with feature report 0xf2. The address begins at
2650 * offset 4.
2651 */
9b2b5c9a
FP		 2652 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2653 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2654 HID_REQ_GET_REPORT);
d2d782fc 2655
9b2b5c9a 2656 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
d2d782fc 2657 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
9b2b5c9a
FP		 2658 ret = ret < 0 ? ret : -EINVAL;
2659 goto out_free;
d2d782fc
FP		 2660 }
2661
2662 /*
2663 * The Sixaxis device MAC in the report is big-endian and must
2664 * be byte-swapped.
2665 */
2666 for (n = 0; n < 6; n++)
2667 sc->mac_address[5-n] = buf[4+n];
5a144be3
RC		 2668
2669 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
648d4932 2670 "%pMR", sc->mac_address);
d2d782fc
FP		 2671 } else {
2672 return 0;
2673 }
2674
9b2b5c9a
FP		 2675 ret = sony_check_add_dev_list(sc);
2676
2677out_free:
2678
2679 kfree(buf);
2680
2681 return ret;
d2d782fc
FP		 2682}
2683
8025087a
FP		 2684static int sony_set_device_id(struct sony_sc *sc)
2685{
2686 int ret;
2687
2688 /*
2689 * Only DualShock 4 or Sixaxis controllers get an id.
2690 * All others are set to -1.
2691 */
2692 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2693 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2694 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2695 GFP_KERNEL);
2696 if (ret < 0) {
2697 sc->device_id = -1;
2698 return ret;
2699 }
2700 sc->device_id = ret;
2701 } else {
2702 sc->device_id = -1;
2703 }
2704
2705 return 0;
2706}
2707
2708static void sony_release_device_id(struct sony_sc *sc)
2709{
2710 if (sc->device_id >= 0) {
2711 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2712 sc->device_id = -1;
2713 }
2714}
2715
d8aaccda 2716static inline void sony_init_output_report(struct sony_sc *sc,
09593e38 2717 void (*send_output_report)(struct sony_sc *))
46262047 2718{
d8aaccda
FP		 2719 sc->send_output_report = send_output_report;
2720
b5322736 2721 if (!sc->state_worker_initialized)
d8aaccda 2722 INIT_WORK(&sc->state_worker, sony_state_worker);
46262047 2723
b5322736 2724 sc->state_worker_initialized = 1;
46262047
FP		 2725}
2726
2727static inline void sony_cancel_work_sync(struct sony_sc *sc)
2728{
e0f6974a
RC		 2729 unsigned long flags;
2730
f2f47c38
RC		 2731 if (sc->hotplug_worker_initialized)
2732 cancel_work_sync(&sc->hotplug_worker);
e0f6974a
RC		 2733 if (sc->state_worker_initialized) {
2734 spin_lock_irqsave(&sc->lock, flags);
2735 sc->state_worker_initialized = 0;
2736 spin_unlock_irqrestore(&sc->lock, flags);
46262047 2737 cancel_work_sync(&sc->state_worker);
e0f6974a 2738 }
46262047 2739}
d2d782fc 2740
e1bc84d0
RC		 2741static int sony_input_configured(struct hid_device *hdev,
2742 struct hid_input *hidinput)
bd28ce00 2743{
e1bc84d0 2744 struct sony_sc *sc = hid_get_drvdata(hdev);
0f398230 2745 int append_dev_id;
e1bc84d0 2746 int ret;
bd28ce00 2747
131a8a9a 2748 ret = sony_set_device_id(sc);
9b2b5c9a 2749 if (ret < 0) {
131a8a9a 2750 hid_err(hdev, "failed to allocate the device id\n");
9b2b5c9a
FP		 2751 goto err_stop;
2752 }
2753
df848bc0
RC		 2754 ret = append_dev_id = sony_check_add(sc);
2755 if (ret < 0)
2756 goto err_stop;
2757
131a8a9a 2758 ret = sony_allocate_output_report(sc);
8025087a 2759 if (ret < 0) {
131a8a9a 2760 hid_err(hdev, "failed to allocate the output report buffer\n");
8025087a
FP		 2761 goto err_stop;
2762 }
2763
510c8b7c 2764 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
e534a935
BT		 2765 /*
2766 * The Sony Sixaxis does not handle HID Output Reports on the
2767 * Interrupt EP like it could, so we need to force HID Output
2768 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2769 *
2770 * There is also another issue about HID Output Reports via USB,
2771 * the Sixaxis does not want the report_id as part of the data
2772 * packet, so we have to discard buf[0] when sending the actual
2773 * control message, even for numbered reports, humpf!
2a242932
FP		 2774 *
2775 * Additionally, the Sixaxis on USB isn't properly initialized
2776 * until the PS logo button is pressed and as such won't retain
2777 * any state set by an output report, so the initial
2778 * configuration report is deferred until the first input
2779 * report arrives.
e534a935
BT		 2780 */
2781 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2782 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2a242932 2783 sc->defer_initialization = 1;
80ecc48c 2784
816651a7 2785 ret = sixaxis_set_operational_usb(hdev);
80ecc48c
RC		 2786 if (ret < 0) {
2787 hid_err(hdev, "Failed to set controller into operational mode\n");
2788 goto err_stop;
2789 }
2790
d8aaccda 2791 sony_init_output_report(sc, sixaxis_send_output_report);
510c8b7c
RC		 2792 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2793 /*
2794 * The Navigation controller wants output reports sent on the ctrl
2795 * endpoint when connected via Bluetooth.
2796 */
2797 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2798
2799 ret = sixaxis_set_operational_bt(hdev);
2800 if (ret < 0) {
2801 hid_err(hdev, "Failed to set controller into operational mode\n");
2802 goto err_stop;
2803 }
2804
d8aaccda 2805 sony_init_output_report(sc, sixaxis_send_output_report);
510c8b7c
RC		 2806 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2807 /*
2808 * The Sony Sixaxis does not handle HID Output Reports on the
2809 * Interrupt EP and the device only becomes active when the
2810 * PS button is pressed. See comment for Navigation controller
2811 * above for more details.
2812 */
2813 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2814 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2815 sc->defer_initialization = 1;
2816
2817 ret = sixaxis_set_operational_usb(hdev);
2818 if (ret < 0) {
2819 hid_err(hdev, "Failed to set controller into operational mode\n");
2820 goto err_stop;
2821 }
2822
2823 ret = sony_register_sensors(sc);
2824 if (ret) {
2825 hid_err(sc->hdev,
2826 "Unable to initialize motion sensors: %d\n", ret);
2827 goto err_stop;
2828 }
2829
2830 sony_init_output_report(sc, sixaxis_send_output_report);
2831 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2078b9bb
FP		 2832 /*
2833 * The Sixaxis wants output reports sent on the ctrl endpoint
2834 * when connected via Bluetooth.
2835 */
2836 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
80ecc48c 2837
816651a7 2838 ret = sixaxis_set_operational_bt(hdev);
80ecc48c
RC		 2839 if (ret < 0) {
2840 hid_err(hdev, "Failed to set controller into operational mode\n");
2841 goto err_stop;
2842 }
2843
510c8b7c
RC		 2844 ret = sony_register_sensors(sc);
2845 if (ret) {
2846 hid_err(sc->hdev,
2847 "Unable to initialize motion sensors: %d\n", ret);
2848 goto err_stop;
2849 }
2850
d8aaccda 2851 sony_init_output_report(sc, sixaxis_send_output_report);
fee4e2d5 2852 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
55a07d62
RC		 2853 ret = dualshock4_get_calibration_data(sc);
2854 if (ret < 0) {
2855 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2856 goto err_stop;
68330d83 2857 }
c4e1ddf2 2858
169f15ab
RC		 2859 ret = dualshock4_get_version_info(sc);
2860 if (ret < 0) {
2861 hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2862 goto err_stop;
2863 }
2864
2865 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2866 if (ret) {
169f15ab
RC		 2867 hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2868 goto err_stop;
2869 }
1a8212e8 2870 sc->fw_version_created = true;
169f15ab
RC		 2871
2872 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2873 if (ret) {
169f15ab
RC		 2874 hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2875 goto err_stop;
2876 }
1a8212e8 2877 sc->hw_version_created = true;
169f15ab 2878
e1bc84d0
RC		 2879 /*
2880 * The Dualshock 4 touchpad supports 2 touches and has a
2881 * resolution of 1920x942 (44.86 dots/mm).
2882 */
b7289cb1 2883 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
e1bc84d0
RC		 2884 if (ret) {
2885 hid_err(sc->hdev,
2886 "Unable to initialize multi-touch slots: %d\n",
2887 ret);
2b6579d4 2888 goto err_stop;
e1bc84d0
RC		 2889 }
2890
227c011b
RC		 2891 ret = sony_register_sensors(sc);
2892 if (ret) {
2893 hid_err(sc->hdev,
2894 "Unable to initialize motion sensors: %d\n", ret);
2895 goto err_stop;
2896 }
2897
77b499e7
RC		 2898 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2899 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2900 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2901 if (ret)
2902 hid_warn(sc->hdev,
2903 "can't create sysfs bt_poll_interval attribute err: %d\n",
2904 ret);
2905 }
2906
f2f47c38
RC		 2907 if (sc->quirks & DUALSHOCK4_DONGLE) {
2908 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2909 sc->hotplug_worker_initialized = 1;
2910 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2911 }
2912
d8aaccda 2913 sony_init_output_report(sc, dualshock4_send_output_report);
b7289cb1
TK		 2914 } else if (sc->quirks & NSG_MRXU_REMOTE) {
2915 /*
2916 * The NSG-MRxU touchpad supports 2 touches and has a
2917 * resolution of 1667x1868
2918 */
2919 ret = sony_register_touchpad(sc, 2,
2920 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2921 if (ret) {
2922 hid_err(sc->hdev,
2923 "Unable to initialize multi-touch slots: %d\n",
2924 ret);
2925 goto err_stop;
2926 }
2927
c5e0c1c4 2928 } else if (sc->quirks & MOTION_CONTROLLER) {
d8aaccda 2929 sony_init_output_report(sc, motion_send_output_report);
0bd88dd3
FP		 2930 } else {
2931 ret = 0;
2932 }
f9ce7c28 2933
0a286ef2 2934 if (sc->quirks & SONY_LED_SUPPORT) {
fa57a810 2935 ret = sony_leds_init(sc);
0a286ef2
SE		 2936 if (ret < 0)
2937 goto err_stop;
2938 }
2939
d902f472 2940 if (sc->quirks & SONY_BATTERY_SUPPORT) {
0f398230 2941 ret = sony_battery_probe(sc, append_dev_id);
d902f472
FP		 2942 if (ret < 0)
2943 goto err_stop;
2944
2945 /* Open the device to receive reports with battery info */
2946 ret = hid_hw_open(hdev);
2947 if (ret < 0) {
2948 hid_err(hdev, "hw open failed\n");
2949 goto err_stop;
2950 }
2951 }
2952
c8de9dbb 2953 if (sc->quirks & SONY_FF_SUPPORT) {
fa57a810 2954 ret = sony_init_ff(sc);
c8de9dbb
FP		 2955 if (ret < 0)
2956 goto err_close;
5f5750d2 2957 }
a08c22c0 2958
bd28ce00 2959 return 0;
d902f472
FP		 2960err_close:
2961 hid_hw_close(hdev);
bd28ce00 2962err_stop:
77b499e7
RC		 2963 /* Piggy back on the default ds4_bt_ poll_interval to determine
2964 * if we need to remove the file as we don't know for sure if we
2965 * executed that logic.
2966 */
2967 if (sc->ds4_bt_poll_interval)
2968 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
1a8212e8 2969 if (sc->fw_version_created)
169f15ab 2970 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
1a8212e8 2971 if (sc->hw_version_created)
169f15ab 2972 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
46262047 2973 sony_cancel_work_sync(sc);
d2d782fc 2974 sony_remove_dev_list(sc);
8025087a 2975 sony_release_device_id(sc);
bd28ce00
JS		 2976 return ret;
2977}
2978
e1bc84d0
RC		 2979static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2980{
2981 int ret;
2982 unsigned long quirks = id->driver_data;
2983 struct sony_sc *sc;
2984 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2985
2986 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2987 quirks |= FUTUREMAX_DANCE_MAT;
2988
69481059
HY		 2989 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad"))
2990 quirks |= SHANWAN_GAMEPAD;
2991
e1bc84d0
RC		 2992 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
e19a267b 3015 /* Patch the hw version on DS3/4 compatible devices, so applications can
9131f8cc
RC		 3016 * 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 */
e19a267b 3021 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
9131f8cc
RC		 3022 hdev->version |= 0x8000;
3023
e1bc84d0
RC		 3024 ret = hid_hw_start(hdev, connect_mask);
3025 if (ret) {
3026 hid_err(hdev, "hw start failed\n");
3027 return ret;
3028 }
3029
4f967f6d
RC		 3030 /* 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");
2bcdacb7 3040 hid_hw_stop(hdev);
4f967f6d
RC		 3041 return -ENODEV;
3042 }
3043
cc894ac5
PG		 3044 if (sc->quirks & GHL_GUITAR_PS3WIIU) {
3045 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
3046 mod_timer(&sc->ghl_poke_timer,
3047 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
3048 }
3049
e1bc84d0
RC		 3050 return ret;
3051}
3052
cc6e0bbb
JK		 3053static void sony_remove(struct hid_device *hdev)
3054{
f04d5140
CL		 3055 struct sony_sc *sc = hid_get_drvdata(hdev);
3056
cc894ac5
PG		 3057 if (sc->quirks & GHL_GUITAR_PS3WIIU)
3058 del_timer_sync(&sc->ghl_poke_timer);
3059
ac797b95
RC		 3060 hid_hw_close(hdev);
3061
77b499e7
RC		 3062 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
3063 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
3064
1a8212e8 3065 if (sc->fw_version_created)
169f15ab
RC		 3066 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
3067
1a8212e8 3068 if (sc->hw_version_created)
169f15ab
RC		 3069 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
3070
46262047 3071 sony_cancel_work_sync(sc);
9f323b68 3072
d2d782fc 3073 sony_remove_dev_list(sc);
9f323b68 3074
8025087a
FP		 3075 sony_release_device_id(sc);
3076
cc6e0bbb 3077 hid_hw_stop(hdev);
cc6e0bbb
JK		 3078}
3079
decd946c
FP		 3080#ifdef CONFIG_PM
3081
3082static int sony_suspend(struct hid_device *hdev, pm_message_t message)
3083{
decd946c 3084#ifdef CONFIG_SONY_FF
decd946c 3085
765a1077
FP		 3086 /* On suspend stop any running force-feedback events */
3087 if (SONY_FF_SUPPORT) {
3088 struct sony_sc *sc = hid_get_drvdata(hdev);
decd946c 3089
765a1077 3090 sc->left = sc->right = 0;
decd946c
FP		 3091 sony_send_output_report(sc);
3092 }
3093
765a1077 3094#endif
decd946c
FP		 3095 return 0;
3096}
3097
3098static int sony_resume(struct hid_device *hdev)
3099{
765a1077 3100 struct sony_sc *sc = hid_get_drvdata(hdev);
decd946c 3101
765a1077
FP		 3102 /*
3103 * The Sixaxis and navigation controllers on USB need to be
3104 * reinitialized on resume or they won't behave properly.
3105 */
3106 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
3107 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
3108 sixaxis_set_operational_usb(sc->hdev);
3109 sc->defer_initialization = 1;
decd946c
FP		 3110 }
3111
3112 return 0;
3113}
3114
3115#endif
3116
bd28ce00 3117static const struct hid_device_id sony_devices[] = {
816651a7
AO		 3118 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3119 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4 3120 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 3121 .driver_data = NAVIGATION_CONTROLLER_USB },
6eabaaa0 3122 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 3123 .driver_data = NAVIGATION_CONTROLLER_BT },
c5e0c1c4 3124 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 3125 .driver_data = MOTION_CONTROLLER_USB },
a4afa854 3126 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 3127 .driver_data = MOTION_CONTROLLER_BT },
816651a7
AO		 3128 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3129 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 3130 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
3131 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 3132 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
3133 .driver_data = VAIO_RDESC_CONSTANT },
ef916ef5
AO		 3134 /*
3135 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
3136 * Logitech joystick from the device descriptor.
3137 */
f04d5140
CL		 3138 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
3139 .driver_data = BUZZ_CONTROLLER },
3140 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
3141 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 3142 /* PS3 BD Remote Control */
3143 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
3144 .driver_data = PS3REMOTE },
3145 /* Logitech Harmony Adapter for PS3 */
3146 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
3147 .driver_data = PS3REMOTE },
68a49e51
FP		 3148 /* SMK-Link PS3 BD Remote Control */
3149 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
3150 .driver_data = PS3REMOTE },
0bd88dd3
FP		 3151 /* Sony Dualshock 4 controllers for PS4 */
3152 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 3153 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 3154 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 3155 .driver_data = DUALSHOCK4_CONTROLLER_BT },
cf1015d6
RC		 3156 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3157 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3158 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3159 .driver_data = DUALSHOCK4_CONTROLLER_BT },
de66a1a0 3160 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
35f436c3 3161 .driver_data = DUALSHOCK4_DONGLE },
74500cc8
SM		 3162 /* Nyko Core Controller for PS3 */
3163 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
3164 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
b7289cb1
TK		 3165 /* SMK-Link NSG-MR5U Remote Control */
3166 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3167 .driver_data = NSG_MR5U_REMOTE_BT },
3168 /* SMK-Link NSG-MR7U Remote Control */
3169 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3170 .driver_data = NSG_MR7U_REMOTE_BT },
cc894ac5 3171 /* Guitar Hero Live PS3 and Wii U guitar dongles */
32e411d0
SG		 3172 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
3173 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
3174 /* Guitar Hero PC Guitar Dongle */
3175 { HID_USB_DEVICE(USB_VENDOR_ID_ACTIVISION, USB_DEVICE_ID_ACTIVISION_GUITAR_DONGLE),
3176 .driver_data = GH_GUITAR_CONTROLLER },
3177 /* Guitar Hero PS3 World Tour Guitar Dongle */
3178 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
3179 .driver_data = GH_GUITAR_CONTROLLER },
bd28ce00
JS		 3180 { }
3181};
3182MODULE_DEVICE_TABLE(hid, sony_devices);
3183
3184static struct hid_driver sony_driver = {
ce8efc3b
FP		 3185 .name = "sony",
3186 .id_table = sony_devices,
3187 .input_mapping = sony_mapping,
3188 .input_configured = sony_input_configured,
3189 .probe = sony_probe,
3190 .remove = sony_remove,
3191 .report_fixup = sony_report_fixup,
decd946c
FP		 3192 .raw_event = sony_raw_event,
3193
3194#ifdef CONFIG_PM
3195 .suspend = sony_suspend,
3196 .resume = sony_resume,
3197 .reset_resume = sony_resume,
3198#endif
bd28ce00 3199};
8025087a
FP		 3200
3201static int __init sony_init(void)
3202{
3203 dbg_hid("Sony:%s\n", __func__);
3204
3205 return hid_register_driver(&sony_driver);
3206}
3207
3208static void __exit sony_exit(void)
3209{
3210 dbg_hid("Sony:%s\n", __func__);
3211
8025087a 3212 hid_unregister_driver(&sony_driver);
6c40065f 3213 ida_destroy(&sony_device_id_allocator);
8025087a
FP		 3214}
3215module_init(sony_init);
3216module_exit(sony_exit);
bd28ce00 3217
bd28ce00 3218MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)