1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * HID driver for Sony DualSense(TM) controller.
5 * Copyright (c) 2020-2022 Sony Interactive Entertainment
8 #include <linux/bits.h>
9 #include <linux/crc32.h>
10 #include <linux/device.h>
11 #include <linux/hid.h>
12 #include <linux/idr.h>
13 #include <linux/input/mt.h>
14 #include <linux/leds.h>
15 #include <linux/led-class-multicolor.h>
16 #include <linux/module.h>
18 #include <asm/unaligned.h>
22 /* List of connected playstation devices. */
23 static DEFINE_MUTEX(ps_devices_lock
);
24 static LIST_HEAD(ps_devices_list
);
26 static DEFINE_IDA(ps_player_id_allocator
);
28 #define HID_PLAYSTATION_VERSION_PATCH 0x8000
30 /* Base class for playstation devices. */
32 struct list_head list
;
33 struct hid_device
*hdev
;
38 struct power_supply_desc battery_desc
;
39 struct power_supply
*battery
;
40 uint8_t battery_capacity
;
43 const char *input_dev_name
; /* Name of primary input device. */
44 uint8_t mac_address
[6]; /* Note: stored in little endian order. */
48 int (*parse_report
)(struct ps_device
*dev
, struct hid_report
*report
, u8
*data
, int size
);
49 void (*remove
)(struct ps_device
*dev
);
52 /* Calibration data for playstation motion sensors. */
53 struct ps_calibration_data
{
64 enum led_brightness (*brightness_get
)(struct led_classdev
*cdev
);
65 int (*brightness_set
)(struct led_classdev
*cdev
, enum led_brightness
);
66 int (*blink_set
)(struct led_classdev
*led
, unsigned long *on
, unsigned long *off
);
69 /* Seed values for DualShock4 / DualSense CRC32 for different report types. */
70 #define PS_INPUT_CRC32_SEED 0xA1
71 #define PS_OUTPUT_CRC32_SEED 0xA2
72 #define PS_FEATURE_CRC32_SEED 0xA3
74 #define DS_INPUT_REPORT_USB 0x01
75 #define DS_INPUT_REPORT_USB_SIZE 64
76 #define DS_INPUT_REPORT_BT 0x31
77 #define DS_INPUT_REPORT_BT_SIZE 78
78 #define DS_OUTPUT_REPORT_USB 0x02
79 #define DS_OUTPUT_REPORT_USB_SIZE 63
80 #define DS_OUTPUT_REPORT_BT 0x31
81 #define DS_OUTPUT_REPORT_BT_SIZE 78
83 #define DS_FEATURE_REPORT_CALIBRATION 0x05
84 #define DS_FEATURE_REPORT_CALIBRATION_SIZE 41
85 #define DS_FEATURE_REPORT_PAIRING_INFO 0x09
86 #define DS_FEATURE_REPORT_PAIRING_INFO_SIZE 20
87 #define DS_FEATURE_REPORT_FIRMWARE_INFO 0x20
88 #define DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE 64
90 /* Button masks for DualSense input report. */
91 #define DS_BUTTONS0_HAT_SWITCH GENMASK(3, 0)
92 #define DS_BUTTONS0_SQUARE BIT(4)
93 #define DS_BUTTONS0_CROSS BIT(5)
94 #define DS_BUTTONS0_CIRCLE BIT(6)
95 #define DS_BUTTONS0_TRIANGLE BIT(7)
96 #define DS_BUTTONS1_L1 BIT(0)
97 #define DS_BUTTONS1_R1 BIT(1)
98 #define DS_BUTTONS1_L2 BIT(2)
99 #define DS_BUTTONS1_R2 BIT(3)
100 #define DS_BUTTONS1_CREATE BIT(4)
101 #define DS_BUTTONS1_OPTIONS BIT(5)
102 #define DS_BUTTONS1_L3 BIT(6)
103 #define DS_BUTTONS1_R3 BIT(7)
104 #define DS_BUTTONS2_PS_HOME BIT(0)
105 #define DS_BUTTONS2_TOUCHPAD BIT(1)
106 #define DS_BUTTONS2_MIC_MUTE BIT(2)
108 /* Status field of DualSense input report. */
109 #define DS_STATUS_BATTERY_CAPACITY GENMASK(3, 0)
110 #define DS_STATUS_CHARGING GENMASK(7, 4)
111 #define DS_STATUS_CHARGING_SHIFT 4
113 /* Feature version from DualSense Firmware Info report. */
114 #define DS_FEATURE_VERSION(major, minor) ((major & 0xff) << 8 | (minor & 0xff))
117 * Status of a DualSense touch point contact.
118 * Contact IDs, with highest bit set are 'inactive'
119 * and any associated data is then invalid.
121 #define DS_TOUCH_POINT_INACTIVE BIT(7)
123 /* Magic value required in tag field of Bluetooth output report. */
124 #define DS_OUTPUT_TAG 0x10
125 /* Flags for DualSense output report. */
126 #define DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION BIT(0)
127 #define DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT BIT(1)
128 #define DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE BIT(0)
129 #define DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE BIT(1)
130 #define DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE BIT(2)
131 #define DS_OUTPUT_VALID_FLAG1_RELEASE_LEDS BIT(3)
132 #define DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE BIT(4)
133 #define DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE BIT(1)
134 #define DS_OUTPUT_VALID_FLAG2_COMPATIBLE_VIBRATION2 BIT(2)
135 #define DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE BIT(4)
136 #define DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT BIT(1)
138 /* DualSense hardware limits */
139 #define DS_ACC_RES_PER_G 8192
140 #define DS_ACC_RANGE (4*DS_ACC_RES_PER_G)
141 #define DS_GYRO_RES_PER_DEG_S 1024
142 #define DS_GYRO_RANGE (2048*DS_GYRO_RES_PER_DEG_S)
143 #define DS_TOUCHPAD_WIDTH 1920
144 #define DS_TOUCHPAD_HEIGHT 1080
147 struct ps_device base
;
148 struct input_dev
*gamepad
;
149 struct input_dev
*sensors
;
150 struct input_dev
*touchpad
;
152 /* Update version is used as a feature/capability version. */
153 uint16_t update_version
;
155 /* Calibration data for accelerometer and gyroscope. */
156 struct ps_calibration_data accel_calib_data
[3];
157 struct ps_calibration_data gyro_calib_data
[3];
159 /* Timestamp for sensor data */
160 bool sensor_timestamp_initialized
;
161 uint32_t prev_sensor_timestamp
;
162 uint32_t sensor_timestamp_us
;
164 /* Compatible rumble state */
165 bool use_vibration_v2
;
171 struct led_classdev_mc lightbar
;
172 bool update_lightbar
;
173 uint8_t lightbar_red
;
174 uint8_t lightbar_green
;
175 uint8_t lightbar_blue
;
178 bool update_mic_mute
;
180 bool last_btn_mic_state
;
183 bool update_player_leds
;
184 uint8_t player_leds_state
;
185 struct led_classdev player_leds
[5];
187 struct work_struct output_worker
;
188 bool output_worker_initialized
;
189 void *output_report_dmabuf
;
190 uint8_t output_seq
; /* Sequence number for output report. */
193 struct dualsense_touch_point
{
196 uint8_t x_hi
:4, y_lo
:4;
199 static_assert(sizeof(struct dualsense_touch_point
) == 4);
201 /* Main DualSense input report excluding any BT/USB specific headers. */
202 struct dualsense_input_report
{
211 __le16 gyro
[3]; /* x, y, z */
212 __le16 accel
[3]; /* x, y, z */
213 __le32 sensor_timestamp
;
217 struct dualsense_touch_point points
[2];
219 uint8_t reserved3
[12];
221 uint8_t reserved4
[10];
223 /* Common input report size shared equals the size of the USB report minus 1 byte for ReportID. */
224 static_assert(sizeof(struct dualsense_input_report
) == DS_INPUT_REPORT_USB_SIZE
- 1);
226 /* Common data between DualSense BT/USB main output report. */
227 struct dualsense_output_report_common
{
231 /* For DualShock 4 compatibility mode. */
237 uint8_t mute_button_led
;
239 uint8_t power_save_control
;
240 uint8_t reserved2
[28];
242 /* LEDs and lightbar */
244 uint8_t reserved3
[2];
245 uint8_t lightbar_setup
;
246 uint8_t led_brightness
;
248 uint8_t lightbar_red
;
249 uint8_t lightbar_green
;
250 uint8_t lightbar_blue
;
252 static_assert(sizeof(struct dualsense_output_report_common
) == 47);
254 struct dualsense_output_report_bt
{
255 uint8_t report_id
; /* 0x31 */
258 struct dualsense_output_report_common common
;
259 uint8_t reserved
[24];
262 static_assert(sizeof(struct dualsense_output_report_bt
) == DS_OUTPUT_REPORT_BT_SIZE
);
264 struct dualsense_output_report_usb
{
265 uint8_t report_id
; /* 0x02 */
266 struct dualsense_output_report_common common
;
267 uint8_t reserved
[15];
269 static_assert(sizeof(struct dualsense_output_report_usb
) == DS_OUTPUT_REPORT_USB_SIZE
);
272 * The DualSense has a main output report used to control most features. It is
273 * largely the same between Bluetooth and USB except for different headers and CRC.
274 * This structure hide the differences between the two to simplify sending output reports.
276 struct dualsense_output_report
{
277 uint8_t *data
; /* Start of data */
278 uint8_t len
; /* Size of output report */
280 /* Points to Bluetooth data payload in case for a Bluetooth report else NULL. */
281 struct dualsense_output_report_bt
*bt
;
282 /* Points to USB data payload in case for a USB report else NULL. */
283 struct dualsense_output_report_usb
*usb
;
284 /* Points to common section of report, so past any headers. */
285 struct dualsense_output_report_common
*common
;
288 #define DS4_INPUT_REPORT_USB 0x01
289 #define DS4_INPUT_REPORT_USB_SIZE 64
290 #define DS4_INPUT_REPORT_BT 0x11
291 #define DS4_INPUT_REPORT_BT_SIZE 78
292 #define DS4_OUTPUT_REPORT_USB 0x05
293 #define DS4_OUTPUT_REPORT_USB_SIZE 32
294 #define DS4_OUTPUT_REPORT_BT 0x11
295 #define DS4_OUTPUT_REPORT_BT_SIZE 78
297 #define DS4_FEATURE_REPORT_CALIBRATION 0x02
298 #define DS4_FEATURE_REPORT_CALIBRATION_SIZE 37
299 #define DS4_FEATURE_REPORT_CALIBRATION_BT 0x05
300 #define DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE 41
301 #define DS4_FEATURE_REPORT_FIRMWARE_INFO 0xa3
302 #define DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE 49
303 #define DS4_FEATURE_REPORT_PAIRING_INFO 0x12
304 #define DS4_FEATURE_REPORT_PAIRING_INFO_SIZE 16
307 * Status of a DualShock4 touch point contact.
308 * Contact IDs, with highest bit set are 'inactive'
309 * and any associated data is then invalid.
311 #define DS4_TOUCH_POINT_INACTIVE BIT(7)
313 /* Status field of DualShock4 input report. */
314 #define DS4_STATUS0_BATTERY_CAPACITY GENMASK(3, 0)
315 #define DS4_STATUS0_CABLE_STATE BIT(4)
316 /* Battery status within batery_status field. */
317 #define DS4_BATTERY_STATUS_FULL 11
318 /* Status1 bit2 contains dongle connection state:
322 #define DS4_STATUS1_DONGLE_STATE BIT(2)
324 /* The lower 6 bits of hw_control of the Bluetooth main output report
325 * control the interval at which Dualshock 4 reports data:
332 #define DS4_OUTPUT_HWCTL_BT_POLL_MASK 0x3F
333 /* Default to 4ms poll interval, which is same as USB (not adjustable). */
334 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS 4
335 #define DS4_OUTPUT_HWCTL_CRC32 0x40
336 #define DS4_OUTPUT_HWCTL_HID 0x80
338 /* Flags for DualShock4 output report. */
339 #define DS4_OUTPUT_VALID_FLAG0_MOTOR 0x01
340 #define DS4_OUTPUT_VALID_FLAG0_LED 0x02
341 #define DS4_OUTPUT_VALID_FLAG0_LED_BLINK 0x04
343 /* DualShock4 hardware limits */
344 #define DS4_ACC_RES_PER_G 8192
345 #define DS4_ACC_RANGE (4*DS_ACC_RES_PER_G)
346 #define DS4_GYRO_RES_PER_DEG_S 1024
347 #define DS4_GYRO_RANGE (2048*DS_GYRO_RES_PER_DEG_S)
348 #define DS4_LIGHTBAR_MAX_BLINK 255 /* 255 centiseconds */
349 #define DS4_TOUCHPAD_WIDTH 1920
350 #define DS4_TOUCHPAD_HEIGHT 942
352 enum dualshock4_dongle_state
{
360 struct ps_device base
;
361 struct input_dev
*gamepad
;
362 struct input_dev
*sensors
;
363 struct input_dev
*touchpad
;
365 /* Calibration data for accelerometer and gyroscope. */
366 struct ps_calibration_data accel_calib_data
[3];
367 struct ps_calibration_data gyro_calib_data
[3];
369 /* Only used on dongle to track state transitions. */
370 enum dualshock4_dongle_state dongle_state
;
371 /* Used during calibration. */
372 struct work_struct dongle_hotplug_worker
;
374 /* Timestamp for sensor data */
375 bool sensor_timestamp_initialized
;
376 uint32_t prev_sensor_timestamp
;
377 uint32_t sensor_timestamp_us
;
379 /* Bluetooth poll interval */
380 bool update_bt_poll_interval
;
381 uint8_t bt_poll_interval
;
388 bool update_lightbar
;
389 bool update_lightbar_blink
;
390 bool lightbar_enabled
; /* For use by global LED control. */
391 uint8_t lightbar_red
;
392 uint8_t lightbar_green
;
393 uint8_t lightbar_blue
;
394 uint8_t lightbar_blink_on
; /* In increments of 10ms. */
395 uint8_t lightbar_blink_off
; /* In increments of 10ms. */
396 struct led_classdev lightbar_leds
[4];
398 struct work_struct output_worker
;
399 bool output_worker_initialized
;
400 void *output_report_dmabuf
;
403 struct dualshock4_touch_point
{
406 uint8_t x_hi
:4, y_lo
:4;
409 static_assert(sizeof(struct dualshock4_touch_point
) == 4);
411 struct dualshock4_touch_report
{
413 struct dualshock4_touch_point points
[2];
415 static_assert(sizeof(struct dualshock4_touch_report
) == 9);
417 /* Main DualShock4 input report excluding any BT/USB specific headers. */
418 struct dualshock4_input_report_common
{
425 __le16 sensor_timestamp
;
426 uint8_t sensor_temperature
;
427 __le16 gyro
[3]; /* x, y, z */
428 __le16 accel
[3]; /* x, y, z */
429 uint8_t reserved2
[5];
434 static_assert(sizeof(struct dualshock4_input_report_common
) == 32);
436 struct dualshock4_input_report_usb
{
437 uint8_t report_id
; /* 0x01 */
438 struct dualshock4_input_report_common common
;
439 uint8_t num_touch_reports
;
440 struct dualshock4_touch_report touch_reports
[3];
443 static_assert(sizeof(struct dualshock4_input_report_usb
) == DS4_INPUT_REPORT_USB_SIZE
);
445 struct dualshock4_input_report_bt
{
446 uint8_t report_id
; /* 0x11 */
448 struct dualshock4_input_report_common common
;
449 uint8_t num_touch_reports
;
450 struct dualshock4_touch_report touch_reports
[4]; /* BT has 4 compared to 3 for USB */
451 uint8_t reserved2
[2];
454 static_assert(sizeof(struct dualshock4_input_report_bt
) == DS4_INPUT_REPORT_BT_SIZE
);
456 /* Common data between Bluetooth and USB DualShock4 output reports. */
457 struct dualshock4_output_report_common
{
466 uint8_t lightbar_red
;
467 uint8_t lightbar_green
;
468 uint8_t lightbar_blue
;
469 uint8_t lightbar_blink_on
;
470 uint8_t lightbar_blink_off
;
473 struct dualshock4_output_report_usb
{
474 uint8_t report_id
; /* 0x5 */
475 struct dualshock4_output_report_common common
;
476 uint8_t reserved
[21];
478 static_assert(sizeof(struct dualshock4_output_report_usb
) == DS4_OUTPUT_REPORT_USB_SIZE
);
480 struct dualshock4_output_report_bt
{
481 uint8_t report_id
; /* 0x11 */
483 uint8_t audio_control
;
484 struct dualshock4_output_report_common common
;
485 uint8_t reserved
[61];
488 static_assert(sizeof(struct dualshock4_output_report_bt
) == DS4_OUTPUT_REPORT_BT_SIZE
);
491 * The DualShock4 has a main output report used to control most features. It is
492 * largely the same between Bluetooth and USB except for different headers and CRC.
493 * This structure hide the differences between the two to simplify sending output reports.
495 struct dualshock4_output_report
{
496 uint8_t *data
; /* Start of data */
497 uint8_t len
; /* Size of output report */
499 /* Points to Bluetooth data payload in case for a Bluetooth report else NULL. */
500 struct dualshock4_output_report_bt
*bt
;
501 /* Points to USB data payload in case for a USB report else NULL. */
502 struct dualshock4_output_report_usb
*usb
;
503 /* Points to common section of report, so past any headers. */
504 struct dualshock4_output_report_common
*common
;
508 * Common gamepad buttons across DualShock 3 / 4 and DualSense.
509 * Note: for device with a touchpad, touchpad button is not included
510 * as it will be part of the touchpad device.
512 static const int ps_gamepad_buttons
[] = {
513 BTN_WEST
, /* Square */
514 BTN_NORTH
, /* Triangle */
515 BTN_EAST
, /* Circle */
516 BTN_SOUTH
, /* Cross */
521 BTN_SELECT
, /* Create (PS5) / Share (PS4) */
522 BTN_START
, /* Option */
525 BTN_MODE
, /* PS Home */
528 static const struct {int x
; int y
; } ps_gamepad_hat_mapping
[] = {
529 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
533 static int dualshock4_get_calibration_data(struct dualshock4
*ds4
);
534 static inline void dualsense_schedule_work(struct dualsense
*ds
);
535 static inline void dualshock4_schedule_work(struct dualshock4
*ds4
);
536 static void dualsense_set_lightbar(struct dualsense
*ds
, uint8_t red
, uint8_t green
, uint8_t blue
);
537 static void dualshock4_set_default_lightbar_colors(struct dualshock4
*ds4
);
540 * Add a new ps_device to ps_devices if it doesn't exist.
541 * Return error on duplicate device, which can happen if the same
542 * device is connected using both Bluetooth and USB.
544 static int ps_devices_list_add(struct ps_device
*dev
)
546 struct ps_device
*entry
;
548 mutex_lock(&ps_devices_lock
);
549 list_for_each_entry(entry
, &ps_devices_list
, list
) {
550 if (!memcmp(entry
->mac_address
, dev
->mac_address
, sizeof(dev
->mac_address
))) {
551 hid_err(dev
->hdev
, "Duplicate device found for MAC address %pMR.\n",
553 mutex_unlock(&ps_devices_lock
);
558 list_add_tail(&dev
->list
, &ps_devices_list
);
559 mutex_unlock(&ps_devices_lock
);
563 static int ps_devices_list_remove(struct ps_device
*dev
)
565 mutex_lock(&ps_devices_lock
);
566 list_del(&dev
->list
);
567 mutex_unlock(&ps_devices_lock
);
571 static int ps_device_set_player_id(struct ps_device
*dev
)
573 int ret
= ida_alloc(&ps_player_id_allocator
, GFP_KERNEL
);
578 dev
->player_id
= ret
;
582 static void ps_device_release_player_id(struct ps_device
*dev
)
584 ida_free(&ps_player_id_allocator
, dev
->player_id
);
586 dev
->player_id
= U32_MAX
;
589 static struct input_dev
*ps_allocate_input_dev(struct hid_device
*hdev
, const char *name_suffix
)
591 struct input_dev
*input_dev
;
593 input_dev
= devm_input_allocate_device(&hdev
->dev
);
595 return ERR_PTR(-ENOMEM
);
597 input_dev
->id
.bustype
= hdev
->bus
;
598 input_dev
->id
.vendor
= hdev
->vendor
;
599 input_dev
->id
.product
= hdev
->product
;
600 input_dev
->id
.version
= hdev
->version
;
601 input_dev
->uniq
= hdev
->uniq
;
604 input_dev
->name
= devm_kasprintf(&hdev
->dev
, GFP_KERNEL
, "%s %s", hdev
->name
,
606 if (!input_dev
->name
)
607 return ERR_PTR(-ENOMEM
);
609 input_dev
->name
= hdev
->name
;
612 input_set_drvdata(input_dev
, hdev
);
617 static enum power_supply_property ps_power_supply_props
[] = {
618 POWER_SUPPLY_PROP_STATUS
,
619 POWER_SUPPLY_PROP_PRESENT
,
620 POWER_SUPPLY_PROP_CAPACITY
,
621 POWER_SUPPLY_PROP_SCOPE
,
624 static int ps_battery_get_property(struct power_supply
*psy
,
625 enum power_supply_property psp
,
626 union power_supply_propval
*val
)
628 struct ps_device
*dev
= power_supply_get_drvdata(psy
);
629 uint8_t battery_capacity
;
634 spin_lock_irqsave(&dev
->lock
, flags
);
635 battery_capacity
= dev
->battery_capacity
;
636 battery_status
= dev
->battery_status
;
637 spin_unlock_irqrestore(&dev
->lock
, flags
);
640 case POWER_SUPPLY_PROP_STATUS
:
641 val
->intval
= battery_status
;
643 case POWER_SUPPLY_PROP_PRESENT
:
646 case POWER_SUPPLY_PROP_CAPACITY
:
647 val
->intval
= battery_capacity
;
649 case POWER_SUPPLY_PROP_SCOPE
:
650 val
->intval
= POWER_SUPPLY_SCOPE_DEVICE
;
660 static int ps_device_register_battery(struct ps_device
*dev
)
662 struct power_supply
*battery
;
663 struct power_supply_config battery_cfg
= { .drv_data
= dev
};
666 dev
->battery_desc
.type
= POWER_SUPPLY_TYPE_BATTERY
;
667 dev
->battery_desc
.properties
= ps_power_supply_props
;
668 dev
->battery_desc
.num_properties
= ARRAY_SIZE(ps_power_supply_props
);
669 dev
->battery_desc
.get_property
= ps_battery_get_property
;
670 dev
->battery_desc
.name
= devm_kasprintf(&dev
->hdev
->dev
, GFP_KERNEL
,
671 "ps-controller-battery-%pMR", dev
->mac_address
);
672 if (!dev
->battery_desc
.name
)
675 battery
= devm_power_supply_register(&dev
->hdev
->dev
, &dev
->battery_desc
, &battery_cfg
);
676 if (IS_ERR(battery
)) {
677 ret
= PTR_ERR(battery
);
678 hid_err(dev
->hdev
, "Unable to register battery device: %d\n", ret
);
681 dev
->battery
= battery
;
683 ret
= power_supply_powers(dev
->battery
, &dev
->hdev
->dev
);
685 hid_err(dev
->hdev
, "Unable to activate battery device: %d\n", ret
);
692 /* Compute crc32 of HID data and compare against expected CRC. */
693 static bool ps_check_crc32(uint8_t seed
, uint8_t *data
, size_t len
, uint32_t report_crc
)
697 crc
= crc32_le(0xFFFFFFFF, &seed
, 1);
698 crc
= ~crc32_le(crc
, data
, len
);
700 return crc
== report_crc
;
703 static struct input_dev
*ps_gamepad_create(struct hid_device
*hdev
,
704 int (*play_effect
)(struct input_dev
*, void *, struct ff_effect
*))
706 struct input_dev
*gamepad
;
710 gamepad
= ps_allocate_input_dev(hdev
, NULL
);
712 return ERR_CAST(gamepad
);
714 input_set_abs_params(gamepad
, ABS_X
, 0, 255, 0, 0);
715 input_set_abs_params(gamepad
, ABS_Y
, 0, 255, 0, 0);
716 input_set_abs_params(gamepad
, ABS_Z
, 0, 255, 0, 0);
717 input_set_abs_params(gamepad
, ABS_RX
, 0, 255, 0, 0);
718 input_set_abs_params(gamepad
, ABS_RY
, 0, 255, 0, 0);
719 input_set_abs_params(gamepad
, ABS_RZ
, 0, 255, 0, 0);
721 input_set_abs_params(gamepad
, ABS_HAT0X
, -1, 1, 0, 0);
722 input_set_abs_params(gamepad
, ABS_HAT0Y
, -1, 1, 0, 0);
724 for (i
= 0; i
< ARRAY_SIZE(ps_gamepad_buttons
); i
++)
725 input_set_capability(gamepad
, EV_KEY
, ps_gamepad_buttons
[i
]);
727 #if IS_ENABLED(CONFIG_PLAYSTATION_FF)
729 input_set_capability(gamepad
, EV_FF
, FF_RUMBLE
);
730 input_ff_create_memless(gamepad
, NULL
, play_effect
);
734 ret
= input_register_device(gamepad
);
741 static int ps_get_report(struct hid_device
*hdev
, uint8_t report_id
, uint8_t *buf
, size_t size
,
746 ret
= hid_hw_raw_request(hdev
, report_id
, buf
, size
, HID_FEATURE_REPORT
,
749 hid_err(hdev
, "Failed to retrieve feature with reportID %d: %d\n", report_id
, ret
);
754 hid_err(hdev
, "Invalid byte count transferred, expected %zu got %d\n", size
, ret
);
758 if (buf
[0] != report_id
) {
759 hid_err(hdev
, "Invalid reportID received, expected %d got %d\n", report_id
, buf
[0]);
763 if (hdev
->bus
== BUS_BLUETOOTH
&& check_crc
) {
764 /* Last 4 bytes contains crc32. */
765 uint8_t crc_offset
= size
- 4;
766 uint32_t report_crc
= get_unaligned_le32(&buf
[crc_offset
]);
768 if (!ps_check_crc32(PS_FEATURE_CRC32_SEED
, buf
, crc_offset
, report_crc
)) {
769 hid_err(hdev
, "CRC check failed for reportID=%d\n", report_id
);
777 static int ps_led_register(struct ps_device
*ps_dev
, struct led_classdev
*led
,
778 const struct ps_led_info
*led_info
)
782 if (led_info
->name
) {
783 led
->name
= devm_kasprintf(&ps_dev
->hdev
->dev
, GFP_KERNEL
,
784 "%s:%s:%s", ps_dev
->input_dev_name
, led_info
->color
, led_info
->name
);
786 /* Backwards compatible mode for hid-sony, but not compliant with LED class spec. */
787 led
->name
= devm_kasprintf(&ps_dev
->hdev
->dev
, GFP_KERNEL
,
788 "%s:%s", ps_dev
->input_dev_name
, led_info
->color
);
795 led
->max_brightness
= led_info
->max_brightness
;
796 led
->flags
= LED_CORE_SUSPENDRESUME
;
797 led
->brightness_get
= led_info
->brightness_get
;
798 led
->brightness_set_blocking
= led_info
->brightness_set
;
799 led
->blink_set
= led_info
->blink_set
;
801 ret
= devm_led_classdev_register(&ps_dev
->hdev
->dev
, led
);
803 hid_err(ps_dev
->hdev
, "Failed to register LED %s: %d\n", led_info
->name
, ret
);
810 /* Register a DualSense/DualShock4 RGB lightbar represented by a multicolor LED. */
811 static int ps_lightbar_register(struct ps_device
*ps_dev
, struct led_classdev_mc
*lightbar_mc_dev
,
812 int (*brightness_set
)(struct led_classdev
*, enum led_brightness
))
814 struct hid_device
*hdev
= ps_dev
->hdev
;
815 struct mc_subled
*mc_led_info
;
816 struct led_classdev
*led_cdev
;
819 mc_led_info
= devm_kmalloc_array(&hdev
->dev
, 3, sizeof(*mc_led_info
),
820 GFP_KERNEL
| __GFP_ZERO
);
824 mc_led_info
[0].color_index
= LED_COLOR_ID_RED
;
825 mc_led_info
[1].color_index
= LED_COLOR_ID_GREEN
;
826 mc_led_info
[2].color_index
= LED_COLOR_ID_BLUE
;
828 lightbar_mc_dev
->subled_info
= mc_led_info
;
829 lightbar_mc_dev
->num_colors
= 3;
831 led_cdev
= &lightbar_mc_dev
->led_cdev
;
832 led_cdev
->name
= devm_kasprintf(&hdev
->dev
, GFP_KERNEL
, "%s:rgb:indicator",
833 ps_dev
->input_dev_name
);
836 led_cdev
->brightness
= 255;
837 led_cdev
->max_brightness
= 255;
838 led_cdev
->brightness_set_blocking
= brightness_set
;
840 ret
= devm_led_classdev_multicolor_register(&hdev
->dev
, lightbar_mc_dev
);
842 hid_err(hdev
, "Cannot register multicolor LED device\n");
849 static struct input_dev
*ps_sensors_create(struct hid_device
*hdev
, int accel_range
, int accel_res
,
850 int gyro_range
, int gyro_res
)
852 struct input_dev
*sensors
;
855 sensors
= ps_allocate_input_dev(hdev
, "Motion Sensors");
857 return ERR_CAST(sensors
);
859 __set_bit(INPUT_PROP_ACCELEROMETER
, sensors
->propbit
);
860 __set_bit(EV_MSC
, sensors
->evbit
);
861 __set_bit(MSC_TIMESTAMP
, sensors
->mscbit
);
864 input_set_abs_params(sensors
, ABS_X
, -accel_range
, accel_range
, 16, 0);
865 input_set_abs_params(sensors
, ABS_Y
, -accel_range
, accel_range
, 16, 0);
866 input_set_abs_params(sensors
, ABS_Z
, -accel_range
, accel_range
, 16, 0);
867 input_abs_set_res(sensors
, ABS_X
, accel_res
);
868 input_abs_set_res(sensors
, ABS_Y
, accel_res
);
869 input_abs_set_res(sensors
, ABS_Z
, accel_res
);
872 input_set_abs_params(sensors
, ABS_RX
, -gyro_range
, gyro_range
, 16, 0);
873 input_set_abs_params(sensors
, ABS_RY
, -gyro_range
, gyro_range
, 16, 0);
874 input_set_abs_params(sensors
, ABS_RZ
, -gyro_range
, gyro_range
, 16, 0);
875 input_abs_set_res(sensors
, ABS_RX
, gyro_res
);
876 input_abs_set_res(sensors
, ABS_RY
, gyro_res
);
877 input_abs_set_res(sensors
, ABS_RZ
, gyro_res
);
879 ret
= input_register_device(sensors
);
886 static struct input_dev
*ps_touchpad_create(struct hid_device
*hdev
, int width
, int height
,
887 unsigned int num_contacts
)
889 struct input_dev
*touchpad
;
892 touchpad
= ps_allocate_input_dev(hdev
, "Touchpad");
893 if (IS_ERR(touchpad
))
894 return ERR_CAST(touchpad
);
896 /* Map button underneath touchpad to BTN_LEFT. */
897 input_set_capability(touchpad
, EV_KEY
, BTN_LEFT
);
898 __set_bit(INPUT_PROP_BUTTONPAD
, touchpad
->propbit
);
900 input_set_abs_params(touchpad
, ABS_MT_POSITION_X
, 0, width
- 1, 0, 0);
901 input_set_abs_params(touchpad
, ABS_MT_POSITION_Y
, 0, height
- 1, 0, 0);
903 ret
= input_mt_init_slots(touchpad
, num_contacts
, INPUT_MT_POINTER
);
907 ret
= input_register_device(touchpad
);
914 static ssize_t
firmware_version_show(struct device
*dev
,
915 struct device_attribute
918 struct hid_device
*hdev
= to_hid_device(dev
);
919 struct ps_device
*ps_dev
= hid_get_drvdata(hdev
);
921 return sysfs_emit(buf
, "0x%08x\n", ps_dev
->fw_version
);
924 static DEVICE_ATTR_RO(firmware_version
);
926 static ssize_t
hardware_version_show(struct device
*dev
,
927 struct device_attribute
930 struct hid_device
*hdev
= to_hid_device(dev
);
931 struct ps_device
*ps_dev
= hid_get_drvdata(hdev
);
933 return sysfs_emit(buf
, "0x%08x\n", ps_dev
->hw_version
);
936 static DEVICE_ATTR_RO(hardware_version
);
938 static struct attribute
*ps_device_attrs
[] = {
939 &dev_attr_firmware_version
.attr
,
940 &dev_attr_hardware_version
.attr
,
943 ATTRIBUTE_GROUPS(ps_device
);
945 static int dualsense_get_calibration_data(struct dualsense
*ds
)
947 struct hid_device
*hdev
= ds
->base
.hdev
;
948 short gyro_pitch_bias
, gyro_pitch_plus
, gyro_pitch_minus
;
949 short gyro_yaw_bias
, gyro_yaw_plus
, gyro_yaw_minus
;
950 short gyro_roll_bias
, gyro_roll_plus
, gyro_roll_minus
;
951 short gyro_speed_plus
, gyro_speed_minus
;
952 short acc_x_plus
, acc_x_minus
;
953 short acc_y_plus
, acc_y_minus
;
954 short acc_z_plus
, acc_z_minus
;
961 buf
= kzalloc(DS_FEATURE_REPORT_CALIBRATION_SIZE
, GFP_KERNEL
);
965 ret
= ps_get_report(ds
->base
.hdev
, DS_FEATURE_REPORT_CALIBRATION
, buf
,
966 DS_FEATURE_REPORT_CALIBRATION_SIZE
, true);
968 hid_err(ds
->base
.hdev
, "Failed to retrieve DualSense calibration info: %d\n", ret
);
972 gyro_pitch_bias
= get_unaligned_le16(&buf
[1]);
973 gyro_yaw_bias
= get_unaligned_le16(&buf
[3]);
974 gyro_roll_bias
= get_unaligned_le16(&buf
[5]);
975 gyro_pitch_plus
= get_unaligned_le16(&buf
[7]);
976 gyro_pitch_minus
= get_unaligned_le16(&buf
[9]);
977 gyro_yaw_plus
= get_unaligned_le16(&buf
[11]);
978 gyro_yaw_minus
= get_unaligned_le16(&buf
[13]);
979 gyro_roll_plus
= get_unaligned_le16(&buf
[15]);
980 gyro_roll_minus
= get_unaligned_le16(&buf
[17]);
981 gyro_speed_plus
= get_unaligned_le16(&buf
[19]);
982 gyro_speed_minus
= get_unaligned_le16(&buf
[21]);
983 acc_x_plus
= get_unaligned_le16(&buf
[23]);
984 acc_x_minus
= get_unaligned_le16(&buf
[25]);
985 acc_y_plus
= get_unaligned_le16(&buf
[27]);
986 acc_y_minus
= get_unaligned_le16(&buf
[29]);
987 acc_z_plus
= get_unaligned_le16(&buf
[31]);
988 acc_z_minus
= get_unaligned_le16(&buf
[33]);
991 * Set gyroscope calibration and normalization parameters.
992 * Data values will be normalized to 1/DS_GYRO_RES_PER_DEG_S degree/s.
994 speed_2x
= (gyro_speed_plus
+ gyro_speed_minus
);
995 ds
->gyro_calib_data
[0].abs_code
= ABS_RX
;
996 ds
->gyro_calib_data
[0].bias
= 0;
997 ds
->gyro_calib_data
[0].sens_numer
= speed_2x
*DS_GYRO_RES_PER_DEG_S
;
998 ds
->gyro_calib_data
[0].sens_denom
= abs(gyro_pitch_plus
- gyro_pitch_bias
) +
999 abs(gyro_pitch_minus
- gyro_pitch_bias
);
1001 ds
->gyro_calib_data
[1].abs_code
= ABS_RY
;
1002 ds
->gyro_calib_data
[1].bias
= 0;
1003 ds
->gyro_calib_data
[1].sens_numer
= speed_2x
*DS_GYRO_RES_PER_DEG_S
;
1004 ds
->gyro_calib_data
[1].sens_denom
= abs(gyro_yaw_plus
- gyro_yaw_bias
) +
1005 abs(gyro_yaw_minus
- gyro_yaw_bias
);
1007 ds
->gyro_calib_data
[2].abs_code
= ABS_RZ
;
1008 ds
->gyro_calib_data
[2].bias
= 0;
1009 ds
->gyro_calib_data
[2].sens_numer
= speed_2x
*DS_GYRO_RES_PER_DEG_S
;
1010 ds
->gyro_calib_data
[2].sens_denom
= abs(gyro_roll_plus
- gyro_roll_bias
) +
1011 abs(gyro_roll_minus
- gyro_roll_bias
);
1014 * Sanity check gyro calibration data. This is needed to prevent crashes
1015 * during report handling of virtual, clone or broken devices not implementing
1016 * calibration data properly.
1018 for (i
= 0; i
< ARRAY_SIZE(ds
->gyro_calib_data
); i
++) {
1019 if (ds
->gyro_calib_data
[i
].sens_denom
== 0) {
1020 hid_warn(hdev
, "Invalid gyro calibration data for axis (%d), disabling calibration.",
1021 ds
->gyro_calib_data
[i
].abs_code
);
1022 ds
->gyro_calib_data
[i
].bias
= 0;
1023 ds
->gyro_calib_data
[i
].sens_numer
= DS_GYRO_RANGE
;
1024 ds
->gyro_calib_data
[i
].sens_denom
= S16_MAX
;
1029 * Set accelerometer calibration and normalization parameters.
1030 * Data values will be normalized to 1/DS_ACC_RES_PER_G g.
1032 range_2g
= acc_x_plus
- acc_x_minus
;
1033 ds
->accel_calib_data
[0].abs_code
= ABS_X
;
1034 ds
->accel_calib_data
[0].bias
= acc_x_plus
- range_2g
/ 2;
1035 ds
->accel_calib_data
[0].sens_numer
= 2*DS_ACC_RES_PER_G
;
1036 ds
->accel_calib_data
[0].sens_denom
= range_2g
;
1038 range_2g
= acc_y_plus
- acc_y_minus
;
1039 ds
->accel_calib_data
[1].abs_code
= ABS_Y
;
1040 ds
->accel_calib_data
[1].bias
= acc_y_plus
- range_2g
/ 2;
1041 ds
->accel_calib_data
[1].sens_numer
= 2*DS_ACC_RES_PER_G
;
1042 ds
->accel_calib_data
[1].sens_denom
= range_2g
;
1044 range_2g
= acc_z_plus
- acc_z_minus
;
1045 ds
->accel_calib_data
[2].abs_code
= ABS_Z
;
1046 ds
->accel_calib_data
[2].bias
= acc_z_plus
- range_2g
/ 2;
1047 ds
->accel_calib_data
[2].sens_numer
= 2*DS_ACC_RES_PER_G
;
1048 ds
->accel_calib_data
[2].sens_denom
= range_2g
;
1051 * Sanity check accelerometer calibration data. This is needed to prevent crashes
1052 * during report handling of virtual, clone or broken devices not implementing calibration
1055 for (i
= 0; i
< ARRAY_SIZE(ds
->accel_calib_data
); i
++) {
1056 if (ds
->accel_calib_data
[i
].sens_denom
== 0) {
1057 hid_warn(hdev
, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",
1058 ds
->accel_calib_data
[i
].abs_code
);
1059 ds
->accel_calib_data
[i
].bias
= 0;
1060 ds
->accel_calib_data
[i
].sens_numer
= DS_ACC_RANGE
;
1061 ds
->accel_calib_data
[i
].sens_denom
= S16_MAX
;
1071 static int dualsense_get_firmware_info(struct dualsense
*ds
)
1076 buf
= kzalloc(DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE
, GFP_KERNEL
);
1080 ret
= ps_get_report(ds
->base
.hdev
, DS_FEATURE_REPORT_FIRMWARE_INFO
, buf
,
1081 DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE
, true);
1083 hid_err(ds
->base
.hdev
, "Failed to retrieve DualSense firmware info: %d\n", ret
);
1087 ds
->base
.hw_version
= get_unaligned_le32(&buf
[24]);
1088 ds
->base
.fw_version
= get_unaligned_le32(&buf
[28]);
1090 /* Update version is some kind of feature version. It is distinct from
1091 * the firmware version as there can be many different variations of a
1092 * controller over time with the same physical shell, but with different
1093 * PCBs and other internal changes. The update version (internal name) is
1094 * used as a means to detect what features are available and change behavior.
1095 * Note: the version is different between DualSense and DualSense Edge.
1097 ds
->update_version
= get_unaligned_le16(&buf
[44]);
1104 static int dualsense_get_mac_address(struct dualsense
*ds
)
1109 buf
= kzalloc(DS_FEATURE_REPORT_PAIRING_INFO_SIZE
, GFP_KERNEL
);
1113 ret
= ps_get_report(ds
->base
.hdev
, DS_FEATURE_REPORT_PAIRING_INFO
, buf
,
1114 DS_FEATURE_REPORT_PAIRING_INFO_SIZE
, true);
1116 hid_err(ds
->base
.hdev
, "Failed to retrieve DualSense pairing info: %d\n", ret
);
1120 memcpy(ds
->base
.mac_address
, &buf
[1], sizeof(ds
->base
.mac_address
));
1127 static int dualsense_lightbar_set_brightness(struct led_classdev
*cdev
,
1128 enum led_brightness brightness
)
1130 struct led_classdev_mc
*mc_cdev
= lcdev_to_mccdev(cdev
);
1131 struct dualsense
*ds
= container_of(mc_cdev
, struct dualsense
, lightbar
);
1132 uint8_t red
, green
, blue
;
1134 led_mc_calc_color_components(mc_cdev
, brightness
);
1135 red
= mc_cdev
->subled_info
[0].brightness
;
1136 green
= mc_cdev
->subled_info
[1].brightness
;
1137 blue
= mc_cdev
->subled_info
[2].brightness
;
1139 dualsense_set_lightbar(ds
, red
, green
, blue
);
1143 static enum led_brightness
dualsense_player_led_get_brightness(struct led_classdev
*led
)
1145 struct hid_device
*hdev
= to_hid_device(led
->dev
->parent
);
1146 struct dualsense
*ds
= hid_get_drvdata(hdev
);
1148 return !!(ds
->player_leds_state
& BIT(led
- ds
->player_leds
));
1151 static int dualsense_player_led_set_brightness(struct led_classdev
*led
, enum led_brightness value
)
1153 struct hid_device
*hdev
= to_hid_device(led
->dev
->parent
);
1154 struct dualsense
*ds
= hid_get_drvdata(hdev
);
1155 unsigned long flags
;
1156 unsigned int led_index
;
1158 spin_lock_irqsave(&ds
->base
.lock
, flags
);
1160 led_index
= led
- ds
->player_leds
;
1161 if (value
== LED_OFF
)
1162 ds
->player_leds_state
&= ~BIT(led_index
);
1164 ds
->player_leds_state
|= BIT(led_index
);
1166 ds
->update_player_leds
= true;
1167 spin_unlock_irqrestore(&ds
->base
.lock
, flags
);
1169 dualsense_schedule_work(ds
);
1174 static void dualsense_init_output_report(struct dualsense
*ds
, struct dualsense_output_report
*rp
,
1177 struct hid_device
*hdev
= ds
->base
.hdev
;
1179 if (hdev
->bus
== BUS_BLUETOOTH
) {
1180 struct dualsense_output_report_bt
*bt
= buf
;
1182 memset(bt
, 0, sizeof(*bt
));
1183 bt
->report_id
= DS_OUTPUT_REPORT_BT
;
1184 bt
->tag
= DS_OUTPUT_TAG
; /* Tag must be set. Exact meaning is unclear. */
1187 * Highest 4-bit is a sequence number, which needs to be increased
1188 * every report. Lowest 4-bit is tag and can be zero for now.
1190 bt
->seq_tag
= (ds
->output_seq
<< 4) | 0x0;
1191 if (++ds
->output_seq
== 16)
1195 rp
->len
= sizeof(*bt
);
1198 rp
->common
= &bt
->common
;
1200 struct dualsense_output_report_usb
*usb
= buf
;
1202 memset(usb
, 0, sizeof(*usb
));
1203 usb
->report_id
= DS_OUTPUT_REPORT_USB
;
1206 rp
->len
= sizeof(*usb
);
1209 rp
->common
= &usb
->common
;
1213 static inline void dualsense_schedule_work(struct dualsense
*ds
)
1215 unsigned long flags
;
1217 spin_lock_irqsave(&ds
->base
.lock
, flags
);
1218 if (ds
->output_worker_initialized
)
1219 schedule_work(&ds
->output_worker
);
1220 spin_unlock_irqrestore(&ds
->base
.lock
, flags
);
1224 * Helper function to send DualSense output reports. Applies a CRC at the end of a report
1225 * for Bluetooth reports.
1227 static void dualsense_send_output_report(struct dualsense
*ds
,
1228 struct dualsense_output_report
*report
)
1230 struct hid_device
*hdev
= ds
->base
.hdev
;
1232 /* Bluetooth packets need to be signed with a CRC in the last 4 bytes. */
1235 uint8_t seed
= PS_OUTPUT_CRC32_SEED
;
1237 crc
= crc32_le(0xFFFFFFFF, &seed
, 1);
1238 crc
= ~crc32_le(crc
, report
->data
, report
->len
- 4);
1240 report
->bt
->crc32
= cpu_to_le32(crc
);
1243 hid_hw_output_report(hdev
, report
->data
, report
->len
);
1246 static void dualsense_output_worker(struct work_struct
*work
)
1248 struct dualsense
*ds
= container_of(work
, struct dualsense
, output_worker
);
1249 struct dualsense_output_report report
;
1250 struct dualsense_output_report_common
*common
;
1251 unsigned long flags
;
1253 dualsense_init_output_report(ds
, &report
, ds
->output_report_dmabuf
);
1254 common
= report
.common
;
1256 spin_lock_irqsave(&ds
->base
.lock
, flags
);
1258 if (ds
->update_rumble
) {
1259 /* Select classic rumble style haptics and enable it. */
1260 common
->valid_flag0
|= DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT
;
1261 if (ds
->use_vibration_v2
)
1262 common
->valid_flag2
|= DS_OUTPUT_VALID_FLAG2_COMPATIBLE_VIBRATION2
;
1264 common
->valid_flag0
|= DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION
;
1265 common
->motor_left
= ds
->motor_left
;
1266 common
->motor_right
= ds
->motor_right
;
1267 ds
->update_rumble
= false;
1270 if (ds
->update_lightbar
) {
1271 common
->valid_flag1
|= DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE
;
1272 common
->lightbar_red
= ds
->lightbar_red
;
1273 common
->lightbar_green
= ds
->lightbar_green
;
1274 common
->lightbar_blue
= ds
->lightbar_blue
;
1276 ds
->update_lightbar
= false;
1279 if (ds
->update_player_leds
) {
1280 common
->valid_flag1
|= DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE
;
1281 common
->player_leds
= ds
->player_leds_state
;
1283 ds
->update_player_leds
= false;
1286 if (ds
->update_mic_mute
) {
1287 common
->valid_flag1
|= DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE
;
1288 common
->mute_button_led
= ds
->mic_muted
;
1290 if (ds
->mic_muted
) {
1291 /* Disable microphone */
1292 common
->valid_flag1
|= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE
;
1293 common
->power_save_control
|= DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE
;
1295 /* Enable microphone */
1296 common
->valid_flag1
|= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE
;
1297 common
->power_save_control
&= ~DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE
;
1300 ds
->update_mic_mute
= false;
1303 spin_unlock_irqrestore(&ds
->base
.lock
, flags
);
1305 dualsense_send_output_report(ds
, &report
);
1308 static int dualsense_parse_report(struct ps_device
*ps_dev
, struct hid_report
*report
,
1311 struct hid_device
*hdev
= ps_dev
->hdev
;
1312 struct dualsense
*ds
= container_of(ps_dev
, struct dualsense
, base
);
1313 struct dualsense_input_report
*ds_report
;
1314 uint8_t battery_data
, battery_capacity
, charging_status
, value
;
1316 uint32_t sensor_timestamp
;
1318 unsigned long flags
;
1322 * DualSense in USB uses the full HID report for reportID 1, but
1323 * Bluetooth uses a minimal HID report for reportID 1 and reports
1324 * the full report using reportID 49.
1326 if (hdev
->bus
== BUS_USB
&& report
->id
== DS_INPUT_REPORT_USB
&&
1327 size
== DS_INPUT_REPORT_USB_SIZE
) {
1328 ds_report
= (struct dualsense_input_report
*)&data
[1];
1329 } else if (hdev
->bus
== BUS_BLUETOOTH
&& report
->id
== DS_INPUT_REPORT_BT
&&
1330 size
== DS_INPUT_REPORT_BT_SIZE
) {
1331 /* Last 4 bytes of input report contain crc32 */
1332 uint32_t report_crc
= get_unaligned_le32(&data
[size
- 4]);
1334 if (!ps_check_crc32(PS_INPUT_CRC32_SEED
, data
, size
- 4, report_crc
)) {
1335 hid_err(hdev
, "DualSense input CRC's check failed\n");
1339 ds_report
= (struct dualsense_input_report
*)&data
[2];
1341 hid_err(hdev
, "Unhandled reportID=%d\n", report
->id
);
1345 input_report_abs(ds
->gamepad
, ABS_X
, ds_report
->x
);
1346 input_report_abs(ds
->gamepad
, ABS_Y
, ds_report
->y
);
1347 input_report_abs(ds
->gamepad
, ABS_RX
, ds_report
->rx
);
1348 input_report_abs(ds
->gamepad
, ABS_RY
, ds_report
->ry
);
1349 input_report_abs(ds
->gamepad
, ABS_Z
, ds_report
->z
);
1350 input_report_abs(ds
->gamepad
, ABS_RZ
, ds_report
->rz
);
1352 value
= ds_report
->buttons
[0] & DS_BUTTONS0_HAT_SWITCH
;
1353 if (value
>= ARRAY_SIZE(ps_gamepad_hat_mapping
))
1354 value
= 8; /* center */
1355 input_report_abs(ds
->gamepad
, ABS_HAT0X
, ps_gamepad_hat_mapping
[value
].x
);
1356 input_report_abs(ds
->gamepad
, ABS_HAT0Y
, ps_gamepad_hat_mapping
[value
].y
);
1358 input_report_key(ds
->gamepad
, BTN_WEST
, ds_report
->buttons
[0] & DS_BUTTONS0_SQUARE
);
1359 input_report_key(ds
->gamepad
, BTN_SOUTH
, ds_report
->buttons
[0] & DS_BUTTONS0_CROSS
);
1360 input_report_key(ds
->gamepad
, BTN_EAST
, ds_report
->buttons
[0] & DS_BUTTONS0_CIRCLE
);
1361 input_report_key(ds
->gamepad
, BTN_NORTH
, ds_report
->buttons
[0] & DS_BUTTONS0_TRIANGLE
);
1362 input_report_key(ds
->gamepad
, BTN_TL
, ds_report
->buttons
[1] & DS_BUTTONS1_L1
);
1363 input_report_key(ds
->gamepad
, BTN_TR
, ds_report
->buttons
[1] & DS_BUTTONS1_R1
);
1364 input_report_key(ds
->gamepad
, BTN_TL2
, ds_report
->buttons
[1] & DS_BUTTONS1_L2
);
1365 input_report_key(ds
->gamepad
, BTN_TR2
, ds_report
->buttons
[1] & DS_BUTTONS1_R2
);
1366 input_report_key(ds
->gamepad
, BTN_SELECT
, ds_report
->buttons
[1] & DS_BUTTONS1_CREATE
);
1367 input_report_key(ds
->gamepad
, BTN_START
, ds_report
->buttons
[1] & DS_BUTTONS1_OPTIONS
);
1368 input_report_key(ds
->gamepad
, BTN_THUMBL
, ds_report
->buttons
[1] & DS_BUTTONS1_L3
);
1369 input_report_key(ds
->gamepad
, BTN_THUMBR
, ds_report
->buttons
[1] & DS_BUTTONS1_R3
);
1370 input_report_key(ds
->gamepad
, BTN_MODE
, ds_report
->buttons
[2] & DS_BUTTONS2_PS_HOME
);
1371 input_sync(ds
->gamepad
);
1374 * The DualSense has an internal microphone, which can be muted through a mute button
1375 * on the device. The driver is expected to read the button state and program the device
1376 * to mute/unmute audio at the hardware level.
1378 btn_mic_state
= !!(ds_report
->buttons
[2] & DS_BUTTONS2_MIC_MUTE
);
1379 if (btn_mic_state
&& !ds
->last_btn_mic_state
) {
1380 spin_lock_irqsave(&ps_dev
->lock
, flags
);
1381 ds
->update_mic_mute
= true;
1382 ds
->mic_muted
= !ds
->mic_muted
; /* toggle */
1383 spin_unlock_irqrestore(&ps_dev
->lock
, flags
);
1385 /* Schedule updating of microphone state at hardware level. */
1386 dualsense_schedule_work(ds
);
1388 ds
->last_btn_mic_state
= btn_mic_state
;
1390 /* Parse and calibrate gyroscope data. */
1391 for (i
= 0; i
< ARRAY_SIZE(ds_report
->gyro
); i
++) {
1392 int raw_data
= (short)le16_to_cpu(ds_report
->gyro
[i
]);
1393 int calib_data
= mult_frac(ds
->gyro_calib_data
[i
].sens_numer
,
1394 raw_data
, ds
->gyro_calib_data
[i
].sens_denom
);
1396 input_report_abs(ds
->sensors
, ds
->gyro_calib_data
[i
].abs_code
, calib_data
);
1399 /* Parse and calibrate accelerometer data. */
1400 for (i
= 0; i
< ARRAY_SIZE(ds_report
->accel
); i
++) {
1401 int raw_data
= (short)le16_to_cpu(ds_report
->accel
[i
]);
1402 int calib_data
= mult_frac(ds
->accel_calib_data
[i
].sens_numer
,
1403 raw_data
- ds
->accel_calib_data
[i
].bias
,
1404 ds
->accel_calib_data
[i
].sens_denom
);
1406 input_report_abs(ds
->sensors
, ds
->accel_calib_data
[i
].abs_code
, calib_data
);
1409 /* Convert timestamp (in 0.33us unit) to timestamp_us */
1410 sensor_timestamp
= le32_to_cpu(ds_report
->sensor_timestamp
);
1411 if (!ds
->sensor_timestamp_initialized
) {
1412 ds
->sensor_timestamp_us
= DIV_ROUND_CLOSEST(sensor_timestamp
, 3);
1413 ds
->sensor_timestamp_initialized
= true;
1417 if (ds
->prev_sensor_timestamp
> sensor_timestamp
)
1418 delta
= (U32_MAX
- ds
->prev_sensor_timestamp
+ sensor_timestamp
+ 1);
1420 delta
= sensor_timestamp
- ds
->prev_sensor_timestamp
;
1421 ds
->sensor_timestamp_us
+= DIV_ROUND_CLOSEST(delta
, 3);
1423 ds
->prev_sensor_timestamp
= sensor_timestamp
;
1424 input_event(ds
->sensors
, EV_MSC
, MSC_TIMESTAMP
, ds
->sensor_timestamp_us
);
1425 input_sync(ds
->sensors
);
1427 for (i
= 0; i
< ARRAY_SIZE(ds_report
->points
); i
++) {
1428 struct dualsense_touch_point
*point
= &ds_report
->points
[i
];
1429 bool active
= (point
->contact
& DS_TOUCH_POINT_INACTIVE
) ? false : true;
1431 input_mt_slot(ds
->touchpad
, i
);
1432 input_mt_report_slot_state(ds
->touchpad
, MT_TOOL_FINGER
, active
);
1435 int x
= (point
->x_hi
<< 8) | point
->x_lo
;
1436 int y
= (point
->y_hi
<< 4) | point
->y_lo
;
1438 input_report_abs(ds
->touchpad
, ABS_MT_POSITION_X
, x
);
1439 input_report_abs(ds
->touchpad
, ABS_MT_POSITION_Y
, y
);
1442 input_mt_sync_frame(ds
->touchpad
);
1443 input_report_key(ds
->touchpad
, BTN_LEFT
, ds_report
->buttons
[2] & DS_BUTTONS2_TOUCHPAD
);
1444 input_sync(ds
->touchpad
);
1446 battery_data
= ds_report
->status
& DS_STATUS_BATTERY_CAPACITY
;
1447 charging_status
= (ds_report
->status
& DS_STATUS_CHARGING
) >> DS_STATUS_CHARGING_SHIFT
;
1449 switch (charging_status
) {
1452 * Each unit of battery data corresponds to 10%
1453 * 0 = 0-9%, 1 = 10-19%, .. and 10 = 100%
1455 battery_capacity
= min(battery_data
* 10 + 5, 100);
1456 battery_status
= POWER_SUPPLY_STATUS_DISCHARGING
;
1459 battery_capacity
= min(battery_data
* 10 + 5, 100);
1460 battery_status
= POWER_SUPPLY_STATUS_CHARGING
;
1463 battery_capacity
= 100;
1464 battery_status
= POWER_SUPPLY_STATUS_FULL
;
1466 case 0xa: /* voltage or temperature out of range */
1467 case 0xb: /* temperature error */
1468 battery_capacity
= 0;
1469 battery_status
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
1471 case 0xf: /* charging error */
1473 battery_capacity
= 0;
1474 battery_status
= POWER_SUPPLY_STATUS_UNKNOWN
;
1477 spin_lock_irqsave(&ps_dev
->lock
, flags
);
1478 ps_dev
->battery_capacity
= battery_capacity
;
1479 ps_dev
->battery_status
= battery_status
;
1480 spin_unlock_irqrestore(&ps_dev
->lock
, flags
);
1485 static int dualsense_play_effect(struct input_dev
*dev
, void *data
, struct ff_effect
*effect
)
1487 struct hid_device
*hdev
= input_get_drvdata(dev
);
1488 struct dualsense
*ds
= hid_get_drvdata(hdev
);
1489 unsigned long flags
;
1491 if (effect
->type
!= FF_RUMBLE
)
1494 spin_lock_irqsave(&ds
->base
.lock
, flags
);
1495 ds
->update_rumble
= true;
1496 ds
->motor_left
= effect
->u
.rumble
.strong_magnitude
/ 256;
1497 ds
->motor_right
= effect
->u
.rumble
.weak_magnitude
/ 256;
1498 spin_unlock_irqrestore(&ds
->base
.lock
, flags
);
1500 dualsense_schedule_work(ds
);
1504 static void dualsense_remove(struct ps_device
*ps_dev
)
1506 struct dualsense
*ds
= container_of(ps_dev
, struct dualsense
, base
);
1507 unsigned long flags
;
1509 spin_lock_irqsave(&ds
->base
.lock
, flags
);
1510 ds
->output_worker_initialized
= false;
1511 spin_unlock_irqrestore(&ds
->base
.lock
, flags
);
1513 cancel_work_sync(&ds
->output_worker
);
1516 static int dualsense_reset_leds(struct dualsense
*ds
)
1518 struct dualsense_output_report report
;
1521 buf
= kzalloc(sizeof(struct dualsense_output_report_bt
), GFP_KERNEL
);
1525 dualsense_init_output_report(ds
, &report
, buf
);
1527 * On Bluetooth the DualSense outputs an animation on the lightbar
1528 * during startup and maintains a color afterwards. We need to explicitly
1529 * reconfigure the lightbar before we can do any programming later on.
1530 * In USB the lightbar is not on by default, but redoing the setup there
1533 report
.common
->valid_flag2
= DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE
;
1534 report
.common
->lightbar_setup
= DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT
; /* Fade light out. */
1535 dualsense_send_output_report(ds
, &report
);
1541 static void dualsense_set_lightbar(struct dualsense
*ds
, uint8_t red
, uint8_t green
, uint8_t blue
)
1543 unsigned long flags
;
1545 spin_lock_irqsave(&ds
->base
.lock
, flags
);
1546 ds
->update_lightbar
= true;
1547 ds
->lightbar_red
= red
;
1548 ds
->lightbar_green
= green
;
1549 ds
->lightbar_blue
= blue
;
1550 spin_unlock_irqrestore(&ds
->base
.lock
, flags
);
1552 dualsense_schedule_work(ds
);
1555 static void dualsense_set_player_leds(struct dualsense
*ds
)
1558 * The DualSense controller has a row of 5 LEDs used for player ids.
1559 * Behavior on the PlayStation 5 console is to center the player id
1560 * across the LEDs, so e.g. player 1 would be "--x--" with x being 'on'.
1561 * Follow a similar mapping here.
1563 static const int player_ids
[5] = {
1566 BIT(4) | BIT(2) | BIT(0),
1567 BIT(4) | BIT(3) | BIT(1) | BIT(0),
1568 BIT(4) | BIT(3) | BIT(2) | BIT(1) | BIT(0)
1571 uint8_t player_id
= ds
->base
.player_id
% ARRAY_SIZE(player_ids
);
1573 ds
->update_player_leds
= true;
1574 ds
->player_leds_state
= player_ids
[player_id
];
1575 dualsense_schedule_work(ds
);
1578 static struct ps_device
*dualsense_create(struct hid_device
*hdev
)
1580 struct dualsense
*ds
;
1581 struct ps_device
*ps_dev
;
1582 uint8_t max_output_report_size
;
1585 static const struct ps_led_info player_leds_info
[] = {
1586 { LED_FUNCTION_PLAYER1
, "white", 1, dualsense_player_led_get_brightness
,
1587 dualsense_player_led_set_brightness
},
1588 { LED_FUNCTION_PLAYER2
, "white", 1, dualsense_player_led_get_brightness
,
1589 dualsense_player_led_set_brightness
},
1590 { LED_FUNCTION_PLAYER3
, "white", 1, dualsense_player_led_get_brightness
,
1591 dualsense_player_led_set_brightness
},
1592 { LED_FUNCTION_PLAYER4
, "white", 1, dualsense_player_led_get_brightness
,
1593 dualsense_player_led_set_brightness
},
1594 { LED_FUNCTION_PLAYER5
, "white", 1, dualsense_player_led_get_brightness
,
1595 dualsense_player_led_set_brightness
}
1598 ds
= devm_kzalloc(&hdev
->dev
, sizeof(*ds
), GFP_KERNEL
);
1600 return ERR_PTR(-ENOMEM
);
1603 * Patch version to allow userspace to distinguish between
1604 * hid-generic vs hid-playstation axis and button mapping.
1606 hdev
->version
|= HID_PLAYSTATION_VERSION_PATCH
;
1609 ps_dev
->hdev
= hdev
;
1610 spin_lock_init(&ps_dev
->lock
);
1611 ps_dev
->battery_capacity
= 100; /* initial value until parse_report. */
1612 ps_dev
->battery_status
= POWER_SUPPLY_STATUS_UNKNOWN
;
1613 ps_dev
->parse_report
= dualsense_parse_report
;
1614 ps_dev
->remove
= dualsense_remove
;
1615 INIT_WORK(&ds
->output_worker
, dualsense_output_worker
);
1616 ds
->output_worker_initialized
= true;
1617 hid_set_drvdata(hdev
, ds
);
1619 max_output_report_size
= sizeof(struct dualsense_output_report_bt
);
1620 ds
->output_report_dmabuf
= devm_kzalloc(&hdev
->dev
, max_output_report_size
, GFP_KERNEL
);
1621 if (!ds
->output_report_dmabuf
)
1622 return ERR_PTR(-ENOMEM
);
1624 ret
= dualsense_get_mac_address(ds
);
1626 hid_err(hdev
, "Failed to get MAC address from DualSense\n");
1627 return ERR_PTR(ret
);
1629 snprintf(hdev
->uniq
, sizeof(hdev
->uniq
), "%pMR", ds
->base
.mac_address
);
1631 ret
= dualsense_get_firmware_info(ds
);
1633 hid_err(hdev
, "Failed to get firmware info from DualSense\n");
1634 return ERR_PTR(ret
);
1637 /* Original DualSense firmware simulated classic controller rumble through
1638 * its new haptics hardware. It felt different from classic rumble users
1639 * were used to. Since then new firmwares were introduced to change behavior
1640 * and make this new 'v2' behavior default on PlayStation and other platforms.
1641 * The original DualSense requires a new enough firmware as bundled with PS5
1642 * software released in 2021. DualSense edge supports it out of the box.
1643 * Both devices also support the old mode, but it is not really used.
1645 if (hdev
->product
== USB_DEVICE_ID_SONY_PS5_CONTROLLER
) {
1646 /* Feature version 2.21 introduced new vibration method. */
1647 ds
->use_vibration_v2
= ds
->update_version
>= DS_FEATURE_VERSION(2, 21);
1648 } else if (hdev
->product
== USB_DEVICE_ID_SONY_PS5_CONTROLLER_2
) {
1649 ds
->use_vibration_v2
= true;
1652 ret
= ps_devices_list_add(ps_dev
);
1654 return ERR_PTR(ret
);
1656 ret
= dualsense_get_calibration_data(ds
);
1658 hid_err(hdev
, "Failed to get calibration data from DualSense\n");
1662 ds
->gamepad
= ps_gamepad_create(hdev
, dualsense_play_effect
);
1663 if (IS_ERR(ds
->gamepad
)) {
1664 ret
= PTR_ERR(ds
->gamepad
);
1667 /* Use gamepad input device name as primary device name for e.g. LEDs */
1668 ps_dev
->input_dev_name
= dev_name(&ds
->gamepad
->dev
);
1670 ds
->sensors
= ps_sensors_create(hdev
, DS_ACC_RANGE
, DS_ACC_RES_PER_G
,
1671 DS_GYRO_RANGE
, DS_GYRO_RES_PER_DEG_S
);
1672 if (IS_ERR(ds
->sensors
)) {
1673 ret
= PTR_ERR(ds
->sensors
);
1677 ds
->touchpad
= ps_touchpad_create(hdev
, DS_TOUCHPAD_WIDTH
, DS_TOUCHPAD_HEIGHT
, 2);
1678 if (IS_ERR(ds
->touchpad
)) {
1679 ret
= PTR_ERR(ds
->touchpad
);
1683 ret
= ps_device_register_battery(ps_dev
);
1688 * The hardware may have control over the LEDs (e.g. in Bluetooth on startup).
1689 * Reset the LEDs (lightbar, mute, player leds), so we can control them
1692 ret
= dualsense_reset_leds(ds
);
1696 ret
= ps_lightbar_register(ps_dev
, &ds
->lightbar
, dualsense_lightbar_set_brightness
);
1700 /* Set default lightbar color. */
1701 dualsense_set_lightbar(ds
, 0, 0, 128); /* blue */
1703 for (i
= 0; i
< ARRAY_SIZE(player_leds_info
); i
++) {
1704 const struct ps_led_info
*led_info
= &player_leds_info
[i
];
1706 ret
= ps_led_register(ps_dev
, &ds
->player_leds
[i
], led_info
);
1711 ret
= ps_device_set_player_id(ps_dev
);
1713 hid_err(hdev
, "Failed to assign player id for DualSense: %d\n", ret
);
1717 /* Set player LEDs to our player id. */
1718 dualsense_set_player_leds(ds
);
1721 * Reporting hardware and firmware is important as there are frequent updates, which
1722 * can change behavior.
1724 hid_info(hdev
, "Registered DualSense controller hw_version=0x%08x fw_version=0x%08x\n",
1725 ds
->base
.hw_version
, ds
->base
.fw_version
);
1730 ps_devices_list_remove(ps_dev
);
1731 return ERR_PTR(ret
);
1734 static void dualshock4_dongle_calibration_work(struct work_struct
*work
)
1736 struct dualshock4
*ds4
= container_of(work
, struct dualshock4
, dongle_hotplug_worker
);
1737 unsigned long flags
;
1738 enum dualshock4_dongle_state dongle_state
;
1741 ret
= dualshock4_get_calibration_data(ds4
);
1743 /* This call is very unlikely to fail for the dongle. When it
1744 * fails we are probably in a very bad state, so mark the
1745 * dongle as disabled. We will re-enable the dongle if a new
1746 * DS4 hotplug is detect from sony_raw_event as any issues
1747 * are likely resolved then (the dongle is quite stupid).
1749 hid_err(ds4
->base
.hdev
, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1750 dongle_state
= DONGLE_DISABLED
;
1752 hid_info(ds4
->base
.hdev
, "DualShock 4 USB dongle: calibration completed\n");
1753 dongle_state
= DONGLE_CONNECTED
;
1756 spin_lock_irqsave(&ds4
->base
.lock
, flags
);
1757 ds4
->dongle_state
= dongle_state
;
1758 spin_unlock_irqrestore(&ds4
->base
.lock
, flags
);
1761 static int dualshock4_get_calibration_data(struct dualshock4
*ds4
)
1763 struct hid_device
*hdev
= ds4
->base
.hdev
;
1764 short gyro_pitch_bias
, gyro_pitch_plus
, gyro_pitch_minus
;
1765 short gyro_yaw_bias
, gyro_yaw_plus
, gyro_yaw_minus
;
1766 short gyro_roll_bias
, gyro_roll_plus
, gyro_roll_minus
;
1767 short gyro_speed_plus
, gyro_speed_minus
;
1768 short acc_x_plus
, acc_x_minus
;
1769 short acc_y_plus
, acc_y_minus
;
1770 short acc_z_plus
, acc_z_minus
;
1777 if (ds4
->base
.hdev
->bus
== BUS_USB
) {
1780 buf
= kzalloc(DS4_FEATURE_REPORT_CALIBRATION_SIZE
, GFP_KERNEL
);
1784 /* We should normally receive the feature report data we asked
1785 * for, but hidraw applications such as Steam can issue feature
1786 * reports as well. In particular for Dongle reconnects, Steam
1787 * and this function are competing resulting in often receiving
1788 * data for a different HID report, so retry a few times.
1790 for (retries
= 0; retries
< 3; retries
++) {
1791 ret
= ps_get_report(hdev
, DS4_FEATURE_REPORT_CALIBRATION
, buf
,
1792 DS4_FEATURE_REPORT_CALIBRATION_SIZE
, true);
1795 hid_warn(hdev
, "Retrying DualShock 4 get calibration report (0x02) request\n");
1799 hid_err(hdev
, "Failed to retrieve DualShock4 calibration info: %d\n", ret
);
1806 } else { /* Bluetooth */
1807 buf
= kzalloc(DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE
, GFP_KERNEL
);
1811 ret
= ps_get_report(hdev
, DS4_FEATURE_REPORT_CALIBRATION_BT
, buf
,
1812 DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE
, true);
1814 hid_err(hdev
, "Failed to retrieve DualShock4 calibration info: %d\n", ret
);
1819 gyro_pitch_bias
= get_unaligned_le16(&buf
[1]);
1820 gyro_yaw_bias
= get_unaligned_le16(&buf
[3]);
1821 gyro_roll_bias
= get_unaligned_le16(&buf
[5]);
1822 if (ds4
->base
.hdev
->bus
== BUS_USB
) {
1823 gyro_pitch_plus
= get_unaligned_le16(&buf
[7]);
1824 gyro_pitch_minus
= get_unaligned_le16(&buf
[9]);
1825 gyro_yaw_plus
= get_unaligned_le16(&buf
[11]);
1826 gyro_yaw_minus
= get_unaligned_le16(&buf
[13]);
1827 gyro_roll_plus
= get_unaligned_le16(&buf
[15]);
1828 gyro_roll_minus
= get_unaligned_le16(&buf
[17]);
1831 gyro_pitch_plus
= get_unaligned_le16(&buf
[7]);
1832 gyro_yaw_plus
= get_unaligned_le16(&buf
[9]);
1833 gyro_roll_plus
= get_unaligned_le16(&buf
[11]);
1834 gyro_pitch_minus
= get_unaligned_le16(&buf
[13]);
1835 gyro_yaw_minus
= get_unaligned_le16(&buf
[15]);
1836 gyro_roll_minus
= get_unaligned_le16(&buf
[17]);
1838 gyro_speed_plus
= get_unaligned_le16(&buf
[19]);
1839 gyro_speed_minus
= get_unaligned_le16(&buf
[21]);
1840 acc_x_plus
= get_unaligned_le16(&buf
[23]);
1841 acc_x_minus
= get_unaligned_le16(&buf
[25]);
1842 acc_y_plus
= get_unaligned_le16(&buf
[27]);
1843 acc_y_minus
= get_unaligned_le16(&buf
[29]);
1844 acc_z_plus
= get_unaligned_le16(&buf
[31]);
1845 acc_z_minus
= get_unaligned_le16(&buf
[33]);
1848 * Set gyroscope calibration and normalization parameters.
1849 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1851 speed_2x
= (gyro_speed_plus
+ gyro_speed_minus
);
1852 ds4
->gyro_calib_data
[0].abs_code
= ABS_RX
;
1853 ds4
->gyro_calib_data
[0].bias
= 0;
1854 ds4
->gyro_calib_data
[0].sens_numer
= speed_2x
*DS4_GYRO_RES_PER_DEG_S
;
1855 ds4
->gyro_calib_data
[0].sens_denom
= abs(gyro_pitch_plus
- gyro_pitch_bias
) +
1856 abs(gyro_pitch_minus
- gyro_pitch_bias
);
1858 ds4
->gyro_calib_data
[1].abs_code
= ABS_RY
;
1859 ds4
->gyro_calib_data
[1].bias
= 0;
1860 ds4
->gyro_calib_data
[1].sens_numer
= speed_2x
*DS4_GYRO_RES_PER_DEG_S
;
1861 ds4
->gyro_calib_data
[1].sens_denom
= abs(gyro_yaw_plus
- gyro_yaw_bias
) +
1862 abs(gyro_yaw_minus
- gyro_yaw_bias
);
1864 ds4
->gyro_calib_data
[2].abs_code
= ABS_RZ
;
1865 ds4
->gyro_calib_data
[2].bias
= 0;
1866 ds4
->gyro_calib_data
[2].sens_numer
= speed_2x
*DS4_GYRO_RES_PER_DEG_S
;
1867 ds4
->gyro_calib_data
[2].sens_denom
= abs(gyro_roll_plus
- gyro_roll_bias
) +
1868 abs(gyro_roll_minus
- gyro_roll_bias
);
1871 * Sanity check gyro calibration data. This is needed to prevent crashes
1872 * during report handling of virtual, clone or broken devices not implementing
1873 * calibration data properly.
1875 for (i
= 0; i
< ARRAY_SIZE(ds4
->gyro_calib_data
); i
++) {
1876 if (ds4
->gyro_calib_data
[i
].sens_denom
== 0) {
1877 hid_warn(hdev
, "Invalid gyro calibration data for axis (%d), disabling calibration.",
1878 ds4
->gyro_calib_data
[i
].abs_code
);
1879 ds4
->gyro_calib_data
[i
].bias
= 0;
1880 ds4
->gyro_calib_data
[i
].sens_numer
= DS4_GYRO_RANGE
;
1881 ds4
->gyro_calib_data
[i
].sens_denom
= S16_MAX
;
1886 * Set accelerometer calibration and normalization parameters.
1887 * Data values will be normalized to 1/DS4_ACC_RES_PER_G g.
1889 range_2g
= acc_x_plus
- acc_x_minus
;
1890 ds4
->accel_calib_data
[0].abs_code
= ABS_X
;
1891 ds4
->accel_calib_data
[0].bias
= acc_x_plus
- range_2g
/ 2;
1892 ds4
->accel_calib_data
[0].sens_numer
= 2*DS4_ACC_RES_PER_G
;
1893 ds4
->accel_calib_data
[0].sens_denom
= range_2g
;
1895 range_2g
= acc_y_plus
- acc_y_minus
;
1896 ds4
->accel_calib_data
[1].abs_code
= ABS_Y
;
1897 ds4
->accel_calib_data
[1].bias
= acc_y_plus
- range_2g
/ 2;
1898 ds4
->accel_calib_data
[1].sens_numer
= 2*DS4_ACC_RES_PER_G
;
1899 ds4
->accel_calib_data
[1].sens_denom
= range_2g
;
1901 range_2g
= acc_z_plus
- acc_z_minus
;
1902 ds4
->accel_calib_data
[2].abs_code
= ABS_Z
;
1903 ds4
->accel_calib_data
[2].bias
= acc_z_plus
- range_2g
/ 2;
1904 ds4
->accel_calib_data
[2].sens_numer
= 2*DS4_ACC_RES_PER_G
;
1905 ds4
->accel_calib_data
[2].sens_denom
= range_2g
;
1908 * Sanity check accelerometer calibration data. This is needed to prevent crashes
1909 * during report handling of virtual, clone or broken devices not implementing calibration
1912 for (i
= 0; i
< ARRAY_SIZE(ds4
->accel_calib_data
); i
++) {
1913 if (ds4
->accel_calib_data
[i
].sens_denom
== 0) {
1914 hid_warn(hdev
, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",
1915 ds4
->accel_calib_data
[i
].abs_code
);
1916 ds4
->accel_calib_data
[i
].bias
= 0;
1917 ds4
->accel_calib_data
[i
].sens_numer
= DS4_ACC_RANGE
;
1918 ds4
->accel_calib_data
[i
].sens_denom
= S16_MAX
;
1927 static int dualshock4_get_firmware_info(struct dualshock4
*ds4
)
1932 buf
= kzalloc(DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE
, GFP_KERNEL
);
1936 /* Note USB and BT support the same feature report, but this report
1937 * lacks CRC support, so must be disabled in ps_get_report.
1939 ret
= ps_get_report(ds4
->base
.hdev
, DS4_FEATURE_REPORT_FIRMWARE_INFO
, buf
,
1940 DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE
, false);
1942 hid_err(ds4
->base
.hdev
, "Failed to retrieve DualShock4 firmware info: %d\n", ret
);
1946 ds4
->base
.hw_version
= get_unaligned_le16(&buf
[35]);
1947 ds4
->base
.fw_version
= get_unaligned_le16(&buf
[41]);
1954 static int dualshock4_get_mac_address(struct dualshock4
*ds4
)
1956 struct hid_device
*hdev
= ds4
->base
.hdev
;
1960 if (hdev
->bus
== BUS_USB
) {
1961 buf
= kzalloc(DS4_FEATURE_REPORT_PAIRING_INFO_SIZE
, GFP_KERNEL
);
1965 ret
= ps_get_report(hdev
, DS4_FEATURE_REPORT_PAIRING_INFO
, buf
,
1966 DS4_FEATURE_REPORT_PAIRING_INFO_SIZE
, false);
1968 hid_err(hdev
, "Failed to retrieve DualShock4 pairing info: %d\n", ret
);
1972 memcpy(ds4
->base
.mac_address
, &buf
[1], sizeof(ds4
->base
.mac_address
));
1974 /* Rely on HIDP for Bluetooth */
1975 if (strlen(hdev
->uniq
) != 17)
1978 ret
= sscanf(hdev
->uniq
, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1979 &ds4
->base
.mac_address
[5], &ds4
->base
.mac_address
[4],
1980 &ds4
->base
.mac_address
[3], &ds4
->base
.mac_address
[2],
1981 &ds4
->base
.mac_address
[1], &ds4
->base
.mac_address
[0]);
1983 if (ret
!= sizeof(ds4
->base
.mac_address
))
1994 static enum led_brightness
dualshock4_led_get_brightness(struct led_classdev
*led
)
1996 struct hid_device
*hdev
= to_hid_device(led
->dev
->parent
);
1997 struct dualshock4
*ds4
= hid_get_drvdata(hdev
);
1998 unsigned int led_index
;
2000 led_index
= led
- ds4
->lightbar_leds
;
2001 switch (led_index
) {
2003 return ds4
->lightbar_red
;
2005 return ds4
->lightbar_green
;
2007 return ds4
->lightbar_blue
;
2009 return ds4
->lightbar_enabled
;
2015 static int dualshock4_led_set_blink(struct led_classdev
*led
, unsigned long *delay_on
,
2016 unsigned long *delay_off
)
2018 struct hid_device
*hdev
= to_hid_device(led
->dev
->parent
);
2019 struct dualshock4
*ds4
= hid_get_drvdata(hdev
);
2020 unsigned long flags
;
2022 spin_lock_irqsave(&ds4
->base
.lock
, flags
);
2024 if (!*delay_on
&& !*delay_off
) {
2025 /* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */
2026 ds4
->lightbar_blink_on
= 50;
2027 ds4
->lightbar_blink_off
= 50;
2029 /* Blink delays in centiseconds. */
2030 ds4
->lightbar_blink_on
= min_t(unsigned long, *delay_on
/10, DS4_LIGHTBAR_MAX_BLINK
);
2031 ds4
->lightbar_blink_off
= min_t(unsigned long, *delay_off
/10, DS4_LIGHTBAR_MAX_BLINK
);
2034 ds4
->update_lightbar_blink
= true;
2036 spin_unlock_irqrestore(&ds4
->base
.lock
, flags
);
2038 dualshock4_schedule_work(ds4
);
2040 *delay_on
= ds4
->lightbar_blink_on
;
2041 *delay_off
= ds4
->lightbar_blink_off
;
2046 static int dualshock4_led_set_brightness(struct led_classdev
*led
, enum led_brightness value
)
2048 struct hid_device
*hdev
= to_hid_device(led
->dev
->parent
);
2049 struct dualshock4
*ds4
= hid_get_drvdata(hdev
);
2050 unsigned long flags
;
2051 unsigned int led_index
;
2053 spin_lock_irqsave(&ds4
->base
.lock
, flags
);
2055 led_index
= led
- ds4
->lightbar_leds
;
2056 switch (led_index
) {
2058 ds4
->lightbar_red
= value
;
2061 ds4
->lightbar_green
= value
;
2064 ds4
->lightbar_blue
= value
;
2067 ds4
->lightbar_enabled
= !!value
;
2070 ds4
->update_lightbar
= true;
2072 spin_unlock_irqrestore(&ds4
->base
.lock
, flags
);
2074 dualshock4_schedule_work(ds4
);
2079 static void dualshock4_init_output_report(struct dualshock4
*ds4
,
2080 struct dualshock4_output_report
*rp
, void *buf
)
2082 struct hid_device
*hdev
= ds4
->base
.hdev
;
2084 if (hdev
->bus
== BUS_BLUETOOTH
) {
2085 struct dualshock4_output_report_bt
*bt
= buf
;
2087 memset(bt
, 0, sizeof(*bt
));
2088 bt
->report_id
= DS4_OUTPUT_REPORT_BT
;
2091 rp
->len
= sizeof(*bt
);
2094 rp
->common
= &bt
->common
;
2096 struct dualshock4_output_report_usb
*usb
= buf
;
2098 memset(usb
, 0, sizeof(*usb
));
2099 usb
->report_id
= DS4_OUTPUT_REPORT_USB
;
2102 rp
->len
= sizeof(*usb
);
2105 rp
->common
= &usb
->common
;
2109 static void dualshock4_output_worker(struct work_struct
*work
)
2111 struct dualshock4
*ds4
= container_of(work
, struct dualshock4
, output_worker
);
2112 struct dualshock4_output_report report
;
2113 struct dualshock4_output_report_common
*common
;
2114 unsigned long flags
;
2116 dualshock4_init_output_report(ds4
, &report
, ds4
->output_report_dmabuf
);
2117 common
= report
.common
;
2119 spin_lock_irqsave(&ds4
->base
.lock
, flags
);
2121 if (ds4
->update_rumble
) {
2122 /* Select classic rumble style haptics and enable it. */
2123 common
->valid_flag0
|= DS4_OUTPUT_VALID_FLAG0_MOTOR
;
2124 common
->motor_left
= ds4
->motor_left
;
2125 common
->motor_right
= ds4
->motor_right
;
2126 ds4
->update_rumble
= false;
2129 if (ds4
->update_lightbar
) {
2130 common
->valid_flag0
|= DS4_OUTPUT_VALID_FLAG0_LED
;
2131 /* Comptabile behavior with hid-sony, which used a dummy global LED to
2132 * allow enabling/disabling the lightbar. The global LED maps to
2135 common
->lightbar_red
= ds4
->lightbar_enabled
? ds4
->lightbar_red
: 0;
2136 common
->lightbar_green
= ds4
->lightbar_enabled
? ds4
->lightbar_green
: 0;
2137 common
->lightbar_blue
= ds4
->lightbar_enabled
? ds4
->lightbar_blue
: 0;
2138 ds4
->update_lightbar
= false;
2141 if (ds4
->update_lightbar_blink
) {
2142 common
->valid_flag0
|= DS4_OUTPUT_VALID_FLAG0_LED_BLINK
;
2143 common
->lightbar_blink_on
= ds4
->lightbar_blink_on
;
2144 common
->lightbar_blink_off
= ds4
->lightbar_blink_off
;
2145 ds4
->update_lightbar_blink
= false;
2148 spin_unlock_irqrestore(&ds4
->base
.lock
, flags
);
2150 /* Bluetooth packets need additional flags as well as a CRC in the last 4 bytes. */
2153 uint8_t seed
= PS_OUTPUT_CRC32_SEED
;
2155 /* Hardware control flags need to set to let the device know
2156 * there is HID data as well as CRC.
2158 report
.bt
->hw_control
= DS4_OUTPUT_HWCTL_HID
| DS4_OUTPUT_HWCTL_CRC32
;
2160 if (ds4
->update_bt_poll_interval
) {
2161 report
.bt
->hw_control
|= ds4
->bt_poll_interval
;
2162 ds4
->update_bt_poll_interval
= false;
2165 crc
= crc32_le(0xFFFFFFFF, &seed
, 1);
2166 crc
= ~crc32_le(crc
, report
.data
, report
.len
- 4);
2168 report
.bt
->crc32
= cpu_to_le32(crc
);
2171 hid_hw_output_report(ds4
->base
.hdev
, report
.data
, report
.len
);
2174 static int dualshock4_parse_report(struct ps_device
*ps_dev
, struct hid_report
*report
,
2177 struct hid_device
*hdev
= ps_dev
->hdev
;
2178 struct dualshock4
*ds4
= container_of(ps_dev
, struct dualshock4
, base
);
2179 struct dualshock4_input_report_common
*ds4_report
;
2180 struct dualshock4_touch_report
*touch_reports
;
2181 uint8_t battery_capacity
, num_touch_reports
, value
;
2182 int battery_status
, i
, j
;
2183 uint16_t sensor_timestamp
;
2184 unsigned long flags
;
2187 * DualShock4 in USB uses the full HID report for reportID 1, but
2188 * Bluetooth uses a minimal HID report for reportID 1 and reports
2189 * the full report using reportID 17.
2191 if (hdev
->bus
== BUS_USB
&& report
->id
== DS4_INPUT_REPORT_USB
&&
2192 size
== DS4_INPUT_REPORT_USB_SIZE
) {
2193 struct dualshock4_input_report_usb
*usb
= (struct dualshock4_input_report_usb
*)data
;
2195 ds4_report
= &usb
->common
;
2196 num_touch_reports
= usb
->num_touch_reports
;
2197 touch_reports
= usb
->touch_reports
;
2198 } else if (hdev
->bus
== BUS_BLUETOOTH
&& report
->id
== DS4_INPUT_REPORT_BT
&&
2199 size
== DS4_INPUT_REPORT_BT_SIZE
) {
2200 struct dualshock4_input_report_bt
*bt
= (struct dualshock4_input_report_bt
*)data
;
2201 uint32_t report_crc
= get_unaligned_le32(&bt
->crc32
);
2203 /* Last 4 bytes of input report contains CRC. */
2204 if (!ps_check_crc32(PS_INPUT_CRC32_SEED
, data
, size
- 4, report_crc
)) {
2205 hid_err(hdev
, "DualShock4 input CRC's check failed\n");
2209 ds4_report
= &bt
->common
;
2210 num_touch_reports
= bt
->num_touch_reports
;
2211 touch_reports
= bt
->touch_reports
;
2213 hid_err(hdev
, "Unhandled reportID=%d\n", report
->id
);
2217 input_report_abs(ds4
->gamepad
, ABS_X
, ds4_report
->x
);
2218 input_report_abs(ds4
->gamepad
, ABS_Y
, ds4_report
->y
);
2219 input_report_abs(ds4
->gamepad
, ABS_RX
, ds4_report
->rx
);
2220 input_report_abs(ds4
->gamepad
, ABS_RY
, ds4_report
->ry
);
2221 input_report_abs(ds4
->gamepad
, ABS_Z
, ds4_report
->z
);
2222 input_report_abs(ds4
->gamepad
, ABS_RZ
, ds4_report
->rz
);
2224 value
= ds4_report
->buttons
[0] & DS_BUTTONS0_HAT_SWITCH
;
2225 if (value
>= ARRAY_SIZE(ps_gamepad_hat_mapping
))
2226 value
= 8; /* center */
2227 input_report_abs(ds4
->gamepad
, ABS_HAT0X
, ps_gamepad_hat_mapping
[value
].x
);
2228 input_report_abs(ds4
->gamepad
, ABS_HAT0Y
, ps_gamepad_hat_mapping
[value
].y
);
2230 input_report_key(ds4
->gamepad
, BTN_WEST
, ds4_report
->buttons
[0] & DS_BUTTONS0_SQUARE
);
2231 input_report_key(ds4
->gamepad
, BTN_SOUTH
, ds4_report
->buttons
[0] & DS_BUTTONS0_CROSS
);
2232 input_report_key(ds4
->gamepad
, BTN_EAST
, ds4_report
->buttons
[0] & DS_BUTTONS0_CIRCLE
);
2233 input_report_key(ds4
->gamepad
, BTN_NORTH
, ds4_report
->buttons
[0] & DS_BUTTONS0_TRIANGLE
);
2234 input_report_key(ds4
->gamepad
, BTN_TL
, ds4_report
->buttons
[1] & DS_BUTTONS1_L1
);
2235 input_report_key(ds4
->gamepad
, BTN_TR
, ds4_report
->buttons
[1] & DS_BUTTONS1_R1
);
2236 input_report_key(ds4
->gamepad
, BTN_TL2
, ds4_report
->buttons
[1] & DS_BUTTONS1_L2
);
2237 input_report_key(ds4
->gamepad
, BTN_TR2
, ds4_report
->buttons
[1] & DS_BUTTONS1_R2
);
2238 input_report_key(ds4
->gamepad
, BTN_SELECT
, ds4_report
->buttons
[1] & DS_BUTTONS1_CREATE
);
2239 input_report_key(ds4
->gamepad
, BTN_START
, ds4_report
->buttons
[1] & DS_BUTTONS1_OPTIONS
);
2240 input_report_key(ds4
->gamepad
, BTN_THUMBL
, ds4_report
->buttons
[1] & DS_BUTTONS1_L3
);
2241 input_report_key(ds4
->gamepad
, BTN_THUMBR
, ds4_report
->buttons
[1] & DS_BUTTONS1_R3
);
2242 input_report_key(ds4
->gamepad
, BTN_MODE
, ds4_report
->buttons
[2] & DS_BUTTONS2_PS_HOME
);
2243 input_sync(ds4
->gamepad
);
2245 /* Parse and calibrate gyroscope data. */
2246 for (i
= 0; i
< ARRAY_SIZE(ds4_report
->gyro
); i
++) {
2247 int raw_data
= (short)le16_to_cpu(ds4_report
->gyro
[i
]);
2248 int calib_data
= mult_frac(ds4
->gyro_calib_data
[i
].sens_numer
,
2249 raw_data
, ds4
->gyro_calib_data
[i
].sens_denom
);
2251 input_report_abs(ds4
->sensors
, ds4
->gyro_calib_data
[i
].abs_code
, calib_data
);
2254 /* Parse and calibrate accelerometer data. */
2255 for (i
= 0; i
< ARRAY_SIZE(ds4_report
->accel
); i
++) {
2256 int raw_data
= (short)le16_to_cpu(ds4_report
->accel
[i
]);
2257 int calib_data
= mult_frac(ds4
->accel_calib_data
[i
].sens_numer
,
2258 raw_data
- ds4
->accel_calib_data
[i
].bias
,
2259 ds4
->accel_calib_data
[i
].sens_denom
);
2261 input_report_abs(ds4
->sensors
, ds4
->accel_calib_data
[i
].abs_code
, calib_data
);
2264 /* Convert timestamp (in 5.33us unit) to timestamp_us */
2265 sensor_timestamp
= le16_to_cpu(ds4_report
->sensor_timestamp
);
2266 if (!ds4
->sensor_timestamp_initialized
) {
2267 ds4
->sensor_timestamp_us
= DIV_ROUND_CLOSEST(sensor_timestamp
*16, 3);
2268 ds4
->sensor_timestamp_initialized
= true;
2272 if (ds4
->prev_sensor_timestamp
> sensor_timestamp
)
2273 delta
= (U16_MAX
- ds4
->prev_sensor_timestamp
+ sensor_timestamp
+ 1);
2275 delta
= sensor_timestamp
- ds4
->prev_sensor_timestamp
;
2276 ds4
->sensor_timestamp_us
+= DIV_ROUND_CLOSEST(delta
*16, 3);
2278 ds4
->prev_sensor_timestamp
= sensor_timestamp
;
2279 input_event(ds4
->sensors
, EV_MSC
, MSC_TIMESTAMP
, ds4
->sensor_timestamp_us
);
2280 input_sync(ds4
->sensors
);
2282 for (i
= 0; i
< num_touch_reports
; i
++) {
2283 struct dualshock4_touch_report
*touch_report
= &touch_reports
[i
];
2285 for (j
= 0; j
< ARRAY_SIZE(touch_report
->points
); j
++) {
2286 struct dualshock4_touch_point
*point
= &touch_report
->points
[j
];
2287 bool active
= (point
->contact
& DS4_TOUCH_POINT_INACTIVE
) ? false : true;
2289 input_mt_slot(ds4
->touchpad
, j
);
2290 input_mt_report_slot_state(ds4
->touchpad
, MT_TOOL_FINGER
, active
);
2293 int x
= (point
->x_hi
<< 8) | point
->x_lo
;
2294 int y
= (point
->y_hi
<< 4) | point
->y_lo
;
2296 input_report_abs(ds4
->touchpad
, ABS_MT_POSITION_X
, x
);
2297 input_report_abs(ds4
->touchpad
, ABS_MT_POSITION_Y
, y
);
2300 input_mt_sync_frame(ds4
->touchpad
);
2301 input_sync(ds4
->touchpad
);
2303 input_report_key(ds4
->touchpad
, BTN_LEFT
, ds4_report
->buttons
[2] & DS_BUTTONS2_TOUCHPAD
);
2306 * Interpretation of the battery_capacity data depends on the cable state.
2307 * When no cable is connected (bit4 is 0):
2308 * - 0:10: percentage in units of 10%.
2309 * When a cable is plugged in:
2310 * - 0-10: percentage in units of 10%.
2311 * - 11: battery is full
2312 * - 14: not charging due to Voltage or temperature error
2313 * - 15: charge error
2315 if (ds4_report
->status
[0] & DS4_STATUS0_CABLE_STATE
) {
2316 uint8_t battery_data
= ds4_report
->status
[0] & DS4_STATUS0_BATTERY_CAPACITY
;
2318 if (battery_data
< 10) {
2319 /* Take the mid-point for each battery capacity value,
2320 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
2321 * This matches official platform behavior, which does
2324 battery_capacity
= battery_data
* 10 + 5;
2325 battery_status
= POWER_SUPPLY_STATUS_CHARGING
;
2326 } else if (battery_data
== 10) {
2327 battery_capacity
= 100;
2328 battery_status
= POWER_SUPPLY_STATUS_CHARGING
;
2329 } else if (battery_data
== DS4_BATTERY_STATUS_FULL
) {
2330 battery_capacity
= 100;
2331 battery_status
= POWER_SUPPLY_STATUS_FULL
;
2332 } else { /* 14, 15 and undefined values */
2333 battery_capacity
= 0;
2334 battery_status
= POWER_SUPPLY_STATUS_UNKNOWN
;
2337 uint8_t battery_data
= ds4_report
->status
[0] & DS4_STATUS0_BATTERY_CAPACITY
;
2339 if (battery_data
< 10)
2340 battery_capacity
= battery_data
* 10 + 5;
2342 battery_capacity
= 100;
2344 battery_status
= POWER_SUPPLY_STATUS_DISCHARGING
;
2347 spin_lock_irqsave(&ps_dev
->lock
, flags
);
2348 ps_dev
->battery_capacity
= battery_capacity
;
2349 ps_dev
->battery_status
= battery_status
;
2350 spin_unlock_irqrestore(&ps_dev
->lock
, flags
);
2355 static int dualshock4_dongle_parse_report(struct ps_device
*ps_dev
, struct hid_report
*report
,
2358 struct dualshock4
*ds4
= container_of(ps_dev
, struct dualshock4
, base
);
2359 bool connected
= false;
2361 /* The dongle reports data using the main USB report (0x1) no matter whether a controller
2362 * is connected with mostly zeros. The report does contain dongle status, which we use to
2363 * determine if a controller is connected and if so we forward to the regular DualShock4
2366 if (data
[0] == DS4_INPUT_REPORT_USB
&& size
== DS4_INPUT_REPORT_USB_SIZE
) {
2367 struct dualshock4_input_report_common
*ds4_report
= (struct dualshock4_input_report_common
*)&data
[1];
2368 unsigned long flags
;
2370 connected
= ds4_report
->status
[1] & DS4_STATUS1_DONGLE_STATE
? false : true;
2372 if (ds4
->dongle_state
== DONGLE_DISCONNECTED
&& connected
) {
2373 hid_info(ps_dev
->hdev
, "DualShock 4 USB dongle: controller connected\n");
2375 dualshock4_set_default_lightbar_colors(ds4
);
2377 spin_lock_irqsave(&ps_dev
->lock
, flags
);
2378 ds4
->dongle_state
= DONGLE_CALIBRATING
;
2379 spin_unlock_irqrestore(&ps_dev
->lock
, flags
);
2381 schedule_work(&ds4
->dongle_hotplug_worker
);
2383 /* Don't process the report since we don't have
2384 * calibration data, but let hidraw have it anyway.
2387 } else if ((ds4
->dongle_state
== DONGLE_CONNECTED
||
2388 ds4
->dongle_state
== DONGLE_DISABLED
) && !connected
) {
2389 hid_info(ps_dev
->hdev
, "DualShock 4 USB dongle: controller disconnected\n");
2391 spin_lock_irqsave(&ps_dev
->lock
, flags
);
2392 ds4
->dongle_state
= DONGLE_DISCONNECTED
;
2393 spin_unlock_irqrestore(&ps_dev
->lock
, flags
);
2395 /* Return 0, so hidraw can get the report. */
2397 } else if (ds4
->dongle_state
== DONGLE_CALIBRATING
||
2398 ds4
->dongle_state
== DONGLE_DISABLED
||
2399 ds4
->dongle_state
== DONGLE_DISCONNECTED
) {
2400 /* Return 0, so hidraw can get the report. */
2406 return dualshock4_parse_report(ps_dev
, report
, data
, size
);
2411 static int dualshock4_play_effect(struct input_dev
*dev
, void *data
, struct ff_effect
*effect
)
2413 struct hid_device
*hdev
= input_get_drvdata(dev
);
2414 struct dualshock4
*ds4
= hid_get_drvdata(hdev
);
2415 unsigned long flags
;
2417 if (effect
->type
!= FF_RUMBLE
)
2420 spin_lock_irqsave(&ds4
->base
.lock
, flags
);
2421 ds4
->update_rumble
= true;
2422 ds4
->motor_left
= effect
->u
.rumble
.strong_magnitude
/ 256;
2423 ds4
->motor_right
= effect
->u
.rumble
.weak_magnitude
/ 256;
2424 spin_unlock_irqrestore(&ds4
->base
.lock
, flags
);
2426 dualshock4_schedule_work(ds4
);
2430 static void dualshock4_remove(struct ps_device
*ps_dev
)
2432 struct dualshock4
*ds4
= container_of(ps_dev
, struct dualshock4
, base
);
2433 unsigned long flags
;
2435 spin_lock_irqsave(&ds4
->base
.lock
, flags
);
2436 ds4
->output_worker_initialized
= false;
2437 spin_unlock_irqrestore(&ds4
->base
.lock
, flags
);
2439 cancel_work_sync(&ds4
->output_worker
);
2441 if (ps_dev
->hdev
->product
== USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE
)
2442 cancel_work_sync(&ds4
->dongle_hotplug_worker
);
2445 static inline void dualshock4_schedule_work(struct dualshock4
*ds4
)
2447 unsigned long flags
;
2449 spin_lock_irqsave(&ds4
->base
.lock
, flags
);
2450 if (ds4
->output_worker_initialized
)
2451 schedule_work(&ds4
->output_worker
);
2452 spin_unlock_irqrestore(&ds4
->base
.lock
, flags
);
2455 static void dualshock4_set_bt_poll_interval(struct dualshock4
*ds4
, uint8_t interval
)
2457 ds4
->bt_poll_interval
= interval
;
2458 ds4
->update_bt_poll_interval
= true;
2459 dualshock4_schedule_work(ds4
);
2462 /* Set default lightbar color based on player. */
2463 static void dualshock4_set_default_lightbar_colors(struct dualshock4
*ds4
)
2465 /* Use same player colors as PlayStation 4.
2466 * Array of colors is in RGB.
2468 static const int player_colors
[4][3] = {
2469 { 0x00, 0x00, 0x40 }, /* Blue */
2470 { 0x40, 0x00, 0x00 }, /* Red */
2471 { 0x00, 0x40, 0x00 }, /* Green */
2472 { 0x20, 0x00, 0x20 } /* Pink */
2475 uint8_t player_id
= ds4
->base
.player_id
% ARRAY_SIZE(player_colors
);
2477 ds4
->lightbar_enabled
= true;
2478 ds4
->lightbar_red
= player_colors
[player_id
][0];
2479 ds4
->lightbar_green
= player_colors
[player_id
][1];
2480 ds4
->lightbar_blue
= player_colors
[player_id
][2];
2482 ds4
->update_lightbar
= true;
2483 dualshock4_schedule_work(ds4
);
2486 static struct ps_device
*dualshock4_create(struct hid_device
*hdev
)
2488 struct dualshock4
*ds4
;
2489 struct ps_device
*ps_dev
;
2490 uint8_t max_output_report_size
;
2493 /* The DualShock4 has an RGB lightbar, which the original hid-sony driver
2494 * exposed as a set of 4 LEDs for the 3 color channels and a global control.
2495 * Ideally this should have used the multi-color LED class, which didn't exist
2496 * yet. In addition the driver used a naming scheme not compliant with the LED
2497 * naming spec by using "<mac_address>:<color>", which contained many colons.
2498 * We use a more compliant by using "<device_name>:<color>" name now. Ideally
2499 * would have been "<device_name>:<color>:indicator", but that would break
2500 * existing applications (e.g. Android). Nothing matches against MAC address.
2502 static const struct ps_led_info lightbar_leds_info
[] = {
2503 { NULL
, "red", 255, dualshock4_led_get_brightness
, dualshock4_led_set_brightness
},
2504 { NULL
, "green", 255, dualshock4_led_get_brightness
, dualshock4_led_set_brightness
},
2505 { NULL
, "blue", 255, dualshock4_led_get_brightness
, dualshock4_led_set_brightness
},
2506 { NULL
, "global", 1, dualshock4_led_get_brightness
, dualshock4_led_set_brightness
,
2507 dualshock4_led_set_blink
},
2510 ds4
= devm_kzalloc(&hdev
->dev
, sizeof(*ds4
), GFP_KERNEL
);
2512 return ERR_PTR(-ENOMEM
);
2515 * Patch version to allow userspace to distinguish between
2516 * hid-generic vs hid-playstation axis and button mapping.
2518 hdev
->version
|= HID_PLAYSTATION_VERSION_PATCH
;
2520 ps_dev
= &ds4
->base
;
2521 ps_dev
->hdev
= hdev
;
2522 spin_lock_init(&ps_dev
->lock
);
2523 ps_dev
->battery_capacity
= 100; /* initial value until parse_report. */
2524 ps_dev
->battery_status
= POWER_SUPPLY_STATUS_UNKNOWN
;
2525 ps_dev
->parse_report
= dualshock4_parse_report
;
2526 ps_dev
->remove
= dualshock4_remove
;
2527 INIT_WORK(&ds4
->output_worker
, dualshock4_output_worker
);
2528 ds4
->output_worker_initialized
= true;
2529 hid_set_drvdata(hdev
, ds4
);
2531 max_output_report_size
= sizeof(struct dualshock4_output_report_bt
);
2532 ds4
->output_report_dmabuf
= devm_kzalloc(&hdev
->dev
, max_output_report_size
, GFP_KERNEL
);
2533 if (!ds4
->output_report_dmabuf
)
2534 return ERR_PTR(-ENOMEM
);
2536 if (hdev
->product
== USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE
) {
2537 ds4
->dongle_state
= DONGLE_DISCONNECTED
;
2538 INIT_WORK(&ds4
->dongle_hotplug_worker
, dualshock4_dongle_calibration_work
);
2540 /* Override parse report for dongle specific hotplug handling. */
2541 ps_dev
->parse_report
= dualshock4_dongle_parse_report
;
2544 ret
= dualshock4_get_mac_address(ds4
);
2546 hid_err(hdev
, "Failed to get MAC address from DualShock4\n");
2547 return ERR_PTR(ret
);
2549 snprintf(hdev
->uniq
, sizeof(hdev
->uniq
), "%pMR", ds4
->base
.mac_address
);
2551 ret
= dualshock4_get_firmware_info(ds4
);
2553 hid_err(hdev
, "Failed to get firmware info from DualShock4\n");
2554 return ERR_PTR(ret
);
2557 ret
= ps_devices_list_add(ps_dev
);
2559 return ERR_PTR(ret
);
2561 ret
= dualshock4_get_calibration_data(ds4
);
2563 hid_err(hdev
, "Failed to get calibration data from DualShock4\n");
2567 ds4
->gamepad
= ps_gamepad_create(hdev
, dualshock4_play_effect
);
2568 if (IS_ERR(ds4
->gamepad
)) {
2569 ret
= PTR_ERR(ds4
->gamepad
);
2573 /* Use gamepad input device name as primary device name for e.g. LEDs */
2574 ps_dev
->input_dev_name
= dev_name(&ds4
->gamepad
->dev
);
2576 ds4
->sensors
= ps_sensors_create(hdev
, DS4_ACC_RANGE
, DS4_ACC_RES_PER_G
,
2577 DS4_GYRO_RANGE
, DS4_GYRO_RES_PER_DEG_S
);
2578 if (IS_ERR(ds4
->sensors
)) {
2579 ret
= PTR_ERR(ds4
->sensors
);
2583 ds4
->touchpad
= ps_touchpad_create(hdev
, DS4_TOUCHPAD_WIDTH
, DS4_TOUCHPAD_HEIGHT
, 2);
2584 if (IS_ERR(ds4
->touchpad
)) {
2585 ret
= PTR_ERR(ds4
->touchpad
);
2589 ret
= ps_device_register_battery(ps_dev
);
2593 for (i
= 0; i
< ARRAY_SIZE(lightbar_leds_info
); i
++) {
2594 const struct ps_led_info
*led_info
= &lightbar_leds_info
[i
];
2596 ret
= ps_led_register(ps_dev
, &ds4
->lightbar_leds
[i
], led_info
);
2601 dualshock4_set_bt_poll_interval(ds4
, DS4_BT_DEFAULT_POLL_INTERVAL_MS
);
2603 ret
= ps_device_set_player_id(ps_dev
);
2605 hid_err(hdev
, "Failed to assign player id for DualShock4: %d\n", ret
);
2609 dualshock4_set_default_lightbar_colors(ds4
);
2612 * Reporting hardware and firmware is important as there are frequent updates, which
2613 * can change behavior.
2615 hid_info(hdev
, "Registered DualShock4 controller hw_version=0x%08x fw_version=0x%08x\n",
2616 ds4
->base
.hw_version
, ds4
->base
.fw_version
);
2620 ps_devices_list_remove(ps_dev
);
2621 return ERR_PTR(ret
);
2624 static int ps_raw_event(struct hid_device
*hdev
, struct hid_report
*report
,
2627 struct ps_device
*dev
= hid_get_drvdata(hdev
);
2629 if (dev
&& dev
->parse_report
)
2630 return dev
->parse_report(dev
, report
, data
, size
);
2635 static int ps_probe(struct hid_device
*hdev
, const struct hid_device_id
*id
)
2637 struct ps_device
*dev
;
2640 ret
= hid_parse(hdev
);
2642 hid_err(hdev
, "Parse failed\n");
2646 ret
= hid_hw_start(hdev
, HID_CONNECT_HIDRAW
);
2648 hid_err(hdev
, "Failed to start HID device\n");
2652 ret
= hid_hw_open(hdev
);
2654 hid_err(hdev
, "Failed to open HID device\n");
2658 if (hdev
->product
== USB_DEVICE_ID_SONY_PS4_CONTROLLER
||
2659 hdev
->product
== USB_DEVICE_ID_SONY_PS4_CONTROLLER_2
||
2660 hdev
->product
== USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE
) {
2661 dev
= dualshock4_create(hdev
);
2663 hid_err(hdev
, "Failed to create dualshock4.\n");
2667 } else if (hdev
->product
== USB_DEVICE_ID_SONY_PS5_CONTROLLER
||
2668 hdev
->product
== USB_DEVICE_ID_SONY_PS5_CONTROLLER_2
) {
2669 dev
= dualsense_create(hdev
);
2671 hid_err(hdev
, "Failed to create dualsense.\n");
2686 static void ps_remove(struct hid_device
*hdev
)
2688 struct ps_device
*dev
= hid_get_drvdata(hdev
);
2690 ps_devices_list_remove(dev
);
2691 ps_device_release_player_id(dev
);
2700 static const struct hid_device_id ps_devices
[] = {
2701 /* Sony DualShock 4 controllers for PS4 */
2702 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER
) },
2703 { HID_USB_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER
) },
2704 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2
) },
2705 { HID_USB_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2
) },
2706 { HID_USB_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE
) },
2707 /* Sony DualSense controllers for PS5 */
2708 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS5_CONTROLLER
) },
2709 { HID_USB_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS5_CONTROLLER
) },
2710 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2
) },
2711 { HID_USB_DEVICE(USB_VENDOR_ID_SONY
, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2
) },
2714 MODULE_DEVICE_TABLE(hid
, ps_devices
);
2716 static struct hid_driver ps_driver
= {
2717 .name
= "playstation",
2718 .id_table
= ps_devices
,
2720 .remove
= ps_remove
,
2721 .raw_event
= ps_raw_event
,
2723 .dev_groups
= ps_device_groups
,
2727 static int __init
ps_init(void)
2729 return hid_register_driver(&ps_driver
);
2732 static void __exit
ps_exit(void)
2734 hid_unregister_driver(&ps_driver
);
2735 ida_destroy(&ps_player_id_allocator
);
2738 module_init(ps_init
);
2739 module_exit(ps_exit
);
2741 MODULE_AUTHOR("Sony Interactive Entertainment");
2742 MODULE_DESCRIPTION("HID Driver for PlayStation peripherals.");
2743 MODULE_LICENSE("GPL");