drivers/hid/hid-playstation.c

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