fix(SteamDeck Target): Properly normailize unsigned values

- Adds denormalize_unsgned_value_to_signed_value to steam deck target.
- Fix setting touching to true for steamdeck target.
- Fix OrangePi NEO Touchpad Driver hid_report.
- Set Legion Go, Steam Deck, and OrangePi NEO to steam deck target.

rootfs/usr/share/inputplumber/devices/50-legion_go.yaml

@@ -151,6 +151,6 @@ source_devices:
 
 # The target input device(s) that the virtual device profile can use
 target_devices:
-  - xbox-elite
+  - deck
   - mouse
   - keyboard

rootfs/usr/share/inputplumber/devices/50-orangepi_neo.yaml

@@ -22,24 +22,24 @@ matches:
 # One or more source devices to combine into a single virtual device. The events
 # from these devices will be watched and translated according to the key map.
 source_devices:
-  ## Touch Devices
-  #- group: mouse
-  #  unique: false
-  #  hidraw:
-  #    vendor_id: 0x0911
-  #    product_id: 0x5288
-  #- group: mouse
-  #  blocked: true
-  #  evdev:
-  #    name: OPI0001:00 0911:5288 Touchpad
-  #    phys_path: i2c-OPI0001:00
-  #    handler: event*
-  #- group: mouse
-  #  blocked: true
-  #  evdev:
-  #    name: OPI0002:00 0911:5288 Touchpad
-  #    phys_path: i2c-OPI0002:00
-  #    handler: event*
+  # Touch Devices
+  - group: mouse
+    unique: false
+    hidraw:
+      vendor_id: 0x0911
+      product_id: 0x5288
+  - group: mouse
+    blocked: true
+    evdev:
+      name: OPI0001:00 0911:5288 Touchpad
+      phys_path: i2c-OPI0001:00
+      handler: event*
+  - group: mouse
+    blocked: true
+    evdev:
+      name: OPI0002:00 0911:5288 Touchpad
+      phys_path: i2c-OPI0002:00
+      handler: event*
 
   ## Gamepad Devices
   - group: gamepad
@@ -67,7 +67,7 @@ source_devices:
 
 # The target input device(s) that the virtual device profile can use
 target_devices:
-  - xb360
+  - deck
   - mouse
   - keyboard
 

rootfs/usr/share/inputplumber/devices/50-steam_deck.yaml

@@ -53,7 +53,7 @@ source_devices:
 
 # The target input device(s) that the virtual device profile can use
 target_devices:
-  - xbox-elite
+  - deck
   - mouse
   - keyboard
   - touchscreen

src/drivers/opineo/hid_report.rs

@@ -41,15 +41,15 @@ pub struct TouchpadDataReport {
     // BYTE 2-3
     #[packed_field(bytes = "2..=3", endian = "lsb")]
     pub touch_x: Integer<u16, packed_bits::Bits<16>>,
-    // BYTE 4
-    #[packed_field(bytes = "4")]
-    pub unk_4: u8,
-    // BYTE 5-6
-    #[packed_field(bytes = "5..=6", endian = "lsb")]
+    // BYTE 4-5
+    #[packed_field(bytes = "4..=5", endian = "lsb")]
     pub touch_y: Integer<u16, packed_bits::Bits<16>>,
-    // BYTE 7-8
-    #[packed_field(bytes = "7..=8", endian = "lsb")]
+    // BYTE 6-7
+    #[packed_field(bytes = "6..=7", endian = "lsb")]
     pub scan_time: Integer<u16, packed_bits::Bits<16>>,
+    // BYTE 8
+    #[packed_field(bytes = "8")]
+    pub contact_count: u8,
     // BYTE 9
     #[packed_field(bytes = "9")]
     pub unk_9: u8,
@@ -61,9 +61,9 @@ impl Default for TouchpadDataReport {
             report_id: Default::default(),
             confidence: Default::default(),
             touch_x: Default::default(),
-            unk_4: Default::default(),
             touch_y: Default::default(),
             scan_time: Default::default(),
+            contact_count: Default::default(),
             unk_9: Default::default(),
         }
     }

src/input/source/hidraw/opineo.rs

@@ -87,11 +87,14 @@ fn normalize_unsigned_value(raw_value: f64, max: f64) -> f64 {
 /// Normalize the value to something between -1.0 and 1.0 based on the Deck's
 /// minimum and maximum axis ranges.
 fn normalize_axis_value(event: event::TouchAxisInput) -> InputValue {
+    let x = event.x;
+    let y = event.y;
+    log::trace!("Got axis to normalize: {x}, {y}");
     let max = driver::PAD_X_MAX;
-    let x = normalize_unsigned_value(event.x as f64, max);
+    let x = normalize_unsigned_value(x as f64, max);
 
     let max = driver::PAD_Y_MAX;
-    let y = normalize_unsigned_value(event.y as f64, max);
+    let y = normalize_unsigned_value(y as f64, max);
 
     // If this is an UP event, don't override the position of X/Y
     let (x, y) = if !event.is_touching {
@@ -100,6 +103,7 @@ fn normalize_axis_value(event: event::TouchAxisInput) -> InputValue {
         (Some(x), Some(y))
     };
 
+    log::trace!("Normalized axis: {x:?}, {y:?}");
     InputValue::Touch {
         index: event.index,
         is_touching: event.is_touching,

src/input/target/dualsense.rs

@@ -2,14 +2,7 @@
 //! The DualSense implementation is based on the great work done by NeroReflex
 //! and the ROGueENEMY project:
 //! https://github.com/NeroReflex/ROGueENEMY/
-use std::{
-    cmp::Ordering,
-    error::Error,
-    fmt::Debug,
-    fs::File,
-    time::{Duration, SystemTime, UNIX_EPOCH},
-    usize,
-};
+use std::{cmp::Ordering, error::Error, fs::File, time::Duration};
 
 use packed_struct::prelude::*;
 use rand::{self, Rng};

src/input/target/steam_deck.rs

@@ -452,9 +452,9 @@ impl VirtualDeckController {
                 Reply::from_xfer(xfer, &[])
             }
             HidRequest::GetReport(req) => {
-                log::trace!("GetReport: {req}");
+                //log::trace!("GetReport: {req}");
                 let interface = req.interface.to_primitive();
-                log::trace!("Got GetReport data for iface {interface}");
+                //log::trace!("Got GetReport data for iface {interface}");
                 let report_type = req.report_type;
 
                 // Handle GetReport
@@ -577,7 +577,7 @@ impl VirtualDeckController {
     /// Out transfers do not have any replies.
     fn handle_xfer_out(&mut self, xfer: Xfer) {
         // OUT transfers (host -> device) are generally always to ep 0
-        log::trace!("Got OUT transfer for endpoint: {}", xfer.ep);
+        //log::trace!("Got OUT transfer for endpoint: {}", xfer.ep);
 
         let Some(setup) = xfer.header() else {
             log::debug!("No setup request in OUT xfer");
@@ -598,14 +598,14 @@ impl VirtualDeckController {
                 log::warn!("Unknown HID request!");
             }
             HidRequest::SetIdle(req) => {
-                log::trace!("SetIdle: {req}");
+                //log::trace!("SetIdle: {req}");
             }
             // The host wants to set the given report on the device
             HidRequest::SetReport(req) => {
-                log::trace!("SetReport: {req}");
+                //log::trace!("SetReport: {req}");
                 let interface = req.interface.to_primitive();
                 let data = xfer.data;
-                log::trace!("Got SetReport data for iface {interface}: {data:?}");
+                //log::trace!("Got SetReport data for iface {interface}: {data:?}");
 
                 // The first byte contains the report type
                 let Some(first_byte) = data.first() else {
@@ -625,7 +625,7 @@ impl VirtualDeckController {
                     // ClearMappings gets called to take the controller out of lizard
                     // mode so that Steam can control it directly.
                     ReportType::ClearMappings => {
-                        log::trace!("Disabling lizard mode");
+                        //log::trace!("Disabling lizard mode");
                         self.lizard_mode_enabled = false;
                     }
                     ReportType::GetMappings => (),
@@ -685,10 +685,7 @@ impl VirtualDeckController {
                     GamepadButton::West => self.state.y = event.pressed(),
                     GamepadButton::Start => self.state.menu = event.pressed(),
                     GamepadButton::Select => self.state.options = event.pressed(),
-                    GamepadButton::Guide => {
-                        log::debug!("Got GUIDE button: {}", event.pressed());
-                        self.state.steam = event.pressed()
-                    }
+                    GamepadButton::Guide => self.state.steam = event.pressed(),
                     GamepadButton::QuickAccess => self.state.quick_access = event.pressed(),
                     GamepadButton::DPadUp => self.state.up = event.pressed(),
                     GamepadButton::DPadDown => self.state.down = event.pressed(),
@@ -851,18 +848,21 @@ impl VirtualDeckController {
                     Touch::Motion => {
                         if let InputValue::Touch {
                             index: _,
-                            is_touching: _,
+                            is_touching,
                             pressure: _,
                             x,
                             y,
                         } = value
                         {
+                            self.state.l_pad_touch = is_touching;
                             if let Some(x) = x {
-                                let value = denormalize_signed_value(x, PAD_X_MIN, PAD_X_MAX);
+                                let value =
+                                    denormalize_unsigned_to_signed_value(x, PAD_X_MIN, PAD_X_MAX);
                                 self.state.l_pad_x = Integer::from_primitive(value);
                             };
                             if let Some(y) = y {
-                                let value = denormalize_signed_value(y, PAD_Y_MIN, PAD_Y_MAX);
+                                let value =
+                                    denormalize_unsigned_to_signed_value(y, PAD_Y_MIN, PAD_Y_MAX);
                                 self.state.l_pad_y = Integer::from_primitive(value);
                             };
                         }
@@ -876,18 +876,21 @@ impl VirtualDeckController {
                     Touch::Motion => {
                         if let InputValue::Touch {
                             index: _,
-                            is_touching: _,
+                            is_touching,
                             pressure: _,
                             x,
                             y,
                         } = value
                         {
+                            self.state.r_pad_touch = is_touching;
                             if let Some(x) = x {
-                                let value = denormalize_signed_value(x, PAD_X_MIN, PAD_X_MAX);
+                                let value =
+                                    denormalize_unsigned_to_signed_value(x, PAD_X_MIN, PAD_X_MAX);
                                 self.state.r_pad_x = Integer::from_primitive(value);
                             };
                             if let Some(y) = y {
-                                let value = denormalize_signed_value(y, PAD_Y_MIN, PAD_Y_MAX);
+                                let value =
+                                    denormalize_unsigned_to_signed_value(y, PAD_Y_MIN, PAD_Y_MAX);
                                 self.state.r_pad_y = Integer::from_primitive(value);
                             };
                         }
@@ -905,7 +908,7 @@ impl VirtualDeckController {
     }
 }
 
-/// Convert the given normalized value to the real value based on the given
+/// Convert the given normalized signed value to the real value based on the given
 /// minimum and maximum axis range.
 fn denormalize_signed_value(normal_value: f64, min: f64, max: f64) -> i16 {
     let mid = (max + min) / 2.0;
@@ -921,6 +924,13 @@ fn denormalize_signed_value(normal_value: f64, min: f64, max: f64) -> i16 {
     }
 }
 
+/// Convert the given normalized unsigned value to the real value based on the given
+/// minimum and maximum axis range.
+fn denormalize_unsigned_to_signed_value(normal_value: f64, min: f64, max: f64) -> i16 {
+    let normal_value = (normal_value * 2.0) - 1.0;
+    denormalize_signed_value(normal_value, min, max)
+}
+
 /// De-normalizes the given value from 0.0 - 1.0 into a real value based on
 /// the maximum axis range.
 fn denormalize_unsigned_value(normal_value: f64, max: f64) -> u16 {