HID: hid-asus: reset the backlight brightness level on resume
[linux-2.6-microblaze.git] / drivers / hid / hid-playstation.c
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  */
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
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
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
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
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
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
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. */
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
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
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
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. */
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
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
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
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
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
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
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
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
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
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
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
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
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  */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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. */
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
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
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
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
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
2727 static int __init ps_init(void)
2728 {
2729         return hid_register_driver(&ps_driver);
2730 }
2731
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");