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 = gyro_pitch_bias;
 997         ds->gyro_calib_data[0].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
 998         ds->gyro_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
 999
1000         ds->gyro_calib_data[1].abs_code = ABS_RY;
1001         ds->gyro_calib_data[1].bias = gyro_yaw_bias;
1002         ds->gyro_calib_data[1].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
1003         ds->gyro_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1004
1005         ds->gyro_calib_data[2].abs_code = ABS_RZ;
1006         ds->gyro_calib_data[2].bias = gyro_roll_bias;
1007         ds->gyro_calib_data[2].sens_numer = speed_2x*DS_GYRO_RES_PER_DEG_S;
1008         ds->gyro_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1009
1010         /*
1011          * Sanity check gyro calibration data. This is needed to prevent crashes
1012          * during report handling of virtual, clone or broken devices not implementing
1013          * calibration data properly.
1014          */
1015         for (i = 0; i < ARRAY_SIZE(ds->gyro_calib_data); i++) {
1016                 if (ds->gyro_calib_data[i].sens_denom == 0) {
1017                         hid_warn(hdev, "Invalid gyro calibration data for axis (%d), disabling calibration.",
1018                                         ds->gyro_calib_data[i].abs_code);
1019                         ds->gyro_calib_data[i].bias = 0;
1020                         ds->gyro_calib_data[i].sens_numer = DS_GYRO_RANGE;
1021                         ds->gyro_calib_data[i].sens_denom = S16_MAX;
1022                 }
1023         }
1024
1025         /*
1026          * Set accelerometer calibration and normalization parameters.
1027          * Data values will be normalized to 1/DS_ACC_RES_PER_G g.
1028          */
1029         range_2g = acc_x_plus - acc_x_minus;
1030         ds->accel_calib_data[0].abs_code = ABS_X;
1031         ds->accel_calib_data[0].bias = acc_x_plus - range_2g / 2;
1032         ds->accel_calib_data[0].sens_numer = 2*DS_ACC_RES_PER_G;
1033         ds->accel_calib_data[0].sens_denom = range_2g;
1034
1035         range_2g = acc_y_plus - acc_y_minus;
1036         ds->accel_calib_data[1].abs_code = ABS_Y;
1037         ds->accel_calib_data[1].bias = acc_y_plus - range_2g / 2;
1038         ds->accel_calib_data[1].sens_numer = 2*DS_ACC_RES_PER_G;
1039         ds->accel_calib_data[1].sens_denom = range_2g;
1040
1041         range_2g = acc_z_plus - acc_z_minus;
1042         ds->accel_calib_data[2].abs_code = ABS_Z;
1043         ds->accel_calib_data[2].bias = acc_z_plus - range_2g / 2;
1044         ds->accel_calib_data[2].sens_numer = 2*DS_ACC_RES_PER_G;
1045         ds->accel_calib_data[2].sens_denom = range_2g;
1046
1047         /*
1048          * Sanity check accelerometer calibration data. This is needed to prevent crashes
1049          * during report handling of virtual, clone or broken devices not implementing calibration
1050          * data properly.
1051          */
1052         for (i = 0; i < ARRAY_SIZE(ds->accel_calib_data); i++) {
1053                 if (ds->accel_calib_data[i].sens_denom == 0) {
1054                         hid_warn(hdev, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",
1055                                         ds->accel_calib_data[i].abs_code);
1056                         ds->accel_calib_data[i].bias = 0;
1057                         ds->accel_calib_data[i].sens_numer = DS_ACC_RANGE;
1058                         ds->accel_calib_data[i].sens_denom = S16_MAX;
1059                 }
1060         }
1061
1062 err_free:
1063         kfree(buf);
1064         return ret;
1065 }
1066
1067
1068 static int dualsense_get_firmware_info(struct dualsense *ds)
1069 {
1070         uint8_t *buf;
1071         int ret;
1072
1073         buf = kzalloc(DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE, GFP_KERNEL);
1074         if (!buf)
1075                 return -ENOMEM;
1076
1077         ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_FIRMWARE_INFO, buf,
1078                         DS_FEATURE_REPORT_FIRMWARE_INFO_SIZE, true);
1079         if (ret) {
1080                 hid_err(ds->base.hdev, "Failed to retrieve DualSense firmware info: %d\n", ret);
1081                 goto err_free;
1082         }
1083
1084         ds->base.hw_version = get_unaligned_le32(&buf[24]);
1085         ds->base.fw_version = get_unaligned_le32(&buf[28]);
1086
1087         /* Update version is some kind of feature version. It is distinct from
1088          * the firmware version as there can be many different variations of a
1089          * controller over time with the same physical shell, but with different
1090          * PCBs and other internal changes. The update version (internal name) is
1091          * used as a means to detect what features are available and change behavior.
1092          * Note: the version is different between DualSense and DualSense Edge.
1093          */
1094         ds->update_version = get_unaligned_le16(&buf[44]);
1095
1096 err_free:
1097         kfree(buf);
1098         return ret;
1099 }
1100
1101 static int dualsense_get_mac_address(struct dualsense *ds)
1102 {
1103         uint8_t *buf;
1104         int ret = 0;
1105
1106         buf = kzalloc(DS_FEATURE_REPORT_PAIRING_INFO_SIZE, GFP_KERNEL);
1107         if (!buf)
1108                 return -ENOMEM;
1109
1110         ret = ps_get_report(ds->base.hdev, DS_FEATURE_REPORT_PAIRING_INFO, buf,
1111                         DS_FEATURE_REPORT_PAIRING_INFO_SIZE, true);
1112         if (ret) {
1113                 hid_err(ds->base.hdev, "Failed to retrieve DualSense pairing info: %d\n", ret);
1114                 goto err_free;
1115         }
1116
1117         memcpy(ds->base.mac_address, &buf[1], sizeof(ds->base.mac_address));
1118
1119 err_free:
1120         kfree(buf);
1121         return ret;
1122 }
1123
1124 static int dualsense_lightbar_set_brightness(struct led_classdev *cdev,
1125         enum led_brightness brightness)
1126 {
1127         struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(cdev);
1128         struct dualsense *ds = container_of(mc_cdev, struct dualsense, lightbar);
1129         uint8_t red, green, blue;
1130
1131         led_mc_calc_color_components(mc_cdev, brightness);
1132         red = mc_cdev->subled_info[0].brightness;
1133         green = mc_cdev->subled_info[1].brightness;
1134         blue = mc_cdev->subled_info[2].brightness;
1135
1136         dualsense_set_lightbar(ds, red, green, blue);
1137         return 0;
1138 }
1139
1140 static enum led_brightness dualsense_player_led_get_brightness(struct led_classdev *led)
1141 {
1142         struct hid_device *hdev = to_hid_device(led->dev->parent);
1143         struct dualsense *ds = hid_get_drvdata(hdev);
1144
1145         return !!(ds->player_leds_state & BIT(led - ds->player_leds));
1146 }
1147
1148 static int dualsense_player_led_set_brightness(struct led_classdev *led, enum led_brightness value)
1149 {
1150         struct hid_device *hdev = to_hid_device(led->dev->parent);
1151         struct dualsense *ds = hid_get_drvdata(hdev);
1152         unsigned long flags;
1153         unsigned int led_index;
1154
1155         spin_lock_irqsave(&ds->base.lock, flags);
1156
1157         led_index = led - ds->player_leds;
1158         if (value == LED_OFF)
1159                 ds->player_leds_state &= ~BIT(led_index);
1160         else
1161                 ds->player_leds_state |= BIT(led_index);
1162
1163         ds->update_player_leds = true;
1164         spin_unlock_irqrestore(&ds->base.lock, flags);
1165
1166         dualsense_schedule_work(ds);
1167
1168         return 0;
1169 }
1170
1171 static void dualsense_init_output_report(struct dualsense *ds, struct dualsense_output_report *rp,
1172                 void *buf)
1173 {
1174         struct hid_device *hdev = ds->base.hdev;
1175
1176         if (hdev->bus == BUS_BLUETOOTH) {
1177                 struct dualsense_output_report_bt *bt = buf;
1178
1179                 memset(bt, 0, sizeof(*bt));
1180                 bt->report_id = DS_OUTPUT_REPORT_BT;
1181                 bt->tag = DS_OUTPUT_TAG; /* Tag must be set. Exact meaning is unclear. */
1182
1183                 /*
1184                  * Highest 4-bit is a sequence number, which needs to be increased
1185                  * every report. Lowest 4-bit is tag and can be zero for now.
1186                  */
1187                 bt->seq_tag = (ds->output_seq << 4) | 0x0;
1188                 if (++ds->output_seq == 16)
1189                         ds->output_seq = 0;
1190
1191                 rp->data = buf;
1192                 rp->len = sizeof(*bt);
1193                 rp->bt = bt;
1194                 rp->usb = NULL;
1195                 rp->common = &bt->common;
1196         } else { /* USB */
1197                 struct dualsense_output_report_usb *usb = buf;
1198
1199                 memset(usb, 0, sizeof(*usb));
1200                 usb->report_id = DS_OUTPUT_REPORT_USB;
1201
1202                 rp->data = buf;
1203                 rp->len = sizeof(*usb);
1204                 rp->bt = NULL;
1205                 rp->usb = usb;
1206                 rp->common = &usb->common;
1207         }
1208 }
1209
1210 static inline void dualsense_schedule_work(struct dualsense *ds)
1211 {
1212         unsigned long flags;
1213
1214         spin_lock_irqsave(&ds->base.lock, flags);
1215         if (ds->output_worker_initialized)
1216                 schedule_work(&ds->output_worker);
1217         spin_unlock_irqrestore(&ds->base.lock, flags);
1218 }
1219
1220 /*
1221  * Helper function to send DualSense output reports. Applies a CRC at the end of a report
1222  * for Bluetooth reports.
1223  */
1224 static void dualsense_send_output_report(struct dualsense *ds,
1225                 struct dualsense_output_report *report)
1226 {
1227         struct hid_device *hdev = ds->base.hdev;
1228
1229         /* Bluetooth packets need to be signed with a CRC in the last 4 bytes. */
1230         if (report->bt) {
1231                 uint32_t crc;
1232                 uint8_t seed = PS_OUTPUT_CRC32_SEED;
1233
1234                 crc = crc32_le(0xFFFFFFFF, &seed, 1);
1235                 crc = ~crc32_le(crc, report->data, report->len - 4);
1236
1237                 report->bt->crc32 = cpu_to_le32(crc);
1238         }
1239
1240         hid_hw_output_report(hdev, report->data, report->len);
1241 }
1242
1243 static void dualsense_output_worker(struct work_struct *work)
1244 {
1245         struct dualsense *ds = container_of(work, struct dualsense, output_worker);
1246         struct dualsense_output_report report;
1247         struct dualsense_output_report_common *common;
1248         unsigned long flags;
1249
1250         dualsense_init_output_report(ds, &report, ds->output_report_dmabuf);
1251         common = report.common;
1252
1253         spin_lock_irqsave(&ds->base.lock, flags);
1254
1255         if (ds->update_rumble) {
1256                 /* Select classic rumble style haptics and enable it. */
1257                 common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_HAPTICS_SELECT;
1258                 if (ds->use_vibration_v2)
1259                         common->valid_flag2 |= DS_OUTPUT_VALID_FLAG2_COMPATIBLE_VIBRATION2;
1260                 else
1261                         common->valid_flag0 |= DS_OUTPUT_VALID_FLAG0_COMPATIBLE_VIBRATION;
1262                 common->motor_left = ds->motor_left;
1263                 common->motor_right = ds->motor_right;
1264                 ds->update_rumble = false;
1265         }
1266
1267         if (ds->update_lightbar) {
1268                 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_LIGHTBAR_CONTROL_ENABLE;
1269                 common->lightbar_red = ds->lightbar_red;
1270                 common->lightbar_green = ds->lightbar_green;
1271                 common->lightbar_blue = ds->lightbar_blue;
1272
1273                 ds->update_lightbar = false;
1274         }
1275
1276         if (ds->update_player_leds) {
1277                 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_PLAYER_INDICATOR_CONTROL_ENABLE;
1278                 common->player_leds = ds->player_leds_state;
1279
1280                 ds->update_player_leds = false;
1281         }
1282
1283         if (ds->update_mic_mute) {
1284                 common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_MIC_MUTE_LED_CONTROL_ENABLE;
1285                 common->mute_button_led = ds->mic_muted;
1286
1287                 if (ds->mic_muted) {
1288                         /* Disable microphone */
1289                         common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;
1290                         common->power_save_control |= DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;
1291                 } else {
1292                         /* Enable microphone */
1293                         common->valid_flag1 |= DS_OUTPUT_VALID_FLAG1_POWER_SAVE_CONTROL_ENABLE;
1294                         common->power_save_control &= ~DS_OUTPUT_POWER_SAVE_CONTROL_MIC_MUTE;
1295                 }
1296
1297                 ds->update_mic_mute = false;
1298         }
1299
1300         spin_unlock_irqrestore(&ds->base.lock, flags);
1301
1302         dualsense_send_output_report(ds, &report);
1303 }
1304
1305 static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *report,
1306                 u8 *data, int size)
1307 {
1308         struct hid_device *hdev = ps_dev->hdev;
1309         struct dualsense *ds = container_of(ps_dev, struct dualsense, base);
1310         struct dualsense_input_report *ds_report;
1311         uint8_t battery_data, battery_capacity, charging_status, value;
1312         int battery_status;
1313         uint32_t sensor_timestamp;
1314         bool btn_mic_state;
1315         unsigned long flags;
1316         int i;
1317
1318         /*
1319          * DualSense in USB uses the full HID report for reportID 1, but
1320          * Bluetooth uses a minimal HID report for reportID 1 and reports
1321          * the full report using reportID 49.
1322          */
1323         if (hdev->bus == BUS_USB && report->id == DS_INPUT_REPORT_USB &&
1324                         size == DS_INPUT_REPORT_USB_SIZE) {
1325                 ds_report = (struct dualsense_input_report *)&data[1];
1326         } else if (hdev->bus == BUS_BLUETOOTH && report->id == DS_INPUT_REPORT_BT &&
1327                         size == DS_INPUT_REPORT_BT_SIZE) {
1328                 /* Last 4 bytes of input report contain crc32 */
1329                 uint32_t report_crc = get_unaligned_le32(&data[size - 4]);
1330
1331                 if (!ps_check_crc32(PS_INPUT_CRC32_SEED, data, size - 4, report_crc)) {
1332                         hid_err(hdev, "DualSense input CRC's check failed\n");
1333                         return -EILSEQ;
1334                 }
1335
1336                 ds_report = (struct dualsense_input_report *)&data[2];
1337         } else {
1338                 hid_err(hdev, "Unhandled reportID=%d\n", report->id);
1339                 return -1;
1340         }
1341
1342         input_report_abs(ds->gamepad, ABS_X,  ds_report->x);
1343         input_report_abs(ds->gamepad, ABS_Y,  ds_report->y);
1344         input_report_abs(ds->gamepad, ABS_RX, ds_report->rx);
1345         input_report_abs(ds->gamepad, ABS_RY, ds_report->ry);
1346         input_report_abs(ds->gamepad, ABS_Z,  ds_report->z);
1347         input_report_abs(ds->gamepad, ABS_RZ, ds_report->rz);
1348
1349         value = ds_report->buttons[0] & DS_BUTTONS0_HAT_SWITCH;
1350         if (value >= ARRAY_SIZE(ps_gamepad_hat_mapping))
1351                 value = 8; /* center */
1352         input_report_abs(ds->gamepad, ABS_HAT0X, ps_gamepad_hat_mapping[value].x);
1353         input_report_abs(ds->gamepad, ABS_HAT0Y, ps_gamepad_hat_mapping[value].y);
1354
1355         input_report_key(ds->gamepad, BTN_WEST,   ds_report->buttons[0] & DS_BUTTONS0_SQUARE);
1356         input_report_key(ds->gamepad, BTN_SOUTH,  ds_report->buttons[0] & DS_BUTTONS0_CROSS);
1357         input_report_key(ds->gamepad, BTN_EAST,   ds_report->buttons[0] & DS_BUTTONS0_CIRCLE);
1358         input_report_key(ds->gamepad, BTN_NORTH,  ds_report->buttons[0] & DS_BUTTONS0_TRIANGLE);
1359         input_report_key(ds->gamepad, BTN_TL,     ds_report->buttons[1] & DS_BUTTONS1_L1);
1360         input_report_key(ds->gamepad, BTN_TR,     ds_report->buttons[1] & DS_BUTTONS1_R1);
1361         input_report_key(ds->gamepad, BTN_TL2,    ds_report->buttons[1] & DS_BUTTONS1_L2);
1362         input_report_key(ds->gamepad, BTN_TR2,    ds_report->buttons[1] & DS_BUTTONS1_R2);
1363         input_report_key(ds->gamepad, BTN_SELECT, ds_report->buttons[1] & DS_BUTTONS1_CREATE);
1364         input_report_key(ds->gamepad, BTN_START,  ds_report->buttons[1] & DS_BUTTONS1_OPTIONS);
1365         input_report_key(ds->gamepad, BTN_THUMBL, ds_report->buttons[1] & DS_BUTTONS1_L3);
1366         input_report_key(ds->gamepad, BTN_THUMBR, ds_report->buttons[1] & DS_BUTTONS1_R3);
1367         input_report_key(ds->gamepad, BTN_MODE,   ds_report->buttons[2] & DS_BUTTONS2_PS_HOME);
1368         input_sync(ds->gamepad);
1369
1370         /*
1371          * The DualSense has an internal microphone, which can be muted through a mute button
1372          * on the device. The driver is expected to read the button state and program the device
1373          * to mute/unmute audio at the hardware level.
1374          */
1375         btn_mic_state = !!(ds_report->buttons[2] & DS_BUTTONS2_MIC_MUTE);
1376         if (btn_mic_state && !ds->last_btn_mic_state) {
1377                 spin_lock_irqsave(&ps_dev->lock, flags);
1378                 ds->update_mic_mute = true;
1379                 ds->mic_muted = !ds->mic_muted; /* toggle */
1380                 spin_unlock_irqrestore(&ps_dev->lock, flags);
1381
1382                 /* Schedule updating of microphone state at hardware level. */
1383                 dualsense_schedule_work(ds);
1384         }
1385         ds->last_btn_mic_state = btn_mic_state;
1386
1387         /* Parse and calibrate gyroscope data. */
1388         for (i = 0; i < ARRAY_SIZE(ds_report->gyro); i++) {
1389                 int raw_data = (short)le16_to_cpu(ds_report->gyro[i]);
1390                 int calib_data = mult_frac(ds->gyro_calib_data[i].sens_numer,
1391                                            raw_data - ds->gyro_calib_data[i].bias,
1392                                            ds->gyro_calib_data[i].sens_denom);
1393
1394                 input_report_abs(ds->sensors, ds->gyro_calib_data[i].abs_code, calib_data);
1395         }
1396
1397         /* Parse and calibrate accelerometer data. */
1398         for (i = 0; i < ARRAY_SIZE(ds_report->accel); i++) {
1399                 int raw_data = (short)le16_to_cpu(ds_report->accel[i]);
1400                 int calib_data = mult_frac(ds->accel_calib_data[i].sens_numer,
1401                                            raw_data - ds->accel_calib_data[i].bias,
1402                                            ds->accel_calib_data[i].sens_denom);
1403
1404                 input_report_abs(ds->sensors, ds->accel_calib_data[i].abs_code, calib_data);
1405         }
1406
1407         /* Convert timestamp (in 0.33us unit) to timestamp_us */
1408         sensor_timestamp = le32_to_cpu(ds_report->sensor_timestamp);
1409         if (!ds->sensor_timestamp_initialized) {
1410                 ds->sensor_timestamp_us = DIV_ROUND_CLOSEST(sensor_timestamp, 3);
1411                 ds->sensor_timestamp_initialized = true;
1412         } else {
1413                 uint32_t delta;
1414
1415                 if (ds->prev_sensor_timestamp > sensor_timestamp)
1416                         delta = (U32_MAX - ds->prev_sensor_timestamp + sensor_timestamp + 1);
1417                 else
1418                         delta = sensor_timestamp - ds->prev_sensor_timestamp;
1419                 ds->sensor_timestamp_us += DIV_ROUND_CLOSEST(delta, 3);
1420         }
1421         ds->prev_sensor_timestamp = sensor_timestamp;
1422         input_event(ds->sensors, EV_MSC, MSC_TIMESTAMP, ds->sensor_timestamp_us);
1423         input_sync(ds->sensors);
1424
1425         for (i = 0; i < ARRAY_SIZE(ds_report->points); i++) {
1426                 struct dualsense_touch_point *point = &ds_report->points[i];
1427                 bool active = (point->contact & DS_TOUCH_POINT_INACTIVE) ? false : true;
1428
1429                 input_mt_slot(ds->touchpad, i);
1430                 input_mt_report_slot_state(ds->touchpad, MT_TOOL_FINGER, active);
1431
1432                 if (active) {
1433                         int x = (point->x_hi << 8) | point->x_lo;
1434                         int y = (point->y_hi << 4) | point->y_lo;
1435
1436                         input_report_abs(ds->touchpad, ABS_MT_POSITION_X, x);
1437                         input_report_abs(ds->touchpad, ABS_MT_POSITION_Y, y);
1438                 }
1439         }
1440         input_mt_sync_frame(ds->touchpad);
1441         input_report_key(ds->touchpad, BTN_LEFT, ds_report->buttons[2] & DS_BUTTONS2_TOUCHPAD);
1442         input_sync(ds->touchpad);
1443
1444         battery_data = ds_report->status & DS_STATUS_BATTERY_CAPACITY;
1445         charging_status = (ds_report->status & DS_STATUS_CHARGING) >> DS_STATUS_CHARGING_SHIFT;
1446
1447         switch (charging_status) {
1448         case 0x0:
1449                 /*
1450                  * Each unit of battery data corresponds to 10%
1451                  * 0 = 0-9%, 1 = 10-19%, .. and 10 = 100%
1452                  */
1453                 battery_capacity = min(battery_data * 10 + 5, 100);
1454                 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
1455                 break;
1456         case 0x1:
1457                 battery_capacity = min(battery_data * 10 + 5, 100);
1458                 battery_status = POWER_SUPPLY_STATUS_CHARGING;
1459                 break;
1460         case 0x2:
1461                 battery_capacity = 100;
1462                 battery_status = POWER_SUPPLY_STATUS_FULL;
1463                 break;
1464         case 0xa: /* voltage or temperature out of range */
1465         case 0xb: /* temperature error */
1466                 battery_capacity = 0;
1467                 battery_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1468                 break;
1469         case 0xf: /* charging error */
1470         default:
1471                 battery_capacity = 0;
1472                 battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1473         }
1474
1475         spin_lock_irqsave(&ps_dev->lock, flags);
1476         ps_dev->battery_capacity = battery_capacity;
1477         ps_dev->battery_status = battery_status;
1478         spin_unlock_irqrestore(&ps_dev->lock, flags);
1479
1480         return 0;
1481 }
1482
1483 static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
1484 {
1485         struct hid_device *hdev = input_get_drvdata(dev);
1486         struct dualsense *ds = hid_get_drvdata(hdev);
1487         unsigned long flags;
1488
1489         if (effect->type != FF_RUMBLE)
1490                 return 0;
1491
1492         spin_lock_irqsave(&ds->base.lock, flags);
1493         ds->update_rumble = true;
1494         ds->motor_left = effect->u.rumble.strong_magnitude / 256;
1495         ds->motor_right = effect->u.rumble.weak_magnitude / 256;
1496         spin_unlock_irqrestore(&ds->base.lock, flags);
1497
1498         dualsense_schedule_work(ds);
1499         return 0;
1500 }
1501
1502 static void dualsense_remove(struct ps_device *ps_dev)
1503 {
1504         struct dualsense *ds = container_of(ps_dev, struct dualsense, base);
1505         unsigned long flags;
1506
1507         spin_lock_irqsave(&ds->base.lock, flags);
1508         ds->output_worker_initialized = false;
1509         spin_unlock_irqrestore(&ds->base.lock, flags);
1510
1511         cancel_work_sync(&ds->output_worker);
1512 }
1513
1514 static int dualsense_reset_leds(struct dualsense *ds)
1515 {
1516         struct dualsense_output_report report;
1517         uint8_t *buf;
1518
1519         buf = kzalloc(sizeof(struct dualsense_output_report_bt), GFP_KERNEL);
1520         if (!buf)
1521                 return -ENOMEM;
1522
1523         dualsense_init_output_report(ds, &report, buf);
1524         /*
1525          * On Bluetooth the DualSense outputs an animation on the lightbar
1526          * during startup and maintains a color afterwards. We need to explicitly
1527          * reconfigure the lightbar before we can do any programming later on.
1528          * In USB the lightbar is not on by default, but redoing the setup there
1529          * doesn't hurt.
1530          */
1531         report.common->valid_flag2 = DS_OUTPUT_VALID_FLAG2_LIGHTBAR_SETUP_CONTROL_ENABLE;
1532         report.common->lightbar_setup = DS_OUTPUT_LIGHTBAR_SETUP_LIGHT_OUT; /* Fade light out. */
1533         dualsense_send_output_report(ds, &report);
1534
1535         kfree(buf);
1536         return 0;
1537 }
1538
1539 static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue)
1540 {
1541         unsigned long flags;
1542
1543         spin_lock_irqsave(&ds->base.lock, flags);
1544         ds->update_lightbar = true;
1545         ds->lightbar_red = red;
1546         ds->lightbar_green = green;
1547         ds->lightbar_blue = blue;
1548         spin_unlock_irqrestore(&ds->base.lock, flags);
1549
1550         dualsense_schedule_work(ds);
1551 }
1552
1553 static void dualsense_set_player_leds(struct dualsense *ds)
1554 {
1555         /*
1556          * The DualSense controller has a row of 5 LEDs used for player ids.
1557          * Behavior on the PlayStation 5 console is to center the player id
1558          * across the LEDs, so e.g. player 1 would be "--x--" with x being 'on'.
1559          * Follow a similar mapping here.
1560          */
1561         static const int player_ids[5] = {
1562                 BIT(2),
1563                 BIT(3) | BIT(1),
1564                 BIT(4) | BIT(2) | BIT(0),
1565                 BIT(4) | BIT(3) | BIT(1) | BIT(0),
1566                 BIT(4) | BIT(3) | BIT(2) | BIT(1) | BIT(0)
1567         };
1568
1569         uint8_t player_id = ds->base.player_id % ARRAY_SIZE(player_ids);
1570
1571         ds->update_player_leds = true;
1572         ds->player_leds_state = player_ids[player_id];
1573         dualsense_schedule_work(ds);
1574 }
1575
1576 static struct ps_device *dualsense_create(struct hid_device *hdev)
1577 {
1578         struct dualsense *ds;
1579         struct ps_device *ps_dev;
1580         uint8_t max_output_report_size;
1581         int i, ret;
1582
1583         static const struct ps_led_info player_leds_info[] = {
1584                 { LED_FUNCTION_PLAYER1, "white", 1, dualsense_player_led_get_brightness,
1585                                 dualsense_player_led_set_brightness },
1586                 { LED_FUNCTION_PLAYER2, "white", 1, dualsense_player_led_get_brightness,
1587                                 dualsense_player_led_set_brightness },
1588                 { LED_FUNCTION_PLAYER3, "white", 1, dualsense_player_led_get_brightness,
1589                                 dualsense_player_led_set_brightness },
1590                 { LED_FUNCTION_PLAYER4, "white", 1, dualsense_player_led_get_brightness,
1591                                 dualsense_player_led_set_brightness },
1592                 { LED_FUNCTION_PLAYER5, "white", 1, dualsense_player_led_get_brightness,
1593                                 dualsense_player_led_set_brightness }
1594         };
1595
1596         ds = devm_kzalloc(&hdev->dev, sizeof(*ds), GFP_KERNEL);
1597         if (!ds)
1598                 return ERR_PTR(-ENOMEM);
1599
1600         /*
1601          * Patch version to allow userspace to distinguish between
1602          * hid-generic vs hid-playstation axis and button mapping.
1603          */
1604         hdev->version |= HID_PLAYSTATION_VERSION_PATCH;
1605
1606         ps_dev = &ds->base;
1607         ps_dev->hdev = hdev;
1608         spin_lock_init(&ps_dev->lock);
1609         ps_dev->battery_capacity = 100; /* initial value until parse_report. */
1610         ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
1611         ps_dev->parse_report = dualsense_parse_report;
1612         ps_dev->remove = dualsense_remove;
1613         INIT_WORK(&ds->output_worker, dualsense_output_worker);
1614         ds->output_worker_initialized = true;
1615         hid_set_drvdata(hdev, ds);
1616
1617         max_output_report_size = sizeof(struct dualsense_output_report_bt);
1618         ds->output_report_dmabuf = devm_kzalloc(&hdev->dev, max_output_report_size, GFP_KERNEL);
1619         if (!ds->output_report_dmabuf)
1620                 return ERR_PTR(-ENOMEM);
1621
1622         ret = dualsense_get_mac_address(ds);
1623         if (ret) {
1624                 hid_err(hdev, "Failed to get MAC address from DualSense\n");
1625                 return ERR_PTR(ret);
1626         }
1627         snprintf(hdev->uniq, sizeof(hdev->uniq), "%pMR", ds->base.mac_address);
1628
1629         ret = dualsense_get_firmware_info(ds);
1630         if (ret) {
1631                 hid_err(hdev, "Failed to get firmware info from DualSense\n");
1632                 return ERR_PTR(ret);
1633         }
1634
1635         /* Original DualSense firmware simulated classic controller rumble through
1636          * its new haptics hardware. It felt different from classic rumble users
1637          * were used to. Since then new firmwares were introduced to change behavior
1638          * and make this new 'v2' behavior default on PlayStation and other platforms.
1639          * The original DualSense requires a new enough firmware as bundled with PS5
1640          * software released in 2021. DualSense edge supports it out of the box.
1641          * Both devices also support the old mode, but it is not really used.
1642          */
1643         if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER) {
1644                 /* Feature version 2.21 introduced new vibration method. */
1645                 ds->use_vibration_v2 = ds->update_version >= DS_FEATURE_VERSION(2, 21);
1646         } else if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) {
1647                 ds->use_vibration_v2 = true;
1648         }
1649
1650         ret = ps_devices_list_add(ps_dev);
1651         if (ret)
1652                 return ERR_PTR(ret);
1653
1654         ret = dualsense_get_calibration_data(ds);
1655         if (ret) {
1656                 hid_err(hdev, "Failed to get calibration data from DualSense\n");
1657                 goto err;
1658         }
1659
1660         ds->gamepad = ps_gamepad_create(hdev, dualsense_play_effect);
1661         if (IS_ERR(ds->gamepad)) {
1662                 ret = PTR_ERR(ds->gamepad);
1663                 goto err;
1664         }
1665         /* Use gamepad input device name as primary device name for e.g. LEDs */
1666         ps_dev->input_dev_name = dev_name(&ds->gamepad->dev);
1667
1668         ds->sensors = ps_sensors_create(hdev, DS_ACC_RANGE, DS_ACC_RES_PER_G,
1669                         DS_GYRO_RANGE, DS_GYRO_RES_PER_DEG_S);
1670         if (IS_ERR(ds->sensors)) {
1671                 ret = PTR_ERR(ds->sensors);
1672                 goto err;
1673         }
1674
1675         ds->touchpad = ps_touchpad_create(hdev, DS_TOUCHPAD_WIDTH, DS_TOUCHPAD_HEIGHT, 2);
1676         if (IS_ERR(ds->touchpad)) {
1677                 ret = PTR_ERR(ds->touchpad);
1678                 goto err;
1679         }
1680
1681         ret = ps_device_register_battery(ps_dev);
1682         if (ret)
1683                 goto err;
1684
1685         /*
1686          * The hardware may have control over the LEDs (e.g. in Bluetooth on startup).
1687          * Reset the LEDs (lightbar, mute, player leds), so we can control them
1688          * from software.
1689          */
1690         ret = dualsense_reset_leds(ds);
1691         if (ret)
1692                 goto err;
1693
1694         ret = ps_lightbar_register(ps_dev, &ds->lightbar, dualsense_lightbar_set_brightness);
1695         if (ret)
1696                 goto err;
1697
1698         /* Set default lightbar color. */
1699         dualsense_set_lightbar(ds, 0, 0, 128); /* blue */
1700
1701         for (i = 0; i < ARRAY_SIZE(player_leds_info); i++) {
1702                 const struct ps_led_info *led_info = &player_leds_info[i];
1703
1704                 ret = ps_led_register(ps_dev, &ds->player_leds[i], led_info);
1705                 if (ret < 0)
1706                         goto err;
1707         }
1708
1709         ret = ps_device_set_player_id(ps_dev);
1710         if (ret) {
1711                 hid_err(hdev, "Failed to assign player id for DualSense: %d\n", ret);
1712                 goto err;
1713         }
1714
1715         /* Set player LEDs to our player id. */
1716         dualsense_set_player_leds(ds);
1717
1718         /*
1719          * Reporting hardware and firmware is important as there are frequent updates, which
1720          * can change behavior.
1721          */
1722         hid_info(hdev, "Registered DualSense controller hw_version=0x%08x fw_version=0x%08x\n",
1723                         ds->base.hw_version, ds->base.fw_version);
1724
1725         return &ds->base;
1726
1727 err:
1728         ps_devices_list_remove(ps_dev);
1729         return ERR_PTR(ret);
1730 }
1731
1732 static void dualshock4_dongle_calibration_work(struct work_struct *work)
1733 {
1734         struct dualshock4 *ds4 = container_of(work, struct dualshock4, dongle_hotplug_worker);
1735         unsigned long flags;
1736         enum dualshock4_dongle_state dongle_state;
1737         int ret;
1738
1739         ret = dualshock4_get_calibration_data(ds4);
1740         if (ret < 0) {
1741                 /* This call is very unlikely to fail for the dongle. When it
1742                  * fails we are probably in a very bad state, so mark the
1743                  * dongle as disabled. We will re-enable the dongle if a new
1744                  * DS4 hotplug is detect from sony_raw_event as any issues
1745                  * are likely resolved then (the dongle is quite stupid).
1746                  */
1747                 hid_err(ds4->base.hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1748                 dongle_state = DONGLE_DISABLED;
1749         } else {
1750                 hid_info(ds4->base.hdev, "DualShock 4 USB dongle: calibration completed\n");
1751                 dongle_state = DONGLE_CONNECTED;
1752         }
1753
1754         spin_lock_irqsave(&ds4->base.lock, flags);
1755         ds4->dongle_state = dongle_state;
1756         spin_unlock_irqrestore(&ds4->base.lock, flags);
1757 }
1758
1759 static int dualshock4_get_calibration_data(struct dualshock4 *ds4)
1760 {
1761         struct hid_device *hdev = ds4->base.hdev;
1762         short gyro_pitch_bias, gyro_pitch_plus, gyro_pitch_minus;
1763         short gyro_yaw_bias, gyro_yaw_plus, gyro_yaw_minus;
1764         short gyro_roll_bias, gyro_roll_plus, gyro_roll_minus;
1765         short gyro_speed_plus, gyro_speed_minus;
1766         short acc_x_plus, acc_x_minus;
1767         short acc_y_plus, acc_y_minus;
1768         short acc_z_plus, acc_z_minus;
1769         int speed_2x;
1770         int range_2g;
1771         int ret = 0;
1772         int i;
1773         uint8_t *buf;
1774
1775         if (ds4->base.hdev->bus == BUS_USB) {
1776                 int retries;
1777
1778                 buf = kzalloc(DS4_FEATURE_REPORT_CALIBRATION_SIZE, GFP_KERNEL);
1779                 if (!buf)
1780                         return -ENOMEM;
1781
1782                 /* We should normally receive the feature report data we asked
1783                  * for, but hidraw applications such as Steam can issue feature
1784                  * reports as well. In particular for Dongle reconnects, Steam
1785                  * and this function are competing resulting in often receiving
1786                  * data for a different HID report, so retry a few times.
1787                  */
1788                 for (retries = 0; retries < 3; retries++) {
1789                         ret = ps_get_report(hdev, DS4_FEATURE_REPORT_CALIBRATION, buf,
1790                                         DS4_FEATURE_REPORT_CALIBRATION_SIZE, true);
1791                         if (ret) {
1792                                 if (retries < 2) {
1793                                         hid_warn(hdev, "Retrying DualShock 4 get calibration report (0x02) request\n");
1794                                         continue;
1795                                 } else {
1796                                         ret = -EILSEQ;
1797                                         goto err_free;
1798                                 }
1799                                 hid_err(hdev, "Failed to retrieve DualShock4 calibration info: %d\n", ret);
1800                                 goto err_free;
1801                         } else {
1802                                 break;
1803                         }
1804                 }
1805         } else { /* Bluetooth */
1806                 buf = kzalloc(DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE, GFP_KERNEL);
1807                 if (!buf)
1808                         return -ENOMEM;
1809
1810                 ret = ps_get_report(hdev, DS4_FEATURE_REPORT_CALIBRATION_BT, buf,
1811                                 DS4_FEATURE_REPORT_CALIBRATION_BT_SIZE, true);
1812                 if (ret) {
1813                         hid_err(hdev, "Failed to retrieve DualShock4 calibration info: %d\n", ret);
1814                         goto err_free;
1815                 }
1816         }
1817
1818         gyro_pitch_bias  = get_unaligned_le16(&buf[1]);
1819         gyro_yaw_bias    = get_unaligned_le16(&buf[3]);
1820         gyro_roll_bias   = get_unaligned_le16(&buf[5]);
1821         if (ds4->base.hdev->bus == BUS_USB) {
1822                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1823                 gyro_pitch_minus = get_unaligned_le16(&buf[9]);
1824                 gyro_yaw_plus    = get_unaligned_le16(&buf[11]);
1825                 gyro_yaw_minus   = get_unaligned_le16(&buf[13]);
1826                 gyro_roll_plus   = get_unaligned_le16(&buf[15]);
1827                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1828         } else {
1829                 /* BT + Dongle */
1830                 gyro_pitch_plus  = get_unaligned_le16(&buf[7]);
1831                 gyro_yaw_plus    = get_unaligned_le16(&buf[9]);
1832                 gyro_roll_plus   = get_unaligned_le16(&buf[11]);
1833                 gyro_pitch_minus = get_unaligned_le16(&buf[13]);
1834                 gyro_yaw_minus   = get_unaligned_le16(&buf[15]);
1835                 gyro_roll_minus  = get_unaligned_le16(&buf[17]);
1836         }
1837         gyro_speed_plus  = get_unaligned_le16(&buf[19]);
1838         gyro_speed_minus = get_unaligned_le16(&buf[21]);
1839         acc_x_plus       = get_unaligned_le16(&buf[23]);
1840         acc_x_minus      = get_unaligned_le16(&buf[25]);
1841         acc_y_plus       = get_unaligned_le16(&buf[27]);
1842         acc_y_minus      = get_unaligned_le16(&buf[29]);
1843         acc_z_plus       = get_unaligned_le16(&buf[31]);
1844         acc_z_minus      = get_unaligned_le16(&buf[33]);
1845
1846         /*
1847          * Set gyroscope calibration and normalization parameters.
1848          * Data values will be normalized to 1/DS4_GYRO_RES_PER_DEG_S degree/s.
1849          */
1850         speed_2x = (gyro_speed_plus + gyro_speed_minus);
1851         ds4->gyro_calib_data[0].abs_code = ABS_RX;
1852         ds4->gyro_calib_data[0].bias = gyro_pitch_bias;
1853         ds4->gyro_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1854         ds4->gyro_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1855
1856         ds4->gyro_calib_data[1].abs_code = ABS_RY;
1857         ds4->gyro_calib_data[1].bias = gyro_yaw_bias;
1858         ds4->gyro_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1859         ds4->gyro_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1860
1861         ds4->gyro_calib_data[2].abs_code = ABS_RZ;
1862         ds4->gyro_calib_data[2].bias = gyro_roll_bias;
1863         ds4->gyro_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1864         ds4->gyro_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1865
1866         /*
1867          * Sanity check gyro calibration data. This is needed to prevent crashes
1868          * during report handling of virtual, clone or broken devices not implementing
1869          * calibration data properly.
1870          */
1871         for (i = 0; i < ARRAY_SIZE(ds4->gyro_calib_data); i++) {
1872                 if (ds4->gyro_calib_data[i].sens_denom == 0) {
1873                         hid_warn(hdev, "Invalid gyro calibration data for axis (%d), disabling calibration.",
1874                                         ds4->gyro_calib_data[i].abs_code);
1875                         ds4->gyro_calib_data[i].bias = 0;
1876                         ds4->gyro_calib_data[i].sens_numer = DS4_GYRO_RANGE;
1877                         ds4->gyro_calib_data[i].sens_denom = S16_MAX;
1878                 }
1879         }
1880
1881         /*
1882          * Set accelerometer calibration and normalization parameters.
1883          * Data values will be normalized to 1/DS4_ACC_RES_PER_G g.
1884          */
1885         range_2g = acc_x_plus - acc_x_minus;
1886         ds4->accel_calib_data[0].abs_code = ABS_X;
1887         ds4->accel_calib_data[0].bias = acc_x_plus - range_2g / 2;
1888         ds4->accel_calib_data[0].sens_numer = 2*DS4_ACC_RES_PER_G;
1889         ds4->accel_calib_data[0].sens_denom = range_2g;
1890
1891         range_2g = acc_y_plus - acc_y_minus;
1892         ds4->accel_calib_data[1].abs_code = ABS_Y;
1893         ds4->accel_calib_data[1].bias = acc_y_plus - range_2g / 2;
1894         ds4->accel_calib_data[1].sens_numer = 2*DS4_ACC_RES_PER_G;
1895         ds4->accel_calib_data[1].sens_denom = range_2g;
1896
1897         range_2g = acc_z_plus - acc_z_minus;
1898         ds4->accel_calib_data[2].abs_code = ABS_Z;
1899         ds4->accel_calib_data[2].bias = acc_z_plus - range_2g / 2;
1900         ds4->accel_calib_data[2].sens_numer = 2*DS4_ACC_RES_PER_G;
1901         ds4->accel_calib_data[2].sens_denom = range_2g;
1902
1903         /*
1904          * Sanity check accelerometer calibration data. This is needed to prevent crashes
1905          * during report handling of virtual, clone or broken devices not implementing calibration
1906          * data properly.
1907          */
1908         for (i = 0; i < ARRAY_SIZE(ds4->accel_calib_data); i++) {
1909                 if (ds4->accel_calib_data[i].sens_denom == 0) {
1910                         hid_warn(hdev, "Invalid accelerometer calibration data for axis (%d), disabling calibration.",
1911                                         ds4->accel_calib_data[i].abs_code);
1912                         ds4->accel_calib_data[i].bias = 0;
1913                         ds4->accel_calib_data[i].sens_numer = DS4_ACC_RANGE;
1914                         ds4->accel_calib_data[i].sens_denom = S16_MAX;
1915                 }
1916         }
1917
1918 err_free:
1919         kfree(buf);
1920         return ret;
1921 }
1922
1923 static int dualshock4_get_firmware_info(struct dualshock4 *ds4)
1924 {
1925         uint8_t *buf;
1926         int ret;
1927
1928         buf = kzalloc(DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE, GFP_KERNEL);
1929         if (!buf)
1930                 return -ENOMEM;
1931
1932         /* Note USB and BT support the same feature report, but this report
1933          * lacks CRC support, so must be disabled in ps_get_report.
1934          */
1935         ret = ps_get_report(ds4->base.hdev, DS4_FEATURE_REPORT_FIRMWARE_INFO, buf,
1936                         DS4_FEATURE_REPORT_FIRMWARE_INFO_SIZE, false);
1937         if (ret) {
1938                 hid_err(ds4->base.hdev, "Failed to retrieve DualShock4 firmware info: %d\n", ret);
1939                 goto err_free;
1940         }
1941
1942         ds4->base.hw_version = get_unaligned_le16(&buf[35]);
1943         ds4->base.fw_version = get_unaligned_le16(&buf[41]);
1944
1945 err_free:
1946         kfree(buf);
1947         return ret;
1948 }
1949
1950 static int dualshock4_get_mac_address(struct dualshock4 *ds4)
1951 {
1952         struct hid_device *hdev = ds4->base.hdev;
1953         uint8_t *buf;
1954         int ret = 0;
1955
1956         if (hdev->bus == BUS_USB) {
1957                 buf = kzalloc(DS4_FEATURE_REPORT_PAIRING_INFO_SIZE, GFP_KERNEL);
1958                 if (!buf)
1959                         return -ENOMEM;
1960
1961                 ret = ps_get_report(hdev, DS4_FEATURE_REPORT_PAIRING_INFO, buf,
1962                                 DS4_FEATURE_REPORT_PAIRING_INFO_SIZE, false);
1963                 if (ret) {
1964                         hid_err(hdev, "Failed to retrieve DualShock4 pairing info: %d\n", ret);
1965                         goto err_free;
1966                 }
1967
1968                 memcpy(ds4->base.mac_address, &buf[1], sizeof(ds4->base.mac_address));
1969         } else {
1970                 /* Rely on HIDP for Bluetooth */
1971                 if (strlen(hdev->uniq) != 17)
1972                         return -EINVAL;
1973
1974                 ret = sscanf(hdev->uniq, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1975                                 &ds4->base.mac_address[5], &ds4->base.mac_address[4],
1976                                 &ds4->base.mac_address[3], &ds4->base.mac_address[2],
1977                                 &ds4->base.mac_address[1], &ds4->base.mac_address[0]);
1978
1979                 if (ret != sizeof(ds4->base.mac_address))
1980                         return -EINVAL;
1981
1982                 return 0;
1983         }
1984
1985 err_free:
1986         kfree(buf);
1987         return ret;
1988 }
1989
1990 static enum led_brightness dualshock4_led_get_brightness(struct led_classdev *led)
1991 {
1992         struct hid_device *hdev = to_hid_device(led->dev->parent);
1993         struct dualshock4 *ds4 = hid_get_drvdata(hdev);
1994         unsigned int led_index;
1995
1996         led_index = led - ds4->lightbar_leds;
1997         switch (led_index) {
1998         case 0:
1999                 return ds4->lightbar_red;
2000         case 1:
2001                 return ds4->lightbar_green;
2002         case 2:
2003                 return ds4->lightbar_blue;
2004         case 3:
2005                 return ds4->lightbar_enabled;
2006         }
2007
2008         return -1;
2009 }
2010
2011 static int dualshock4_led_set_blink(struct led_classdev *led, unsigned long *delay_on,
2012                 unsigned long *delay_off)
2013 {
2014         struct hid_device *hdev = to_hid_device(led->dev->parent);
2015         struct dualshock4 *ds4 = hid_get_drvdata(hdev);
2016         unsigned long flags;
2017
2018         spin_lock_irqsave(&ds4->base.lock, flags);
2019
2020         if (!*delay_on && !*delay_off) {
2021                 /* Default to 1 Hz (50 centiseconds on, 50 centiseconds off). */
2022                 ds4->lightbar_blink_on = 50;
2023                 ds4->lightbar_blink_off = 50;
2024         } else {
2025                 /* Blink delays in centiseconds. */
2026                 ds4->lightbar_blink_on = min_t(unsigned long, *delay_on/10, DS4_LIGHTBAR_MAX_BLINK);
2027                 ds4->lightbar_blink_off = min_t(unsigned long, *delay_off/10, DS4_LIGHTBAR_MAX_BLINK);
2028         }
2029
2030         ds4->update_lightbar_blink = true;
2031
2032         spin_unlock_irqrestore(&ds4->base.lock, flags);
2033
2034         dualshock4_schedule_work(ds4);
2035
2036         *delay_on = ds4->lightbar_blink_on;
2037         *delay_off = ds4->lightbar_blink_off;
2038
2039         return 0;
2040 }
2041
2042 static int dualshock4_led_set_brightness(struct led_classdev *led, enum led_brightness value)
2043 {
2044         struct hid_device *hdev = to_hid_device(led->dev->parent);
2045         struct dualshock4 *ds4 = hid_get_drvdata(hdev);
2046         unsigned long flags;
2047         unsigned int led_index;
2048
2049         spin_lock_irqsave(&ds4->base.lock, flags);
2050
2051         led_index = led - ds4->lightbar_leds;
2052         switch (led_index) {
2053         case 0:
2054                 ds4->lightbar_red = value;
2055                 break;
2056         case 1:
2057                 ds4->lightbar_green = value;
2058                 break;
2059         case 2:
2060                 ds4->lightbar_blue = value;
2061                 break;
2062         case 3:
2063                 ds4->lightbar_enabled = !!value;
2064         }
2065
2066         ds4->update_lightbar = true;
2067
2068         spin_unlock_irqrestore(&ds4->base.lock, flags);
2069
2070         dualshock4_schedule_work(ds4);
2071
2072         return 0;
2073 }
2074
2075 static void dualshock4_init_output_report(struct dualshock4 *ds4,
2076                 struct dualshock4_output_report *rp, void *buf)
2077 {
2078         struct hid_device *hdev = ds4->base.hdev;
2079
2080         if (hdev->bus == BUS_BLUETOOTH) {
2081                 struct dualshock4_output_report_bt *bt = buf;
2082
2083                 memset(bt, 0, sizeof(*bt));
2084                 bt->report_id = DS4_OUTPUT_REPORT_BT;
2085
2086                 rp->data = buf;
2087                 rp->len = sizeof(*bt);
2088                 rp->bt = bt;
2089                 rp->usb = NULL;
2090                 rp->common = &bt->common;
2091         } else { /* USB */
2092                 struct dualshock4_output_report_usb *usb = buf;
2093
2094                 memset(usb, 0, sizeof(*usb));
2095                 usb->report_id = DS4_OUTPUT_REPORT_USB;
2096
2097                 rp->data = buf;
2098                 rp->len = sizeof(*usb);
2099                 rp->bt = NULL;
2100                 rp->usb = usb;
2101                 rp->common = &usb->common;
2102         }
2103 }
2104
2105 static void dualshock4_output_worker(struct work_struct *work)
2106 {
2107         struct dualshock4 *ds4 = container_of(work, struct dualshock4, output_worker);
2108         struct dualshock4_output_report report;
2109         struct dualshock4_output_report_common *common;
2110         unsigned long flags;
2111
2112         dualshock4_init_output_report(ds4, &report, ds4->output_report_dmabuf);
2113         common = report.common;
2114
2115         spin_lock_irqsave(&ds4->base.lock, flags);
2116
2117         if (ds4->update_rumble) {
2118                 /* Select classic rumble style haptics and enable it. */
2119                 common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_MOTOR;
2120                 common->motor_left = ds4->motor_left;
2121                 common->motor_right = ds4->motor_right;
2122                 ds4->update_rumble = false;
2123         }
2124
2125         if (ds4->update_lightbar) {
2126                 common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_LED;
2127                 /* Comptabile behavior with hid-sony, which used a dummy global LED to
2128                  * allow enabling/disabling the lightbar. The global LED maps to
2129                  * lightbar_enabled.
2130                  */
2131                 common->lightbar_red = ds4->lightbar_enabled ? ds4->lightbar_red : 0;
2132                 common->lightbar_green = ds4->lightbar_enabled ? ds4->lightbar_green : 0;
2133                 common->lightbar_blue = ds4->lightbar_enabled ? ds4->lightbar_blue : 0;
2134                 ds4->update_lightbar = false;
2135         }
2136
2137         if (ds4->update_lightbar_blink) {
2138                 common->valid_flag0 |= DS4_OUTPUT_VALID_FLAG0_LED_BLINK;
2139                 common->lightbar_blink_on = ds4->lightbar_blink_on;
2140                 common->lightbar_blink_off = ds4->lightbar_blink_off;
2141                 ds4->update_lightbar_blink = false;
2142         }
2143
2144         spin_unlock_irqrestore(&ds4->base.lock, flags);
2145
2146         /* Bluetooth packets need additional flags as well as a CRC in the last 4 bytes. */
2147         if (report.bt) {
2148                 uint32_t crc;
2149                 uint8_t seed = PS_OUTPUT_CRC32_SEED;
2150
2151                 /* Hardware control flags need to set to let the device know
2152                  * there is HID data as well as CRC.
2153                  */
2154                 report.bt->hw_control = DS4_OUTPUT_HWCTL_HID | DS4_OUTPUT_HWCTL_CRC32;
2155
2156                 if (ds4->update_bt_poll_interval) {
2157                         report.bt->hw_control |= ds4->bt_poll_interval;
2158                         ds4->update_bt_poll_interval = false;
2159                 }
2160
2161                 crc = crc32_le(0xFFFFFFFF, &seed, 1);
2162                 crc = ~crc32_le(crc, report.data, report.len - 4);
2163
2164                 report.bt->crc32 = cpu_to_le32(crc);
2165         }
2166
2167         hid_hw_output_report(ds4->base.hdev, report.data, report.len);
2168 }
2169
2170 static int dualshock4_parse_report(struct ps_device *ps_dev, struct hid_report *report,
2171                 u8 *data, int size)
2172 {
2173         struct hid_device *hdev = ps_dev->hdev;
2174         struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
2175         struct dualshock4_input_report_common *ds4_report;
2176         struct dualshock4_touch_report *touch_reports;
2177         uint8_t battery_capacity, num_touch_reports, value;
2178         int battery_status, i, j;
2179         uint16_t sensor_timestamp;
2180         unsigned long flags;
2181
2182         /*
2183          * DualShock4 in USB uses the full HID report for reportID 1, but
2184          * Bluetooth uses a minimal HID report for reportID 1 and reports
2185          * the full report using reportID 17.
2186          */
2187         if (hdev->bus == BUS_USB && report->id == DS4_INPUT_REPORT_USB &&
2188                         size == DS4_INPUT_REPORT_USB_SIZE) {
2189                 struct dualshock4_input_report_usb *usb = (struct dualshock4_input_report_usb *)data;
2190
2191                 ds4_report = &usb->common;
2192                 num_touch_reports = usb->num_touch_reports;
2193                 touch_reports = usb->touch_reports;
2194         } else if (hdev->bus == BUS_BLUETOOTH && report->id == DS4_INPUT_REPORT_BT &&
2195                         size == DS4_INPUT_REPORT_BT_SIZE) {
2196                 struct dualshock4_input_report_bt *bt = (struct dualshock4_input_report_bt *)data;
2197                 uint32_t report_crc = get_unaligned_le32(&bt->crc32);
2198
2199                 /* Last 4 bytes of input report contains CRC. */
2200                 if (!ps_check_crc32(PS_INPUT_CRC32_SEED, data, size - 4, report_crc)) {
2201                         hid_err(hdev, "DualShock4 input CRC's check failed\n");
2202                         return -EILSEQ;
2203                 }
2204
2205                 ds4_report = &bt->common;
2206                 num_touch_reports = bt->num_touch_reports;
2207                 touch_reports = bt->touch_reports;
2208         } else {
2209                 hid_err(hdev, "Unhandled reportID=%d\n", report->id);
2210                 return -1;
2211         }
2212
2213         input_report_abs(ds4->gamepad, ABS_X,  ds4_report->x);
2214         input_report_abs(ds4->gamepad, ABS_Y,  ds4_report->y);
2215         input_report_abs(ds4->gamepad, ABS_RX, ds4_report->rx);
2216         input_report_abs(ds4->gamepad, ABS_RY, ds4_report->ry);
2217         input_report_abs(ds4->gamepad, ABS_Z,  ds4_report->z);
2218         input_report_abs(ds4->gamepad, ABS_RZ, ds4_report->rz);
2219
2220         value = ds4_report->buttons[0] & DS_BUTTONS0_HAT_SWITCH;
2221         if (value >= ARRAY_SIZE(ps_gamepad_hat_mapping))
2222                 value = 8; /* center */
2223         input_report_abs(ds4->gamepad, ABS_HAT0X, ps_gamepad_hat_mapping[value].x);
2224         input_report_abs(ds4->gamepad, ABS_HAT0Y, ps_gamepad_hat_mapping[value].y);
2225
2226         input_report_key(ds4->gamepad, BTN_WEST,   ds4_report->buttons[0] & DS_BUTTONS0_SQUARE);
2227         input_report_key(ds4->gamepad, BTN_SOUTH,  ds4_report->buttons[0] & DS_BUTTONS0_CROSS);
2228         input_report_key(ds4->gamepad, BTN_EAST,   ds4_report->buttons[0] & DS_BUTTONS0_CIRCLE);
2229         input_report_key(ds4->gamepad, BTN_NORTH,  ds4_report->buttons[0] & DS_BUTTONS0_TRIANGLE);
2230         input_report_key(ds4->gamepad, BTN_TL,     ds4_report->buttons[1] & DS_BUTTONS1_L1);
2231         input_report_key(ds4->gamepad, BTN_TR,     ds4_report->buttons[1] & DS_BUTTONS1_R1);
2232         input_report_key(ds4->gamepad, BTN_TL2,    ds4_report->buttons[1] & DS_BUTTONS1_L2);
2233         input_report_key(ds4->gamepad, BTN_TR2,    ds4_report->buttons[1] & DS_BUTTONS1_R2);
2234         input_report_key(ds4->gamepad, BTN_SELECT, ds4_report->buttons[1] & DS_BUTTONS1_CREATE);
2235         input_report_key(ds4->gamepad, BTN_START,  ds4_report->buttons[1] & DS_BUTTONS1_OPTIONS);
2236         input_report_key(ds4->gamepad, BTN_THUMBL, ds4_report->buttons[1] & DS_BUTTONS1_L3);
2237         input_report_key(ds4->gamepad, BTN_THUMBR, ds4_report->buttons[1] & DS_BUTTONS1_R3);
2238         input_report_key(ds4->gamepad, BTN_MODE,   ds4_report->buttons[2] & DS_BUTTONS2_PS_HOME);
2239         input_sync(ds4->gamepad);
2240
2241         /* Parse and calibrate gyroscope data. */
2242         for (i = 0; i < ARRAY_SIZE(ds4_report->gyro); i++) {
2243                 int raw_data = (short)le16_to_cpu(ds4_report->gyro[i]);
2244                 int calib_data = mult_frac(ds4->gyro_calib_data[i].sens_numer,
2245                                            raw_data - ds4->gyro_calib_data[i].bias,
2246                                            ds4->gyro_calib_data[i].sens_denom);
2247
2248                 input_report_abs(ds4->sensors, ds4->gyro_calib_data[i].abs_code, calib_data);
2249         }
2250
2251         /* Parse and calibrate accelerometer data. */
2252         for (i = 0; i < ARRAY_SIZE(ds4_report->accel); i++) {
2253                 int raw_data = (short)le16_to_cpu(ds4_report->accel[i]);
2254                 int calib_data = mult_frac(ds4->accel_calib_data[i].sens_numer,
2255                                            raw_data - ds4->accel_calib_data[i].bias,
2256                                            ds4->accel_calib_data[i].sens_denom);
2257
2258                 input_report_abs(ds4->sensors, ds4->accel_calib_data[i].abs_code, calib_data);
2259         }
2260
2261         /* Convert timestamp (in 5.33us unit) to timestamp_us */
2262         sensor_timestamp = le16_to_cpu(ds4_report->sensor_timestamp);
2263         if (!ds4->sensor_timestamp_initialized) {
2264                 ds4->sensor_timestamp_us = DIV_ROUND_CLOSEST(sensor_timestamp*16, 3);
2265                 ds4->sensor_timestamp_initialized = true;
2266         } else {
2267                 uint16_t delta;
2268
2269                 if (ds4->prev_sensor_timestamp > sensor_timestamp)
2270                         delta = (U16_MAX - ds4->prev_sensor_timestamp + sensor_timestamp + 1);
2271                 else
2272                         delta = sensor_timestamp - ds4->prev_sensor_timestamp;
2273                 ds4->sensor_timestamp_us += DIV_ROUND_CLOSEST(delta*16, 3);
2274         }
2275         ds4->prev_sensor_timestamp = sensor_timestamp;
2276         input_event(ds4->sensors, EV_MSC, MSC_TIMESTAMP, ds4->sensor_timestamp_us);
2277         input_sync(ds4->sensors);
2278
2279         for (i = 0; i < num_touch_reports; i++) {
2280                 struct dualshock4_touch_report *touch_report = &touch_reports[i];
2281
2282                 for (j = 0; j < ARRAY_SIZE(touch_report->points); j++) {
2283                         struct dualshock4_touch_point *point = &touch_report->points[j];
2284                         bool active = (point->contact & DS4_TOUCH_POINT_INACTIVE) ? false : true;
2285
2286                         input_mt_slot(ds4->touchpad, j);
2287                         input_mt_report_slot_state(ds4->touchpad, MT_TOOL_FINGER, active);
2288
2289                         if (active) {
2290                                 int x = (point->x_hi << 8) | point->x_lo;
2291                                 int y = (point->y_hi << 4) | point->y_lo;
2292
2293                                 input_report_abs(ds4->touchpad, ABS_MT_POSITION_X, x);
2294                                 input_report_abs(ds4->touchpad, ABS_MT_POSITION_Y, y);
2295                         }
2296                 }
2297                 input_mt_sync_frame(ds4->touchpad);
2298                 input_sync(ds4->touchpad);
2299         }
2300         input_report_key(ds4->touchpad, BTN_LEFT, ds4_report->buttons[2] & DS_BUTTONS2_TOUCHPAD);
2301
2302         /*
2303          * Interpretation of the battery_capacity data depends on the cable state.
2304          * When no cable is connected (bit4 is 0):
2305          * - 0:10: percentage in units of 10%.
2306          * When a cable is plugged in:
2307          * - 0-10: percentage in units of 10%.
2308          * - 11: battery is full
2309          * - 14: not charging due to Voltage or temperature error
2310          * - 15: charge error
2311          */
2312         if (ds4_report->status[0] & DS4_STATUS0_CABLE_STATE) {
2313                 uint8_t battery_data = ds4_report->status[0] & DS4_STATUS0_BATTERY_CAPACITY;
2314
2315                 if (battery_data < 10) {
2316                         /* Take the mid-point for each battery capacity value,
2317                          * because on the hardware side 0 = 0-9%, 1=10-19%, etc.
2318                          * This matches official platform behavior, which does
2319                          * the same.
2320                          */
2321                         battery_capacity = battery_data * 10 + 5;
2322                         battery_status = POWER_SUPPLY_STATUS_CHARGING;
2323                 } else if (battery_data == 10) {
2324                         battery_capacity = 100;
2325                         battery_status = POWER_SUPPLY_STATUS_CHARGING;
2326                 } else if (battery_data == DS4_BATTERY_STATUS_FULL) {
2327                         battery_capacity = 100;
2328                         battery_status = POWER_SUPPLY_STATUS_FULL;
2329                 } else { /* 14, 15 and undefined values */
2330                         battery_capacity = 0;
2331                         battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
2332                 }
2333         } else {
2334                 uint8_t battery_data = ds4_report->status[0] & DS4_STATUS0_BATTERY_CAPACITY;
2335
2336                 if (battery_data < 10)
2337                         battery_capacity = battery_data * 10 + 5;
2338                 else /* 10 */
2339                         battery_capacity = 100;
2340
2341                 battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
2342         }
2343
2344         spin_lock_irqsave(&ps_dev->lock, flags);
2345         ps_dev->battery_capacity = battery_capacity;
2346         ps_dev->battery_status = battery_status;
2347         spin_unlock_irqrestore(&ps_dev->lock, flags);
2348
2349         return 0;
2350 }
2351
2352 static int dualshock4_dongle_parse_report(struct ps_device *ps_dev, struct hid_report *report,
2353                 u8 *data, int size)
2354 {
2355         struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
2356         bool connected = false;
2357
2358         /* The dongle reports data using the main USB report (0x1) no matter whether a controller
2359          * is connected with mostly zeros. The report does contain dongle status, which we use to
2360          * determine if a controller is connected and if so we forward to the regular DualShock4
2361          * parsing code.
2362          */
2363         if (data[0] == DS4_INPUT_REPORT_USB && size == DS4_INPUT_REPORT_USB_SIZE) {
2364                 struct dualshock4_input_report_common *ds4_report = (struct dualshock4_input_report_common *)&data[1];
2365                 unsigned long flags;
2366
2367                 connected = ds4_report->status[1] & DS4_STATUS1_DONGLE_STATE ? false : true;
2368
2369                 if (ds4->dongle_state == DONGLE_DISCONNECTED && connected) {
2370                         hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller connected\n");
2371
2372                         dualshock4_set_default_lightbar_colors(ds4);
2373
2374                         spin_lock_irqsave(&ps_dev->lock, flags);
2375                         ds4->dongle_state = DONGLE_CALIBRATING;
2376                         spin_unlock_irqrestore(&ps_dev->lock, flags);
2377
2378                         schedule_work(&ds4->dongle_hotplug_worker);
2379
2380                         /* Don't process the report since we don't have
2381                          * calibration data, but let hidraw have it anyway.
2382                          */
2383                         return 0;
2384                 } else if ((ds4->dongle_state == DONGLE_CONNECTED ||
2385                             ds4->dongle_state == DONGLE_DISABLED) && !connected) {
2386                         hid_info(ps_dev->hdev, "DualShock 4 USB dongle: controller disconnected\n");
2387
2388                         spin_lock_irqsave(&ps_dev->lock, flags);
2389                         ds4->dongle_state = DONGLE_DISCONNECTED;
2390                         spin_unlock_irqrestore(&ps_dev->lock, flags);
2391
2392                         /* Return 0, so hidraw can get the report. */
2393                         return 0;
2394                 } else if (ds4->dongle_state == DONGLE_CALIBRATING ||
2395                            ds4->dongle_state == DONGLE_DISABLED ||
2396                            ds4->dongle_state == DONGLE_DISCONNECTED) {
2397                         /* Return 0, so hidraw can get the report. */
2398                         return 0;
2399                 }
2400         }
2401
2402         if (connected)
2403                 return dualshock4_parse_report(ps_dev, report, data, size);
2404
2405         return 0;
2406 }
2407
2408 static int dualshock4_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
2409 {
2410         struct hid_device *hdev = input_get_drvdata(dev);
2411         struct dualshock4 *ds4 = hid_get_drvdata(hdev);
2412         unsigned long flags;
2413
2414         if (effect->type != FF_RUMBLE)
2415                 return 0;
2416
2417         spin_lock_irqsave(&ds4->base.lock, flags);
2418         ds4->update_rumble = true;
2419         ds4->motor_left = effect->u.rumble.strong_magnitude / 256;
2420         ds4->motor_right = effect->u.rumble.weak_magnitude / 256;
2421         spin_unlock_irqrestore(&ds4->base.lock, flags);
2422
2423         dualshock4_schedule_work(ds4);
2424         return 0;
2425 }
2426
2427 static void dualshock4_remove(struct ps_device *ps_dev)
2428 {
2429         struct dualshock4 *ds4 = container_of(ps_dev, struct dualshock4, base);
2430         unsigned long flags;
2431
2432         spin_lock_irqsave(&ds4->base.lock, flags);
2433         ds4->output_worker_initialized = false;
2434         spin_unlock_irqrestore(&ds4->base.lock, flags);
2435
2436         cancel_work_sync(&ds4->output_worker);
2437
2438         if (ps_dev->hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE)
2439                 cancel_work_sync(&ds4->dongle_hotplug_worker);
2440 }
2441
2442 static inline void dualshock4_schedule_work(struct dualshock4 *ds4)
2443 {
2444         unsigned long flags;
2445
2446         spin_lock_irqsave(&ds4->base.lock, flags);
2447         if (ds4->output_worker_initialized)
2448                 schedule_work(&ds4->output_worker);
2449         spin_unlock_irqrestore(&ds4->base.lock, flags);
2450 }
2451
2452 static void dualshock4_set_bt_poll_interval(struct dualshock4 *ds4, uint8_t interval)
2453 {
2454         ds4->bt_poll_interval = interval;
2455         ds4->update_bt_poll_interval = true;
2456         dualshock4_schedule_work(ds4);
2457 }
2458
2459 /* Set default lightbar color based on player. */
2460 static void dualshock4_set_default_lightbar_colors(struct dualshock4 *ds4)
2461 {
2462         /* Use same player colors as PlayStation 4.
2463          * Array of colors is in RGB.
2464          */
2465         static const int player_colors[4][3] = {
2466                 { 0x00, 0x00, 0x40 }, /* Blue */
2467                 { 0x40, 0x00, 0x00 }, /* Red */
2468                 { 0x00, 0x40, 0x00 }, /* Green */
2469                 { 0x20, 0x00, 0x20 }  /* Pink */
2470         };
2471
2472         uint8_t player_id = ds4->base.player_id % ARRAY_SIZE(player_colors);
2473
2474         ds4->lightbar_enabled = true;
2475         ds4->lightbar_red = player_colors[player_id][0];
2476         ds4->lightbar_green = player_colors[player_id][1];
2477         ds4->lightbar_blue = player_colors[player_id][2];
2478
2479         ds4->update_lightbar = true;
2480         dualshock4_schedule_work(ds4);
2481 }
2482
2483 static struct ps_device *dualshock4_create(struct hid_device *hdev)
2484 {
2485         struct dualshock4 *ds4;
2486         struct ps_device *ps_dev;
2487         uint8_t max_output_report_size;
2488         int i, ret;
2489
2490         /* The DualShock4 has an RGB lightbar, which the original hid-sony driver
2491          * exposed as a set of 4 LEDs for the 3 color channels and a global control.
2492          * Ideally this should have used the multi-color LED class, which didn't exist
2493          * yet. In addition the driver used a naming scheme not compliant with the LED
2494          * naming spec by using "<mac_address>:<color>", which contained many colons.
2495          * We use a more compliant by using "<device_name>:<color>" name now. Ideally
2496          * would have been "<device_name>:<color>:indicator", but that would break
2497          * existing applications (e.g. Android). Nothing matches against MAC address.
2498          */
2499         static const struct ps_led_info lightbar_leds_info[] = {
2500                 { NULL, "red", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },
2501                 { NULL, "green", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },
2502                 { NULL, "blue", 255, dualshock4_led_get_brightness, dualshock4_led_set_brightness },
2503                 { NULL, "global", 1, dualshock4_led_get_brightness, dualshock4_led_set_brightness,
2504                                 dualshock4_led_set_blink },
2505         };
2506
2507         ds4 = devm_kzalloc(&hdev->dev, sizeof(*ds4), GFP_KERNEL);
2508         if (!ds4)
2509                 return ERR_PTR(-ENOMEM);
2510
2511         /*
2512          * Patch version to allow userspace to distinguish between
2513          * hid-generic vs hid-playstation axis and button mapping.
2514          */
2515         hdev->version |= HID_PLAYSTATION_VERSION_PATCH;
2516
2517         ps_dev = &ds4->base;
2518         ps_dev->hdev = hdev;
2519         spin_lock_init(&ps_dev->lock);
2520         ps_dev->battery_capacity = 100; /* initial value until parse_report. */
2521         ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN;
2522         ps_dev->parse_report = dualshock4_parse_report;
2523         ps_dev->remove = dualshock4_remove;
2524         INIT_WORK(&ds4->output_worker, dualshock4_output_worker);
2525         ds4->output_worker_initialized = true;
2526         hid_set_drvdata(hdev, ds4);
2527
2528         max_output_report_size = sizeof(struct dualshock4_output_report_bt);
2529         ds4->output_report_dmabuf = devm_kzalloc(&hdev->dev, max_output_report_size, GFP_KERNEL);
2530         if (!ds4->output_report_dmabuf)
2531                 return ERR_PTR(-ENOMEM);
2532
2533         if (hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) {
2534                 ds4->dongle_state = DONGLE_DISCONNECTED;
2535                 INIT_WORK(&ds4->dongle_hotplug_worker, dualshock4_dongle_calibration_work);
2536
2537                 /* Override parse report for dongle specific hotplug handling. */
2538                 ps_dev->parse_report = dualshock4_dongle_parse_report;
2539         }
2540
2541         ret = dualshock4_get_mac_address(ds4);
2542         if (ret) {
2543                 hid_err(hdev, "Failed to get MAC address from DualShock4\n");
2544                 return ERR_PTR(ret);
2545         }
2546         snprintf(hdev->uniq, sizeof(hdev->uniq), "%pMR", ds4->base.mac_address);
2547
2548         ret = dualshock4_get_firmware_info(ds4);
2549         if (ret) {
2550                 hid_err(hdev, "Failed to get firmware info from DualShock4\n");
2551                 return ERR_PTR(ret);
2552         }
2553
2554         ret = ps_devices_list_add(ps_dev);
2555         if (ret)
2556                 return ERR_PTR(ret);
2557
2558         ret = dualshock4_get_calibration_data(ds4);
2559         if (ret) {
2560                 hid_err(hdev, "Failed to get calibration data from DualShock4\n");
2561                 goto err;
2562         }
2563
2564         ds4->gamepad = ps_gamepad_create(hdev, dualshock4_play_effect);
2565         if (IS_ERR(ds4->gamepad)) {
2566                 ret = PTR_ERR(ds4->gamepad);
2567                 goto err;
2568         }
2569
2570         /* Use gamepad input device name as primary device name for e.g. LEDs */
2571         ps_dev->input_dev_name = dev_name(&ds4->gamepad->dev);
2572
2573         ds4->sensors = ps_sensors_create(hdev, DS4_ACC_RANGE, DS4_ACC_RES_PER_G,
2574                         DS4_GYRO_RANGE, DS4_GYRO_RES_PER_DEG_S);
2575         if (IS_ERR(ds4->sensors)) {
2576                 ret = PTR_ERR(ds4->sensors);
2577                 goto err;
2578         }
2579
2580         ds4->touchpad = ps_touchpad_create(hdev, DS4_TOUCHPAD_WIDTH, DS4_TOUCHPAD_HEIGHT, 2);
2581         if (IS_ERR(ds4->touchpad)) {
2582                 ret = PTR_ERR(ds4->touchpad);
2583                 goto err;
2584         }
2585
2586         ret = ps_device_register_battery(ps_dev);
2587         if (ret)
2588                 goto err;
2589
2590         for (i = 0; i < ARRAY_SIZE(lightbar_leds_info); i++) {
2591                 const struct ps_led_info *led_info = &lightbar_leds_info[i];
2592
2593                 ret = ps_led_register(ps_dev, &ds4->lightbar_leds[i], led_info);
2594                 if (ret < 0)
2595                         goto err;
2596         }
2597
2598         dualshock4_set_bt_poll_interval(ds4, DS4_BT_DEFAULT_POLL_INTERVAL_MS);
2599
2600         ret = ps_device_set_player_id(ps_dev);
2601         if (ret) {
2602                 hid_err(hdev, "Failed to assign player id for DualShock4: %d\n", ret);
2603                 goto err;
2604         }
2605
2606         dualshock4_set_default_lightbar_colors(ds4);
2607
2608         /*
2609          * Reporting hardware and firmware is important as there are frequent updates, which
2610          * can change behavior.
2611          */
2612         hid_info(hdev, "Registered DualShock4 controller hw_version=0x%08x fw_version=0x%08x\n",
2613                         ds4->base.hw_version, ds4->base.fw_version);
2614         return &ds4->base;
2615
2616 err:
2617         ps_devices_list_remove(ps_dev);
2618         return ERR_PTR(ret);
2619 }
2620
2621 static int ps_raw_event(struct hid_device *hdev, struct hid_report *report,
2622                 u8 *data, int size)
2623 {
2624         struct ps_device *dev = hid_get_drvdata(hdev);
2625
2626         if (dev && dev->parse_report)
2627                 return dev->parse_report(dev, report, data, size);
2628
2629         return 0;
2630 }
2631
2632 static int ps_probe(struct hid_device *hdev, const struct hid_device_id *id)
2633 {
2634         struct ps_device *dev;
2635         int ret;
2636
2637         ret = hid_parse(hdev);
2638         if (ret) {
2639                 hid_err(hdev, "Parse failed\n");
2640                 return ret;
2641         }
2642
2643         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
2644         if (ret) {
2645                 hid_err(hdev, "Failed to start HID device\n");
2646                 return ret;
2647         }
2648
2649         ret = hid_hw_open(hdev);
2650         if (ret) {
2651                 hid_err(hdev, "Failed to open HID device\n");
2652                 goto err_stop;
2653         }
2654
2655         if (hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER ||
2656                 hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_2 ||
2657                 hdev->product == USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) {
2658                 dev = dualshock4_create(hdev);
2659                 if (IS_ERR(dev)) {
2660                         hid_err(hdev, "Failed to create dualshock4.\n");
2661                         ret = PTR_ERR(dev);
2662                         goto err_close;
2663                 }
2664         } else if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER ||
2665                 hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) {
2666                 dev = dualsense_create(hdev);
2667                 if (IS_ERR(dev)) {
2668                         hid_err(hdev, "Failed to create dualsense.\n");
2669                         ret = PTR_ERR(dev);
2670                         goto err_close;
2671                 }
2672         }
2673
2674         return ret;
2675
2676 err_close:
2677         hid_hw_close(hdev);
2678 err_stop:
2679         hid_hw_stop(hdev);
2680         return ret;
2681 }
2682
2683 static void ps_remove(struct hid_device *hdev)
2684 {
2685         struct ps_device *dev = hid_get_drvdata(hdev);
2686
2687         ps_devices_list_remove(dev);
2688         ps_device_release_player_id(dev);
2689
2690         if (dev->remove)
2691                 dev->remove(dev);
2692
2693         hid_hw_close(hdev);
2694         hid_hw_stop(hdev);
2695 }
2696
2697 static const struct hid_device_id ps_devices[] = {
2698         /* Sony DualShock 4 controllers for PS4 */
2699         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
2700         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
2701         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2) },
2702         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2) },
2703         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) },
2704         /* Sony DualSense controllers for PS5 */
2705         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER) },
2706         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER) },
2707         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) },
2708         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) },
2709         { }
2710 };
2711 MODULE_DEVICE_TABLE(hid, ps_devices);
2712
2713 static struct hid_driver ps_driver = {
2714         .name           = "playstation",
2715         .id_table       = ps_devices,
2716         .probe          = ps_probe,
2717         .remove         = ps_remove,
2718         .raw_event      = ps_raw_event,
2719         .driver = {
2720                 .dev_groups = ps_device_groups,
2721         },
2722 };
2723
2724 static int __init ps_init(void)
2725 {
2726         return hid_register_driver(&ps_driver);
2727 }
2728
2729 static void __exit ps_exit(void)
2730 {
2731         hid_unregister_driver(&ps_driver);
2732         ida_destroy(&ps_player_id_allocator);
2733 }
2734
2735 module_init(ps_init);
2736 module_exit(ps_exit);
2737
2738 MODULE_AUTHOR("Sony Interactive Entertainment");
2739 MODULE_DESCRIPTION("HID Driver for PlayStation peripherals.");
2740 MODULE_LICENSE("GPL");