From 4f3a5547d6cc4d9c0f8a0e34ada5c73bdc023b3d Mon Sep 17 00:00:00 2001
From: Vicki Pfau <vi@endrift.com>
Date: Mon, 29 Jul 2024 22:01:53 -0700
Subject: [PATCH] manager/user: Move relevant methods to GpuPerformanceLevel1,
 update as specified

---
 com.steampowered.SteamOSManager1.Manager.xml |  40 ------
 src/bin/steamosctl.rs                        |  18 ++-
 src/manager/root.rs                          |   6 +-
 src/manager/user.rs                          | 123 ++++++++++++-------
 src/power.rs                                 |  50 ++++----
 src/proxy/manager.rs                         |  20 ---
 6 files changed, 115 insertions(+), 142 deletions(-)

diff --git a/com.steampowered.SteamOSManager1.Manager.xml b/com.steampowered.SteamOSManager1.Manager.xml
index e7badba..55963bc 100644
--- a/com.steampowered.SteamOSManager1.Manager.xml
+++ b/com.steampowered.SteamOSManager1.Manager.xml
@@ -31,46 +31,6 @@
     -->
     <property name="Version" type="u" access="read"/>
 
-    <!--
-        GpuPerformanceLevel:
-
-        The current GPU performance level.
-
-        Valid states: 0 = Auto, 1 = Low, 2 = High, 3 = Manual, 4 = Profile Peak
-
-        Since: 7
-    -->
-    <property name="GpuPerformanceLevel" type="u" access="readwrite"/>
-
-    <!--
-        ManualGpuClock:
-
-        Controls the GPU clock frequency in MHz when GPUPerformanceLevel is set
-        to Manual.
-
-        Since: 7
-    -->
-    <property name="ManualGpuClock" type="u" access="readwrite"/>
-
-    <!--
-        ManualGpuClockMin:
-
-        Minimum frequency allowed for GPU clocks.
-
-        Since: 7
-    -->
-    <property name="ManualGpuClockMin" type="u" access="read"/>
-
-    <!--
-        ManualGpuClockMax:
-
-        Maximum frequency allowed for GPU clocks.
-
-        Since: 7
-    -->
-    <property name="ManualGpuClockMax" type="u" access="read"/>
-
-
     <!--
         TdpLimit:
 
diff --git a/src/bin/steamosctl.rs b/src/bin/steamosctl.rs
index 09df163..37e12f7 100644
--- a/src/bin/steamosctl.rs
+++ b/src/bin/steamosctl.rs
@@ -14,8 +14,8 @@ use steamos_manager::hardware::FanControlState;
 use steamos_manager::power::{CPUScalingGovernor, GPUPerformanceLevel, GPUPowerProfile};
 use steamos_manager::proxy::{
     AmbientLightSensor1Proxy, CpuScaling1Proxy, FactoryReset1Proxy, FanControl1Proxy,
-    GpuPowerProfile1Proxy, HdmiCec1Proxy, Manager2Proxy, ManagerProxy, Storage1Proxy,
-    UpdateBios1Proxy, UpdateDock1Proxy, WifiPowerManagement1Proxy,
+    GpuPerformanceLevel1Proxy, GpuPowerProfile1Proxy, HdmiCec1Proxy, Manager2Proxy, ManagerProxy,
+    Storage1Proxy, UpdateBios1Proxy, UpdateDock1Proxy, WifiPowerManagement1Proxy,
 };
 use steamos_manager::wifi::{WifiBackend, WifiDebugMode, WifiPowerManagement};
 use zbus::fdo::PropertiesProxy;
@@ -75,7 +75,7 @@ enum Commands {
 
     /// Set the GPU performance level
     SetGPUPerformanceLevel {
-        /// Valid levels are auto, low, high, manual, peak_performance
+        /// Valid levels are auto, low, high, manual, profile_peak
         level: GPUPerformanceLevel,
     },
 
@@ -279,27 +279,35 @@ async fn main() -> Result<()> {
                 .await?;
         }
         Commands::SetGPUPerformanceLevel { level } => {
-            proxy.set_gpu_performance_level(*level as u32).await?;
+            let proxy = GpuPerformanceLevel1Proxy::new(&conn).await?;
+            proxy
+                .set_gpu_performance_level(level.to_string().as_str())
+                .await?;
         }
         Commands::GetGPUPerformanceLevel => {
+            let proxy = GpuPerformanceLevel1Proxy::new(&conn).await?;
             let level = proxy.gpu_performance_level().await?;
-            match GPUPerformanceLevel::try_from(level) {
+            match GPUPerformanceLevel::try_from(level.as_str()) {
                 Ok(l) => println!("GPU performance level: {}", l),
                 Err(_) => println!("Got unknown value {level} from backend"),
             }
         }
         Commands::SetManualGPUClock { freq } => {
+            let proxy = GpuPerformanceLevel1Proxy::new(&conn).await?;
             proxy.set_manual_gpu_clock(*freq).await?;
         }
         Commands::GetManualGPUClock => {
+            let proxy = GpuPerformanceLevel1Proxy::new(&conn).await?;
             let clock = proxy.manual_gpu_clock().await?;
             println!("Manual GPU Clock: {clock}");
         }
         Commands::GetManualGPUClockMax => {
+            let proxy = GpuPerformanceLevel1Proxy::new(&conn).await?;
             let value = proxy.manual_gpu_clock_max().await?;
             println!("Manual GPU Clock Max: {value}");
         }
         Commands::GetManualGPUClockMin => {
+            let proxy = GpuPerformanceLevel1Proxy::new(&conn).await?;
             let value = proxy.manual_gpu_clock_min().await?;
             println!("Manual GPU Clock Min: {value}");
         }
diff --git a/src/manager/root.rs b/src/manager/root.rs
index 037d071..9e08be1 100644
--- a/src/manager/root.rs
+++ b/src/manager/root.rs
@@ -200,7 +200,7 @@ impl SteamOSManager {
             .map_err(to_zbus_fdo_error)
     }
 
-    async fn set_gpu_performance_level(&self, level: u32) -> fdo::Result<()> {
+    async fn set_gpu_performance_level(&self, level: &str) -> fdo::Result<()> {
         let level = match GPUPerformanceLevel::try_from(level) {
             Ok(level) => level,
             Err(e) => return Err(to_zbus_fdo_error(e)),
@@ -442,7 +442,7 @@ mod test {
         default_path = "/com/steampowered/SteamOSManager1"
     )]
     trait GpuPerformanceLevel {
-        fn set_gpu_performance_level(&self, level: u32) -> zbus::Result<()>;
+        fn set_gpu_performance_level(&self, level: String) -> zbus::Result<()>;
     }
 
     #[tokio::test]
@@ -455,7 +455,7 @@ mod test {
             .await
             .unwrap();
         proxy
-            .set_gpu_performance_level(GPUPerformanceLevel::Low as u32)
+            .set_gpu_performance_level(GPUPerformanceLevel::Low.to_string())
             .await
             .expect("proxy_set");
         assert_eq!(
diff --git a/src/manager/user.rs b/src/manager/user.rs
index b43fcfa..9c42ded 100644
--- a/src/manager/user.rs
+++ b/src/manager/user.rs
@@ -21,9 +21,9 @@ use crate::error::{to_zbus_error, to_zbus_fdo_error, zbus_to_zbus_fdo};
 use crate::hardware::{check_support, HardwareCurrentlySupported};
 use crate::job::JobManagerCommand;
 use crate::power::{
-    get_available_cpu_scaling_governors, get_available_gpu_power_profiles,
-    get_cpu_scaling_governor, get_gpu_clocks, get_gpu_clocks_range, get_gpu_performance_level,
-    get_gpu_power_profile, get_tdp_limit,
+    get_available_cpu_scaling_governors, get_available_gpu_performance_levels,
+    get_available_gpu_power_profiles, get_cpu_scaling_governor, get_gpu_clocks,
+    get_gpu_clocks_range, get_gpu_performance_level, get_gpu_power_profile, get_tdp_limit,
 };
 use crate::wifi::{get_wifi_backend, get_wifi_power_management_state};
 use crate::API_VERSION;
@@ -110,6 +110,10 @@ struct FanControl1 {
     proxy: Proxy<'static>,
 }
 
+struct GpuPerformanceLevel1 {
+    proxy: Proxy<'static>,
+}
+
 struct GpuPowerProfile1 {
     proxy: Proxy<'static>,
 }
@@ -160,48 +164,6 @@ impl SteamOSManager {
         API_VERSION
     }
 
-    #[zbus(property(emits_changed_signal = "false"))]
-    async fn gpu_performance_level(&self) -> fdo::Result<u32> {
-        match get_gpu_performance_level().await {
-            Ok(level) => Ok(level as u32),
-            Err(e) => {
-                error!("Error getting GPU performance level: {e}");
-                Err(to_zbus_fdo_error(e))
-            }
-        }
-    }
-
-    #[zbus(property)]
-    async fn set_gpu_performance_level(&self, level: u32) -> zbus::Result<()> {
-        self.proxy
-            .call("SetGpuPerformanceLevel", &(level))
-            .await
-            .map_err(to_zbus_error)
-    }
-
-    #[zbus(property(emits_changed_signal = "false"))]
-    async fn manual_gpu_clock(&self) -> fdo::Result<u32> {
-        get_gpu_clocks()
-            .await
-            .inspect_err(|message| error!("Error getting manual GPU clock: {message}"))
-            .map_err(to_zbus_fdo_error)
-    }
-
-    #[zbus(property)]
-    async fn set_manual_gpu_clock(&self, clocks: u32) -> zbus::Result<()> {
-        setter!(self, "SetManualGpuClock", clocks)
-    }
-
-    #[zbus(property(emits_changed_signal = "const"))]
-    async fn manual_gpu_clock_min(&self) -> fdo::Result<u32> {
-        Ok(get_gpu_clocks_range().await.map_err(to_zbus_fdo_error)?.0)
-    }
-
-    #[zbus(property(emits_changed_signal = "const"))]
-    async fn manual_gpu_clock_max(&self) -> fdo::Result<u32> {
-        Ok(get_gpu_clocks_range().await.map_err(to_zbus_fdo_error)?.1)
-    }
-
     #[zbus(property(emits_changed_signal = "false"))]
     async fn tdp_limit(&self) -> fdo::Result<u32> {
         get_tdp_limit().await.map_err(to_zbus_fdo_error)
@@ -333,6 +295,60 @@ impl FanControl1 {
     }
 }
 
+#[interface(name = "com.steampowered.SteamOSManager1.GpuPerformanceLevel1")]
+impl GpuPerformanceLevel1 {
+    #[zbus(property(emits_changed_signal = "false"))]
+    async fn available_gpu_performance_levels(&self) -> fdo::Result<Vec<String>> {
+        get_available_gpu_performance_levels()
+            .await
+            .inspect_err(|message| error!("Error getting GPU performance levels: {message}"))
+            .map(|levels| levels.into_iter().map(|level| level.to_string()).collect())
+            .map_err(to_zbus_fdo_error)
+    }
+
+    #[zbus(property(emits_changed_signal = "false"))]
+    async fn gpu_performance_level(&self) -> fdo::Result<String> {
+        match get_gpu_performance_level().await {
+            Ok(level) => Ok(level.to_string()),
+            Err(e) => {
+                error!("Error getting GPU performance level: {e}");
+                Err(to_zbus_fdo_error(e))
+            }
+        }
+    }
+
+    #[zbus(property)]
+    async fn set_gpu_performance_level(&self, level: &str) -> zbus::Result<()> {
+        self.proxy
+            .call("SetGpuPerformanceLevel", &(level))
+            .await
+            .map_err(to_zbus_error)
+    }
+
+    #[zbus(property(emits_changed_signal = "false"))]
+    async fn manual_gpu_clock(&self) -> fdo::Result<u32> {
+        get_gpu_clocks()
+            .await
+            .inspect_err(|message| error!("Error getting manual GPU clock: {message}"))
+            .map_err(to_zbus_fdo_error)
+    }
+
+    #[zbus(property)]
+    async fn set_manual_gpu_clock(&self, clocks: u32) -> zbus::Result<()> {
+        setter!(self, "SetManualGpuClock", clocks)
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    async fn manual_gpu_clock_min(&self) -> fdo::Result<u32> {
+        Ok(get_gpu_clocks_range().await.map_err(to_zbus_fdo_error)?.0)
+    }
+
+    #[zbus(property(emits_changed_signal = "const"))]
+    async fn manual_gpu_clock_max(&self) -> fdo::Result<u32> {
+        Ok(get_gpu_clocks_range().await.map_err(to_zbus_fdo_error)?.1)
+    }
+}
+
 #[interface(name = "com.steampowered.SteamOSManager1.GpuPowerProfile1")]
 impl GpuPowerProfile1 {
     #[zbus(property(emits_changed_signal = "false"))]
@@ -493,6 +509,9 @@ pub(crate) async fn create_interfaces(
     let fan_control = FanControl1 {
         proxy: proxy.clone(),
     };
+    let gpu_performance_level = GpuPerformanceLevel1 {
+        proxy: proxy.clone(),
+    };
     let gpu_power_profile = GpuPowerProfile1 {
         proxy: proxy.clone(),
     };
@@ -523,6 +542,9 @@ pub(crate) async fn create_interfaces(
     object_server.at(MANAGER_PATH, cpu_scaling).await?;
     object_server.at(MANAGER_PATH, factory_reset).await?;
     object_server.at(MANAGER_PATH, fan_control).await?;
+    object_server
+        .at(MANAGER_PATH, gpu_performance_level)
+        .await?;
     object_server.at(MANAGER_PATH, gpu_power_profile).await?;
     object_server.at(MANAGER_PATH, hdmi_cec).await?;
     object_server.at(MANAGER_PATH, manager2).await?;
@@ -636,6 +658,17 @@ mod test {
             .unwrap());
     }
 
+    #[tokio::test]
+    async fn interface_matches_gpu_performance_level1() {
+        let test = start().await.expect("start");
+
+        assert!(
+            test_interface_matches::<GpuPerformanceLevel1>(&test.connection)
+                .await
+                .unwrap()
+        );
+    }
+
     #[tokio::test]
     async fn interface_matches_gpu_power_profile1() {
         let test = start().await.expect("start");
diff --git a/src/power.rs b/src/power.rs
index 11d4cd5..633600d 100644
--- a/src/power.rs
+++ b/src/power.rs
@@ -11,7 +11,7 @@ use regex::Regex;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use strum::{Display, EnumString};
-use tokio::fs::{self, File};
+use tokio::fs::{self, try_exists, File};
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tracing::{error, warn};
 
@@ -77,29 +77,12 @@ impl TryFrom<u32> for GPUPowerProfile {
 
 #[derive(Display, EnumString, PartialEq, Debug, Copy, Clone)]
 #[strum(serialize_all = "snake_case")]
-#[repr(u32)]
 pub enum GPUPerformanceLevel {
-    Auto = 0,
-    Low = 1,
-    High = 2,
-    Manual = 3,
-    ProfilePeak = 4,
-}
-
-impl TryFrom<u32> for GPUPerformanceLevel {
-    type Error = &'static str;
-    fn try_from(v: u32) -> Result<Self, Self::Error> {
-        match v {
-            x if x == GPUPerformanceLevel::Auto as u32 => Ok(GPUPerformanceLevel::Auto),
-            x if x == GPUPerformanceLevel::Low as u32 => Ok(GPUPerformanceLevel::Low),
-            x if x == GPUPerformanceLevel::High as u32 => Ok(GPUPerformanceLevel::High),
-            x if x == GPUPerformanceLevel::Manual as u32 => Ok(GPUPerformanceLevel::Manual),
-            x if x == GPUPerformanceLevel::ProfilePeak as u32 => {
-                Ok(GPUPerformanceLevel::ProfilePeak)
-            }
-            _ => Err("No enum match for value {v}"),
-        }
-    }
+    Auto,
+    Low,
+    High,
+    Manual,
+    ProfilePeak,
 }
 
 #[derive(Display, EnumString, Hash, Eq, PartialEq, Debug, Copy, Clone)]
@@ -232,6 +215,21 @@ pub(crate) async fn set_gpu_power_profile(value: GPUPowerProfile) -> Result<()>
     write_gpu_sysfs_contents(GPU_POWER_PROFILE_SUFFIX, profile.as_bytes()).await
 }
 
+pub(crate) async fn get_available_gpu_performance_levels() -> Result<Vec<GPUPerformanceLevel>> {
+    let base = find_hwmon().await?;
+    if !try_exists(base.join(GPU_PERFORMANCE_LEVEL_SUFFIX)).await? {
+        Ok(Vec::new())
+    } else {
+        Ok(vec![
+            GPUPerformanceLevel::Auto,
+            GPUPerformanceLevel::Low,
+            GPUPerformanceLevel::High,
+            GPUPerformanceLevel::Manual,
+            GPUPerformanceLevel::ProfilePeak,
+        ])
+    }
+}
+
 pub(crate) async fn get_gpu_performance_level() -> Result<GPUPerformanceLevel> {
     let level = read_gpu_sysfs_contents(GPU_PERFORMANCE_LEVEL_SUFFIX).await?;
     Ok(GPUPerformanceLevel::from_str(level.trim())?)
@@ -733,18 +731,12 @@ CCLK_RANGE in Core0:
     #[test]
     fn gpu_performance_level_roundtrip() {
         enum_roundtrip!(GPUPerformanceLevel {
-            0: u32 = Auto,
-            1: u32 = Low,
-            2: u32 = High,
-            3: u32 = Manual,
-            4: u32 = ProfilePeak,
             "auto": str = Auto,
             "low": str = Low,
             "high": str = High,
             "manual": str = Manual,
             "profile_peak": str = ProfilePeak,
         });
-        assert!(GPUPerformanceLevel::try_from(9).is_err());
         assert!(GPUPerformanceLevel::from_str("peak_performance").is_err());
     }
 
diff --git a/src/proxy/manager.rs b/src/proxy/manager.rs
index d6f22a7..51c7243 100644
--- a/src/proxy/manager.rs
+++ b/src/proxy/manager.rs
@@ -22,26 +22,6 @@ trait Manager {
     /// SetWifiDebugMode method
     fn set_wifi_debug_mode(&self, mode: u32, buffer_size: u32) -> zbus::Result<()>;
 
-    /// GpuPerformanceLevel property
-    #[zbus(property)]
-    fn gpu_performance_level(&self) -> zbus::Result<u32>;
-    #[zbus(property)]
-    fn set_gpu_performance_level(&self, value: u32) -> zbus::Result<()>;
-
-    /// ManualGpuClock property
-    #[zbus(property)]
-    fn manual_gpu_clock(&self) -> zbus::Result<u32>;
-    #[zbus(property)]
-    fn set_manual_gpu_clock(&self, value: u32) -> zbus::Result<()>;
-
-    /// ManualGpuClockMax property
-    #[zbus(property)]
-    fn manual_gpu_clock_max(&self) -> zbus::Result<u32>;
-
-    /// ManualGpuClockMin property
-    #[zbus(property)]
-    fn manual_gpu_clock_min(&self) -> zbus::Result<u32>;
-
     /// TdpLimit property
     #[zbus(property)]
     fn tdp_limit(&self) -> zbus::Result<u32>;