]> 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
HID: ite: Add USB id match for Acer SW5-012 keyboard dock
[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{
86938d24
RC		 581 unsigned long flags;
582
b5322736
RC		 583 switch (which) {
584 case SONY_WORKER_STATE:
86938d24
RC		 585 spin_lock_irqsave(&sc->lock, flags);
586 if (!sc->defer_initialization && sc->state_worker_initialized)
b5322736 587 schedule_work(&sc->state_worker);
86938d24 588 spin_unlock_irqrestore(&sc->lock, flags);
f2f47c38
RC		 589 break;
590 case SONY_WORKER_HOTPLUG:
591 if (sc->hotplug_worker_initialized)
592 schedule_work(&sc->hotplug_worker);
593 break;
b5322736 594 }
2a242932
FP		 595}
596
77b499e7
RC		 597static ssize_t ds4_show_poll_interval(struct device *dev,
598 struct device_attribute
599 *attr, char *buf)
c607fb8d 600{
77b499e7
RC		 601 struct hid_device *hdev = to_hid_device(dev);
602 struct sony_sc *sc = hid_get_drvdata(hdev);
603
604 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
c607fb8d
AO		 605}
606
77b499e7
RC		 607static ssize_t ds4_store_poll_interval(struct device *dev,
608 struct device_attribute *attr,
609 const char *buf, size_t count)
c5e0c1c4 610{
77b499e7
RC		 611 struct hid_device *hdev = to_hid_device(dev);
612 struct sony_sc *sc = hid_get_drvdata(hdev);
613 unsigned long flags;
614 u8 interval;
615
616 if (kstrtou8(buf, 0, &interval))
617 return -EINVAL;
618
619 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
620 return -EINVAL;
621
622 spin_lock_irqsave(&sc->lock, flags);
623 sc->ds4_bt_poll_interval = interval;
624 spin_unlock_irqrestore(&sc->lock, flags);
625
626 sony_schedule_work(sc, SONY_WORKER_STATE);
627
628 return count;
c5e0c1c4
FP		 629}
630
77b499e7
RC		 631static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
632 ds4_store_poll_interval);
633
634
c5e0c1c4 635static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
b2723eb7
SW		 636 unsigned int *rsize)
637{
c5e0c1c4
FP		 638 *rsize = sizeof(motion_rdesc);
639 return motion_rdesc;
b2723eb7
SW		 640}
641
1adf904e 642static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
078328da
JK		 643 unsigned int *rsize)
644{
645 *rsize = sizeof(ps3remote_rdesc);
646 return ps3remote_rdesc;
647}
648
649static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
650 struct hid_field *field, struct hid_usage *usage,
651 unsigned long **bit, int *max)
652{
653 unsigned int key = usage->hid & HID_USAGE;
654
655 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
656 return -1;
657
658 switch (usage->collection_index) {
659 case 1:
660 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
661 return -1;
662
663 key = ps3remote_keymap_joypad_buttons[key];
664 if (!key)
665 return -1;
666 break;
667 case 2:
668 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
669 return -1;
670
671 key = ps3remote_keymap_remote_buttons[key];
672 if (!key)
673 return -1;
674 break;
675 default:
676 return -1;
677 }
678
679 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
680 return 1;
681}
682
b8f0970d
RC		 683static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
684 struct hid_field *field, struct hid_usage *usage,
685 unsigned long **bit, int *max)
686{
687 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
688 unsigned int key = usage->hid & HID_USAGE;
689
690 if (key >= ARRAY_SIZE(sixaxis_keymap))
691 return -1;
692
693 key = navigation_keymap[key];
694 if (!key)
695 return -1;
696
697 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
698 return 1;
699 } else if (usage->hid == HID_GD_POINTER) {
700 /* See comment in sixaxis_mapping, basically the L2 (and R2)
701 * triggers are reported through GD Pointer.
702 * In addition we ignore any analog button 'axes' and only
703 * support digital buttons.
704 */
705 switch (usage->usage_index) {
706 case 8: /* L2 */
707 usage->hid = HID_GD_Z;
708 break;
709 default:
710 return -1;
711 }
712
713 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
714 return 1;
715 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
716 unsigned int abs = usage->hid & HID_USAGE;
717
718 if (abs >= ARRAY_SIZE(navigation_absmap))
719 return -1;
720
721 abs = navigation_absmap[abs];
722
723 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
724 return 1;
725 }
726
727 return -1;
728}
729
730
e19a267b
RC		 731static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
732 struct hid_field *field, struct hid_usage *usage,
733 unsigned long **bit, int *max)
734{
735 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
736 unsigned int key = usage->hid & HID_USAGE;
737
738 if (key >= ARRAY_SIZE(sixaxis_keymap))
739 return -1;
740
741 key = sixaxis_keymap[key];
742 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
743 return 1;
744 } else if (usage->hid == HID_GD_POINTER) {
745 /* The DS3 provides analog values for most buttons and even
746 * for HAT axes through GD Pointer. L2 and R2 are reported
747 * among these as well instead of as GD Z / RZ. Remap L2
748 * and R2 and ignore other analog 'button axes' as there is
749 * no good way for reporting them.
750 */
751 switch (usage->usage_index) {
752 case 8: /* L2 */
753 usage->hid = HID_GD_Z;
754 break;
755 case 9: /* R2 */
756 usage->hid = HID_GD_RZ;
757 break;
758 default:
759 return -1;
760 }
761
762 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
763 return 1;
764 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
765 unsigned int abs = usage->hid & HID_USAGE;
766
767 if (abs >= ARRAY_SIZE(sixaxis_absmap))
768 return -1;
769
770 abs = sixaxis_absmap[abs];
771
772 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
773 return 1;
774 }
775
776 return -1;
777}
778
9131f8cc
RC		 779static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
780 struct hid_field *field, struct hid_usage *usage,
781 unsigned long **bit, int *max)
782{
783 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
784 unsigned int key = usage->hid & HID_USAGE;
785
786 if (key >= ARRAY_SIZE(ds4_keymap))
787 return -1;
788
789 key = ds4_keymap[key];
790 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
791 return 1;
792 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
793 unsigned int abs = usage->hid & HID_USAGE;
794
795 /* Let the HID parser deal with the HAT. */
796 if (usage->hid == HID_GD_HATSWITCH)
797 return 0;
798
799 if (abs >= ARRAY_SIZE(ds4_absmap))
800 return -1;
801
802 abs = ds4_absmap[abs];
803 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
804 return 1;
805 }
806
807 return 0;
808}
809
1adf904e 810static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
73e4008d 811 unsigned int *rsize)
cc6e0bbb
JK		 812{
813 struct sony_sc *sc = hid_get_drvdata(hdev);
814
4ba1eeeb 815 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
74500cc8
SM		 816 return rdesc;
817
99d24902
FLVC		 818 /*
819 * Some Sony RF receivers wrongly declare the mouse pointer as a
820 * a constant non-data variable.
821 */
822 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
823 /* usage page: generic desktop controls */
824 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
825 /* usage: mouse */
826 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
827 /* input (usage page for x,y axes): constant, variable, relative */
828 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
a4649184 829 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
99d24902 830 /* input: data, variable, relative */
cc6e0bbb
JK		 831 rdesc[55] = 0x06;
832 }
61ab44be 833
c5e0c1c4
FP		 834 if (sc->quirks & MOTION_CONTROLLER)
835 return motion_fixup(hdev, rdesc, rsize);
836
078328da
JK		 837 if (sc->quirks & PS3REMOTE)
838 return ps3remote_fixup(hdev, rdesc, rsize);
839
73e4008d 840 return rdesc;
cc6e0bbb
JK		 841}
842
1adf904e 843static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
d902f472 844{
1adf904e 845 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
d902f472 846 unsigned long flags;
12e9a6d7 847 int offset;
1adf904e 848 u8 cable_state, battery_capacity, battery_charging;
d902f472 849
ad142b9e
FP		 850 /*
851 * The sixaxis is charging if the battery value is 0xee
d902f472
FP		 852 * and it is fully charged if the value is 0xef.
853 * It does not report the actual level while charging so it
854 * is set to 100% while charging is in progress.
855 */
12e9a6d7
SW		 856 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
857
858 if (rd[offset] >= 0xee) {
d902f472 859 battery_capacity = 100;
12e9a6d7 860 battery_charging = !(rd[offset] & 0x01);
9fddd74a 861 cable_state = 1;
d902f472 862 } else {
1adf904e 863 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
ac3c9a94 864 battery_capacity = sixaxis_battery_capacity[index];
d902f472 865 battery_charging = 0;
9fddd74a 866 cable_state = 0;
d902f472 867 }
d902f472
FP		 868
869 spin_lock_irqsave(&sc->lock, flags);
870 sc->cable_state = cable_state;
871 sc->battery_capacity = battery_capacity;
872 sc->battery_charging = battery_charging;
873 spin_unlock_irqrestore(&sc->lock, flags);
510c8b7c
RC		 874
875 if (sc->quirks & SIXAXIS_CONTROLLER) {
876 int val;
877
878 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
879 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
880 input_report_abs(sc->sensor_dev, ABS_X, val);
881
882 /* Y and Z are swapped and inversed */
883 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
884 input_report_abs(sc->sensor_dev, ABS_Y, val);
885
886 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
887 input_report_abs(sc->sensor_dev, ABS_Z, val);
888
889 input_sync(sc->sensor_dev);
890 }
d902f472
FP		 891}
892
1adf904e 893static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
d902f472 894{
d03ae2e1
RC		 895 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
896 struct hid_input, list);
897 struct input_dev *input_dev = hidinput->input;
d902f472 898 unsigned long flags;
cdc1c021 899 int n, m, offset, num_touch_data, max_touch_data;
1adf904e 900 u8 cable_state, battery_capacity, battery_charging;
80786eb9 901 u16 timestamp;
d902f472 902
cdc1c021 903 /* When using Bluetooth the header is 2 bytes longer, so skip these. */
35f436c3 904 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
6c5f860d 905
ac797b95
RC		 906 /* Second bit of third button byte is for the touchpad button. */
907 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
908 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
909
d03ae2e1
RC		 910 /*
911 * The default behavior of the Dualshock 4 is to send reports using
912 * report type 1 when running over Bluetooth. However, when feature
913 * report 2 is requested during the controller initialization it starts
914 * sending input reports in report 17. Since report 17 is undefined
915 * in the default HID descriptor, the HID layer won't generate events.
916 * While it is possible (and this was done before) to fixup the HID
917 * descriptor to add this mapping, it was better to do this manually.
918 * The reason is there were various pieces software both open and closed
919 * source, relying on the descriptors to be the same across various
920 * operating systems. If the descriptors wouldn't match some
921 * applications e.g. games on Wine would not be able to function due
922 * to different descriptors, which such applications are not parsing.
923 */
924 if (rd[0] == 17) {
925 int value;
926
927 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
928 input_report_abs(input_dev, ABS_X, rd[offset]);
929 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
930 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
931 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
932
933 value = rd[offset+4] & 0xf;
934 if (value > 7)
935 value = 8; /* Center 0, 0 */
936 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
937 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
938
939 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
940 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
941 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
942 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
943
944 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
945 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
946 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
947 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
948 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
949 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
950 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
951 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
952
953 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
954
955 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
956 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
957
958 input_sync(input_dev);
959 }
960
80786eb9
RC		 961 /* Convert timestamp (in 5.33us unit) to timestamp_us */
962 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
963 timestamp = get_unaligned_le16(&rd[offset]);
964 if (!sc->timestamp_initialized) {
965 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
966 sc->timestamp_initialized = true;
967 } else {
968 u16 delta;
969
970 if (sc->prev_timestamp > timestamp)
971 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
972 else
973 delta = timestamp - sc->prev_timestamp;
974 sc->timestamp_us += (delta * 16) / 3;
975 }
976 sc->prev_timestamp = timestamp;
977 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
978
227c011b 979 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
55a07d62
RC		 980 for (n = 0; n < 6; n++) {
981 /* Store data in int for more precision during mult_frac. */
982 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
983 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
984
985 /* High precision is needed during calibration, but the
986 * calibrated values are within 32-bit.
987 * Note: we swap numerator 'x' and 'numer' in mult_frac for
988 * precision reasons so we don't need 64-bit.
989 */
990 int calib_data = mult_frac(calib->sens_numer,
991 raw_data - calib->bias,
992 calib->sens_denom);
227c011b 993
55a07d62
RC		 994 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
995 offset += 2;
227c011b
RC		 996 }
997 input_sync(sc->sensor_dev);
998
ad142b9e 999 /*
cdc1c021 1000 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
d902f472
FP		 1001 * and the 5th bit contains the USB cable state.
1002 */
cdc1c021 1003 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
6c5f860d
FP		 1004 cable_state = (rd[offset] >> 4) & 0x01;
1005 battery_capacity = rd[offset] & 0x0F;
d902f472 1006
ad142b9e
FP		 1007 /*
1008 * When a USB power source is connected the battery level ranges from
6c5f860d
FP		 1009 * 0 to 10, and when running on battery power it ranges from 0 to 9.
1010 * A battery level above 10 when plugged in means charge completed.
d902f472 1011 */
6c5f860d 1012 if (!cable_state || battery_capacity > 10)
d902f472
FP		 1013 battery_charging = 0;
1014 else
1015 battery_charging = 1;
1016
6c5f860d
FP		 1017 if (!cable_state)
1018 battery_capacity++;
d902f472 1019 if (battery_capacity > 10)
6c5f860d
FP		 1020 battery_capacity = 10;
1021
d902f472
FP		 1022 battery_capacity *= 10;
1023
1024 spin_lock_irqsave(&sc->lock, flags);
1025 sc->cable_state = cable_state;
1026 sc->battery_capacity = battery_capacity;
1027 sc->battery_charging = battery_charging;
1028 spin_unlock_irqrestore(&sc->lock, flags);
e5606230 1029
ad142b9e 1030 /*
cdc1c021
RC		 1031 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1032 * and 35 on Bluetooth.
1033 * The first byte indicates the number of touch data in the report.
1034 * Trackpad data starts 2 bytes later (e.g. 35 for USB).
e5606230 1035 */
cdc1c021 1036 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
35f436c3 1037 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
cdc1c021
RC		 1038 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1039 num_touch_data = rd[offset];
1040 else
1041 num_touch_data = 1;
1042 offset += 1;
e5606230 1043
cdc1c021
RC		 1044 for (m = 0; m < num_touch_data; m++) {
1045 /* Skip past timestamp */
1046 offset += 1;
e5606230 1047
cdc1c021
RC		 1048 /*
1049 * The first 7 bits of the first byte is a counter and bit 8 is
1050 * a touch indicator that is 0 when pressed and 1 when not
1051 * pressed.
1052 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1053 * The data for the second touch is in the same format and
1054 * immediately follows the data for the first.
1055 */
1056 for (n = 0; n < 2; n++) {
1057 u16 x, y;
1058 bool active;
1059
1060 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1061 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1062
1063 active = !(rd[offset] >> 7);
ac797b95
RC		 1064 input_mt_slot(sc->touchpad, n);
1065 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
cdc1c021
RC		 1066
1067 if (active) {
ac797b95
RC		 1068 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1069 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
cdc1c021
RC		 1070 }
1071
1072 offset += 4;
1073 }
ac797b95
RC		 1074 input_mt_sync_frame(sc->touchpad);
1075 input_sync(sc->touchpad);
e5606230 1076 }
d902f472
FP		 1077}
1078
c9e4d877 1079static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1adf904e 1080 u8 *rd, int size)
c9e4d877
SW		 1081{
1082 struct sony_sc *sc = hid_get_drvdata(hdev);
1083
ad142b9e
FP		 1084 /*
1085 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
c9e4d877
SW		 1086 * has to be BYTE_SWAPPED before passing up to joystick interface
1087 */
fee4e2d5 1088 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
8f5f0bc2
FP		 1089 /*
1090 * When connected via Bluetooth the Sixaxis occasionally sends
1091 * a report with the second byte 0xff and the rest zeroed.
1092 *
1093 * This report does not reflect the actual state of the
1094 * controller must be ignored to avoid generating false input
1095 * events.
1096 */
1097 if (rd[1] == 0xff)
1098 return -EINVAL;
1099
c9e4d877
SW		 1100 swap(rd[41], rd[42]);
1101 swap(rd[43], rd[44]);
1102 swap(rd[45], rd[46]);
1103 swap(rd[47], rd[48]);
d902f472 1104
12e9a6d7
SW		 1105 sixaxis_parse_report(sc, rd, size);
1106 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
d902f472 1107 sixaxis_parse_report(sc, rd, size);
4545ee0a
SW		 1108 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1109 size == 49) {
1110 sixaxis_parse_report(sc, rd, size);
35f436c3
RC		 1111 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1112 size == 64) {
1113 dualshock4_parse_report(sc, rd, size);
1114 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1115 size == 78)) {
1116 /* CRC check */
1117 u8 bthdr = 0xA1;
1118 u32 crc;
1119 u32 report_crc;
49b9ca6c 1120
35f436c3
RC		 1121 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1122 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1123 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1124 if (crc != report_crc) {
1125 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1126 report_crc, crc);
1127 return -EILSEQ;
49b9ca6c 1128 }
405182c2 1129
35f436c3
RC		 1130 dualshock4_parse_report(sc, rd, size);
1131 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1132 size == 64) {
f2f47c38
RC		 1133 unsigned long flags;
1134 enum ds4_dongle_state dongle_state;
1135
405182c2
RC		 1136 /*
1137 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1138 * if a DS4 is actually connected (indicated by '0').
1139 * For non-dongle, this bit is always 0 (connected).
1140 */
35f436c3
RC		 1141 bool connected = (rd[31] & 0x04) ? false : true;
1142
f2f47c38
RC		 1143 spin_lock_irqsave(&sc->lock, flags);
1144 dongle_state = sc->ds4_dongle_state;
1145 spin_unlock_irqrestore(&sc->lock, flags);
1146
1147 /*
1148 * The dongle always sends input reports even when no
1149 * DS4 is attached. When a DS4 is connected, we need to
1150 * obtain calibration data before we can use it.
1151 * The code below tracks dongle state and kicks of
1152 * calibration when needed and only allows us to process
1153 * input if a DS4 is actually connected.
1154 */
1155 if (dongle_state == DONGLE_DISCONNECTED && connected) {
35f436c3
RC		 1156 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1157 sony_set_leds(sc);
f2f47c38
RC		 1158
1159 spin_lock_irqsave(&sc->lock, flags);
1160 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1161 spin_unlock_irqrestore(&sc->lock, flags);
1162
1163 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1164
1165 /* Don't process the report since we don't have
1166 * calibration data, but let hidraw have it anyway.
1167 */
1168 return 0;
1169 } else if ((dongle_state == DONGLE_CONNECTED ||
1170 dongle_state == DONGLE_DISABLED) && !connected) {
35f436c3 1171 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
f2f47c38
RC		 1172
1173 spin_lock_irqsave(&sc->lock, flags);
1174 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1175 spin_unlock_irqrestore(&sc->lock, flags);
1176
35f436c3
RC		 1177 /* Return 0, so hidraw can get the report. */
1178 return 0;
f2f47c38
RC		 1179 } else if (dongle_state == DONGLE_CALIBRATING ||
1180 dongle_state == DONGLE_DISABLED ||
1181 dongle_state == DONGLE_DISCONNECTED) {
35f436c3
RC		 1182 /* Return 0, so hidraw can get the report. */
1183 return 0;
405182c2
RC		 1184 }
1185
d902f472 1186 dualshock4_parse_report(sc, rd, size);
c9e4d877
SW		 1187 }
1188
2a242932
FP		 1189 if (sc->defer_initialization) {
1190 sc->defer_initialization = 0;
b5322736 1191 sony_schedule_work(sc, SONY_WORKER_STATE);
2a242932
FP		 1192 }
1193
c9e4d877
SW		 1194 return 0;
1195}
1196
f04d5140
CL		 1197static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1198 struct hid_field *field, struct hid_usage *usage,
1199 unsigned long **bit, int *max)
1200{
1201 struct sony_sc *sc = hid_get_drvdata(hdev);
1202
1203 if (sc->quirks & BUZZ_CONTROLLER) {
1204 unsigned int key = usage->hid & HID_USAGE;
1205
1206 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1207 return -1;
1208
1209 switch (usage->collection_index) {
1210 case 1:
1211 if (key >= ARRAY_SIZE(buzz_keymap))
1212 return -1;
1213
1214 key = buzz_keymap[key];
1215 if (!key)
1216 return -1;
1217 break;
1218 default:
1219 return -1;
1220 }
1221
1222 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1223 return 1;
1224 }
1225
078328da
JK		 1226 if (sc->quirks & PS3REMOTE)
1227 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1228
b8f0970d
RC		 1229 if (sc->quirks & NAVIGATION_CONTROLLER)
1230 return navigation_mapping(hdev, hi, field, usage, bit, max);
1231
e19a267b
RC		 1232 if (sc->quirks & SIXAXIS_CONTROLLER)
1233 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
9131f8cc
RC		 1234
1235 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1236 return ds4_mapping(hdev, hi, field, usage, bit, max);
1237
e19a267b 1238
6f498018
BT		 1239 /* Let hid-core decide for the others */
1240 return 0;
f04d5140
CL		 1241}
1242
ac797b95 1243static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
ce8efc3b
FP		 1244 int w, int h)
1245{
ac797b95
RC		 1246 size_t name_sz;
1247 char *name;
ce8efc3b
FP		 1248 int ret;
1249
ac797b95
RC		 1250 sc->touchpad = input_allocate_device();
1251 if (!sc->touchpad)
1252 return -ENOMEM;
1253
1254 input_set_drvdata(sc->touchpad, sc);
1255 sc->touchpad->dev.parent = &sc->hdev->dev;
1256 sc->touchpad->phys = sc->hdev->phys;
1257 sc->touchpad->uniq = sc->hdev->uniq;
1258 sc->touchpad->id.bustype = sc->hdev->bus;
1259 sc->touchpad->id.vendor = sc->hdev->vendor;
1260 sc->touchpad->id.product = sc->hdev->product;
1261 sc->touchpad->id.version = sc->hdev->version;
1262
1263 /* Append a suffix to the controller name as there are various
1264 * DS4 compatible non-Sony devices with different names.
1265 */
1266 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1267 name = kzalloc(name_sz, GFP_KERNEL);
1268 if (!name) {
1269 ret = -ENOMEM;
1270 goto err;
1271 }
1272 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1273 sc->touchpad->name = name;
1274
b9f7d245 1275 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
ce8efc3b 1276 if (ret < 0)
ac797b95
RC		 1277 goto err;
1278
1279 /* We map the button underneath the touchpad to BTN_LEFT. */
1280 __set_bit(EV_KEY, sc->touchpad->evbit);
1281 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1282 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
ce8efc3b 1283
ac797b95
RC		 1284 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1285 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1286
1287 ret = input_register_device(sc->touchpad);
1288 if (ret < 0)
1289 goto err;
ce8efc3b
FP		 1290
1291 return 0;
ac797b95
RC		 1292
1293err:
1294 kfree(sc->touchpad->name);
1295 sc->touchpad->name = NULL;
1296
1297 input_free_device(sc->touchpad);
1298 sc->touchpad = NULL;
1299
1300 return ret;
ce8efc3b
FP		 1301}
1302
ac797b95
RC		 1303static void sony_unregister_touchpad(struct sony_sc *sc)
1304{
1305 if (!sc->touchpad)
1306 return;
1307
1308 kfree(sc->touchpad->name);
1309 sc->touchpad->name = NULL;
1310
1311 input_unregister_device(sc->touchpad);
1312 sc->touchpad = NULL;
1313}
ce8efc3b 1314
227c011b
RC		 1315static int sony_register_sensors(struct sony_sc *sc)
1316{
1317 size_t name_sz;
1318 char *name;
1319 int ret;
55a07d62 1320 int range;
227c011b
RC		 1321
1322 sc->sensor_dev = input_allocate_device();
1323 if (!sc->sensor_dev)
1324 return -ENOMEM;
1325
1326 input_set_drvdata(sc->sensor_dev, sc);
1327 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1328 sc->sensor_dev->phys = sc->hdev->phys;
1329 sc->sensor_dev->uniq = sc->hdev->uniq;
1330 sc->sensor_dev->id.bustype = sc->hdev->bus;
1331 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1332 sc->sensor_dev->id.product = sc->hdev->product;
1333 sc->sensor_dev->id.version = sc->hdev->version;
1334
1335 /* Append a suffix to the controller name as there are various
1336 * DS4 compatible non-Sony devices with different names.
1337 */
510c8b7c 1338 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
227c011b
RC		 1339 name = kzalloc(name_sz, GFP_KERNEL);
1340 if (!name) {
1341 ret = -ENOMEM;
1342 goto err;
1343 }
510c8b7c 1344 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
227c011b
RC		 1345 sc->sensor_dev->name = name;
1346
510c8b7c
RC		 1347 if (sc->quirks & SIXAXIS_CONTROLLER) {
1348 /* For the DS3 we only support the accelerometer, which works
1349 * quite well even without calibration. The device also has
1350 * a 1-axis gyro, but it is very difficult to manage from within
1351 * the driver even to get data, the sensor is inaccurate and
1352 * the behavior is very different between hardware revisions.
1353 */
1354 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1355 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1356 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1357 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1358 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1359 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1360 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1361 range = DS4_ACC_RES_PER_G*4;
1362 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1363 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1364 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1365 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1366 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1367 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1368
1369 range = DS4_GYRO_RES_PER_DEG_S*2048;
1370 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1371 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1372 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1373 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1374 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1375 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1376
1377 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1378 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1379 }
1380
227c011b
RC		 1381 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1382
1383 ret = input_register_device(sc->sensor_dev);
1384 if (ret < 0)
1385 goto err;
1386
1387 return 0;
1388
1389err:
1390 kfree(sc->sensor_dev->name);
1391 sc->sensor_dev->name = NULL;
1392
1393 input_free_device(sc->sensor_dev);
1394 sc->sensor_dev = NULL;
1395
1396 return ret;
1397}
1398
1399static void sony_unregister_sensors(struct sony_sc *sc)
1400{
1401 if (!sc->sensor_dev)
1402 return;
1403
1404 kfree(sc->sensor_dev->name);
1405 sc->sensor_dev->name = NULL;
1406
1407 input_unregister_device(sc->sensor_dev);
1408 sc->sensor_dev = NULL;
1409}
1410
1411
bd28ce00
JS		 1412/*
1413 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1414 * to "operational". Without this, the ps3 controller will not report any
1415 * events.
1416 */
816651a7 1417static int sixaxis_set_operational_usb(struct hid_device *hdev)
bd28ce00 1418{
a85d67b5
AO		 1419 const int buf_size =
1420 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1adf904e 1421 u8 *buf;
bd28ce00 1422 int ret;
bd28ce00 1423
2e701a35 1424 buf = kmalloc(buf_size, GFP_KERNEL);
bd28ce00
JS		 1425 if (!buf)
1426 return -ENOMEM;
1427
a85d67b5
AO		 1428 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1429 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1430 if (ret < 0) {
1431 hid_err(hdev, "can't set operational mode: step 1\n");
1432 goto out;
1433 }
f204828a 1434
a7de9b86
LK		 1435 /*
1436 * Some compatible controllers like the Speedlink Strike FX and
1437 * Gasia need another query plus an USB interrupt to get operational.
1438 */
a85d67b5
AO		 1439 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1440 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
a7de9b86
LK		 1441 if (ret < 0) {
1442 hid_err(hdev, "can't set operational mode: step 2\n");
1443 goto out;
1444 }
f204828a 1445
492ca83c
BN		 1446 /*
1447 * But the USB interrupt would cause SHANWAN controllers to
1448 * start rumbling non-stop.
1449 */
1450 if (strcmp(hdev->name, "SHANWAN PS3 GamePad")) {
1451 ret = hid_hw_output_report(hdev, buf, 1);
1452 if (ret < 0) {
1453 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1454 ret = 0;
1455 }
19f4c2ba 1456 }
bd28ce00 1457
a7de9b86 1458out:
bd28ce00
JS		 1459 kfree(buf);
1460
1461 return ret;
1462}
1463
816651a7 1464static int sixaxis_set_operational_bt(struct hid_device *hdev)
f9ce7c28 1465{
1adf904e
PM		 1466 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1467 u8 *buf;
9b2b5c9a
FP		 1468 int ret;
1469
1470 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1471 if (!buf)
1472 return -ENOMEM;
1473
1474 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
b0dd72aa 1475 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
9b2b5c9a
FP		 1476
1477 kfree(buf);
1478
1479 return ret;
f9ce7c28
BN		 1480}
1481
ad142b9e 1482/*
55a07d62
RC		 1483 * Request DS4 calibration data for the motion sensors.
1484 * For Bluetooth this also affects the operating mode (see below).
68330d83 1485 */
55a07d62 1486static int dualshock4_get_calibration_data(struct sony_sc *sc)
68330d83 1487{
1adf904e 1488 u8 *buf;
9b2b5c9a 1489 int ret;
55a07d62
RC		 1490 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1491 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1492 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1493 short gyro_speed_plus, gyro_speed_minus;
1494 short acc_x_plus, acc_x_minus;
1495 short acc_y_plus, acc_y_minus;
1496 short acc_z_plus, acc_z_minus;
1497 int speed_2x;
1498 int range_2g;
1499
1500 /* For Bluetooth we use a different request, which supports CRC.
1501 * Note: in Bluetooth mode feature report 0x02 also changes the state
1502 * of the controller, so that it sends input reports of type 0x11.
1503 */
35f436c3 1504 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
55a07d62
RC		 1505 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1506 if (!buf)
1507 return -ENOMEM;
68330d83 1508
55a07d62
RC		 1509 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1510 DS4_FEATURE_REPORT_0x02_SIZE,
1511 HID_FEATURE_REPORT,
1512 HID_REQ_GET_REPORT);
1513 if (ret < 0)
1514 goto err_stop;
1515 } else {
1516 u8 bthdr = 0xA3;
1517 u32 crc;
1518 u32 report_crc;
1519 int retries;
9b2b5c9a 1520
55a07d62
RC		 1521 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1522 if (!buf)
1523 return -ENOMEM;
9b2b5c9a 1524
55a07d62
RC		 1525 for (retries = 0; retries < 3; retries++) {
1526 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1527 DS4_FEATURE_REPORT_0x05_SIZE,
1528 HID_FEATURE_REPORT,
1529 HID_REQ_GET_REPORT);
1530 if (ret < 0)
1531 goto err_stop;
9b2b5c9a 1532
55a07d62
RC		 1533 /* CRC check */
1534 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1535 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1536 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1537 if (crc != report_crc) {
1538 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1539 report_crc, crc);
1540 if (retries < 2) {
1541 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1542 continue;
1543 } else {
1544 ret = -EILSEQ;
1545 goto err_stop;
1546 }
1547 } else {
1548 break;
1549 }
1550 }
1551 }
9b2b5c9a 1552
55a07d62
RC		 1553 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1554 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1555 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1556 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1557 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1558 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1559 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1560 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1561 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1562 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1563 } else {
35f436c3 1564 /* BT + Dongle */
55a07d62
RC		 1565 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1566 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1567 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1568 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1569 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1570 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1571 }
1572 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1573 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1574 acc_x_plus = get_unaligned_le16(&buf[23]);
1575 acc_x_minus = get_unaligned_le16(&buf[25]);
1576 acc_y_plus = get_unaligned_le16(&buf[27]);
1577 acc_y_minus = get_unaligned_le16(&buf[29]);
1578 acc_z_plus = get_unaligned_le16(&buf[31]);
1579 acc_z_minus = get_unaligned_le16(&buf[33]);
1580
1581 /* Set gyroscope calibration and normalization parameters.
1582 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1583 */
1584 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1585 sc->ds4_calib_data[0].abs_code = ABS_RX;
1586 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1587 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1588 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1589
1590 sc->ds4_calib_data[1].abs_code = ABS_RY;
1591 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1592 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1593 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1594
1595 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1596 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1597 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1598 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1599
1600 /* Set accelerometer calibration and normalization parameters.
1601 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1602 */
1603 range_2g = acc_x_plus - acc_x_minus;
1604 sc->ds4_calib_data[3].abs_code = ABS_X;
1605 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1606 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1607 sc->ds4_calib_data[3].sens_denom = range_2g;
1608
1609 range_2g = acc_y_plus - acc_y_minus;
1610 sc->ds4_calib_data[4].abs_code = ABS_Y;
1611 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1612 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1613 sc->ds4_calib_data[4].sens_denom = range_2g;
1614
1615 range_2g = acc_z_plus - acc_z_minus;
1616 sc->ds4_calib_data[5].abs_code = ABS_Z;
1617 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1618 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1619 sc->ds4_calib_data[5].sens_denom = range_2g;
1620
1621err_stop:
1622 kfree(buf);
9b2b5c9a 1623 return ret;
f9ce7c28
BN		 1624}
1625
f2f47c38
RC		 1626static void dualshock4_calibration_work(struct work_struct *work)
1627{
1628 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1629 unsigned long flags;
1630 enum ds4_dongle_state dongle_state;
1631 int ret;
1632
1633 ret = dualshock4_get_calibration_data(sc);
1634 if (ret < 0) {
1635 /* This call is very unlikely to fail for the dongle. When it
1636 * fails we are probably in a very bad state, so mark the
1637 * dongle as disabled. We will re-enable the dongle if a new
1638 * DS4 hotplug is detect from sony_raw_event as any issues
1639 * are likely resolved then (the dongle is quite stupid).
1640 */
1641 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1642 dongle_state = DONGLE_DISABLED;
1643 } else {
1644 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1645 dongle_state = DONGLE_CONNECTED;
1646 }
1647
1648 spin_lock_irqsave(&sc->lock, flags);
1649 sc->ds4_dongle_state = dongle_state;
1650 spin_unlock_irqrestore(&sc->lock, flags);
1651}
1652
221399b3 1653static void sixaxis_set_leds_from_id(struct sony_sc *sc)
8025087a 1654{
1adf904e 1655 static const u8 sixaxis_leds[10][4] = {
8025087a
FP		 1656 { 0x01, 0x00, 0x00, 0x00 },
1657 { 0x00, 0x01, 0x00, 0x00 },
1658 { 0x00, 0x00, 0x01, 0x00 },
1659 { 0x00, 0x00, 0x00, 0x01 },
1660 { 0x01, 0x00, 0x00, 0x01 },
1661 { 0x00, 0x01, 0x00, 0x01 },
1662 { 0x00, 0x00, 0x01, 0x01 },
1663 { 0x01, 0x00, 0x01, 0x01 },
1664 { 0x00, 0x01, 0x01, 0x01 },
1665 { 0x01, 0x01, 0x01, 0x01 }
1666 };
1667
221399b3
FP		 1668 int id = sc->device_id;
1669
1670 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
8025087a
FP		 1671
1672 if (id < 0)
1673 return;
1674
1675 id %= 10;
221399b3 1676 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
8025087a
FP		 1677}
1678
221399b3 1679static void dualshock4_set_leds_from_id(struct sony_sc *sc)
8025087a
FP		 1680{
1681 /* The first 4 color/index entries match what the PS4 assigns */
1adf904e 1682 static const u8 color_code[7][3] = {
39254a13
RC		 1683 /* Blue */ { 0x00, 0x00, 0x40 },
1684 /* Red */ { 0x40, 0x00, 0x00 },
1685 /* Green */ { 0x00, 0x40, 0x00 },
1686 /* Pink */ { 0x20, 0x00, 0x20 },
8025087a
FP		 1687 /* Orange */ { 0x02, 0x01, 0x00 },
1688 /* Teal */ { 0x00, 0x01, 0x01 },
1689 /* White */ { 0x01, 0x01, 0x01 }
1690 };
1691
221399b3
FP		 1692 int id = sc->device_id;
1693
1694 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
8025087a
FP		 1695
1696 if (id < 0)
1697 return;
1698
1699 id %= 7;
221399b3 1700 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
8025087a
FP		 1701}
1702
221399b3 1703static void buzz_set_leds(struct sony_sc *sc)
f04d5140 1704{
221399b3 1705 struct hid_device *hdev = sc->hdev;
f04d5140
CL		 1706 struct list_head *report_list =
1707 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1708 struct hid_report *report = list_entry(report_list->next,
1709 struct hid_report, list);
1adf904e 1710 s32 *value = report->field[0]->value;
f04d5140 1711
221399b3
FP		 1712 BUILD_BUG_ON(MAX_LEDS < 4);
1713
f04d5140 1714 value[0] = 0x00;
221399b3
FP		 1715 value[1] = sc->led_state[0] ? 0xff : 0x00;
1716 value[2] = sc->led_state[1] ? 0xff : 0x00;
1717 value[3] = sc->led_state[2] ? 0xff : 0x00;
1718 value[4] = sc->led_state[3] ? 0xff : 0x00;
f04d5140
CL		 1719 value[5] = 0x00;
1720 value[6] = 0x00;
1721 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1722}
1723
221399b3 1724static void sony_set_leds(struct sony_sc *sc)
0a286ef2 1725{
221399b3 1726 if (!(sc->quirks & BUZZ_CONTROLLER))
b5322736 1727 sony_schedule_work(sc, SONY_WORKER_STATE);
221399b3
FP		 1728 else
1729 buzz_set_leds(sc);
0a286ef2
SE		 1730}
1731
c5382519 1732static void sony_led_set_brightness(struct led_classdev *led,
f04d5140
CL		 1733 enum led_brightness value)
1734{
1735 struct device *dev = led->dev->parent;
ee79a8f8 1736 struct hid_device *hdev = to_hid_device(dev);
f04d5140 1737 struct sony_sc *drv_data;
f04d5140
CL		 1738
1739 int n;
b3ed458c 1740 int force_update;
f04d5140
CL		 1741
1742 drv_data = hid_get_drvdata(hdev);
2251b85f 1743 if (!drv_data) {
f04d5140
CL		 1744 hid_err(hdev, "No device data\n");
1745 return;
1746 }
f04d5140 1747
b3ed458c
FP		 1748 /*
1749 * The Sixaxis on USB will override any LED settings sent to it
1750 * and keep flashing all of the LEDs until the PS button is pressed.
1751 * Updates, even if redundant, must be always be sent to the
1752 * controller to avoid having to toggle the state of an LED just to
1753 * stop the flashing later on.
1754 */
1755 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
1756
60781cf4 1757 for (n = 0; n < drv_data->led_count; n++) {
b3ed458c
FP		 1758 if (led == drv_data->leds[n] && (force_update ||
1759 (value != drv_data->led_state[n] ||
1760 drv_data->led_delay_on[n] ||
1761 drv_data->led_delay_off[n]))) {
1762
1763 drv_data->led_state[n] = value;
1764
1765 /* Setting the brightness stops the blinking */
1766 drv_data->led_delay_on[n] = 0;
1767 drv_data->led_delay_off[n] = 0;
1768
221399b3 1769 sony_set_leds(drv_data);
f04d5140
CL		 1770 break;
1771 }
1772 }
1773}
1774
c5382519 1775static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
f04d5140
CL		 1776{
1777 struct device *dev = led->dev->parent;
ee79a8f8 1778 struct hid_device *hdev = to_hid_device(dev);
f04d5140 1779 struct sony_sc *drv_data;
f04d5140
CL		 1780
1781 int n;
f04d5140
CL		 1782
1783 drv_data = hid_get_drvdata(hdev);
2251b85f 1784 if (!drv_data) {
f04d5140
CL		 1785 hid_err(hdev, "No device data\n");
1786 return LED_OFF;
1787 }
f04d5140 1788
60781cf4 1789 for (n = 0; n < drv_data->led_count; n++) {
7db7504a
SW		 1790 if (led == drv_data->leds[n])
1791 return drv_data->led_state[n];
f04d5140
CL		 1792 }
1793
7db7504a 1794 return LED_OFF;
f04d5140 1795}
f04d5140 1796
b3ed458c
FP		 1797static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
1798 unsigned long *delay_off)
1799{
1800 struct device *dev = led->dev->parent;
ee79a8f8 1801 struct hid_device *hdev = to_hid_device(dev);
b3ed458c
FP		 1802 struct sony_sc *drv_data = hid_get_drvdata(hdev);
1803 int n;
1adf904e 1804 u8 new_on, new_off;
b3ed458c
FP		 1805
1806 if (!drv_data) {
1807 hid_err(hdev, "No device data\n");
1808 return -EINVAL;
1809 }
1810
1811 /* Max delay is 255 deciseconds or 2550 milliseconds */
1812 if (*delay_on > 2550)
1813 *delay_on = 2550;
1814 if (*delay_off > 2550)
1815 *delay_off = 2550;
1816
1817 /* Blink at 1 Hz if both values are zero */
1818 if (!*delay_on && !*delay_off)
1819 *delay_on = *delay_off = 500;
1820
1821 new_on = *delay_on / 10;
1822 new_off = *delay_off / 10;
1823
1824 for (n = 0; n < drv_data->led_count; n++) {
1825 if (led == drv_data->leds[n])
1826 break;
1827 }
1828
1829 /* This LED is not registered on this device */
1830 if (n >= drv_data->led_count)
1831 return -EINVAL;
1832
1833 /* Don't schedule work if the values didn't change */
1834 if (new_on != drv_data->led_delay_on[n] ||
1835 new_off != drv_data->led_delay_off[n]) {
1836 drv_data->led_delay_on[n] = new_on;
1837 drv_data->led_delay_off[n] = new_off;
b5322736 1838 sony_schedule_work(drv_data, SONY_WORKER_STATE);
b3ed458c
FP		 1839 }
1840
1841 return 0;
1842}
1843
fa57a810 1844static void sony_leds_remove(struct sony_sc *sc)
0a286ef2 1845{
0a286ef2
SE		 1846 struct led_classdev *led;
1847 int n;
1848
fa57a810 1849 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1850
fa57a810
FP		 1851 for (n = 0; n < sc->led_count; n++) {
1852 led = sc->leds[n];
1853 sc->leds[n] = NULL;
0a286ef2
SE		 1854 if (!led)
1855 continue;
1856 led_classdev_unregister(led);
1857 kfree(led);
1858 }
60781cf4 1859
fa57a810 1860 sc->led_count = 0;
0a286ef2
SE		 1861}
1862
fa57a810 1863static int sony_leds_init(struct sony_sc *sc)
f04d5140 1864{
fa57a810 1865 struct hid_device *hdev = sc->hdev;
40e32ee6 1866 int n, ret = 0;
b3ed458c 1867 int use_ds4_names;
40e32ee6
JK		 1868 struct led_classdev *led;
1869 size_t name_sz;
1870 char *name;
0a286ef2
SE		 1871 size_t name_len;
1872 const char *name_fmt;
b3ed458c
FP		 1873 static const char * const ds4_name_str[] = { "red", "green", "blue",
1874 "global" };
1adf904e
PM		 1875 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
1876 u8 use_hw_blink[MAX_LEDS] = { 0 };
f04d5140 1877
fa57a810 1878 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
0a286ef2 1879
fa57a810
FP		 1880 if (sc->quirks & BUZZ_CONTROLLER) {
1881 sc->led_count = 4;
b3ed458c 1882 use_ds4_names = 0;
0a286ef2
SE		 1883 name_len = strlen("::buzz#");
1884 name_fmt = "%s::buzz%d";
1885 /* Validate expected report characteristics. */
1886 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
1887 return -ENODEV;
fa57a810 1888 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
221399b3
FP		 1889 dualshock4_set_leds_from_id(sc);
1890 sc->led_state[3] = 1;
b3ed458c
FP		 1891 sc->led_count = 4;
1892 memset(max_brightness, 255, 3);
1893 use_hw_blink[3] = 1;
1894 use_ds4_names = 1;
61ebca93
FP		 1895 name_len = 0;
1896 name_fmt = "%s:%s";
c5e0c1c4
FP		 1897 } else if (sc->quirks & MOTION_CONTROLLER) {
1898 sc->led_count = 3;
1899 memset(max_brightness, 255, 3);
1900 use_ds4_names = 1;
1901 name_len = 0;
1902 name_fmt = "%s:%s";
4545ee0a 1903 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
1adf904e 1904 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
4545ee0a
SW		 1905
1906 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
1907 sc->led_count = 1;
1908 memset(use_hw_blink, 1, 4);
1909 use_ds4_names = 0;
1910 name_len = strlen("::sony#");
1911 name_fmt = "%s::sony%d";
60781cf4 1912 } else {
221399b3 1913 sixaxis_set_leds_from_id(sc);
fa57a810 1914 sc->led_count = 4;
b3ed458c
FP		 1915 memset(use_hw_blink, 1, 4);
1916 use_ds4_names = 0;
61ebca93
FP		 1917 name_len = strlen("::sony#");
1918 name_fmt = "%s::sony%d";
60781cf4
FP		 1919 }
1920
ad142b9e
FP		 1921 /*
1922 * Clear LEDs as we have no way of reading their initial state. This is
f04d5140 1923 * only relevant if the driver is loaded after somebody actively set the
ad142b9e
FP		 1924 * LEDs to on
1925 */
221399b3 1926 sony_set_leds(sc);
f04d5140 1927
0a286ef2 1928 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
f04d5140 1929
fa57a810 1930 for (n = 0; n < sc->led_count; n++) {
61ebca93 1931
b3ed458c
FP		 1932 if (use_ds4_names)
1933 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
61ebca93 1934
40e32ee6
JK		 1935 led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
1936 if (!led) {
1937 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
8cd5fcda 1938 ret = -ENOMEM;
40e32ee6
JK		 1939 goto error_leds;
1940 }
f04d5140 1941
40e32ee6 1942 name = (void *)(&led[1]);
b3ed458c
FP		 1943 if (use_ds4_names)
1944 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
1945 ds4_name_str[n]);
61ebca93
FP		 1946 else
1947 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
40e32ee6 1948 led->name = name;
221399b3 1949 led->brightness = sc->led_state[n];
b3ed458c 1950 led->max_brightness = max_brightness[n];
765a1077 1951 led->flags = LED_CORE_SUSPENDRESUME;
c5382519
SE		 1952 led->brightness_get = sony_led_get_brightness;
1953 led->brightness_set = sony_led_set_brightness;
f04d5140 1954
b3ed458c
FP		 1955 if (use_hw_blink[n])
1956 led->blink_set = sony_led_blink_set;
1957
8025087a
FP		 1958 sc->leds[n] = led;
1959
8cd5fcda
JL		 1960 ret = led_classdev_register(&hdev->dev, led);
1961 if (ret) {
40e32ee6 1962 hid_err(hdev, "Failed to register LED %d\n", n);
8025087a 1963 sc->leds[n] = NULL;
40e32ee6
JK		 1964 kfree(led);
1965 goto error_leds;
f04d5140
CL		 1966 }
1967 }
f04d5140
CL		 1968
1969 return ret;
1970
f04d5140 1971error_leds:
fa57a810 1972 sony_leds_remove(sc);
f04d5140 1973
f04d5140 1974 return ret;
f04d5140
CL		 1975}
1976
d8aaccda 1977static void sixaxis_send_output_report(struct sony_sc *sc)
a08c22c0 1978{
9b2b5c9a 1979 static const union sixaxis_output_report_01 default_report = {
55d3b664
FP		 1980 .buf = {
1981 0x01,
ad07b7a6 1982 0x01, 0xff, 0x00, 0xff, 0x00,
55d3b664
FP		 1983 0x00, 0x00, 0x00, 0x00, 0x00,
1984 0xff, 0x27, 0x10, 0x00, 0x32,
1985 0xff, 0x27, 0x10, 0x00, 0x32,
1986 0xff, 0x27, 0x10, 0x00, 0x32,
1987 0xff, 0x27, 0x10, 0x00, 0x32,
1988 0x00, 0x00, 0x00, 0x00, 0x00
1989 }
a08c22c0 1990 };
9b2b5c9a
FP		 1991 struct sixaxis_output_report *report =
1992 (struct sixaxis_output_report *)sc->output_report_dmabuf;
1993 int n;
1994
1995 /* Initialize the report with default values */
1996 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
9f323b68 1997
0a286ef2 1998#ifdef CONFIG_SONY_FF
9b2b5c9a
FP		 1999 report->rumble.right_motor_on = sc->right ? 1 : 0;
2000 report->rumble.left_motor_force = sc->left;
0a286ef2
SE		 2001#endif
2002
9b2b5c9a
FP		 2003 report->leds_bitmap |= sc->led_state[0] << 1;
2004 report->leds_bitmap |= sc->led_state[1] << 2;
2005 report->leds_bitmap |= sc->led_state[2] << 3;
2006 report->leds_bitmap |= sc->led_state[3] << 4;
9f323b68 2007
88f6576f 2008 /* Set flag for all leds off, required for 3rd party INTEC controller */
9b2b5c9a
FP		 2009 if ((report->leds_bitmap & 0x1E) == 0)
2010 report->leds_bitmap |= 0x20;
88f6576f 2011
b3ed458c
FP		 2012 /*
2013 * The LEDs in the report are indexed in reverse order to their
2014 * corresponding light on the controller.
2015 * Index 0 = LED 4, index 1 = LED 3, etc...
2016 *
2017 * In the case of both delay values being zero (blinking disabled) the
2018 * default report values should be used or the controller LED will be
2019 * always off.
2020 */
2021 for (n = 0; n < 4; n++) {
2022 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
9b2b5c9a
FP		 2023 report->led[3 - n].duty_off = sc->led_delay_off[n];
2024 report->led[3 - n].duty_on = sc->led_delay_on[n];
b3ed458c
FP		 2025 }
2026 }
2027
1adf904e 2028 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
9b2b5c9a
FP		 2029 sizeof(struct sixaxis_output_report),
2030 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
9f323b68
SE		 2031}
2032
d8aaccda 2033static void dualshock4_send_output_report(struct sony_sc *sc)
0bd88dd3 2034{
0da8ea65 2035 struct hid_device *hdev = sc->hdev;
1adf904e 2036 u8 *buf = sc->output_report_dmabuf;
48220237
FP		 2037 int offset;
2038
c4425c8f 2039 /*
77b499e7
RC		 2040 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2041 * control the interval at which Dualshock 4 reports data:
2042 * 0x00 - 1ms
2043 * 0x01 - 1ms
2044 * 0x02 - 2ms
2045 * 0x3E - 62ms
2046 * 0x3F - disabled
c4425c8f 2047 */
35f436c3 2048 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2c159de0 2049 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
fdcf105d 2050 buf[0] = 0x05;
5caceb06 2051 buf[1] = 0x07; /* blink + LEDs + motor */
fdcf105d
FP		 2052 offset = 4;
2053 } else {
2c159de0 2054 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
fdcf105d 2055 buf[0] = 0x11;
77b499e7 2056 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
5caceb06 2057 buf[3] = 0x07; /* blink + LEDs + motor */
fdcf105d
FP		 2058 offset = 6;
2059 }
0bd88dd3
FP		 2060
2061#ifdef CONFIG_SONY_FF
48220237
FP		 2062 buf[offset++] = sc->right;
2063 buf[offset++] = sc->left;
2064#else
2065 offset += 2;
0bd88dd3
FP		 2066#endif
2067
b3ed458c
FP		 2068 /* LED 3 is the global control */
2069 if (sc->led_state[3]) {
2070 buf[offset++] = sc->led_state[0];
2071 buf[offset++] = sc->led_state[1];
2072 buf[offset++] = sc->led_state[2];
2073 } else {
2074 offset += 3;
2075 }
2076
2077 /* If both delay values are zero the DualShock 4 disables blinking. */
2078 buf[offset++] = sc->led_delay_on[3];
2079 buf[offset++] = sc->led_delay_off[3];
60781cf4 2080
35f436c3 2081 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2c159de0 2082 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
e7ef53ad
RC		 2083 else {
2084 /* CRC generation */
2085 u8 bthdr = 0xA2;
2086 u32 crc;
2087
2088 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2089 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2090 put_unaligned_le32(crc, &buf[74]);
2091 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2092 }
0bd88dd3
FP		 2093}
2094
d8aaccda 2095static void motion_send_output_report(struct sony_sc *sc)
c5e0c1c4 2096{
c5e0c1c4
FP		 2097 struct hid_device *hdev = sc->hdev;
2098 struct motion_output_report_02 *report =
2099 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2100
41d2d425 2101 memset(report, 0, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 2102
2103 report->type = 0x02; /* set leds */
2104 report->r = sc->led_state[0];
2105 report->g = sc->led_state[1];
2106 report->b = sc->led_state[2];
2107
2108#ifdef CONFIG_SONY_FF
2109 report->rumble = max(sc->right, sc->left);
2110#endif
2111
1adf904e 2112 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
c5e0c1c4
FP		 2113}
2114
decd946c
FP		 2115static inline void sony_send_output_report(struct sony_sc *sc)
2116{
2117 if (sc->send_output_report)
2118 sc->send_output_report(sc);
2119}
2120
d8aaccda
FP		 2121static void sony_state_worker(struct work_struct *work)
2122{
2123 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
ef916ef5 2124
d8aaccda
FP		 2125 sc->send_output_report(sc);
2126}
2127
9b2b5c9a
FP		 2128static int sony_allocate_output_report(struct sony_sc *sc)
2129{
4545ee0a
SW		 2130 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2131 (sc->quirks & NAVIGATION_CONTROLLER))
9b2b5c9a
FP		 2132 sc->output_report_dmabuf =
2133 kmalloc(sizeof(union sixaxis_output_report_01),
2134 GFP_KERNEL);
2135 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2c159de0 2136 sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x11_SIZE,
9b2b5c9a 2137 GFP_KERNEL);
35f436c3 2138 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2c159de0 2139 sc->output_report_dmabuf = kmalloc(DS4_OUTPUT_REPORT_0x05_SIZE,
9b2b5c9a 2140 GFP_KERNEL);
c5e0c1c4 2141 else if (sc->quirks & MOTION_CONTROLLER)
41d2d425
SW		 2142 sc->output_report_dmabuf = kmalloc(MOTION_REPORT_0x02_SIZE,
2143 GFP_KERNEL);
9b2b5c9a
FP		 2144 else
2145 return 0;
2146
2147 if (!sc->output_report_dmabuf)
2148 return -ENOMEM;
2149
2150 return 0;
2151}
2152
0a286ef2 2153#ifdef CONFIG_SONY_FF
9f323b68
SE		 2154static int sony_play_effect(struct input_dev *dev, void *data,
2155 struct ff_effect *effect)
2156{
a08c22c0 2157 struct hid_device *hid = input_get_drvdata(dev);
9f323b68 2158 struct sony_sc *sc = hid_get_drvdata(hid);
a08c22c0
SE		 2159
2160 if (effect->type != FF_RUMBLE)
2161 return 0;
2162
9f323b68 2163 sc->left = effect->u.rumble.strong_magnitude / 256;
0bd88dd3 2164 sc->right = effect->u.rumble.weak_magnitude / 256;
a08c22c0 2165
b5322736 2166 sony_schedule_work(sc, SONY_WORKER_STATE);
9f323b68 2167 return 0;
a08c22c0
SE		 2168}
2169
fa57a810 2170static int sony_init_ff(struct sony_sc *sc)
a08c22c0 2171{
29d944cd
AS		 2172 struct hid_input *hidinput;
2173 struct input_dev *input_dev;
2174
2175 if (list_empty(&sc->hdev->inputs)) {
2176 hid_err(sc->hdev, "no inputs found\n");
2177 return -ENODEV;
2178 }
2179 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2180 input_dev = hidinput->input;
a08c22c0
SE		 2181
2182 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2183 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2184}
2185
2186#else
fa57a810 2187static int sony_init_ff(struct sony_sc *sc)
a08c22c0
SE		 2188{
2189 return 0;
2190}
9f323b68 2191
a08c22c0
SE		 2192#endif
2193
d902f472
FP		 2194static int sony_battery_get_property(struct power_supply *psy,
2195 enum power_supply_property psp,
2196 union power_supply_propval *val)
2197{
297d716f 2198 struct sony_sc *sc = power_supply_get_drvdata(psy);
d902f472
FP		 2199 unsigned long flags;
2200 int ret = 0;
2201 u8 battery_charging, battery_capacity, cable_state;
2202
2203 spin_lock_irqsave(&sc->lock, flags);
2204 battery_charging = sc->battery_charging;
2205 battery_capacity = sc->battery_capacity;
2206 cable_state = sc->cable_state;
2207 spin_unlock_irqrestore(&sc->lock, flags);
2208
2209 switch (psp) {
2210 case POWER_SUPPLY_PROP_PRESENT:
2211 val->intval = 1;
2212 break;
2213 case POWER_SUPPLY_PROP_SCOPE:
2214 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2215 break;
2216 case POWER_SUPPLY_PROP_CAPACITY:
2217 val->intval = battery_capacity;
2218 break;
2219 case POWER_SUPPLY_PROP_STATUS:
2220 if (battery_charging)
2221 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2222 else
2223 if (battery_capacity == 100 && cable_state)
2224 val->intval = POWER_SUPPLY_STATUS_FULL;
2225 else
2226 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2227 break;
2228 default:
2229 ret = -EINVAL;
2230 break;
2231 }
2232 return ret;
9f323b68
SE		 2233}
2234
0f398230 2235static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
c4e1ddf2 2236{
0f398230
FP		 2237 const char *battery_str_fmt = append_dev_id ?
2238 "sony_controller_battery_%pMR_%i" :
2239 "sony_controller_battery_%pMR";
297d716f 2240 struct power_supply_config psy_cfg = { .drv_data = sc, };
c4e1ddf2 2241 struct hid_device *hdev = sc->hdev;
d902f472 2242 int ret;
c4e1ddf2 2243
ad142b9e
FP		 2244 /*
2245 * Set the default battery level to 100% to avoid low battery warnings
d9a293a9
FP		 2246 * if the battery is polled before the first device report is received.
2247 */
2248 sc->battery_capacity = 100;
2249
297d716f
KK		 2250 sc->battery_desc.properties = sony_battery_props;
2251 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2252 sc->battery_desc.get_property = sony_battery_get_property;
2253 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2254 sc->battery_desc.use_for_apm = 0;
0f398230
FP		 2255 sc->battery_desc.name = kasprintf(GFP_KERNEL, battery_str_fmt,
2256 sc->mac_address, sc->device_id);
297d716f 2257 if (!sc->battery_desc.name)
d902f472 2258 return -ENOMEM;
c4e1ddf2 2259
297d716f
KK		 2260 sc->battery = power_supply_register(&hdev->dev, &sc->battery_desc,
2261 &psy_cfg);
2262 if (IS_ERR(sc->battery)) {
2263 ret = PTR_ERR(sc->battery);
d902f472
FP		 2264 hid_err(hdev, "Unable to register battery device\n");
2265 goto err_free;
2266 }
c4e1ddf2 2267
297d716f 2268 power_supply_powers(sc->battery, &hdev->dev);
a08c22c0 2269 return 0;
d902f472
FP		 2270
2271err_free:
297d716f
KK		 2272 kfree(sc->battery_desc.name);
2273 sc->battery_desc.name = NULL;
d902f472 2274 return ret;
a08c22c0 2275}
9f323b68 2276
d902f472 2277static void sony_battery_remove(struct sony_sc *sc)
9f323b68 2278{
297d716f 2279 if (!sc->battery_desc.name)
d902f472
FP		 2280 return;
2281
297d716f
KK		 2282 power_supply_unregister(sc->battery);
2283 kfree(sc->battery_desc.name);
2284 sc->battery_desc.name = NULL;
9f323b68 2285}
a08c22c0 2286
d2d782fc
FP		 2287/*
2288 * If a controller is plugged in via USB while already connected via Bluetooth
2289 * it will show up as two devices. A global list of connected controllers and
2290 * their MAC addresses is maintained to ensure that a device is only connected
2291 * once.
0f398230
FP		 2292 *
2293 * Some USB-only devices masquerade as Sixaxis controllers and all have the
2294 * same dummy Bluetooth address, so a comparison of the connection type is
2295 * required. Devices are only rejected in the case where two devices have
2296 * matching Bluetooth addresses on different bus types.
d2d782fc 2297 */
0f398230
FP		 2298static inline int sony_compare_connection_type(struct sony_sc *sc0,
2299 struct sony_sc *sc1)
2300{
2301 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2302 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2303
2304 return sc0_not_bt == sc1_not_bt;
2305}
2306
d2d782fc
FP		 2307static int sony_check_add_dev_list(struct sony_sc *sc)
2308{
2309 struct sony_sc *entry;
2310 unsigned long flags;
2311 int ret;
2312
2313 spin_lock_irqsave(&sony_dev_list_lock, flags);
2314
2315 list_for_each_entry(entry, &sony_device_list, list_node) {
2316 ret = memcmp(sc->mac_address, entry->mac_address,
2317 sizeof(sc->mac_address));
2318 if (!ret) {
0f398230
FP		 2319 if (sony_compare_connection_type(sc, entry)) {
2320 ret = 1;
2321 } else {
2322 ret = -EEXIST;
2323 hid_info(sc->hdev,
2324 "controller with MAC address %pMR already connected\n",
d2d782fc 2325 sc->mac_address);
0f398230 2326 }
d2d782fc 2327 goto unlock;
c4e1ddf2
FP		 2328 }
2329 }
2330
d2d782fc
FP		 2331 ret = 0;
2332 list_add(&(sc->list_node), &sony_device_list);
c4e1ddf2 2333
d2d782fc
FP		 2334unlock:
2335 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2336 return ret;
2337}
2338
2339static void sony_remove_dev_list(struct sony_sc *sc)
2340{
2341 unsigned long flags;
c4e1ddf2 2342
d2d782fc
FP		 2343 if (sc->list_node.next) {
2344 spin_lock_irqsave(&sony_dev_list_lock, flags);
2345 list_del(&(sc->list_node));
2346 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2347 }
c4e1ddf2
FP		 2348}
2349
d2d782fc
FP		 2350static int sony_get_bt_devaddr(struct sony_sc *sc)
2351{
2352 int ret;
2353
2354 /* HIDP stores the device MAC address as a string in the uniq field. */
2355 ret = strlen(sc->hdev->uniq);
2356 if (ret != 17)
2357 return -EINVAL;
2358
2359 ret = sscanf(sc->hdev->uniq,
2360 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2361 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2362 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2363
2364 if (ret != 6)
2365 return -EINVAL;
2366
2367 return 0;
2368}
2369
2370static int sony_check_add(struct sony_sc *sc)
2371{
1adf904e 2372 u8 *buf = NULL;
d2d782fc
FP		 2373 int n, ret;
2374
2375 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
12e9a6d7 2376 (sc->quirks & MOTION_CONTROLLER_BT) ||
4545ee0a 2377 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
d2d782fc
FP		 2378 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2379 /*
2380 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2381 * address from the uniq string where HIDP stores it.
2382 * As uniq cannot be guaranteed to be a MAC address in all cases
2383 * a failure of this function should not prevent the connection.
2384 */
2385 if (sony_get_bt_devaddr(sc) < 0) {
2386 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2387 return 0;
2388 }
35f436c3 2389 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2c159de0 2390 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
9b2b5c9a
FP		 2391 if (!buf)
2392 return -ENOMEM;
d2d782fc
FP		 2393
2394 /*
2395 * The MAC address of a DS4 controller connected via USB can be
2396 * retrieved with feature report 0x81. The address begins at
2397 * offset 1.
2398 */
9b2b5c9a 2399 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2c159de0 2400 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
9b2b5c9a 2401 HID_REQ_GET_REPORT);
d2d782fc 2402
2c159de0 2403 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
d2d782fc 2404 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
9b2b5c9a
FP		 2405 ret = ret < 0 ? ret : -EINVAL;
2406 goto out_free;
d2d782fc
FP		 2407 }
2408
2409 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
c70d5f70
RC		 2410
2411 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2412 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2413 sc->mac_address[5], sc->mac_address[4],
2414 sc->mac_address[3], sc->mac_address[2],
2415 sc->mac_address[1], sc->mac_address[0]);
4545ee0a
SW		 2416 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2417 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
9b2b5c9a
FP		 2418 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2419 if (!buf)
2420 return -ENOMEM;
d2d782fc
FP		 2421
2422 /*
2423 * The MAC address of a Sixaxis controller connected via USB can
2424 * be retrieved with feature report 0xf2. The address begins at
2425 * offset 4.
2426 */
9b2b5c9a
FP		 2427 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2428 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2429 HID_REQ_GET_REPORT);
d2d782fc 2430
9b2b5c9a 2431 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
d2d782fc 2432 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
9b2b5c9a
FP		 2433 ret = ret < 0 ? ret : -EINVAL;
2434 goto out_free;
d2d782fc
FP		 2435 }
2436
2437 /*
2438 * The Sixaxis device MAC in the report is big-endian and must
2439 * be byte-swapped.
2440 */
2441 for (n = 0; n < 6; n++)
2442 sc->mac_address[5-n] = buf[4+n];
5a144be3
RC		 2443
2444 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2445 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2446 sc->mac_address[5], sc->mac_address[4],
2447 sc->mac_address[3], sc->mac_address[2],
2448 sc->mac_address[1], sc->mac_address[0]);
d2d782fc
FP		 2449 } else {
2450 return 0;
2451 }
2452
9b2b5c9a
FP		 2453 ret = sony_check_add_dev_list(sc);
2454
2455out_free:
2456
2457 kfree(buf);
2458
2459 return ret;
d2d782fc
FP		 2460}
2461
8025087a
FP		 2462static int sony_set_device_id(struct sony_sc *sc)
2463{
2464 int ret;
2465
2466 /*
2467 * Only DualShock 4 or Sixaxis controllers get an id.
2468 * All others are set to -1.
2469 */
2470 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2471 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2472 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2473 GFP_KERNEL);
2474 if (ret < 0) {
2475 sc->device_id = -1;
2476 return ret;
2477 }
2478 sc->device_id = ret;
2479 } else {
2480 sc->device_id = -1;
2481 }
2482
2483 return 0;
2484}
2485
2486static void sony_release_device_id(struct sony_sc *sc)
2487{
2488 if (sc->device_id >= 0) {
2489 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2490 sc->device_id = -1;
2491 }
2492}
2493
d8aaccda 2494static inline void sony_init_output_report(struct sony_sc *sc,
09593e38 2495 void (*send_output_report)(struct sony_sc *))
46262047 2496{
d8aaccda
FP		 2497 sc->send_output_report = send_output_report;
2498
b5322736 2499 if (!sc->state_worker_initialized)
d8aaccda 2500 INIT_WORK(&sc->state_worker, sony_state_worker);
46262047 2501
b5322736 2502 sc->state_worker_initialized = 1;
46262047
FP		 2503}
2504
2505static inline void sony_cancel_work_sync(struct sony_sc *sc)
2506{
86938d24
RC		 2507 unsigned long flags;
2508
f2f47c38
RC		 2509 if (sc->hotplug_worker_initialized)
2510 cancel_work_sync(&sc->hotplug_worker);
86938d24
RC		 2511 if (sc->state_worker_initialized) {
2512 spin_lock_irqsave(&sc->lock, flags);
2513 sc->state_worker_initialized = 0;
2514 spin_unlock_irqrestore(&sc->lock, flags);
46262047 2515 cancel_work_sync(&sc->state_worker);
86938d24 2516 }
46262047 2517}
d2d782fc 2518
e1bc84d0
RC		 2519static int sony_input_configured(struct hid_device *hdev,
2520 struct hid_input *hidinput)
bd28ce00 2521{
e1bc84d0 2522 struct sony_sc *sc = hid_get_drvdata(hdev);
0f398230 2523 int append_dev_id;
e1bc84d0 2524 int ret;
bd28ce00 2525
131a8a9a 2526 ret = sony_set_device_id(sc);
9b2b5c9a 2527 if (ret < 0) {
131a8a9a 2528 hid_err(hdev, "failed to allocate the device id\n");
9b2b5c9a
FP		 2529 goto err_stop;
2530 }
2531
df848bc0
RC		 2532 ret = append_dev_id = sony_check_add(sc);
2533 if (ret < 0)
2534 goto err_stop;
2535
131a8a9a 2536 ret = sony_allocate_output_report(sc);
8025087a 2537 if (ret < 0) {
131a8a9a 2538 hid_err(hdev, "failed to allocate the output report buffer\n");
8025087a
FP		 2539 goto err_stop;
2540 }
2541
510c8b7c 2542 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
e534a935
BT		 2543 /*
2544 * The Sony Sixaxis does not handle HID Output Reports on the
2545 * Interrupt EP like it could, so we need to force HID Output
2546 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2547 *
2548 * There is also another issue about HID Output Reports via USB,
2549 * the Sixaxis does not want the report_id as part of the data
2550 * packet, so we have to discard buf[0] when sending the actual
2551 * control message, even for numbered reports, humpf!
2a242932
FP		 2552 *
2553 * Additionally, the Sixaxis on USB isn't properly initialized
2554 * until the PS logo button is pressed and as such won't retain
2555 * any state set by an output report, so the initial
2556 * configuration report is deferred until the first input
2557 * report arrives.
e534a935
BT		 2558 */
2559 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2560 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2a242932 2561 sc->defer_initialization = 1;
80ecc48c 2562
816651a7 2563 ret = sixaxis_set_operational_usb(hdev);
80ecc48c
RC		 2564 if (ret < 0) {
2565 hid_err(hdev, "Failed to set controller into operational mode\n");
2566 goto err_stop;
2567 }
2568
d8aaccda 2569 sony_init_output_report(sc, sixaxis_send_output_report);
510c8b7c
RC		 2570 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2571 /*
2572 * The Navigation controller wants output reports sent on the ctrl
2573 * endpoint when connected via Bluetooth.
2574 */
2575 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2576
2577 ret = sixaxis_set_operational_bt(hdev);
2578 if (ret < 0) {
2579 hid_err(hdev, "Failed to set controller into operational mode\n");
2580 goto err_stop;
2581 }
2582
d8aaccda 2583 sony_init_output_report(sc, sixaxis_send_output_report);
510c8b7c
RC		 2584 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2585 /*
2586 * The Sony Sixaxis does not handle HID Output Reports on the
2587 * Interrupt EP and the device only becomes active when the
2588 * PS button is pressed. See comment for Navigation controller
2589 * above for more details.
2590 */
2591 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2592 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2593 sc->defer_initialization = 1;
2594
2595 ret = sixaxis_set_operational_usb(hdev);
2596 if (ret < 0) {
2597 hid_err(hdev, "Failed to set controller into operational mode\n");
2598 goto err_stop;
2599 }
2600
2601 ret = sony_register_sensors(sc);
2602 if (ret) {
2603 hid_err(sc->hdev,
2604 "Unable to initialize motion sensors: %d\n", ret);
2605 goto err_stop;
2606 }
2607
2608 sony_init_output_report(sc, sixaxis_send_output_report);
2609 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2078b9bb
FP		 2610 /*
2611 * The Sixaxis wants output reports sent on the ctrl endpoint
2612 * when connected via Bluetooth.
2613 */
2614 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
80ecc48c 2615
816651a7 2616 ret = sixaxis_set_operational_bt(hdev);
80ecc48c
RC		 2617 if (ret < 0) {
2618 hid_err(hdev, "Failed to set controller into operational mode\n");
2619 goto err_stop;
2620 }
2621
510c8b7c
RC		 2622 ret = sony_register_sensors(sc);
2623 if (ret) {
2624 hid_err(sc->hdev,
2625 "Unable to initialize motion sensors: %d\n", ret);
2626 goto err_stop;
2627 }
2628
d8aaccda 2629 sony_init_output_report(sc, sixaxis_send_output_report);
fee4e2d5 2630 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
55a07d62
RC		 2631 ret = dualshock4_get_calibration_data(sc);
2632 if (ret < 0) {
2633 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2634 goto err_stop;
68330d83 2635 }
c4e1ddf2 2636
e1bc84d0
RC		 2637 /*
2638 * The Dualshock 4 touchpad supports 2 touches and has a
2639 * resolution of 1920x942 (44.86 dots/mm).
2640 */
ac797b95 2641 ret = sony_register_touchpad(sc, 2, 1920, 942);
e1bc84d0
RC		 2642 if (ret) {
2643 hid_err(sc->hdev,
2644 "Unable to initialize multi-touch slots: %d\n",
2645 ret);
2b6579d4 2646 goto err_stop;
e1bc84d0
RC		 2647 }
2648
227c011b
RC		 2649 ret = sony_register_sensors(sc);
2650 if (ret) {
2651 hid_err(sc->hdev,
2652 "Unable to initialize motion sensors: %d\n", ret);
2653 goto err_stop;
2654 }
2655
77b499e7
RC		 2656 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2657 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2658 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2659 if (ret)
2660 hid_warn(sc->hdev,
2661 "can't create sysfs bt_poll_interval attribute err: %d\n",
2662 ret);
2663 }
2664
f2f47c38
RC		 2665 if (sc->quirks & DUALSHOCK4_DONGLE) {
2666 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2667 sc->hotplug_worker_initialized = 1;
2668 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2669 }
2670
d8aaccda 2671 sony_init_output_report(sc, dualshock4_send_output_report);
c5e0c1c4 2672 } else if (sc->quirks & MOTION_CONTROLLER) {
d8aaccda 2673 sony_init_output_report(sc, motion_send_output_report);
0bd88dd3
FP		 2674 } else {
2675 ret = 0;
2676 }
f9ce7c28 2677
0a286ef2 2678 if (sc->quirks & SONY_LED_SUPPORT) {
fa57a810 2679 ret = sony_leds_init(sc);
0a286ef2
SE		 2680 if (ret < 0)
2681 goto err_stop;
2682 }
2683
d902f472 2684 if (sc->quirks & SONY_BATTERY_SUPPORT) {
0f398230 2685 ret = sony_battery_probe(sc, append_dev_id);
d902f472
FP		 2686 if (ret < 0)
2687 goto err_stop;
2688
2689 /* Open the device to receive reports with battery info */
2690 ret = hid_hw_open(hdev);
2691 if (ret < 0) {
2692 hid_err(hdev, "hw open failed\n");
2693 goto err_stop;
2694 }
2695 }
2696
c8de9dbb 2697 if (sc->quirks & SONY_FF_SUPPORT) {
fa57a810 2698 ret = sony_init_ff(sc);
c8de9dbb
FP		 2699 if (ret < 0)
2700 goto err_close;
5f5750d2 2701 }
a08c22c0 2702
bd28ce00 2703 return 0;
d902f472
FP		 2704err_close:
2705 hid_hw_close(hdev);
bd28ce00 2706err_stop:
77b499e7
RC		 2707 /* Piggy back on the default ds4_bt_ poll_interval to determine
2708 * if we need to remove the file as we don't know for sure if we
2709 * executed that logic.
2710 */
2711 if (sc->ds4_bt_poll_interval)
2712 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
0a286ef2 2713 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 2714 sony_leds_remove(sc);
d902f472
FP		 2715 if (sc->quirks & SONY_BATTERY_SUPPORT)
2716 sony_battery_remove(sc);
a687c576
RC		 2717 if (sc->touchpad)
2718 sony_unregister_touchpad(sc);
a676bdc4
RC		 2719 if (sc->sensor_dev)
2720 sony_unregister_sensors(sc);
46262047 2721 sony_cancel_work_sync(sc);
9b2b5c9a 2722 kfree(sc->output_report_dmabuf);
d2d782fc 2723 sony_remove_dev_list(sc);
8025087a 2724 sony_release_device_id(sc);
bd28ce00
JS		 2725 return ret;
2726}
2727
e1bc84d0
RC		 2728static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2729{
2730 int ret;
2731 unsigned long quirks = id->driver_data;
2732 struct sony_sc *sc;
2733 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2734
2735 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2736 quirks |= FUTUREMAX_DANCE_MAT;
2737
2738 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2739 if (sc == NULL) {
2740 hid_err(hdev, "can't alloc sony descriptor\n");
2741 return -ENOMEM;
2742 }
2743
2744 spin_lock_init(&sc->lock);
2745
2746 sc->quirks = quirks;
2747 hid_set_drvdata(hdev, sc);
2748 sc->hdev = hdev;
2749
2750 ret = hid_parse(hdev);
2751 if (ret) {
2752 hid_err(hdev, "parse failed\n");
2753 return ret;
2754 }
2755
2756 if (sc->quirks & VAIO_RDESC_CONSTANT)
2757 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2758 else if (sc->quirks & SIXAXIS_CONTROLLER)
2759 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
2760
e19a267b 2761 /* Patch the hw version on DS3/4 compatible devices, so applications can
9131f8cc
RC		 2762 * distinguish between the default HID mappings and the mappings defined
2763 * by the Linux game controller spec. This is important for the SDL2
2764 * library, which has a game controller database, which uses device ids
2765 * in combination with version as a key.
2766 */
e19a267b 2767 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
9131f8cc
RC		 2768 hdev->version |= 0x8000;
2769
e1bc84d0
RC		 2770 ret = hid_hw_start(hdev, connect_mask);
2771 if (ret) {
2772 hid_err(hdev, "hw start failed\n");
2773 return ret;
2774 }
2775
4f967f6d
RC		 2776 /* sony_input_configured can fail, but this doesn't result
2777 * in hid_hw_start failures (intended). Check whether
2778 * the HID layer claimed the device else fail.
2779 * We don't know the actual reason for the failure, most
2780 * likely it is due to EEXIST in case of double connection
2781 * of USB and Bluetooth, but could have been due to ENOMEM
2782 * or other reasons as well.
2783 */
2784 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
2785 hid_err(hdev, "failed to claim input\n");
92a79917 2786 hid_hw_stop(hdev);
4f967f6d
RC		 2787 return -ENODEV;
2788 }
2789
e1bc84d0
RC		 2790 return ret;
2791}
2792
cc6e0bbb
JK		 2793static void sony_remove(struct hid_device *hdev)
2794{
f04d5140
CL		 2795 struct sony_sc *sc = hid_get_drvdata(hdev);
2796
ac797b95
RC		 2797 hid_hw_close(hdev);
2798
0a286ef2 2799 if (sc->quirks & SONY_LED_SUPPORT)
fa57a810 2800 sony_leds_remove(sc);
f04d5140 2801
ac797b95 2802 if (sc->quirks & SONY_BATTERY_SUPPORT)
d902f472 2803 sony_battery_remove(sc);
ac797b95
RC		 2804
2805 if (sc->touchpad)
2806 sony_unregister_touchpad(sc);
d902f472 2807
227c011b
RC		 2808 if (sc->sensor_dev)
2809 sony_unregister_sensors(sc);
2810
77b499e7
RC		 2811 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2812 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2813
46262047 2814 sony_cancel_work_sync(sc);
9f323b68 2815
9b2b5c9a
FP		 2816 kfree(sc->output_report_dmabuf);
2817
d2d782fc 2818 sony_remove_dev_list(sc);
9f323b68 2819
8025087a
FP		 2820 sony_release_device_id(sc);
2821
cc6e0bbb 2822 hid_hw_stop(hdev);
cc6e0bbb
JK		 2823}
2824
decd946c
FP		 2825#ifdef CONFIG_PM
2826
2827static int sony_suspend(struct hid_device *hdev, pm_message_t message)
2828{
decd946c 2829#ifdef CONFIG_SONY_FF
decd946c 2830
765a1077
FP		 2831 /* On suspend stop any running force-feedback events */
2832 if (SONY_FF_SUPPORT) {
2833 struct sony_sc *sc = hid_get_drvdata(hdev);
decd946c 2834
765a1077 2835 sc->left = sc->right = 0;
decd946c
FP		 2836 sony_send_output_report(sc);
2837 }
2838
765a1077 2839#endif
decd946c
FP		 2840 return 0;
2841}
2842
2843static int sony_resume(struct hid_device *hdev)
2844{
765a1077 2845 struct sony_sc *sc = hid_get_drvdata(hdev);
decd946c 2846
765a1077
FP		 2847 /*
2848 * The Sixaxis and navigation controllers on USB need to be
2849 * reinitialized on resume or they won't behave properly.
2850 */
2851 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2852 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2853 sixaxis_set_operational_usb(sc->hdev);
2854 sc->defer_initialization = 1;
decd946c
FP		 2855 }
2856
2857 return 0;
2858}
2859
2860#endif
2861
bd28ce00 2862static const struct hid_device_id sony_devices[] = {
816651a7
AO		 2863 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2864 .driver_data = SIXAXIS_CONTROLLER_USB },
35dca5b4 2865 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 2866 .driver_data = NAVIGATION_CONTROLLER_USB },
6eabaaa0 2867 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
4545ee0a 2868 .driver_data = NAVIGATION_CONTROLLER_BT },
c5e0c1c4 2869 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 2870 .driver_data = MOTION_CONTROLLER_USB },
a4afa854 2871 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
b3bca326 2872 .driver_data = MOTION_CONTROLLER_BT },
816651a7
AO		 2873 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
2874 .driver_data = SIXAXIS_CONTROLLER_BT },
cc6e0bbb
JK		 2875 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
2876 .driver_data = VAIO_RDESC_CONSTANT },
a4649184
FLVC		 2877 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
2878 .driver_data = VAIO_RDESC_CONSTANT },
ef916ef5
AO		 2879 /*
2880 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
2881 * Logitech joystick from the device descriptor.
2882 */
f04d5140
CL		 2883 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
2884 .driver_data = BUZZ_CONTROLLER },
2885 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
2886 .driver_data = BUZZ_CONTROLLER },
078328da
JK		 2887 /* PS3 BD Remote Control */
2888 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
2889 .driver_data = PS3REMOTE },
2890 /* Logitech Harmony Adapter for PS3 */
2891 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
2892 .driver_data = PS3REMOTE },
68a49e51
FP		 2893 /* SMK-Link PS3 BD Remote Control */
2894 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
2895 .driver_data = PS3REMOTE },
0bd88dd3
FP		 2896 /* Sony Dualshock 4 controllers for PS4 */
2897 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 2898 .driver_data = DUALSHOCK4_CONTROLLER_USB },
0bd88dd3 2899 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
8ab1676b 2900 .driver_data = DUALSHOCK4_CONTROLLER_BT },
cf1015d6
RC		 2901 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2902 .driver_data = DUALSHOCK4_CONTROLLER_USB },
2903 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2904 .driver_data = DUALSHOCK4_CONTROLLER_BT },
de66a1a0 2905 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
35f436c3 2906 .driver_data = DUALSHOCK4_DONGLE },
74500cc8
SM		 2907 /* Nyko Core Controller for PS3 */
2908 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
2909 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
bd28ce00
JS		 2910 { }
2911};
2912MODULE_DEVICE_TABLE(hid, sony_devices);
2913
2914static struct hid_driver sony_driver = {
ce8efc3b
FP		 2915 .name = "sony",
2916 .id_table = sony_devices,
2917 .input_mapping = sony_mapping,
2918 .input_configured = sony_input_configured,
2919 .probe = sony_probe,
2920 .remove = sony_remove,
2921 .report_fixup = sony_report_fixup,
decd946c
FP		 2922 .raw_event = sony_raw_event,
2923
2924#ifdef CONFIG_PM
2925 .suspend = sony_suspend,
2926 .resume = sony_resume,
2927 .reset_resume = sony_resume,
2928#endif
bd28ce00 2929};
8025087a
FP		 2930
2931static int __init sony_init(void)
2932{
2933 dbg_hid("Sony:%s\n", __func__);
2934
2935 return hid_register_driver(&sony_driver);
2936}
2937
2938static void __exit sony_exit(void)
2939{
2940 dbg_hid("Sony:%s\n", __func__);
2941
8025087a 2942 hid_unregister_driver(&sony_driver);
6c40065f 2943 ida_destroy(&sony_device_id_allocator);
8025087a
FP		 2944}
2945module_init(sony_init);
2946module_exit(sony_exit);
bd28ce00 2947
bd28ce00 2948MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror