Remap DS4 USB to Bluetooth for UHID

A virtual UHID device has no physical USB ancestor, so steam-devices cannot match its USB-only DualShock 4 hidraw rule. When a USB DS4 profile is requested on Linux, the backend now transparently substitutes the Bluetooth descriptor and report framing so steam-devices' Bluetooth rule matches instead. The public profile name, vendor/product IDs, and all non-Linux behavior are preserved. Adds a test hook and unit tests to verify the effective profile selection.

Author: ReenigneArcher

docs/platform-support.md

@@ -139,11 +139,14 @@ parsing, whether the kernel includes the report number in the payload or
 provides it separately on the UHID event.
 
 On Linux, the UHID transport emits Sony's native `Wireless Controller` product
-name for DualShock 4 and DualSense devices. This keeps Steam's PlayStation HID
-detection compatible even when a streaming host customizes the public profile
-name. The requested USB or Bluetooth descriptor and report framing are left
-unchanged. This identity adjustment is confined to the Linux backend; Windows
-profile names and VHF behavior are unchanged.
+name for DualShock 4 and DualSense devices. The default USB DualShock 4 profile
+is instantiated with its Bluetooth descriptor and report framing because a
+virtual UHID device has no physical USB ancestor for the USB-only DualShock 4
+rule shipped by `steam-devices`; its Bluetooth rule matches the virtual HID
+ancestor directly. `Gamepad::profile()` reports this effective transport.
+DualSense keeps its requested USB or Bluetooth framing. These adjustments are
+confined to the Linux backend; Windows profile names and VHF behavior are
+unchanged.
 
 Switch Pro keeps its Nintendo identity on the Linux uinput path. This follows
 the evdev layout used by Linux-native virtual-controller implementations and

src/platform/linux/uhid_backend.cpp

@@ -313,6 +313,28 @@ namespace lvh::detail {
       }
       return profile.name;
     }
+
+    std::optional<DeviceProfile> effective_uhid_gamepad_profile(const DeviceProfile &requested_profile) {
+      if (
+        requested_profile.gamepad_kind != GamepadProfileKind::dualshock4 ||
+        requested_profile.bus_type == BusType::bluetooth
+      ) {
+        return std::nullopt;
+      }
+
+      // A UHID device has no physical USB ancestor, so steam-devices cannot
+      // apply its USB-only DS4 hidraw rule. Its Bluetooth rule matches the
+      // virtual HID ancestor directly. Keep the public DS4 profile neutral and
+      // change only the Linux transport descriptor and report framing.
+      const auto transport_profile = profiles::dualshock4_bluetooth();
+      auto effective_profile = requested_profile;
+      effective_profile.bus_type = transport_profile.bus_type;
+      effective_profile.report_id = transport_profile.report_id;
+      effective_profile.input_report_size = transport_profile.input_report_size;
+      effective_profile.output_report_size = transport_profile.output_report_size;
+      effective_profile.report_descriptor = transport_profile.report_descriptor;
+      return effective_profile;
+    }
 #endif
 
     std::uint16_t to_uinput_bus(BusType bus_type) {
@@ -3200,13 +3222,19 @@ namespace lvh::detail {
           return {system_error_status(ErrorCode::backend_unavailable, "failed to open /dev/uhid", errno), nullptr};
         }
 
+        auto effective_options = options;
+        auto effective_profile = effective_uhid_gamepad_profile(options.profile);
+        if (effective_profile.has_value()) {
+          effective_options.profile = *effective_profile;
+        }
+
         auto gamepad = std::make_unique<UhidGamepad>(fd);
-        if (const auto status = gamepad->create(id, options); !status.ok()) {
+        if (const auto status = gamepad->create(id, effective_options); !status.ok()) {
           static_cast<void>(gamepad->close());
           return {status, nullptr};
         }
 
-        return {OperationStatus::success(), std::move(gamepad)};
+        return {OperationStatus::success(), std::move(gamepad), std::move(effective_profile)};
 #else
         return {
           OperationStatus::failure(ErrorCode::unsupported_profile, "gamepad profile requires Linux UHID"),

tests/fixtures/include/fixtures/linux_backend_test_hooks.hpp

@@ -427,6 +427,14 @@ namespace lvh::detail::test {
    */
   std::uint16_t linux_gamepad_uhid_bus(GamepadProfileKind kind);
 
+  /**
+   * @brief Select the effective Linux UHID profile for a requested gamepad profile.
+   *
+   * @param profile Requested gamepad profile.
+   * @return Backend-adjusted gamepad profile.
+   */
+  DeviceProfile linux_effective_uhid_gamepad_profile(const DeviceProfile &profile);
+
   /**
    * @brief Translate a bus type to a Linux uinput bus code.
    *

tests/fixtures/linux_backend_test_hooks.cpp

@@ -878,6 +878,10 @@ namespace lvh::detail::test {
     return profile ? to_uhid_bus(*profile) : to_uhid_bus(BusType::unknown);
   }
 
+  DeviceProfile linux_effective_uhid_gamepad_profile(const DeviceProfile &profile) {
+    return effective_uhid_gamepad_profile(profile).value_or(profile);
+  }
+
   std::uint16_t linux_uinput_bus(BusType bus_type) {
     return to_uinput_bus(bus_type);
   }

tests/unit/test_linux_backend.cpp

@@ -125,6 +125,30 @@ TEST_F(LinuxBackendTest, TranslatesMouseButtonsAndBusTypes) {
   EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::switch_pro), BUS_VIRTUAL);
   EXPECT_EQ(lvh::detail::test::linux_uinput_bus(lvh::BusType::bluetooth), BUS_BLUETOOTH);
 
+  auto dualshock4 = lvh::profiles::dualshock4_usb();
+  dualshock4.name = "Streaming host DS4";
+  const auto effective_dualshock4 = lvh::detail::test::linux_effective_uhid_gamepad_profile(dualshock4);
+  const auto dualshock4_bluetooth = lvh::profiles::dualshock4_bluetooth();
+  EXPECT_EQ(effective_dualshock4.bus_type, lvh::BusType::bluetooth);
+  EXPECT_EQ(effective_dualshock4.report_id, dualshock4_bluetooth.report_id);
+  EXPECT_EQ(effective_dualshock4.input_report_size, dualshock4_bluetooth.input_report_size);
+  EXPECT_EQ(effective_dualshock4.output_report_size, dualshock4_bluetooth.output_report_size);
+  EXPECT_EQ(effective_dualshock4.report_descriptor, dualshock4_bluetooth.report_descriptor);
+  EXPECT_EQ(effective_dualshock4.name, dualshock4.name);
+  EXPECT_EQ(effective_dualshock4.vendor_id, dualshock4.vendor_id);
+  EXPECT_EQ(effective_dualshock4.product_id, dualshock4.product_id);
+
+  const auto requested_dualshock4_bluetooth = lvh::profiles::dualshock4_bluetooth();
+  EXPECT_EQ(
+    lvh::detail::test::linux_effective_uhid_gamepad_profile(requested_dualshock4_bluetooth).report_descriptor,
+    requested_dualshock4_bluetooth.report_descriptor
+  );
+
+  const auto dualsense = lvh::profiles::dualsense_usb();
+  const auto effective_dualsense = lvh::detail::test::linux_effective_uhid_gamepad_profile(dualsense);
+  EXPECT_EQ(effective_dualsense.bus_type, lvh::BusType::usb);
+  EXPECT_EQ(effective_dualsense.report_descriptor, dualsense.report_descriptor);
+
   EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::pen), BTN_TOOL_PEN);
   EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::eraser), BTN_TOOL_RUBBER);
   EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::brush), BTN_TOOL_BRUSH);