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];
601 struct timer_list ghl_poke_timer;
604 static void sony_set_leds(struct sony_sc *sc);
606 static inline void sony_schedule_work(struct sony_sc *sc,
607 enum sony_worker which)
612 case SONY_WORKER_STATE:
613 spin_lock_irqsave(&sc->lock, flags);
614 if (!sc->defer_initialization && sc->state_worker_initialized)
615 schedule_work(&sc->state_worker);
616 spin_unlock_irqrestore(&sc->lock, flags);
618 case SONY_WORKER_HOTPLUG:
619 if (sc->hotplug_worker_initialized)
620 schedule_work(&sc->hotplug_worker);
625 static void ghl_magic_poke_cb(struct urb *urb)
627 struct sony_sc *sc = urb->context;
630 hid_err(sc->hdev, "URB transfer failed : %d", urb->status);
632 mod_timer(&sc->ghl_poke_timer, jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
635 static void ghl_magic_poke(struct timer_list *t)
638 struct sony_sc *sc = from_timer(sc, t, ghl_poke_timer);
640 ret = usb_submit_urb(sc->ghl_urb, GFP_ATOMIC);
642 hid_err(sc->hdev, "usb_submit_urb failed: %d", ret);
645 static int ghl_init_urb(struct sony_sc *sc, struct usb_device *usbdev)
647 struct usb_ctrlrequest *cr;
652 poke_size = ARRAY_SIZE(ghl_ps3wiiu_magic_data);
653 pipe = usb_sndctrlpipe(usbdev, 0);
655 cr = devm_kzalloc(&sc->hdev->dev, sizeof(*cr), GFP_ATOMIC);
659 databuf = devm_kzalloc(&sc->hdev->dev, poke_size, GFP_ATOMIC);
664 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT;
665 cr->bRequest = USB_REQ_SET_CONFIGURATION;
666 cr->wValue = cpu_to_le16(ghl_ps3wiiu_magic_value);
668 cr->wLength = cpu_to_le16(poke_size);
669 memcpy(databuf, ghl_ps3wiiu_magic_data, poke_size);
670 usb_fill_control_urb(
671 sc->ghl_urb, usbdev, pipe,
672 (unsigned char *) cr, databuf, poke_size,
673 ghl_magic_poke_cb, sc);
677 static int guitar_mapping(struct hid_device *hdev, struct hid_input *hi,
678 struct hid_field *field, struct hid_usage *usage,
679 unsigned long **bit, int *max)
681 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
682 unsigned int abs = usage->hid & HID_USAGE;
684 if (abs == GUITAR_TILT_USAGE) {
685 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, ABS_RY);
692 static ssize_t ds4_show_poll_interval(struct device *dev,
693 struct device_attribute
696 struct hid_device *hdev = to_hid_device(dev);
697 struct sony_sc *sc = hid_get_drvdata(hdev);
699 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
702 static ssize_t ds4_store_poll_interval(struct device *dev,
703 struct device_attribute *attr,
704 const char *buf, size_t count)
706 struct hid_device *hdev = to_hid_device(dev);
707 struct sony_sc *sc = hid_get_drvdata(hdev);
711 if (kstrtou8(buf, 0, &interval))
714 if (interval > DS4_BT_MAX_POLL_INTERVAL_MS)
717 spin_lock_irqsave(&sc->lock, flags);
718 sc->ds4_bt_poll_interval = interval;
719 spin_unlock_irqrestore(&sc->lock, flags);
721 sony_schedule_work(sc, SONY_WORKER_STATE);
726 static DEVICE_ATTR(bt_poll_interval, 0644, ds4_show_poll_interval,
727 ds4_store_poll_interval);
729 static ssize_t sony_show_firmware_version(struct device *dev,
730 struct device_attribute
733 struct hid_device *hdev = to_hid_device(dev);
734 struct sony_sc *sc = hid_get_drvdata(hdev);
736 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
739 static DEVICE_ATTR(firmware_version, 0444, sony_show_firmware_version, NULL);
741 static ssize_t sony_show_hardware_version(struct device *dev,
742 struct device_attribute
745 struct hid_device *hdev = to_hid_device(dev);
746 struct sony_sc *sc = hid_get_drvdata(hdev);
748 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
751 static DEVICE_ATTR(hardware_version, 0444, sony_show_hardware_version, NULL);
753 static u8 *motion_fixup(struct hid_device *hdev, u8 *rdesc,
756 *rsize = sizeof(motion_rdesc);
760 static u8 *ps3remote_fixup(struct hid_device *hdev, u8 *rdesc,
763 *rsize = sizeof(ps3remote_rdesc);
764 return ps3remote_rdesc;
767 static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
768 struct hid_field *field, struct hid_usage *usage,
769 unsigned long **bit, int *max)
771 unsigned int key = usage->hid & HID_USAGE;
773 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
776 switch (usage->collection_index) {
778 if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
781 key = ps3remote_keymap_joypad_buttons[key];
786 if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
789 key = ps3remote_keymap_remote_buttons[key];
797 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
801 static int navigation_mapping(struct hid_device *hdev, struct hid_input *hi,
802 struct hid_field *field, struct hid_usage *usage,
803 unsigned long **bit, int *max)
805 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
806 unsigned int key = usage->hid & HID_USAGE;
808 if (key >= ARRAY_SIZE(sixaxis_keymap))
811 key = navigation_keymap[key];
815 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
817 } else if (usage->hid == HID_GD_POINTER) {
818 /* See comment in sixaxis_mapping, basically the L2 (and R2)
819 * triggers are reported through GD Pointer.
820 * In addition we ignore any analog button 'axes' and only
821 * support digital buttons.
823 switch (usage->usage_index) {
825 usage->hid = HID_GD_Z;
831 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
833 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
834 unsigned int abs = usage->hid & HID_USAGE;
836 if (abs >= ARRAY_SIZE(navigation_absmap))
839 abs = navigation_absmap[abs];
841 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
849 static int sixaxis_mapping(struct hid_device *hdev, struct hid_input *hi,
850 struct hid_field *field, struct hid_usage *usage,
851 unsigned long **bit, int *max)
853 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
854 unsigned int key = usage->hid & HID_USAGE;
856 if (key >= ARRAY_SIZE(sixaxis_keymap))
859 key = sixaxis_keymap[key];
860 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
862 } else if (usage->hid == HID_GD_POINTER) {
863 /* The DS3 provides analog values for most buttons and even
864 * for HAT axes through GD Pointer. L2 and R2 are reported
865 * among these as well instead of as GD Z / RZ. Remap L2
866 * and R2 and ignore other analog 'button axes' as there is
867 * no good way for reporting them.
869 switch (usage->usage_index) {
871 usage->hid = HID_GD_Z;
874 usage->hid = HID_GD_RZ;
880 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
882 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
883 unsigned int abs = usage->hid & HID_USAGE;
885 if (abs >= ARRAY_SIZE(sixaxis_absmap))
888 abs = sixaxis_absmap[abs];
890 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
897 static int ds4_mapping(struct hid_device *hdev, struct hid_input *hi,
898 struct hid_field *field, struct hid_usage *usage,
899 unsigned long **bit, int *max)
901 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
902 unsigned int key = usage->hid & HID_USAGE;
904 if (key >= ARRAY_SIZE(ds4_keymap))
907 key = ds4_keymap[key];
908 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
910 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
911 unsigned int abs = usage->hid & HID_USAGE;
913 /* Let the HID parser deal with the HAT. */
914 if (usage->hid == HID_GD_HATSWITCH)
917 if (abs >= ARRAY_SIZE(ds4_absmap))
920 abs = ds4_absmap[abs];
921 hid_map_usage_clear(hi, usage, bit, max, EV_ABS, abs);
928 static u8 *sony_report_fixup(struct hid_device *hdev, u8 *rdesc,
931 struct sony_sc *sc = hid_get_drvdata(hdev);
933 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
937 * Some Sony RF receivers wrongly declare the mouse pointer as a
938 * a constant non-data variable.
940 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
941 /* usage page: generic desktop controls */
942 /* rdesc[0] == 0x05 && rdesc[1] == 0x01 && */
944 rdesc[2] == 0x09 && rdesc[3] == 0x02 &&
945 /* input (usage page for x,y axes): constant, variable, relative */
946 rdesc[54] == 0x81 && rdesc[55] == 0x07) {
947 hid_info(hdev, "Fixing up Sony RF Receiver report descriptor\n");
948 /* input: data, variable, relative */
952 if (sc->quirks & MOTION_CONTROLLER)
953 return motion_fixup(hdev, rdesc, rsize);
955 if (sc->quirks & PS3REMOTE)
956 return ps3remote_fixup(hdev, rdesc, rsize);
959 * Some knock-off USB dongles incorrectly report their button count
960 * as 13 instead of 16 causing three non-functional buttons.
962 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
963 /* Report Count (13) */
964 rdesc[23] == 0x95 && rdesc[24] == 0x0D &&
965 /* Usage Maximum (13) */
966 rdesc[37] == 0x29 && rdesc[38] == 0x0D &&
967 /* Report Count (3) */
968 rdesc[43] == 0x95 && rdesc[44] == 0x03) {
969 hid_info(hdev, "Fixing up USB dongle report descriptor\n");
978 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
980 static const u8 sixaxis_battery_capacity[] = { 0, 1, 25, 50, 75, 100 };
987 * The sixaxis is charging if the battery value is 0xee
988 * and it is fully charged if the value is 0xef.
989 * It does not report the actual level while charging so it
990 * is set to 100% while charging is in progress.
992 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
994 if (rd[offset] >= 0xee) {
995 battery_capacity = 100;
996 battery_status = (rd[offset] & 0x01) ? POWER_SUPPLY_STATUS_FULL : POWER_SUPPLY_STATUS_CHARGING;
998 u8 index = rd[offset] <= 5 ? rd[offset] : 5;
999 battery_capacity = sixaxis_battery_capacity[index];
1000 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1003 spin_lock_irqsave(&sc->lock, flags);
1004 sc->battery_capacity = battery_capacity;
1005 sc->battery_status = battery_status;
1006 spin_unlock_irqrestore(&sc->lock, flags);
1008 if (sc->quirks & SIXAXIS_CONTROLLER) {
1011 offset = SIXAXIS_INPUT_REPORT_ACC_X_OFFSET;
1012 val = ((rd[offset+1] << 8) | rd[offset]) - 511;
1013 input_report_abs(sc->sensor_dev, ABS_X, val);
1015 /* Y and Z are swapped and inversed */
1016 val = 511 - ((rd[offset+5] << 8) | rd[offset+4]);
1017 input_report_abs(sc->sensor_dev, ABS_Y, val);
1019 val = 511 - ((rd[offset+3] << 8) | rd[offset+2]);
1020 input_report_abs(sc->sensor_dev, ABS_Z, val);
1022 input_sync(sc->sensor_dev);
1026 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
1028 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
1029 struct hid_input, list);
1030 struct input_dev *input_dev = hidinput->input;
1031 unsigned long flags;
1032 int n, m, offset, num_touch_data, max_touch_data;
1033 u8 cable_state, battery_capacity;
1037 /* When using Bluetooth the header is 2 bytes longer, so skip these. */
1038 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
1040 /* Second bit of third button byte is for the touchpad button. */
1041 offset = data_offset + DS4_INPUT_REPORT_BUTTON_OFFSET;
1042 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1045 * The default behavior of the Dualshock 4 is to send reports using
1046 * report type 1 when running over Bluetooth. However, when feature
1047 * report 2 is requested during the controller initialization it starts
1048 * sending input reports in report 17. Since report 17 is undefined
1049 * in the default HID descriptor, the HID layer won't generate events.
1050 * While it is possible (and this was done before) to fixup the HID
1051 * descriptor to add this mapping, it was better to do this manually.
1052 * The reason is there were various pieces software both open and closed
1053 * source, relying on the descriptors to be the same across various
1054 * operating systems. If the descriptors wouldn't match some
1055 * applications e.g. games on Wine would not be able to function due
1056 * to different descriptors, which such applications are not parsing.
1061 offset = data_offset + DS4_INPUT_REPORT_AXIS_OFFSET;
1062 input_report_abs(input_dev, ABS_X, rd[offset]);
1063 input_report_abs(input_dev, ABS_Y, rd[offset+1]);
1064 input_report_abs(input_dev, ABS_RX, rd[offset+2]);
1065 input_report_abs(input_dev, ABS_RY, rd[offset+3]);
1067 value = rd[offset+4] & 0xf;
1069 value = 8; /* Center 0, 0 */
1070 input_report_abs(input_dev, ABS_HAT0X, ds4_hat_mapping[value].x);
1071 input_report_abs(input_dev, ABS_HAT0Y, ds4_hat_mapping[value].y);
1073 input_report_key(input_dev, BTN_WEST, rd[offset+4] & 0x10);
1074 input_report_key(input_dev, BTN_SOUTH, rd[offset+4] & 0x20);
1075 input_report_key(input_dev, BTN_EAST, rd[offset+4] & 0x40);
1076 input_report_key(input_dev, BTN_NORTH, rd[offset+4] & 0x80);
1078 input_report_key(input_dev, BTN_TL, rd[offset+5] & 0x1);
1079 input_report_key(input_dev, BTN_TR, rd[offset+5] & 0x2);
1080 input_report_key(input_dev, BTN_TL2, rd[offset+5] & 0x4);
1081 input_report_key(input_dev, BTN_TR2, rd[offset+5] & 0x8);
1082 input_report_key(input_dev, BTN_SELECT, rd[offset+5] & 0x10);
1083 input_report_key(input_dev, BTN_START, rd[offset+5] & 0x20);
1084 input_report_key(input_dev, BTN_THUMBL, rd[offset+5] & 0x40);
1085 input_report_key(input_dev, BTN_THUMBR, rd[offset+5] & 0x80);
1087 input_report_key(input_dev, BTN_MODE, rd[offset+6] & 0x1);
1089 input_report_abs(input_dev, ABS_Z, rd[offset+7]);
1090 input_report_abs(input_dev, ABS_RZ, rd[offset+8]);
1092 input_sync(input_dev);
1095 /* Convert timestamp (in 5.33us unit) to timestamp_us */
1096 offset = data_offset + DS4_INPUT_REPORT_TIMESTAMP_OFFSET;
1097 timestamp = get_unaligned_le16(&rd[offset]);
1098 if (!sc->timestamp_initialized) {
1099 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1100 sc->timestamp_initialized = true;
1104 if (sc->prev_timestamp > timestamp)
1105 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1107 delta = timestamp - sc->prev_timestamp;
1108 sc->timestamp_us += (delta * 16) / 3;
1110 sc->prev_timestamp = timestamp;
1111 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1113 offset = data_offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
1114 for (n = 0; n < 6; n++) {
1115 /* Store data in int for more precision during mult_frac. */
1116 int raw_data = (short)((rd[offset+1] << 8) | rd[offset]);
1117 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1119 /* High precision is needed during calibration, but the
1120 * calibrated values are within 32-bit.
1121 * Note: we swap numerator 'x' and 'numer' in mult_frac for
1122 * precision reasons so we don't need 64-bit.
1124 int calib_data = mult_frac(calib->sens_numer,
1125 raw_data - calib->bias,
1128 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1131 input_sync(sc->sensor_dev);
1134 * The lower 4 bits of byte 30 (or 32 for BT) contain the battery level
1135 * and the 5th bit contains the USB cable state.
1137 offset = data_offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
1138 cable_state = (rd[offset] >> 4) & 0x01;
1141 * Interpretation of the battery_capacity data depends on the cable state.
1142 * When no cable is connected (bit4 is 0):
1143 * - 0:10: percentage in units of 10%.
1144 * When a cable is plugged in:
1145 * - 0-10: percentage in units of 10%.
1146 * - 11: battery is full
1147 * - 14: not charging due to Voltage or temperature error
1148 * - 15: charge error
1151 u8 battery_data = rd[offset] & 0xf;
1153 if (battery_data < 10) {
1154 /* Take the mid-point for each battery capacity value,
1155 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
1156 * This matches official platform behavior, which does
1159 battery_capacity = battery_data * 10 + 5;
1160 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1161 } else if (battery_data == 10) {
1162 battery_capacity = 100;
1163 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1164 } else if (battery_data == 11) {
1165 battery_capacity = 100;
1166 battery_status = POWER_SUPPLY_STATUS_FULL;
1167 } else { /* 14, 15 and undefined values */
1168 battery_capacity = 0;
1169 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1172 u8 battery_data = rd[offset] & 0xf;
1174 if (battery_data < 10)
1175 battery_capacity = battery_data * 10 + 5;
1177 battery_capacity = 100;
1179 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1182 spin_lock_irqsave(&sc->lock, flags);
1183 sc->battery_capacity = battery_capacity;
1184 sc->battery_status = battery_status;
1185 spin_unlock_irqrestore(&sc->lock, flags);
1188 * The Dualshock 4 multi-touch trackpad data starts at offset 33 on USB
1189 * and 35 on Bluetooth.
1190 * The first byte indicates the number of touch data in the report.
1191 * Trackpad data starts 2 bytes later (e.g. 35 for USB).
1193 offset = data_offset + DS4_INPUT_REPORT_TOUCHPAD_OFFSET;
1194 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1195 if (rd[offset] > 0 && rd[offset] <= max_touch_data)
1196 num_touch_data = rd[offset];
1201 for (m = 0; m < num_touch_data; m++) {
1202 /* Skip past timestamp */
1206 * The first 7 bits of the first byte is a counter and bit 8 is
1207 * a touch indicator that is 0 when pressed and 1 when not
1209 * The next 3 bytes are two 12 bit touch coordinates, X and Y.
1210 * The data for the second touch is in the same format and
1211 * immediately follows the data for the first.
1213 for (n = 0; n < 2; n++) {
1217 x = rd[offset+1] | ((rd[offset+2] & 0xF) << 8);
1218 y = ((rd[offset+2] & 0xF0) >> 4) | (rd[offset+3] << 4);
1220 active = !(rd[offset] >> 7);
1221 input_mt_slot(sc->touchpad, n);
1222 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1225 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1226 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1231 input_mt_sync_frame(sc->touchpad);
1232 input_sync(sc->touchpad);
1236 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1238 int n, offset, relx, rely;
1242 * The NSG-MRxU multi-touch trackpad data starts at offset 1 and
1243 * the touch-related data starts at offset 2.
1244 * For the first byte, bit 0 is set when touchpad button is pressed.
1245 * Bit 2 is set when a touch is active and the drag (Fn) key is pressed.
1246 * This drag key is mapped to BTN_LEFT. It is operational only when a
1247 * touch point is active.
1248 * Bit 4 is set when only the first touch point is active.
1249 * Bit 6 is set when only the second touch point is active.
1250 * Bits 5 and 7 are set when both touch points are active.
1251 * The next 3 bytes are two 12 bit X/Y coordinates for the first touch.
1252 * The following byte, offset 5, has the touch width and length.
1253 * Bits 0-4=X (width), bits 5-7=Y (length).
1254 * A signed relative X coordinate is at offset 6.
1255 * The bytes at offset 7-9 are the second touch X/Y coordinates.
1256 * Offset 10 has the second touch width and length.
1257 * Offset 11 has the relative Y coordinate.
1261 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1262 active = (rd[offset] >> 4);
1263 relx = (s8) rd[offset+5];
1264 rely = ((s8) rd[offset+10]) * -1;
1268 for (n = 0; n < 2; n++) {
1270 u8 contactx, contacty;
1272 x = rd[offset] | ((rd[offset+1] & 0x0F) << 8);
1273 y = ((rd[offset+1] & 0xF0) >> 4) | (rd[offset+2] << 4);
1275 input_mt_slot(sc->touchpad, n);
1276 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1278 if (active & 0x03) {
1279 contactx = rd[offset+3] & 0x0F;
1280 contacty = rd[offset+3] >> 4;
1281 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1282 max(contactx, contacty));
1283 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1284 min(contactx, contacty));
1285 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1286 (bool) (contactx > contacty));
1287 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1288 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1289 NSG_MRXU_MAX_Y - y);
1291 * The relative coordinates belong to the first touch
1292 * point, when present, or to the second touch point
1293 * when the first is not active.
1295 if ((n == 0) || ((n == 1) && (active & 0x01))) {
1296 input_report_rel(sc->touchpad, REL_X, relx);
1297 input_report_rel(sc->touchpad, REL_Y, rely);
1305 input_mt_sync_frame(sc->touchpad);
1307 input_sync(sc->touchpad);
1310 static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
1313 struct sony_sc *sc = hid_get_drvdata(hdev);
1316 * Sixaxis HID report has acclerometers/gyro with MSByte first, this
1317 * has to be BYTE_SWAPPED before passing up to joystick interface
1319 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1321 * When connected via Bluetooth the Sixaxis occasionally sends
1322 * a report with the second byte 0xff and the rest zeroed.
1324 * This report does not reflect the actual state of the
1325 * controller must be ignored to avoid generating false input
1331 swap(rd[41], rd[42]);
1332 swap(rd[43], rd[44]);
1333 swap(rd[45], rd[46]);
1334 swap(rd[47], rd[48]);
1336 sixaxis_parse_report(sc, rd, size);
1337 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1338 sixaxis_parse_report(sc, rd, size);
1339 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1341 sixaxis_parse_report(sc, rd, size);
1342 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1344 dualshock4_parse_report(sc, rd, size);
1345 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1352 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1353 crc = ~crc32_le(crc, rd, DS4_INPUT_REPORT_0x11_SIZE-4);
1354 report_crc = get_unaligned_le32(&rd[DS4_INPUT_REPORT_0x11_SIZE-4]);
1355 if (crc != report_crc) {
1356 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1361 dualshock4_parse_report(sc, rd, size);
1362 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1364 unsigned long flags;
1365 enum ds4_dongle_state dongle_state;
1368 * In the case of a DS4 USB dongle, bit[2] of byte 31 indicates
1369 * if a DS4 is actually connected (indicated by '0').
1370 * For non-dongle, this bit is always 0 (connected).
1372 bool connected = (rd[31] & 0x04) ? false : true;
1374 spin_lock_irqsave(&sc->lock, flags);
1375 dongle_state = sc->ds4_dongle_state;
1376 spin_unlock_irqrestore(&sc->lock, flags);
1379 * The dongle always sends input reports even when no
1380 * DS4 is attached. When a DS4 is connected, we need to
1381 * obtain calibration data before we can use it.
1382 * The code below tracks dongle state and kicks of
1383 * calibration when needed and only allows us to process
1384 * input if a DS4 is actually connected.
1386 if (dongle_state == DONGLE_DISCONNECTED && connected) {
1387 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1390 spin_lock_irqsave(&sc->lock, flags);
1391 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1392 spin_unlock_irqrestore(&sc->lock, flags);
1394 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1396 /* Don't process the report since we don't have
1397 * calibration data, but let hidraw have it anyway.
1400 } else if ((dongle_state == DONGLE_CONNECTED ||
1401 dongle_state == DONGLE_DISABLED) && !connected) {
1402 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1404 spin_lock_irqsave(&sc->lock, flags);
1405 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1406 spin_unlock_irqrestore(&sc->lock, flags);
1408 /* Return 0, so hidraw can get the report. */
1410 } else if (dongle_state == DONGLE_CALIBRATING ||
1411 dongle_state == DONGLE_DISABLED ||
1412 dongle_state == DONGLE_DISCONNECTED) {
1413 /* Return 0, so hidraw can get the report. */
1417 dualshock4_parse_report(sc, rd, size);
1419 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1420 nsg_mrxu_parse_report(sc, rd, size);
1424 if (sc->defer_initialization) {
1425 sc->defer_initialization = 0;
1426 sony_schedule_work(sc, SONY_WORKER_STATE);
1432 static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
1433 struct hid_field *field, struct hid_usage *usage,
1434 unsigned long **bit, int *max)
1436 struct sony_sc *sc = hid_get_drvdata(hdev);
1438 if (sc->quirks & BUZZ_CONTROLLER) {
1439 unsigned int key = usage->hid & HID_USAGE;
1441 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
1444 switch (usage->collection_index) {
1446 if (key >= ARRAY_SIZE(buzz_keymap))
1449 key = buzz_keymap[key];
1457 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
1461 if (sc->quirks & PS3REMOTE)
1462 return ps3remote_mapping(hdev, hi, field, usage, bit, max);
1464 if (sc->quirks & NAVIGATION_CONTROLLER)
1465 return navigation_mapping(hdev, hi, field, usage, bit, max);
1467 if (sc->quirks & SIXAXIS_CONTROLLER)
1468 return sixaxis_mapping(hdev, hi, field, usage, bit, max);
1470 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1471 return ds4_mapping(hdev, hi, field, usage, bit, max);
1473 if (sc->quirks & GH_GUITAR_CONTROLLER)
1474 return guitar_mapping(hdev, hi, field, usage, bit, max);
1476 /* Let hid-core decide for the others */
1480 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1481 int w, int h, int touch_major, int touch_minor, int orientation)
1487 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1491 input_set_drvdata(sc->touchpad, sc);
1492 sc->touchpad->dev.parent = &sc->hdev->dev;
1493 sc->touchpad->phys = sc->hdev->phys;
1494 sc->touchpad->uniq = sc->hdev->uniq;
1495 sc->touchpad->id.bustype = sc->hdev->bus;
1496 sc->touchpad->id.vendor = sc->hdev->vendor;
1497 sc->touchpad->id.product = sc->hdev->product;
1498 sc->touchpad->id.version = sc->hdev->version;
1500 /* Append a suffix to the controller name as there are various
1501 * DS4 compatible non-Sony devices with different names.
1503 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1504 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1507 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1508 sc->touchpad->name = name;
1510 /* We map the button underneath the touchpad to BTN_LEFT. */
1511 __set_bit(EV_KEY, sc->touchpad->evbit);
1512 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1513 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1515 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1516 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1518 if (touch_major > 0) {
1519 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1520 0, touch_major, 0, 0);
1521 if (touch_minor > 0)
1522 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1523 0, touch_minor, 0, 0);
1524 if (orientation > 0)
1525 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1526 0, orientation, 0, 0);
1529 if (sc->quirks & NSG_MRXU_REMOTE) {
1530 __set_bit(EV_REL, sc->touchpad->evbit);
1533 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1537 ret = input_register_device(sc->touchpad);
1544 static int sony_register_sensors(struct sony_sc *sc)
1551 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1552 if (!sc->sensor_dev)
1555 input_set_drvdata(sc->sensor_dev, sc);
1556 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1557 sc->sensor_dev->phys = sc->hdev->phys;
1558 sc->sensor_dev->uniq = sc->hdev->uniq;
1559 sc->sensor_dev->id.bustype = sc->hdev->bus;
1560 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1561 sc->sensor_dev->id.product = sc->hdev->product;
1562 sc->sensor_dev->id.version = sc->hdev->version;
1564 /* Append a suffix to the controller name as there are various
1565 * DS4 compatible non-Sony devices with different names.
1567 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1568 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1571 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1572 sc->sensor_dev->name = name;
1574 if (sc->quirks & SIXAXIS_CONTROLLER) {
1575 /* For the DS3 we only support the accelerometer, which works
1576 * quite well even without calibration. The device also has
1577 * a 1-axis gyro, but it is very difficult to manage from within
1578 * the driver even to get data, the sensor is inaccurate and
1579 * the behavior is very different between hardware revisions.
1581 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1582 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1583 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1584 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1585 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1586 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1587 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1588 range = DS4_ACC_RES_PER_G*4;
1589 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1590 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1591 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1592 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1593 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1594 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1596 range = DS4_GYRO_RES_PER_DEG_S*2048;
1597 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1598 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1599 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1600 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1601 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1602 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1604 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1605 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1608 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1610 ret = input_register_device(sc->sensor_dev);
1618 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1619 * to "operational". Without this, the ps3 controller will not report any
1622 static int sixaxis_set_operational_usb(struct hid_device *hdev)
1624 struct sony_sc *sc = hid_get_drvdata(hdev);
1625 const int buf_size =
1626 max(SIXAXIS_REPORT_0xF2_SIZE, SIXAXIS_REPORT_0xF5_SIZE);
1630 buf = kmalloc(buf_size, GFP_KERNEL);
1634 ret = hid_hw_raw_request(hdev, 0xf2, buf, SIXAXIS_REPORT_0xF2_SIZE,
1635 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1637 hid_err(hdev, "can't set operational mode: step 1\n");
1642 * Some compatible controllers like the Speedlink Strike FX and
1643 * Gasia need another query plus an USB interrupt to get operational.
1645 ret = hid_hw_raw_request(hdev, 0xf5, buf, SIXAXIS_REPORT_0xF5_SIZE,
1646 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
1648 hid_err(hdev, "can't set operational mode: step 2\n");
1653 * But the USB interrupt would cause SHANWAN controllers to
1654 * start rumbling non-stop, so skip step 3 for these controllers.
1656 if (sc->quirks & SHANWAN_GAMEPAD)
1659 ret = hid_hw_output_report(hdev, buf, 1);
1661 hid_info(hdev, "can't set operational mode: step 3, ignoring\n");
1671 static int sixaxis_set_operational_bt(struct hid_device *hdev)
1673 static const u8 report[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
1677 buf = kmemdup(report, sizeof(report), GFP_KERNEL);
1681 ret = hid_hw_raw_request(hdev, buf[0], buf, sizeof(report),
1682 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
1690 * Request DS4 calibration data for the motion sensors.
1691 * For Bluetooth this also affects the operating mode (see below).
1693 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1697 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1698 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1699 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1700 short gyro_speed_plus, gyro_speed_minus;
1701 short acc_x_plus, acc_x_minus;
1702 short acc_y_plus, acc_y_minus;
1703 short acc_z_plus, acc_z_minus;
1707 /* For Bluetooth we use a different request, which supports CRC.
1708 * Note: in Bluetooth mode feature report 0x02 also changes the state
1709 * of the controller, so that it sends input reports of type 0x11.
1711 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1714 buf = kmalloc(DS4_FEATURE_REPORT_0x02_SIZE, GFP_KERNEL);
1718 /* We should normally receive the feature report data we asked
1719 * for, but hidraw applications such as Steam can issue feature
1720 * reports as well. In particular for Dongle reconnects, Steam
1721 * and this function are competing resulting in often receiving
1722 * data for a different HID report, so retry a few times.
1724 for (retries = 0; retries < 3; retries++) {
1725 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1726 DS4_FEATURE_REPORT_0x02_SIZE,
1728 HID_REQ_GET_REPORT);
1732 if (buf[0] != 0x02) {
1734 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1750 buf = kmalloc(DS4_FEATURE_REPORT_0x05_SIZE, GFP_KERNEL);
1754 for (retries = 0; retries < 3; retries++) {
1755 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1756 DS4_FEATURE_REPORT_0x05_SIZE,
1758 HID_REQ_GET_REPORT);
1763 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
1764 crc = ~crc32_le(crc, buf, DS4_FEATURE_REPORT_0x05_SIZE-4);
1765 report_crc = get_unaligned_le32(&buf[DS4_FEATURE_REPORT_0x05_SIZE-4]);
1766 if (crc != report_crc) {
1767 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1770 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1782 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
1783 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
1784 gyro_roll_bias = get_unaligned_le16(&buf[5]);
1785 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1786 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1787 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1788 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
1789 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
1790 gyro_roll_plus = get_unaligned_le16(&buf[15]);
1791 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1794 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
1795 gyro_yaw_plus = get_unaligned_le16(&buf[9]);
1796 gyro_roll_plus = get_unaligned_le16(&buf[11]);
1797 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1798 gyro_yaw_minus = get_unaligned_le16(&buf[15]);
1799 gyro_roll_minus = get_unaligned_le16(&buf[17]);
1801 gyro_speed_plus = get_unaligned_le16(&buf[19]);
1802 gyro_speed_minus = get_unaligned_le16(&buf[21]);
1803 acc_x_plus = get_unaligned_le16(&buf[23]);
1804 acc_x_minus = get_unaligned_le16(&buf[25]);
1805 acc_y_plus = get_unaligned_le16(&buf[27]);
1806 acc_y_minus = get_unaligned_le16(&buf[29]);
1807 acc_z_plus = get_unaligned_le16(&buf[31]);
1808 acc_z_minus = get_unaligned_le16(&buf[33]);
1810 /* Set gyroscope calibration and normalization parameters.
1811 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1813 speed_2x = (gyro_speed_plus + gyro_speed_minus);
1814 sc->ds4_calib_data[0].abs_code = ABS_RX;
1815 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1816 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1817 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1819 sc->ds4_calib_data[1].abs_code = ABS_RY;
1820 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1821 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1822 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1824 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1825 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1826 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1827 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1829 /* Set accelerometer calibration and normalization parameters.
1830 * Data values will be normalized to 1/DS4_ACC_RES_PER_G G.
1832 range_2g = acc_x_plus - acc_x_minus;
1833 sc->ds4_calib_data[3].abs_code = ABS_X;
1834 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1835 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1836 sc->ds4_calib_data[3].sens_denom = range_2g;
1838 range_2g = acc_y_plus - acc_y_minus;
1839 sc->ds4_calib_data[4].abs_code = ABS_Y;
1840 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1841 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1842 sc->ds4_calib_data[4].sens_denom = range_2g;
1844 range_2g = acc_z_plus - acc_z_minus;
1845 sc->ds4_calib_data[5].abs_code = ABS_Z;
1846 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1847 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1848 sc->ds4_calib_data[5].sens_denom = range_2g;
1855 static void dualshock4_calibration_work(struct work_struct *work)
1857 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1858 unsigned long flags;
1859 enum ds4_dongle_state dongle_state;
1862 ret = dualshock4_get_calibration_data(sc);
1864 /* This call is very unlikely to fail for the dongle. When it
1865 * fails we are probably in a very bad state, so mark the
1866 * dongle as disabled. We will re-enable the dongle if a new
1867 * DS4 hotplug is detect from sony_raw_event as any issues
1868 * are likely resolved then (the dongle is quite stupid).
1870 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1871 dongle_state = DONGLE_DISABLED;
1873 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1874 dongle_state = DONGLE_CONNECTED;
1877 spin_lock_irqsave(&sc->lock, flags);
1878 sc->ds4_dongle_state = dongle_state;
1879 spin_unlock_irqrestore(&sc->lock, flags);
1882 static int dualshock4_get_version_info(struct sony_sc *sc)
1887 buf = kmalloc(DS4_FEATURE_REPORT_0xA3_SIZE, GFP_KERNEL);
1891 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1892 DS4_FEATURE_REPORT_0xA3_SIZE,
1894 HID_REQ_GET_REPORT);
1900 sc->hw_version = get_unaligned_le16(&buf[35]);
1901 sc->fw_version = get_unaligned_le16(&buf[41]);
1907 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1909 static const u8 sixaxis_leds[10][4] = {
1910 { 0x01, 0x00, 0x00, 0x00 },
1911 { 0x00, 0x01, 0x00, 0x00 },
1912 { 0x00, 0x00, 0x01, 0x00 },
1913 { 0x00, 0x00, 0x00, 0x01 },
1914 { 0x01, 0x00, 0x00, 0x01 },
1915 { 0x00, 0x01, 0x00, 0x01 },
1916 { 0x00, 0x00, 0x01, 0x01 },
1917 { 0x01, 0x00, 0x01, 0x01 },
1918 { 0x00, 0x01, 0x01, 0x01 },
1919 { 0x01, 0x01, 0x01, 0x01 }
1922 int id = sc->device_id;
1924 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(sixaxis_leds[0]));
1930 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1933 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1935 /* The first 4 color/index entries match what the PS4 assigns */
1936 static const u8 color_code[7][3] = {
1937 /* Blue */ { 0x00, 0x00, 0x40 },
1938 /* Red */ { 0x40, 0x00, 0x00 },
1939 /* Green */ { 0x00, 0x40, 0x00 },
1940 /* Pink */ { 0x20, 0x00, 0x20 },
1941 /* Orange */ { 0x02, 0x01, 0x00 },
1942 /* Teal */ { 0x00, 0x01, 0x01 },
1943 /* White */ { 0x01, 0x01, 0x01 }
1946 int id = sc->device_id;
1948 BUILD_BUG_ON(MAX_LEDS < ARRAY_SIZE(color_code[0]));
1954 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1957 static void buzz_set_leds(struct sony_sc *sc)
1959 struct hid_device *hdev = sc->hdev;
1960 struct list_head *report_list =
1961 &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
1962 struct hid_report *report = list_entry(report_list->next,
1963 struct hid_report, list);
1964 s32 *value = report->field[0]->value;
1966 BUILD_BUG_ON(MAX_LEDS < 4);
1969 value[1] = sc->led_state[0] ? 0xff : 0x00;
1970 value[2] = sc->led_state[1] ? 0xff : 0x00;
1971 value[3] = sc->led_state[2] ? 0xff : 0x00;
1972 value[4] = sc->led_state[3] ? 0xff : 0x00;
1975 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
1978 static void sony_set_leds(struct sony_sc *sc)
1980 if (!(sc->quirks & BUZZ_CONTROLLER))
1981 sony_schedule_work(sc, SONY_WORKER_STATE);
1986 static void sony_led_set_brightness(struct led_classdev *led,
1987 enum led_brightness value)
1989 struct device *dev = led->dev->parent;
1990 struct hid_device *hdev = to_hid_device(dev);
1991 struct sony_sc *drv_data;
1996 drv_data = hid_get_drvdata(hdev);
1998 hid_err(hdev, "No device data\n");
2003 * The Sixaxis on USB will override any LED settings sent to it
2004 * and keep flashing all of the LEDs until the PS button is pressed.
2005 * Updates, even if redundant, must be always be sent to the
2006 * controller to avoid having to toggle the state of an LED just to
2007 * stop the flashing later on.
2009 force_update = !!(drv_data->quirks & SIXAXIS_CONTROLLER_USB);
2011 for (n = 0; n < drv_data->led_count; n++) {
2012 if (led == drv_data->leds[n] && (force_update ||
2013 (value != drv_data->led_state[n] ||
2014 drv_data->led_delay_on[n] ||
2015 drv_data->led_delay_off[n]))) {
2017 drv_data->led_state[n] = value;
2019 /* Setting the brightness stops the blinking */
2020 drv_data->led_delay_on[n] = 0;
2021 drv_data->led_delay_off[n] = 0;
2023 sony_set_leds(drv_data);
2029 static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
2031 struct device *dev = led->dev->parent;
2032 struct hid_device *hdev = to_hid_device(dev);
2033 struct sony_sc *drv_data;
2037 drv_data = hid_get_drvdata(hdev);
2039 hid_err(hdev, "No device data\n");
2043 for (n = 0; n < drv_data->led_count; n++) {
2044 if (led == drv_data->leds[n])
2045 return drv_data->led_state[n];
2051 static int sony_led_blink_set(struct led_classdev *led, unsigned long *delay_on,
2052 unsigned long *delay_off)
2054 struct device *dev = led->dev->parent;
2055 struct hid_device *hdev = to_hid_device(dev);
2056 struct sony_sc *drv_data = hid_get_drvdata(hdev);
2061 hid_err(hdev, "No device data\n");
2065 /* Max delay is 255 deciseconds or 2550 milliseconds */
2066 if (*delay_on > 2550)
2068 if (*delay_off > 2550)
2071 /* Blink at 1 Hz if both values are zero */
2072 if (!*delay_on && !*delay_off)
2073 *delay_on = *delay_off = 500;
2075 new_on = *delay_on / 10;
2076 new_off = *delay_off / 10;
2078 for (n = 0; n < drv_data->led_count; n++) {
2079 if (led == drv_data->leds[n])
2083 /* This LED is not registered on this device */
2084 if (n >= drv_data->led_count)
2087 /* Don't schedule work if the values didn't change */
2088 if (new_on != drv_data->led_delay_on[n] ||
2089 new_off != drv_data->led_delay_off[n]) {
2090 drv_data->led_delay_on[n] = new_on;
2091 drv_data->led_delay_off[n] = new_off;
2092 sony_schedule_work(drv_data, SONY_WORKER_STATE);
2098 static int sony_leds_init(struct sony_sc *sc)
2100 struct hid_device *hdev = sc->hdev;
2103 struct led_classdev *led;
2107 const char *name_fmt;
2108 static const char * const ds4_name_str[] = { "red", "green", "blue",
2110 u8 max_brightness[MAX_LEDS] = { [0 ... (MAX_LEDS - 1)] = 1 };
2111 u8 use_hw_blink[MAX_LEDS] = { 0 };
2113 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
2115 if (sc->quirks & BUZZ_CONTROLLER) {
2118 name_len = strlen("::buzz#");
2119 name_fmt = "%s::buzz%d";
2120 /* Validate expected report characteristics. */
2121 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
2123 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2124 dualshock4_set_leds_from_id(sc);
2125 sc->led_state[3] = 1;
2127 memset(max_brightness, 255, 3);
2128 use_hw_blink[3] = 1;
2132 } else if (sc->quirks & MOTION_CONTROLLER) {
2134 memset(max_brightness, 255, 3);
2138 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
2139 static const u8 navigation_leds[4] = {0x01, 0x00, 0x00, 0x00};
2141 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2143 memset(use_hw_blink, 1, 4);
2145 name_len = strlen("::sony#");
2146 name_fmt = "%s::sony%d";
2148 sixaxis_set_leds_from_id(sc);
2150 memset(use_hw_blink, 1, 4);
2152 name_len = strlen("::sony#");
2153 name_fmt = "%s::sony%d";
2157 * Clear LEDs as we have no way of reading their initial state. This is
2158 * only relevant if the driver is loaded after somebody actively set the
2163 name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;
2165 for (n = 0; n < sc->led_count; n++) {
2168 name_sz = strlen(dev_name(&hdev->dev)) + strlen(ds4_name_str[n]) + 2;
2170 led = devm_kzalloc(&hdev->dev, sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
2172 hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
2176 name = (void *)(&led[1]);
2178 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev),
2181 snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
2183 led->brightness = sc->led_state[n];
2184 led->max_brightness = max_brightness[n];
2185 led->flags = LED_CORE_SUSPENDRESUME;
2186 led->brightness_get = sony_led_get_brightness;
2187 led->brightness_set = sony_led_set_brightness;
2189 if (use_hw_blink[n])
2190 led->blink_set = sony_led_blink_set;
2194 ret = devm_led_classdev_register(&hdev->dev, led);
2196 hid_err(hdev, "Failed to register LED %d\n", n);
2204 static void sixaxis_send_output_report(struct sony_sc *sc)
2206 static const union sixaxis_output_report_01 default_report = {
2209 0x01, 0xff, 0x00, 0xff, 0x00,
2210 0x00, 0x00, 0x00, 0x00, 0x00,
2211 0xff, 0x27, 0x10, 0x00, 0x32,
2212 0xff, 0x27, 0x10, 0x00, 0x32,
2213 0xff, 0x27, 0x10, 0x00, 0x32,
2214 0xff, 0x27, 0x10, 0x00, 0x32,
2215 0x00, 0x00, 0x00, 0x00, 0x00
2218 struct sixaxis_output_report *report =
2219 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2222 /* Initialize the report with default values */
2223 memcpy(report, &default_report, sizeof(struct sixaxis_output_report));
2225 #ifdef CONFIG_SONY_FF
2226 report->rumble.right_motor_on = sc->right ? 1 : 0;
2227 report->rumble.left_motor_force = sc->left;
2230 report->leds_bitmap |= sc->led_state[0] << 1;
2231 report->leds_bitmap |= sc->led_state[1] << 2;
2232 report->leds_bitmap |= sc->led_state[2] << 3;
2233 report->leds_bitmap |= sc->led_state[3] << 4;
2235 /* Set flag for all leds off, required for 3rd party INTEC controller */
2236 if ((report->leds_bitmap & 0x1E) == 0)
2237 report->leds_bitmap |= 0x20;
2240 * The LEDs in the report are indexed in reverse order to their
2241 * corresponding light on the controller.
2242 * Index 0 = LED 4, index 1 = LED 3, etc...
2244 * In the case of both delay values being zero (blinking disabled) the
2245 * default report values should be used or the controller LED will be
2248 for (n = 0; n < 4; n++) {
2249 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2250 report->led[3 - n].duty_off = sc->led_delay_off[n];
2251 report->led[3 - n].duty_on = sc->led_delay_on[n];
2255 /* SHANWAN controllers require output reports via intr channel */
2256 if (sc->quirks & SHANWAN_GAMEPAD)
2257 hid_hw_output_report(sc->hdev, (u8 *)report,
2258 sizeof(struct sixaxis_output_report));
2260 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2261 sizeof(struct sixaxis_output_report),
2262 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
2265 static void dualshock4_send_output_report(struct sony_sc *sc)
2267 struct hid_device *hdev = sc->hdev;
2268 u8 *buf = sc->output_report_dmabuf;
2272 * NOTE: The lower 6 bits of buf[1] field of the Bluetooth report
2273 * control the interval at which Dualshock 4 reports data:
2280 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2281 memset(buf, 0, DS4_OUTPUT_REPORT_0x05_SIZE);
2283 buf[1] = 0x07; /* blink + LEDs + motor */
2286 memset(buf, 0, DS4_OUTPUT_REPORT_0x11_SIZE);
2288 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2289 buf[3] = 0x07; /* blink + LEDs + motor */
2293 #ifdef CONFIG_SONY_FF
2294 buf[offset++] = sc->right;
2295 buf[offset++] = sc->left;
2300 /* LED 3 is the global control */
2301 if (sc->led_state[3]) {
2302 buf[offset++] = sc->led_state[0];
2303 buf[offset++] = sc->led_state[1];
2304 buf[offset++] = sc->led_state[2];
2309 /* If both delay values are zero the DualShock 4 disables blinking. */
2310 buf[offset++] = sc->led_delay_on[3];
2311 buf[offset++] = sc->led_delay_off[3];
2313 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2314 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x05_SIZE);
2316 /* CRC generation */
2320 crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
2321 crc = ~crc32_le(crc, buf, DS4_OUTPUT_REPORT_0x11_SIZE-4);
2322 put_unaligned_le32(crc, &buf[74]);
2323 hid_hw_output_report(hdev, buf, DS4_OUTPUT_REPORT_0x11_SIZE);
2327 static void motion_send_output_report(struct sony_sc *sc)
2329 struct hid_device *hdev = sc->hdev;
2330 struct motion_output_report_02 *report =
2331 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2333 memset(report, 0, MOTION_REPORT_0x02_SIZE);
2335 report->type = 0x02; /* set leds */
2336 report->r = sc->led_state[0];
2337 report->g = sc->led_state[1];
2338 report->b = sc->led_state[2];
2340 #ifdef CONFIG_SONY_FF
2341 report->rumble = max(sc->right, sc->left);
2344 hid_hw_output_report(hdev, (u8 *)report, MOTION_REPORT_0x02_SIZE);
2347 static inline void sony_send_output_report(struct sony_sc *sc)
2349 if (sc->send_output_report)
2350 sc->send_output_report(sc);
2353 static void sony_state_worker(struct work_struct *work)
2355 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2357 sc->send_output_report(sc);
2360 static int sony_allocate_output_report(struct sony_sc *sc)
2362 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2363 (sc->quirks & NAVIGATION_CONTROLLER))
2364 sc->output_report_dmabuf =
2365 devm_kmalloc(&sc->hdev->dev,
2366 sizeof(union sixaxis_output_report_01),
2368 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2369 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2370 DS4_OUTPUT_REPORT_0x11_SIZE,
2372 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2373 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2374 DS4_OUTPUT_REPORT_0x05_SIZE,
2376 else if (sc->quirks & MOTION_CONTROLLER)
2377 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2378 MOTION_REPORT_0x02_SIZE,
2383 if (!sc->output_report_dmabuf)
2389 #ifdef CONFIG_SONY_FF
2390 static int sony_play_effect(struct input_dev *dev, void *data,
2391 struct ff_effect *effect)
2393 struct hid_device *hid = input_get_drvdata(dev);
2394 struct sony_sc *sc = hid_get_drvdata(hid);
2396 if (effect->type != FF_RUMBLE)
2399 sc->left = effect->u.rumble.strong_magnitude / 256;
2400 sc->right = effect->u.rumble.weak_magnitude / 256;
2402 sony_schedule_work(sc, SONY_WORKER_STATE);
2406 static int sony_init_ff(struct sony_sc *sc)
2408 struct hid_input *hidinput;
2409 struct input_dev *input_dev;
2411 if (list_empty(&sc->hdev->inputs)) {
2412 hid_err(sc->hdev, "no inputs found\n");
2415 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2416 input_dev = hidinput->input;
2418 input_set_capability(input_dev, EV_FF, FF_RUMBLE);
2419 return input_ff_create_memless(input_dev, NULL, sony_play_effect);
2423 static int sony_init_ff(struct sony_sc *sc)
2430 static int sony_battery_get_property(struct power_supply *psy,
2431 enum power_supply_property psp,
2432 union power_supply_propval *val)
2434 struct sony_sc *sc = power_supply_get_drvdata(psy);
2435 unsigned long flags;
2437 u8 battery_capacity;
2440 spin_lock_irqsave(&sc->lock, flags);
2441 battery_capacity = sc->battery_capacity;
2442 battery_status = sc->battery_status;
2443 spin_unlock_irqrestore(&sc->lock, flags);
2446 case POWER_SUPPLY_PROP_PRESENT:
2449 case POWER_SUPPLY_PROP_SCOPE:
2450 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
2452 case POWER_SUPPLY_PROP_CAPACITY:
2453 val->intval = battery_capacity;
2455 case POWER_SUPPLY_PROP_STATUS:
2456 val->intval = battery_status;
2465 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2467 const char *battery_str_fmt = append_dev_id ?
2468 "sony_controller_battery_%pMR_%i" :
2469 "sony_controller_battery_%pMR";
2470 struct power_supply_config psy_cfg = { .drv_data = sc, };
2471 struct hid_device *hdev = sc->hdev;
2475 * Set the default battery level to 100% to avoid low battery warnings
2476 * if the battery is polled before the first device report is received.
2478 sc->battery_capacity = 100;
2480 sc->battery_desc.properties = sony_battery_props;
2481 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2482 sc->battery_desc.get_property = sony_battery_get_property;
2483 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2484 sc->battery_desc.use_for_apm = 0;
2485 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2486 battery_str_fmt, sc->mac_address, sc->device_id);
2487 if (!sc->battery_desc.name)
2490 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2492 if (IS_ERR(sc->battery)) {
2493 ret = PTR_ERR(sc->battery);
2494 hid_err(hdev, "Unable to register battery device\n");
2498 power_supply_powers(sc->battery, &hdev->dev);
2503 * If a controller is plugged in via USB while already connected via Bluetooth
2504 * it will show up as two devices. A global list of connected controllers and
2505 * their MAC addresses is maintained to ensure that a device is only connected
2508 * Some USB-only devices masquerade as Sixaxis controllers and all have the
2509 * same dummy Bluetooth address, so a comparison of the connection type is
2510 * required. Devices are only rejected in the case where two devices have
2511 * matching Bluetooth addresses on different bus types.
2513 static inline int sony_compare_connection_type(struct sony_sc *sc0,
2514 struct sony_sc *sc1)
2516 const int sc0_not_bt = !(sc0->quirks & SONY_BT_DEVICE);
2517 const int sc1_not_bt = !(sc1->quirks & SONY_BT_DEVICE);
2519 return sc0_not_bt == sc1_not_bt;
2522 static int sony_check_add_dev_list(struct sony_sc *sc)
2524 struct sony_sc *entry;
2525 unsigned long flags;
2528 spin_lock_irqsave(&sony_dev_list_lock, flags);
2530 list_for_each_entry(entry, &sony_device_list, list_node) {
2531 ret = memcmp(sc->mac_address, entry->mac_address,
2532 sizeof(sc->mac_address));
2534 if (sony_compare_connection_type(sc, entry)) {
2539 "controller with MAC address %pMR already connected\n",
2547 list_add(&(sc->list_node), &sony_device_list);
2550 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2554 static void sony_remove_dev_list(struct sony_sc *sc)
2556 unsigned long flags;
2558 if (sc->list_node.next) {
2559 spin_lock_irqsave(&sony_dev_list_lock, flags);
2560 list_del(&(sc->list_node));
2561 spin_unlock_irqrestore(&sony_dev_list_lock, flags);
2565 static int sony_get_bt_devaddr(struct sony_sc *sc)
2569 /* HIDP stores the device MAC address as a string in the uniq field. */
2570 ret = strlen(sc->hdev->uniq);
2574 ret = sscanf(sc->hdev->uniq,
2575 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2576 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2577 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2585 static int sony_check_add(struct sony_sc *sc)
2590 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2591 (sc->quirks & MOTION_CONTROLLER_BT) ||
2592 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2593 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2595 * sony_get_bt_devaddr() attempts to parse the Bluetooth MAC
2596 * address from the uniq string where HIDP stores it.
2597 * As uniq cannot be guaranteed to be a MAC address in all cases
2598 * a failure of this function should not prevent the connection.
2600 if (sony_get_bt_devaddr(sc) < 0) {
2601 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2604 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2605 buf = kmalloc(DS4_FEATURE_REPORT_0x81_SIZE, GFP_KERNEL);
2610 * The MAC address of a DS4 controller connected via USB can be
2611 * retrieved with feature report 0x81. The address begins at
2614 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2615 DS4_FEATURE_REPORT_0x81_SIZE, HID_FEATURE_REPORT,
2616 HID_REQ_GET_REPORT);
2618 if (ret != DS4_FEATURE_REPORT_0x81_SIZE) {
2619 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2620 ret = ret < 0 ? ret : -EINVAL;
2624 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2626 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2627 "%pMR", sc->mac_address);
2628 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2629 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2630 buf = kmalloc(SIXAXIS_REPORT_0xF2_SIZE, GFP_KERNEL);
2635 * The MAC address of a Sixaxis controller connected via USB can
2636 * be retrieved with feature report 0xf2. The address begins at
2639 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2640 SIXAXIS_REPORT_0xF2_SIZE, HID_FEATURE_REPORT,
2641 HID_REQ_GET_REPORT);
2643 if (ret != SIXAXIS_REPORT_0xF2_SIZE) {
2644 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2645 ret = ret < 0 ? ret : -EINVAL;
2650 * The Sixaxis device MAC in the report is big-endian and must
2653 for (n = 0; n < 6; n++)
2654 sc->mac_address[5-n] = buf[4+n];
2656 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2657 "%pMR", sc->mac_address);
2662 ret = sony_check_add_dev_list(sc);
2671 static int sony_set_device_id(struct sony_sc *sc)
2676 * Only DualShock 4 or Sixaxis controllers get an id.
2677 * All others are set to -1.
2679 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2680 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2681 ret = ida_simple_get(&sony_device_id_allocator, 0, 0,
2687 sc->device_id = ret;
2695 static void sony_release_device_id(struct sony_sc *sc)
2697 if (sc->device_id >= 0) {
2698 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2703 static inline void sony_init_output_report(struct sony_sc *sc,
2704 void (*send_output_report)(struct sony_sc *))
2706 sc->send_output_report = send_output_report;
2708 if (!sc->state_worker_initialized)
2709 INIT_WORK(&sc->state_worker, sony_state_worker);
2711 sc->state_worker_initialized = 1;
2714 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2716 unsigned long flags;
2718 if (sc->hotplug_worker_initialized)
2719 cancel_work_sync(&sc->hotplug_worker);
2720 if (sc->state_worker_initialized) {
2721 spin_lock_irqsave(&sc->lock, flags);
2722 sc->state_worker_initialized = 0;
2723 spin_unlock_irqrestore(&sc->lock, flags);
2724 cancel_work_sync(&sc->state_worker);
2728 static int sony_input_configured(struct hid_device *hdev,
2729 struct hid_input *hidinput)
2731 struct sony_sc *sc = hid_get_drvdata(hdev);
2735 ret = sony_set_device_id(sc);
2737 hid_err(hdev, "failed to allocate the device id\n");
2741 ret = append_dev_id = sony_check_add(sc);
2745 ret = sony_allocate_output_report(sc);
2747 hid_err(hdev, "failed to allocate the output report buffer\n");
2751 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2753 * The Sony Sixaxis does not handle HID Output Reports on the
2754 * Interrupt EP like it could, so we need to force HID Output
2755 * Reports to use HID_REQ_SET_REPORT on the Control EP.
2757 * There is also another issue about HID Output Reports via USB,
2758 * the Sixaxis does not want the report_id as part of the data
2759 * packet, so we have to discard buf[0] when sending the actual
2760 * control message, even for numbered reports, humpf!
2762 * Additionally, the Sixaxis on USB isn't properly initialized
2763 * until the PS logo button is pressed and as such won't retain
2764 * any state set by an output report, so the initial
2765 * configuration report is deferred until the first input
2768 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2769 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2770 sc->defer_initialization = 1;
2772 ret = sixaxis_set_operational_usb(hdev);
2774 hid_err(hdev, "Failed to set controller into operational mode\n");
2778 sony_init_output_report(sc, sixaxis_send_output_report);
2779 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2781 * The Navigation controller wants output reports sent on the ctrl
2782 * endpoint when connected via Bluetooth.
2784 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2786 ret = sixaxis_set_operational_bt(hdev);
2788 hid_err(hdev, "Failed to set controller into operational mode\n");
2792 sony_init_output_report(sc, sixaxis_send_output_report);
2793 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2795 * The Sony Sixaxis does not handle HID Output Reports on the
2796 * Interrupt EP and the device only becomes active when the
2797 * PS button is pressed. See comment for Navigation controller
2798 * above for more details.
2800 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2801 hdev->quirks |= HID_QUIRK_SKIP_OUTPUT_REPORT_ID;
2802 sc->defer_initialization = 1;
2804 ret = sixaxis_set_operational_usb(hdev);
2806 hid_err(hdev, "Failed to set controller into operational mode\n");
2810 ret = sony_register_sensors(sc);
2813 "Unable to initialize motion sensors: %d\n", ret);
2817 sony_init_output_report(sc, sixaxis_send_output_report);
2818 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2820 * The Sixaxis wants output reports sent on the ctrl endpoint
2821 * when connected via Bluetooth.
2823 hdev->quirks |= HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP;
2825 ret = sixaxis_set_operational_bt(hdev);
2827 hid_err(hdev, "Failed to set controller into operational mode\n");
2831 ret = sony_register_sensors(sc);
2834 "Unable to initialize motion sensors: %d\n", ret);
2838 sony_init_output_report(sc, sixaxis_send_output_report);
2839 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2840 ret = dualshock4_get_calibration_data(sc);
2842 hid_err(hdev, "Failed to get calibration data from Dualshock 4\n");
2846 ret = dualshock4_get_version_info(sc);
2848 hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2852 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2854 hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2857 sc->fw_version_created = true;
2859 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2861 hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2864 sc->hw_version_created = true;
2867 * The Dualshock 4 touchpad supports 2 touches and has a
2868 * resolution of 1920x942 (44.86 dots/mm).
2870 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2873 "Unable to initialize multi-touch slots: %d\n",
2878 ret = sony_register_sensors(sc);
2881 "Unable to initialize motion sensors: %d\n", ret);
2885 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2886 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2887 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2890 "can't create sysfs bt_poll_interval attribute err: %d\n",
2894 if (sc->quirks & DUALSHOCK4_DONGLE) {
2895 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2896 sc->hotplug_worker_initialized = 1;
2897 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2900 sony_init_output_report(sc, dualshock4_send_output_report);
2901 } else if (sc->quirks & NSG_MRXU_REMOTE) {
2903 * The NSG-MRxU touchpad supports 2 touches and has a
2904 * resolution of 1667x1868
2906 ret = sony_register_touchpad(sc, 2,
2907 NSG_MRXU_MAX_X, NSG_MRXU_MAX_Y, 15, 15, 1);
2910 "Unable to initialize multi-touch slots: %d\n",
2915 } else if (sc->quirks & MOTION_CONTROLLER) {
2916 sony_init_output_report(sc, motion_send_output_report);
2921 if (sc->quirks & SONY_LED_SUPPORT) {
2922 ret = sony_leds_init(sc);
2927 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2928 ret = sony_battery_probe(sc, append_dev_id);
2932 /* Open the device to receive reports with battery info */
2933 ret = hid_hw_open(hdev);
2935 hid_err(hdev, "hw open failed\n");
2940 if (sc->quirks & SONY_FF_SUPPORT) {
2941 ret = sony_init_ff(sc);
2950 /* Piggy back on the default ds4_bt_ poll_interval to determine
2951 * if we need to remove the file as we don't know for sure if we
2952 * executed that logic.
2954 if (sc->ds4_bt_poll_interval)
2955 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2956 if (sc->fw_version_created)
2957 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2958 if (sc->hw_version_created)
2959 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2960 sony_cancel_work_sync(sc);
2961 sony_remove_dev_list(sc);
2962 sony_release_device_id(sc);
2966 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
2969 unsigned long quirks = id->driver_data;
2971 struct usb_device *usbdev;
2972 unsigned int connect_mask = HID_CONNECT_DEFAULT;
2974 if (!strcmp(hdev->name, "FutureMax Dance Mat"))
2975 quirks |= FUTUREMAX_DANCE_MAT;
2977 if (!strcmp(hdev->name, "SHANWAN PS3 GamePad"))
2978 quirks |= SHANWAN_GAMEPAD;
2980 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2982 hid_err(hdev, "can't alloc sony descriptor\n");
2986 spin_lock_init(&sc->lock);
2988 sc->quirks = quirks;
2989 hid_set_drvdata(hdev, sc);
2991 usbdev = to_usb_device(sc->hdev->dev.parent->parent);
2993 ret = hid_parse(hdev);
2995 hid_err(hdev, "parse failed\n");
2999 if (sc->quirks & VAIO_RDESC_CONSTANT)
3000 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3001 else if (sc->quirks & SIXAXIS_CONTROLLER)
3002 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
3004 /* Patch the hw version on DS3/4 compatible devices, so applications can
3005 * distinguish between the default HID mappings and the mappings defined
3006 * by the Linux game controller spec. This is important for the SDL2
3007 * library, which has a game controller database, which uses device ids
3008 * in combination with version as a key.
3010 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
3011 hdev->version |= 0x8000;
3013 ret = hid_hw_start(hdev, connect_mask);
3015 hid_err(hdev, "hw start failed\n");
3019 /* sony_input_configured can fail, but this doesn't result
3020 * in hid_hw_start failures (intended). Check whether
3021 * the HID layer claimed the device else fail.
3022 * We don't know the actual reason for the failure, most
3023 * likely it is due to EEXIST in case of double connection
3024 * of USB and Bluetooth, but could have been due to ENOMEM
3025 * or other reasons as well.
3027 if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
3028 hid_err(hdev, "failed to claim input\n");
3033 if (sc->quirks & GHL_GUITAR_PS3WIIU) {
3034 sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
3037 ret = ghl_init_urb(sc, usbdev);
3039 hid_err(hdev, "error preparing URB\n");
3043 timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
3044 mod_timer(&sc->ghl_poke_timer,
3045 jiffies + GHL_GUITAR_POKE_INTERVAL*HZ);
3051 static void sony_remove(struct hid_device *hdev)
3053 struct sony_sc *sc = hid_get_drvdata(hdev);
3055 if (sc->quirks & GHL_GUITAR_PS3WIIU) {
3056 del_timer_sync(&sc->ghl_poke_timer);
3057 usb_free_urb(sc->ghl_urb);
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");