1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  HID driver for Sony DualSense(TM) controller.
4  *
5  *  Copyright (c) 2020-2022 Sony Interactive Entertainment
6  */
7 
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>
17 
18 #include <linux/unaligned.h>
19 
20 #include "hid-ids.h"
21 
22 /* List of connected playstation devices. */
23 static DEFINE_MUTEX(ps_devices_lock);
24 static LIST_HEAD(ps_devices_list);
25 
26 static DEFINE_IDA(ps_player_id_allocator);
27 
28 #define HID_PLAYSTATION_VERSION_PATCH 0x8000
29 
30 enum PS_TYPE {
31 	PS_TYPE_PS4_DUALSHOCK4,
32 	PS_TYPE_PS5_DUALSENSE,
33 };
34 
35 /* Base class for playstation devices. */
36 struct ps_device {
37 	struct list_head list;
38 	struct hid_device *hdev;
39 	spinlock_t lock;
40 
41 	uint32_t player_id;
42 
43 	struct power_supply_desc battery_desc;
44 	struct power_supply *battery;
45 	uint8_t battery_capacity;
46 	int battery_status;
47 
48 	const char *input_dev_name; /* Name of primary input device. */
49 	uint8_t mac_address[6]; /* Note: stored in little endian order. */
50 	uint32_t hw_version;
51 	uint32_t fw_version;
52 
53 	int (*parse_report)(struct ps_device *dev, struct hid_report *report, u8 *data, int size);
54 	void (*remove)(struct ps_device *dev);
55 };
56 
57 /* Calibration data for playstation motion sensors. */
58 struct ps_calibration_data {
59 	int abs_code;
60 	short bias;
61 	int sens_numer;
62 	int sens_denom;
63 };
64 
65 struct ps_led_info {
66 	const char *name;
67 	const char *color;
68 	int max_brightness;
69 	enum led_brightness (*brightness_get)(struct led_classdev *cdev);
70 	int (*brightness_set)(struct led_classdev *cdev, enum led_brightness);
71 	int (*blink_set)(struct led_classdev *led, unsigned long *on, unsigned long *off);
72 };
73 
74 /* Seed values for DualShock4 / DualSense CRC32 for different report types. */
75 #define PS_INPUT_CRC32_SEED	0xA1
76 #define PS_OUTPUT_CRC32_SEED	0xA2
77 #define PS_FEATURE_CRC32_SEED	0xA3
78 
79 #define DS_INPUT_REPORT_USB			0x01
80 #define DS_INPUT_REPORT_USB_SIZE		64
81 #define DS_INPUT_REPORT_BT			0x31
82 #define DS_INPUT_REPORT_BT_SIZE			78
83 #define DS_OUTPUT_REPORT_USB			0x02
84 #define DS_OUTPUT_REPORT_USB_SIZE		63
85 #define DS_OUTPUT_REPORT_BT			0x31
86 #define DS_OUTPUT_REPORT_BT_SIZE		78
87 
88 #define DS_FEATURE_REPORT_CALIBRATION		0x05
89 #define DS_FEATURE_REPORT_CALIBRATION_SIZE	41
90 #define DS_FEATURE_REPORT_PAIRING_INFO		0x09
91 #define DS_FEATURE_REPORT_PAIRING_INFO_SIZE	20
92 #define DS_FEATURE_REPORT_FIRMWARE_INFO		0x20
93 #define DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE	64
94 
95 /* Button masks for DualSense input report. */
96 #define DS_BUTTONS0_HAT_SWITCH	GENMASK(3, 0)
97 #define DS_BUTTONS0_SQUARE	BIT(4)
98 #define DS_BUTTONS0_CROSS	BIT(5)
99 #define DS_BUTTONS0_CIRCLE	BIT(6)
100 #define DS_BUTTONS0_TRIANGLE	BIT(7)
101 #define DS_BUTTONS1_L1		BIT(0)
102 #define DS_BUTTONS1_R1		BIT(1)
103 #define DS_BUTTONS1_L2		BIT(2)
104 #define DS_BUTTONS1_R2		BIT(3)
105 #define DS_BUTTONS1_CREATE	BIT(4)
106 #define DS_BUTTONS1_OPTIONS	BIT(5)
107 #define DS_BUTTONS1_L3		BIT(6)
108 #define DS_BUTTONS1_R3		BIT(7)
109 #define DS_BUTTONS2_PS_HOME	BIT(0)
110 #define DS_BUTTONS2_TOUCHPAD	BIT(1)
111 #define DS_BUTTONS2_MIC_MUTE	BIT(2)
112 
113 /* Status field of DualSense input report. */
114 #define DS_STATUS_BATTERY_CAPACITY	GENMASK(3, 0)
115 #define DS_STATUS_CHARGING		GENMASK(7, 4)
116 #define DS_STATUS_CHARGING_SHIFT	4
117 
118 /* Feature version from DualSense Firmware Info report. */
119 #define DS_FEATURE_VERSION(major, minor) ((major & 0xff) << 8 | (minor & 0xff))
120 
121 /*
122  * Status of a DualSense touch point contact.
123  * Contact IDs, with highest bit set are 'inactive'
124  * and any associated data is then invalid.
125  */
126 #define DS_TOUCH_POINT_INACTIVE BIT(7)
127 
128  /* Magic value required in tag field of Bluetooth output report. */
129 #define DS_OUTPUT_TAG 0x10
130 /* Flags for DualSense output report. */
131 #define DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION BIT(0)
132 #define DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT BIT(1)
133 #define DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE BIT(0)
134 #define DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE BIT(1)
135 #define DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE BIT(2)
136 #define DS_OUTPUT_VALID_FLAG1_RELEASE_LEDS BIT(3)
137 #define DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE BIT(4)
138 #define DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE BIT(1)
139 #define DS_OUTPUT_VALID_FLAG2_COMPATIBLE_VIBRATION2 BIT(2)
140 #define DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE BIT(4)
141 #define DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT BIT(1)
142 
143 /* DualSense hardware limits */
144 #define DS_ACC_RES_PER_G	8192
145 #define DS_ACC_RANGE		(4*DS_ACC_RES_PER_G)
146 #define DS_GYRO_RES_PER_DEG_S	1024
147 #define DS_GYRO_RANGE		(2048*DS_GYRO_RES_PER_DEG_S)
148 #define DS_TOUCHPAD_WIDTH	1920
149 #define DS_TOUCHPAD_HEIGHT	1080
150 
151 struct dualsense {
152 	struct ps_device base;
153 	struct input_dev *gamepad;
154 	struct input_dev *sensors;
155 	struct input_dev *touchpad;
156 
157 	/* Update version is used as a feature/capability version. */
158 	uint16_t update_version;
159 
160 	/* Calibration data for accelerometer and gyroscope. */
161 	struct ps_calibration_data accel_calib_data[3];
162 	struct ps_calibration_data gyro_calib_data[3];
163 
164 	/* Timestamp for sensor data */
165 	bool sensor_timestamp_initialized;
166 	uint32_t prev_sensor_timestamp;
167 	uint32_t sensor_timestamp_us;
168 
169 	/* Compatible rumble state */
170 	bool use_vibration_v2;
171 	bool update_rumble;
172 	uint8_t motor_left;
173 	uint8_t motor_right;
174 
175 	/* RGB lightbar */
176 	struct led_classdev_mc lightbar;
177 	bool update_lightbar;
178 	uint8_t lightbar_red;
179 	uint8_t lightbar_green;
180 	uint8_t lightbar_blue;
181 
182 	/* Microphone */
183 	bool update_mic_mute;
184 	bool mic_muted;
185 	bool last_btn_mic_state;
186 
187 	/* Player leds */
188 	bool update_player_leds;
189 	uint8_t player_leds_state;
190 	struct led_classdev player_leds[5];
191 
192 	struct work_struct output_worker;
193 	bool output_worker_initialized;
194 	void *output_report_dmabuf;
195 	uint8_t output_seq; /* Sequence number for output report. */
196 };
197 
198 struct dualsense_touch_point {
199 	uint8_t contact;
200 	uint8_t x_lo;
201 	uint8_t x_hi:4, y_lo:4;
202 	uint8_t y_hi;
203 } __packed;
204 static_assert(sizeof(struct dualsense_touch_point) == 4);
205 
206 /* Main DualSense input report excluding any BT/USB specific headers. */
207 struct dualsense_input_report {
208 	uint8_t x, y;
209 	uint8_t rx, ry;
210 	uint8_t z, rz;
211 	uint8_t seq_number;
212 	uint8_t buttons[4];
213 	uint8_t reserved[4];
214 
215 	/* Motion sensors */
216 	__le16 gyro[3]; /* x, y, z */
217 	__le16 accel[3]; /* x, y, z */
218 	__le32 sensor_timestamp;
219 	uint8_t reserved2;
220 
221 	/* Touchpad */
222 	struct dualsense_touch_point points[2];
223 
224 	uint8_t reserved3[12];
225 	uint8_t status;
226 	uint8_t reserved4[10];
227 } __packed;
228 /* Common input report size shared equals the size of the USB report minus 1 byte for ReportID. */
229 static_assert(sizeof(struct dualsense_input_report) == DS_INPUT_REPORT_USB_SIZE - 1);
230 
231 /* Common data between DualSense BT/USB main output report. */
232 struct dualsense_output_report_common {
233 	uint8_t valid_flag0;
234 	uint8_t valid_flag1;
235 
236 	/* For DualShock 4 compatibility mode. */
237 	uint8_t motor_right;
238 	uint8_t motor_left;
239 
240 	/* Audio controls */
241 	uint8_t reserved[4];
242 	uint8_t mute_button_led;
243 
244 	uint8_t power_save_control;
245 	uint8_t reserved2[28];
246 
247 	/* LEDs and lightbar */
248 	uint8_t valid_flag2;
249 	uint8_t reserved3[2];
250 	uint8_t lightbar_setup;
251 	uint8_t led_brightness;
252 	uint8_t player_leds;
253 	uint8_t lightbar_red;
254 	uint8_t lightbar_green;
255 	uint8_t lightbar_blue;
256 } __packed;
257 static_assert(sizeof(struct dualsense_output_report_common) == 47);
258 
259 struct dualsense_output_report_bt {
260 	uint8_t report_id; /* 0x31 */
261 	uint8_t seq_tag;
262 	uint8_t tag;
263 	struct dualsense_output_report_common common;
264 	uint8_t reserved[24];
265 	__le32 crc32;
266 } __packed;
267 static_assert(sizeof(struct dualsense_output_report_bt) == DS_OUTPUT_REPORT_BT_SIZE);
268 
269 struct dualsense_output_report_usb {
270 	uint8_t report_id; /* 0x02 */
271 	struct dualsense_output_report_common common;
272 	uint8_t reserved[15];
273 } __packed;
274 static_assert(sizeof(struct dualsense_output_report_usb) == DS_OUTPUT_REPORT_USB_SIZE);
275 
276 /*
277  * The DualSense has a main output report used to control most features. It is
278  * largely the same between Bluetooth and USB except for different headers and CRC.
279  * This structure hide the differences between the two to simplify sending output reports.
280  */
281 struct dualsense_output_report {
282 	uint8_t *data; /* Start of data */
283 	uint8_t len; /* Size of output report */
284 
285 	/* Points to Bluetooth data payload in case for a Bluetooth report else NULL. */
286 	struct dualsense_output_report_bt *bt;
287 	/* Points to USB data payload in case for a USB report else NULL. */
288 	struct dualsense_output_report_usb *usb;
289 	/* Points to common section of report, so past any headers. */
290 	struct dualsense_output_report_common *common;
291 };
292 
293 #define DS4_INPUT_REPORT_USB			0x01
294 #define DS4_INPUT_REPORT_USB_SIZE		64
295 #define DS4_INPUT_REPORT_BT_MINIMAL		0x01
296 #define DS4_INPUT_REPORT_BT_MINIMAL_SIZE	10
297 #define DS4_INPUT_REPORT_BT			0x11
298 #define DS4_INPUT_REPORT_BT_SIZE		78
299 #define DS4_OUTPUT_REPORT_USB			0x05
300 #define DS4_OUTPUT_REPORT_USB_SIZE		32
301 #define DS4_OUTPUT_REPORT_BT			0x11
302 #define DS4_OUTPUT_REPORT_BT_SIZE		78
303 
304 #define DS4_FEATURE_REPORT_CALIBRATION		0x02
305 #define DS4_FEATURE_REPORT_CALIBRATION_SIZE	37
306 #define DS4_FEATURE_REPORT_CALIBRATION_BT	0x05
307 #define DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE	41
308 #define DS4_FEATURE_REPORT_FIRMWARE_INFO	0xa3
309 #define DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE	49
310 #define DS4_FEATURE_REPORT_PAIRING_INFO		0x12
311 #define DS4_FEATURE_REPORT_PAIRING_INFO_SIZE	16
312 
313 /*
314  * Status of a DualShock4 touch point contact.
315  * Contact IDs, with highest bit set are 'inactive'
316  * and any associated data is then invalid.
317  */
318 #define DS4_TOUCH_POINT_INACTIVE BIT(7)
319 
320 /* Status field of DualShock4 input report. */
321 #define DS4_STATUS0_BATTERY_CAPACITY	GENMASK(3, 0)
322 #define DS4_STATUS0_CABLE_STATE		BIT(4)
323 /* Battery status within batery_status field. */
324 #define DS4_BATTERY_STATUS_FULL		11
325 /* Status1 bit2 contains dongle connection state:
326  * 0 = connectd
327  * 1 = disconnected
328  */
329 #define DS4_STATUS1_DONGLE_STATE	BIT(2)
330 
331 /* The lower 6 bits of hw_control of the Bluetooth main output report
332  * control the interval at which Dualshock 4 reports data:
333  * 0x00 - 1ms
334  * 0x01 - 1ms
335  * 0x02 - 2ms
336  * 0x3E - 62ms
337  * 0x3F - disabled
338  */
339 #define DS4_OUTPUT_HWCTL_BT_POLL_MASK	0x3F
340 /* Default to 4ms poll interval, which is same as USB (not adjustable). */
341 #define DS4_BT_DEFAULT_POLL_INTERVAL_MS	4
342 #define DS4_OUTPUT_HWCTL_CRC32		0x40
343 #define DS4_OUTPUT_HWCTL_HID		0x80
344 
345 /* Flags for DualShock4 output report. */
346 #define DS4_OUTPUT_VALID_FLAG0_MOTOR		0x01
347 #define DS4_OUTPUT_VALID_FLAG0_LED		0x02
348 #define DS4_OUTPUT_VALID_FLAG0_LED_BLINK	0x04
349 
350 /* DualShock4 hardware limits */
351 #define DS4_ACC_RES_PER_G	8192
352 #define DS4_ACC_RANGE		(4*DS_ACC_RES_PER_G)
353 #define DS4_GYRO_RES_PER_DEG_S	1024
354 #define DS4_GYRO_RANGE		(2048*DS_GYRO_RES_PER_DEG_S)
355 #define DS4_LIGHTBAR_MAX_BLINK	255 /* 255 centiseconds */
356 #define DS4_TOUCHPAD_WIDTH	1920
357 #define DS4_TOUCHPAD_HEIGHT	942
358 
359 enum dualshock4_dongle_state {
360 	DONGLE_DISCONNECTED,
361 	DONGLE_CALIBRATING,
362 	DONGLE_CONNECTED,
363 	DONGLE_DISABLED
364 };
365 
366 struct dualshock4 {
367 	struct ps_device base;
368 	struct input_dev *gamepad;
369 	struct input_dev *sensors;
370 	struct input_dev *touchpad;
371 
372 	/* Calibration data for accelerometer and gyroscope. */
373 	struct ps_calibration_data accel_calib_data[3];
374 	struct ps_calibration_data gyro_calib_data[3];
375 
376 	/* Only used on dongle to track state transitions. */
377 	enum dualshock4_dongle_state dongle_state;
378 	/* Used during calibration. */
379 	struct work_struct dongle_hotplug_worker;
380 
381 	/* Timestamp for sensor data */
382 	bool sensor_timestamp_initialized;
383 	uint32_t prev_sensor_timestamp;
384 	uint32_t sensor_timestamp_us;
385 
386 	/* Bluetooth poll interval */
387 	bool update_bt_poll_interval;
388 	uint8_t bt_poll_interval;
389 
390 	bool update_rumble;
391 	uint8_t motor_left;
392 	uint8_t motor_right;
393 
394 	/* Lightbar leds */
395 	bool update_lightbar;
396 	bool update_lightbar_blink;
397 	bool lightbar_enabled; /* For use by global LED control. */
398 	uint8_t lightbar_red;
399 	uint8_t lightbar_green;
400 	uint8_t lightbar_blue;
401 	uint8_t lightbar_blink_on; /* In increments of 10ms. */
402 	uint8_t lightbar_blink_off; /* In increments of 10ms. */
403 	struct led_classdev lightbar_leds[4];
404 
405 	struct work_struct output_worker;
406 	bool output_worker_initialized;
407 	void *output_report_dmabuf;
408 };
409 
410 struct dualshock4_touch_point {
411 	uint8_t contact;
412 	uint8_t x_lo;
413 	uint8_t x_hi:4, y_lo:4;
414 	uint8_t y_hi;
415 } __packed;
416 static_assert(sizeof(struct dualshock4_touch_point) == 4);
417 
418 struct dualshock4_touch_report {
419 	uint8_t timestamp;
420 	struct dualshock4_touch_point points[2];
421 } __packed;
422 static_assert(sizeof(struct dualshock4_touch_report) == 9);
423 
424 /* Main DualShock4 input report excluding any BT/USB specific headers. */
425 struct dualshock4_input_report_common {
426 	uint8_t x, y;
427 	uint8_t rx, ry;
428 	uint8_t buttons[3];
429 	uint8_t z, rz;
430 
431 	/* Motion sensors */
432 	__le16 sensor_timestamp;
433 	uint8_t sensor_temperature;
434 	__le16 gyro[3]; /* x, y, z */
435 	__le16 accel[3]; /* x, y, z */
436 	uint8_t reserved2[5];
437 
438 	uint8_t status[2];
439 	uint8_t reserved3;
440 } __packed;
441 static_assert(sizeof(struct dualshock4_input_report_common) == 32);
442 
443 struct dualshock4_input_report_usb {
444 	uint8_t report_id; /* 0x01 */
445 	struct dualshock4_input_report_common common;
446 	uint8_t num_touch_reports;
447 	struct dualshock4_touch_report touch_reports[3];
448 	uint8_t reserved[3];
449 } __packed;
450 static_assert(sizeof(struct dualshock4_input_report_usb) == DS4_INPUT_REPORT_USB_SIZE);
451 
452 struct dualshock4_input_report_bt {
453 	uint8_t report_id; /* 0x11 */
454 	uint8_t reserved[2];
455 	struct dualshock4_input_report_common common;
456 	uint8_t num_touch_reports;
457 	struct dualshock4_touch_report touch_reports[4]; /* BT has 4 compared to 3 for USB */
458 	uint8_t reserved2[2];
459 	__le32 crc32;
460 } __packed;
461 static_assert(sizeof(struct dualshock4_input_report_bt) == DS4_INPUT_REPORT_BT_SIZE);
462 
463 /* Common data between Bluetooth and USB DualShock4 output reports. */
464 struct dualshock4_output_report_common {
465 	uint8_t valid_flag0;
466 	uint8_t valid_flag1;
467 
468 	uint8_t reserved;
469 
470 	uint8_t motor_right;
471 	uint8_t motor_left;
472 
473 	uint8_t lightbar_red;
474 	uint8_t lightbar_green;
475 	uint8_t lightbar_blue;
476 	uint8_t lightbar_blink_on;
477 	uint8_t lightbar_blink_off;
478 } __packed;
479 
480 struct dualshock4_output_report_usb {
481 	uint8_t report_id; /* 0x5 */
482 	struct dualshock4_output_report_common common;
483 	uint8_t reserved[21];
484 } __packed;
485 static_assert(sizeof(struct dualshock4_output_report_usb) == DS4_OUTPUT_REPORT_USB_SIZE);
486 
487 struct dualshock4_output_report_bt {
488 	uint8_t report_id; /* 0x11 */
489 	uint8_t hw_control;
490 	uint8_t audio_control;
491 	struct dualshock4_output_report_common common;
492 	uint8_t reserved[61];
493 	__le32 crc32;
494 } __packed;
495 static_assert(sizeof(struct dualshock4_output_report_bt) == DS4_OUTPUT_REPORT_BT_SIZE);
496 
497 /*
498  * The DualShock4 has a main output report used to control most features. It is
499  * largely the same between Bluetooth and USB except for different headers and CRC.
500  * This structure hide the differences between the two to simplify sending output reports.
501  */
502 struct dualshock4_output_report {
503 	uint8_t *data; /* Start of data */
504 	uint8_t len; /* Size of output report */
505 
506 	/* Points to Bluetooth data payload in case for a Bluetooth report else NULL. */
507 	struct dualshock4_output_report_bt *bt;
508 	/* Points to USB data payload in case for a USB report else NULL. */
509 	struct dualshock4_output_report_usb *usb;
510 	/* Points to common section of report, so past any headers. */
511 	struct dualshock4_output_report_common *common;
512 };
513 
514 /*
515  * Common gamepad buttons across DualShock 3 / 4 and DualSense.
516  * Note: for device with a touchpad, touchpad button is not included
517  *        as it will be part of the touchpad device.
518  */
519 static const int ps_gamepad_buttons[] = {
520 	BTN_WEST, /* Square */
521 	BTN_NORTH, /* Triangle */
522 	BTN_EAST, /* Circle */
523 	BTN_SOUTH, /* Cross */
524 	BTN_TL, /* L1 */
525 	BTN_TR, /* R1 */
526 	BTN_TL2, /* L2 */
527 	BTN_TR2, /* R2 */
528 	BTN_SELECT, /* Create (PS5) / Share (PS4) */
529 	BTN_START, /* Option */
530 	BTN_THUMBL, /* L3 */
531 	BTN_THUMBR, /* R3 */
532 	BTN_MODE, /* PS Home */
533 };
534 
535 static const struct {int x; int y; } ps_gamepad_hat_mapping[] = {
536 	{0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
537 	{0, 0},
538 };
539 
540 static int dualshock4_get_calibration_data(struct dualshock4 *ds4);
541 static inline void dualsense_schedule_work(struct dualsense *ds);
542 static inline void dualshock4_schedule_work(struct dualshock4 *ds4);
543 static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue);
544 static void dualshock4_set_default_lightbar_colors(struct dualshock4 *ds4);
545 
546 /*
547  * Add a new ps_device to ps_devices if it doesn't exist.
548  * Return error on duplicate device, which can happen if the same
549  * device is connected using both Bluetooth and USB.
550  */
ps_devices_list_add(struct ps_device * dev)551 static int ps_devices_list_add(struct ps_device *dev)
552 {
553 	struct ps_device *entry;
554 
555 	mutex_lock(&ps_devices_lock);
556 	list_for_each_entry(entry, &ps_devices_list, list) {
557 		if (!memcmp(entry->mac_address, dev->mac_address, sizeof(dev->mac_address))) {
558 			hid_err(dev->hdev, "Duplicate device found for MAC address %pMR.\n",
559 					dev->mac_address);
560 			mutex_unlock(&ps_devices_lock);
561 			return -EEXIST;
562 		}
563 	}
564 
565 	list_add_tail(&dev->list, &ps_devices_list);
566 	mutex_unlock(&ps_devices_lock);
567 	return 0;
568 }
569 
ps_devices_list_remove(struct ps_device * dev)570 static int ps_devices_list_remove(struct ps_device *dev)
571 {
572 	mutex_lock(&ps_devices_lock);
573 	list_del(&dev->list);
574 	mutex_unlock(&ps_devices_lock);
575 	return 0;
576 }
577 
ps_device_set_player_id(struct ps_device * dev)578 static int ps_device_set_player_id(struct ps_device *dev)
579 {
580 	int ret = ida_alloc(&ps_player_id_allocator, GFP_KERNEL);
581 
582 	if (ret < 0)
583 		return ret;
584 
585 	dev->player_id = ret;
586 	return 0;
587 }
588 
ps_device_release_player_id(struct ps_device * dev)589 static void ps_device_release_player_id(struct ps_device *dev)
590 {
591 	ida_free(&ps_player_id_allocator, dev->player_id);
592 
593 	dev->player_id = U32_MAX;
594 }
595 
ps_allocate_input_dev(struct hid_device * hdev,const char * name_suffix)596 static struct input_dev *ps_allocate_input_dev(struct hid_device *hdev, const char *name_suffix)
597 {
598 	struct input_dev *input_dev;
599 
600 	input_dev = devm_input_allocate_device(&hdev->dev);
601 	if (!input_dev)
602 		return ERR_PTR(-ENOMEM);
603 
604 	input_dev->id.bustype = hdev->bus;
605 	input_dev->id.vendor = hdev->vendor;
606 	input_dev->id.product = hdev->product;
607 	input_dev->id.version = hdev->version;
608 	input_dev->uniq = hdev->uniq;
609 
610 	if (name_suffix) {
611 		input_dev->name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s %s", hdev->name,
612 				name_suffix);
613 		if (!input_dev->name)
614 			return ERR_PTR(-ENOMEM);
615 	} else {
616 		input_dev->name = hdev->name;
617 	}
618 
619 	input_set_drvdata(input_dev, hdev);
620 
621 	return input_dev;
622 }
623 
624 static enum power_supply_property ps_power_supply_props[] = {
625 	POWER_SUPPLY_PROP_STATUS,
626 	POWER_SUPPLY_PROP_PRESENT,
627 	POWER_SUPPLY_PROP_CAPACITY,
628 	POWER_SUPPLY_PROP_SCOPE,
629 };
630 
ps_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)631 static int ps_battery_get_property(struct power_supply *psy,
632 		enum power_supply_property psp,
633 		union power_supply_propval *val)
634 {
635 	struct ps_device *dev = power_supply_get_drvdata(psy);
636 	uint8_t battery_capacity;
637 	int battery_status;
638 	unsigned long flags;
639 	int ret = 0;
640 
641 	spin_lock_irqsave(&dev->lock, flags);
642 	battery_capacity = dev->battery_capacity;
643 	battery_status = dev->battery_status;
644 	spin_unlock_irqrestore(&dev->lock, flags);
645 
646 	switch (psp) {
647 	case POWER_SUPPLY_PROP_STATUS:
648 		val->intval = battery_status;
649 		break;
650 	case POWER_SUPPLY_PROP_PRESENT:
651 		val->intval = 1;
652 		break;
653 	case POWER_SUPPLY_PROP_CAPACITY:
654 		val->intval = battery_capacity;
655 		break;
656 	case POWER_SUPPLY_PROP_SCOPE:
657 		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
658 		break;
659 	default:
660 		ret = -EINVAL;
661 		break;
662 	}
663 
664 	return ret;
665 }
666 
ps_device_register_battery(struct ps_device * dev)667 static int ps_device_register_battery(struct ps_device *dev)
668 {
669 	struct power_supply *battery;
670 	struct power_supply_config battery_cfg = { .drv_data = dev };
671 	int ret;
672 
673 	dev->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
674 	dev->battery_desc.properties = ps_power_supply_props;
675 	dev->battery_desc.num_properties = ARRAY_SIZE(ps_power_supply_props);
676 	dev->battery_desc.get_property = ps_battery_get_property;
677 	dev->battery_desc.name = devm_kasprintf(&dev->hdev->dev, GFP_KERNEL,
678 			"ps-controller-battery-%pMR", dev->mac_address);
679 	if (!dev->battery_desc.name)
680 		return -ENOMEM;
681 
682 	battery = devm_power_supply_register(&dev->hdev->dev, &dev->battery_desc, &battery_cfg);
683 	if (IS_ERR(battery)) {
684 		ret = PTR_ERR(battery);
685 		hid_err(dev->hdev, "Unable to register battery device: %d\n", ret);
686 		return ret;
687 	}
688 	dev->battery = battery;
689 
690 	ret = power_supply_powers(dev->battery, &dev->hdev->dev);
691 	if (ret) {
692 		hid_err(dev->hdev, "Unable to activate battery device: %d\n", ret);
693 		return ret;
694 	}
695 
696 	return 0;
697 }
698 
699 /* Compute crc32 of HID data and compare against expected CRC. */
ps_check_crc32(uint8_t seed,uint8_t * data,size_t len,uint32_t report_crc)700 static bool ps_check_crc32(uint8_t seed, uint8_t *data, size_t len, uint32_t report_crc)
701 {
702 	uint32_t crc;
703 
704 	crc = crc32_le(0xFFFFFFFF, &seed, 1);
705 	crc = ~crc32_le(crc, data, len);
706 
707 	return crc == report_crc;
708 }
709 
ps_gamepad_create(struct hid_device * hdev,int (* play_effect)(struct input_dev *,void *,struct ff_effect *))710 static struct input_dev *ps_gamepad_create(struct hid_device *hdev,
711 		int (*play_effect)(struct input_dev *, void *, struct ff_effect *))
712 {
713 	struct input_dev *gamepad;
714 	unsigned int i;
715 	int ret;
716 
717 	gamepad = ps_allocate_input_dev(hdev, NULL);
718 	if (IS_ERR(gamepad))
719 		return ERR_CAST(gamepad);
720 
721 	input_set_abs_params(gamepad, ABS_X, 0, 255, 0, 0);
722 	input_set_abs_params(gamepad, ABS_Y, 0, 255, 0, 0);
723 	input_set_abs_params(gamepad, ABS_Z, 0, 255, 0, 0);
724 	input_set_abs_params(gamepad, ABS_RX, 0, 255, 0, 0);
725 	input_set_abs_params(gamepad, ABS_RY, 0, 255, 0, 0);
726 	input_set_abs_params(gamepad, ABS_RZ, 0, 255, 0, 0);
727 
728 	input_set_abs_params(gamepad, ABS_HAT0X, -1, 1, 0, 0);
729 	input_set_abs_params(gamepad, ABS_HAT0Y, -1, 1, 0, 0);
730 
731 	for (i = 0; i < ARRAY_SIZE(ps_gamepad_buttons); i++)
732 		input_set_capability(gamepad, EV_KEY, ps_gamepad_buttons[i]);
733 
734 #if IS_ENABLED(CONFIG_PLAYSTATION_FF)
735 	if (play_effect) {
736 		input_set_capability(gamepad, EV_FF, FF_RUMBLE);
737 		input_ff_create_memless(gamepad, NULL, play_effect);
738 	}
739 #endif
740 
741 	ret = input_register_device(gamepad);
742 	if (ret)
743 		return ERR_PTR(ret);
744 
745 	return gamepad;
746 }
747 
ps_get_report(struct hid_device * hdev,uint8_t report_id,uint8_t * buf,size_t size,bool check_crc)748 static int ps_get_report(struct hid_device *hdev, uint8_t report_id, uint8_t *buf, size_t size,
749 		bool check_crc)
750 {
751 	int ret;
752 
753 	ret = hid_hw_raw_request(hdev, report_id, buf, size, HID_FEATURE_REPORT,
754 				 HID_REQ_GET_REPORT);
755 	if (ret < 0) {
756 		hid_err(hdev, "Failed to retrieve feature with reportID %d: %d\n", report_id, ret);
757 		return ret;
758 	}
759 
760 	if (ret != size) {
761 		hid_err(hdev, "Invalid byte count transferred, expected %zu got %d\n", size, ret);
762 		return -EINVAL;
763 	}
764 
765 	if (buf[0] != report_id) {
766 		hid_err(hdev, "Invalid reportID received, expected %d got %d\n", report_id, buf[0]);
767 		return -EINVAL;
768 	}
769 
770 	if (hdev->bus == BUS_BLUETOOTH && check_crc) {
771 		/* Last 4 bytes contains crc32. */
772 		uint8_t crc_offset = size - 4;
773 		uint32_t report_crc = get_unaligned_le32(&buf[crc_offset]);
774 
775 		if (!ps_check_crc32(PS_FEATURE_CRC32_SEED, buf, crc_offset, report_crc)) {
776 			hid_err(hdev, "CRC check failed for reportID=%d\n", report_id);
777 			return -EILSEQ;
778 		}
779 	}
780 
781 	return 0;
782 }
783 
ps_led_register(struct ps_device * ps_dev,struct led_classdev * led,const struct ps_led_info * led_info)784 static int ps_led_register(struct ps_device *ps_dev, struct led_classdev *led,
785 		const struct ps_led_info *led_info)
786 {
787 	int ret;
788 
789 	if (led_info->name) {
790 		led->name = devm_kasprintf(&ps_dev->hdev->dev, GFP_KERNEL,
791 				"%s:%s:%s", ps_dev->input_dev_name, led_info->color, led_info->name);
792 	} else {
793 		/* Backwards compatible mode for hid-sony, but not compliant with LED class spec. */
794 		led->name = devm_kasprintf(&ps_dev->hdev->dev, GFP_KERNEL,
795 				"%s:%s", ps_dev->input_dev_name, led_info->color);
796 	}
797 
798 	if (!led->name)
799 		return -ENOMEM;
800 
801 	led->brightness = 0;
802 	led->max_brightness = led_info->max_brightness;
803 	led->flags = LED_CORE_SUSPENDRESUME;
804 	led->brightness_get = led_info->brightness_get;
805 	led->brightness_set_blocking = led_info->brightness_set;
806 	led->blink_set = led_info->blink_set;
807 
808 	ret = devm_led_classdev_register(&ps_dev->hdev->dev, led);
809 	if (ret) {
810 		hid_err(ps_dev->hdev, "Failed to register LED %s: %d\n", led_info->name, ret);
811 		return ret;
812 	}
813 
814 	return 0;
815 }
816 
817 /* Register a DualSense/DualShock4 RGB lightbar represented by a multicolor LED. */
ps_lightbar_register(struct ps_device * ps_dev,struct led_classdev_mc * lightbar_mc_dev,int (* brightness_set)(struct led_classdev *,enum led_brightness))818 static int ps_lightbar_register(struct ps_device *ps_dev, struct led_classdev_mc *lightbar_mc_dev,
819 	int (*brightness_set)(struct led_classdev *, enum led_brightness))
820 {
821 	struct hid_device *hdev = ps_dev->hdev;
822 	struct mc_subled *mc_led_info;
823 	struct led_classdev *led_cdev;
824 	int ret;
825 
826 	mc_led_info = devm_kmalloc_array(&hdev->dev, 3, sizeof(*mc_led_info),
827 					 GFP_KERNEL | __GFP_ZERO);
828 	if (!mc_led_info)
829 		return -ENOMEM;
830 
831 	mc_led_info[0].color_index = LED_COLOR_ID_RED;
832 	mc_led_info[1].color_index = LED_COLOR_ID_GREEN;
833 	mc_led_info[2].color_index = LED_COLOR_ID_BLUE;
834 
835 	lightbar_mc_dev->subled_info = mc_led_info;
836 	lightbar_mc_dev->num_colors = 3;
837 
838 	led_cdev = &lightbar_mc_dev->led_cdev;
839 	led_cdev->name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s:rgb:indicator",
840 			ps_dev->input_dev_name);
841 	if (!led_cdev->name)
842 		return -ENOMEM;
843 	led_cdev->brightness = 255;
844 	led_cdev->max_brightness = 255;
845 	led_cdev->brightness_set_blocking = brightness_set;
846 
847 	ret = devm_led_classdev_multicolor_register(&hdev->dev, lightbar_mc_dev);
848 	if (ret < 0) {
849 		hid_err(hdev, "Cannot register multicolor LED device\n");
850 		return ret;
851 	}
852 
853 	return 0;
854 }
855 
ps_sensors_create(struct hid_device * hdev,int accel_range,int accel_res,int gyro_range,int gyro_res)856 static struct input_dev *ps_sensors_create(struct hid_device *hdev, int accel_range, int accel_res,
857 		int gyro_range, int gyro_res)
858 {
859 	struct input_dev *sensors;
860 	int ret;
861 
862 	sensors = ps_allocate_input_dev(hdev, "Motion Sensors");
863 	if (IS_ERR(sensors))
864 		return ERR_CAST(sensors);
865 
866 	__set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit);
867 	__set_bit(EV_MSC, sensors->evbit);
868 	__set_bit(MSC_TIMESTAMP, sensors->mscbit);
869 
870 	/* Accelerometer */
871 	input_set_abs_params(sensors, ABS_X, -accel_range, accel_range, 16, 0);
872 	input_set_abs_params(sensors, ABS_Y, -accel_range, accel_range, 16, 0);
873 	input_set_abs_params(sensors, ABS_Z, -accel_range, accel_range, 16, 0);
874 	input_abs_set_res(sensors, ABS_X, accel_res);
875 	input_abs_set_res(sensors, ABS_Y, accel_res);
876 	input_abs_set_res(sensors, ABS_Z, accel_res);
877 
878 	/* Gyroscope */
879 	input_set_abs_params(sensors, ABS_RX, -gyro_range, gyro_range, 16, 0);
880 	input_set_abs_params(sensors, ABS_RY, -gyro_range, gyro_range, 16, 0);
881 	input_set_abs_params(sensors, ABS_RZ, -gyro_range, gyro_range, 16, 0);
882 	input_abs_set_res(sensors, ABS_RX, gyro_res);
883 	input_abs_set_res(sensors, ABS_RY, gyro_res);
884 	input_abs_set_res(sensors, ABS_RZ, gyro_res);
885 
886 	ret = input_register_device(sensors);
887 	if (ret)
888 		return ERR_PTR(ret);
889 
890 	return sensors;
891 }
892 
ps_touchpad_create(struct hid_device * hdev,int width,int height,unsigned int num_contacts)893 static struct input_dev *ps_touchpad_create(struct hid_device *hdev, int width, int height,
894 		unsigned int num_contacts)
895 {
896 	struct input_dev *touchpad;
897 	int ret;
898 
899 	touchpad = ps_allocate_input_dev(hdev, "Touchpad");
900 	if (IS_ERR(touchpad))
901 		return ERR_CAST(touchpad);
902 
903 	/* Map button underneath touchpad to BTN_LEFT. */
904 	input_set_capability(touchpad, EV_KEY, BTN_LEFT);
905 	__set_bit(INPUT_PROP_BUTTONPAD, touchpad->propbit);
906 
907 	input_set_abs_params(touchpad, ABS_MT_POSITION_X, 0, width - 1, 0, 0);
908 	input_set_abs_params(touchpad, ABS_MT_POSITION_Y, 0, height - 1, 0, 0);
909 
910 	ret = input_mt_init_slots(touchpad, num_contacts, INPUT_MT_POINTER);
911 	if (ret)
912 		return ERR_PTR(ret);
913 
914 	ret = input_register_device(touchpad);
915 	if (ret)
916 		return ERR_PTR(ret);
917 
918 	return touchpad;
919 }
920 
firmware_version_show(struct device * dev,struct device_attribute * attr,char * buf)921 static ssize_t firmware_version_show(struct device *dev,
922 				struct device_attribute
923 				*attr, char *buf)
924 {
925 	struct hid_device *hdev = to_hid_device(dev);
926 	struct ps_device *ps_dev = hid_get_drvdata(hdev);
927 
928 	return sysfs_emit(buf, "0x%08x\n", ps_dev->fw_version);
929 }
930 
931 static DEVICE_ATTR_RO(firmware_version);
932 
hardware_version_show(struct device * dev,struct device_attribute * attr,char * buf)933 static ssize_t hardware_version_show(struct device *dev,
934 				struct device_attribute
935 				*attr, char *buf)
936 {
937 	struct hid_device *hdev = to_hid_device(dev);
938 	struct ps_device *ps_dev = hid_get_drvdata(hdev);
939 
940 	return sysfs_emit(buf, "0x%08x\n", ps_dev->hw_version);
941 }
942 
943 static DEVICE_ATTR_RO(hardware_version);
944 
945 static struct attribute *ps_device_attrs[] = {
946 	&dev_attr_firmware_version.attr,
947 	&dev_attr_hardware_version.attr,
948 	NULL
949 };
950 ATTRIBUTE_GROUPS(ps_device);
951 
dualsense_get_calibration_data(struct dualsense * ds)952 static int dualsense_get_calibration_data(struct dualsense *ds)
953 {
954 	struct hid_device *hdev = ds->base.hdev;
955 	short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
956 	short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
957 	short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
958 	short gyro_speed_plus, gyro_speed_minus;
959 	short acc_x_plus, acc_x_minus;
960 	short acc_y_plus, acc_y_minus;
961 	short acc_z_plus, acc_z_minus;
962 	int speed_2x;
963 	int range_2g;
964 	int ret = 0;
965 	int i;
966 	uint8_t *buf;
967 
968 	buf = kzalloc(DS_FEATURE_REPORT_CALIBRATION_SIZE, GFP_KERNEL);
969 	if (!buf)
970 		return -ENOMEM;
971 
972 	ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_CALIBRATION, buf,
973 			DS_FEATURE_REPORT_CALIBRATION_SIZE, true);
974 	if (ret) {
975 		hid_err(ds->base.hdev, "Failed to retrieve DualSense calibration info: %d\n", ret);
976 		goto err_free;
977 	}
978 
979 	gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
980 	gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
981 	gyro_roll_bias   = get_unaligned_le16(&buf[5]);
982 	gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
983 	gyro_pitch_minus = get_unaligned_le16(&buf[9]);
984 	gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
985 	gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
986 	gyro_roll_plus   = get_unaligned_le16(&buf[15]);
987 	gyro_roll_minus  = get_unaligned_le16(&buf[17]);
988 	gyro_speed_plus  = get_unaligned_le16(&buf[19]);
989 	gyro_speed_minus = get_unaligned_le16(&buf[21]);
990 	acc_x_plus       = get_unaligned_le16(&buf[23]);
991 	acc_x_minus      = get_unaligned_le16(&buf[25]);
992 	acc_y_plus       = get_unaligned_le16(&buf[27]);
993 	acc_y_minus      = get_unaligned_le16(&buf[29]);
994 	acc_z_plus       = get_unaligned_le16(&buf[31]);
995 	acc_z_minus      = get_unaligned_le16(&buf[33]);
996 
997 	/*
998 	 * Set gyroscope calibration and normalization parameters.
999 	 * Data values will be normalized to 1/DS_GYRO_RES_PER_DEG_S degree/s.
1000 	 */
1001 	speed_2x = (gyro_speed_plus + gyro_speed_minus);
1002 	ds->gyro_calib_data[0].abs_code = ABS_RX;
1003 	ds->gyro_calib_data[0].bias = 0;
1004 	ds->gyro_calib_data[0].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
1005 	ds->gyro_calib_data[0].sens_denom = abs(gyro_pitch_plus - gyro_pitch_bias) +
1006 			abs(gyro_pitch_minus - gyro_pitch_bias);
1007 
1008 	ds->gyro_calib_data[1].abs_code = ABS_RY;
1009 	ds->gyro_calib_data[1].bias = 0;
1010 	ds->gyro_calib_data[1].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
1011 	ds->gyro_calib_data[1].sens_denom = abs(gyro_yaw_plus - gyro_yaw_bias) +
1012 			abs(gyro_yaw_minus - gyro_yaw_bias);
1013 
1014 	ds->gyro_calib_data[2].abs_code = ABS_RZ;
1015 	ds->gyro_calib_data[2].bias = 0;
1016 	ds->gyro_calib_data[2].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
1017 	ds->gyro_calib_data[2].sens_denom = abs(gyro_roll_plus - gyro_roll_bias) +
1018 			abs(gyro_roll_minus - gyro_roll_bias);
1019 
1020 	/*
1021 	 * Sanity check gyro calibration data. This is needed to prevent crashes
1022 	 * during report handling of virtual, clone or broken devices not implementing
1023 	 * calibration data properly.
1024 	 */
1025 	for (i = 0; i < ARRAY_SIZE(ds->gyro_calib_data); i++) {
1026 		if (ds->gyro_calib_data[i].sens_denom == 0) {
1027 			hid_warn(hdev, "Invalid gyro calibration data for axis (%d), disabling calibration.",
1028 					ds->gyro_calib_data[i].abs_code);
1029 			ds->gyro_calib_data[i].bias = 0;
1030 			ds->gyro_calib_data[i].sens_numer = DS_GYRO_RANGE;
1031 			ds->gyro_calib_data[i].sens_denom = S16_MAX;
1032 		}
1033 	}
1034 
1035 	/*
1036 	 * Set accelerometer calibration and normalization parameters.
1037 	 * Data values will be normalized to 1/DS_ACC_RES_PER_G g.
1038 	 */
1039 	range_2g = acc_x_plus - acc_x_minus;
1040 	ds->accel_calib_data[0].abs_code = ABS_X;
1041 	ds->accel_calib_data[0].bias = acc_x_plus - range_2g / 2;
1042 	ds->accel_calib_data[0].sens_numer = 2*DS_ACC_RES_PER_G;
1043 	ds->accel_calib_data[0].sens_denom = range_2g;
1044 
1045 	range_2g = acc_y_plus - acc_y_minus;
1046 	ds->accel_calib_data[1].abs_code = ABS_Y;
1047 	ds->accel_calib_data[1].bias = acc_y_plus - range_2g / 2;
1048 	ds->accel_calib_data[1].sens_numer = 2*DS_ACC_RES_PER_G;
1049 	ds->accel_calib_data[1].sens_denom = range_2g;
1050 
1051 	range_2g = acc_z_plus - acc_z_minus;
1052 	ds->accel_calib_data[2].abs_code = ABS_Z;
1053 	ds->accel_calib_data[2].bias = acc_z_plus - range_2g / 2;
1054 	ds->accel_calib_data[2].sens_numer = 2*DS_ACC_RES_PER_G;
1055 	ds->accel_calib_data[2].sens_denom = range_2g;
1056 
1057 	/*
1058 	 * Sanity check accelerometer calibration data. This is needed to prevent crashes
1059 	 * during report handling of virtual, clone or broken devices not implementing calibration
1060 	 * data properly.
1061 	 */
1062 	for (i = 0; i < ARRAY_SIZE(ds->accel_calib_data); i++) {
1063 		if (ds->accel_calib_data[i].sens_denom == 0) {
1064 			hid_warn(hdev, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",
1065 					ds->accel_calib_data[i].abs_code);
1066 			ds->accel_calib_data[i].bias = 0;
1067 			ds->accel_calib_data[i].sens_numer = DS_ACC_RANGE;
1068 			ds->accel_calib_data[i].sens_denom = S16_MAX;
1069 		}
1070 	}
1071 
1072 err_free:
1073 	kfree(buf);
1074 	return ret;
1075 }
1076 
1077 
dualsense_get_firmware_info(struct dualsense * ds)1078 static int dualsense_get_firmware_info(struct dualsense *ds)
1079 {
1080 	uint8_t *buf;
1081 	int ret;
1082 
1083 	buf = kzalloc(DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE, GFP_KERNEL);
1084 	if (!buf)
1085 		return -ENOMEM;
1086 
1087 	ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_FIRMWARE_INFO, buf,
1088 			DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE, true);
1089 	if (ret) {
1090 		hid_err(ds->base.hdev, "Failed to retrieve DualSense firmware info: %d\n", ret);
1091 		goto err_free;
1092 	}
1093 
1094 	ds->base.hw_version = get_unaligned_le32(&buf[24]);
1095 	ds->base.fw_version = get_unaligned_le32(&buf[28]);
1096 
1097 	/* Update version is some kind of feature version. It is distinct from
1098 	 * the firmware version as there can be many different variations of a
1099 	 * controller over time with the same physical shell, but with different
1100 	 * PCBs and other internal changes. The update version (internal name) is
1101 	 * used as a means to detect what features are available and change behavior.
1102 	 * Note: the version is different between DualSense and DualSense Edge.
1103 	 */
1104 	ds->update_version = get_unaligned_le16(&buf[44]);
1105 
1106 err_free:
1107 	kfree(buf);
1108 	return ret;
1109 }
1110 
dualsense_get_mac_address(struct dualsense * ds)1111 static int dualsense_get_mac_address(struct dualsense *ds)
1112 {
1113 	uint8_t *buf;
1114 	int ret = 0;
1115 
1116 	buf = kzalloc(DS_FEATURE_REPORT_PAIRING_INFO_SIZE, GFP_KERNEL);
1117 	if (!buf)
1118 		return -ENOMEM;
1119 
1120 	ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_PAIRING_INFO, buf,
1121 			DS_FEATURE_REPORT_PAIRING_INFO_SIZE, true);
1122 	if (ret) {
1123 		hid_err(ds->base.hdev, "Failed to retrieve DualSense pairing info: %d\n", ret);
1124 		goto err_free;
1125 	}
1126 
1127 	memcpy(ds->base.mac_address, &buf[1], sizeof(ds->base.mac_address));
1128 
1129 err_free:
1130 	kfree(buf);
1131 	return ret;
1132 }
1133 
dualsense_lightbar_set_brightness(struct led_classdev * cdev,enum led_brightness brightness)1134 static int dualsense_lightbar_set_brightness(struct led_classdev *cdev,
1135 	enum led_brightness brightness)
1136 {
1137 	struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(cdev);
1138 	struct dualsense *ds = container_of(mc_cdev, struct dualsense, lightbar);
1139 	uint8_t red, green, blue;
1140 
1141 	led_mc_calc_color_components(mc_cdev, brightness);
1142 	red = mc_cdev->subled_info[0].brightness;
1143 	green = mc_cdev->subled_info[1].brightness;
1144 	blue = mc_cdev->subled_info[2].brightness;
1145 
1146 	dualsense_set_lightbar(ds, red, green, blue);
1147 	return 0;
1148 }
1149 
dualsense_player_led_get_brightness(struct led_classdev * led)1150 static enum led_brightness dualsense_player_led_get_brightness(struct led_classdev *led)
1151 {
1152 	struct hid_device *hdev = to_hid_device(led->dev->parent);
1153 	struct dualsense *ds = hid_get_drvdata(hdev);
1154 
1155 	return !!(ds->player_leds_state & BIT(led - ds->player_leds));
1156 }
1157 
dualsense_player_led_set_brightness(struct led_classdev * led,enum led_brightness value)1158 static int dualsense_player_led_set_brightness(struct led_classdev *led, enum led_brightness value)
1159 {
1160 	struct hid_device *hdev = to_hid_device(led->dev->parent);
1161 	struct dualsense *ds = hid_get_drvdata(hdev);
1162 	unsigned long flags;
1163 	unsigned int led_index;
1164 
1165 	spin_lock_irqsave(&ds->base.lock, flags);
1166 
1167 	led_index = led - ds->player_leds;
1168 	if (value == LED_OFF)
1169 		ds->player_leds_state &= ~BIT(led_index);
1170 	else
1171 		ds->player_leds_state |= BIT(led_index);
1172 
1173 	ds->update_player_leds = true;
1174 	spin_unlock_irqrestore(&ds->base.lock, flags);
1175 
1176 	dualsense_schedule_work(ds);
1177 
1178 	return 0;
1179 }
1180 
dualsense_init_output_report(struct dualsense * ds,struct dualsense_output_report * rp,void * buf)1181 static void dualsense_init_output_report(struct dualsense *ds, struct dualsense_output_report *rp,
1182 		void *buf)
1183 {
1184 	struct hid_device *hdev = ds->base.hdev;
1185 
1186 	if (hdev->bus == BUS_BLUETOOTH) {
1187 		struct dualsense_output_report_bt *bt = buf;
1188 
1189 		memset(bt, 0, sizeof(*bt));
1190 		bt->report_id = DS_OUTPUT_REPORT_BT;
1191 		bt->tag = DS_OUTPUT_TAG; /* Tag must be set. Exact meaning is unclear. */
1192 
1193 		/*
1194 		 * Highest 4-bit is a sequence number, which needs to be increased
1195 		 * every report. Lowest 4-bit is tag and can be zero for now.
1196 		 */
1197 		bt->seq_tag = (ds->output_seq << 4) | 0x0;
1198 		if (++ds->output_seq == 16)
1199 			ds->output_seq = 0;
1200 
1201 		rp->data = buf;
1202 		rp->len = sizeof(*bt);
1203 		rp->bt = bt;
1204 		rp->usb = NULL;
1205 		rp->common = &bt->common;
1206 	} else { /* USB */
1207 		struct dualsense_output_report_usb *usb = buf;
1208 
1209 		memset(usb, 0, sizeof(*usb));
1210 		usb->report_id = DS_OUTPUT_REPORT_USB;
1211 
1212 		rp->data = buf;
1213 		rp->len = sizeof(*usb);
1214 		rp->bt = NULL;
1215 		rp->usb = usb;
1216 		rp->common = &usb->common;
1217 	}
1218 }
1219 
dualsense_schedule_work(struct dualsense * ds)1220 static inline void dualsense_schedule_work(struct dualsense *ds)
1221 {
1222 	unsigned long flags;
1223 
1224 	spin_lock_irqsave(&ds->base.lock, flags);
1225 	if (ds->output_worker_initialized)
1226 		schedule_work(&ds->output_worker);
1227 	spin_unlock_irqrestore(&ds->base.lock, flags);
1228 }
1229 
1230 /*
1231  * Helper function to send DualSense output reports. Applies a CRC at the end of a report
1232  * for Bluetooth reports.
1233  */
dualsense_send_output_report(struct dualsense * ds,struct dualsense_output_report * report)1234 static void dualsense_send_output_report(struct dualsense *ds,
1235 		struct dualsense_output_report *report)
1236 {
1237 	struct hid_device *hdev = ds->base.hdev;
1238 
1239 	/* Bluetooth packets need to be signed with a CRC in the last 4 bytes. */
1240 	if (report->bt) {
1241 		uint32_t crc;
1242 		uint8_t seed = PS_OUTPUT_CRC32_SEED;
1243 
1244 		crc = crc32_le(0xFFFFFFFF, &seed, 1);
1245 		crc = ~crc32_le(crc, report->data, report->len - 4);
1246 
1247 		report->bt->crc32 = cpu_to_le32(crc);
1248 	}
1249 
1250 	hid_hw_output_report(hdev, report->data, report->len);
1251 }
1252 
dualsense_output_worker(struct work_struct * work)1253 static void dualsense_output_worker(struct work_struct *work)
1254 {
1255 	struct dualsense *ds = container_of(work, struct dualsense, output_worker);
1256 	struct dualsense_output_report report;
1257 	struct dualsense_output_report_common *common;
1258 	unsigned long flags;
1259 
1260 	dualsense_init_output_report(ds, &report, ds->output_report_dmabuf);
1261 	common = report.common;
1262 
1263 	spin_lock_irqsave(&ds->base.lock, flags);
1264 
1265 	if (ds->update_rumble) {
1266 		/* Select classic rumble style haptics and enable it. */
1267 		common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT;
1268 		if (ds->use_vibration_v2)
1269 			common->valid_flag2 |= DS_OUTPUT_VALID_FLAG2_COMPATIBLE_VIBRATION2;
1270 		else
1271 			common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION;
1272 		common->motor_left = ds->motor_left;
1273 		common->motor_right = ds->motor_right;
1274 		ds->update_rumble = false;
1275 	}
1276 
1277 	if (ds->update_lightbar) {
1278 		common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE;
1279 		common->lightbar_red = ds->lightbar_red;
1280 		common->lightbar_green = ds->lightbar_green;
1281 		common->lightbar_blue = ds->lightbar_blue;
1282 
1283 		ds->update_lightbar = false;
1284 	}
1285 
1286 	if (ds->update_player_leds) {
1287 		common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE;
1288 		common->player_leds = ds->player_leds_state;
1289 
1290 		ds->update_player_leds = false;
1291 	}
1292 
1293 	if (ds->update_mic_mute) {
1294 		common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE;
1295 		common->mute_button_led = ds->mic_muted;
1296 
1297 		if (ds->mic_muted) {
1298 			/* Disable microphone */
1299 			common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;
1300 			common->power_save_control |= DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;
1301 		} else {
1302 			/* Enable microphone */
1303 			common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;
1304 			common->power_save_control &= ~DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;
1305 		}
1306 
1307 		ds->update_mic_mute = false;
1308 	}
1309 
1310 	spin_unlock_irqrestore(&ds->base.lock, flags);
1311 
1312 	dualsense_send_output_report(ds, &report);
1313 }
1314 
dualsense_parse_report(struct ps_device * ps_dev,struct hid_report * report,u8 * data,int size)1315 static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *report,
1316 		u8 *data, int size)
1317 {
1318 	struct hid_device *hdev = ps_dev->hdev;
1319 	struct dualsense *ds = container_of(ps_dev, struct dualsense, base);
1320 	struct dualsense_input_report *ds_report;
1321 	uint8_t battery_data, battery_capacity, charging_status, value;
1322 	int battery_status;
1323 	uint32_t sensor_timestamp;
1324 	bool btn_mic_state;
1325 	unsigned long flags;
1326 	int i;
1327 
1328 	/*
1329 	 * DualSense in USB uses the full HID report for reportID 1, but
1330 	 * Bluetooth uses a minimal HID report for reportID 1 and reports
1331 	 * the full report using reportID 49.
1332 	 */
1333 	if (hdev->bus == BUS_USB && report->id == DS_INPUT_REPORT_USB &&
1334 			size == DS_INPUT_REPORT_USB_SIZE) {
1335 		ds_report = (struct dualsense_input_report *)&data[1];
1336 	} else if (hdev->bus == BUS_BLUETOOTH && report->id == DS_INPUT_REPORT_BT &&
1337 			size == DS_INPUT_REPORT_BT_SIZE) {
1338 		/* Last 4 bytes of input report contain crc32 */
1339 		uint32_t report_crc = get_unaligned_le32(&data[size - 4]);
1340 
1341 		if (!ps_check_crc32(PS_INPUT_CRC32_SEED, data, size - 4, report_crc)) {
1342 			hid_err(hdev, "DualSense input CRC's check failed\n");
1343 			return -EILSEQ;
1344 		}
1345 
1346 		ds_report = (struct dualsense_input_report *)&data[2];
1347 	} else {
1348 		hid_err(hdev, "Unhandled reportID=%d\n", report->id);
1349 		return -1;
1350 	}
1351 
1352 	input_report_abs(ds->gamepad, ABS_X,  ds_report->x);
1353 	input_report_abs(ds->gamepad, ABS_Y,  ds_report->y);
1354 	input_report_abs(ds->gamepad, ABS_RX, ds_report->rx);
1355 	input_report_abs(ds->gamepad, ABS_RY, ds_report->ry);
1356 	input_report_abs(ds->gamepad, ABS_Z,  ds_report->z);
1357 	input_report_abs(ds->gamepad, ABS_RZ, ds_report->rz);
1358 
1359 	value = ds_report->buttons[0] & DS_BUTTONS0_HAT_SWITCH;
1360 	if (value >= ARRAY_SIZE(ps_gamepad_hat_mapping))
1361 		value = 8; /* center */
1362 	input_report_abs(ds->gamepad, ABS_HAT0X, ps_gamepad_hat_mapping[value].x);
1363 	input_report_abs(ds->gamepad, ABS_HAT0Y, ps_gamepad_hat_mapping[value].y);
1364 
1365 	input_report_key(ds->gamepad, BTN_WEST,   ds_report->buttons[0] & DS_BUTTONS0_SQUARE);
1366 	input_report_key(ds->gamepad, BTN_SOUTH,  ds_report->buttons[0] & DS_BUTTONS0_CROSS);
1367 	input_report_key(ds->gamepad, BTN_EAST,   ds_report->buttons[0] & DS_BUTTONS0_CIRCLE);
1368 	input_report_key(ds->gamepad, BTN_NORTH,  ds_report->buttons[0] & DS_BUTTONS0_TRIANGLE);
1369 	input_report_key(ds->gamepad, BTN_TL,     ds_report->buttons[1] & DS_BUTTONS1_L1);
1370 	input_report_key(ds->gamepad, BTN_TR,     ds_report->buttons[1] & DS_BUTTONS1_R1);
1371 	input_report_key(ds->gamepad, BTN_TL2,    ds_report->buttons[1] & DS_BUTTONS1_L2);
1372 	input_report_key(ds->gamepad, BTN_TR2,    ds_report->buttons[1] & DS_BUTTONS1_R2);
1373 	input_report_key(ds->gamepad, BTN_SELECT, ds_report->buttons[1] & DS_BUTTONS1_CREATE);
1374 	input_report_key(ds->gamepad, BTN_START,  ds_report->buttons[1] & DS_BUTTONS1_OPTIONS);
1375 	input_report_key(ds->gamepad, BTN_THUMBL, ds_report->buttons[1] & DS_BUTTONS1_L3);
1376 	input_report_key(ds->gamepad, BTN_THUMBR, ds_report->buttons[1] & DS_BUTTONS1_R3);
1377 	input_report_key(ds->gamepad, BTN_MODE,   ds_report->buttons[2] & DS_BUTTONS2_PS_HOME);
1378 	input_sync(ds->gamepad);
1379 
1380 	/*
1381 	 * The DualSense has an internal microphone, which can be muted through a mute button
1382 	 * on the device. The driver is expected to read the button state and program the device
1383 	 * to mute/unmute audio at the hardware level.
1384 	 */
1385 	btn_mic_state = !!(ds_report->buttons[2] & DS_BUTTONS2_MIC_MUTE);
1386 	if (btn_mic_state && !ds->last_btn_mic_state) {
1387 		spin_lock_irqsave(&ps_dev->lock, flags);
1388 		ds->update_mic_mute = true;
1389 		ds->mic_muted = !ds->mic_muted; /* toggle */
1390 		spin_unlock_irqrestore(&ps_dev->lock, flags);
1391 
1392 		/* Schedule updating of microphone state at hardware level. */
1393 		dualsense_schedule_work(ds);
1394 	}
1395 	ds->last_btn_mic_state = btn_mic_state;
1396 
1397 	/* Parse and calibrate gyroscope data. */
1398 	for (i = 0; i < ARRAY_SIZE(ds_report->gyro); i++) {
1399 		int raw_data = (short)le16_to_cpu(ds_report->gyro[i]);
1400 		int calib_data = mult_frac(ds->gyro_calib_data[i].sens_numer,
1401 					   raw_data, ds->gyro_calib_data[i].sens_denom);
1402 
1403 		input_report_abs(ds->sensors, ds->gyro_calib_data[i].abs_code, calib_data);
1404 	}
1405 
1406 	/* Parse and calibrate accelerometer data. */
1407 	for (i = 0; i < ARRAY_SIZE(ds_report->accel); i++) {
1408 		int raw_data = (short)le16_to_cpu(ds_report->accel[i]);
1409 		int calib_data = mult_frac(ds->accel_calib_data[i].sens_numer,
1410 					   raw_data - ds->accel_calib_data[i].bias,
1411 					   ds->accel_calib_data[i].sens_denom);
1412 
1413 		input_report_abs(ds->sensors, ds->accel_calib_data[i].abs_code, calib_data);
1414 	}
1415 
1416 	/* Convert timestamp (in 0.33us unit) to timestamp_us */
1417 	sensor_timestamp = le32_to_cpu(ds_report->sensor_timestamp);
1418 	if (!ds->sensor_timestamp_initialized) {
1419 		ds->sensor_timestamp_us = DIV_ROUND_CLOSEST(sensor_timestamp, 3);
1420 		ds->sensor_timestamp_initialized = true;
1421 	} else {
1422 		uint32_t delta;
1423 
1424 		if (ds->prev_sensor_timestamp > sensor_timestamp)
1425 			delta = (U32_MAX - ds->prev_sensor_timestamp + sensor_timestamp + 1);
1426 		else
1427 			delta = sensor_timestamp - ds->prev_sensor_timestamp;
1428 		ds->sensor_timestamp_us += DIV_ROUND_CLOSEST(delta, 3);
1429 	}
1430 	ds->prev_sensor_timestamp = sensor_timestamp;
1431 	input_event(ds->sensors, EV_MSC, MSC_TIMESTAMP, ds->sensor_timestamp_us);
1432 	input_sync(ds->sensors);
1433 
1434 	for (i = 0; i < ARRAY_SIZE(ds_report->points); i++) {
1435 		struct dualsense_touch_point *point = &ds_report->points[i];
1436 		bool active = (point->contact & DS_TOUCH_POINT_INACTIVE) ? false : true;
1437 
1438 		input_mt_slot(ds->touchpad, i);
1439 		input_mt_report_slot_state(ds->touchpad, MT_TOOL_FINGER, active);
1440 
1441 		if (active) {
1442 			int x = (point->x_hi << 8) | point->x_lo;
1443 			int y = (point->y_hi << 4) | point->y_lo;
1444 
1445 			input_report_abs(ds->touchpad, ABS_MT_POSITION_X, x);
1446 			input_report_abs(ds->touchpad, ABS_MT_POSITION_Y, y);
1447 		}
1448 	}
1449 	input_mt_sync_frame(ds->touchpad);
1450 	input_report_key(ds->touchpad, BTN_LEFT, ds_report->buttons[2] & DS_BUTTONS2_TOUCHPAD);
1451 	input_sync(ds->touchpad);
1452 
1453 	battery_data = ds_report->status & DS_STATUS_BATTERY_CAPACITY;
1454 	charging_status = (ds_report->status & DS_STATUS_CHARGING) >> DS_STATUS_CHARGING_SHIFT;
1455 
1456 	switch (charging_status) {
1457 	case 0x0:
1458 		/*
1459 		 * Each unit of battery data corresponds to 10%
1460 		 * 0 = 0-9%, 1 = 10-19%, .. and 10 = 100%
1461 		 */
1462 		battery_capacity = min(battery_data * 10 + 5, 100);
1463 		battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1464 		break;
1465 	case 0x1:
1466 		battery_capacity = min(battery_data * 10 + 5, 100);
1467 		battery_status = POWER_SUPPLY_STATUS_CHARGING;
1468 		break;
1469 	case 0x2:
1470 		battery_capacity = 100;
1471 		battery_status = POWER_SUPPLY_STATUS_FULL;
1472 		break;
1473 	case 0xa: /* voltage or temperature out of range */
1474 	case 0xb: /* temperature error */
1475 		battery_capacity = 0;
1476 		battery_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1477 		break;
1478 	case 0xf: /* charging error */
1479 	default:
1480 		battery_capacity = 0;
1481 		battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1482 	}
1483 
1484 	spin_lock_irqsave(&ps_dev->lock, flags);
1485 	ps_dev->battery_capacity = battery_capacity;
1486 	ps_dev->battery_status = battery_status;
1487 	spin_unlock_irqrestore(&ps_dev->lock, flags);
1488 
1489 	return 0;
1490 }
1491 
dualsense_play_effect(struct input_dev * dev,void * data,struct ff_effect * effect)1492 static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
1493 {
1494 	struct hid_device *hdev = input_get_drvdata(dev);
1495 	struct dualsense *ds = hid_get_drvdata(hdev);
1496 	unsigned long flags;
1497 
1498 	if (effect->type != FF_RUMBLE)
1499 		return 0;
1500 
1501 	spin_lock_irqsave(&ds->base.lock, flags);
1502 	ds->update_rumble = true;
1503 	ds->motor_left = effect->u.rumble.strong_magnitude / 256;
1504 	ds->motor_right = effect->u.rumble.weak_magnitude / 256;
1505 	spin_unlock_irqrestore(&ds->base.lock, flags);
1506 
1507 	dualsense_schedule_work(ds);
1508 	return 0;
1509 }
1510 
dualsense_remove(struct ps_device * ps_dev)1511 static void dualsense_remove(struct ps_device *ps_dev)
1512 {
1513 	struct dualsense *ds = container_of(ps_dev, struct dualsense, base);
1514 	unsigned long flags;
1515 
1516 	spin_lock_irqsave(&ds->base.lock, flags);
1517 	ds->output_worker_initialized = false;
1518 	spin_unlock_irqrestore(&ds->base.lock, flags);
1519 
1520 	cancel_work_sync(&ds->output_worker);
1521 }
1522 
dualsense_reset_leds(struct dualsense * ds)1523 static int dualsense_reset_leds(struct dualsense *ds)
1524 {
1525 	struct dualsense_output_report report;
1526 	uint8_t *buf;
1527 
1528 	buf = kzalloc(sizeof(struct dualsense_output_report_bt), GFP_KERNEL);
1529 	if (!buf)
1530 		return -ENOMEM;
1531 
1532 	dualsense_init_output_report(ds, &report, buf);
1533 	/*
1534 	 * On Bluetooth the DualSense outputs an animation on the lightbar
1535 	 * during startup and maintains a color afterwards. We need to explicitly
1536 	 * reconfigure the lightbar before we can do any programming later on.
1537 	 * In USB the lightbar is not on by default, but redoing the setup there
1538 	 * doesn't hurt.
1539 	 */
1540 	report.common->valid_flag2 = DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE;
1541 	report.common->lightbar_setup = DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT; /* Fade light out. */
1542 	dualsense_send_output_report(ds, &report);
1543 
1544 	kfree(buf);
1545 	return 0;
1546 }
1547 
dualsense_set_lightbar(struct dualsense * ds,uint8_t red,uint8_t green,uint8_t blue)1548 static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue)
1549 {
1550 	unsigned long flags;
1551 
1552 	spin_lock_irqsave(&ds->base.lock, flags);
1553 	ds->update_lightbar = true;
1554 	ds->lightbar_red = red;
1555 	ds->lightbar_green = green;
1556 	ds->lightbar_blue = blue;
1557 	spin_unlock_irqrestore(&ds->base.lock, flags);
1558 
1559 	dualsense_schedule_work(ds);
1560 }
1561 
dualsense_set_player_leds(struct dualsense * ds)1562 static void dualsense_set_player_leds(struct dualsense *ds)
1563 {
1564 	/*
1565 	 * The DualSense controller has a row of 5 LEDs used for player ids.
1566 	 * Behavior on the PlayStation 5 console is to center the player id
1567 	 * across the LEDs, so e.g. player 1 would be "--x--" with x being 'on'.
1568 	 * Follow a similar mapping here.
1569 	 */
1570 	static const int player_ids[5] = {
1571 		BIT(2),
1572 		BIT(3) | BIT(1),
1573 		BIT(4) | BIT(2) | BIT(0),
1574 		BIT(4) | BIT(3) | BIT(1) | BIT(0),
1575 		BIT(4) | BIT(3) | BIT(2) | BIT(1) | BIT(0)
1576 	};
1577 
1578 	uint8_t player_id = ds->base.player_id % ARRAY_SIZE(player_ids);
1579 
1580 	ds->update_player_leds = true;
1581 	ds->player_leds_state = player_ids[player_id];
1582 	dualsense_schedule_work(ds);
1583 }
1584 
dualsense_create(struct hid_device * hdev)1585 static struct ps_device *dualsense_create(struct hid_device *hdev)
1586 {
1587 	struct dualsense *ds;
1588 	struct ps_device *ps_dev;
1589 	uint8_t max_output_report_size;
1590 	int i, ret;
1591 
1592 	static const struct ps_led_info player_leds_info[] = {
1593 		{ LED_FUNCTION_PLAYER1, "white", 1, dualsense_player_led_get_brightness,
1594 				dualsense_player_led_set_brightness },
1595 		{ LED_FUNCTION_PLAYER2, "white", 1, dualsense_player_led_get_brightness,
1596 				dualsense_player_led_set_brightness },
1597 		{ LED_FUNCTION_PLAYER3, "white", 1, dualsense_player_led_get_brightness,
1598 				dualsense_player_led_set_brightness },
1599 		{ LED_FUNCTION_PLAYER4, "white", 1, dualsense_player_led_get_brightness,
1600 				dualsense_player_led_set_brightness },
1601 		{ LED_FUNCTION_PLAYER5, "white", 1, dualsense_player_led_get_brightness,
1602 				dualsense_player_led_set_brightness }
1603 	};
1604 
1605 	ds = devm_kzalloc(&hdev->dev, sizeof(*ds), GFP_KERNEL);
1606 	if (!ds)
1607 		return ERR_PTR(-ENOMEM);
1608 
1609 	/*
1610 	 * Patch version to allow userspace to distinguish between
1611 	 * hid-generic vs hid-playstation axis and button mapping.
1612 	 */
1613 	hdev->version |= HID_PLAYSTATION_VERSION_PATCH;
1614 
1615 	ps_dev = &ds->base;
1616 	ps_dev->hdev = hdev;
1617 	spin_lock_init(&ps_dev->lock);
1618 	ps_dev->battery_capacity = 100; /* initial value until parse_report. */
1619 	ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1620 	ps_dev->parse_report = dualsense_parse_report;
1621 	ps_dev->remove = dualsense_remove;
1622 	INIT_WORK(&ds->output_worker, dualsense_output_worker);
1623 	ds->output_worker_initialized = true;
1624 	hid_set_drvdata(hdev, ds);
1625 
1626 	max_output_report_size = sizeof(struct dualsense_output_report_bt);
1627 	ds->output_report_dmabuf = devm_kzalloc(&hdev->dev, max_output_report_size, GFP_KERNEL);
1628 	if (!ds->output_report_dmabuf)
1629 		return ERR_PTR(-ENOMEM);
1630 
1631 	ret = dualsense_get_mac_address(ds);
1632 	if (ret) {
1633 		hid_err(hdev, "Failed to get MAC address from DualSense\n");
1634 		return ERR_PTR(ret);
1635 	}
1636 	snprintf(hdev->uniq, sizeof(hdev->uniq), "%pMR", ds->base.mac_address);
1637 
1638 	ret = dualsense_get_firmware_info(ds);
1639 	if (ret) {
1640 		hid_err(hdev, "Failed to get firmware info from DualSense\n");
1641 		return ERR_PTR(ret);
1642 	}
1643 
1644 	/* Original DualSense firmware simulated classic controller rumble through
1645 	 * its new haptics hardware. It felt different from classic rumble users
1646 	 * were used to. Since then new firmwares were introduced to change behavior
1647 	 * and make this new 'v2' behavior default on PlayStation and other platforms.
1648 	 * The original DualSense requires a new enough firmware as bundled with PS5
1649 	 * software released in 2021. DualSense edge supports it out of the box.
1650 	 * Both devices also support the old mode, but it is not really used.
1651 	 */
1652 	if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER) {
1653 		/* Feature version 2.21 introduced new vibration method. */
1654 		ds->use_vibration_v2 = ds->update_version >= DS_FEATURE_VERSION(2, 21);
1655 	} else if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) {
1656 		ds->use_vibration_v2 = true;
1657 	}
1658 
1659 	ret = ps_devices_list_add(ps_dev);
1660 	if (ret)
1661 		return ERR_PTR(ret);
1662 
1663 	ret = dualsense_get_calibration_data(ds);
1664 	if (ret) {
1665 		hid_err(hdev, "Failed to get calibration data from DualSense\n");
1666 		goto err;
1667 	}
1668 
1669 	ds->gamepad = ps_gamepad_create(hdev, dualsense_play_effect);
1670 	if (IS_ERR(ds->gamepad)) {
1671 		ret = PTR_ERR(ds->gamepad);
1672 		goto err;
1673 	}
1674 	/* Use gamepad input device name as primary device name for e.g. LEDs */
1675 	ps_dev->input_dev_name = dev_name(&ds->gamepad->dev);
1676 
1677 	ds->sensors = ps_sensors_create(hdev, DS_ACC_RANGE, DS_ACC_RES_PER_G,
1678 			DS_GYRO_RANGE, DS_GYRO_RES_PER_DEG_S);
1679 	if (IS_ERR(ds->sensors)) {
1680 		ret = PTR_ERR(ds->sensors);
1681 		goto err;
1682 	}
1683 
1684 	ds->touchpad = ps_touchpad_create(hdev, DS_TOUCHPAD_WIDTH, DS_TOUCHPAD_HEIGHT, 2);
1685 	if (IS_ERR(ds->touchpad)) {
1686 		ret = PTR_ERR(ds->touchpad);
1687 		goto err;
1688 	}
1689 
1690 	ret = ps_device_register_battery(ps_dev);
1691 	if (ret)
1692 		goto err;
1693 
1694 	/*
1695 	 * The hardware may have control over the LEDs (e.g. in Bluetooth on startup).
1696 	 * Reset the LEDs (lightbar, mute, player leds), so we can control them
1697 	 * from software.
1698 	 */
1699 	ret = dualsense_reset_leds(ds);
1700 	if (ret)
1701 		goto err;
1702 
1703 	ret = ps_lightbar_register(ps_dev, &ds->lightbar, dualsense_lightbar_set_brightness);
1704 	if (ret)
1705 		goto err;
1706 
1707 	/* Set default lightbar color. */
1708 	dualsense_set_lightbar(ds, 0, 0, 128); /* blue */
1709 
1710 	for (i = 0; i < ARRAY_SIZE(player_leds_info); i++) {
1711 		const struct ps_led_info *led_info = &player_leds_info[i];
1712 
1713 		ret = ps_led_register(ps_dev, &ds->player_leds[i], led_info);
1714 		if (ret < 0)
1715 			goto err;
1716 	}
1717 
1718 	ret = ps_device_set_player_id(ps_dev);
1719 	if (ret) {
1720 		hid_err(hdev, "Failed to assign player id for DualSense: %d\n", ret);
1721 		goto err;
1722 	}
1723 
1724 	/* Set player LEDs to our player id. */
1725 	dualsense_set_player_leds(ds);
1726 
1727 	/*
1728 	 * Reporting hardware and firmware is important as there are frequent updates, which
1729 	 * can change behavior.
1730 	 */
1731 	hid_info(hdev, "Registered DualSense controller hw_version=0x%08x fw_version=0x%08x\n",
1732 			ds->base.hw_version, ds->base.fw_version);
1733 
1734 	return &ds->base;
1735 
1736 err:
1737 	ps_devices_list_remove(ps_dev);
1738 	return ERR_PTR(ret);
1739 }
1740 
dualshock4_dongle_calibration_work(struct work_struct * work)1741 static void dualshock4_dongle_calibration_work(struct work_struct *work)
1742 {
1743 	struct dualshock4 *ds4 = container_of(work, struct dualshock4, dongle_hotplug_worker);
1744 	unsigned long flags;
1745 	enum dualshock4_dongle_state dongle_state;
1746 	int ret;
1747 
1748 	ret = dualshock4_get_calibration_data(ds4);
1749 	if (ret < 0) {
1750 		/* This call is very unlikely to fail for the dongle. When it
1751 		 * fails we are probably in a very bad state, so mark the
1752 		 * dongle as disabled. We will re-enable the dongle if a new
1753 		 * DS4 hotplug is detect from sony_raw_event as any issues
1754 		 * are likely resolved then (the dongle is quite stupid).
1755 		 */
1756 		hid_err(ds4->base.hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1757 		dongle_state = DONGLE_DISABLED;
1758 	} else {
1759 		hid_info(ds4->base.hdev, "DualShock 4 USB dongle: calibration completed\n");
1760 		dongle_state = DONGLE_CONNECTED;
1761 	}
1762 
1763 	spin_lock_irqsave(&ds4->base.lock, flags);
1764 	ds4->dongle_state = dongle_state;
1765 	spin_unlock_irqrestore(&ds4->base.lock, flags);
1766 }
1767 
dualshock4_get_calibration_data(struct dualshock4 * ds4)1768 static int dualshock4_get_calibration_data(struct dualshock4 *ds4)
1769 {
1770 	struct hid_device *hdev = ds4->base.hdev;
1771 	short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1772 	short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1773 	short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1774 	short gyro_speed_plus, gyro_speed_minus;
1775 	short acc_x_plus, acc_x_minus;
1776 	short acc_y_plus, acc_y_minus;
1777 	short acc_z_plus, acc_z_minus;
1778 	int speed_2x;
1779 	int range_2g;
1780 	int ret = 0;
1781 	int i;
1782 	uint8_t *buf;
1783 
1784 	if (ds4->base.hdev->bus == BUS_USB) {
1785 		int retries;
1786 
1787 		buf = kzalloc(DS4_FEATURE_REPORT_CALIBRATION_SIZE, GFP_KERNEL);
1788 		if (!buf) {
1789 			ret = -ENOMEM;
1790 			goto transfer_failed;
1791 		}
1792 
1793 		/* We should normally receive the feature report data we asked
1794 		 * for, but hidraw applications such as Steam can issue feature
1795 		 * reports as well. In particular for Dongle reconnects, Steam
1796 		 * and this function are competing resulting in often receiving
1797 		 * data for a different HID report, so retry a few times.
1798 		 */
1799 		for (retries = 0; retries < 3; retries++) {
1800 			ret = ps_get_report(hdev, DS4_FEATURE_REPORT_CALIBRATION, buf,
1801 					DS4_FEATURE_REPORT_CALIBRATION_SIZE, true);
1802 			if (ret) {
1803 				if (retries < 2) {
1804 					hid_warn(hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1805 					continue;
1806 				}
1807 
1808 				hid_warn(hdev, "Failed to retrieve DualShock4 calibration info: %d\n", ret);
1809 				ret = -EILSEQ;
1810 				goto transfer_failed;
1811 			} else {
1812 				break;
1813 			}
1814 		}
1815 	} else { /* Bluetooth */
1816 		buf = kzalloc(DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE, GFP_KERNEL);
1817 		if (!buf) {
1818 			ret = -ENOMEM;
1819 			goto transfer_failed;
1820 		}
1821 
1822 		ret = ps_get_report(hdev, DS4_FEATURE_REPORT_CALIBRATION_BT, buf,
1823 				DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE, true);
1824 
1825 		if (ret) {
1826 			hid_warn(hdev, "Failed to retrieve DualShock4 calibration info: %d\n", ret);
1827 			goto transfer_failed;
1828 		}
1829 	}
1830 
1831 	/* Transfer succeeded - parse the calibration data received. */
1832 	gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
1833 	gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
1834 	gyro_roll_bias   = get_unaligned_le16(&buf[5]);
1835 	if (ds4->base.hdev->bus == BUS_USB) {
1836 		gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1837 		gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1838 		gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
1839 		gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
1840 		gyro_roll_plus   = get_unaligned_le16(&buf[15]);
1841 		gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1842 	} else {
1843 		/* BT + Dongle */
1844 		gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1845 		gyro_yaw_plus    = get_unaligned_le16(&buf[9]);
1846 		gyro_roll_plus   = get_unaligned_le16(&buf[11]);
1847 		gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1848 		gyro_yaw_minus   = get_unaligned_le16(&buf[15]);
1849 		gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1850 	}
1851 	gyro_speed_plus  = get_unaligned_le16(&buf[19]);
1852 	gyro_speed_minus = get_unaligned_le16(&buf[21]);
1853 	acc_x_plus       = get_unaligned_le16(&buf[23]);
1854 	acc_x_minus      = get_unaligned_le16(&buf[25]);
1855 	acc_y_plus       = get_unaligned_le16(&buf[27]);
1856 	acc_y_minus      = get_unaligned_le16(&buf[29]);
1857 	acc_z_plus       = get_unaligned_le16(&buf[31]);
1858 	acc_z_minus      = get_unaligned_le16(&buf[33]);
1859 
1860 	/* Done parsing the buffer, so let's free it. */
1861 	kfree(buf);
1862 
1863 	/*
1864 	 * Set gyroscope calibration and normalization parameters.
1865 	 * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1866 	 */
1867 	speed_2x = (gyro_speed_plus + gyro_speed_minus);
1868 	ds4->gyro_calib_data[0].abs_code = ABS_RX;
1869 	ds4->gyro_calib_data[0].bias = 0;
1870 	ds4->gyro_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1871 	ds4->gyro_calib_data[0].sens_denom = abs(gyro_pitch_plus - gyro_pitch_bias) +
1872 			abs(gyro_pitch_minus - gyro_pitch_bias);
1873 
1874 	ds4->gyro_calib_data[1].abs_code = ABS_RY;
1875 	ds4->gyro_calib_data[1].bias = 0;
1876 	ds4->gyro_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1877 	ds4->gyro_calib_data[1].sens_denom = abs(gyro_yaw_plus - gyro_yaw_bias) +
1878 			abs(gyro_yaw_minus - gyro_yaw_bias);
1879 
1880 	ds4->gyro_calib_data[2].abs_code = ABS_RZ;
1881 	ds4->gyro_calib_data[2].bias = 0;
1882 	ds4->gyro_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1883 	ds4->gyro_calib_data[2].sens_denom = abs(gyro_roll_plus - gyro_roll_bias) +
1884 			abs(gyro_roll_minus - gyro_roll_bias);
1885 
1886 	/*
1887 	 * Set accelerometer calibration and normalization parameters.
1888 	 * Data values will be normalized to 1/DS4_ACC_RES_PER_G g.
1889 	 */
1890 	range_2g = acc_x_plus - acc_x_minus;
1891 	ds4->accel_calib_data[0].abs_code = ABS_X;
1892 	ds4->accel_calib_data[0].bias = acc_x_plus - range_2g / 2;
1893 	ds4->accel_calib_data[0].sens_numer = 2*DS4_ACC_RES_PER_G;
1894 	ds4->accel_calib_data[0].sens_denom = range_2g;
1895 
1896 	range_2g = acc_y_plus - acc_y_minus;
1897 	ds4->accel_calib_data[1].abs_code = ABS_Y;
1898 	ds4->accel_calib_data[1].bias = acc_y_plus - range_2g / 2;
1899 	ds4->accel_calib_data[1].sens_numer = 2*DS4_ACC_RES_PER_G;
1900 	ds4->accel_calib_data[1].sens_denom = range_2g;
1901 
1902 	range_2g = acc_z_plus - acc_z_minus;
1903 	ds4->accel_calib_data[2].abs_code = ABS_Z;
1904 	ds4->accel_calib_data[2].bias = acc_z_plus - range_2g / 2;
1905 	ds4->accel_calib_data[2].sens_numer = 2*DS4_ACC_RES_PER_G;
1906 	ds4->accel_calib_data[2].sens_denom = range_2g;
1907 
1908 transfer_failed:
1909 	/*
1910 	 * Sanity check gyro calibration data. This is needed to prevent crashes
1911 	 * during report handling of virtual, clone or broken devices not implementing
1912 	 * calibration data properly.
1913 	 */
1914 	for (i = 0; i < ARRAY_SIZE(ds4->gyro_calib_data); i++) {
1915 		if (ds4->gyro_calib_data[i].sens_denom == 0) {
1916 			ds4->gyro_calib_data[i].abs_code = ABS_RX + i;
1917 			hid_warn(hdev, "Invalid gyro calibration data for axis (%d), disabling calibration.",
1918 					ds4->gyro_calib_data[i].abs_code);
1919 			ds4->gyro_calib_data[i].bias = 0;
1920 			ds4->gyro_calib_data[i].sens_numer = DS4_GYRO_RANGE;
1921 			ds4->gyro_calib_data[i].sens_denom = S16_MAX;
1922 		}
1923 	}
1924 
1925 	/*
1926 	 * Sanity check accelerometer calibration data. This is needed to prevent crashes
1927 	 * during report handling of virtual, clone or broken devices not implementing calibration
1928 	 * data properly.
1929 	 */
1930 	for (i = 0; i < ARRAY_SIZE(ds4->accel_calib_data); i++) {
1931 		if (ds4->accel_calib_data[i].sens_denom == 0) {
1932 			ds4->accel_calib_data[i].abs_code = ABS_X + i;
1933 			hid_warn(hdev, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",
1934 					ds4->accel_calib_data[i].abs_code);
1935 			ds4->accel_calib_data[i].bias = 0;
1936 			ds4->accel_calib_data[i].sens_numer = DS4_ACC_RANGE;
1937 			ds4->accel_calib_data[i].sens_denom = S16_MAX;
1938 		}
1939 	}
1940 
1941 	return ret;
1942 }
1943 
dualshock4_get_firmware_info(struct dualshock4 * ds4)1944 static int dualshock4_get_firmware_info(struct dualshock4 *ds4)
1945 {
1946 	uint8_t *buf;
1947 	int ret;
1948 
1949 	buf = kzalloc(DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE, GFP_KERNEL);
1950 	if (!buf)
1951 		return -ENOMEM;
1952 
1953 	/* Note USB and BT support the same feature report, but this report
1954 	 * lacks CRC support, so must be disabled in ps_get_report.
1955 	 */
1956 	ret = ps_get_report(ds4->base.hdev, DS4_FEATURE_REPORT_FIRMWARE_INFO, buf,
1957 			DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE, false);
1958 	if (ret) {
1959 		hid_err(ds4->base.hdev, "Failed to retrieve DualShock4 firmware info: %d\n", ret);
1960 		goto err_free;
1961 	}
1962 
1963 	ds4->base.hw_version = get_unaligned_le16(&buf[35]);
1964 	ds4->base.fw_version = get_unaligned_le16(&buf[41]);
1965 
1966 err_free:
1967 	kfree(buf);
1968 	return ret;
1969 }
1970 
dualshock4_get_mac_address(struct dualshock4 * ds4)1971 static int dualshock4_get_mac_address(struct dualshock4 *ds4)
1972 {
1973 	struct hid_device *hdev = ds4->base.hdev;
1974 	uint8_t *buf;
1975 	int ret = 0;
1976 
1977 	if (hdev->bus == BUS_USB) {
1978 		buf = kzalloc(DS4_FEATURE_REPORT_PAIRING_INFO_SIZE, GFP_KERNEL);
1979 		if (!buf)
1980 			return -ENOMEM;
1981 
1982 		ret = ps_get_report(hdev, DS4_FEATURE_REPORT_PAIRING_INFO, buf,
1983 				DS4_FEATURE_REPORT_PAIRING_INFO_SIZE, false);
1984 		if (ret) {
1985 			hid_err(hdev, "Failed to retrieve DualShock4 pairing info: %d\n", ret);
1986 			goto err_free;
1987 		}
1988 
1989 		memcpy(ds4->base.mac_address, &buf[1], sizeof(ds4->base.mac_address));
1990 	} else {
1991 		/* Rely on HIDP for Bluetooth */
1992 		if (strlen(hdev->uniq) != 17)
1993 			return -EINVAL;
1994 
1995 		ret = sscanf(hdev->uniq, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1996 				&ds4->base.mac_address[5], &ds4->base.mac_address[4],
1997 				&ds4->base.mac_address[3], &ds4->base.mac_address[2],
1998 				&ds4->base.mac_address[1], &ds4->base.mac_address[0]);
1999 
2000 		if (ret != sizeof(ds4->base.mac_address))
2001 			return -EINVAL;
2002 
2003 		return 0;
2004 	}
2005 
2006 err_free:
2007 	kfree(buf);
2008 	return ret;
2009 }
2010 
dualshock4_led_get_brightness(struct led_classdev * led)2011 static enum led_brightness dualshock4_led_get_brightness(struct led_classdev *led)
2012 {
2013 	struct hid_device *hdev = to_hid_device(led->dev->parent);
2014 	struct dualshock4 *ds4 = hid_get_drvdata(hdev);
2015 	unsigned int led_index;
2016 
2017 	led_index = led - ds4->lightbar_leds;
2018 	switch (led_index) {
2019 	case 0:
2020 		return ds4->lightbar_red;
2021 	case 1:
2022 		return ds4->lightbar_green;
2023 	case 2:
2024 		return ds4->lightbar_blue;
2025 	case 3:
2026 		return ds4->lightbar_enabled;
2027 	}
2028 
2029 	return -1;
2030 }
2031 
dualshock4_led_set_blink(struct led_classdev * led,unsigned long * delay_on,unsigned long * delay_off)2032 static int dualshock4_led_set_blink(struct led_classdev *led, unsigned long *delay_on,
2033 		unsigned long *delay_off)
2034 {
2035 	struct hid_device *hdev = to_hid_device(led->dev->parent);
2036 	struct dualshock4 *ds4 = hid_get_drvdata(hdev);
2037 	unsigned long flags;
2038 
2039 	spin_lock_irqsave(&ds4->base.lock, flags);
2040 
2041 	if (!*delay_on && !*delay_off) {
2042 		/* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */
2043 		ds4->lightbar_blink_on = 50;
2044 		ds4->lightbar_blink_off = 50;
2045 	} else {
2046 		/* Blink delays in centiseconds. */
2047 		ds4->lightbar_blink_on = min_t(unsigned long, *delay_on/10, DS4_LIGHTBAR_MAX_BLINK);
2048 		ds4->lightbar_blink_off = min_t(unsigned long, *delay_off/10, DS4_LIGHTBAR_MAX_BLINK);
2049 	}
2050 
2051 	ds4->update_lightbar_blink = true;
2052 
2053 	spin_unlock_irqrestore(&ds4->base.lock, flags);
2054 
2055 	dualshock4_schedule_work(ds4);
2056 
2057 	/* Report scaled values back to LED subsystem */
2058 	*delay_on = ds4->lightbar_blink_on * 10;
2059 	*delay_off = ds4->lightbar_blink_off * 10;
2060 
2061 	return 0;
2062 }
2063 
dualshock4_led_set_brightness(struct led_classdev * led,enum led_brightness value)2064 static int dualshock4_led_set_brightness(struct led_classdev *led, enum led_brightness value)
2065 {
2066 	struct hid_device *hdev = to_hid_device(led->dev->parent);
2067 	struct dualshock4 *ds4 = hid_get_drvdata(hdev);
2068 	unsigned long flags;
2069 	unsigned int led_index;
2070 
2071 	spin_lock_irqsave(&ds4->base.lock, flags);
2072 
2073 	led_index = led - ds4->lightbar_leds;
2074 	switch (led_index) {
2075 	case 0:
2076 		ds4->lightbar_red = value;
2077 		break;
2078 	case 1:
2079 		ds4->lightbar_green = value;
2080 		break;
2081 	case 2:
2082 		ds4->lightbar_blue = value;
2083 		break;
2084 	case 3:
2085 		ds4->lightbar_enabled = !!value;
2086 
2087 		/* brightness = 0 also cancels blinking in Linux. */
2088 		if (!ds4->lightbar_enabled) {
2089 			ds4->lightbar_blink_off = 0;
2090 			ds4->lightbar_blink_on = 0;
2091 			ds4->update_lightbar_blink = true;
2092 		}
2093 	}
2094 
2095 	ds4->update_lightbar = true;
2096 
2097 	spin_unlock_irqrestore(&ds4->base.lock, flags);
2098 
2099 	dualshock4_schedule_work(ds4);
2100 
2101 	return 0;
2102 }
2103 
dualshock4_init_output_report(struct dualshock4 * ds4,struct dualshock4_output_report * rp,void * buf)2104 static void dualshock4_init_output_report(struct dualshock4 *ds4,
2105 		struct dualshock4_output_report *rp, void *buf)
2106 {
2107 	struct hid_device *hdev = ds4->base.hdev;
2108 
2109 	if (hdev->bus == BUS_BLUETOOTH) {
2110 		struct dualshock4_output_report_bt *bt = buf;
2111 
2112 		memset(bt, 0, sizeof(*bt));
2113 		bt->report_id = DS4_OUTPUT_REPORT_BT;
2114 
2115 		rp->data = buf;
2116 		rp->len = sizeof(*bt);
2117 		rp->bt = bt;
2118 		rp->usb = NULL;
2119 		rp->common = &bt->common;
2120 	} else { /* USB */
2121 		struct dualshock4_output_report_usb *usb = buf;
2122 
2123 		memset(usb, 0, sizeof(*usb));
2124 		usb->report_id = DS4_OUTPUT_REPORT_USB;
2125 
2126 		rp->data = buf;
2127 		rp->len = sizeof(*usb);
2128 		rp->bt = NULL;
2129 		rp->usb = usb;
2130 		rp->common = &usb->common;
2131 	}
2132 }
2133 
dualshock4_output_worker(struct work_struct * work)2134 static void dualshock4_output_worker(struct work_struct *work)
2135 {
2136 	struct dualshock4 *ds4 = container_of(work, struct dualshock4, output_worker);
2137 	struct dualshock4_output_report report;
2138 	struct dualshock4_output_report_common *common;
2139 	unsigned long flags;
2140 
2141 	dualshock4_init_output_report(ds4, &report, ds4->output_report_dmabuf);
2142 	common = report.common;
2143 
2144 	spin_lock_irqsave(&ds4->base.lock, flags);
2145 
2146 	/*
2147 	 * Some 3rd party gamepads expect updates to rumble and lightbar
2148 	 * together, and setting one may cancel the other.
2149 	 *
2150 	 * Let's maximise compatibility by always sending rumble and lightbar
2151 	 * updates together, even when only one has been scheduled, resulting
2152 	 * in:
2153 	 *
2154 	 *   ds4->valid_flag0 >= 0x03
2155 	 *
2156 	 * Hopefully this will maximise compatibility with third-party pads.
2157 	 *
2158 	 * Any further update bits, such as 0x04 for lightbar blinking, will
2159 	 * be or'd on top of this like before.
2160 	 */
2161 	if (ds4->update_rumble || ds4->update_lightbar) {
2162 		ds4->update_rumble = true; /* 0x01 */
2163 		ds4->update_lightbar = true; /* 0x02 */
2164 	}
2165 
2166 	if (ds4->update_rumble) {
2167 		/* Select classic rumble style haptics and enable it. */
2168 		common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_MOTOR;
2169 		common->motor_left = ds4->motor_left;
2170 		common->motor_right = ds4->motor_right;
2171 		ds4->update_rumble = false;
2172 	}
2173 
2174 	if (ds4->update_lightbar) {
2175 		common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_LED;
2176 		/* Comptabile behavior with hid-sony, which used a dummy global LED to
2177 		 * allow enabling/disabling the lightbar. The global LED maps to
2178 		 * lightbar_enabled.
2179 		 */
2180 		common->lightbar_red = ds4->lightbar_enabled ? ds4->lightbar_red : 0;
2181 		common->lightbar_green = ds4->lightbar_enabled ? ds4->lightbar_green : 0;
2182 		common->lightbar_blue = ds4->lightbar_enabled ? ds4->lightbar_blue : 0;
2183 		ds4->update_lightbar = false;
2184 	}
2185 
2186 	if (ds4->update_lightbar_blink) {
2187 		common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_LED_BLINK;
2188 		common->lightbar_blink_on = ds4->lightbar_blink_on;
2189 		common->lightbar_blink_off = ds4->lightbar_blink_off;
2190 		ds4->update_lightbar_blink = false;
2191 	}
2192 
2193 	spin_unlock_irqrestore(&ds4->base.lock, flags);
2194 
2195 	/* Bluetooth packets need additional flags as well as a CRC in the last 4 bytes. */
2196 	if (report.bt) {
2197 		uint32_t crc;
2198 		uint8_t seed = PS_OUTPUT_CRC32_SEED;
2199 
2200 		/* Hardware control flags need to set to let the device know
2201 		 * there is HID data as well as CRC.
2202 		 */
2203 		report.bt->hw_control = DS4_OUTPUT_HWCTL_HID | DS4_OUTPUT_HWCTL_CRC32;
2204 
2205 		if (ds4->update_bt_poll_interval) {
2206 			report.bt->hw_control |= ds4->bt_poll_interval;
2207 			ds4->update_bt_poll_interval = false;
2208 		}
2209 
2210 		crc = crc32_le(0xFFFFFFFF, &seed, 1);
2211 		crc = ~crc32_le(crc, report.data, report.len - 4);
2212 
2213 		report.bt->crc32 = cpu_to_le32(crc);
2214 	}
2215 
2216 	hid_hw_output_report(ds4->base.hdev, report.data, report.len);
2217 }
2218 
dualshock4_parse_report(struct ps_device * ps_dev,struct hid_report * report,u8 * data,int size)2219 static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *report,
2220 		u8 *data, int size)
2221 {
2222 	struct hid_device *hdev = ps_dev->hdev;
2223 	struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
2224 	struct dualshock4_input_report_common *ds4_report;
2225 	struct dualshock4_touch_report *touch_reports;
2226 	uint8_t battery_capacity, num_touch_reports, value;
2227 	int battery_status, i, j;
2228 	uint16_t sensor_timestamp;
2229 	unsigned long flags;
2230 	bool is_minimal = false;
2231 
2232 	/*
2233 	 * DualShock4 in USB uses the full HID report for reportID 1, but
2234 	 * Bluetooth uses a minimal HID report for reportID 1 and reports
2235 	 * the full report using reportID 17.
2236 	 */
2237 	if (hdev->bus == BUS_USB && report->id == DS4_INPUT_REPORT_USB &&
2238 			size == DS4_INPUT_REPORT_USB_SIZE) {
2239 		struct dualshock4_input_report_usb *usb = (struct dualshock4_input_report_usb *)data;
2240 
2241 		ds4_report = &usb->common;
2242 		num_touch_reports = usb->num_touch_reports;
2243 		touch_reports = usb->touch_reports;
2244 	} else if (hdev->bus == BUS_BLUETOOTH && report->id == DS4_INPUT_REPORT_BT &&
2245 			size == DS4_INPUT_REPORT_BT_SIZE) {
2246 		struct dualshock4_input_report_bt *bt = (struct dualshock4_input_report_bt *)data;
2247 		uint32_t report_crc = get_unaligned_le32(&bt->crc32);
2248 
2249 		/* Last 4 bytes of input report contains CRC. */
2250 		if (!ps_check_crc32(PS_INPUT_CRC32_SEED, data, size - 4, report_crc)) {
2251 			hid_err(hdev, "DualShock4 input CRC's check failed\n");
2252 			return -EILSEQ;
2253 		}
2254 
2255 		ds4_report = &bt->common;
2256 		num_touch_reports = bt->num_touch_reports;
2257 		touch_reports = bt->touch_reports;
2258 	} else if (hdev->bus == BUS_BLUETOOTH &&
2259 		   report->id == DS4_INPUT_REPORT_BT_MINIMAL &&
2260 			 size == DS4_INPUT_REPORT_BT_MINIMAL_SIZE) {
2261 		/* Some third-party pads never switch to the full 0x11 report.
2262 		 * The short 0x01 report is 10 bytes long:
2263 		 *   u8 report_id == 0x01
2264 		 *   u8 first_bytes_of_full_report[9]
2265 		 * So let's reuse the full report parser, and stop it after
2266 		 * parsing the buttons.
2267 		 */
2268 		ds4_report = (struct dualshock4_input_report_common *)&data[1];
2269 		is_minimal = true;
2270 	} else {
2271 		hid_err(hdev, "Unhandled reportID=%d\n", report->id);
2272 		return -1;
2273 	}
2274 
2275 	input_report_abs(ds4->gamepad, ABS_X,  ds4_report->x);
2276 	input_report_abs(ds4->gamepad, ABS_Y,  ds4_report->y);
2277 	input_report_abs(ds4->gamepad, ABS_RX, ds4_report->rx);
2278 	input_report_abs(ds4->gamepad, ABS_RY, ds4_report->ry);
2279 	input_report_abs(ds4->gamepad, ABS_Z,  ds4_report->z);
2280 	input_report_abs(ds4->gamepad, ABS_RZ, ds4_report->rz);
2281 
2282 	value = ds4_report->buttons[0] & DS_BUTTONS0_HAT_SWITCH;
2283 	if (value >= ARRAY_SIZE(ps_gamepad_hat_mapping))
2284 		value = 8; /* center */
2285 	input_report_abs(ds4->gamepad, ABS_HAT0X, ps_gamepad_hat_mapping[value].x);
2286 	input_report_abs(ds4->gamepad, ABS_HAT0Y, ps_gamepad_hat_mapping[value].y);
2287 
2288 	input_report_key(ds4->gamepad, BTN_WEST,   ds4_report->buttons[0] & DS_BUTTONS0_SQUARE);
2289 	input_report_key(ds4->gamepad, BTN_SOUTH,  ds4_report->buttons[0] & DS_BUTTONS0_CROSS);
2290 	input_report_key(ds4->gamepad, BTN_EAST,   ds4_report->buttons[0] & DS_BUTTONS0_CIRCLE);
2291 	input_report_key(ds4->gamepad, BTN_NORTH,  ds4_report->buttons[0] & DS_BUTTONS0_TRIANGLE);
2292 	input_report_key(ds4->gamepad, BTN_TL,     ds4_report->buttons[1] & DS_BUTTONS1_L1);
2293 	input_report_key(ds4->gamepad, BTN_TR,     ds4_report->buttons[1] & DS_BUTTONS1_R1);
2294 	input_report_key(ds4->gamepad, BTN_TL2,    ds4_report->buttons[1] & DS_BUTTONS1_L2);
2295 	input_report_key(ds4->gamepad, BTN_TR2,    ds4_report->buttons[1] & DS_BUTTONS1_R2);
2296 	input_report_key(ds4->gamepad, BTN_SELECT, ds4_report->buttons[1] & DS_BUTTONS1_CREATE);
2297 	input_report_key(ds4->gamepad, BTN_START,  ds4_report->buttons[1] & DS_BUTTONS1_OPTIONS);
2298 	input_report_key(ds4->gamepad, BTN_THUMBL, ds4_report->buttons[1] & DS_BUTTONS1_L3);
2299 	input_report_key(ds4->gamepad, BTN_THUMBR, ds4_report->buttons[1] & DS_BUTTONS1_R3);
2300 	input_report_key(ds4->gamepad, BTN_MODE,   ds4_report->buttons[2] & DS_BUTTONS2_PS_HOME);
2301 	input_sync(ds4->gamepad);
2302 
2303 	if (is_minimal)
2304 		return 0;
2305 
2306 	/* Parse and calibrate gyroscope data. */
2307 	for (i = 0; i < ARRAY_SIZE(ds4_report->gyro); i++) {
2308 		int raw_data = (short)le16_to_cpu(ds4_report->gyro[i]);
2309 		int calib_data = mult_frac(ds4->gyro_calib_data[i].sens_numer,
2310 					   raw_data, ds4->gyro_calib_data[i].sens_denom);
2311 
2312 		input_report_abs(ds4->sensors, ds4->gyro_calib_data[i].abs_code, calib_data);
2313 	}
2314 
2315 	/* Parse and calibrate accelerometer data. */
2316 	for (i = 0; i < ARRAY_SIZE(ds4_report->accel); i++) {
2317 		int raw_data = (short)le16_to_cpu(ds4_report->accel[i]);
2318 		int calib_data = mult_frac(ds4->accel_calib_data[i].sens_numer,
2319 					   raw_data - ds4->accel_calib_data[i].bias,
2320 					   ds4->accel_calib_data[i].sens_denom);
2321 
2322 		input_report_abs(ds4->sensors, ds4->accel_calib_data[i].abs_code, calib_data);
2323 	}
2324 
2325 	/* Convert timestamp (in 5.33us unit) to timestamp_us */
2326 	sensor_timestamp = le16_to_cpu(ds4_report->sensor_timestamp);
2327 	if (!ds4->sensor_timestamp_initialized) {
2328 		ds4->sensor_timestamp_us = DIV_ROUND_CLOSEST(sensor_timestamp*16, 3);
2329 		ds4->sensor_timestamp_initialized = true;
2330 	} else {
2331 		uint16_t delta;
2332 
2333 		if (ds4->prev_sensor_timestamp > sensor_timestamp)
2334 			delta = (U16_MAX - ds4->prev_sensor_timestamp + sensor_timestamp + 1);
2335 		else
2336 			delta = sensor_timestamp - ds4->prev_sensor_timestamp;
2337 		ds4->sensor_timestamp_us += DIV_ROUND_CLOSEST(delta*16, 3);
2338 	}
2339 	ds4->prev_sensor_timestamp = sensor_timestamp;
2340 	input_event(ds4->sensors, EV_MSC, MSC_TIMESTAMP, ds4->sensor_timestamp_us);
2341 	input_sync(ds4->sensors);
2342 
2343 	for (i = 0; i < num_touch_reports; i++) {
2344 		struct dualshock4_touch_report *touch_report = &touch_reports[i];
2345 
2346 		for (j = 0; j < ARRAY_SIZE(touch_report->points); j++) {
2347 			struct dualshock4_touch_point *point = &touch_report->points[j];
2348 			bool active = (point->contact & DS4_TOUCH_POINT_INACTIVE) ? false : true;
2349 
2350 			input_mt_slot(ds4->touchpad, j);
2351 			input_mt_report_slot_state(ds4->touchpad, MT_TOOL_FINGER, active);
2352 
2353 			if (active) {
2354 				int x = (point->x_hi << 8) | point->x_lo;
2355 				int y = (point->y_hi << 4) | point->y_lo;
2356 
2357 				input_report_abs(ds4->touchpad, ABS_MT_POSITION_X, x);
2358 				input_report_abs(ds4->touchpad, ABS_MT_POSITION_Y, y);
2359 			}
2360 		}
2361 		input_mt_sync_frame(ds4->touchpad);
2362 		input_sync(ds4->touchpad);
2363 	}
2364 	input_report_key(ds4->touchpad, BTN_LEFT, ds4_report->buttons[2] & DS_BUTTONS2_TOUCHPAD);
2365 
2366 	/*
2367 	 * Interpretation of the battery_capacity data depends on the cable state.
2368 	 * When no cable is connected (bit4 is 0):
2369 	 * - 0:10: percentage in units of 10%.
2370 	 * When a cable is plugged in:
2371 	 * - 0-10: percentage in units of 10%.
2372 	 * - 11: battery is full
2373 	 * - 14: not charging due to Voltage or temperature error
2374 	 * - 15: charge error
2375 	 */
2376 	if (ds4_report->status[0] & DS4_STATUS0_CABLE_STATE) {
2377 		uint8_t battery_data = ds4_report->status[0] & DS4_STATUS0_BATTERY_CAPACITY;
2378 
2379 		if (battery_data < 10) {
2380 			/* Take the mid-point for each battery capacity value,
2381 			 * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
2382 			 * This matches official platform behavior, which does
2383 			 * the same.
2384 			 */
2385 			battery_capacity = battery_data * 10 + 5;
2386 			battery_status = POWER_SUPPLY_STATUS_CHARGING;
2387 		} else if (battery_data == 10) {
2388 			battery_capacity = 100;
2389 			battery_status = POWER_SUPPLY_STATUS_CHARGING;
2390 		} else if (battery_data == DS4_BATTERY_STATUS_FULL) {
2391 			battery_capacity = 100;
2392 			battery_status = POWER_SUPPLY_STATUS_FULL;
2393 		} else { /* 14, 15 and undefined values */
2394 			battery_capacity = 0;
2395 			battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
2396 		}
2397 	} else {
2398 		uint8_t battery_data = ds4_report->status[0] & DS4_STATUS0_BATTERY_CAPACITY;
2399 
2400 		if (battery_data < 10)
2401 			battery_capacity = battery_data * 10 + 5;
2402 		else /* 10 */
2403 			battery_capacity = 100;
2404 
2405 		battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
2406 	}
2407 
2408 	spin_lock_irqsave(&ps_dev->lock, flags);
2409 	ps_dev->battery_capacity = battery_capacity;
2410 	ps_dev->battery_status = battery_status;
2411 	spin_unlock_irqrestore(&ps_dev->lock, flags);
2412 
2413 	return 0;
2414 }
2415 
dualshock4_dongle_parse_report(struct ps_device * ps_dev,struct hid_report * report,u8 * data,int size)2416 static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_report *report,
2417 		u8 *data, int size)
2418 {
2419 	struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
2420 	bool connected = false;
2421 
2422 	/* The dongle reports data using the main USB report (0x1) no matter whether a controller
2423 	 * is connected with mostly zeros. The report does contain dongle status, which we use to
2424 	 * determine if a controller is connected and if so we forward to the regular DualShock4
2425 	 * parsing code.
2426 	 */
2427 	if (data[0] == DS4_INPUT_REPORT_USB && size == DS4_INPUT_REPORT_USB_SIZE) {
2428 		struct dualshock4_input_report_common *ds4_report = (struct dualshock4_input_report_common *)&data[1];
2429 		unsigned long flags;
2430 
2431 		connected = ds4_report->status[1] & DS4_STATUS1_DONGLE_STATE ? false : true;
2432 
2433 		if (ds4->dongle_state == DONGLE_DISCONNECTED && connected) {
2434 			hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller connected\n");
2435 
2436 			dualshock4_set_default_lightbar_colors(ds4);
2437 
2438 			spin_lock_irqsave(&ps_dev->lock, flags);
2439 			ds4->dongle_state = DONGLE_CALIBRATING;
2440 			spin_unlock_irqrestore(&ps_dev->lock, flags);
2441 
2442 			schedule_work(&ds4->dongle_hotplug_worker);
2443 
2444 			/* Don't process the report since we don't have
2445 			 * calibration data, but let hidraw have it anyway.
2446 			 */
2447 			return 0;
2448 		} else if ((ds4->dongle_state == DONGLE_CONNECTED ||
2449 			    ds4->dongle_state == DONGLE_DISABLED) && !connected) {
2450 			hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller disconnected\n");
2451 
2452 			spin_lock_irqsave(&ps_dev->lock, flags);
2453 			ds4->dongle_state = DONGLE_DISCONNECTED;
2454 			spin_unlock_irqrestore(&ps_dev->lock, flags);
2455 
2456 			/* Return 0, so hidraw can get the report. */
2457 			return 0;
2458 		} else if (ds4->dongle_state == DONGLE_CALIBRATING ||
2459 			   ds4->dongle_state == DONGLE_DISABLED ||
2460 			   ds4->dongle_state == DONGLE_DISCONNECTED) {
2461 			/* Return 0, so hidraw can get the report. */
2462 			return 0;
2463 		}
2464 	}
2465 
2466 	if (connected)
2467 		return dualshock4_parse_report(ps_dev, report, data, size);
2468 
2469 	return 0;
2470 }
2471 
dualshock4_play_effect(struct input_dev * dev,void * data,struct ff_effect * effect)2472 static int dualshock4_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
2473 {
2474 	struct hid_device *hdev = input_get_drvdata(dev);
2475 	struct dualshock4 *ds4 = hid_get_drvdata(hdev);
2476 	unsigned long flags;
2477 
2478 	if (effect->type != FF_RUMBLE)
2479 		return 0;
2480 
2481 	spin_lock_irqsave(&ds4->base.lock, flags);
2482 	ds4->update_rumble = true;
2483 	ds4->motor_left = effect->u.rumble.strong_magnitude / 256;
2484 	ds4->motor_right = effect->u.rumble.weak_magnitude / 256;
2485 	spin_unlock_irqrestore(&ds4->base.lock, flags);
2486 
2487 	dualshock4_schedule_work(ds4);
2488 	return 0;
2489 }
2490 
dualshock4_remove(struct ps_device * ps_dev)2491 static void dualshock4_remove(struct ps_device *ps_dev)
2492 {
2493 	struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
2494 	unsigned long flags;
2495 
2496 	spin_lock_irqsave(&ds4->base.lock, flags);
2497 	ds4->output_worker_initialized = false;
2498 	spin_unlock_irqrestore(&ds4->base.lock, flags);
2499 
2500 	cancel_work_sync(&ds4->output_worker);
2501 
2502 	if (ps_dev->hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE)
2503 		cancel_work_sync(&ds4->dongle_hotplug_worker);
2504 }
2505 
dualshock4_schedule_work(struct dualshock4 * ds4)2506 static inline void dualshock4_schedule_work(struct dualshock4 *ds4)
2507 {
2508 	unsigned long flags;
2509 
2510 	spin_lock_irqsave(&ds4->base.lock, flags);
2511 	if (ds4->output_worker_initialized)
2512 		schedule_work(&ds4->output_worker);
2513 	spin_unlock_irqrestore(&ds4->base.lock, flags);
2514 }
2515 
dualshock4_set_bt_poll_interval(struct dualshock4 * ds4,uint8_t interval)2516 static void dualshock4_set_bt_poll_interval(struct dualshock4 *ds4, uint8_t interval)
2517 {
2518 	ds4->bt_poll_interval = interval;
2519 	ds4->update_bt_poll_interval = true;
2520 	dualshock4_schedule_work(ds4);
2521 }
2522 
2523 /* Set default lightbar color based on player. */
dualshock4_set_default_lightbar_colors(struct dualshock4 * ds4)2524 static void dualshock4_set_default_lightbar_colors(struct dualshock4 *ds4)
2525 {
2526 	/* Use same player colors as PlayStation 4.
2527 	 * Array of colors is in RGB.
2528 	 */
2529 	static const int player_colors[4][3] = {
2530 		{ 0x00, 0x00, 0x40 }, /* Blue */
2531 		{ 0x40, 0x00, 0x00 }, /* Red */
2532 		{ 0x00, 0x40, 0x00 }, /* Green */
2533 		{ 0x20, 0x00, 0x20 }  /* Pink */
2534 	};
2535 
2536 	uint8_t player_id = ds4->base.player_id % ARRAY_SIZE(player_colors);
2537 
2538 	ds4->lightbar_enabled = true;
2539 	ds4->lightbar_red = player_colors[player_id][0];
2540 	ds4->lightbar_green = player_colors[player_id][1];
2541 	ds4->lightbar_blue = player_colors[player_id][2];
2542 
2543 	ds4->update_lightbar = true;
2544 	dualshock4_schedule_work(ds4);
2545 }
2546 
dualshock4_create(struct hid_device * hdev)2547 static struct ps_device *dualshock4_create(struct hid_device *hdev)
2548 {
2549 	struct dualshock4 *ds4;
2550 	struct ps_device *ps_dev;
2551 	uint8_t max_output_report_size;
2552 	int i, ret;
2553 
2554 	/* The DualShock4 has an RGB lightbar, which the original hid-sony driver
2555 	 * exposed as a set of 4 LEDs for the 3 color channels and a global control.
2556 	 * Ideally this should have used the multi-color LED class, which didn't exist
2557 	 * yet. In addition the driver used a naming scheme not compliant with the LED
2558 	 * naming spec by using "<mac_address>:<color>", which contained many colons.
2559 	 * We use a more compliant by using "<device_name>:<color>" name now. Ideally
2560 	 * would have been "<device_name>:<color>:indicator", but that would break
2561 	 * existing applications (e.g. Android). Nothing matches against MAC address.
2562 	 */
2563 	static const struct ps_led_info lightbar_leds_info[] = {
2564 		{ NULL, "red", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },
2565 		{ NULL, "green", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },
2566 		{ NULL, "blue", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },
2567 		{ NULL, "global", 1, dualshock4_led_get_brightness, dualshock4_led_set_brightness,
2568 				dualshock4_led_set_blink },
2569 	};
2570 
2571 	ds4 = devm_kzalloc(&hdev->dev, sizeof(*ds4), GFP_KERNEL);
2572 	if (!ds4)
2573 		return ERR_PTR(-ENOMEM);
2574 
2575 	/*
2576 	 * Patch version to allow userspace to distinguish between
2577 	 * hid-generic vs hid-playstation axis and button mapping.
2578 	 */
2579 	hdev->version |= HID_PLAYSTATION_VERSION_PATCH;
2580 
2581 	ps_dev = &ds4->base;
2582 	ps_dev->hdev = hdev;
2583 	spin_lock_init(&ps_dev->lock);
2584 	ps_dev->battery_capacity = 100; /* initial value until parse_report. */
2585 	ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
2586 	ps_dev->parse_report = dualshock4_parse_report;
2587 	ps_dev->remove = dualshock4_remove;
2588 	INIT_WORK(&ds4->output_worker, dualshock4_output_worker);
2589 	ds4->output_worker_initialized = true;
2590 	hid_set_drvdata(hdev, ds4);
2591 
2592 	max_output_report_size = sizeof(struct dualshock4_output_report_bt);
2593 	ds4->output_report_dmabuf = devm_kzalloc(&hdev->dev, max_output_report_size, GFP_KERNEL);
2594 	if (!ds4->output_report_dmabuf)
2595 		return ERR_PTR(-ENOMEM);
2596 
2597 	if (hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) {
2598 		ds4->dongle_state = DONGLE_DISCONNECTED;
2599 		INIT_WORK(&ds4->dongle_hotplug_worker, dualshock4_dongle_calibration_work);
2600 
2601 		/* Override parse report for dongle specific hotplug handling. */
2602 		ps_dev->parse_report = dualshock4_dongle_parse_report;
2603 	}
2604 
2605 	ret = dualshock4_get_mac_address(ds4);
2606 	if (ret) {
2607 		hid_err(hdev, "Failed to get MAC address from DualShock4\n");
2608 		return ERR_PTR(ret);
2609 	}
2610 	snprintf(hdev->uniq, sizeof(hdev->uniq), "%pMR", ds4->base.mac_address);
2611 
2612 	ret = dualshock4_get_firmware_info(ds4);
2613 	if (ret) {
2614 		hid_warn(hdev, "Failed to get firmware info from DualShock4\n");
2615 		hid_warn(hdev, "HW/FW version data in sysfs will be invalid.\n");
2616 	}
2617 
2618 	ret = ps_devices_list_add(ps_dev);
2619 	if (ret)
2620 		return ERR_PTR(ret);
2621 
2622 	ret = dualshock4_get_calibration_data(ds4);
2623 	if (ret) {
2624 		hid_warn(hdev, "Failed to get calibration data from DualShock4\n");
2625 		hid_warn(hdev, "Gyroscope and accelerometer will be inaccurate.\n");
2626 	}
2627 
2628 	ds4->gamepad = ps_gamepad_create(hdev, dualshock4_play_effect);
2629 	if (IS_ERR(ds4->gamepad)) {
2630 		ret = PTR_ERR(ds4->gamepad);
2631 		goto err;
2632 	}
2633 
2634 	/* Use gamepad input device name as primary device name for e.g. LEDs */
2635 	ps_dev->input_dev_name = dev_name(&ds4->gamepad->dev);
2636 
2637 	ds4->sensors = ps_sensors_create(hdev, DS4_ACC_RANGE, DS4_ACC_RES_PER_G,
2638 			DS4_GYRO_RANGE, DS4_GYRO_RES_PER_DEG_S);
2639 	if (IS_ERR(ds4->sensors)) {
2640 		ret = PTR_ERR(ds4->sensors);
2641 		goto err;
2642 	}
2643 
2644 	ds4->touchpad = ps_touchpad_create(hdev, DS4_TOUCHPAD_WIDTH, DS4_TOUCHPAD_HEIGHT, 2);
2645 	if (IS_ERR(ds4->touchpad)) {
2646 		ret = PTR_ERR(ds4->touchpad);
2647 		goto err;
2648 	}
2649 
2650 	ret = ps_device_register_battery(ps_dev);
2651 	if (ret)
2652 		goto err;
2653 
2654 	for (i = 0; i < ARRAY_SIZE(lightbar_leds_info); i++) {
2655 		const struct ps_led_info *led_info = &lightbar_leds_info[i];
2656 
2657 		ret = ps_led_register(ps_dev, &ds4->lightbar_leds[i], led_info);
2658 		if (ret < 0)
2659 			goto err;
2660 	}
2661 
2662 	dualshock4_set_bt_poll_interval(ds4, DS4_BT_DEFAULT_POLL_INTERVAL_MS);
2663 
2664 	ret = ps_device_set_player_id(ps_dev);
2665 	if (ret) {
2666 		hid_err(hdev, "Failed to assign player id for DualShock4: %d\n", ret);
2667 		goto err;
2668 	}
2669 
2670 	dualshock4_set_default_lightbar_colors(ds4);
2671 
2672 	/*
2673 	 * Reporting hardware and firmware is important as there are frequent updates, which
2674 	 * can change behavior.
2675 	 */
2676 	hid_info(hdev, "Registered DualShock4 controller hw_version=0x%08x fw_version=0x%08x\n",
2677 			ds4->base.hw_version, ds4->base.fw_version);
2678 	return &ds4->base;
2679 
2680 err:
2681 	ps_devices_list_remove(ps_dev);
2682 	return ERR_PTR(ret);
2683 }
2684 
ps_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int size)2685 static int ps_raw_event(struct hid_device *hdev, struct hid_report *report,
2686 		u8 *data, int size)
2687 {
2688 	struct ps_device *dev = hid_get_drvdata(hdev);
2689 
2690 	if (dev && dev->parse_report)
2691 		return dev->parse_report(dev, report, data, size);
2692 
2693 	return 0;
2694 }
2695 
ps_probe(struct hid_device * hdev,const struct hid_device_id * id)2696 static int ps_probe(struct hid_device *hdev, const struct hid_device_id *id)
2697 {
2698 	struct ps_device *dev;
2699 	int ret;
2700 
2701 	ret = hid_parse(hdev);
2702 	if (ret) {
2703 		hid_err(hdev, "Parse failed\n");
2704 		return ret;
2705 	}
2706 
2707 	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
2708 	if (ret) {
2709 		hid_err(hdev, "Failed to start HID device\n");
2710 		return ret;
2711 	}
2712 
2713 	ret = hid_hw_open(hdev);
2714 	if (ret) {
2715 		hid_err(hdev, "Failed to open HID device\n");
2716 		goto err_stop;
2717 	}
2718 
2719 	if (id->driver_data == PS_TYPE_PS4_DUALSHOCK4) {
2720 		dev = dualshock4_create(hdev);
2721 		if (IS_ERR(dev)) {
2722 			hid_err(hdev, "Failed to create dualshock4.\n");
2723 			ret = PTR_ERR(dev);
2724 			goto err_close;
2725 		}
2726 	} else if (id->driver_data == PS_TYPE_PS5_DUALSENSE) {
2727 		dev = dualsense_create(hdev);
2728 		if (IS_ERR(dev)) {
2729 			hid_err(hdev, "Failed to create dualsense.\n");
2730 			ret = PTR_ERR(dev);
2731 			goto err_close;
2732 		}
2733 	}
2734 
2735 	return ret;
2736 
2737 err_close:
2738 	hid_hw_close(hdev);
2739 err_stop:
2740 	hid_hw_stop(hdev);
2741 	return ret;
2742 }
2743 
ps_remove(struct hid_device * hdev)2744 static void ps_remove(struct hid_device *hdev)
2745 {
2746 	struct ps_device *dev = hid_get_drvdata(hdev);
2747 
2748 	ps_devices_list_remove(dev);
2749 	ps_device_release_player_id(dev);
2750 
2751 	if (dev->remove)
2752 		dev->remove(dev);
2753 
2754 	hid_hw_close(hdev);
2755 	hid_hw_stop(hdev);
2756 }
2757 
2758 static const struct hid_device_id ps_devices[] = {
2759 	/* Sony DualShock 4 controllers for PS4 */
2760 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2761 		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },
2762 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER),
2763 		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },
2764 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2765 		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },
2766 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2),
2767 		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },
2768 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE),
2769 		.driver_data = PS_TYPE_PS4_DUALSHOCK4 },
2770 
2771 	/* Sony DualSense controllers for PS5 */
2772 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER),
2773 		.driver_data = PS_TYPE_PS5_DUALSENSE },
2774 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER),
2775 		.driver_data = PS_TYPE_PS5_DUALSENSE },
2776 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2),
2777 		.driver_data = PS_TYPE_PS5_DUALSENSE },
2778 	{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2),
2779 		.driver_data = PS_TYPE_PS5_DUALSENSE },
2780 	{ }
2781 };
2782 MODULE_DEVICE_TABLE(hid, ps_devices);
2783 
2784 static struct hid_driver ps_driver = {
2785 	.name		= "playstation",
2786 	.id_table	= ps_devices,
2787 	.probe		= ps_probe,
2788 	.remove		= ps_remove,
2789 	.raw_event	= ps_raw_event,
2790 	.driver = {
2791 		.dev_groups = ps_device_groups,
2792 	},
2793 };
2794 
ps_init(void)2795 static int __init ps_init(void)
2796 {
2797 	return hid_register_driver(&ps_driver);
2798 }
2799 
ps_exit(void)2800 static void __exit ps_exit(void)
2801 {
2802 	hid_unregister_driver(&ps_driver);
2803 	ida_destroy(&ps_player_id_allocator);
2804 }
2805 
2806 module_init(ps_init);
2807 module_exit(ps_exit);
2808 
2809 MODULE_AUTHOR("Sony Interactive Entertainment");
2810 MODULE_DESCRIPTION("HID Driver for PlayStation peripherals.");
2811 MODULE_LICENSE("GPL");
2812