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-2021 Pascal Giard <pascal.giard@etsmtl.ca>
15 * Copyright (c) 2020 Sanjay Govind <sanjay.govind9@gmail.com>
16 * Copyright (c) 2021 Daniel Nguyen <daniel.nguyen.1@ens.etsmtl.ca>
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.
27 * There will be no PIN request from the device.
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 <linux/usb.h>
42 #include <linux/timer.h>
43 #include <asm/unaligned.h>
47 #define VAIO_RDESC_CONSTANT BIT(0)
48 #define SIXAXIS_CONTROLLER_USB BIT(1)
49 #define SIXAXIS_CONTROLLER_BT BIT(2)
50 #define BUZZ_CONTROLLER BIT(3)
51 #define PS3REMOTE BIT(4)
52 #define DUALSHOCK4_CONTROLLER_USB BIT(5)
53 #define DUALSHOCK4_CONTROLLER_BT BIT(6)
54 #define DUALSHOCK4_DONGLE BIT(7)
55 #define MOTION_CONTROLLER_USB BIT(8)
56 #define MOTION_CONTROLLER_BT BIT(9)
57 #define NAVIGATION_CONTROLLER_USB BIT(10)
58 #define NAVIGATION_CONTROLLER_BT BIT(11)
59 #define SINO_LITE_CONTROLLER BIT(12)
60 #define FUTUREMAX_DANCE_MAT BIT(13)
61 #define NSG_MR5U_REMOTE_BT BIT(14)
62 #define NSG_MR7U_REMOTE_BT BIT(15)
63 #define SHANWAN_GAMEPAD BIT(16)
64 #define GH_GUITAR_CONTROLLER BIT(17)
65 #define GHL_GUITAR_PS3WIIU BIT(18)
66 #define GHL_GUITAR_PS4 BIT(19)
68 #define SIXAXIS_CONTROLLER (SIXAXIS_CONTROLLER_USB | SIXAXIS_CONTROLLER_BT)
69 #define MOTION_CONTROLLER (MOTION_CONTROLLER_USB | MOTION_CONTROLLER_BT)
70 #define NAVIGATION_CONTROLLER (NAVIGATION_CONTROLLER_USB |\
71 NAVIGATION_CONTROLLER_BT)
72 #define DUALSHOCK4_CONTROLLER (DUALSHOCK4_CONTROLLER_USB |\
73 DUALSHOCK4_CONTROLLER_BT | \
75 #define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER | BUZZ_CONTROLLER |\
76 DUALSHOCK4_CONTROLLER | MOTION_CONTROLLER |\
77 NAVIGATION_CONTROLLER)
78 #define SONY_BATTERY_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
79 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER)
80 #define SONY_FF_SUPPORT (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER |\
82 #define SONY_BT_DEVICE (SIXAXIS_CONTROLLER_BT | DUALSHOCK4_CONTROLLER_BT |\
83 MOTION_CONTROLLER_BT | NAVIGATION_CONTROLLER_BT)
84 #define NSG_MRXU_REMOTE (NSG_MR5U_REMOTE_BT | NSG_MR7U_REMOTE_BT)
87 #define NSG_MRXU_MAX_X 1667
88 #define NSG_MRXU_MAX_Y 1868
90 /* The PS3/Wii U dongles require a poke every 10 seconds, but the PS4
91 * requires one every 8 seconds. Using 8 seconds for all for simplicity.
93 #define GHL_GUITAR_POKE_INTERVAL 8 /* In seconds */
94 #define GUITAR_TILT_USAGE 44
96 /* Magic data taken from GHLtarUtility:
97 * https://github.com/ghlre/GHLtarUtility/blob/master/PS3Guitar.cs
98 * Note: The Wii U and PS3 dongles happen to share the same!
100 static const char ghl_ps3wiiu_magic_data[] = {
101 0x02, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00
104 /* Magic data for the PS4 dongles sniffed with a USB protocol
107 static const char ghl_ps4_magic_data[] = {
108 0x30, 0x02, 0x08, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00
111 /* PS/3 Motion controller */
112 static u8 motion_rdesc[] = {
113 0x05, 0x01, /* Usage Page (Desktop), */
114 0x09, 0x04, /* Usage (Joystick), */
115 0xA1, 0x01, /* Collection (Application), */
116 0xA1, 0x02, /* Collection (Logical), */
117 0x85, 0x01, /* Report ID (1), */
118 0x75, 0x01, /* Report Size (1), */
119 0x95, 0x15, /* Report Count (21), */
120 0x15, 0x00, /* Logical Minimum (0), */
121 0x25, 0x01, /* Logical Maximum (1), */
122 0x35, 0x00, /* Physical Minimum (0), */
123 0x45, 0x01, /* Physical Maximum (1), */
124 0x05, 0x09, /* Usage Page (Button), */
125 0x19, 0x01, /* Usage Minimum (01h), */
126 0x29, 0x15, /* Usage Maximum (15h), */
127 0x81, 0x02, /* Input (Variable), * Buttons */
128 0x95, 0x0B, /* Report Count (11), */
129 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
130 0x81, 0x03, /* Input (Constant, Variable), * Padding */
131 0x15, 0x00, /* Logical Minimum (0), */
132 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
133 0x05, 0x01, /* Usage Page (Desktop), */
134 0xA1, 0x00, /* Collection (Physical), */
135 0x75, 0x08, /* Report Size (8), */
136 0x95, 0x01, /* Report Count (1), */
137 0x35, 0x00, /* Physical Minimum (0), */
138 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
139 0x09, 0x30, /* Usage (X), */
140 0x81, 0x02, /* Input (Variable), * Trigger */
141 0xC0, /* End Collection, */
142 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
143 0x75, 0x08, /* Report Size (8), */
144 0x95, 0x07, /* Report Count (7), * skip 7 bytes */
145 0x81, 0x02, /* Input (Variable), */
146 0x05, 0x01, /* Usage Page (Desktop), */
147 0x75, 0x10, /* Report Size (16), */
148 0x46, 0xFF, 0xFF, /* Physical Maximum (65535), */
149 0x27, 0xFF, 0xFF, 0x00, 0x00, /* Logical Maximum (65535), */
150 0x95, 0x03, /* Report Count (3), * 3x Accels */
151 0x09, 0x33, /* Usage (rX), */
152 0x09, 0x34, /* Usage (rY), */
153 0x09, 0x35, /* Usage (rZ), */
154 0x81, 0x02, /* Input (Variable), */
155 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
156 0x95, 0x03, /* Report Count (3), * Skip Accels 2nd frame */
157 0x81, 0x02, /* Input (Variable), */
158 0x05, 0x01, /* Usage Page (Desktop), */
159 0x09, 0x01, /* Usage (Pointer), */
160 0x95, 0x03, /* Report Count (3), * 3x Gyros */
161 0x81, 0x02, /* Input (Variable), */
162 0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
163 0x95, 0x03, /* Report Count (3), * Skip Gyros 2nd frame */
164 0x81, 0x02, /* Input (Variable), */
165 0x75, 0x0C, /* Report Size (12), */
166 0x46, 0xFF, 0x0F, /* Physical Maximum (4095), */
167 0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
168 0x95, 0x04, /* Report Count (4), * Skip Temp and Magnetometers */
169 0x81, 0x02, /* Input (Variable), */
170 0x75, 0x08, /* Report Size (8), */
171 0x46, 0xFF, 0x00, /* Physical Maximum (255), */
172 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
173 0x95, 0x06, /* Report Count (6), * Skip Timestamp and Extension Bytes */
174 0x81, 0x02, /* Input (Variable), */
175 0x75, 0x08, /* Report Size (8), */
176 0x95, 0x30, /* Report Count (48), */
177 0x09, 0x01, /* Usage (Pointer), */
178 0x91, 0x02, /* Output (Variable), */
179 0x75, 0x08, /* Report Size (8), */
180 0x95, 0x30, /* Report Count (48), */
181 0x09, 0x01, /* Usage (Pointer), */
182 0xB1, 0x02, /* Feature (Variable), */
183 0xC0, /* End Collection, */
184 0xA1, 0x02, /* Collection (Logical), */
185 0x85, 0x02, /* Report ID (2), */
186 0x75, 0x08, /* Report Size (8), */
187 0x95, 0x30, /* Report Count (48), */
188 0x09, 0x01, /* Usage (Pointer), */
189 0xB1, 0x02, /* Feature (Variable), */
190 0xC0, /* End Collection, */
191 0xA1, 0x02, /* Collection (Logical), */
192 0x85, 0xEE, /* Report ID (238), */
193 0x75, 0x08, /* Report Size (8), */
194 0x95, 0x30, /* Report Count (48), */
195 0x09, 0x01, /* Usage (Pointer), */
196 0xB1, 0x02, /* Feature (Variable), */
197 0xC0, /* End Collection, */
198 0xA1, 0x02, /* Collection (Logical), */
199 0x85, 0xEF, /* Report ID (239), */
200 0x75, 0x08, /* Report Size (8), */
201 0x95, 0x30, /* Report Count (48), */
202 0x09, 0x01, /* Usage (Pointer), */
203 0xB1, 0x02, /* Feature (Variable), */
204 0xC0, /* End Collection, */
205 0xC0 /* End Collection */
208 static u8 ps3remote_rdesc[] = {
209 0x05, 0x01, /* GUsagePage Generic Desktop */
210 0x09, 0x05, /* LUsage 0x05 [Game Pad] */
211 0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
213 /* Use collection 1 for joypad buttons */
214 0xA1, 0x02, /* MCollection Logical (interrelated data) */
217 * Ignore the 1st byte, maybe it is used for a controller
218 * number but it's not needed for correct operation
220 0x75, 0x08, /* GReportSize 0x08 [8] */
221 0x95, 0x01, /* GReportCount 0x01 [1] */
222 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
225 * Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
226 * buttons multiple keypresses are allowed
228 0x05, 0x09, /* GUsagePage Button */
229 0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
230 0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
231 0x14, /* GLogicalMinimum [0] */
232 0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
233 0x75, 0x01, /* GReportSize 0x01 [1] */
234 0x95, 0x18, /* GReportCount 0x18 [24] */
235 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
237 0xC0, /* MEndCollection */
239 /* Use collection 2 for remote control buttons */
240 0xA1, 0x02, /* MCollection Logical (interrelated data) */
242 /* 5th byte is used for remote control buttons */
243 0x05, 0x09, /* GUsagePage Button */
244 0x18, /* LUsageMinimum [No button pressed] */
245 0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
246 0x14, /* GLogicalMinimum [0] */
247 0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
248 0x75, 0x08, /* GReportSize 0x08 [8] */
249 0x95, 0x01, /* GReportCount 0x01 [1] */
253 * Ignore bytes from 6th to 11th, 6th to 10th are always constant at
254 * 0xff and 11th is for press indication
256 0x75, 0x08, /* GReportSize 0x08 [8] */
257 0x95, 0x06, /* GReportCount 0x06 [6] */
258 0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
260 /* 12th byte is for battery strength */
261 0x05, 0x06, /* GUsagePage Generic Device Controls */
262 0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
263 0x14, /* GLogicalMinimum [0] */
264 0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
265 0x75, 0x08, /* GReportSize 0x08 [8] */
266 0x95, 0x01, /* GReportCount 0x01 [1] */
267 0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
269 0xC0, /* MEndCollection */
271 0xC0 /* MEndCollection [Game Pad] */
274 static const unsigned int ps3remote_keymap_joypad_buttons[] = {
276 [0x02] = BTN_THUMBL, /* L3 */
277 [0x03] = BTN_THUMBR, /* R3 */
283 [0x09] = BTN_TL2, /* L2 */
284 [0x0a] = BTN_TR2, /* R2 */
285 [0x0b] = BTN_TL, /* L1 */
286 [0x0c] = BTN_TR, /* R1 */
287 [0x0d] = KEY_OPTION, /* options/triangle */
288 [0x0e] = KEY_BACK, /* back/circle */
289 [0x0f] = BTN_0, /* cross */
290 [0x10] = KEY_SCREEN, /* view/square */
291 [0x11] = KEY_HOMEPAGE, /* PS button */
294 static const unsigned int ps3remote_keymap_remote_buttons[] = {
305 [0x0e] = KEY_ESC, /* return */
307 [0x16] = KEY_EJECTCD,
308 [0x1a] = KEY_MENU, /* top menu */
310 [0x30] = KEY_PREVIOUS,
313 [0x33] = KEY_REWIND, /* scan back */
314 [0x34] = KEY_FORWARD, /* scan forward */
317 [0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
318 [0x60] = KEY_FRAMEBACK, /* slow/step back */
319 [0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
320 [0x63] = KEY_SUBTITLE,
323 [0x70] = KEY_INFO, /* display */
330 static const unsigned int buzz_keymap[] = {
332 * The controller has 4 remote buzzers, each with one LED and 5
335 * We use the mapping chosen by the controller, which is:
338 * -------------------
345 * So, for example, the orange button on the third buzzer is mapped to
346 * BTN_TRIGGER_HAPPY14
348 [1] = BTN_TRIGGER_HAPPY1,
349 [2] = BTN_TRIGGER_HAPPY2,
350 [3] = BTN_TRIGGER_HAPPY3,
351 [4] = BTN_TRIGGER_HAPPY4,
352 [5] = BTN_TRIGGER_HAPPY5,
353 [6] = BTN_TRIGGER_HAPPY6,
354 [7] = BTN_TRIGGER_HAPPY7,
355 [8] = BTN_TRIGGER_HAPPY8,
356 [9] = BTN_TRIGGER_HAPPY9,
357 [10] = BTN_TRIGGER_HAPPY10,
358 [11] = BTN_TRIGGER_HAPPY11,
359 [12] = BTN_TRIGGER_HAPPY12,
360 [13] = BTN_TRIGGER_HAPPY13,
361 [14] = BTN_TRIGGER_HAPPY14,
362 [15] = BTN_TRIGGER_HAPPY15,
363 [16] = BTN_TRIGGER_HAPPY16,
364 [17] = BTN_TRIGGER_HAPPY17,
365 [18] = BTN_TRIGGER_HAPPY18,
366 [19] = BTN_TRIGGER_HAPPY19,
367 [20] = BTN_TRIGGER_HAPPY20,
370 /* The Navigation controller is a partial DS3 and uses the same HID report
371 * and hence the same keymap indices, however not all axes/buttons
372 * are physically present. We use the same axis and button mapping as
373 * the DS3, which uses the Linux gamepad spec.
375 static const unsigned int navigation_absmap[] = {
378 [0x33] = ABS_Z, /* L2 */
381 /* Buttons not physically available on the device, but still available
382 * in the reports are explicitly set to 0 for documentation purposes.
384 static const unsigned int navigation_keymap[] = {
385 [0x01] = 0, /* Select */
386 [0x02] = BTN_THUMBL, /* L3 */
388 [0x04] = 0, /* Start */
389 [0x05] = BTN_DPAD_UP, /* Up */
390 [0x06] = BTN_DPAD_RIGHT, /* Right */
391 [0x07] = BTN_DPAD_DOWN, /* Down */
392 [0x08] = BTN_DPAD_LEFT, /* Left */
393 [0x09] = BTN_TL2, /* L2 */
395 [0x0b] = BTN_TL, /* L1 */
397 [0x0d] = BTN_NORTH, /* Triangle */
398 [0x0e] = BTN_EAST, /* Circle */
399 [0x0f] = BTN_SOUTH, /* Cross */
400 [0x10] = BTN_WEST, /* Square */
401 [0x11] = BTN_MODE, /* PS */
404 static const unsigned int sixaxis_absmap[] = {
407 [0x32] = ABS_RX, /* right stick X */
408 [0x35] = ABS_RY, /* right stick Y */
411 static const unsigned int sixaxis_keymap[] = {
412 [0x01] = BTN_SELECT, /* Select */
413 [0x02] = BTN_THUMBL, /* L3 */
414 [0x03] = BTN_THUMBR, /* R3 */
415 [0x04] = BTN_START, /* Start */
416 [0x05] = BTN_DPAD_UP, /* Up */
417 [0x06] = BTN_DPAD_RIGHT, /* Right */
418 [0x07] = BTN_DPAD_DOWN, /* Down */
419 [0x08] = BTN_DPAD_LEFT, /* Left */
420 [0x09] = BTN_TL2, /* L2 */
421 [0x0a] = BTN_TR2, /* R2 */
422 [0x0b] = BTN_TL, /* L1 */
423 [0x0c] = BTN_TR, /* R1 */
424 [0x0d] = BTN_NORTH, /* Triangle */
425 [0x0e] = BTN_EAST, /* Circle */
426 [0x0f] = BTN_SOUTH, /* Cross */
427 [0x10] = BTN_WEST, /* Square */
428 [0x11] = BTN_MODE, /* PS */
431 static const unsigned int ds4_absmap[] = {
434 [0x32] = ABS_RX, /* right stick X */
435 [0x33] = ABS_Z, /* L2 */
436 [0x34] = ABS_RZ, /* R2 */
437 [0x35] = ABS_RY, /* right stick Y */
440 static const unsigned int ds4_keymap[] = {
441 [0x1] = BTN_WEST, /* Square */
442 [0x2] = BTN_SOUTH, /* Cross */
443 [0x3] = BTN_EAST, /* Circle */
444 [0x4] = BTN_NORTH, /* Triangle */
445 [0x5] = BTN_TL, /* L1 */
446 [0x6] = BTN_TR, /* R1 */
447 [0x7] = BTN_TL2, /* L2 */
448 [0x8] = BTN_TR2, /* R2 */
449 [0x9] = BTN_SELECT, /* Share */
450 [0xa] = BTN_START, /* Options */
451 [0xb] = BTN_THUMBL, /* L3 */
452 [0xc] = BTN_THUMBR, /* R3 */
453 [0xd] = BTN_MODE, /* PS */
456 static const struct {int x; int y; } ds4_hat_mapping[] = {
457 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
461 static enum power_supply_property sony_battery_props[] = {
462 POWER_SUPPLY_PROP_PRESENT,
463 POWER_SUPPLY_PROP_CAPACITY,
464 POWER_SUPPLY_PROP_SCOPE,
465 POWER_SUPPLY_PROP_STATUS,
469 u8 time_enabled; /* the total time the led is active (0xff means forever) */
470 u8 duty_length; /* how long a cycle is in deciseconds (0 means "really fast") */
472 u8 duty_off; /* % of duty_length the led is off (0xff means 100%) */
473 u8 duty_on; /* % of duty_length the led is on (0xff mean 100%) */
476 struct sixaxis_rumble {
478 u8 right_duration; /* Right motor duration (0xff means forever) */
479 u8 right_motor_on; /* Right (small) motor on/off, only supports values of 0 or 1 (off/on) */
480 u8 left_duration; /* Left motor duration (0xff means forever) */
481 u8 left_motor_force; /* left (large) motor, supports force values from 0 to 255 */
484 struct sixaxis_output_report {
486 struct sixaxis_rumble rumble;
488 u8 leds_bitmap; /* bitmap of enabled LEDs: LED_1 = 0x02, LED_2 = 0x04, ... */
489 struct sixaxis_led led[4]; /* LEDx at (4 - x) */
490 struct sixaxis_led _reserved; /* LED5, not actually soldered */
493 union sixaxis_output_report_01 {
494 struct sixaxis_output_report data;
498 struct motion_output_report_02 {
505 #define DS4_FEATURE_REPORT_0x02_SIZE 37
506 #define DS4_FEATURE_REPORT_0x05_SIZE 41
507 #define DS4_FEATURE_REPORT_0x81_SIZE 7
508 #define DS4_FEATURE_REPORT_0xA3_SIZE 49
509 #define DS4_INPUT_REPORT_0x11_SIZE 78
510 #define DS4_OUTPUT_REPORT_0x05_SIZE 32
511 #define DS4_OUTPUT_REPORT_0x11_SIZE 78
512 #define SIXAXIS_REPORT_0xF2_SIZE 17
513 #define SIXAXIS_REPORT_0xF5_SIZE 8
514 #define MOTION_REPORT_0x02_SIZE 49
516 /* Offsets relative to USB input report (0x1). Bluetooth (0x11) requires an
519 #define DS4_INPUT_REPORT_AXIS_OFFSET 1
520 #define DS4_INPUT_REPORT_BUTTON_OFFSET 5
521 #define DS4_INPUT_REPORT_TIMESTAMP_OFFSET 10
522 #define DS4_INPUT_REPORT_GYRO_X_OFFSET 13
523 #define DS4_INPUT_REPORT_BATTERY_OFFSET 30
524 #define DS4_INPUT_REPORT_TOUCHPAD_OFFSET 33
526 #define SENSOR_SUFFIX " Motion Sensors"
527 #define DS4_TOUCHPAD_SUFFIX " Touchpad"
529 /* Default to 4ms poll interval, which is same as USB (not adjustable). */
530 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
531 #define DS4_BT_MAX_POLL_INTERVAL_MS 62
532 #define DS4_GYRO_RES_PER_DEG_S 1024
533 #define DS4_ACC_RES_PER_G 8192
535 #define SIXAXIS_INPUT_REPORT_ACC_X_OFFSET 41
536 #define SIXAXIS_ACC_RES_PER_G 113
538 static DEFINE_SPINLOCK(sony_dev_list_lock);
539 static LIST_HEAD(sony_device_list);
540 static DEFINE_IDA(sony_device_id_allocator);
542 /* Used for calibration of DS4 accelerometer and gyro. */
543 struct ds4_calibration_data {
546 /* Calibration requires scaling against a sensitivity value, which is a
547 * float. Store sensitivity as a fraction to limit floating point
548 * calculations until final calibration.
554 enum ds4_dongle_state {
568 struct list_head list_node;
569 struct hid_device *hdev;
570 struct input_dev *touchpad;
571 struct input_dev *sensor_dev;
572 struct led_classdev *leds[MAX_LEDS];
573 unsigned long quirks;
574 struct work_struct hotplug_worker;
575 struct work_struct state_worker;
576 void (*send_output_report)(struct sony_sc *);
577 struct power_supply *battery;
578 struct power_supply_desc battery_desc;
581 bool fw_version_created;
583 bool hw_version_created;
584 u8 *output_report_dmabuf;
586 #ifdef CONFIG_SONY_FF
592 u8 hotplug_worker_initialized;
593 u8 state_worker_initialized;
594 u8 defer_initialization;
597 u8 led_state[MAX_LEDS];
598 u8 led_delay_on[MAX_LEDS];
599 u8 led_delay_off[MAX_LEDS];
602 bool timestamp_initialized;
604 unsigned int timestamp_us;
606 u8 ds4_bt_poll_interval;
607 enum ds4_dongle_state ds4_dongle_state;
608 /* DS4 calibration data */
609 struct ds4_calibration_data ds4_calib_data[6];
612 struct timer_list ghl_poke_timer;
615 static void sony_set_leds(struct sony_sc *sc);
617 static inline void sony_schedule_work(struct sony_sc *sc,
618 enum sony_worker which)
623 case SONY_WORKER_STATE:
624 spin_lock_irqsave(&sc->lock, flags);
625 if (!sc->defer_initialization && sc->state_worker_initialized)
626 schedule_work(&sc->state_worker);
627 spin_unlock_irqrestore(&sc->lock, flags);
629 case SONY_WORKER_HOTPLUG:
630 if (sc->hotplug_worker_initialized)
631 schedule_work(&sc->hotplug_worker);
636 static void ghl_magic_poke_cb(struct urb *urb)
638 struct sony_sc *sc = urb->context;
641 hid_err(sc->hdev, "URB transfer failed : %d", urb->status);
643 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
646 static void ghl_magic_poke(struct timer_list *t)
649 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
651 ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC);
653 hid_err(sc->hdev, "usb_submit_urb failed: %d", ret);
656 static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev,
657 const char ghl_magic_data[], u16 poke_size)
659 struct usb_ctrlrequest *cr;
662 u16 ghl_magic_value = (((HID_OUTPUT_REPORT + 1) << 8) | ghl_magic_data[0]);
664 pipe = usb_sndctrlpipe(usbdev, 0);
666 cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
670 databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
675 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
676 cr->bRequest = USB_REQ_SET_CONFIGURATION;
677 cr->wValue = cpu_to_le16(ghl_magic_value);
679 cr->wLength = cpu_to_le16(poke_size);
680 memcpy(databuf, ghl_magic_data, poke_size);
681 usb_fill_control_urb(
682 sc->ghl_urb, usbdev, pipe,
683 (unsigned char *) cr, databuf, poke_size,
684 ghl_magic_poke_cb, sc);
688 static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
689 struct hid_field *field, struct hid_usage *usage,
690 unsigned long **bit, int *max)
692 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
693 unsigned int abs = usage->hid & HID_USAGE;
695 if (abs == GUITAR_TILT_USAGE) {
696 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
703 static ssize_t ds4_show_poll_interval(struct device *dev,
704 struct device_attribute
707 struct hid_device *hdev = to_hid_device(dev);
708 struct sony_sc *sc = hid_get_drvdata(hdev);
710 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
713 static ssize_t ds4_store_poll_interval(struct device *dev,
714 struct device_attribute *attr,
715 const char *buf, size_t count)
717 struct hid_device *hdev = to_hid_device(dev);
718 struct sony_sc *sc = hid_get_drvdata(hdev);
722 if (kstrtou8(buf, 0, &interval))
725 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
728 spin_lock_irqsave(&sc->lock, flags);
729 sc->ds4_bt_poll_interval = interval;
730 spin_unlock_irqrestore(&sc->lock, flags);
732 sony_schedule_work(sc, SONY_WORKER_STATE);
737 static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
738 ds4_store_poll_interval);
740 static ssize_t sony_show_firmware_version(struct device *dev,
741 struct device_attribute
744 struct hid_device *hdev = to_hid_device(dev);
745 struct sony_sc *sc = hid_get_drvdata(hdev);
747 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
750 static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
752 static ssize_t sony_show_hardware_version(struct device *dev,
753 struct device_attribute
756 struct hid_device *hdev = to_hid_device(dev);
757 struct sony_sc *sc = hid_get_drvdata(hdev);
759 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
762 static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
764 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
767 *rsize = sizeof(motion_rdesc);
771 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
774 *rsize = sizeof(ps3remote_rdesc);
775 return ps3remote_rdesc;
778 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
779 struct hid_field *field, struct hid_usage *usage,
780 unsigned long **bit, int *max)
782 unsigned int key = usage->hid & HID_USAGE;
784 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
787 switch (usage->collection_index) {
789 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
792 key = ps3remote_keymap_joypad_buttons[key];
797 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
800 key = ps3remote_keymap_remote_buttons[key];
808 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
812 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
813 struct hid_field *field, struct hid_usage *usage,
814 unsigned long **bit, int *max)
816 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
817 unsigned int key = usage->hid & HID_USAGE;
819 if (key >= ARRAY_SIZE(sixaxis_keymap))
822 key = navigation_keymap[key];
826 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
828 } else if (usage->hid == HID_GD_POINTER) {
829 /* See comment in sixaxis_mapping, basically the L2 (and R2)
830 * triggers are reported through GD Pointer.
831 * In addition we ignore any analog button 'axes' and only
832 * support digital buttons.
834 switch (usage->usage_index) {
836 usage->hid = HID_GD_Z;
842 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
844 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
845 unsigned int abs = usage->hid & HID_USAGE;
847 if (abs >= ARRAY_SIZE(navigation_absmap))
850 abs = navigation_absmap[abs];
852 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
860 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
861 struct hid_field *field, struct hid_usage *usage,
862 unsigned long **bit, int *max)
864 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
865 unsigned int key = usage->hid & HID_USAGE;
867 if (key >= ARRAY_SIZE(sixaxis_keymap))
870 key = sixaxis_keymap[key];
871 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
873 } else if (usage->hid == HID_GD_POINTER) {
874 /* The DS3 provides analog values for most buttons and even
875 * for HAT axes through GD Pointer. L2 and R2 are reported
876 * among these as well instead of as GD Z / RZ. Remap L2
877 * and R2 and ignore other analog 'button axes' as there is
878 * no good way for reporting them.
880 switch (usage->usage_index) {
882 usage->hid = HID_GD_Z;
885 usage->hid = HID_GD_RZ;
891 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
893 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
894 unsigned int abs = usage->hid & HID_USAGE;
896 if (abs >= ARRAY_SIZE(sixaxis_absmap))
899 abs = sixaxis_absmap[abs];
901 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
908 static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
909 struct hid_field *field, struct hid_usage *usage,
910 unsigned long **bit, int *max)
912 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
913 unsigned int key = usage->hid & HID_USAGE;
915 if (key >= ARRAY_SIZE(ds4_keymap))
918 key = ds4_keymap[key];
919 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
921 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
922 unsigned int abs = usage->hid & HID_USAGE;
924 /* Let the HID parser deal with the HAT. */
925 if (usage->hid == HID_GD_HATSWITCH)
928 if (abs >= ARRAY_SIZE(ds4_absmap))
931 abs = ds4_absmap[abs];
932 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
939 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
942 struct sony_sc *sc = hid_get_drvdata(hdev);
944 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
948 * Some Sony RF receivers wrongly declare the mouse pointer as a
949 * a constant non-data variable.
951 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
952 /* usage page: generic desktop controls */
953 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
955 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
956 /* input (usage page for x,y axes): constant, variable, relative */
957 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
958 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
959 /* input: data, variable, relative */
963 if (sc->quirks & MOTION_CONTROLLER)
964 return motion_fixup(hdev, rdesc, rsize);
966 if (sc->quirks & PS3REMOTE)
967 return ps3remote_fixup(hdev, rdesc, rsize);
970 * Some knock-off USB dongles incorrectly report their button count
971 * as 13 instead of 16 causing three non-functional buttons.
973 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
974 /* Report Count (13) */
975 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
976 /* Usage Maximum (13) */
977 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
978 /* Report Count (3) */
979 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
980 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
989 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
991 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
998 * The sixaxis is charging if the battery value is 0xee
999 * and it is fully charged if the value is 0xef.
1000 * It does not report the actual level while charging so it
1001 * is set to 100% while charging is in progress.
1003 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
1005 if (rd[offset] >= 0xee) {
1006 battery_capacity = 100;
1007 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
1009 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
1010 battery_capacity = sixaxis_battery_capacity[index];
1011 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1014 spin_lock_irqsave(&sc->lock, flags);
1015 sc->battery_capacity = battery_capacity;
1016 sc->battery_status = battery_status;
1017 spin_unlock_irqrestore(&sc->lock, flags);
1019 if (sc->quirks & SIXAXIS_CONTROLLER) {
1022 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
1023 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
1024 input_report_abs(sc->sensor_dev, ABS_X, val);
1026 /* Y and Z are swapped and inversed */
1027 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
1028 input_report_abs(sc->sensor_dev, ABS_Y, val);
1030 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
1031 input_report_abs(sc->sensor_dev, ABS_Z, val);
1033 input_sync(sc->sensor_dev);
1037 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
1039 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1040 struct hid_input, list);
1041 struct input_dev *input_dev = hidinput->input;
1042 unsigned long flags;
1043 int n, m, offset, num_touch_data, max_touch_data;
1044 u8 cable_state, battery_capacity;
1048 /* When using Bluetooth the header is 2 bytes longer, so skip these. */
1049 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
1051 /* Second bit of third button byte is for the touchpad button. */
1052 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
1053 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1056 * The default behavior of the Dualshock 4 is to send reports using
1057 * report type 1 when running over Bluetooth. However, when feature
1058 * report 2 is requested during the controller initialization it starts
1059 * sending input reports in report 17. Since report 17 is undefined
1060 * in the default HID descriptor, the HID layer won't generate events.
1061 * While it is possible (and this was done before) to fixup the HID
1062 * descriptor to add this mapping, it was better to do this manually.
1063 * The reason is there were various pieces software both open and closed
1064 * source, relying on the descriptors to be the same across various
1065 * operating systems. If the descriptors wouldn't match some
1066 * applications e.g. games on Wine would not be able to function due
1067 * to different descriptors, which such applications are not parsing.
1072 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
1073 input_report_abs(input_dev, ABS_X, rd[offset]);
1074 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
1075 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
1076 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
1078 value = rd[offset+4] & 0xf;
1080 value = 8; /* Center 0, 0 */
1081 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
1082 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
1084 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
1085 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
1086 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
1087 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
1089 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
1090 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
1091 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
1092 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
1093 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
1094 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
1095 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
1096 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
1098 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
1100 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
1101 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
1103 input_sync(input_dev);
1106 /* Convert timestamp (in 5.33us unit) to timestamp_us */
1107 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
1108 timestamp = get_unaligned_le16(&rd[offset]);
1109 if (!sc->timestamp_initialized) {
1110 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1111 sc->timestamp_initialized = true;
1115 if (sc->prev_timestamp > timestamp)
1116 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1118 delta = timestamp - sc->prev_timestamp;
1119 sc->timestamp_us += (delta * 16) / 3;
1121 sc->prev_timestamp = timestamp;
1122 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1124 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
1125 for (n = 0; n < 6; n++) {
1126 /* Store data in int for more precision during mult_frac. */
1127 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1128 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1130 /* High precision is needed during calibration, but the
1131 * calibrated values are within 32-bit.
1132 * Note: we swap numerator 'x' and 'numer' in mult_frac for
1133 * precision reasons so we don't need 64-bit.
1135 int calib_data = mult_frac(calib->sens_numer,
1136 raw_data - calib->bias,
1139 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1142 input_sync(sc->sensor_dev);
1145 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1146 * and the 5th bit contains the USB cable state.
1148 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1149 cable_state = (rd[offset] >> 4) & 0x01;
1152 * Interpretation of the battery_capacity data depends on the cable state.
1153 * When no cable is connected (bit4 is 0):
1154 * - 0:10: percentage in units of 10%.
1155 * When a cable is plugged in:
1156 * - 0-10: percentage in units of 10%.
1157 * - 11: battery is full
1158 * - 14: not charging due to Voltage or temperature error
1159 * - 15: charge error
1162 u8 battery_data = rd[offset] & 0xf;
1164 if (battery_data < 10) {
1165 /* Take the mid-point for each battery capacity value,
1166 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
1167 * This matches official platform behavior, which does
1170 battery_capacity = battery_data * 10 + 5;
1171 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1172 } else if (battery_data == 10) {
1173 battery_capacity = 100;
1174 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1175 } else if (battery_data == 11) {
1176 battery_capacity = 100;
1177 battery_status = POWER_SUPPLY_STATUS_FULL;
1178 } else { /* 14, 15 and undefined values */
1179 battery_capacity = 0;
1180 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1183 u8 battery_data = rd[offset] & 0xf;
1185 if (battery_data < 10)
1186 battery_capacity = battery_data * 10 + 5;
1188 battery_capacity = 100;
1190 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1193 spin_lock_irqsave(&sc->lock, flags);
1194 sc->battery_capacity = battery_capacity;
1195 sc->battery_status = battery_status;
1196 spin_unlock_irqrestore(&sc->lock, flags);
1199 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1200 * and 35 on Bluetooth.
1201 * The first byte indicates the number of touch data in the report.
1202 * Trackpad data starts 2 bytes later (e.g. 35 for USB).
1204 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1205 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1206 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1207 num_touch_data = rd[offset];
1212 for (m = 0; m < num_touch_data; m++) {
1213 /* Skip past timestamp */
1217 * The first 7 bits of the first byte is a counter and bit 8 is
1218 * a touch indicator that is 0 when pressed and 1 when not
1220 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1221 * The data for the second touch is in the same format and
1222 * immediately follows the data for the first.
1224 for (n = 0; n < 2; n++) {
1228 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1229 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1231 active = !(rd[offset] >> 7);
1232 input_mt_slot(sc->touchpad, n);
1233 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1236 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1237 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1242 input_mt_sync_frame(sc->touchpad);
1243 input_sync(sc->touchpad);
1247 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1249 int n, offset, relx, rely;
1253 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
1254 * the touch-related data starts at offset 2.
1255 * For the first byte, bit 0 is set when touchpad button is pressed.
1256 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
1257 * This drag key is mapped to BTN_LEFT. It is operational only when a
1258 * touch point is active.
1259 * Bit 4 is set when only the first touch point is active.
1260 * Bit 6 is set when only the second touch point is active.
1261 * Bits 5 and 7 are set when both touch points are active.
1262 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
1263 * The following byte, offset 5, has the touch width and length.
1264 * Bits 0-4=X (width), bits 5-7=Y (length).
1265 * A signed relative X coordinate is at offset 6.
1266 * The bytes at offset 7-9 are the second touch X/Y coordinates.
1267 * Offset 10 has the second touch width and length.
1268 * Offset 11 has the relative Y coordinate.
1272 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1273 active = (rd[offset] >> 4);
1274 relx = (s8) rd[offset+5];
1275 rely = ((s8) rd[offset+10]) * -1;
1279 for (n = 0; n < 2; n++) {
1281 u8 contactx, contacty;
1283 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1284 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1286 input_mt_slot(sc->touchpad, n);
1287 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1289 if (active & 0x03) {
1290 contactx = rd[offset+3] & 0x0F;
1291 contacty = rd[offset+3] >> 4;
1292 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1293 max(contactx, contacty));
1294 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1295 min(contactx, contacty));
1296 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1297 (bool) (contactx > contacty));
1298 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1299 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1300 NSG_MRXU_MAX_Y - y);
1302 * The relative coordinates belong to the first touch
1303 * point, when present, or to the second touch point
1304 * when the first is not active.
1306 if ((n == 0) || ((n == 1) && (active & 0x01))) {
1307 input_report_rel(sc->touchpad, REL_X, relx);
1308 input_report_rel(sc->touchpad, REL_Y, rely);
1316 input_mt_sync_frame(sc->touchpad);
1318 input_sync(sc->touchpad);
1321 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1324 struct sony_sc *sc = hid_get_drvdata(hdev);
1327 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1328 * has to be BYTE_SWAPPED before passing up to joystick interface
1330 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1332 * When connected via Bluetooth the Sixaxis occasionally sends
1333 * a report with the second byte 0xff and the rest zeroed.
1335 * This report does not reflect the actual state of the
1336 * controller must be ignored to avoid generating false input
1342 swap(rd[41], rd[42]);
1343 swap(rd[43], rd[44]);
1344 swap(rd[45], rd[46]);
1345 swap(rd[47], rd[48]);
1347 sixaxis_parse_report(sc, rd, size);
1348 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1349 sixaxis_parse_report(sc, rd, size);
1350 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1352 sixaxis_parse_report(sc, rd, size);
1353 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1355 dualshock4_parse_report(sc, rd, size);
1356 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1363 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1364 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1365 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1366 if (crc != report_crc) {
1367 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1372 dualshock4_parse_report(sc, rd, size);
1373 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1375 unsigned long flags;
1376 enum ds4_dongle_state dongle_state;
1379 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1380 * if a DS4 is actually connected (indicated by '0').
1381 * For non-dongle, this bit is always 0 (connected).
1383 bool connected = (rd[31] & 0x04) ? false : true;
1385 spin_lock_irqsave(&sc->lock, flags);
1386 dongle_state = sc->ds4_dongle_state;
1387 spin_unlock_irqrestore(&sc->lock, flags);
1390 * The dongle always sends input reports even when no
1391 * DS4 is attached. When a DS4 is connected, we need to
1392 * obtain calibration data before we can use it.
1393 * The code below tracks dongle state and kicks of
1394 * calibration when needed and only allows us to process
1395 * input if a DS4 is actually connected.
1397 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1398 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1401 spin_lock_irqsave(&sc->lock, flags);
1402 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1403 spin_unlock_irqrestore(&sc->lock, flags);
1405 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1407 /* Don't process the report since we don't have
1408 * calibration data, but let hidraw have it anyway.
1411 } else if ((dongle_state == DONGLE_CONNECTED ||
1412 dongle_state == DONGLE_DISABLED) && !connected) {
1413 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1415 spin_lock_irqsave(&sc->lock, flags);
1416 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1417 spin_unlock_irqrestore(&sc->lock, flags);
1419 /* Return 0, so hidraw can get the report. */
1421 } else if (dongle_state == DONGLE_CALIBRATING ||
1422 dongle_state == DONGLE_DISABLED ||
1423 dongle_state == DONGLE_DISCONNECTED) {
1424 /* Return 0, so hidraw can get the report. */
1428 dualshock4_parse_report(sc, rd, size);
1430 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1431 nsg_mrxu_parse_report(sc, rd, size);
1435 if (sc->defer_initialization) {
1436 sc->defer_initialization = 0;
1437 sony_schedule_work(sc, SONY_WORKER_STATE);
1443 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1444 struct hid_field *field, struct hid_usage *usage,
1445 unsigned long **bit, int *max)
1447 struct sony_sc *sc = hid_get_drvdata(hdev);
1449 if (sc->quirks & BUZZ_CONTROLLER) {
1450 unsigned int key = usage->hid & HID_USAGE;
1452 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1455 switch (usage->collection_index) {
1457 if (key >= ARRAY_SIZE(buzz_keymap))
1460 key = buzz_keymap[key];
1468 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1472 if (sc->quirks & PS3REMOTE)
1473 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1475 if (sc->quirks & NAVIGATION_CONTROLLER)
1476 return navigation_mapping(hdev, hi, field, usage, bit, max);
1478 if (sc->quirks & SIXAXIS_CONTROLLER)
1479 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1481 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1482 return ds4_mapping(hdev, hi, field, usage, bit, max);
1484 if (sc->quirks & GH_GUITAR_CONTROLLER)
1485 return guitar_mapping(hdev, hi, field, usage, bit, max);
1487 /* Let hid-core decide for the others */
1491 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1492 int w, int h, int touch_major, int touch_minor, int orientation)
1498 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1502 input_set_drvdata(sc->touchpad, sc);
1503 sc->touchpad->dev.parent = &sc->hdev->dev;
1504 sc->touchpad->phys = sc->hdev->phys;
1505 sc->touchpad->uniq = sc->hdev->uniq;
1506 sc->touchpad->id.bustype = sc->hdev->bus;
1507 sc->touchpad->id.vendor = sc->hdev->vendor;
1508 sc->touchpad->id.product = sc->hdev->product;
1509 sc->touchpad->id.version = sc->hdev->version;
1511 /* Append a suffix to the controller name as there are various
1512 * DS4 compatible non-Sony devices with different names.
1514 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1515 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1518 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1519 sc->touchpad->name = name;
1521 /* We map the button underneath the touchpad to BTN_LEFT. */
1522 __set_bit(EV_KEY, sc->touchpad->evbit);
1523 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1524 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1526 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1527 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1529 if (touch_major > 0) {
1530 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1531 0, touch_major, 0, 0);
1532 if (touch_minor > 0)
1533 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1534 0, touch_minor, 0, 0);
1535 if (orientation > 0)
1536 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1537 0, orientation, 0, 0);
1540 if (sc->quirks & NSG_MRXU_REMOTE) {
1541 __set_bit(EV_REL, sc->touchpad->evbit);
1544 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1548 ret = input_register_device(sc->touchpad);
1555 static int sony_register_sensors(struct sony_sc *sc)
1562 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1563 if (!sc->sensor_dev)
1566 input_set_drvdata(sc->sensor_dev, sc);
1567 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1568 sc->sensor_dev->phys = sc->hdev->phys;
1569 sc->sensor_dev->uniq = sc->hdev->uniq;
1570 sc->sensor_dev->id.bustype = sc->hdev->bus;
1571 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1572 sc->sensor_dev->id.product = sc->hdev->product;
1573 sc->sensor_dev->id.version = sc->hdev->version;
1575 /* Append a suffix to the controller name as there are various
1576 * DS4 compatible non-Sony devices with different names.
1578 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1579 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1582 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1583 sc->sensor_dev->name = name;
1585 if (sc->quirks & SIXAXIS_CONTROLLER) {
1586 /* For the DS3 we only support the accelerometer, which works
1587 * quite well even without calibration. The device also has
1588 * a 1-axis gyro, but it is very difficult to manage from within
1589 * the driver even to get data, the sensor is inaccurate and
1590 * the behavior is very different between hardware revisions.
1592 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1593 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1594 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1595 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1596 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1597 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1598 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1599 range = DS4_ACC_RES_PER_G*4;
1600 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1601 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1602 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1603 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1604 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1605 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1607 range = DS4_GYRO_RES_PER_DEG_S*2048;
1608 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1609 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1610 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1611 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1612 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1613 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1615 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1616 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1619 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1621 ret = input_register_device(sc->sensor_dev);
1629 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1630 * to "operational". Without this, the ps3 controller will not report any
1633 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1635 struct sony_sc *sc = hid_get_drvdata(hdev);
1636 const int buf_size =
1637 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1641 buf = kmalloc(buf_size, GFP_KERNEL);
1645 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1646 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1648 hid_err(hdev, "can't set operational mode: step 1\n");
1653 * Some compatible controllers like the Speedlink Strike FX and
1654 * Gasia need another query plus an USB interrupt to get operational.
1656 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1657 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1659 hid_err(hdev, "can't set operational mode: step 2\n");
1664 * But the USB interrupt would cause SHANWAN controllers to
1665 * start rumbling non-stop, so skip step 3 for these controllers.
1667 if (sc->quirks & SHANWAN_GAMEPAD)
1670 ret = hid_hw_output_report(hdev, buf, 1);
1672 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1682 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1684 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1688 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1692 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1693 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1701 * Request DS4 calibration data for the motion sensors.
1702 * For Bluetooth this also affects the operating mode (see below).
1704 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1708 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1709 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1710 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1711 short gyro_speed_plus, gyro_speed_minus;
1712 short acc_x_plus, acc_x_minus;
1713 short acc_y_plus, acc_y_minus;
1714 short acc_z_plus, acc_z_minus;
1718 /* For Bluetooth we use a different request, which supports CRC.
1719 * Note: in Bluetooth mode feature report 0x02 also changes the state
1720 * of the controller, so that it sends input reports of type 0x11.
1722 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1725 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1729 /* We should normally receive the feature report data we asked
1730 * for, but hidraw applications such as Steam can issue feature
1731 * reports as well. In particular for Dongle reconnects, Steam
1732 * and this function are competing resulting in often receiving
1733 * data for a different HID report, so retry a few times.
1735 for (retries = 0; retries < 3; retries++) {
1736 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1737 DS4_FEATURE_REPORT_0x02_SIZE,
1739 HID_REQ_GET_REPORT);
1743 if (buf[0] != 0x02) {
1745 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1761 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1765 for (retries = 0; retries < 3; retries++) {
1766 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1767 DS4_FEATURE_REPORT_0x05_SIZE,
1769 HID_REQ_GET_REPORT);
1774 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1775 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1776 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1777 if (crc != report_crc) {
1778 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1781 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1793 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1794 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1795 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1796 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1797 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1798 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1799 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1800 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1801 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1802 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1805 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1806 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1807 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1808 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1809 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1810 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1812 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1813 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1814 acc_x_plus = get_unaligned_le16(&buf[23]);
1815 acc_x_minus = get_unaligned_le16(&buf[25]);
1816 acc_y_plus = get_unaligned_le16(&buf[27]);
1817 acc_y_minus = get_unaligned_le16(&buf[29]);
1818 acc_z_plus = get_unaligned_le16(&buf[31]);
1819 acc_z_minus = get_unaligned_le16(&buf[33]);
1821 /* Set gyroscope calibration and normalization parameters.
1822 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1824 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1825 sc->ds4_calib_data[0].abs_code = ABS_RX;
1826 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1827 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1828 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1830 sc->ds4_calib_data[1].abs_code = ABS_RY;
1831 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1832 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1833 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1835 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1836 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1837 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1838 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1840 /* Set accelerometer calibration and normalization parameters.
1841 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1843 range_2g = acc_x_plus - acc_x_minus;
1844 sc->ds4_calib_data[3].abs_code = ABS_X;
1845 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1846 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1847 sc->ds4_calib_data[3].sens_denom = range_2g;
1849 range_2g = acc_y_plus - acc_y_minus;
1850 sc->ds4_calib_data[4].abs_code = ABS_Y;
1851 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1852 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1853 sc->ds4_calib_data[4].sens_denom = range_2g;
1855 range_2g = acc_z_plus - acc_z_minus;
1856 sc->ds4_calib_data[5].abs_code = ABS_Z;
1857 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1858 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1859 sc->ds4_calib_data[5].sens_denom = range_2g;
1866 static void dualshock4_calibration_work(struct work_struct *work)
1868 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1869 unsigned long flags;
1870 enum ds4_dongle_state dongle_state;
1873 ret = dualshock4_get_calibration_data(sc);
1875 /* This call is very unlikely to fail for the dongle. When it
1876 * fails we are probably in a very bad state, so mark the
1877 * dongle as disabled. We will re-enable the dongle if a new
1878 * DS4 hotplug is detect from sony_raw_event as any issues
1879 * are likely resolved then (the dongle is quite stupid).
1881 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1882 dongle_state = DONGLE_DISABLED;
1884 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1885 dongle_state = DONGLE_CONNECTED;
1888 spin_lock_irqsave(&sc->lock, flags);
1889 sc->ds4_dongle_state = dongle_state;
1890 spin_unlock_irqrestore(&sc->lock, flags);
1893 static int dualshock4_get_version_info(struct sony_sc *sc)
1898 buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1902 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1903 DS4_FEATURE_REPORT_0xA3_SIZE,
1905 HID_REQ_GET_REPORT);
1911 sc->hw_version = get_unaligned_le16(&buf[35]);
1912 sc->fw_version = get_unaligned_le16(&buf[41]);
1918 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1920 static const u8 sixaxis_leds[10][4] = {
1921 { 0x01, 0x00, 0x00, 0x00 },
1922 { 0x00, 0x01, 0x00, 0x00 },
1923 { 0x00, 0x00, 0x01, 0x00 },
1924 { 0x00, 0x00, 0x00, 0x01 },
1925 { 0x01, 0x00, 0x00, 0x01 },
1926 { 0x00, 0x01, 0x00, 0x01 },
1927 { 0x00, 0x00, 0x01, 0x01 },
1928 { 0x01, 0x00, 0x01, 0x01 },
1929 { 0x00, 0x01, 0x01, 0x01 },
1930 { 0x01, 0x01, 0x01, 0x01 }
1933 int id = sc->device_id;
1935 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1941 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1944 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1946 /* The first 4 color/index entries match what the PS4 assigns */
1947 static const u8 color_code[7][3] = {
1948 /* Blue */ { 0x00, 0x00, 0x40 },
1949 /* Red */ { 0x40, 0x00, 0x00 },
1950 /* Green */ { 0x00, 0x40, 0x00 },
1951 /* Pink */ { 0x20, 0x00, 0x20 },
1952 /* Orange */ { 0x02, 0x01, 0x00 },
1953 /* Teal */ { 0x00, 0x01, 0x01 },
1954 /* White */ { 0x01, 0x01, 0x01 }
1957 int id = sc->device_id;
1959 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1965 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1968 static void buzz_set_leds(struct sony_sc *sc)
1970 struct hid_device *hdev = sc->hdev;
1971 struct list_head *report_list =
1972 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1973 struct hid_report *report = list_entry(report_list->next,
1974 struct hid_report, list);
1975 s32 *value = report->field[0]->value;
1977 BUILD_BUG_ON(MAX_LEDS < 4);
1980 value[1] = sc->led_state[0] ? 0xff : 0x00;
1981 value[2] = sc->led_state[1] ? 0xff : 0x00;
1982 value[3] = sc->led_state[2] ? 0xff : 0x00;
1983 value[4] = sc->led_state[3] ? 0xff : 0x00;
1986 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1989 static void sony_set_leds(struct sony_sc *sc)
1991 if (!(sc->quirks & BUZZ_CONTROLLER))
1992 sony_schedule_work(sc, SONY_WORKER_STATE);
1997 static void sony_led_set_brightness(struct led_classdev *led,
1998 enum led_brightness value)
2000 struct device *dev = led->dev->parent;
2001 struct hid_device *hdev = to_hid_device(dev);
2002 struct sony_sc *drv_data;
2007 drv_data = hid_get_drvdata(hdev);
2009 hid_err(hdev, "No device data\n");
2014 * The Sixaxis on USB will override any LED settings sent to it
2015 * and keep flashing all of the LEDs until the PS button is pressed.
2016 * Updates, even if redundant, must be always be sent to the
2017 * controller to avoid having to toggle the state of an LED just to
2018 * stop the flashing later on.
2020 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
2022 for (n = 0; n < drv_data->led_count; n++) {
2023 if (led == drv_data->leds[n] && (force_update ||
2024 (value != drv_data->led_state[n] ||
2025 drv_data->led_delay_on[n] ||
2026 drv_data->led_delay_off[n]))) {
2028 drv_data->led_state[n] = value;
2030 /* Setting the brightness stops the blinking */
2031 drv_data->led_delay_on[n] = 0;
2032 drv_data->led_delay_off[n] = 0;
2034 sony_set_leds(drv_data);
2040 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
2042 struct device *dev = led->dev->parent;
2043 struct hid_device *hdev = to_hid_device(dev);
2044 struct sony_sc *drv_data;
2048 drv_data = hid_get_drvdata(hdev);
2050 hid_err(hdev, "No device data\n");
2054 for (n = 0; n < drv_data->led_count; n++) {
2055 if (led == drv_data->leds[n])
2056 return drv_data->led_state[n];
2062 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
2063 unsigned long *delay_off)
2065 struct device *dev = led->dev->parent;
2066 struct hid_device *hdev = to_hid_device(dev);
2067 struct sony_sc *drv_data = hid_get_drvdata(hdev);
2072 hid_err(hdev, "No device data\n");
2076 /* Max delay is 255 deciseconds or 2550 milliseconds */
2077 if (*delay_on > 2550)
2079 if (*delay_off > 2550)
2082 /* Blink at 1 Hz if both values are zero */
2083 if (!*delay_on && !*delay_off)
2084 *delay_on = *delay_off = 500;
2086 new_on = *delay_on / 10;
2087 new_off = *delay_off / 10;
2089 for (n = 0; n < drv_data->led_count; n++) {
2090 if (led == drv_data->leds[n])
2094 /* This LED is not registered on this device */
2095 if (n >= drv_data->led_count)
2098 /* Don't schedule work if the values didn't change */
2099 if (new_on != drv_data->led_delay_on[n] ||
2100 new_off != drv_data->led_delay_off[n]) {
2101 drv_data->led_delay_on[n] = new_on;
2102 drv_data->led_delay_off[n] = new_off;
2103 sony_schedule_work(drv_data, SONY_WORKER_STATE);
2109 static int sony_leds_init(struct sony_sc *sc)
2111 struct hid_device *hdev = sc->hdev;
2114 struct led_classdev *led;
2118 const char *name_fmt;
2119 static const char * const ds4_name_str[] = { "red", "green", "blue",
2121 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
2122 u8 use_hw_blink[MAX_LEDS] = { 0 };
2124 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
2126 if (sc->quirks & BUZZ_CONTROLLER) {
2129 name_len = strlen("::buzz#");
2130 name_fmt = "%s::buzz%d";
2131 /* Validate expected report characteristics. */
2132 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
2134 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2135 dualshock4_set_leds_from_id(sc);
2136 sc->led_state[3] = 1;
2138 memset(max_brightness, 255, 3);
2139 use_hw_blink[3] = 1;
2143 } else if (sc->quirks & MOTION_CONTROLLER) {
2145 memset(max_brightness, 255, 3);
2149 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
2150 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
2152 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2154 memset(use_hw_blink, 1, 4);
2156 name_len = strlen("::sony#");
2157 name_fmt = "%s::sony%d";
2159 sixaxis_set_leds_from_id(sc);
2161 memset(use_hw_blink, 1, 4);
2163 name_len = strlen("::sony#");
2164 name_fmt = "%s::sony%d";
2168 * Clear LEDs as we have no way of reading their initial state. This is
2169 * only relevant if the driver is loaded after somebody actively set the
2174 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2176 for (n = 0; n < sc->led_count; n++) {
2179 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2181 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2183 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2187 name = (void *)(&led[1]);
2189 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2192 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2194 led->brightness = sc->led_state[n];
2195 led->max_brightness = max_brightness[n];
2196 led->flags = LED_CORE_SUSPENDRESUME;
2197 led->brightness_get = sony_led_get_brightness;
2198 led->brightness_set = sony_led_set_brightness;
2200 if (use_hw_blink[n])
2201 led->blink_set = sony_led_blink_set;
2205 ret = devm_led_classdev_register(&hdev->dev, led);
2207 hid_err(hdev, "Failed to register LED %d\n", n);
2215 static void sixaxis_send_output_report(struct sony_sc *sc)
2217 static const union sixaxis_output_report_01 default_report = {
2220 0x01, 0xff, 0x00, 0xff, 0x00,
2221 0x00, 0x00, 0x00, 0x00, 0x00,
2222 0xff, 0x27, 0x10, 0x00, 0x32,
2223 0xff, 0x27, 0x10, 0x00, 0x32,
2224 0xff, 0x27, 0x10, 0x00, 0x32,
2225 0xff, 0x27, 0x10, 0x00, 0x32,
2226 0x00, 0x00, 0x00, 0x00, 0x00
2229 struct sixaxis_output_report *report =
2230 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2233 /* Initialize the report with default values */
2234 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2236 #ifdef CONFIG_SONY_FF
2237 report->rumble.right_motor_on = sc->right ? 1 : 0;
2238 report->rumble.left_motor_force = sc->left;
2241 report->leds_bitmap |= sc->led_state[0] << 1;
2242 report->leds_bitmap |= sc->led_state[1] << 2;
2243 report->leds_bitmap |= sc->led_state[2] << 3;
2244 report->leds_bitmap |= sc->led_state[3] << 4;
2246 /* Set flag for all leds off, required for 3rd party INTEC controller */
2247 if ((report->leds_bitmap & 0x1E) == 0)
2248 report->leds_bitmap |= 0x20;
2251 * The LEDs in the report are indexed in reverse order to their
2252 * corresponding light on the controller.
2253 * Index 0 = LED 4, index 1 = LED 3, etc...
2255 * In the case of both delay values being zero (blinking disabled) the
2256 * default report values should be used or the controller LED will be
2259 for (n = 0; n < 4; n++) {
2260 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2261 report->led[3 - n].duty_off = sc->led_delay_off[n];
2262 report->led[3 - n].duty_on = sc->led_delay_on[n];
2266 /* SHANWAN controllers require output reports via intr channel */
2267 if (sc->quirks & SHANWAN_GAMEPAD)
2268 hid_hw_output_report(sc->hdev, (u8 *)report,
2269 sizeof(struct sixaxis_output_report));
2271 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2272 sizeof(struct sixaxis_output_report),
2273 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2276 static void dualshock4_send_output_report(struct sony_sc *sc)
2278 struct hid_device *hdev = sc->hdev;
2279 u8 *buf = sc->output_report_dmabuf;
2283 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2284 * control the interval at which Dualshock 4 reports data:
2291 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2292 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2294 buf[1] = 0x07; /* blink + LEDs + motor */
2297 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2299 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2300 buf[3] = 0x07; /* blink + LEDs + motor */
2304 #ifdef CONFIG_SONY_FF
2305 buf[offset++] = sc->right;
2306 buf[offset++] = sc->left;
2311 /* LED 3 is the global control */
2312 if (sc->led_state[3]) {
2313 buf[offset++] = sc->led_state[0];
2314 buf[offset++] = sc->led_state[1];
2315 buf[offset++] = sc->led_state[2];
2320 /* If both delay values are zero the DualShock 4 disables blinking. */
2321 buf[offset++] = sc->led_delay_on[3];
2322 buf[offset++] = sc->led_delay_off[3];
2324 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2325 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2327 /* CRC generation */
2331 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2332 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2333 put_unaligned_le32(crc, &buf[74]);
2334 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2338 static void motion_send_output_report(struct sony_sc *sc)
2340 struct hid_device *hdev = sc->hdev;
2341 struct motion_output_report_02 *report =
2342 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2344 memset(report, 0, MOTION_REPORT_0x02_SIZE);
2346 report->type = 0x02; /* set leds */
2347 report->r = sc->led_state[0];
2348 report->g = sc->led_state[1];
2349 report->b = sc->led_state[2];
2351 #ifdef CONFIG_SONY_FF
2352 report->rumble = max(sc->right, sc->left);
2355 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2358 #ifdef CONFIG_SONY_FF
2359 static inline void sony_send_output_report(struct sony_sc *sc)
2361 if (sc->send_output_report)
2362 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 struct usb_device *usbdev;
2985 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2987 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2988 quirks |= FUTUREMAX_DANCE_MAT;
2990 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad") ||
2991 !strcmp(hdev->name, "ShanWan PS(R) Ga`epad"))
2992 quirks |= SHANWAN_GAMEPAD;
2994 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2996 hid_err(hdev, "can't alloc sony descriptor\n");
3000 spin_lock_init(&sc->lock);
3002 sc->quirks = quirks;
3003 hid_set_drvdata(hdev, sc);
3006 ret = hid_parse(hdev);
3008 hid_err(hdev, "parse failed\n");
3012 if (sc->quirks & VAIO_RDESC_CONSTANT)
3013 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3014 else if (sc->quirks & SIXAXIS_CONTROLLER)
3015 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3017 /* Patch the hw version on DS3/4 compatible devices, so applications can
3018 * distinguish between the default HID mappings and the mappings defined
3019 * by the Linux game controller spec. This is important for the SDL2
3020 * library, which has a game controller database, which uses device ids
3021 * in combination with version as a key.
3023 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
3024 hdev->version |= 0x8000;
3026 ret = hid_hw_start(hdev, connect_mask);
3028 hid_err(hdev, "hw start failed\n");
3032 /* sony_input_configured can fail, but this doesn't result
3033 * in hid_hw_start failures (intended). Check whether
3034 * the HID layer claimed the device else fail.
3035 * We don't know the actual reason for the failure, most
3036 * likely it is due to EEXIST in case of double connection
3037 * of USB and Bluetooth, but could have been due to ENOMEM
3038 * or other reasons as well.
3040 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
3041 hid_err(hdev, "failed to claim input\n");
3046 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
3047 if (!hid_is_usb(hdev)) {
3052 usbdev = to_usb_device(sc->hdev->dev.parent->parent);
3054 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
3060 if (sc->quirks & GHL_GUITAR_PS3WIIU)
3061 ret = ghl_init_urb(sc, usbdev, ghl_ps3wiiu_magic_data,
3062 ARRAY_SIZE(ghl_ps3wiiu_magic_data));
3063 else if (sc->quirks & GHL_GUITAR_PS4)
3064 ret = ghl_init_urb(sc, usbdev, ghl_ps4_magic_data,
3065 ARRAY_SIZE(ghl_ps4_magic_data));
3067 hid_err(hdev, "error preparing URB\n");
3071 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
3072 mod_timer(&sc->ghl_poke_timer,
3073 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
3083 static void sony_remove(struct hid_device *hdev)
3085 struct sony_sc *sc = hid_get_drvdata(hdev);
3087 if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
3088 del_timer_sync(&sc->ghl_poke_timer);
3089 usb_free_urb(sc->ghl_urb);
3094 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
3095 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
3097 if (sc->fw_version_created)
3098 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
3100 if (sc->hw_version_created)
3101 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
3103 sony_cancel_work_sync(sc);
3105 sony_remove_dev_list(sc);
3107 sony_release_device_id(sc);
3114 static int sony_suspend(struct hid_device *hdev, pm_message_t message)
3116 #ifdef CONFIG_SONY_FF
3118 /* On suspend stop any running force-feedback events */
3119 if (SONY_FF_SUPPORT) {
3120 struct sony_sc *sc = hid_get_drvdata(hdev);
3122 sc->left = sc->right = 0;
3123 sony_send_output_report(sc);
3130 static int sony_resume(struct hid_device *hdev)
3132 struct sony_sc *sc = hid_get_drvdata(hdev);
3135 * The Sixaxis and navigation controllers on USB need to be
3136 * reinitialized on resume or they won't behave properly.
3138 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
3139 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
3140 sixaxis_set_operational_usb(sc->hdev);
3141 sc->defer_initialization = 1;
3149 static const struct hid_device_id sony_devices[] = {
3150 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3151 .driver_data = SIXAXIS_CONTROLLER_USB },
3152 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
3153 .driver_data = NAVIGATION_CONTROLLER_USB },
3154 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER),
3155 .driver_data = NAVIGATION_CONTROLLER_BT },
3156 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
3157 .driver_data = MOTION_CONTROLLER_USB },
3158 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER),
3159 .driver_data = MOTION_CONTROLLER_BT },
3160 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER),
3161 .driver_data = SIXAXIS_CONTROLLER_BT },
3162 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
3163 .driver_data = VAIO_RDESC_CONSTANT },
3164 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
3165 .driver_data = VAIO_RDESC_CONSTANT },
3167 * Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
3168 * Logitech joystick from the device descriptor.
3170 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
3171 .driver_data = BUZZ_CONTROLLER },
3172 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
3173 .driver_data = BUZZ_CONTROLLER },
3174 /* PS3 BD Remote Control */
3175 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
3176 .driver_data = PS3REMOTE },
3177 /* Logitech Harmony Adapter for PS3 */
3178 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
3179 .driver_data = PS3REMOTE },
3180 /* SMK-Link PS3 BD Remote Control */
3181 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE),
3182 .driver_data = PS3REMOTE },
3183 /* Sony Dualshock 4 controllers for PS4 */
3184 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3185 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3186 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
3187 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3188 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3189 .driver_data = DUALSHOCK4_CONTROLLER_USB },
3190 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
3191 .driver_data = DUALSHOCK4_CONTROLLER_BT },
3192 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
3193 .driver_data = DUALSHOCK4_DONGLE },
3194 /* Nyko Core Controller for PS3 */
3195 { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER),
3196 .driver_data = SIXAXIS_CONTROLLER_USB | SINO_LITE_CONTROLLER },
3197 /* SMK-Link NSG-MR5U Remote Control */
3198 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR5U_REMOTE),
3199 .driver_data = NSG_MR5U_REMOTE_BT },
3200 /* SMK-Link NSG-MR7U Remote Control */
3201 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_NSG_MR7U_REMOTE),
3202 .driver_data = NSG_MR7U_REMOTE_BT },
3203 /* Guitar Hero Live PS3 and Wii U guitar dongles */
3204 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3WIIU_GHLIVE_DONGLE),
3205 .driver_data = GHL_GUITAR_PS3WIIU | GH_GUITAR_CONTROLLER },
3206 /* Guitar Hero PC Guitar Dongle */
3207 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_GUITAR_DONGLE),
3208 .driver_data = GH_GUITAR_CONTROLLER },
3209 /* Guitar Hero PS3 World Tour Guitar Dongle */
3210 { HID_USB_DEVICE(USB_VENDOR_ID_SONY_RHYTHM, USB_DEVICE_ID_SONY_PS3_GUITAR_DONGLE),
3211 .driver_data = GH_GUITAR_CONTROLLER },
3212 /* Guitar Hero Live PS4 guitar dongles */
3213 { HID_USB_DEVICE(USB_VENDOR_ID_REDOCTANE, USB_DEVICE_ID_REDOCTANE_PS4_GHLIVE_DONGLE),
3214 .driver_data = GHL_GUITAR_PS4 | GH_GUITAR_CONTROLLER },
3217 MODULE_DEVICE_TABLE(hid, sony_devices);
3219 static struct hid_driver sony_driver = {
3221 .id_table = sony_devices,
3222 .input_mapping = sony_mapping,
3223 .input_configured = sony_input_configured,
3224 .probe = sony_probe,
3225 .remove = sony_remove,
3226 .report_fixup = sony_report_fixup,
3227 .raw_event = sony_raw_event,
3230 .suspend = sony_suspend,
3231 .resume = sony_resume,
3232 .reset_resume = sony_resume,
3236 static int __init sony_init(void)
3238 dbg_hid("Sony:%s\n", __func__);
3240 return hid_register_driver(&sony_driver);
3243 static void __exit sony_exit(void)
3245 dbg_hid("Sony:%s\n", __func__);
3247 hid_unregister_driver(&sony_driver);
3248 ida_destroy(&sony_device_id_allocator);
3250 module_init(sony_init);
3251 module_exit(sony_exit);
3253 MODULE_LICENSE("GPL");