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