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