1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * HID driver for Sony / PS2 / PS3 / PS4 BD devices.
5 * Copyright (c) 1999 Andreas Gal
6 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
7 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
8 * Copyright (c) 2008 Jiri Slaby
9 * Copyright (c) 2012 David Dillow <dave@thedillows.org>
10 * Copyright (c) 2006-2013 Jiri Kosina
11 * Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
12 * Copyright (c) 2014-2016 Frank Praznik <frank.praznik@gmail.com>
13 * Copyright (c) 2018 Todd Kelner
14 * Copyright (c) 2020 Pascal Giard <pascal.giard@etsmtl.ca>
15 * Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
22 * NOTE: in order for the Sony PS3 BD Remote Control to be found by
23 * a Bluetooth host, the key combination Start+Enter has to be kept pressed
24 * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
26 * There will be no PIN request from the device.
29 #include <linux/device.h>
30 #include <linux/hid.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/leds.h>
34 #include <linux/power_supply.h>
35 #include <linux/spinlock.h>
36 #include <linux/list.h>
37 #include <linux/idr.h>
38 #include <linux/input/mt.h>
39 #include <linux/crc32.h>
40 #include <linux/usb.h>
41 #include <linux/timer.h>
42 #include <asm/unaligned.h>
46 #define VAIO_RDESC_CONSTANT BIT(0)
47 #define SIXAXIS_CONTROLLER_USB BIT(1)
48 #define SIXAXIS_CONTROLLER_BT BIT(2)
49 #define BUZZ_CONTROLLER BIT(3)
50 #define PS3REMOTE BIT(4)
51 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
52 #define DUALSHOCK4_CONTROLLER_BT BIT(6)
53 #define DUALSHOCK4_DONGLE BIT(7)
54 #define MOTION_CONTROLLER_USB BIT(8)
55 #define MOTION_CONTROLLER_BT BIT(9)
56 #define NAVIGATION_CONTROLLER_USB BIT(10)
57 #define NAVIGATION_CONTROLLER_BT BIT(11)
58 #define SINO_LITE_CONTROLLER BIT(12)
59 #define FUTUREMAX_DANCE_MAT BIT(13)
60 #define NSG_MR5U_REMOTE_BT BIT(14)
61 #define NSG_MR7U_REMOTE_BT BIT(15)
62 #define SHANWAN_GAMEPAD BIT(16)
63 #define GH_GUITAR_CONTROLLER BIT(17)
64 #define GHL_GUITAR_PS3WIIU BIT(18)
66 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
67 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
68 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
69 NAVIGATION_CONTROLLER_BT)
70 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
71 DUALSHOCK4_CONTROLLER_BT | \
73 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
74 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
75 NAVIGATION_CONTROLLER)
76 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
77 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
78 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
80 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
81 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
82 #define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
85 #define NSG_MRXU_MAX_X 1667
86 #define NSG_MRXU_MAX_Y 1868
88 #define GHL_GUITAR_POKE_INTERVAL 10 /* In seconds */
89 #define GUITAR_TILT_USAGE 44
91 /* Magic value and data taken from GHLtarUtility:
92 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
93 * Note: The Wii U and PS3 dongles happen to share the same!
95 static const u16 ghl_ps3wiiu_magic_value = 0x201;
96 static const char ghl_ps3wiiu_magic_data[] = {
97 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
100 /* PS/3 Motion controller */
101 static u8 motion_rdesc[] = {
102 0x05, 0x01, /* Usage Page (Desktop), */
103 0x09, 0x04, /* Usage (Joystick), */
104 0xA1, 0x01, /* Collection (Application), */
105 0xA1, 0x02, /* Collection (Logical), */
106 0x85, 0x01, /* Report ID (1), */
107 0x75, 0x01, /* Report Size (1), */
108 0x95, 0x15, /* Report Count (21), */
109 0x15, 0x00, /* Logical Minimum (0), */
110 0x25, 0x01, /* Logical Maximum (1), */
111 0x35, 0x00, /* Physical Minimum (0), */
112 0x45, 0x01, /* Physical Maximum (1), */
113 0x05, 0x09, /* Usage Page (Button), */
114 0x19, 0x01, /* Usage Minimum (01h), */
115 0x29, 0x15, /* Usage Maximum (15h), */
116 0x81, 0x02, /* Input (Variable), * Buttons */
117 0x95, 0x0B, /* Report Count (11), */
118 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
119 0x81, 0x03, /* Input (Constant, Variable), * Padding */
120 0x15, 0x00, /* Logical Minimum (0), */
121 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
122 0x05, 0x01, /* Usage Page (Desktop), */
123 0xA1, 0x00, /* Collection (Physical), */
124 0x75, 0x08, /* Report Size (8), */
125 0x95, 0x01, /* Report Count (1), */
126 0x35, 0x00, /* Physical Minimum (0), */
127 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
128 0x09, 0x30, /* Usage (X), */
129 0x81, 0x02, /* Input (Variable), * Trigger */
130 0xC0, /* End Collection, */
131 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
132 0x75, 0x08, /* Report Size (8), */
133 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
134 0x81, 0x02, /* Input (Variable), */
135 0x05, 0x01, /* Usage Page (Desktop), */
136 0x75, 0x10, /* Report Size (16), */
137 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
138 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
139 0x95, 0x03, /* Report Count (3), * 3x Accels */
140 0x09, 0x33, /* Usage (rX), */
141 0x09, 0x34, /* Usage (rY), */
142 0x09, 0x35, /* Usage (rZ), */
143 0x81, 0x02, /* Input (Variable), */
144 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
145 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
146 0x81, 0x02, /* Input (Variable), */
147 0x05, 0x01, /* Usage Page (Desktop), */
148 0x09, 0x01, /* Usage (Pointer), */
149 0x95, 0x03, /* Report Count (3), * 3x Gyros */
150 0x81, 0x02, /* Input (Variable), */
151 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
152 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
153 0x81, 0x02, /* Input (Variable), */
154 0x75, 0x0C, /* Report Size (12), */
155 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
156 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
157 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
158 0x81, 0x02, /* Input (Variable), */
159 0x75, 0x08, /* Report Size (8), */
160 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
161 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
162 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
163 0x81, 0x02, /* Input (Variable), */
164 0x75, 0x08, /* Report Size (8), */
165 0x95, 0x30, /* Report Count (48), */
166 0x09, 0x01, /* Usage (Pointer), */
167 0x91, 0x02, /* Output (Variable), */
168 0x75, 0x08, /* Report Size (8), */
169 0x95, 0x30, /* Report Count (48), */
170 0x09, 0x01, /* Usage (Pointer), */
171 0xB1, 0x02, /* Feature (Variable), */
172 0xC0, /* End Collection, */
173 0xA1, 0x02, /* Collection (Logical), */
174 0x85, 0x02, /* Report ID (2), */
175 0x75, 0x08, /* Report Size (8), */
176 0x95, 0x30, /* Report Count (48), */
177 0x09, 0x01, /* Usage (Pointer), */
178 0xB1, 0x02, /* Feature (Variable), */
179 0xC0, /* End Collection, */
180 0xA1, 0x02, /* Collection (Logical), */
181 0x85, 0xEE, /* Report ID (238), */
182 0x75, 0x08, /* Report Size (8), */
183 0x95, 0x30, /* Report Count (48), */
184 0x09, 0x01, /* Usage (Pointer), */
185 0xB1, 0x02, /* Feature (Variable), */
186 0xC0, /* End Collection, */
187 0xA1, 0x02, /* Collection (Logical), */
188 0x85, 0xEF, /* Report ID (239), */
189 0x75, 0x08, /* Report Size (8), */
190 0x95, 0x30, /* Report Count (48), */
191 0x09, 0x01, /* Usage (Pointer), */
192 0xB1, 0x02, /* Feature (Variable), */
193 0xC0, /* End Collection, */
194 0xC0 /* End Collection */
197 static u8 ps3remote_rdesc[] = {
198 0x05, 0x01, /* GUsagePage Generic Desktop */
199 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
200 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
202 /* Use collection 1 for joypad buttons */
203 0xA1, 0x02, /* MCollection Logical (interrelated data) */
206 * Ignore the 1st byte, maybe it is used for a controller
207 * number but it's not needed for correct operation
209 0x75, 0x08, /* GReportSize 0x08 [8] */
210 0x95, 0x01, /* GReportCount 0x01 [1] */
211 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
214 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
215 * buttons multiple keypresses are allowed
217 0x05, 0x09, /* GUsagePage Button */
218 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
219 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
220 0x14, /* GLogicalMinimum [0] */
221 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
222 0x75, 0x01, /* GReportSize 0x01 [1] */
223 0x95, 0x18, /* GReportCount 0x18 [24] */
224 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
226 0xC0, /* MEndCollection */
228 /* Use collection 2 for remote control buttons */
229 0xA1, 0x02, /* MCollection Logical (interrelated data) */
231 /* 5th byte is used for remote control buttons */
232 0x05, 0x09, /* GUsagePage Button */
233 0x18, /* LUsageMinimum [No button pressed] */
234 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
235 0x14, /* GLogicalMinimum [0] */
236 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
237 0x75, 0x08, /* GReportSize 0x08 [8] */
238 0x95, 0x01, /* GReportCount 0x01 [1] */
242 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
243 * 0xff and 11th is for press indication
245 0x75, 0x08, /* GReportSize 0x08 [8] */
246 0x95, 0x06, /* GReportCount 0x06 [6] */
247 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
249 /* 12th byte is for battery strength */
250 0x05, 0x06, /* GUsagePage Generic Device Controls */
251 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
252 0x14, /* GLogicalMinimum [0] */
253 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
254 0x75, 0x08, /* GReportSize 0x08 [8] */
255 0x95, 0x01, /* GReportCount 0x01 [1] */
256 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
258 0xC0, /* MEndCollection */
260 0xC0 /* MEndCollection [Game Pad] */
263 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
265 [0x02] = BTN_THUMBL, /* L3 */
266 [0x03] = BTN_THUMBR, /* R3 */
272 [0x09] = BTN_TL2, /* L2 */
273 [0x0a] = BTN_TR2, /* R2 */
274 [0x0b] = BTN_TL, /* L1 */
275 [0x0c] = BTN_TR, /* R1 */
276 [0x0d] = KEY_OPTION, /* options/triangle */
277 [0x0e] = KEY_BACK, /* back/circle */
278 [0x0f] = BTN_0, /* cross */
279 [0x10] = KEY_SCREEN, /* view/square */
280 [0x11] = KEY_HOMEPAGE, /* PS button */
283 static const unsigned int ps3remote_keymap_remote_buttons[] = {
294 [0x0e] = KEY_ESC, /* return */
296 [0x16] = KEY_EJECTCD,
297 [0x1a] = KEY_MENU, /* top menu */
299 [0x30] = KEY_PREVIOUS,
302 [0x33] = KEY_REWIND, /* scan back */
303 [0x34] = KEY_FORWARD, /* scan forward */
306 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
307 [0x60] = KEY_FRAMEBACK, /* slow/step back */
308 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
309 [0x63] = KEY_SUBTITLE,
312 [0x70] = KEY_INFO, /* display */
319 static const unsigned int buzz_keymap[] = {
321 * The controller has 4 remote buzzers, each with one LED and 5
324 * We use the mapping chosen by the controller, which is:
327 * -------------------
334 * So, for example, the orange button on the third buzzer is mapped to
335 * BTN_TRIGGER_HAPPY14
337 [1] = BTN_TRIGGER_HAPPY1,
338 [2] = BTN_TRIGGER_HAPPY2,
339 [3] = BTN_TRIGGER_HAPPY3,
340 [4] = BTN_TRIGGER_HAPPY4,
341 [5] = BTN_TRIGGER_HAPPY5,
342 [6] = BTN_TRIGGER_HAPPY6,
343 [7] = BTN_TRIGGER_HAPPY7,
344 [8] = BTN_TRIGGER_HAPPY8,
345 [9] = BTN_TRIGGER_HAPPY9,
346 [10] = BTN_TRIGGER_HAPPY10,
347 [11] = BTN_TRIGGER_HAPPY11,
348 [12] = BTN_TRIGGER_HAPPY12,
349 [13] = BTN_TRIGGER_HAPPY13,
350 [14] = BTN_TRIGGER_HAPPY14,
351 [15] = BTN_TRIGGER_HAPPY15,
352 [16] = BTN_TRIGGER_HAPPY16,
353 [17] = BTN_TRIGGER_HAPPY17,
354 [18] = BTN_TRIGGER_HAPPY18,
355 [19] = BTN_TRIGGER_HAPPY19,
356 [20] = BTN_TRIGGER_HAPPY20,
359 /* The Navigation controller is a partial DS3 and uses the same HID report
360 * and hence the same keymap indices, however not not all axes/buttons
361 * are physically present. We use the same axis and button mapping as
362 * the DS3, which uses the Linux gamepad spec.
364 static const unsigned int navigation_absmap[] = {
367 [0x33] = ABS_Z, /* L2 */
370 /* Buttons not physically available on the device, but still available
371 * in the reports are explicitly set to 0 for documentation purposes.
373 static const unsigned int navigation_keymap[] = {
374 [0x01] = 0, /* Select */
375 [0x02] = BTN_THUMBL, /* L3 */
377 [0x04] = 0, /* Start */
378 [0x05] = BTN_DPAD_UP, /* Up */
379 [0x06] = BTN_DPAD_RIGHT, /* Right */
380 [0x07] = BTN_DPAD_DOWN, /* Down */
381 [0x08] = BTN_DPAD_LEFT, /* Left */
382 [0x09] = BTN_TL2, /* L2 */
384 [0x0b] = BTN_TL, /* L1 */
386 [0x0d] = BTN_NORTH, /* Triangle */
387 [0x0e] = BTN_EAST, /* Circle */
388 [0x0f] = BTN_SOUTH, /* Cross */
389 [0x10] = BTN_WEST, /* Square */
390 [0x11] = BTN_MODE, /* PS */
393 static const unsigned int sixaxis_absmap[] = {
396 [0x32] = ABS_RX, /* right stick X */
397 [0x35] = ABS_RY, /* right stick Y */
400 static const unsigned int sixaxis_keymap[] = {
401 [0x01] = BTN_SELECT, /* Select */
402 [0x02] = BTN_THUMBL, /* L3 */
403 [0x03] = BTN_THUMBR, /* R3 */
404 [0x04] = BTN_START, /* Start */
405 [0x05] = BTN_DPAD_UP, /* Up */
406 [0x06] = BTN_DPAD_RIGHT, /* Right */
407 [0x07] = BTN_DPAD_DOWN, /* Down */
408 [0x08] = BTN_DPAD_LEFT, /* Left */
409 [0x09] = BTN_TL2, /* L2 */
410 [0x0a] = BTN_TR2, /* R2 */
411 [0x0b] = BTN_TL, /* L1 */
412 [0x0c] = BTN_TR, /* R1 */
413 [0x0d] = BTN_NORTH, /* Triangle */
414 [0x0e] = BTN_EAST, /* Circle */
415 [0x0f] = BTN_SOUTH, /* Cross */
416 [0x10] = BTN_WEST, /* Square */
417 [0x11] = BTN_MODE, /* PS */
420 static const unsigned int ds4_absmap[] = {
423 [0x32] = ABS_RX, /* right stick X */
424 [0x33] = ABS_Z, /* L2 */
425 [0x34] = ABS_RZ, /* R2 */
426 [0x35] = ABS_RY, /* right stick Y */
429 static const unsigned int ds4_keymap[] = {
430 [0x1] = BTN_WEST, /* Square */
431 [0x2] = BTN_SOUTH, /* Cross */
432 [0x3] = BTN_EAST, /* Circle */
433 [0x4] = BTN_NORTH, /* Triangle */
434 [0x5] = BTN_TL, /* L1 */
435 [0x6] = BTN_TR, /* R1 */
436 [0x7] = BTN_TL2, /* L2 */
437 [0x8] = BTN_TR2, /* R2 */
438 [0x9] = BTN_SELECT, /* Share */
439 [0xa] = BTN_START, /* Options */
440 [0xb] = BTN_THUMBL, /* L3 */
441 [0xc] = BTN_THUMBR, /* R3 */
442 [0xd] = BTN_MODE, /* PS */
445 static const struct {int x; int y; } ds4_hat_mapping[] = {
446 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
450 static enum power_supply_property sony_battery_props[] = {
451 POWER_SUPPLY_PROP_PRESENT,
452 POWER_SUPPLY_PROP_CAPACITY,
453 POWER_SUPPLY_PROP_SCOPE,
454 POWER_SUPPLY_PROP_STATUS,
458 u8 time_enabled; /* the total time the led is active (0xff means forever) */
459 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
461 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
462 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
465 struct sixaxis_rumble {
467 u8 right_duration; /* Right motor duration (0xff means forever) */
468 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
469 u8 left_duration; /* Left motor duration (0xff means forever) */
470 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
473 struct sixaxis_output_report {
475 struct sixaxis_rumble rumble;
477 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
478 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
479 struct sixaxis_led _reserved; /* LED5, not actually soldered */
482 union sixaxis_output_report_01 {
483 struct sixaxis_output_report data;
487 struct motion_output_report_02 {
494 #define DS4_FEATURE_REPORT_0x02_SIZE 37
495 #define DS4_FEATURE_REPORT_0x05_SIZE 41
496 #define DS4_FEATURE_REPORT_0x81_SIZE 7
497 #define DS4_FEATURE_REPORT_0xA3_SIZE 49
498 #define DS4_INPUT_REPORT_0x11_SIZE 78
499 #define DS4_OUTPUT_REPORT_0x05_SIZE 32
500 #define DS4_OUTPUT_REPORT_0x11_SIZE 78
501 #define SIXAXIS_REPORT_0xF2_SIZE 17
502 #define SIXAXIS_REPORT_0xF5_SIZE 8
503 #define MOTION_REPORT_0x02_SIZE 49
505 /* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
508 #define DS4_INPUT_REPORT_AXIS_OFFSET 1
509 #define DS4_INPUT_REPORT_BUTTON_OFFSET 5
510 #define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
511 #define DS4_INPUT_REPORT_GYRO_X_OFFSET 13
512 #define DS4_INPUT_REPORT_BATTERY_OFFSET 30
513 #define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
515 #define SENSOR_SUFFIX " Motion Sensors"
516 #define DS4_TOUCHPAD_SUFFIX " Touchpad"
518 /* Default to 4ms poll interval, which is same as USB (not adjustable). */
519 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
520 #define DS4_BT_MAX_POLL_INTERVAL_MS 62
521 #define DS4_GYRO_RES_PER_DEG_S 1024
522 #define DS4_ACC_RES_PER_G 8192
524 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
525 #define SIXAXIS_ACC_RES_PER_G 113
527 static DEFINE_SPINLOCK(sony_dev_list_lock);
528 static LIST_HEAD(sony_device_list);
529 static DEFINE_IDA(sony_device_id_allocator);
531 /* Used for calibration of DS4 accelerometer and gyro. */
532 struct ds4_calibration_data {
535 /* Calibration requires scaling against a sensitivity value, which is a
536 * float. Store sensitivity as a fraction to limit floating point
537 * calculations until final calibration.
543 enum ds4_dongle_state {
557 struct list_head list_node;
558 struct hid_device *hdev;
559 struct input_dev *touchpad;
560 struct input_dev *sensor_dev;
561 struct led_classdev *leds[MAX_LEDS];
562 unsigned long quirks;
563 struct work_struct hotplug_worker;
564 struct work_struct state_worker;
565 void (*send_output_report)(struct sony_sc *);
566 struct power_supply *battery;
567 struct power_supply_desc battery_desc;
570 bool fw_version_created;
572 bool hw_version_created;
573 u8 *output_report_dmabuf;
575 #ifdef CONFIG_SONY_FF
581 u8 hotplug_worker_initialized;
582 u8 state_worker_initialized;
583 u8 defer_initialization;
586 u8 led_state[MAX_LEDS];
587 u8 led_delay_on[MAX_LEDS];
588 u8 led_delay_off[MAX_LEDS];
591 bool timestamp_initialized;
593 unsigned int timestamp_us;
595 u8 ds4_bt_poll_interval;
596 enum ds4_dongle_state ds4_dongle_state;
597 /* DS4 calibration data */
598 struct ds4_calibration_data ds4_calib_data[6];
600 struct timer_list ghl_poke_timer;
601 struct usb_ctrlrequest *ghl_cr;
605 static void sony_set_leds(struct sony_sc *sc);
607 static inline void sony_schedule_work(struct sony_sc *sc,
608 enum sony_worker which)
613 case SONY_WORKER_STATE:
614 spin_lock_irqsave(&sc->lock, flags);
615 if (!sc->defer_initialization && sc->state_worker_initialized)
616 schedule_work(&sc->state_worker);
617 spin_unlock_irqrestore(&sc->lock, flags);
619 case SONY_WORKER_HOTPLUG:
620 if (sc->hotplug_worker_initialized)
621 schedule_work(&sc->hotplug_worker);
626 static void ghl_magic_poke_cb(struct urb *urb)
629 /* Free sc->ghl_cr and sc->ghl_databuf allocated in
632 kfree(urb->setup_packet);
633 kfree(urb->transfer_buffer);
637 static void ghl_magic_poke(struct timer_list *t)
639 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
644 struct usb_device *usbdev = to_usb_device(sc->hdev->dev.parent->parent);
645 const u16 poke_size =
646 ARRAY_SIZE(ghl_ps3wiiu_magic_data);
648 pipe = usb_sndctrlpipe(usbdev, 0);
651 sc->ghl_cr = kzalloc(sizeof(*sc->ghl_cr), GFP_ATOMIC);
656 if (!sc->ghl_databuf) {
657 sc->ghl_databuf = kzalloc(poke_size, GFP_ATOMIC);
658 if (!sc->ghl_databuf)
662 urb = usb_alloc_urb(0, GFP_ATOMIC);
666 sc->ghl_cr->bRequestType =
667 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
668 sc->ghl_cr->bRequest = USB_REQ_SET_CONFIGURATION;
669 sc->ghl_cr->wValue = cpu_to_le16(ghl_ps3wiiu_magic_value);
670 sc->ghl_cr->wIndex = 0;
671 sc->ghl_cr->wLength = cpu_to_le16(poke_size);
672 memcpy(sc->ghl_databuf, ghl_ps3wiiu_magic_data, poke_size);
674 usb_fill_control_urb(
676 (unsigned char *) sc->ghl_cr, sc->ghl_databuf,
677 poke_size, ghl_magic_poke_cb, NULL);
678 ret = usb_submit_urb(urb, GFP_ATOMIC);
680 kfree(sc->ghl_databuf);
686 /* Reschedule for next time */
687 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
690 static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
691 struct hid_field *field, struct hid_usage *usage,
692 unsigned long **bit, int *max)
694 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
695 unsigned int abs = usage->hid & HID_USAGE;
697 if (abs == GUITAR_TILT_USAGE) {
698 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
705 static ssize_t ds4_show_poll_interval(struct device *dev,
706 struct device_attribute
709 struct hid_device *hdev = to_hid_device(dev);
710 struct sony_sc *sc = hid_get_drvdata(hdev);
712 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
715 static ssize_t ds4_store_poll_interval(struct device *dev,
716 struct device_attribute *attr,
717 const char *buf, size_t count)
719 struct hid_device *hdev = to_hid_device(dev);
720 struct sony_sc *sc = hid_get_drvdata(hdev);
724 if (kstrtou8(buf, 0, &interval))
727 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
730 spin_lock_irqsave(&sc->lock, flags);
731 sc->ds4_bt_poll_interval = interval;
732 spin_unlock_irqrestore(&sc->lock, flags);
734 sony_schedule_work(sc, SONY_WORKER_STATE);
739 static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
740 ds4_store_poll_interval);
742 static ssize_t sony_show_firmware_version(struct device *dev,
743 struct device_attribute
746 struct hid_device *hdev = to_hid_device(dev);
747 struct sony_sc *sc = hid_get_drvdata(hdev);
749 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
752 static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
754 static ssize_t sony_show_hardware_version(struct device *dev,
755 struct device_attribute
758 struct hid_device *hdev = to_hid_device(dev);
759 struct sony_sc *sc = hid_get_drvdata(hdev);
761 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
764 static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
766 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
769 *rsize = sizeof(motion_rdesc);
773 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
776 *rsize = sizeof(ps3remote_rdesc);
777 return ps3remote_rdesc;
780 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
781 struct hid_field *field, struct hid_usage *usage,
782 unsigned long **bit, int *max)
784 unsigned int key = usage->hid & HID_USAGE;
786 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
789 switch (usage->collection_index) {
791 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
794 key = ps3remote_keymap_joypad_buttons[key];
799 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
802 key = ps3remote_keymap_remote_buttons[key];
810 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
814 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
815 struct hid_field *field, struct hid_usage *usage,
816 unsigned long **bit, int *max)
818 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
819 unsigned int key = usage->hid & HID_USAGE;
821 if (key >= ARRAY_SIZE(sixaxis_keymap))
824 key = navigation_keymap[key];
828 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
830 } else if (usage->hid == HID_GD_POINTER) {
831 /* See comment in sixaxis_mapping, basically the L2 (and R2)
832 * triggers are reported through GD Pointer.
833 * In addition we ignore any analog button 'axes' and only
834 * support digital buttons.
836 switch (usage->usage_index) {
838 usage->hid = HID_GD_Z;
844 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
846 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
847 unsigned int abs = usage->hid & HID_USAGE;
849 if (abs >= ARRAY_SIZE(navigation_absmap))
852 abs = navigation_absmap[abs];
854 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
862 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
863 struct hid_field *field, struct hid_usage *usage,
864 unsigned long **bit, int *max)
866 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
867 unsigned int key = usage->hid & HID_USAGE;
869 if (key >= ARRAY_SIZE(sixaxis_keymap))
872 key = sixaxis_keymap[key];
873 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
875 } else if (usage->hid == HID_GD_POINTER) {
876 /* The DS3 provides analog values for most buttons and even
877 * for HAT axes through GD Pointer. L2 and R2 are reported
878 * among these as well instead of as GD Z / RZ. Remap L2
879 * and R2 and ignore other analog 'button axes' as there is
880 * no good way for reporting them.
882 switch (usage->usage_index) {
884 usage->hid = HID_GD_Z;
887 usage->hid = HID_GD_RZ;
893 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
895 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
896 unsigned int abs = usage->hid & HID_USAGE;
898 if (abs >= ARRAY_SIZE(sixaxis_absmap))
901 abs = sixaxis_absmap[abs];
903 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
910 static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
911 struct hid_field *field, struct hid_usage *usage,
912 unsigned long **bit, int *max)
914 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
915 unsigned int key = usage->hid & HID_USAGE;
917 if (key >= ARRAY_SIZE(ds4_keymap))
920 key = ds4_keymap[key];
921 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
923 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
924 unsigned int abs = usage->hid & HID_USAGE;
926 /* Let the HID parser deal with the HAT. */
927 if (usage->hid == HID_GD_HATSWITCH)
930 if (abs >= ARRAY_SIZE(ds4_absmap))
933 abs = ds4_absmap[abs];
934 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
941 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
944 struct sony_sc *sc = hid_get_drvdata(hdev);
946 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
950 * Some Sony RF receivers wrongly declare the mouse pointer as a
951 * a constant non-data variable.
953 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
954 /* usage page: generic desktop controls */
955 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
957 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
958 /* input (usage page for x,y axes): constant, variable, relative */
959 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
960 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
961 /* input: data, variable, relative */
965 if (sc->quirks & MOTION_CONTROLLER)
966 return motion_fixup(hdev, rdesc, rsize);
968 if (sc->quirks & PS3REMOTE)
969 return ps3remote_fixup(hdev, rdesc, rsize);
972 * Some knock-off USB dongles incorrectly report their button count
973 * as 13 instead of 16 causing three non-functional buttons.
975 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
976 /* Report Count (13) */
977 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
978 /* Usage Maximum (13) */
979 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
980 /* Report Count (3) */
981 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
982 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
991 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
993 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
1000 * The sixaxis is charging if the battery value is 0xee
1001 * and it is fully charged if the value is 0xef.
1002 * It does not report the actual level while charging so it
1003 * is set to 100% while charging is in progress.
1005 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1007 if (rd[offset] >= 0xee) {
1008 battery_capacity = 100;
1009 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
1011 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
1012 battery_capacity = sixaxis_battery_capacity[index];
1013 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1016 spin_lock_irqsave(&sc->lock, flags);
1017 sc->battery_capacity = battery_capacity;
1018 sc->battery_status = battery_status;
1019 spin_unlock_irqrestore(&sc->lock, flags);
1021 if (sc->quirks & SIXAXIS_CONTROLLER) {
1024 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
1025 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
1026 input_report_abs(sc->sensor_dev, ABS_X, val);
1028 /* Y and Z are swapped and inversed */
1029 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
1030 input_report_abs(sc->sensor_dev, ABS_Y, val);
1032 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
1033 input_report_abs(sc->sensor_dev, ABS_Z, val);
1035 input_sync(sc->sensor_dev);
1039 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
1041 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1042 struct hid_input, list);
1043 struct input_dev *input_dev = hidinput->input;
1044 unsigned long flags;
1045 int n, m, offset, num_touch_data, max_touch_data;
1046 u8 cable_state, battery_capacity;
1050 /* When using Bluetooth the header is 2 bytes longer, so skip these. */
1051 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
1053 /* Second bit of third button byte is for the touchpad button. */
1054 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
1055 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1058 * The default behavior of the Dualshock 4 is to send reports using
1059 * report type 1 when running over Bluetooth. However, when feature
1060 * report 2 is requested during the controller initialization it starts
1061 * sending input reports in report 17. Since report 17 is undefined
1062 * in the default HID descriptor, the HID layer won't generate events.
1063 * While it is possible (and this was done before) to fixup the HID
1064 * descriptor to add this mapping, it was better to do this manually.
1065 * The reason is there were various pieces software both open and closed
1066 * source, relying on the descriptors to be the same across various
1067 * operating systems. If the descriptors wouldn't match some
1068 * applications e.g. games on Wine would not be able to function due
1069 * to different descriptors, which such applications are not parsing.
1074 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
1075 input_report_abs(input_dev, ABS_X, rd[offset]);
1076 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
1077 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
1078 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
1080 value = rd[offset+4] & 0xf;
1082 value = 8; /* Center 0, 0 */
1083 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
1084 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
1086 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
1087 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
1088 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
1089 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
1091 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
1092 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
1093 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
1094 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
1095 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
1096 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
1097 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
1098 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
1100 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
1102 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
1103 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
1105 input_sync(input_dev);
1108 /* Convert timestamp (in 5.33us unit) to timestamp_us */
1109 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
1110 timestamp = get_unaligned_le16(&rd[offset]);
1111 if (!sc->timestamp_initialized) {
1112 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1113 sc->timestamp_initialized = true;
1117 if (sc->prev_timestamp > timestamp)
1118 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1120 delta = timestamp - sc->prev_timestamp;
1121 sc->timestamp_us += (delta * 16) / 3;
1123 sc->prev_timestamp = timestamp;
1124 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1126 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
1127 for (n = 0; n < 6; n++) {
1128 /* Store data in int for more precision during mult_frac. */
1129 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1130 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1132 /* High precision is needed during calibration, but the
1133 * calibrated values are within 32-bit.
1134 * Note: we swap numerator 'x' and 'numer' in mult_frac for
1135 * precision reasons so we don't need 64-bit.
1137 int calib_data = mult_frac(calib->sens_numer,
1138 raw_data - calib->bias,
1141 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1144 input_sync(sc->sensor_dev);
1147 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1148 * and the 5th bit contains the USB cable state.
1150 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1151 cable_state = (rd[offset] >> 4) & 0x01;
1154 * Interpretation of the battery_capacity data depends on the cable state.
1155 * When no cable is connected (bit4 is 0):
1156 * - 0:10: percentage in units of 10%.
1157 * When a cable is plugged in:
1158 * - 0-10: percentage in units of 10%.
1159 * - 11: battery is full
1160 * - 14: not charging due to Voltage or temperature error
1161 * - 15: charge error
1164 u8 battery_data = rd[offset] & 0xf;
1166 if (battery_data < 10) {
1167 /* Take the mid-point for each battery capacity value,
1168 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
1169 * This matches official platform behavior, which does
1172 battery_capacity = battery_data * 10 + 5;
1173 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1174 } else if (battery_data == 10) {
1175 battery_capacity = 100;
1176 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1177 } else if (battery_data == 11) {
1178 battery_capacity = 100;
1179 battery_status = POWER_SUPPLY_STATUS_FULL;
1180 } else { /* 14, 15 and undefined values */
1181 battery_capacity = 0;
1182 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1185 u8 battery_data = rd[offset] & 0xf;
1187 if (battery_data < 10)
1188 battery_capacity = battery_data * 10 + 5;
1190 battery_capacity = 100;
1192 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1195 spin_lock_irqsave(&sc->lock, flags);
1196 sc->battery_capacity = battery_capacity;
1197 sc->battery_status = battery_status;
1198 spin_unlock_irqrestore(&sc->lock, flags);
1201 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1202 * and 35 on Bluetooth.
1203 * The first byte indicates the number of touch data in the report.
1204 * Trackpad data starts 2 bytes later (e.g. 35 for USB).
1206 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1207 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1208 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1209 num_touch_data = rd[offset];
1214 for (m = 0; m < num_touch_data; m++) {
1215 /* Skip past timestamp */
1219 * The first 7 bits of the first byte is a counter and bit 8 is
1220 * a touch indicator that is 0 when pressed and 1 when not
1222 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1223 * The data for the second touch is in the same format and
1224 * immediately follows the data for the first.
1226 for (n = 0; n < 2; n++) {
1230 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1231 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1233 active = !(rd[offset] >> 7);
1234 input_mt_slot(sc->touchpad, n);
1235 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1238 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1239 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1244 input_mt_sync_frame(sc->touchpad);
1245 input_sync(sc->touchpad);
1249 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1251 int n, offset, relx, rely;
1255 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
1256 * the touch-related data starts at offset 2.
1257 * For the first byte, bit 0 is set when touchpad button is pressed.
1258 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
1259 * This drag key is mapped to BTN_LEFT. It is operational only when a
1260 * touch point is active.
1261 * Bit 4 is set when only the first touch point is active.
1262 * Bit 6 is set when only the second touch point is active.
1263 * Bits 5 and 7 are set when both touch points are active.
1264 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
1265 * The following byte, offset 5, has the touch width and length.
1266 * Bits 0-4=X (width), bits 5-7=Y (length).
1267 * A signed relative X coordinate is at offset 6.
1268 * The bytes at offset 7-9 are the second touch X/Y coordinates.
1269 * Offset 10 has the second touch width and length.
1270 * Offset 11 has the relative Y coordinate.
1274 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1275 active = (rd[offset] >> 4);
1276 relx = (s8) rd[offset+5];
1277 rely = ((s8) rd[offset+10]) * -1;
1281 for (n = 0; n < 2; n++) {
1283 u8 contactx, contacty;
1285 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1286 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1288 input_mt_slot(sc->touchpad, n);
1289 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1291 if (active & 0x03) {
1292 contactx = rd[offset+3] & 0x0F;
1293 contacty = rd[offset+3] >> 4;
1294 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1295 max(contactx, contacty));
1296 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1297 min(contactx, contacty));
1298 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1299 (bool) (contactx > contacty));
1300 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1301 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1302 NSG_MRXU_MAX_Y - y);
1304 * The relative coordinates belong to the first touch
1305 * point, when present, or to the second touch point
1306 * when the first is not active.
1308 if ((n == 0) || ((n == 1) && (active & 0x01))) {
1309 input_report_rel(sc->touchpad, REL_X, relx);
1310 input_report_rel(sc->touchpad, REL_Y, rely);
1318 input_mt_sync_frame(sc->touchpad);
1320 input_sync(sc->touchpad);
1323 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1326 struct sony_sc *sc = hid_get_drvdata(hdev);
1329 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1330 * has to be BYTE_SWAPPED before passing up to joystick interface
1332 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1334 * When connected via Bluetooth the Sixaxis occasionally sends
1335 * a report with the second byte 0xff and the rest zeroed.
1337 * This report does not reflect the actual state of the
1338 * controller must be ignored to avoid generating false input
1344 swap(rd[41], rd[42]);
1345 swap(rd[43], rd[44]);
1346 swap(rd[45], rd[46]);
1347 swap(rd[47], rd[48]);
1349 sixaxis_parse_report(sc, rd, size);
1350 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1351 sixaxis_parse_report(sc, rd, size);
1352 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1354 sixaxis_parse_report(sc, rd, size);
1355 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1357 dualshock4_parse_report(sc, rd, size);
1358 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1365 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1366 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1367 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1368 if (crc != report_crc) {
1369 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1374 dualshock4_parse_report(sc, rd, size);
1375 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1377 unsigned long flags;
1378 enum ds4_dongle_state dongle_state;
1381 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1382 * if a DS4 is actually connected (indicated by '0').
1383 * For non-dongle, this bit is always 0 (connected).
1385 bool connected = (rd[31] & 0x04) ? false : true;
1387 spin_lock_irqsave(&sc->lock, flags);
1388 dongle_state = sc->ds4_dongle_state;
1389 spin_unlock_irqrestore(&sc->lock, flags);
1392 * The dongle always sends input reports even when no
1393 * DS4 is attached. When a DS4 is connected, we need to
1394 * obtain calibration data before we can use it.
1395 * The code below tracks dongle state and kicks of
1396 * calibration when needed and only allows us to process
1397 * input if a DS4 is actually connected.
1399 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1400 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1403 spin_lock_irqsave(&sc->lock, flags);
1404 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1405 spin_unlock_irqrestore(&sc->lock, flags);
1407 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1409 /* Don't process the report since we don't have
1410 * calibration data, but let hidraw have it anyway.
1413 } else if ((dongle_state == DONGLE_CONNECTED ||
1414 dongle_state == DONGLE_DISABLED) && !connected) {
1415 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1417 spin_lock_irqsave(&sc->lock, flags);
1418 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1419 spin_unlock_irqrestore(&sc->lock, flags);
1421 /* Return 0, so hidraw can get the report. */
1423 } else if (dongle_state == DONGLE_CALIBRATING ||
1424 dongle_state == DONGLE_DISABLED ||
1425 dongle_state == DONGLE_DISCONNECTED) {
1426 /* Return 0, so hidraw can get the report. */
1430 dualshock4_parse_report(sc, rd, size);
1432 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1433 nsg_mrxu_parse_report(sc, rd, size);
1437 if (sc->defer_initialization) {
1438 sc->defer_initialization = 0;
1439 sony_schedule_work(sc, SONY_WORKER_STATE);
1445 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1446 struct hid_field *field, struct hid_usage *usage,
1447 unsigned long **bit, int *max)
1449 struct sony_sc *sc = hid_get_drvdata(hdev);
1451 if (sc->quirks & BUZZ_CONTROLLER) {
1452 unsigned int key = usage->hid & HID_USAGE;
1454 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1457 switch (usage->collection_index) {
1459 if (key >= ARRAY_SIZE(buzz_keymap))
1462 key = buzz_keymap[key];
1470 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1474 if (sc->quirks & PS3REMOTE)
1475 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1477 if (sc->quirks & NAVIGATION_CONTROLLER)
1478 return navigation_mapping(hdev, hi, field, usage, bit, max);
1480 if (sc->quirks & SIXAXIS_CONTROLLER)
1481 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1483 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1484 return ds4_mapping(hdev, hi, field, usage, bit, max);
1486 if (sc->quirks & GH_GUITAR_CONTROLLER)
1487 return guitar_mapping(hdev, hi, field, usage, bit, max);
1489 /* Let hid-core decide for the others */
1493 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1494 int w, int h, int touch_major, int touch_minor, int orientation)
1500 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1504 input_set_drvdata(sc->touchpad, sc);
1505 sc->touchpad->dev.parent = &sc->hdev->dev;
1506 sc->touchpad->phys = sc->hdev->phys;
1507 sc->touchpad->uniq = sc->hdev->uniq;
1508 sc->touchpad->id.bustype = sc->hdev->bus;
1509 sc->touchpad->id.vendor = sc->hdev->vendor;
1510 sc->touchpad->id.product = sc->hdev->product;
1511 sc->touchpad->id.version = sc->hdev->version;
1513 /* Append a suffix to the controller name as there are various
1514 * DS4 compatible non-Sony devices with different names.
1516 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1517 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1520 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1521 sc->touchpad->name = name;
1523 /* We map the button underneath the touchpad to BTN_LEFT. */
1524 __set_bit(EV_KEY, sc->touchpad->evbit);
1525 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1526 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1528 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1529 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1531 if (touch_major > 0) {
1532 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1533 0, touch_major, 0, 0);
1534 if (touch_minor > 0)
1535 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1536 0, touch_minor, 0, 0);
1537 if (orientation > 0)
1538 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1539 0, orientation, 0, 0);
1542 if (sc->quirks & NSG_MRXU_REMOTE) {
1543 __set_bit(EV_REL, sc->touchpad->evbit);
1546 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1550 ret = input_register_device(sc->touchpad);
1557 static int sony_register_sensors(struct sony_sc *sc)
1564 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1565 if (!sc->sensor_dev)
1568 input_set_drvdata(sc->sensor_dev, sc);
1569 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1570 sc->sensor_dev->phys = sc->hdev->phys;
1571 sc->sensor_dev->uniq = sc->hdev->uniq;
1572 sc->sensor_dev->id.bustype = sc->hdev->bus;
1573 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1574 sc->sensor_dev->id.product = sc->hdev->product;
1575 sc->sensor_dev->id.version = sc->hdev->version;
1577 /* Append a suffix to the controller name as there are various
1578 * DS4 compatible non-Sony devices with different names.
1580 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1581 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1584 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1585 sc->sensor_dev->name = name;
1587 if (sc->quirks & SIXAXIS_CONTROLLER) {
1588 /* For the DS3 we only support the accelerometer, which works
1589 * quite well even without calibration. The device also has
1590 * a 1-axis gyro, but it is very difficult to manage from within
1591 * the driver even to get data, the sensor is inaccurate and
1592 * the behavior is very different between hardware revisions.
1594 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1595 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1596 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1597 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1598 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1599 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1600 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1601 range = DS4_ACC_RES_PER_G*4;
1602 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1603 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1604 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1605 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1606 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1607 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1609 range = DS4_GYRO_RES_PER_DEG_S*2048;
1610 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1611 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1612 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1613 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1614 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1615 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1617 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1618 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1621 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1623 ret = input_register_device(sc->sensor_dev);
1631 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1632 * to "operational". Without this, the ps3 controller will not report any
1635 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1637 struct sony_sc *sc = hid_get_drvdata(hdev);
1638 const int buf_size =
1639 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1643 buf = kmalloc(buf_size, GFP_KERNEL);
1647 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1648 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1650 hid_err(hdev, "can't set operational mode: step 1\n");
1655 * Some compatible controllers like the Speedlink Strike FX and
1656 * Gasia need another query plus an USB interrupt to get operational.
1658 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1659 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1661 hid_err(hdev, "can't set operational mode: step 2\n");
1666 * But the USB interrupt would cause SHANWAN controllers to
1667 * start rumbling non-stop, so skip step 3 for these controllers.
1669 if (sc->quirks & SHANWAN_GAMEPAD)
1672 ret = hid_hw_output_report(hdev, buf, 1);
1674 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1684 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1686 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1690 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1694 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1695 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1703 * Request DS4 calibration data for the motion sensors.
1704 * For Bluetooth this also affects the operating mode (see below).
1706 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1710 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1711 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1712 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1713 short gyro_speed_plus, gyro_speed_minus;
1714 short acc_x_plus, acc_x_minus;
1715 short acc_y_plus, acc_y_minus;
1716 short acc_z_plus, acc_z_minus;
1720 /* For Bluetooth we use a different request, which supports CRC.
1721 * Note: in Bluetooth mode feature report 0x02 also changes the state
1722 * of the controller, so that it sends input reports of type 0x11.
1724 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1727 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1731 /* We should normally receive the feature report data we asked
1732 * for, but hidraw applications such as Steam can issue feature
1733 * reports as well. In particular for Dongle reconnects, Steam
1734 * and this function are competing resulting in often receiving
1735 * data for a different HID report, so retry a few times.
1737 for (retries = 0; retries < 3; retries++) {
1738 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1739 DS4_FEATURE_REPORT_0x02_SIZE,
1741 HID_REQ_GET_REPORT);
1745 if (buf[0] != 0x02) {
1747 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1763 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1767 for (retries = 0; retries < 3; retries++) {
1768 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1769 DS4_FEATURE_REPORT_0x05_SIZE,
1771 HID_REQ_GET_REPORT);
1776 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1777 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1778 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1779 if (crc != report_crc) {
1780 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1783 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1795 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1796 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1797 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1798 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1799 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1800 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1801 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1802 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1803 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1804 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1807 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1808 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1809 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1810 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1811 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1812 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1814 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1815 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1816 acc_x_plus = get_unaligned_le16(&buf[23]);
1817 acc_x_minus = get_unaligned_le16(&buf[25]);
1818 acc_y_plus = get_unaligned_le16(&buf[27]);
1819 acc_y_minus = get_unaligned_le16(&buf[29]);
1820 acc_z_plus = get_unaligned_le16(&buf[31]);
1821 acc_z_minus = get_unaligned_le16(&buf[33]);
1823 /* Set gyroscope calibration and normalization parameters.
1824 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1826 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1827 sc->ds4_calib_data[0].abs_code = ABS_RX;
1828 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1829 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1830 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1832 sc->ds4_calib_data[1].abs_code = ABS_RY;
1833 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1834 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1835 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1837 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1838 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1839 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1840 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1842 /* Set accelerometer calibration and normalization parameters.
1843 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1845 range_2g = acc_x_plus - acc_x_minus;
1846 sc->ds4_calib_data[3].abs_code = ABS_X;
1847 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1848 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1849 sc->ds4_calib_data[3].sens_denom = range_2g;
1851 range_2g = acc_y_plus - acc_y_minus;
1852 sc->ds4_calib_data[4].abs_code = ABS_Y;
1853 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1854 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1855 sc->ds4_calib_data[4].sens_denom = range_2g;
1857 range_2g = acc_z_plus - acc_z_minus;
1858 sc->ds4_calib_data[5].abs_code = ABS_Z;
1859 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1860 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1861 sc->ds4_calib_data[5].sens_denom = range_2g;
1868 static void dualshock4_calibration_work(struct work_struct *work)
1870 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1871 unsigned long flags;
1872 enum ds4_dongle_state dongle_state;
1875 ret = dualshock4_get_calibration_data(sc);
1877 /* This call is very unlikely to fail for the dongle. When it
1878 * fails we are probably in a very bad state, so mark the
1879 * dongle as disabled. We will re-enable the dongle if a new
1880 * DS4 hotplug is detect from sony_raw_event as any issues
1881 * are likely resolved then (the dongle is quite stupid).
1883 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1884 dongle_state = DONGLE_DISABLED;
1886 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1887 dongle_state = DONGLE_CONNECTED;
1890 spin_lock_irqsave(&sc->lock, flags);
1891 sc->ds4_dongle_state = dongle_state;
1892 spin_unlock_irqrestore(&sc->lock, flags);
1895 static int dualshock4_get_version_info(struct sony_sc *sc)
1900 buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1904 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1905 DS4_FEATURE_REPORT_0xA3_SIZE,
1907 HID_REQ_GET_REPORT);
1913 sc->hw_version = get_unaligned_le16(&buf[35]);
1914 sc->fw_version = get_unaligned_le16(&buf[41]);
1920 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1922 static const u8 sixaxis_leds[10][4] = {
1923 { 0x01, 0x00, 0x00, 0x00 },
1924 { 0x00, 0x01, 0x00, 0x00 },
1925 { 0x00, 0x00, 0x01, 0x00 },
1926 { 0x00, 0x00, 0x00, 0x01 },
1927 { 0x01, 0x00, 0x00, 0x01 },
1928 { 0x00, 0x01, 0x00, 0x01 },
1929 { 0x00, 0x00, 0x01, 0x01 },
1930 { 0x01, 0x00, 0x01, 0x01 },
1931 { 0x00, 0x01, 0x01, 0x01 },
1932 { 0x01, 0x01, 0x01, 0x01 }
1935 int id = sc->device_id;
1937 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1943 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1946 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1948 /* The first 4 color/index entries match what the PS4 assigns */
1949 static const u8 color_code[7][3] = {
1950 /* Blue */ { 0x00, 0x00, 0x40 },
1951 /* Red */ { 0x40, 0x00, 0x00 },
1952 /* Green */ { 0x00, 0x40, 0x00 },
1953 /* Pink */ { 0x20, 0x00, 0x20 },
1954 /* Orange */ { 0x02, 0x01, 0x00 },
1955 /* Teal */ { 0x00, 0x01, 0x01 },
1956 /* White */ { 0x01, 0x01, 0x01 }
1959 int id = sc->device_id;
1961 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1967 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1970 static void buzz_set_leds(struct sony_sc *sc)
1972 struct hid_device *hdev = sc->hdev;
1973 struct list_head *report_list =
1974 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1975 struct hid_report *report = list_entry(report_list->next,
1976 struct hid_report, list);
1977 s32 *value = report->field[0]->value;
1979 BUILD_BUG_ON(MAX_LEDS < 4);
1982 value[1] = sc->led_state[0] ? 0xff : 0x00;
1983 value[2] = sc->led_state[1] ? 0xff : 0x00;
1984 value[3] = sc->led_state[2] ? 0xff : 0x00;
1985 value[4] = sc->led_state[3] ? 0xff : 0x00;
1988 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1991 static void sony_set_leds(struct sony_sc *sc)
1993 if (!(sc->quirks & BUZZ_CONTROLLER))
1994 sony_schedule_work(sc, SONY_WORKER_STATE);
1999 static void sony_led_set_brightness(struct led_classdev *led,
2000 enum led_brightness value)
2002 struct device *dev = led->dev->parent;
2003 struct hid_device *hdev = to_hid_device(dev);
2004 struct sony_sc *drv_data;
2009 drv_data = hid_get_drvdata(hdev);
2011 hid_err(hdev, "No device data\n");
2016 * The Sixaxis on USB will override any LED settings sent to it
2017 * and keep flashing all of the LEDs until the PS button is pressed.
2018 * Updates, even if redundant, must be always be sent to the
2019 * controller to avoid having to toggle the state of an LED just to
2020 * stop the flashing later on.
2022 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
2024 for (n = 0; n < drv_data->led_count; n++) {
2025 if (led == drv_data->leds[n] && (force_update ||
2026 (value != drv_data->led_state[n] ||
2027 drv_data->led_delay_on[n] ||
2028 drv_data->led_delay_off[n]))) {
2030 drv_data->led_state[n] = value;
2032 /* Setting the brightness stops the blinking */
2033 drv_data->led_delay_on[n] = 0;
2034 drv_data->led_delay_off[n] = 0;
2036 sony_set_leds(drv_data);
2042 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
2044 struct device *dev = led->dev->parent;
2045 struct hid_device *hdev = to_hid_device(dev);
2046 struct sony_sc *drv_data;
2050 drv_data = hid_get_drvdata(hdev);
2052 hid_err(hdev, "No device data\n");
2056 for (n = 0; n < drv_data->led_count; n++) {
2057 if (led == drv_data->leds[n])
2058 return drv_data->led_state[n];
2064 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
2065 unsigned long *delay_off)
2067 struct device *dev = led->dev->parent;
2068 struct hid_device *hdev = to_hid_device(dev);
2069 struct sony_sc *drv_data = hid_get_drvdata(hdev);
2074 hid_err(hdev, "No device data\n");
2078 /* Max delay is 255 deciseconds or 2550 milliseconds */
2079 if (*delay_on > 2550)
2081 if (*delay_off > 2550)
2084 /* Blink at 1 Hz if both values are zero */
2085 if (!*delay_on && !*delay_off)
2086 *delay_on = *delay_off = 500;
2088 new_on = *delay_on / 10;
2089 new_off = *delay_off / 10;
2091 for (n = 0; n < drv_data->led_count; n++) {
2092 if (led == drv_data->leds[n])
2096 /* This LED is not registered on this device */
2097 if (n >= drv_data->led_count)
2100 /* Don't schedule work if the values didn't change */
2101 if (new_on != drv_data->led_delay_on[n] ||
2102 new_off != drv_data->led_delay_off[n]) {
2103 drv_data->led_delay_on[n] = new_on;
2104 drv_data->led_delay_off[n] = new_off;
2105 sony_schedule_work(drv_data, SONY_WORKER_STATE);
2111 static int sony_leds_init(struct sony_sc *sc)
2113 struct hid_device *hdev = sc->hdev;
2116 struct led_classdev *led;
2120 const char *name_fmt;
2121 static const char * const ds4_name_str[] = { "red", "green", "blue",
2123 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
2124 u8 use_hw_blink[MAX_LEDS] = { 0 };
2126 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
2128 if (sc->quirks & BUZZ_CONTROLLER) {
2131 name_len = strlen("::buzz#");
2132 name_fmt = "%s::buzz%d";
2133 /* Validate expected report characteristics. */
2134 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
2136 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2137 dualshock4_set_leds_from_id(sc);
2138 sc->led_state[3] = 1;
2140 memset(max_brightness, 255, 3);
2141 use_hw_blink[3] = 1;
2145 } else if (sc->quirks & MOTION_CONTROLLER) {
2147 memset(max_brightness, 255, 3);
2151 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
2152 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
2154 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2156 memset(use_hw_blink, 1, 4);
2158 name_len = strlen("::sony#");
2159 name_fmt = "%s::sony%d";
2161 sixaxis_set_leds_from_id(sc);
2163 memset(use_hw_blink, 1, 4);
2165 name_len = strlen("::sony#");
2166 name_fmt = "%s::sony%d";
2170 * Clear LEDs as we have no way of reading their initial state. This is
2171 * only relevant if the driver is loaded after somebody actively set the
2176 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2178 for (n = 0; n < sc->led_count; n++) {
2181 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2183 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2185 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2189 name = (void *)(&led[1]);
2191 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2194 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2196 led->brightness = sc->led_state[n];
2197 led->max_brightness = max_brightness[n];
2198 led->flags = LED_CORE_SUSPENDRESUME;
2199 led->brightness_get = sony_led_get_brightness;
2200 led->brightness_set = sony_led_set_brightness;
2202 if (use_hw_blink[n])
2203 led->blink_set = sony_led_blink_set;
2207 ret = devm_led_classdev_register(&hdev->dev, led);
2209 hid_err(hdev, "Failed to register LED %d\n", n);
2217 static void sixaxis_send_output_report(struct sony_sc *sc)
2219 static const union sixaxis_output_report_01 default_report = {
2222 0x01, 0xff, 0x00, 0xff, 0x00,
2223 0x00, 0x00, 0x00, 0x00, 0x00,
2224 0xff, 0x27, 0x10, 0x00, 0x32,
2225 0xff, 0x27, 0x10, 0x00, 0x32,
2226 0xff, 0x27, 0x10, 0x00, 0x32,
2227 0xff, 0x27, 0x10, 0x00, 0x32,
2228 0x00, 0x00, 0x00, 0x00, 0x00
2231 struct sixaxis_output_report *report =
2232 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2235 /* Initialize the report with default values */
2236 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2238 #ifdef CONFIG_SONY_FF
2239 report->rumble.right_motor_on = sc->right ? 1 : 0;
2240 report->rumble.left_motor_force = sc->left;
2243 report->leds_bitmap |= sc->led_state[0] << 1;
2244 report->leds_bitmap |= sc->led_state[1] << 2;
2245 report->leds_bitmap |= sc->led_state[2] << 3;
2246 report->leds_bitmap |= sc->led_state[3] << 4;
2248 /* Set flag for all leds off, required for 3rd party INTEC controller */
2249 if ((report->leds_bitmap & 0x1E) == 0)
2250 report->leds_bitmap |= 0x20;
2253 * The LEDs in the report are indexed in reverse order to their
2254 * corresponding light on the controller.
2255 * Index 0 = LED 4, index 1 = LED 3, etc...
2257 * In the case of both delay values being zero (blinking disabled) the
2258 * default report values should be used or the controller LED will be
2261 for (n = 0; n < 4; n++) {
2262 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2263 report->led[3 - n].duty_off = sc->led_delay_off[n];
2264 report->led[3 - n].duty_on = sc->led_delay_on[n];
2268 /* SHANWAN controllers require output reports via intr channel */
2269 if (sc->quirks & SHANWAN_GAMEPAD)
2270 hid_hw_output_report(sc->hdev, (u8 *)report,
2271 sizeof(struct sixaxis_output_report));
2273 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2274 sizeof(struct sixaxis_output_report),
2275 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2278 static void dualshock4_send_output_report(struct sony_sc *sc)
2280 struct hid_device *hdev = sc->hdev;
2281 u8 *buf = sc->output_report_dmabuf;
2285 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2286 * control the interval at which Dualshock 4 reports data:
2293 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2294 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2296 buf[1] = 0x07; /* blink + LEDs + motor */
2299 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2301 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2302 buf[3] = 0x07; /* blink + LEDs + motor */
2306 #ifdef CONFIG_SONY_FF
2307 buf[offset++] = sc->right;
2308 buf[offset++] = sc->left;
2313 /* LED 3 is the global control */
2314 if (sc->led_state[3]) {
2315 buf[offset++] = sc->led_state[0];
2316 buf[offset++] = sc->led_state[1];
2317 buf[offset++] = sc->led_state[2];
2322 /* If both delay values are zero the DualShock 4 disables blinking. */
2323 buf[offset++] = sc->led_delay_on[3];
2324 buf[offset++] = sc->led_delay_off[3];
2326 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2327 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2329 /* CRC generation */
2333 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2334 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2335 put_unaligned_le32(crc, &buf[74]);
2336 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2340 static void motion_send_output_report(struct sony_sc *sc)
2342 struct hid_device *hdev = sc->hdev;
2343 struct motion_output_report_02 *report =
2344 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2346 memset(report, 0, MOTION_REPORT_0x02_SIZE);
2348 report->type = 0x02; /* set leds */
2349 report->r = sc->led_state[0];
2350 report->g = sc->led_state[1];
2351 report->b = sc->led_state[2];
2353 #ifdef CONFIG_SONY_FF
2354 report->rumble = max(sc->right, sc->left);
2357 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2360 static inline void sony_send_output_report(struct sony_sc *sc)
2362 if (sc->send_output_report)
2363 sc->send_output_report(sc);
2366 static void sony_state_worker(struct work_struct *work)
2368 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2370 sc->send_output_report(sc);
2373 static int sony_allocate_output_report(struct sony_sc *sc)
2375 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2376 (sc->quirks & NAVIGATION_CONTROLLER))
2377 sc->output_report_dmabuf =
2378 devm_kmalloc(&sc->hdev->dev,
2379 sizeof(union sixaxis_output_report_01),
2381 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2382 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2383 DS4_OUTPUT_REPORT_0x11_SIZE,
2385 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2386 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2387 DS4_OUTPUT_REPORT_0x05_SIZE,
2389 else if (sc->quirks & MOTION_CONTROLLER)
2390 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2391 MOTION_REPORT_0x02_SIZE,
2396 if (!sc->output_report_dmabuf)
2402 #ifdef CONFIG_SONY_FF
2403 static int sony_play_effect(struct input_dev *dev, void *data,
2404 struct ff_effect *effect)
2406 struct hid_device *hid = input_get_drvdata(dev);
2407 struct sony_sc *sc = hid_get_drvdata(hid);
2409 if (effect->type != FF_RUMBLE)
2412 sc->left = effect->u.rumble.strong_magnitude / 256;
2413 sc->right = effect->u.rumble.weak_magnitude / 256;
2415 sony_schedule_work(sc, SONY_WORKER_STATE);
2419 static int sony_init_ff(struct sony_sc *sc)
2421 struct hid_input *hidinput;
2422 struct input_dev *input_dev;
2424 if (list_empty(&sc->hdev->inputs)) {
2425 hid_err(sc->hdev, "no inputs found\n");
2428 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2429 input_dev = hidinput->input;
2431 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2432 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2436 static int sony_init_ff(struct sony_sc *sc)
2443 static int sony_battery_get_property(struct power_supply *psy,
2444 enum power_supply_property psp,
2445 union power_supply_propval *val)
2447 struct sony_sc *sc = power_supply_get_drvdata(psy);
2448 unsigned long flags;
2450 u8 battery_capacity;
2453 spin_lock_irqsave(&sc->lock, flags);
2454 battery_capacity = sc->battery_capacity;
2455 battery_status = sc->battery_status;
2456 spin_unlock_irqrestore(&sc->lock, flags);
2459 case POWER_SUPPLY_PROP_PRESENT:
2462 case POWER_SUPPLY_PROP_SCOPE:
2463 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2465 case POWER_SUPPLY_PROP_CAPACITY:
2466 val->intval = battery_capacity;
2468 case POWER_SUPPLY_PROP_STATUS:
2469 val->intval = battery_status;
2478 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2480 const char *battery_str_fmt = append_dev_id ?
2481 "sony_controller_battery_%pMR_%i" :
2482 "sony_controller_battery_%pMR";
2483 struct power_supply_config psy_cfg = { .drv_data = sc, };
2484 struct hid_device *hdev = sc->hdev;
2488 * Set the default battery level to 100% to avoid low battery warnings
2489 * if the battery is polled before the first device report is received.
2491 sc->battery_capacity = 100;
2493 sc->battery_desc.properties = sony_battery_props;
2494 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2495 sc->battery_desc.get_property = sony_battery_get_property;
2496 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2497 sc->battery_desc.use_for_apm = 0;
2498 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2499 battery_str_fmt, sc->mac_address, sc->device_id);
2500 if (!sc->battery_desc.name)
2503 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2505 if (IS_ERR(sc->battery)) {
2506 ret = PTR_ERR(sc->battery);
2507 hid_err(hdev, "Unable to register battery device\n");
2511 power_supply_powers(sc->battery, &hdev->dev);
2516 * If a controller is plugged in via USB while already connected via Bluetooth
2517 * it will show up as two devices. A global list of connected controllers and
2518 * their MAC addresses is maintained to ensure that a device is only connected
2521 * Some USB-only devices masquerade as Sixaxis controllers and all have the
2522 * same dummy Bluetooth address, so a comparison of the connection type is
2523 * required. Devices are only rejected in the case where two devices have
2524 * matching Bluetooth addresses on different bus types.
2526 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2527 struct sony_sc *sc1)
2529 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2530 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2532 return sc0_not_bt == sc1_not_bt;
2535 static int sony_check_add_dev_list(struct sony_sc *sc)
2537 struct sony_sc *entry;
2538 unsigned long flags;
2541 spin_lock_irqsave(&sony_dev_list_lock, flags);
2543 list_for_each_entry(entry, &sony_device_list, list_node) {
2544 ret = memcmp(sc->mac_address, entry->mac_address,
2545 sizeof(sc->mac_address));
2547 if (sony_compare_connection_type(sc, entry)) {
2552 "controller with MAC address %pMR already connected\n",
2560 list_add(&(sc->list_node), &sony_device_list);
2563 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2567 static void sony_remove_dev_list(struct sony_sc *sc)
2569 unsigned long flags;
2571 if (sc->list_node.next) {
2572 spin_lock_irqsave(&sony_dev_list_lock, flags);
2573 list_del(&(sc->list_node));
2574 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2578 static int sony_get_bt_devaddr(struct sony_sc *sc)
2582 /* HIDP stores the device MAC address as a string in the uniq field. */
2583 ret = strlen(sc->hdev->uniq);
2587 ret = sscanf(sc->hdev->uniq,
2588 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2589 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2590 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2598 static int sony_check_add(struct sony_sc *sc)
2603 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2604 (sc->quirks & MOTION_CONTROLLER_BT) ||
2605 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2606 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2608 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2609 * address from the uniq string where HIDP stores it.
2610 * As uniq cannot be guaranteed to be a MAC address in all cases
2611 * a failure of this function should not prevent the connection.
2613 if (sony_get_bt_devaddr(sc) < 0) {
2614 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2617 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2618 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2623 * The MAC address of a DS4 controller connected via USB can be
2624 * retrieved with feature report 0x81. The address begins at
2627 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2628 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2629 HID_REQ_GET_REPORT);
2631 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2632 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2633 ret = ret < 0 ? ret : -EINVAL;
2637 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2639 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2640 "%pMR", sc->mac_address);
2641 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2642 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2643 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2648 * The MAC address of a Sixaxis controller connected via USB can
2649 * be retrieved with feature report 0xf2. The address begins at
2652 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2653 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2654 HID_REQ_GET_REPORT);
2656 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2657 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2658 ret = ret < 0 ? ret : -EINVAL;
2663 * The Sixaxis device MAC in the report is big-endian and must
2666 for (n = 0; n < 6; n++)
2667 sc->mac_address[5-n] = buf[4+n];
2669 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2670 "%pMR", sc->mac_address);
2675 ret = sony_check_add_dev_list(sc);
2684 static int sony_set_device_id(struct sony_sc *sc)
2689 * Only DualShock 4 or Sixaxis controllers get an id.
2690 * All others are set to -1.
2692 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2693 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2694 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2700 sc->device_id = ret;
2708 static void sony_release_device_id(struct sony_sc *sc)
2710 if (sc->device_id >= 0) {
2711 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2716 static inline void sony_init_output_report(struct sony_sc *sc,
2717 void (*send_output_report)(struct sony_sc *))
2719 sc->send_output_report = send_output_report;
2721 if (!sc->state_worker_initialized)
2722 INIT_WORK(&sc->state_worker, sony_state_worker);
2724 sc->state_worker_initialized = 1;
2727 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2729 unsigned long flags;
2731 if (sc->hotplug_worker_initialized)
2732 cancel_work_sync(&sc->hotplug_worker);
2733 if (sc->state_worker_initialized) {
2734 spin_lock_irqsave(&sc->lock, flags);
2735 sc->state_worker_initialized = 0;
2736 spin_unlock_irqrestore(&sc->lock, flags);
2737 cancel_work_sync(&sc->state_worker);
2741 static int sony_input_configured(struct hid_device *hdev,
2742 struct hid_input *hidinput)
2744 struct sony_sc *sc = hid_get_drvdata(hdev);
2748 ret = sony_set_device_id(sc);
2750 hid_err(hdev, "failed to allocate the device id\n");
2754 ret = append_dev_id = sony_check_add(sc);
2758 ret = sony_allocate_output_report(sc);
2760 hid_err(hdev, "failed to allocate the output report buffer\n");
2764 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2766 * The Sony Sixaxis does not handle HID Output Reports on the
2767 * Interrupt EP like it could, so we need to force HID Output
2768 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2770 * There is also another issue about HID Output Reports via USB,
2771 * the Sixaxis does not want the report_id as part of the data
2772 * packet, so we have to discard buf[0] when sending the actual
2773 * control message, even for numbered reports, humpf!
2775 * Additionally, the Sixaxis on USB isn't properly initialized
2776 * until the PS logo button is pressed and as such won't retain
2777 * any state set by an output report, so the initial
2778 * configuration report is deferred until the first input
2781 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2782 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2783 sc->defer_initialization = 1;
2785 ret = sixaxis_set_operational_usb(hdev);
2787 hid_err(hdev, "Failed to set controller into operational mode\n");
2791 sony_init_output_report(sc, sixaxis_send_output_report);
2792 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2794 * The Navigation controller wants output reports sent on the ctrl
2795 * endpoint when connected via Bluetooth.
2797 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2799 ret = sixaxis_set_operational_bt(hdev);
2801 hid_err(hdev, "Failed to set controller into operational mode\n");
2805 sony_init_output_report(sc, sixaxis_send_output_report);
2806 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2808 * The Sony Sixaxis does not handle HID Output Reports on the
2809 * Interrupt EP and the device only becomes active when the
2810 * PS button is pressed. See comment for Navigation controller
2811 * above for more details.
2813 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2814 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2815 sc->defer_initialization = 1;
2817 ret = sixaxis_set_operational_usb(hdev);
2819 hid_err(hdev, "Failed to set controller into operational mode\n");
2823 ret = sony_register_sensors(sc);
2826 "Unable to initialize motion sensors: %d\n", ret);
2830 sony_init_output_report(sc, sixaxis_send_output_report);
2831 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2833 * The Sixaxis wants output reports sent on the ctrl endpoint
2834 * when connected via Bluetooth.
2836 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2838 ret = sixaxis_set_operational_bt(hdev);
2840 hid_err(hdev, "Failed to set controller into operational mode\n");
2844 ret = sony_register_sensors(sc);
2847 "Unable to initialize motion sensors: %d\n", ret);
2851 sony_init_output_report(sc, sixaxis_send_output_report);
2852 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2853 ret = dualshock4_get_calibration_data(sc);
2855 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2859 ret = dualshock4_get_version_info(sc);
2861 hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2865 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2867 hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2870 sc->fw_version_created = true;
2872 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2874 hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2877 sc->hw_version_created = true;
2880 * The Dualshock 4 touchpad supports 2 touches and has a
2881 * resolution of 1920x942 (44.86 dots/mm).
2883 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2886 "Unable to initialize multi-touch slots: %d\n",
2891 ret = sony_register_sensors(sc);
2894 "Unable to initialize motion sensors: %d\n", ret);
2898 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2899 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2900 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2903 "can't create sysfs bt_poll_interval attribute err: %d\n",
2907 if (sc->quirks & DUALSHOCK4_DONGLE) {
2908 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2909 sc->hotplug_worker_initialized = 1;
2910 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2913 sony_init_output_report(sc, dualshock4_send_output_report);
2914 } else if (sc->quirks & NSG_MRXU_REMOTE) {
2916 * The NSG-MRxU touchpad supports 2 touches and has a
2917 * resolution of 1667x1868
2919 ret = sony_register_touchpad(sc, 2,
2920 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2923 "Unable to initialize multi-touch slots: %d\n",
2928 } else if (sc->quirks & MOTION_CONTROLLER) {
2929 sony_init_output_report(sc, motion_send_output_report);
2934 if (sc->quirks & SONY_LED_SUPPORT) {
2935 ret = sony_leds_init(sc);
2940 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2941 ret = sony_battery_probe(sc, append_dev_id);
2945 /* Open the device to receive reports with battery info */
2946 ret = hid_hw_open(hdev);
2948 hid_err(hdev, "hw open failed\n");
2953 if (sc->quirks & SONY_FF_SUPPORT) {
2954 ret = sony_init_ff(sc);
2963 /* Piggy back on the default ds4_bt_ poll_interval to determine
2964 * if we need to remove the file as we don't know for sure if we
2965 * executed that logic.
2967 if (sc->ds4_bt_poll_interval)
2968 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2969 if (sc->fw_version_created)
2970 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2971 if (sc->hw_version_created)
2972 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2973 sony_cancel_work_sync(sc);
2974 sony_remove_dev_list(sc);
2975 sony_release_device_id(sc);
2979 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2982 unsigned long quirks = id->driver_data;
2984 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2986 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2987 quirks |= FUTUREMAX_DANCE_MAT;
2989 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad"))
2990 quirks |= SHANWAN_GAMEPAD;
2992 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2994 hid_err(hdev, "can't alloc sony descriptor\n");
2998 spin_lock_init(&sc->lock);
3000 sc->quirks = quirks;
3001 hid_set_drvdata(hdev, sc);
3004 ret = hid_parse(hdev);
3006 hid_err(hdev, "parse failed\n");
3010 if (sc->quirks & VAIO_RDESC_CONSTANT)
3011 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3012 else if (sc->quirks & SIXAXIS_CONTROLLER)
3013 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3015 /* Patch the hw version on DS3/4 compatible devices, so applications can
3016 * distinguish between the default HID mappings and the mappings defined
3017 * by the Linux game controller spec. This is important for the SDL2
3018 * library, which has a game controller database, which uses device ids
3019 * in combination with version as a key.
3021 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
3022 hdev->version |= 0x8000;
3024 ret = hid_hw_start(hdev, connect_mask);
3026 hid_err(hdev, "hw start failed\n");
3030 /* sony_input_configured can fail, but this doesn't result
3031 * in hid_hw_start failures (intended). Check whether
3032 * the HID layer claimed the device else fail.
3033 * We don't know the actual reason for the failure, most
3034 * likely it is due to EEXIST in case of double connection
3035 * of USB and Bluetooth, but could have been due to ENOMEM
3036 * or other reasons as well.
3038 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
3039 hid_err(hdev, "failed to claim input\n");
3044 if (sc->quirks & GHL_GUITAR_PS3WIIU) {
3045 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
3046 mod_timer(&sc->ghl_poke_timer,
3047 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
3053 static void sony_remove(struct hid_device *hdev)
3055 struct sony_sc *sc = hid_get_drvdata(hdev);
3057 if (sc->quirks & GHL_GUITAR_PS3WIIU)
3058 del_timer_sync(&sc->ghl_poke_timer);
3062 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
3063 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
3065 if (sc->fw_version_created)
3066 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
3068 if (sc->hw_version_created)
3069 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
3071 sony_cancel_work_sync(sc);
3073 sony_remove_dev_list(sc);
3075 sony_release_device_id(sc);
3082 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
3084 #ifdef CONFIG_SONY_FF
3086 /* On suspend stop any running force-feedback events */
3087 if (SONY_FF_SUPPORT) {
3088 struct sony_sc *sc = hid_get_drvdata(hdev);
3090 sc->left = sc->right = 0;
3091 sony_send_output_report(sc);
3098 static int sony_resume(struct hid_device *hdev)
3100 struct sony_sc *sc = hid_get_drvdata(hdev);
3103 * The Sixaxis and navigation controllers on USB need to be
3104 * reinitialized on resume or they won't behave properly.
3106 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
3107 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
3108 sixaxis_set_operational_usb(sc->hdev);
3109 sc->defer_initialization = 1;
3117 static const struct hid_device_id sony_devices[] = {
3118 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3119 .driver_data = SIXAXIS_CONTROLLER_USB },
3120 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
3121 .driver_data = NAVIGATION_CONTROLLER_USB },
3122 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
3123 .driver_data = NAVIGATION_CONTROLLER_BT },
3124 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
3125 .driver_data = MOTION_CONTROLLER_USB },
3126 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
3127 .driver_data = MOTION_CONTROLLER_BT },
3128 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3129 .driver_data = SIXAXIS_CONTROLLER_BT },
3130 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
3131 .driver_data = VAIO_RDESC_CONSTANT },
3132 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
3133 .driver_data = VAIO_RDESC_CONSTANT },
3135 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
3136 * Logitech joystick from the device descriptor.
3138 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
3139 .driver_data = BUZZ_CONTROLLER },
3140 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
3141 .driver_data = BUZZ_CONTROLLER },
3142 /* PS3 BD Remote Control */
3143 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
3144 .driver_data = PS3REMOTE },
3145 /* Logitech Harmony Adapter for PS3 */
3146 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
3147 .driver_data = PS3REMOTE },
3148 /* SMK-Link PS3 BD Remote Control */
3149 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
3150 .driver_data = PS3REMOTE },
3151 /* Sony Dualshock 4 controllers for PS4 */
3152 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3153 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3154 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3155 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3156 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3157 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3158 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3159 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3160 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
3161 .driver_data = DUALSHOCK4_DONGLE },
3162 /* Nyko Core Controller for PS3 */
3163 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
3164 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
3165 /* SMK-Link NSG-MR5U Remote Control */
3166 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3167 .driver_data = NSG_MR5U_REMOTE_BT },
3168 /* SMK-Link NSG-MR7U Remote Control */
3169 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3170 .driver_data = NSG_MR7U_REMOTE_BT },
3171 /* Guitar Hero Live PS3 and Wii U guitar dongles */
3172 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
3173 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
3174 /* Guitar Hero PC Guitar Dongle */
3175 { HID_USB_DEVICE(USB_VENDOR_ID_ACTIVISION, USB_DEVICE_ID_ACTIVISION_GUITAR_DONGLE),
3176 .driver_data = GH_GUITAR_CONTROLLER },
3177 /* Guitar Hero PS3 World Tour Guitar Dongle */
3178 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
3179 .driver_data = GH_GUITAR_CONTROLLER },
3182 MODULE_DEVICE_TABLE(hid, sony_devices);
3184 static struct hid_driver sony_driver = {
3186 .id_table = sony_devices,
3187 .input_mapping = sony_mapping,
3188 .input_configured = sony_input_configured,
3189 .probe = sony_probe,
3190 .remove = sony_remove,
3191 .report_fixup = sony_report_fixup,
3192 .raw_event = sony_raw_event,
3195 .suspend = sony_suspend,
3196 .resume = sony_resume,
3197 .reset_resume = sony_resume,
3201 static int __init sony_init(void)
3203 dbg_hid("Sony:%s\n", __func__);
3205 return hid_register_driver(&sony_driver);
3208 static void __exit sony_exit(void)
3210 dbg_hid("Sony:%s\n", __func__);
3212 hid_unregister_driver(&sony_driver);
3213 ida_destroy(&sony_device_id_allocator);
3215 module_init(sony_init);
3216 module_exit(sony_exit);
3218 MODULE_LICENSE("GPL");