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