fix(AsusWMI): use platform to set TDP instead of FirmwareAttributes

src/performance/gpu/asus/asus_wmi.rs

@@ -1,85 +1,55 @@
 use crate::performance::gpu::tdp::{TDPError, TDPResult};
 
-use rog_platform::{
-    firmware_attributes::{AttrValue, FirmwareAttributes},
-    platform::RogPlatform,
-};
+use rog_platform::{error::PlatformError, platform::RogPlatform};
+
+impl From<PlatformError> for TDPError {
+    fn from(value: PlatformError) -> Self {
+        Self::FailedOperation(value.to_string())
+    }
+}
 
 /// Implementation of asus-wmi sysfs
 /// See https://www.kernel.org/doc/html/v6.8-rc4/admin-guide/abi-testing.html#abi-sys-devices-platform-platform-ppt-apu-sppt
 pub struct AsusWmi {
-    attributes: FirmwareAttributes,
+    platform: RogPlatform,
 }
 
 impl AsusWmi {
     /// test if we are in an asus system with asus-wmi loaded
     pub async fn new() -> Option<Self> {
         match RogPlatform::new() {
-            Ok(_) => {
+            Ok(platform) => {
                 log::info!("Module asus-wmi found");
-                Some(Self {
-                    attributes: FirmwareAttributes::new(),
-                })
+                Some(Self { platform })
             }
             Err(err) => {
-                log::info!("Module asus-wmi not found: {}", err);
+                log::info!("Module asus-wmi not found: {err:?}");
                 None
             }
         }
     }
 
     /// Returns the currently set STAPM value
     pub async fn tdp(&self) -> TDPResult<f64> {
-        match self
-            .attributes
-            .attributes()
-            .iter()
-            .find(|a| a.name() == "ppt_pl1_spl")
-            .unwrap()
-            .current_value()
-        {
-            Ok(attr_value) => match attr_value {
-                AttrValue::Integer(value) => {
-                    log::info!("Found STAPM value: {value}");
-                    Ok(value as f64)
-                }
-                _ => Err(TDPError::FailedOperation(
-                    "Failed to read STAPM value".to_string(),
-                )),
-            },
-            Err(e) => Err(TDPError::FailedOperation(format!(
-                "Failed to read STAPM Value: {e:?}"
-            ))),
-        }
+        Ok(self.platform.get_ppt_pl1_spl()? as f64)
     }
 
     /// Sets STAPM to the given value and adjusts the SPPT/FPPT to maintaing the current boost
     /// ratio
     pub async fn set_tdp(&mut self, value: f64) -> TDPResult<()> {
+        if value < 1.0 || value > u8::MAX as f64 {
+            return Err(TDPError::InvalidArgument(
+                "Value must be between 1 and 255".to_string(),
+            ));
+        }
+
         // Get the current Boost value
         let boost = self.boost().await?;
 
         // Set the STAPM value to the given TDP value
-        let val = AttrValue::Integer(value as i32);
-        match self
-            .attributes
-            .attributes_mut()
-            .iter()
-            .find(|a| a.name() == "ppt_pl1_spl")
-            .unwrap()
-            .set_current_value(val)
-        {
-            Ok(_) => {
-                log::info!("Set STAPM value to {value}");
-            }
-            Err(e) => {
-                return Err(TDPError::FailedOperation(format!(
-                    "Failed to set STAPM value: {e:}"
-                )));
-            }
-        }
+        self.platform.set_ppt_pl1_spl(value as u8)?;
 
-        // Set the boost back to the expeted value with the new TDP
+        // Set the boost back to the expected value with the new TDP
         self.set_boost(boost).await?;
 
         Ok(())
@@ -93,35 +63,10 @@ impl AsusWmi {
                 return Err(e);
             }
         };
-
-        let slow_ppt = match self
-            .attributes
-            .attributes()
-            .iter()
-            .find(|a| a.name() == "ppt_platform_sppt")
-            .unwrap()
-            .current_value()
-        {
-            Ok(attr_value) => match attr_value {
-                AttrValue::Integer(value) => {
-                    log::info!("Found Slow PPT value: {value}");
-                    value as f64
-                }
-                _ => {
-                    return Err(TDPError::FailedOperation(
-                        "Failed to read Slow PPT value".to_string(),
-                    ))
-                }
-            },
-            Err(e) => {
-                return Err(TDPError::FailedOperation(format!(
-                    "Failed to read Slow PPT value: {e:?}"
-                )))
-            }
-        };
-
+        let slow_ppt = self.platform.get_ppt_platform_sppt()? as f64;
         let boost = slow_ppt - stapm;
         log::info!("Found current boost: {boost}");
+
         Ok(boost)
     }
 
@@ -133,28 +78,15 @@ impl AsusWmi {
                 return Err(e);
             }
         };
-
-        let sppt_val = (stapm + value) as i32;
-        let boost = AttrValue::Integer(sppt_val);
+        if (stapm + value) < 1.0 || (stapm + value) > u8::MAX as f64 {
+            return Err(TDPError::InvalidArgument(
+                "Combined TDP + Boost value must be between 1 and 255".to_string(),
+            ));
+        }
+        let boost = (stapm + value) as u8;
 
         // ppt_platform_sppt will set sppt to value and fppt to value + 25%
-        match self
-            .attributes
-            .attributes_mut()
-            .iter()
-            .find(|a| a.name() == "ppt_platform_sppt")
-            .unwrap()
-            .set_current_value(boost)
-        {
-            Ok(_) => {
-                log::info!("Set Slow PPT to {sppt_val}");
-            }
-            Err(e) => {
-                return Err(TDPError::FailedOperation(format!(
-                    "Failed to set Slow PPT: {e:?}"
-                )))
-            }
-        };
+        self.platform.set_ppt_platform_sppt(boost)?;
 
         Ok(())
     }