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