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