feat(profiles): add Valve Steam Deck gamepad

Introduces a native Steam Deck controller profile (VID 0x28DE, PID 0x1205) across all supported backends:

- New `GamepadProfileKind::steam_deck` enum value and `profiles::steam_deck()` factory
- 64-byte vendor HID descriptor, native state packet packing (buttons, sticks, triggers, touch, motion)
- `SteamDeckFeatureReportState` shared helper for feature-report initialization (serial query, desktop-mapping commands, rumble via `0xEB`)
- Linux uhid backend: 4 ms periodic reports, SET/GET feature handling, serial seeding from stable_id
- Windows backend: periodic state re-submission thread, feature-report responder, VHF queue dedup on button bytes
- FreeBSD uses uinput path for Steam Deck (same as Xbox/Switch)
- Four rear paddles (L4/R4/L5/R5) exposed via `supported_rear_paddle_count = 4`, Quick Access mapped to `misc1`
- Protocol constant `LVH_WINDOWS_GAMEPAD_STEAM_DECK = 7`, broker validation updated
- Full unit and consumer tests on Linux, Windows, and FreeBSD backends

Author: ReenigneArcher

README.md

@@ -43,8 +43,8 @@ behind backend implementations.
 ## 🎮 Capabilities
 
 - Gamepad profiles for generic HID, Xbox 360, Xbox One, Xbox Series,
-  DualShock 4, DualSense, and Nintendo Switch Pro-style controllers.
-- Descriptor-driven PlayStation gamepads through Linux `uhid`; Generic, Xbox,
+  DualShock 4, DualSense, Nintendo Switch Pro-style, and Steam Deck controllers.
+- Descriptor-driven PlayStation and Steam Deck gamepads through Linux `uhid`; Generic, Xbox,
   and Switch Pro gamepads plus keyboard, mouse, touchscreen, trackpad, and pen
   tablet devices through `uinput`.
 - Windows gamepads through a user-mode UMDF2 control driver backed by Virtual
@@ -149,6 +149,7 @@ Alternatives exist if `libvirtualhid` does not meet your needs.
 | DualShock 4 gamepad               | ✅                                                | ✅                                                | ✅                                                       | ❌                                                        | ✅<sup><a href="#alternatives-note-4">4</a></sup> |
 | DualSense gamepad                 | ✅                                                | ❌                                                | ✅                                                       | ✅                                                        | ✅<sup><a href="#alternatives-note-4">4</a></sup> |
 | Nintendo Switch Pro-style gamepad | ✅                                                | ❌                                                | ✅                                                       | ✅                                                        | ✅<sup><a href="#alternatives-note-4">4</a></sup> |
+| Steam Deck gamepad                | ✅                                                | ❌                                                | ❌                                                       | ❌                                                        | ❌                                                |
 | Rumble or output callbacks        | ✅                                                | ❌                                                | ✅                                                       | ✅                                                        | ✅<sup><a href="#alternatives-note-4">4</a></sup> |
 | Data-driven profiles              | ❌                                                | ❌                                                | ✅                                                       | ❌                                                        | ❌                                                |
 | Actively developed                | ✅                                                | ❌                                                | ✅                                                       | ✅                                                        | ✅                                                |

docs/platform-support.md

@@ -75,7 +75,11 @@ The VHF driver answers the calibration, pairing, and firmware feature reports
 used to initialize DualShock 4 and DualSense HIDAPI output. It also answers the
 Switch Pro USB and subcommand initialization sequence and accepts the native
 `0x30` input layout, so descriptor-aware consumers can initialize those
-controllers before sending their native output reports.
+controllers before sending their native output reports. The Steam Deck profile
+uses Valve's `0x28DE:0x1205` USB identity and native 64-byte state and feature
+reports. SDL/HIDAPI can therefore recognize it as a Steam Deck, disable its
+desktop mappings, and send native rumble without exposing Valve protocol details
+through the public C++ API.
 
 See [Windows driver package](windows-driver.md) for build, install, validation,
 and signing details.
@@ -84,7 +88,7 @@ and signing details.
 
 The Linux backend uses standard user-space kernel interfaces:
 
-- `uhid` for descriptor-driven HID gamepads.
+- `uhid` for descriptor-driven HID gamepads, including Steam Deck.
 - `uinput` for Generic, Xbox 360, Xbox One, Xbox Series, and Switch Pro
   gamepads, plus keyboard, mouse, touchscreen, trackpad, and pen tablet
   devices.
@@ -131,13 +135,20 @@ buttons, Guide, L3, and R3 at their expected indices. D-pad directions are
 reported through the hat axes and exposed as logical buttons by standard
 gamepad consumers.
 
-DualShock 4 and DualSense remain on `uhid` so their descriptors, motion,
+DualShock 4, DualSense, and Steam Deck remain on `uhid` so their descriptors, motion,
 touchpad, battery, feature reports, and profile-specific output reports stay
 available. The backend accepts PlayStation output through both UHID interrupt
 and control channels. Numbered control-channel output is normalized before
 parsing, whether the kernel includes the report number in the payload or
 provides it separately on the UHID event.
 
+Steam Deck retains Valve's native USB identity and emits the 64-byte Deck state
+packet periodically so both the kernel `hid-steam` driver and SDL's direct
+HIDAPI path can initialize before the first client input arrives. The backend
+answers the unit-serial feature query used during Linux registration, accepts
+the desktop-mapping/settings commands used by SDL and `hid-steam`, and forwards
+native `0xEB` rumble requests through the portable output callback.
+
 The backend opens `/dev/uhid` in nonblocking mode, matching the original
 asynchronous gamepad registration path. Its event reader is active before
 device registration begins, and creation does not report success until the
@@ -246,8 +257,8 @@ The FreeBSD backend uses the native evdev compatibility stack through
 FreeBSD path, and `/dev/uinput` for environments that provide the Linux-style
 alias. It supports the same uinput device categories as the Linux backend:
 
-- Generic, Xbox 360, Xbox One, Xbox Series, DualShock 4, DualSense, and Switch
-  Pro gamepads.
+- Generic, Xbox 360, Xbox One, Xbox Series, DualShock 4, DualSense, Switch Pro,
+  and Steam Deck gamepads.
 - Keyboard and mouse devices, with X11/XTest available as a fallback.
 - Touchscreen, trackpad, and pen tablet devices.
 
@@ -259,8 +270,8 @@ with the kernel HID bus. FreeBSD CUSE applications such as
 a `uhid(4)`-compatible character device for direct consumers, but that is a
 different integration surface and is not used by the current backend.
 
-Generic, Xbox-family, Switch Pro, DualShock 4, and DualSense behavior therefore
-uses uinput. Ordinary buttons, sticks, analog triggers, and rumble are available,
+Generic, Xbox-family, Switch Pro, DualShock 4, DualSense, and Steam Deck behavior
+therefore uses uinput. Ordinary buttons, sticks, analog triggers, and rumble are available,
 but raw HID reports and descriptor-driven features are not.
 
 For each created gamepad, `Gamepad::profile()` reports the effective FreeBSD

docs/streaming-host-integration.md

@@ -51,9 +51,11 @@ The core API and adapter shape cover the major streaming-host requirements:
 - Rich controller metadata.
 - Gamepad output callbacks.
 - Keyboard and mouse input paths.
-- Linux PlayStation gamepads through `uhid`, Generic/Xbox/Switch Pro gamepads
-  through `uinput`, and `uinput` keyboard/pointer devices.
+- Linux PlayStation and Steam Deck gamepads through `uhid`, Generic/Xbox/Switch
+  Pro gamepads through `uinput`, and `uinput` keyboard/pointer devices.
 - Linux DualSense and DualShock 4 USB/Bluetooth report handling.
+- Native Steam Deck identity, input, feature-report initialization, touch/motion,
+  rear-button, Quick Access, and rumble handling on Windows and Linux.
 - Linux touchscreen, trackpad, and pen tablet device types.
 - FreeBSD uinput gamepads and pointer devices, with basic PlayStation input and
   rumble but without Linux UHID-only PlayStation features.

docs/usage.md

@@ -212,6 +212,7 @@ Built-in gamepad profiles and their platform-neutral default device names are:
 | DualShock 4 USB and Bluetooth | `(libvirtualhid) PS4 Controller`          |
 | DualSense USB and Bluetooth   | `(libvirtualhid) PS5 Controller`          |
 | Nintendo Switch Pro           | `(libvirtualhid) Nintendo Pro Controller` |
+| Steam Deck                    | `(libvirtualhid) Steam Deck Controller`   |
 
 Consumers may replace `DeviceProfile::name` before creating a gamepad, for
 example, to prepend an application name while preserving the default controller
@@ -226,6 +227,8 @@ Profiles advertise support for features such as rumble, trigger rumble, RGB
 LEDs, adaptive triggers, motion sensors, touchpads, battery state,
 profile-specific buttons, and raw output reports. Consumers should query profile and
 backend capabilities before warning users about unsupported client features.
-The `misc1` button represents Share/Capture/Mic Mute-style controls and is
-available on the generic, Xbox Series, DualSense, and Switch Pro profiles; Xbox
-360 and Xbox One do not advertise that extra button.
+The `misc1` button represents Share/Capture/Mic Mute/Quick Access-style controls
+and is available on the generic, Xbox Series, DualSense, Switch Pro, and Steam
+Deck profiles; Xbox 360 and Xbox One do not advertise that extra button. Steam
+Deck also exposes its two trackpads through the two portable touch contacts and
+maps its L4/R4/L5/R5 rear controls to the four paddle buttons.

docs/windows-driver.md

@@ -381,6 +381,11 @@ gamepad.
 DualShock 4 and DualSense answer the calibration, pairing, and firmware feature
 requests used by their Windows HIDAPI initialization paths. Switch Pro answers
 the native USB and subcommand handshake and submits native `0x30` input reports.
+Steam Deck uses Valve's `VID_28DE&PID_1205` identity, responds to the unnumbered
+feature-report sequence used by SDL/HIDAPI, submits native 64-byte Deck state
+reports, and normalizes native `0xEB` rumble requests into the public callback.
+The driver queues a neutral Deck state before starting VHF so already-running
+consumers can receive the first packet within SDL's short endpoint-probe window.
 The built-in Generic profile is presented to Windows as a DirectInput PID
 Joystick with the complete output-report set required for DirectInput
 enumeration. Constant Force and Sine output is normalized to the portable

examples/gamepad_adapter.cpp

@@ -39,6 +39,9 @@ namespace {
     if (name == "switch") {
       return lvh::profiles::switch_pro();
     }
+    if (name == "steamdeck") {
+      return lvh::profiles::steam_deck();
+    }
 
     return std::nullopt;
   }
@@ -58,6 +61,7 @@ namespace {
       case switch_pro:
         return nintendo;
       case generic:
+      case steam_deck:
         return unknown;
     }
 

src/core/gamepad_adapter.cpp

@@ -47,6 +47,7 @@ namespace lvh {
         case xbox_series:
         case dualsense:
         case switch_pro:
+        case steam_deck:
           return true;
         case xbox_360:
         case xbox_one:
@@ -88,6 +89,9 @@ namespace lvh {
     support.supports_battery = profile.capabilities.supports_battery;
     support.supports_misc1_button = supports_common_misc1_button(profile.gamepad_kind);
     support.supports_touchpad_button = profile.capabilities.supports_touchpad;
+    if (profile.gamepad_kind == GamepadProfileKind::steam_deck) {
+      support.supported_rear_paddle_count = 4U;
+    }
 
     return support;
   }

src/core/profiles.cpp

@@ -41,6 +41,10 @@ namespace lvh::profiles {
 
     constexpr std::size_t switch_pro_output_report_size = 64;
 
+    constexpr std::size_t steam_deck_input_report_size = 64;
+
+    constexpr std::size_t steam_deck_feature_report_size = 64;
+
     constexpr std::size_t dualshock4_usb_input_report_size = 64;
 
     constexpr std::size_t dualshock4_usb_output_report_size = 32;
@@ -269,6 +273,40 @@ namespace lvh::profiles {
       return bytes_from_hex(descriptor);
     }
 
+    std::vector<std::uint8_t> make_steam_deck_report_descriptor() {
+      // The native Steam Deck controller endpoint carries an unnumbered
+      // 64-byte vendor input report and an unnumbered 64-byte feature report.
+      return {
+        0x06,
+        0x00,
+        0xFF,  // Usage Page (Vendor Defined 0xFF00)
+        0x09,
+        0x01,  // Usage (Vendor Usage 1)
+        0xA1,
+        0x01,  // Collection (Application)
+        0x15,
+        0x00,  // Logical Minimum (0)
+        0x26,
+        0xFF,
+        0x00,  // Logical Maximum (255)
+        0x75,
+        0x08,  // Report Size (8)
+        0x95,
+        0x40,  // Report Count (64)
+        0x09,
+        0x01,  // Usage (Vendor Usage 1)
+        0x81,
+        0x02,  // Input (Data,Var,Abs)
+        0x09,
+        0x02,  // Usage (Vendor Usage 2)
+        0x95,
+        0x40,  // Report Count (64)
+        0xB1,
+        0x02,  // Feature (Data,Var,Abs)
+        0xC0,  // End Collection
+      };
+    }
+
     std::vector<std::uint8_t> make_gamepad_report_descriptor(std::uint8_t report_id, bool supports_rumble) {
       std::vector<std::uint8_t> descriptor {
         0x05,
@@ -2036,6 +2074,28 @@ namespace lvh::profiles {
       return profile;
     }
 
+    DeviceProfile make_steam_deck_profile() {
+      DeviceProfile profile;
+      profile.device_type = DeviceType::gamepad;
+      profile.gamepad_kind = GamepadProfileKind::steam_deck;
+      profile.bus_type = BusType::usb;
+      profile.vendor_id = 0x28DE;
+      profile.product_id = 0x1205;
+      profile.version = 0x0100;
+      profile.report_id = 0;
+      profile.input_report_size = steam_deck_input_report_size;
+      profile.output_report_size = steam_deck_feature_report_size;
+      profile.name = "(libvirtualhid) Steam Deck Controller";
+      profile.manufacturer = "Valve Software";
+      profile.capabilities = {
+        .supports_rumble = true,
+        .supports_motion = true,
+        .supports_touchpad = true,
+      };
+      profile.report_descriptor = make_steam_deck_report_descriptor();
+      return profile;
+    }
+
     DeviceProfile make_simple_profile(DeviceType device_type, std::string name, std::uint16_t product_id) {
       DeviceProfile profile;
       profile.device_type = device_type;
@@ -2124,6 +2184,10 @@ namespace lvh::profiles {
     return make_switch_pro_profile();
   }
 
+  DeviceProfile steam_deck() {
+    return make_steam_deck_profile();
+  }
+
   DeviceProfile keyboard() {
     return make_simple_profile(DeviceType::keyboard, "libvirtualhid Keyboard", 0x0002);
   }
@@ -2160,6 +2224,8 @@ namespace lvh::profiles {
         return dualsense();
       case GamepadProfileKind::switch_pro:
         return switch_pro();
+      case GamepadProfileKind::steam_deck:
+        return steam_deck();
     }
 
     return std::nullopt;
@@ -2174,6 +2240,7 @@ namespace lvh::profiles {
       dualshock4(),
       dualsense(),
       switch_pro(),
+      steam_deck(),
     };
   }