Add the missing dirs, dumbarse

asusd/src/ctrl_profiles/controller.rs

@@ -0,0 +1,191 @@
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{info, warn};
+use rog_platform::platform::AsusPlatform;
+use rog_platform::supported::PlatformProfileFunctions;
+use rog_profiles::error::ProfileError;
+use rog_profiles::{FanCurveProfiles, Profile};
+
+use super::config::{FanCurveConfig, ProfileConfig};
+use crate::error::RogError;
+use crate::GetSupported;
+
+// TODO: macro wrapper for warn/info/error log macros to add module name
+const MOD_NAME: &str = "CtrlPlatformProfile";
+
+pub struct FanCurves {
+    config_file: FanCurveConfig,
+    profiles: FanCurveProfiles,
+}
+
+impl FanCurves {
+    pub fn update_profiles_from_config(&mut self) {
+        self.profiles.balanced = self.config_file.balanced.clone();
+        self.profiles.performance = self.config_file.performance.clone();
+        self.profiles.quiet = self.config_file.quiet.clone();
+    }
+
+    pub fn update_config_from_profiles(&mut self) {
+        self.config_file.balanced = self.profiles.balanced.clone();
+        self.config_file.performance = self.profiles.performance.clone();
+        self.config_file.quiet = self.profiles.quiet.clone();
+    }
+
+    pub fn profiles(&self) -> &FanCurveProfiles {
+        &self.profiles
+    }
+
+    pub fn profiles_mut(&mut self) -> &mut FanCurveProfiles {
+        &mut self.profiles
+    }
+}
+
+pub struct CtrlPlatformProfile {
+    pub profile_config: ProfileConfig,
+    pub fan_curves: Option<FanCurves>,
+    pub platform: AsusPlatform,
+}
+
+impl GetSupported for CtrlPlatformProfile {
+    type A = PlatformProfileFunctions;
+
+    fn get_supported() -> Self::A {
+        if !Profile::is_platform_profile_supported() {
+            warn!(
+                "platform_profile kernel interface not found, your laptop does not support this, \
+                 or the interface is missing."
+            );
+        }
+
+        let res = FanCurveProfiles::is_supported();
+        let mut fan_curve_supported = res.is_err();
+        if let Ok(r) = res {
+            fan_curve_supported = r;
+        };
+
+        if !fan_curve_supported {
+            info!(
+                "fan curves kernel interface not found, your laptop does not support this, or the \
+                 interface is missing."
+            );
+        }
+
+        PlatformProfileFunctions {
+            platform_profile: Profile::is_platform_profile_supported(),
+            fan_curves: fan_curve_supported,
+        }
+    }
+}
+
+impl CtrlPlatformProfile {
+    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
+        let platform = AsusPlatform::new()?;
+        if platform.has_platform_profile() || platform.has_throttle_thermal_policy() {
+            info!("{MOD_NAME}: Device has profile control available");
+
+            let mut controller = CtrlPlatformProfile {
+                profile_config: config,
+                fan_curves: None,
+                platform,
+            };
+            if FanCurveProfiles::get_device().is_ok() {
+                info!("{MOD_NAME}: Device has fan curves available");
+                let fan_config = FanCurveConfig::new();
+                // Only do defaults if the config doesn't already exist
+                if !fan_config.file_path().exists() {
+                    info!("{MOD_NAME}: Fetching default fan curves");
+                    controller.fan_curves = Some(FanCurves {
+                        config_file: fan_config,
+                        profiles: FanCurveProfiles::default(),
+                    });
+                    for _ in [Profile::Balanced, Profile::Performance, Profile::Quiet] {
+                        // For each profile we need to switch to it before we
+                        // can read the existing values from hardware. The ACPI method used
+                        // for this is what limits us.
+                        controller.set_next_profile()?;
+                        // Make sure to set the baseline to default
+                        controller.set_active_curve_to_defaults()?;
+                        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+
+                        if let Some(curves) = controller.fan_curves.as_ref() {
+                            info!(
+                                "{MOD_NAME}: {active:?}: {}",
+                                String::from(curves.profiles().get_fan_curves_for(active))
+                            );
+                        }
+                    }
+                    if let Some(curves) = controller.fan_curves.as_ref() {
+                        curves.config_file.write();
+                    }
+                } else {
+                    info!("{MOD_NAME}: Fan curves previously stored, loading...");
+                    let mut fan_curves = FanCurves {
+                        config_file: fan_config.load(),
+                        profiles: FanCurveProfiles::default(),
+                    };
+                    fan_curves.update_profiles_from_config();
+                    controller.fan_curves = Some(fan_curves);
+                }
+            }
+
+            return Ok(controller);
+        }
+
+        Err(ProfileError::NotSupported.into())
+    }
+
+    pub fn save_config(&mut self) {
+        self.profile_config.write();
+        if let Some(fans) = self.fan_curves.as_mut() {
+            fans.update_config_from_profiles();
+            fans.config_file.write(); // config write
+        }
+    }
+
+    /// Toggle to next profile in list. This will first read the config, switch,
+    /// then write out
+    pub(super) fn set_next_profile(&mut self) -> Result<(), RogError> {
+        // Read first just incase the user has modified the config before calling this
+        match self.profile_config.active_profile {
+            Profile::Balanced => {
+                Profile::set_profile(Profile::Performance)?;
+                self.profile_config.active_profile = Profile::Performance;
+            }
+            Profile::Performance => {
+                Profile::set_profile(Profile::Quiet)?;
+                self.profile_config.active_profile = Profile::Quiet;
+            }
+            Profile::Quiet => {
+                Profile::set_profile(Profile::Balanced)?;
+                self.profile_config.active_profile = Profile::Balanced;
+            }
+        }
+        self.write_profile_curve_to_platform()?;
+        Ok(())
+    }
+
+    /// Set the curve for the active profile active
+    pub(super) fn write_profile_curve_to_platform(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = &mut self.fan_curves {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.profiles_mut().write_profile_curve_to_platform(
+                    self.profile_config.active_profile,
+                    &mut device,
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = self.fan_curves.as_mut() {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.profiles_mut().set_active_curve_to_defaults(
+                    self.profile_config.active_profile,
+                    &mut device,
+                )?;
+                curves.update_config_from_profiles();
+            }
+        }
+        Ok(())
+    }
+}