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