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