1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * HID driver for Sony DualSense(TM) controller.
4 *
5 * Copyright (c) 2020 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/module.h>
15
16 #include <asm/unaligned.h>
17
18 #include "hid-ids.h"
19
20 /* List of connected playstation devices. */
21 static DEFINE_MUTEX(ps_devices_lock);
22 static LIST_HEAD(ps_devices_list);
23
24 static DEFINE_IDA(ps_player_id_allocator);
25
26 #define HID_PLAYSTATION_VERSION_PATCH 0x8000
27
28 /* Base class for playstation devices. */
29 struct ps_device {
30 struct list_head list;
31 struct hid_device *hdev;
32 spinlock_t lock;
33
34 uint32_t player_id;
35
36 struct power_supply_desc battery_desc;
37 struct power_supply *battery;
38 uint8_t battery_capacity;
39 int battery_status;
40
41 uint8_t mac_address[6]; /* Note: stored in little endian order. */
42 uint32_t hw_version;
43 uint32_t fw_version;
44
45 int (*parse_report)(struct ps_device *dev, struct hid_report *report, u8 *data, int size);
46 };
47
48 /* Calibration data for playstation motion sensors. */
49 struct ps_calibration_data {
50 int abs_code;
51 short bias;
52 int sens_numer;
53 int sens_denom;
54 };
55
56 /* Seed values for DualShock4 / DualSense CRC32 for different report types. */
57 #define PS_INPUT_CRC32_SEED 0xA1
58 #define PS_OUTPUT_CRC32_SEED 0xA2
59 #define PS_FEATURE_CRC32_SEED 0xA3
60
61 #define DS_INPUT_REPORT_USB 0x01
62 #define DS_INPUT_REPORT_USB_SIZE 64
63 #define DS_INPUT_REPORT_BT 0x31
64 #define DS_INPUT_REPORT_BT_SIZE 78
65 #define DS_OUTPUT_REPORT_USB 0x02
66 #define DS_OUTPUT_REPORT_USB_SIZE 63
67 #define DS_OUTPUT_REPORT_BT 0x31
68 #define DS_OUTPUT_REPORT_BT_SIZE 78
69
70 #define DS_FEATURE_REPORT_CALIBRATION 0x05
71 #define DS_FEATURE_REPORT_CALIBRATION_SIZE 41
72 #define DS_FEATURE_REPORT_PAIRING_INFO 0x09
73 #define DS_FEATURE_REPORT_PAIRING_INFO_SIZE 20
74 #define DS_FEATURE_REPORT_FIRMWARE_INFO 0x20
75 #define DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE 64
76
77 /* Button masks for DualSense input report. */
78 #define DS_BUTTONS0_HAT_SWITCH GENMASK(3, 0)
79 #define DS_BUTTONS0_SQUARE BIT(4)
80 #define DS_BUTTONS0_CROSS BIT(5)
81 #define DS_BUTTONS0_CIRCLE BIT(6)
82 #define DS_BUTTONS0_TRIANGLE BIT(7)
83 #define DS_BUTTONS1_L1 BIT(0)
84 #define DS_BUTTONS1_R1 BIT(1)
85 #define DS_BUTTONS1_L2 BIT(2)
86 #define DS_BUTTONS1_R2 BIT(3)
87 #define DS_BUTTONS1_CREATE BIT(4)
88 #define DS_BUTTONS1_OPTIONS BIT(5)
89 #define DS_BUTTONS1_L3 BIT(6)
90 #define DS_BUTTONS1_R3 BIT(7)
91 #define DS_BUTTONS2_PS_HOME BIT(0)
92 #define DS_BUTTONS2_TOUCHPAD BIT(1)
93 #define DS_BUTTONS2_MIC_MUTE BIT(2)
94
95 /* Status field of DualSense input report. */
96 #define DS_STATUS_BATTERY_CAPACITY GENMASK(3, 0)
97 #define DS_STATUS_CHARGING GENMASK(7, 4)
98 #define DS_STATUS_CHARGING_SHIFT 4
99
100 /*
101 * Status of a DualSense touch point contact.
102 * Contact IDs, with highest bit set are 'inactive'
103 * and any associated data is then invalid.
104 */
105 #define DS_TOUCH_POINT_INACTIVE BIT(7)
106
107 /* Magic value required in tag field of Bluetooth output report. */
108 #define DS_OUTPUT_TAG 0x10
109 /* Flags for DualSense output report. */
110 #define DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION BIT(0)
111 #define DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT BIT(1)
112 #define DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE BIT(0)
113 #define DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE BIT(1)
114 #define DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE BIT(2)
115 #define DS_OUTPUT_VALID_FLAG1_RELEASE_LEDS BIT(3)
116 #define DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE BIT(4)
117 #define DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE BIT(1)
118 #define DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE BIT(4)
119 #define DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT BIT(1)
120
121 /* DualSense hardware limits */
122 #define DS_ACC_RES_PER_G 8192
123 #define DS_ACC_RANGE (4*DS_ACC_RES_PER_G)
124 #define DS_GYRO_RES_PER_DEG_S 1024
125 #define DS_GYRO_RANGE (2048*DS_GYRO_RES_PER_DEG_S)
126 #define DS_TOUCHPAD_WIDTH 1920
127 #define DS_TOUCHPAD_HEIGHT 1080
128
129 struct dualsense {
130 struct ps_device base;
131 struct input_dev *gamepad;
132 struct input_dev *sensors;
133 struct input_dev *touchpad;
134
135 /* Calibration data for accelerometer and gyroscope. */
136 struct ps_calibration_data accel_calib_data[3];
137 struct ps_calibration_data gyro_calib_data[3];
138
139 /* Timestamp for sensor data */
140 bool sensor_timestamp_initialized;
141 uint32_t prev_sensor_timestamp;
142 uint32_t sensor_timestamp_us;
143
144 /* Compatible rumble state */
145 bool update_rumble;
146 uint8_t motor_left;
147 uint8_t motor_right;
148
149 /* RGB lightbar */
150 bool update_lightbar;
151 uint8_t lightbar_red;
152 uint8_t lightbar_green;
153 uint8_t lightbar_blue;
154
155 /* Microphone */
156 bool update_mic_mute;
157 bool mic_muted;
158 bool last_btn_mic_state;
159
160 /* Player leds */
161 bool update_player_leds;
162 uint8_t player_leds_state;
163 struct led_classdev player_leds[5];
164
165 struct work_struct output_worker;
166 void *output_report_dmabuf;
167 uint8_t output_seq; /* Sequence number for output report. */
168 };
169
170 struct dualsense_touch_point {
171 uint8_t contact;
172 uint8_t x_lo;
173 uint8_t x_hi:4, y_lo:4;
174 uint8_t y_hi;
175 } __packed;
176 static_assert(sizeof(struct dualsense_touch_point) == 4);
177
178 /* Main DualSense input report excluding any BT/USB specific headers. */
179 struct dualsense_input_report {
180 uint8_t x, y;
181 uint8_t rx, ry;
182 uint8_t z, rz;
183 uint8_t seq_number;
184 uint8_t buttons[4];
185 uint8_t reserved[4];
186
187 /* Motion sensors */
188 __le16 gyro[3]; /* x, y, z */
189 __le16 accel[3]; /* x, y, z */
190 __le32 sensor_timestamp;
191 uint8_t reserved2;
192
193 /* Touchpad */
194 struct dualsense_touch_point points[2];
195
196 uint8_t reserved3[12];
197 uint8_t status;
198 uint8_t reserved4[10];
199 } __packed;
200 /* Common input report size shared equals the size of the USB report minus 1 byte for ReportID. */
201 static_assert(sizeof(struct dualsense_input_report) == DS_INPUT_REPORT_USB_SIZE - 1);
202
203 /* Common data between DualSense BT/USB main output report. */
204 struct dualsense_output_report_common {
205 uint8_t valid_flag0;
206 uint8_t valid_flag1;
207
208 /* For DualShock 4 compatibility mode. */
209 uint8_t motor_right;
210 uint8_t motor_left;
211
212 /* Audio controls */
213 uint8_t reserved[4];
214 uint8_t mute_button_led;
215
216 uint8_t power_save_control;
217 uint8_t reserved2[28];
218
219 /* LEDs and lightbar */
220 uint8_t valid_flag2;
221 uint8_t reserved3[2];
222 uint8_t lightbar_setup;
223 uint8_t led_brightness;
224 uint8_t player_leds;
225 uint8_t lightbar_red;
226 uint8_t lightbar_green;
227 uint8_t lightbar_blue;
228 } __packed;
229 static_assert(sizeof(struct dualsense_output_report_common) == 47);
230
231 struct dualsense_output_report_bt {
232 uint8_t report_id; /* 0x31 */
233 uint8_t seq_tag;
234 uint8_t tag;
235 struct dualsense_output_report_common common;
236 uint8_t reserved[24];
237 __le32 crc32;
238 } __packed;
239 static_assert(sizeof(struct dualsense_output_report_bt) == DS_OUTPUT_REPORT_BT_SIZE);
240
241 struct dualsense_output_report_usb {
242 uint8_t report_id; /* 0x02 */
243 struct dualsense_output_report_common common;
244 uint8_t reserved[15];
245 } __packed;
246 static_assert(sizeof(struct dualsense_output_report_usb) == DS_OUTPUT_REPORT_USB_SIZE);
247
248 /*
249 * The DualSense has a main output report used to control most features. It is
250 * largely the same between Bluetooth and USB except for different headers and CRC.
251 * This structure hide the differences between the two to simplify sending output reports.
252 */
253 struct dualsense_output_report {
254 uint8_t *data; /* Start of data */
255 uint8_t len; /* Size of output report */
256
257 /* Points to Bluetooth data payload in case for a Bluetooth report else NULL. */
258 struct dualsense_output_report_bt *bt;
259 /* Points to USB data payload in case for a USB report else NULL. */
260 struct dualsense_output_report_usb *usb;
261 /* Points to common section of report, so past any headers. */
262 struct dualsense_output_report_common *common;
263 };
264
265 /*
266 * Common gamepad buttons across DualShock 3 / 4 and DualSense.
267 * Note: for device with a touchpad, touchpad button is not included
268 * as it will be part of the touchpad device.
269 */
270 static const int ps_gamepad_buttons[] = {
271 BTN_WEST, /* Square */
272 BTN_NORTH, /* Triangle */
273 BTN_EAST, /* Circle */
274 BTN_SOUTH, /* Cross */
275 BTN_TL, /* L1 */
276 BTN_TR, /* R1 */
277 BTN_TL2, /* L2 */
278 BTN_TR2, /* R2 */
279 BTN_SELECT, /* Create (PS5) / Share (PS4) */
280 BTN_START, /* Option */
281 BTN_THUMBL, /* L3 */
282 BTN_THUMBR, /* R3 */
283 BTN_MODE, /* PS Home */
284 };
285
286 static const struct {int x; int y; } ps_gamepad_hat_mapping[] = {
287 {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
288 {0, 0},
289 };
290
291 /*
292 * Add a new ps_device to ps_devices if it doesn't exist.
293 * Return error on duplicate device, which can happen if the same
294 * device is connected using both Bluetooth and USB.
295 */
ps_devices_list_add(struct ps_device * dev)296 static int ps_devices_list_add(struct ps_device *dev)
297 {
298 struct ps_device *entry;
299
300 mutex_lock(&ps_devices_lock);
301 list_for_each_entry(entry, &ps_devices_list, list) {
302 if (!memcmp(entry->mac_address, dev->mac_address, sizeof(dev->mac_address))) {
303 hid_err(dev->hdev, "Duplicate device found for MAC address %pMR.\n",
304 dev->mac_address);
305 mutex_unlock(&ps_devices_lock);
306 return -EEXIST;
307 }
308 }
309
310 list_add_tail(&dev->list, &ps_devices_list);
311 mutex_unlock(&ps_devices_lock);
312 return 0;
313 }
314
ps_devices_list_remove(struct ps_device * dev)315 static int ps_devices_list_remove(struct ps_device *dev)
316 {
317 mutex_lock(&ps_devices_lock);
318 list_del(&dev->list);
319 mutex_unlock(&ps_devices_lock);
320 return 0;
321 }
322
ps_device_set_player_id(struct ps_device * dev)323 static int ps_device_set_player_id(struct ps_device *dev)
324 {
325 int ret = ida_alloc(&ps_player_id_allocator, GFP_KERNEL);
326
327 if (ret < 0)
328 return ret;
329
330 dev->player_id = ret;
331 return 0;
332 }
333
ps_device_release_player_id(struct ps_device * dev)334 static void ps_device_release_player_id(struct ps_device *dev)
335 {
336 ida_free(&ps_player_id_allocator, dev->player_id);
337
338 dev->player_id = U32_MAX;
339 }
340
ps_allocate_input_dev(struct hid_device * hdev,const char * name_suffix)341 static struct input_dev *ps_allocate_input_dev(struct hid_device *hdev, const char *name_suffix)
342 {
343 struct input_dev *input_dev;
344
345 input_dev = devm_input_allocate_device(&hdev->dev);
346 if (!input_dev)
347 return ERR_PTR(-ENOMEM);
348
349 input_dev->id.bustype = hdev->bus;
350 input_dev->id.vendor = hdev->vendor;
351 input_dev->id.product = hdev->product;
352 input_dev->id.version = hdev->version;
353 input_dev->uniq = hdev->uniq;
354
355 if (name_suffix) {
356 input_dev->name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s %s", hdev->name,
357 name_suffix);
358 if (!input_dev->name)
359 return ERR_PTR(-ENOMEM);
360 } else {
361 input_dev->name = hdev->name;
362 }
363
364 input_set_drvdata(input_dev, hdev);
365
366 return input_dev;
367 }
368
369 static enum power_supply_property ps_power_supply_props[] = {
370 POWER_SUPPLY_PROP_STATUS,
371 POWER_SUPPLY_PROP_PRESENT,
372 POWER_SUPPLY_PROP_CAPACITY,
373 POWER_SUPPLY_PROP_SCOPE,
374 };
375
ps_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)376 static int ps_battery_get_property(struct power_supply *psy,
377 enum power_supply_property psp,
378 union power_supply_propval *val)
379 {
380 struct ps_device *dev = power_supply_get_drvdata(psy);
381 uint8_t battery_capacity;
382 int battery_status;
383 unsigned long flags;
384 int ret = 0;
385
386 spin_lock_irqsave(&dev->lock, flags);
387 battery_capacity = dev->battery_capacity;
388 battery_status = dev->battery_status;
389 spin_unlock_irqrestore(&dev->lock, flags);
390
391 switch (psp) {
392 case POWER_SUPPLY_PROP_STATUS:
393 val->intval = battery_status;
394 break;
395 case POWER_SUPPLY_PROP_PRESENT:
396 val->intval = 1;
397 break;
398 case POWER_SUPPLY_PROP_CAPACITY:
399 val->intval = battery_capacity;
400 break;
401 case POWER_SUPPLY_PROP_SCOPE:
402 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
403 break;
404 default:
405 ret = -EINVAL;
406 break;
407 }
408
409 return ret;
410 }
411
ps_device_register_battery(struct ps_device * dev)412 static int ps_device_register_battery(struct ps_device *dev)
413 {
414 struct power_supply *battery;
415 struct power_supply_config battery_cfg = { .drv_data = dev };
416 int ret;
417
418 dev->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
419 dev->battery_desc.properties = ps_power_supply_props;
420 dev->battery_desc.num_properties = ARRAY_SIZE(ps_power_supply_props);
421 dev->battery_desc.get_property = ps_battery_get_property;
422 dev->battery_desc.name = devm_kasprintf(&dev->hdev->dev, GFP_KERNEL,
423 "ps-controller-battery-%pMR", dev->mac_address);
424 if (!dev->battery_desc.name)
425 return -ENOMEM;
426
427 battery = devm_power_supply_register(&dev->hdev->dev, &dev->battery_desc, &battery_cfg);
428 if (IS_ERR(battery)) {
429 ret = PTR_ERR(battery);
430 hid_err(dev->hdev, "Unable to register battery device: %d\n", ret);
431 return ret;
432 }
433 dev->battery = battery;
434
435 ret = power_supply_powers(dev->battery, &dev->hdev->dev);
436 if (ret) {
437 hid_err(dev->hdev, "Unable to activate battery device: %d\n", ret);
438 return ret;
439 }
440
441 return 0;
442 }
443
444 /* 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)445 static bool ps_check_crc32(uint8_t seed, uint8_t *data, size_t len, uint32_t report_crc)
446 {
447 uint32_t crc;
448
449 crc = crc32_le(0xFFFFFFFF, &seed, 1);
450 crc = ~crc32_le(crc, data, len);
451
452 return crc == report_crc;
453 }
454
ps_gamepad_create(struct hid_device * hdev,int (* play_effect)(struct input_dev *,void *,struct ff_effect *))455 static struct input_dev *ps_gamepad_create(struct hid_device *hdev,
456 int (*play_effect)(struct input_dev *, void *, struct ff_effect *))
457 {
458 struct input_dev *gamepad;
459 unsigned int i;
460 int ret;
461
462 gamepad = ps_allocate_input_dev(hdev, NULL);
463 if (IS_ERR(gamepad))
464 return ERR_CAST(gamepad);
465
466 input_set_abs_params(gamepad, ABS_X, 0, 255, 0, 0);
467 input_set_abs_params(gamepad, ABS_Y, 0, 255, 0, 0);
468 input_set_abs_params(gamepad, ABS_Z, 0, 255, 0, 0);
469 input_set_abs_params(gamepad, ABS_RX, 0, 255, 0, 0);
470 input_set_abs_params(gamepad, ABS_RY, 0, 255, 0, 0);
471 input_set_abs_params(gamepad, ABS_RZ, 0, 255, 0, 0);
472
473 input_set_abs_params(gamepad, ABS_HAT0X, -1, 1, 0, 0);
474 input_set_abs_params(gamepad, ABS_HAT0Y, -1, 1, 0, 0);
475
476 for (i = 0; i < ARRAY_SIZE(ps_gamepad_buttons); i++)
477 input_set_capability(gamepad, EV_KEY, ps_gamepad_buttons[i]);
478
479 #if IS_ENABLED(CONFIG_PLAYSTATION_FF)
480 if (play_effect) {
481 input_set_capability(gamepad, EV_FF, FF_RUMBLE);
482 input_ff_create_memless(gamepad, NULL, play_effect);
483 }
484 #endif
485
486 ret = input_register_device(gamepad);
487 if (ret)
488 return ERR_PTR(ret);
489
490 return gamepad;
491 }
492
ps_get_report(struct hid_device * hdev,uint8_t report_id,uint8_t * buf,size_t size)493 static int ps_get_report(struct hid_device *hdev, uint8_t report_id, uint8_t *buf, size_t size)
494 {
495 int ret;
496
497 ret = hid_hw_raw_request(hdev, report_id, buf, size, HID_FEATURE_REPORT,
498 HID_REQ_GET_REPORT);
499 if (ret < 0) {
500 hid_err(hdev, "Failed to retrieve feature with reportID %d: %d\n", report_id, ret);
501 return ret;
502 }
503
504 if (ret != size) {
505 hid_err(hdev, "Invalid byte count transferred, expected %zu got %d\n", size, ret);
506 return -EINVAL;
507 }
508
509 if (buf[0] != report_id) {
510 hid_err(hdev, "Invalid reportID received, expected %d got %d\n", report_id, buf[0]);
511 return -EINVAL;
512 }
513
514 if (hdev->bus == BUS_BLUETOOTH) {
515 /* Last 4 bytes contains crc32. */
516 uint8_t crc_offset = size - 4;
517 uint32_t report_crc = get_unaligned_le32(&buf[crc_offset]);
518
519 if (!ps_check_crc32(PS_FEATURE_CRC32_SEED, buf, crc_offset, report_crc)) {
520 hid_err(hdev, "CRC check failed for reportID=%d\n", report_id);
521 return -EILSEQ;
522 }
523 }
524
525 return 0;
526 }
527
ps_sensors_create(struct hid_device * hdev,int accel_range,int accel_res,int gyro_range,int gyro_res)528 static struct input_dev *ps_sensors_create(struct hid_device *hdev, int accel_range, int accel_res,
529 int gyro_range, int gyro_res)
530 {
531 struct input_dev *sensors;
532 int ret;
533
534 sensors = ps_allocate_input_dev(hdev, "Motion Sensors");
535 if (IS_ERR(sensors))
536 return ERR_CAST(sensors);
537
538 __set_bit(INPUT_PROP_ACCELEROMETER, sensors->propbit);
539 __set_bit(EV_MSC, sensors->evbit);
540 __set_bit(MSC_TIMESTAMP, sensors->mscbit);
541
542 /* Accelerometer */
543 input_set_abs_params(sensors, ABS_X, -accel_range, accel_range, 16, 0);
544 input_set_abs_params(sensors, ABS_Y, -accel_range, accel_range, 16, 0);
545 input_set_abs_params(sensors, ABS_Z, -accel_range, accel_range, 16, 0);
546 input_abs_set_res(sensors, ABS_X, accel_res);
547 input_abs_set_res(sensors, ABS_Y, accel_res);
548 input_abs_set_res(sensors, ABS_Z, accel_res);
549
550 /* Gyroscope */
551 input_set_abs_params(sensors, ABS_RX, -gyro_range, gyro_range, 16, 0);
552 input_set_abs_params(sensors, ABS_RY, -gyro_range, gyro_range, 16, 0);
553 input_set_abs_params(sensors, ABS_RZ, -gyro_range, gyro_range, 16, 0);
554 input_abs_set_res(sensors, ABS_RX, gyro_res);
555 input_abs_set_res(sensors, ABS_RY, gyro_res);
556 input_abs_set_res(sensors, ABS_RZ, gyro_res);
557
558 ret = input_register_device(sensors);
559 if (ret)
560 return ERR_PTR(ret);
561
562 return sensors;
563 }
564
ps_touchpad_create(struct hid_device * hdev,int width,int height,unsigned int num_contacts)565 static struct input_dev *ps_touchpad_create(struct hid_device *hdev, int width, int height,
566 unsigned int num_contacts)
567 {
568 struct input_dev *touchpad;
569 int ret;
570
571 touchpad = ps_allocate_input_dev(hdev, "Touchpad");
572 if (IS_ERR(touchpad))
573 return ERR_CAST(touchpad);
574
575 /* Map button underneath touchpad to BTN_LEFT. */
576 input_set_capability(touchpad, EV_KEY, BTN_LEFT);
577 __set_bit(INPUT_PROP_BUTTONPAD, touchpad->propbit);
578
579 input_set_abs_params(touchpad, ABS_MT_POSITION_X, 0, width - 1, 0, 0);
580 input_set_abs_params(touchpad, ABS_MT_POSITION_Y, 0, height - 1, 0, 0);
581
582 ret = input_mt_init_slots(touchpad, num_contacts, INPUT_MT_POINTER);
583 if (ret)
584 return ERR_PTR(ret);
585
586 ret = input_register_device(touchpad);
587 if (ret)
588 return ERR_PTR(ret);
589
590 return touchpad;
591 }
592
firmware_version_show(struct device * dev,struct device_attribute * attr,char * buf)593 static ssize_t firmware_version_show(struct device *dev,
594 struct device_attribute
595 *attr, char *buf)
596 {
597 struct hid_device *hdev = to_hid_device(dev);
598 struct ps_device *ps_dev = hid_get_drvdata(hdev);
599
600 return sysfs_emit(buf, "0x%08x\n", ps_dev->fw_version);
601 }
602
603 static DEVICE_ATTR_RO(firmware_version);
604
hardware_version_show(struct device * dev,struct device_attribute * attr,char * buf)605 static ssize_t hardware_version_show(struct device *dev,
606 struct device_attribute
607 *attr, char *buf)
608 {
609 struct hid_device *hdev = to_hid_device(dev);
610 struct ps_device *ps_dev = hid_get_drvdata(hdev);
611
612 return sysfs_emit(buf, "0x%08x\n", ps_dev->hw_version);
613 }
614
615 static DEVICE_ATTR_RO(hardware_version);
616
617 static struct attribute *ps_device_attributes[] = {
618 &dev_attr_firmware_version.attr,
619 &dev_attr_hardware_version.attr,
620 NULL
621 };
622
623 static const struct attribute_group ps_device_attribute_group = {
624 .attrs = ps_device_attributes,
625 };
626
dualsense_get_calibration_data(struct dualsense * ds)627 static int dualsense_get_calibration_data(struct dualsense *ds)
628 {
629 short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
630 short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
631 short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
632 short gyro_speed_plus, gyro_speed_minus;
633 short acc_x_plus, acc_x_minus;
634 short acc_y_plus, acc_y_minus;
635 short acc_z_plus, acc_z_minus;
636 int speed_2x;
637 int range_2g;
638 int ret = 0;
639 uint8_t *buf;
640
641 buf = kzalloc(DS_FEATURE_REPORT_CALIBRATION_SIZE, GFP_KERNEL);
642 if (!buf)
643 return -ENOMEM;
644
645 ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_CALIBRATION, buf,
646 DS_FEATURE_REPORT_CALIBRATION_SIZE);
647 if (ret) {
648 hid_err(ds->base.hdev, "Failed to retrieve DualSense calibration info: %d\n", ret);
649 goto err_free;
650 }
651
652 gyro_pitch_bias = get_unaligned_le16(&buf[1]);
653 gyro_yaw_bias = get_unaligned_le16(&buf[3]);
654 gyro_roll_bias = get_unaligned_le16(&buf[5]);
655 gyro_pitch_plus = get_unaligned_le16(&buf[7]);
656 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
657 gyro_yaw_plus = get_unaligned_le16(&buf[11]);
658 gyro_yaw_minus = get_unaligned_le16(&buf[13]);
659 gyro_roll_plus = get_unaligned_le16(&buf[15]);
660 gyro_roll_minus = get_unaligned_le16(&buf[17]);
661 gyro_speed_plus = get_unaligned_le16(&buf[19]);
662 gyro_speed_minus = get_unaligned_le16(&buf[21]);
663 acc_x_plus = get_unaligned_le16(&buf[23]);
664 acc_x_minus = get_unaligned_le16(&buf[25]);
665 acc_y_plus = get_unaligned_le16(&buf[27]);
666 acc_y_minus = get_unaligned_le16(&buf[29]);
667 acc_z_plus = get_unaligned_le16(&buf[31]);
668 acc_z_minus = get_unaligned_le16(&buf[33]);
669
670 /*
671 * Set gyroscope calibration and normalization parameters.
672 * Data values will be normalized to 1/DS_GYRO_RES_PER_DEG_S degree/s.
673 */
674 speed_2x = (gyro_speed_plus + gyro_speed_minus);
675 ds->gyro_calib_data[0].abs_code = ABS_RX;
676 ds->gyro_calib_data[0].bias = gyro_pitch_bias;
677 ds->gyro_calib_data[0].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
678 ds->gyro_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
679
680 ds->gyro_calib_data[1].abs_code = ABS_RY;
681 ds->gyro_calib_data[1].bias = gyro_yaw_bias;
682 ds->gyro_calib_data[1].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
683 ds->gyro_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
684
685 ds->gyro_calib_data[2].abs_code = ABS_RZ;
686 ds->gyro_calib_data[2].bias = gyro_roll_bias;
687 ds->gyro_calib_data[2].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
688 ds->gyro_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
689
690 /*
691 * Set accelerometer calibration and normalization parameters.
692 * Data values will be normalized to 1/DS_ACC_RES_PER_G g.
693 */
694 range_2g = acc_x_plus - acc_x_minus;
695 ds->accel_calib_data[0].abs_code = ABS_X;
696 ds->accel_calib_data[0].bias = acc_x_plus - range_2g / 2;
697 ds->accel_calib_data[0].sens_numer = 2*DS_ACC_RES_PER_G;
698 ds->accel_calib_data[0].sens_denom = range_2g;
699
700 range_2g = acc_y_plus - acc_y_minus;
701 ds->accel_calib_data[1].abs_code = ABS_Y;
702 ds->accel_calib_data[1].bias = acc_y_plus - range_2g / 2;
703 ds->accel_calib_data[1].sens_numer = 2*DS_ACC_RES_PER_G;
704 ds->accel_calib_data[1].sens_denom = range_2g;
705
706 range_2g = acc_z_plus - acc_z_minus;
707 ds->accel_calib_data[2].abs_code = ABS_Z;
708 ds->accel_calib_data[2].bias = acc_z_plus - range_2g / 2;
709 ds->accel_calib_data[2].sens_numer = 2*DS_ACC_RES_PER_G;
710 ds->accel_calib_data[2].sens_denom = range_2g;
711
712 err_free:
713 kfree(buf);
714 return ret;
715 }
716
dualsense_get_firmware_info(struct dualsense * ds)717 static int dualsense_get_firmware_info(struct dualsense *ds)
718 {
719 uint8_t *buf;
720 int ret;
721
722 buf = kzalloc(DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE, GFP_KERNEL);
723 if (!buf)
724 return -ENOMEM;
725
726 ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_FIRMWARE_INFO, buf,
727 DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE);
728 if (ret) {
729 hid_err(ds->base.hdev, "Failed to retrieve DualSense firmware info: %d\n", ret);
730 goto err_free;
731 }
732
733 ds->base.hw_version = get_unaligned_le32(&buf[24]);
734 ds->base.fw_version = get_unaligned_le32(&buf[28]);
735
736 err_free:
737 kfree(buf);
738 return ret;
739 }
740
dualsense_get_mac_address(struct dualsense * ds)741 static int dualsense_get_mac_address(struct dualsense *ds)
742 {
743 uint8_t *buf;
744 int ret = 0;
745
746 buf = kzalloc(DS_FEATURE_REPORT_PAIRING_INFO_SIZE, GFP_KERNEL);
747 if (!buf)
748 return -ENOMEM;
749
750 ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_PAIRING_INFO, buf,
751 DS_FEATURE_REPORT_PAIRING_INFO_SIZE);
752 if (ret) {
753 hid_err(ds->base.hdev, "Failed to retrieve DualSense pairing info: %d\n", ret);
754 goto err_free;
755 }
756
757 memcpy(ds->base.mac_address, &buf[1], sizeof(ds->base.mac_address));
758
759 err_free:
760 kfree(buf);
761 return ret;
762 }
763
dualsense_init_output_report(struct dualsense * ds,struct dualsense_output_report * rp,void * buf)764 static void dualsense_init_output_report(struct dualsense *ds, struct dualsense_output_report *rp,
765 void *buf)
766 {
767 struct hid_device *hdev = ds->base.hdev;
768
769 if (hdev->bus == BUS_BLUETOOTH) {
770 struct dualsense_output_report_bt *bt = buf;
771
772 memset(bt, 0, sizeof(*bt));
773 bt->report_id = DS_OUTPUT_REPORT_BT;
774 bt->tag = DS_OUTPUT_TAG; /* Tag must be set. Exact meaning is unclear. */
775
776 /*
777 * Highest 4-bit is a sequence number, which needs to be increased
778 * every report. Lowest 4-bit is tag and can be zero for now.
779 */
780 bt->seq_tag = (ds->output_seq << 4) | 0x0;
781 if (++ds->output_seq == 16)
782 ds->output_seq = 0;
783
784 rp->data = buf;
785 rp->len = sizeof(*bt);
786 rp->bt = bt;
787 rp->usb = NULL;
788 rp->common = &bt->common;
789 } else { /* USB */
790 struct dualsense_output_report_usb *usb = buf;
791
792 memset(usb, 0, sizeof(*usb));
793 usb->report_id = DS_OUTPUT_REPORT_USB;
794
795 rp->data = buf;
796 rp->len = sizeof(*usb);
797 rp->bt = NULL;
798 rp->usb = usb;
799 rp->common = &usb->common;
800 }
801 }
802
803 /*
804 * Helper function to send DualSense output reports. Applies a CRC at the end of a report
805 * for Bluetooth reports.
806 */
dualsense_send_output_report(struct dualsense * ds,struct dualsense_output_report * report)807 static void dualsense_send_output_report(struct dualsense *ds,
808 struct dualsense_output_report *report)
809 {
810 struct hid_device *hdev = ds->base.hdev;
811
812 /* Bluetooth packets need to be signed with a CRC in the last 4 bytes. */
813 if (report->bt) {
814 uint32_t crc;
815 uint8_t seed = PS_OUTPUT_CRC32_SEED;
816
817 crc = crc32_le(0xFFFFFFFF, &seed, 1);
818 crc = ~crc32_le(crc, report->data, report->len - 4);
819
820 report->bt->crc32 = cpu_to_le32(crc);
821 }
822
823 hid_hw_output_report(hdev, report->data, report->len);
824 }
825
dualsense_output_worker(struct work_struct * work)826 static void dualsense_output_worker(struct work_struct *work)
827 {
828 struct dualsense *ds = container_of(work, struct dualsense, output_worker);
829 struct dualsense_output_report report;
830 struct dualsense_output_report_common *common;
831 unsigned long flags;
832
833 dualsense_init_output_report(ds, &report, ds->output_report_dmabuf);
834 common = report.common;
835
836 spin_lock_irqsave(&ds->base.lock, flags);
837
838 if (ds->update_rumble) {
839 /* Select classic rumble style haptics and enable it. */
840 common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT;
841 common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION;
842 common->motor_left = ds->motor_left;
843 common->motor_right = ds->motor_right;
844 ds->update_rumble = false;
845 }
846
847 if (ds->update_lightbar) {
848 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE;
849 common->lightbar_red = ds->lightbar_red;
850 common->lightbar_green = ds->lightbar_green;
851 common->lightbar_blue = ds->lightbar_blue;
852
853 ds->update_lightbar = false;
854 }
855
856 if (ds->update_player_leds) {
857 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE;
858 common->player_leds = ds->player_leds_state;
859
860 ds->update_player_leds = false;
861 }
862
863 if (ds->update_mic_mute) {
864 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE;
865 common->mute_button_led = ds->mic_muted;
866
867 if (ds->mic_muted) {
868 /* Disable microphone */
869 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;
870 common->power_save_control |= DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;
871 } else {
872 /* Enable microphone */
873 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;
874 common->power_save_control &= ~DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;
875 }
876
877 ds->update_mic_mute = false;
878 }
879
880 spin_unlock_irqrestore(&ds->base.lock, flags);
881
882 dualsense_send_output_report(ds, &report);
883 }
884
dualsense_parse_report(struct ps_device * ps_dev,struct hid_report * report,u8 * data,int size)885 static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *report,
886 u8 *data, int size)
887 {
888 struct hid_device *hdev = ps_dev->hdev;
889 struct dualsense *ds = container_of(ps_dev, struct dualsense, base);
890 struct dualsense_input_report *ds_report;
891 uint8_t battery_data, battery_capacity, charging_status, value;
892 int battery_status;
893 uint32_t sensor_timestamp;
894 bool btn_mic_state;
895 unsigned long flags;
896 int i;
897
898 /*
899 * DualSense in USB uses the full HID report for reportID 1, but
900 * Bluetooth uses a minimal HID report for reportID 1 and reports
901 * the full report using reportID 49.
902 */
903 if (hdev->bus == BUS_USB && report->id == DS_INPUT_REPORT_USB &&
904 size == DS_INPUT_REPORT_USB_SIZE) {
905 ds_report = (struct dualsense_input_report *)&data[1];
906 } else if (hdev->bus == BUS_BLUETOOTH && report->id == DS_INPUT_REPORT_BT &&
907 size == DS_INPUT_REPORT_BT_SIZE) {
908 /* Last 4 bytes of input report contain crc32 */
909 uint32_t report_crc = get_unaligned_le32(&data[size - 4]);
910
911 if (!ps_check_crc32(PS_INPUT_CRC32_SEED, data, size - 4, report_crc)) {
912 hid_err(hdev, "DualSense input CRC's check failed\n");
913 return -EILSEQ;
914 }
915
916 ds_report = (struct dualsense_input_report *)&data[2];
917 } else {
918 hid_err(hdev, "Unhandled reportID=%d\n", report->id);
919 return -1;
920 }
921
922 input_report_abs(ds->gamepad, ABS_X, ds_report->x);
923 input_report_abs(ds->gamepad, ABS_Y, ds_report->y);
924 input_report_abs(ds->gamepad, ABS_RX, ds_report->rx);
925 input_report_abs(ds->gamepad, ABS_RY, ds_report->ry);
926 input_report_abs(ds->gamepad, ABS_Z, ds_report->z);
927 input_report_abs(ds->gamepad, ABS_RZ, ds_report->rz);
928
929 value = ds_report->buttons[0] & DS_BUTTONS0_HAT_SWITCH;
930 if (value >= ARRAY_SIZE(ps_gamepad_hat_mapping))
931 value = 8; /* center */
932 input_report_abs(ds->gamepad, ABS_HAT0X, ps_gamepad_hat_mapping[value].x);
933 input_report_abs(ds->gamepad, ABS_HAT0Y, ps_gamepad_hat_mapping[value].y);
934
935 input_report_key(ds->gamepad, BTN_WEST, ds_report->buttons[0] & DS_BUTTONS0_SQUARE);
936 input_report_key(ds->gamepad, BTN_SOUTH, ds_report->buttons[0] & DS_BUTTONS0_CROSS);
937 input_report_key(ds->gamepad, BTN_EAST, ds_report->buttons[0] & DS_BUTTONS0_CIRCLE);
938 input_report_key(ds->gamepad, BTN_NORTH, ds_report->buttons[0] & DS_BUTTONS0_TRIANGLE);
939 input_report_key(ds->gamepad, BTN_TL, ds_report->buttons[1] & DS_BUTTONS1_L1);
940 input_report_key(ds->gamepad, BTN_TR, ds_report->buttons[1] & DS_BUTTONS1_R1);
941 input_report_key(ds->gamepad, BTN_TL2, ds_report->buttons[1] & DS_BUTTONS1_L2);
942 input_report_key(ds->gamepad, BTN_TR2, ds_report->buttons[1] & DS_BUTTONS1_R2);
943 input_report_key(ds->gamepad, BTN_SELECT, ds_report->buttons[1] & DS_BUTTONS1_CREATE);
944 input_report_key(ds->gamepad, BTN_START, ds_report->buttons[1] & DS_BUTTONS1_OPTIONS);
945 input_report_key(ds->gamepad, BTN_THUMBL, ds_report->buttons[1] & DS_BUTTONS1_L3);
946 input_report_key(ds->gamepad, BTN_THUMBR, ds_report->buttons[1] & DS_BUTTONS1_R3);
947 input_report_key(ds->gamepad, BTN_MODE, ds_report->buttons[2] & DS_BUTTONS2_PS_HOME);
948 input_sync(ds->gamepad);
949
950 /*
951 * The DualSense has an internal microphone, which can be muted through a mute button
952 * on the device. The driver is expected to read the button state and program the device
953 * to mute/unmute audio at the hardware level.
954 */
955 btn_mic_state = !!(ds_report->buttons[2] & DS_BUTTONS2_MIC_MUTE);
956 if (btn_mic_state && !ds->last_btn_mic_state) {
957 spin_lock_irqsave(&ps_dev->lock, flags);
958 ds->update_mic_mute = true;
959 ds->mic_muted = !ds->mic_muted; /* toggle */
960 spin_unlock_irqrestore(&ps_dev->lock, flags);
961
962 /* Schedule updating of microphone state at hardware level. */
963 schedule_work(&ds->output_worker);
964 }
965 ds->last_btn_mic_state = btn_mic_state;
966
967 /* Parse and calibrate gyroscope data. */
968 for (i = 0; i < ARRAY_SIZE(ds_report->gyro); i++) {
969 int raw_data = (short)le16_to_cpu(ds_report->gyro[i]);
970 int calib_data = mult_frac(ds->gyro_calib_data[i].sens_numer,
971 raw_data - ds->gyro_calib_data[i].bias,
972 ds->gyro_calib_data[i].sens_denom);
973
974 input_report_abs(ds->sensors, ds->gyro_calib_data[i].abs_code, calib_data);
975 }
976
977 /* Parse and calibrate accelerometer data. */
978 for (i = 0; i < ARRAY_SIZE(ds_report->accel); i++) {
979 int raw_data = (short)le16_to_cpu(ds_report->accel[i]);
980 int calib_data = mult_frac(ds->accel_calib_data[i].sens_numer,
981 raw_data - ds->accel_calib_data[i].bias,
982 ds->accel_calib_data[i].sens_denom);
983
984 input_report_abs(ds->sensors, ds->accel_calib_data[i].abs_code, calib_data);
985 }
986
987 /* Convert timestamp (in 0.33us unit) to timestamp_us */
988 sensor_timestamp = le32_to_cpu(ds_report->sensor_timestamp);
989 if (!ds->sensor_timestamp_initialized) {
990 ds->sensor_timestamp_us = DIV_ROUND_CLOSEST(sensor_timestamp, 3);
991 ds->sensor_timestamp_initialized = true;
992 } else {
993 uint32_t delta;
994
995 if (ds->prev_sensor_timestamp > sensor_timestamp)
996 delta = (U32_MAX - ds->prev_sensor_timestamp + sensor_timestamp + 1);
997 else
998 delta = sensor_timestamp - ds->prev_sensor_timestamp;
999 ds->sensor_timestamp_us += DIV_ROUND_CLOSEST(delta, 3);
1000 }
1001 ds->prev_sensor_timestamp = sensor_timestamp;
1002 input_event(ds->sensors, EV_MSC, MSC_TIMESTAMP, ds->sensor_timestamp_us);
1003 input_sync(ds->sensors);
1004
1005 for (i = 0; i < ARRAY_SIZE(ds_report->points); i++) {
1006 struct dualsense_touch_point *point = &ds_report->points[i];
1007 bool active = (point->contact & DS_TOUCH_POINT_INACTIVE) ? false : true;
1008
1009 input_mt_slot(ds->touchpad, i);
1010 input_mt_report_slot_state(ds->touchpad, MT_TOOL_FINGER, active);
1011
1012 if (active) {
1013 int x = (point->x_hi << 8) | point->x_lo;
1014 int y = (point->y_hi << 4) | point->y_lo;
1015
1016 input_report_abs(ds->touchpad, ABS_MT_POSITION_X, x);
1017 input_report_abs(ds->touchpad, ABS_MT_POSITION_Y, y);
1018 }
1019 }
1020 input_mt_sync_frame(ds->touchpad);
1021 input_report_key(ds->touchpad, BTN_LEFT, ds_report->buttons[2] & DS_BUTTONS2_TOUCHPAD);
1022 input_sync(ds->touchpad);
1023
1024 battery_data = ds_report->status & DS_STATUS_BATTERY_CAPACITY;
1025 charging_status = (ds_report->status & DS_STATUS_CHARGING) >> DS_STATUS_CHARGING_SHIFT;
1026
1027 switch (charging_status) {
1028 case 0x0:
1029 /*
1030 * Each unit of battery data corresponds to 10%
1031 * 0 = 0-9%, 1 = 10-19%, .. and 10 = 100%
1032 */
1033 battery_capacity = min(battery_data * 10 + 5, 100);
1034 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1035 break;
1036 case 0x1:
1037 battery_capacity = min(battery_data * 10 + 5, 100);
1038 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1039 break;
1040 case 0x2:
1041 battery_capacity = 100;
1042 battery_status = POWER_SUPPLY_STATUS_FULL;
1043 break;
1044 case 0xa: /* voltage or temperature out of range */
1045 case 0xb: /* temperature error */
1046 battery_capacity = 0;
1047 battery_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1048 break;
1049 case 0xf: /* charging error */
1050 default:
1051 battery_capacity = 0;
1052 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1053 }
1054
1055 spin_lock_irqsave(&ps_dev->lock, flags);
1056 ps_dev->battery_capacity = battery_capacity;
1057 ps_dev->battery_status = battery_status;
1058 spin_unlock_irqrestore(&ps_dev->lock, flags);
1059
1060 return 0;
1061 }
1062
dualsense_play_effect(struct input_dev * dev,void * data,struct ff_effect * effect)1063 static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
1064 {
1065 struct hid_device *hdev = input_get_drvdata(dev);
1066 struct dualsense *ds = hid_get_drvdata(hdev);
1067 unsigned long flags;
1068
1069 if (effect->type != FF_RUMBLE)
1070 return 0;
1071
1072 spin_lock_irqsave(&ds->base.lock, flags);
1073 ds->update_rumble = true;
1074 ds->motor_left = effect->u.rumble.strong_magnitude / 256;
1075 ds->motor_right = effect->u.rumble.weak_magnitude / 256;
1076 spin_unlock_irqrestore(&ds->base.lock, flags);
1077
1078 schedule_work(&ds->output_worker);
1079 return 0;
1080 }
1081
dualsense_reset_leds(struct dualsense * ds)1082 static int dualsense_reset_leds(struct dualsense *ds)
1083 {
1084 struct dualsense_output_report report;
1085 uint8_t *buf;
1086
1087 buf = kzalloc(sizeof(struct dualsense_output_report_bt), GFP_KERNEL);
1088 if (!buf)
1089 return -ENOMEM;
1090
1091 dualsense_init_output_report(ds, &report, buf);
1092 /*
1093 * On Bluetooth the DualSense outputs an animation on the lightbar
1094 * during startup and maintains a color afterwards. We need to explicitly
1095 * reconfigure the lightbar before we can do any programming later on.
1096 * In USB the lightbar is not on by default, but redoing the setup there
1097 * doesn't hurt.
1098 */
1099 report.common->valid_flag2 = DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE;
1100 report.common->lightbar_setup = DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT; /* Fade light out. */
1101 dualsense_send_output_report(ds, &report);
1102
1103 kfree(buf);
1104 return 0;
1105 }
1106
dualsense_set_lightbar(struct dualsense * ds,uint8_t red,uint8_t green,uint8_t blue)1107 static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue)
1108 {
1109 ds->update_lightbar = true;
1110 ds->lightbar_red = red;
1111 ds->lightbar_green = green;
1112 ds->lightbar_blue = blue;
1113
1114 schedule_work(&ds->output_worker);
1115 }
1116
dualsense_set_player_leds(struct dualsense * ds)1117 static void dualsense_set_player_leds(struct dualsense *ds)
1118 {
1119 /*
1120 * The DualSense controller has a row of 5 LEDs used for player ids.
1121 * Behavior on the PlayStation 5 console is to center the player id
1122 * across the LEDs, so e.g. player 1 would be "--x--" with x being 'on'.
1123 * Follow a similar mapping here.
1124 */
1125 static const int player_ids[5] = {
1126 BIT(2),
1127 BIT(3) | BIT(1),
1128 BIT(4) | BIT(2) | BIT(0),
1129 BIT(4) | BIT(3) | BIT(1) | BIT(0),
1130 BIT(4) | BIT(3) | BIT(2) | BIT(1) | BIT(0)
1131 };
1132
1133 uint8_t player_id = ds->base.player_id % ARRAY_SIZE(player_ids);
1134
1135 ds->update_player_leds = true;
1136 ds->player_leds_state = player_ids[player_id];
1137 schedule_work(&ds->output_worker);
1138 }
1139
dualsense_create(struct hid_device * hdev)1140 static struct ps_device *dualsense_create(struct hid_device *hdev)
1141 {
1142 struct dualsense *ds;
1143 struct ps_device *ps_dev;
1144 uint8_t max_output_report_size;
1145 int ret;
1146
1147 ds = devm_kzalloc(&hdev->dev, sizeof(*ds), GFP_KERNEL);
1148 if (!ds)
1149 return ERR_PTR(-ENOMEM);
1150
1151 /*
1152 * Patch version to allow userspace to distinguish between
1153 * hid-generic vs hid-playstation axis and button mapping.
1154 */
1155 hdev->version |= HID_PLAYSTATION_VERSION_PATCH;
1156
1157 ps_dev = &ds->base;
1158 ps_dev->hdev = hdev;
1159 spin_lock_init(&ps_dev->lock);
1160 ps_dev->battery_capacity = 100; /* initial value until parse_report. */
1161 ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1162 ps_dev->parse_report = dualsense_parse_report;
1163 INIT_WORK(&ds->output_worker, dualsense_output_worker);
1164 hid_set_drvdata(hdev, ds);
1165
1166 max_output_report_size = sizeof(struct dualsense_output_report_bt);
1167 ds->output_report_dmabuf = devm_kzalloc(&hdev->dev, max_output_report_size, GFP_KERNEL);
1168 if (!ds->output_report_dmabuf)
1169 return ERR_PTR(-ENOMEM);
1170
1171 ret = dualsense_get_mac_address(ds);
1172 if (ret) {
1173 hid_err(hdev, "Failed to get MAC address from DualSense\n");
1174 return ERR_PTR(ret);
1175 }
1176 snprintf(hdev->uniq, sizeof(hdev->uniq), "%pMR", ds->base.mac_address);
1177
1178 ret = dualsense_get_firmware_info(ds);
1179 if (ret) {
1180 hid_err(hdev, "Failed to get firmware info from DualSense\n");
1181 return ERR_PTR(ret);
1182 }
1183
1184 ret = ps_devices_list_add(ps_dev);
1185 if (ret)
1186 return ERR_PTR(ret);
1187
1188 ret = dualsense_get_calibration_data(ds);
1189 if (ret) {
1190 hid_err(hdev, "Failed to get calibration data from DualSense\n");
1191 goto err;
1192 }
1193
1194 ds->gamepad = ps_gamepad_create(hdev, dualsense_play_effect);
1195 if (IS_ERR(ds->gamepad)) {
1196 ret = PTR_ERR(ds->gamepad);
1197 goto err;
1198 }
1199
1200 ds->sensors = ps_sensors_create(hdev, DS_ACC_RANGE, DS_ACC_RES_PER_G,
1201 DS_GYRO_RANGE, DS_GYRO_RES_PER_DEG_S);
1202 if (IS_ERR(ds->sensors)) {
1203 ret = PTR_ERR(ds->sensors);
1204 goto err;
1205 }
1206
1207 ds->touchpad = ps_touchpad_create(hdev, DS_TOUCHPAD_WIDTH, DS_TOUCHPAD_HEIGHT, 2);
1208 if (IS_ERR(ds->touchpad)) {
1209 ret = PTR_ERR(ds->touchpad);
1210 goto err;
1211 }
1212
1213 ret = ps_device_register_battery(ps_dev);
1214 if (ret)
1215 goto err;
1216
1217 /*
1218 * The hardware may have control over the LEDs (e.g. in Bluetooth on startup).
1219 * Reset the LEDs (lightbar, mute, player leds), so we can control them
1220 * from software.
1221 */
1222 ret = dualsense_reset_leds(ds);
1223 if (ret)
1224 goto err;
1225
1226 dualsense_set_lightbar(ds, 0, 0, 128); /* blue */
1227
1228 ret = ps_device_set_player_id(ps_dev);
1229 if (ret) {
1230 hid_err(hdev, "Failed to assign player id for DualSense: %d\n", ret);
1231 goto err;
1232 }
1233
1234 /* Set player LEDs to our player id. */
1235 dualsense_set_player_leds(ds);
1236
1237 /*
1238 * Reporting hardware and firmware is important as there are frequent updates, which
1239 * can change behavior.
1240 */
1241 hid_info(hdev, "Registered DualSense controller hw_version=0x%08x fw_version=0x%08x\n",
1242 ds->base.hw_version, ds->base.fw_version);
1243
1244 return &ds->base;
1245
1246 err:
1247 ps_devices_list_remove(ps_dev);
1248 return ERR_PTR(ret);
1249 }
1250
ps_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int size)1251 static int ps_raw_event(struct hid_device *hdev, struct hid_report *report,
1252 u8 *data, int size)
1253 {
1254 struct ps_device *dev = hid_get_drvdata(hdev);
1255
1256 if (dev && dev->parse_report)
1257 return dev->parse_report(dev, report, data, size);
1258
1259 return 0;
1260 }
1261
ps_probe(struct hid_device * hdev,const struct hid_device_id * id)1262 static int ps_probe(struct hid_device *hdev, const struct hid_device_id *id)
1263 {
1264 struct ps_device *dev;
1265 int ret;
1266
1267 ret = hid_parse(hdev);
1268 if (ret) {
1269 hid_err(hdev, "Parse failed\n");
1270 return ret;
1271 }
1272
1273 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1274 if (ret) {
1275 hid_err(hdev, "Failed to start HID device\n");
1276 return ret;
1277 }
1278
1279 ret = hid_hw_open(hdev);
1280 if (ret) {
1281 hid_err(hdev, "Failed to open HID device\n");
1282 goto err_stop;
1283 }
1284
1285 if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER) {
1286 dev = dualsense_create(hdev);
1287 if (IS_ERR(dev)) {
1288 hid_err(hdev, "Failed to create dualsense.\n");
1289 ret = PTR_ERR(dev);
1290 goto err_close;
1291 }
1292 }
1293
1294 ret = devm_device_add_group(&hdev->dev, &ps_device_attribute_group);
1295 if (ret) {
1296 hid_err(hdev, "Failed to register sysfs nodes.\n");
1297 goto err_close;
1298 }
1299
1300 return ret;
1301
1302 err_close:
1303 hid_hw_close(hdev);
1304 err_stop:
1305 hid_hw_stop(hdev);
1306 return ret;
1307 }
1308
ps_remove(struct hid_device * hdev)1309 static void ps_remove(struct hid_device *hdev)
1310 {
1311 struct ps_device *dev = hid_get_drvdata(hdev);
1312
1313 ps_devices_list_remove(dev);
1314 ps_device_release_player_id(dev);
1315
1316 hid_hw_close(hdev);
1317 hid_hw_stop(hdev);
1318 }
1319
1320 static const struct hid_device_id ps_devices[] = {
1321 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER) },
1322 { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER) },
1323 { }
1324 };
1325 MODULE_DEVICE_TABLE(hid, ps_devices);
1326
1327 static struct hid_driver ps_driver = {
1328 .name = "playstation",
1329 .id_table = ps_devices,
1330 .probe = ps_probe,
1331 .remove = ps_remove,
1332 .raw_event = ps_raw_event,
1333 };
1334
ps_init(void)1335 static int __init ps_init(void)
1336 {
1337 return hid_register_driver(&ps_driver);
1338 }
1339
ps_exit(void)1340 static void __exit ps_exit(void)
1341 {
1342 hid_unregister_driver(&ps_driver);
1343 ida_destroy(&ps_player_id_allocator);
1344 }
1345
1346 module_init(ps_init);
1347 module_exit(ps_exit);
1348
1349 MODULE_AUTHOR("Sony Interactive Entertainment");
1350 MODULE_DESCRIPTION("HID Driver for PlayStation peripherals.");
1351 MODULE_LICENSE("GPL");
1352