fix(steam-deck): harden native discovery timing

Author: ReenigneArcher

docs/platform-support.md

@@ -82,8 +82,9 @@ Game Pad while retaining the Valve-native report bytes, so Windows Game
 Controllers and generic HID clients can enumerate it even if the Valve-specific
 path is unavailable. SDL/HIDAPI can recognize it as a Steam Deck, disable its
 desktop mappings, and send native rumble without exposing Valve protocol details
-through the public C++ API. A neutral state is submitted continuously from the
-moment the backend is created, and each packet carries an advancing native
+through the public C++ API. The driver seeds a neutral report before exposing the
+device, the backend submits another synchronously during creation, and periodic
+updates continue afterward. Each backend packet carries an advancing native
 sequence number.
 
 See [Windows driver package](windows-driver.md) for build, install, validation,
@@ -149,14 +150,14 @@ provides it separately on the UHID event.
 
 Steam Deck retains Valve's native identity and emits the 64-byte Deck state
 packet periodically so SDL's direct HIDAPI path can initialize before the first
-client input arrives. Its UHID endpoint uses the virtual bus, preventing the
-hardware-specific `hid-steam` driver from suppressing input behind the physical
-Deck's lizard-mode gate; the Generic Desktop/Game Pad descriptor remains
-available as an evdev fallback. The backend answers the unit-serial feature
-query used during Linux registration, accepts the desktop-mapping/settings
-commands used by SDL, and forwards native `0xEB` rumble requests through the
-portable output callback. Each submitted native packet carries an advancing
-sequence number.
+client input arrives. Its UHID endpoint uses the Bluetooth HID transport tag:
+this remains visible to HIDAPI while avoiding the USB-only `hid-steam` match
+that otherwise suppresses the virtual endpoint's reports when a direct HID
+client opens it. The Generic Desktop/Game Pad descriptor remains available as
+an evdev fallback. The backend answers the unit-serial feature query used during
+Linux registration, accepts the desktop-mapping/settings commands used by SDL,
+and forwards native `0xEB` rumble requests through the portable output callback.
+Each submitted native packet carries an advancing sequence number.
 
 The backend opens `/dev/uhid` in nonblocking mode, matching the original
 asynchronous gamepad registration path. Its event reader is active before

src/platform/linux/uhid_backend.cpp

@@ -319,15 +319,17 @@ namespace lvh::detail {
 
 #if defined(__linux__)
     std::uint16_t to_uhid_bus(const DeviceProfile &profile) {
-      if (
-        profile.gamepad_kind == GamepadProfileKind::switch_pro ||
-        profile.gamepad_kind == GamepadProfileKind::steam_deck
-      ) {
-        // Prevent hardware-specific kernel drivers from taking over these
-        // virtual endpoints. In particular, hid-steam suppresses Steam Deck
-        // gamepad input while its hardware-only lizard-mode gate is active.
+      if (profile.gamepad_kind == GamepadProfileKind::switch_pro) {
+        // Prevent hardware-specific kernel drivers from taking over this
+        // virtual endpoint.
         return BUS_VIRTUAL;
       }
+      if (profile.gamepad_kind == GamepadProfileKind::steam_deck) {
+        // hid-steam matches the Deck's USB identity and suppresses its input
+        // while a hidraw client is open. BUS_VIRTUAL avoids that driver but is
+        // filtered out by hidapi, so use its other supported HID transport.
+        return BUS_BLUETOOTH;
+      }
       return to_uhid_bus(profile.bus_type);
     }
 

src/platform/windows/windows_backend.cpp

@@ -1048,6 +1048,16 @@ namespace lvh::detail {
           response.device_path[0] == '\0' ? command_channel_->path() : std::string {response.device_path.data()}
         );
 
+        if (state->profile.gamepad_kind == GamepadProfileKind::steam_deck) {
+          static_cast<void>(
+            stamp_steam_deck_packet_number(state->last_input_report, ++state->steam_deck_packet_number)
+          );
+          if (const auto status = submit_gamepad_report(state, state->last_input_report); !status.ok()) {
+            static_cast<void>(command_channel_->destroy_device(state->driver_id, state->token));
+            return {status, nullptr};
+          }
+        }
+
         {
           std::lock_guard lock {devices_mutex_};
           gamepads_[state->driver_id] = state;

tests/fixtures/include/fixtures/windows_backend_test_hooks.hpp

@@ -55,6 +55,7 @@ namespace lvh::detail::test {
     OperationStatus create_status;
     OperationStatus submit_status;
     OperationStatus close_status;
+    std::size_t reports_immediately_after_create = 0;
     std::size_t reports_before_submit = 0;
     std::size_t reports_before_close = 0;
     std::size_t reports_after_close = 0;

tests/fixtures/linux_backend_test_hooks.cpp

@@ -1695,7 +1695,7 @@ namespace lvh::detail::test {
     options.metadata.stable_id = "linux-steam-deck";
 
     UhidGamepad gamepad {descriptors[0]};
-    auto event = create_started_profile_uhid_gamepad(gamepad, 11, options, descriptors[1], BUS_VIRTUAL, result);
+    auto event = create_started_profile_uhid_gamepad(gamepad, 11, options, descriptors[1], BUS_BLUETOOTH, result);
     gamepad.set_output_callback([&result](const GamepadOutput &output) {
       if (output.kind == GamepadOutputKind::rumble) {
         ++result.output.callback_count;

tests/fixtures/windows_backend_test_hooks.cpp

@@ -512,6 +512,7 @@ namespace lvh::detail {
       if (!created) {
         return result;
       }
+      result.reports_immediately_after_create = command_state->submit_report_count();
 
       static_cast<void>(wait_until([&command_state] {
         return command_state->submit_report_count() >= 2U;

tests/unit/test_linux_backend.cpp

@@ -124,7 +124,7 @@ TEST_F(LinuxBackendTest, TranslatesMouseButtonsAndBusTypes) {
   EXPECT_EQ(lvh::detail::test::linux_uhid_bus(lvh::BusType::bluetooth), BUS_BLUETOOTH);
   EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::xbox_series), BUS_USB);
   EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::switch_pro), BUS_VIRTUAL);
-  EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::steam_deck), BUS_VIRTUAL);
+  EXPECT_EQ(lvh::detail::test::linux_gamepad_uhid_bus(lvh::GamepadProfileKind::steam_deck), BUS_BLUETOOTH);
   EXPECT_EQ(lvh::detail::test::linux_uinput_bus(lvh::BusType::bluetooth), BUS_BLUETOOTH);
 
   EXPECT_EQ(lvh::detail::test::linux_pen_tool(lvh::PenToolType::pen), BTN_TOOL_PEN);

tests/unit/test_windows_backend.cpp

@@ -100,6 +100,7 @@ TEST_F(WindowsBackendTest, SteamDeckRepeatsNativeStateUntilClose) {
   ASSERT_TRUE(result.create_status.ok()) << result.create_status.message();
   ASSERT_TRUE(result.submit_status.ok()) << result.submit_status.message();
   ASSERT_TRUE(result.close_status.ok()) << result.close_status.message();
+  EXPECT_GE(result.reports_immediately_after_create, 1U);
   EXPECT_GE(result.reports_before_submit, 2U);
   EXPECT_GT(result.reports_before_close, result.reports_before_submit);
   EXPECT_TRUE(result.packet_numbers_advance);