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