Prep 6.1.0

Add basic zones for G513RC

See merge request asus-linux/asusctl!216

CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [v6.1.0]
+
+### Changed
+- Update deps
+- Add support for G513RC RGB modes
+- Many UI fixes
+- Fixes to PPT settings in UI
+
+## [v6.1.0-rc7]
+
+- Refactor PPT handling more:
+  1. Per profile, per-ac/dc
+  2. Do not apply unless group is enabled
+  3. Better reset/disable handling
+  4. Selecting a profile defaults PPT to off/disabled
+- Bugfix: prevent an AniMe thread async deadlock
+
 ## [v6.1.0-rc6]
 
 ### Changed

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace.package]
-version = "6.1.0-rc6"
+version = "6.1.0"
 rust-version = "1.82"
 license = "MPL-2.0"
 readme = "README.md"

asusctl/src/main.rs

@@ -74,7 +74,15 @@ fn main() {
         println!("\nError: {e}\n");
         print_info();
     }) {
-        let asusd_version = platform_proxy.version().unwrap();
+        let asusd_version = platform_proxy
+            .version()
+            .map_err(|e| {
+                error!(
+                    "Could not get asusd version: {e:?}\nIs asusd.service running? {}",
+                    check_service("asusd")
+                );
+            })
+            .unwrap();
         if asusd_version != self_version {
             println!("Version mismatch: asusctl = {self_version}, asusd = {asusd_version}");
             return;

asusd/src/asus_armoury.rs

@@ -68,30 +68,41 @@ impl AsusArmouryAttribute {
     ) -> Result<(), RogError> {
         use zbus::export::futures_util::StreamExt;
 
-        let ctrl = self.clone();
         let name = self.name();
-        match self.attr.get_watcher() {
-            Ok(watch) => {
-                let name = <&str>::from(name);
-                tokio::spawn(async move {
-                    let mut buffer = [0; 32];
-                    watch
-                        .into_event_stream(&mut buffer)
-                        .unwrap()
-                        .for_each(|_| async {
-                            debug!("{} changed", name);
-                            ctrl.current_value_changed(&signal_ctxt).await.ok();
-                        })
-                        .await;
-                });
-            }
-            Err(e) => info!(
-                "inotify watch failed: {}. You can ignore this if your device does not support \
-                 the feature",
-                e
-            )
+        macro_rules! watch_value_notify {
+            ($attr_str:expr, $fn_prop_changed:ident) => {
+                match self.attr.get_watcher($attr_str) {
+                    Ok(watch) => {
+                        let name = <&str>::from(name);
+                        let ctrl = self.clone();
+                        let sig = signal_ctxt.clone();
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch
+                                .into_event_stream(&mut buffer)
+                                .unwrap()
+                                .for_each(|_| async {
+                                    debug!("{} changed", name);
+                                    ctrl.$fn_prop_changed(&sig).await.ok();
+                                })
+                                .await;
+                        });
+                    }
+                    Err(e) => info!(
+                        "inotify watch failed: {}. You can ignore this if your device does not \
+                         support the feature",
+                        e
+                    )
+                }
+            };
         }
 
+        // "current_value", "default_value", "min_value", "max_value"
+        watch_value_notify!("current_value", current_value_changed);
+        watch_value_notify!("default_value", default_value_changed);
+        watch_value_notify!("min_value", min_value_changed);
+        watch_value_notify!("max_value", max_value_changed);
+
         Ok(())
     }
 }
@@ -113,15 +124,18 @@ impl crate::Reloadable for AsusArmouryAttribute {
         } else {
             &self.config.lock().await.dc_profile_tunings
         };
-        if let Some(tunings) = config.get(&profile) {
-            if let Some(tune) = tunings.get(&self.name()) {
-                self.attr
-                    .set_current_value(&AttrValue::Integer(*tune))
-                    .map_err(|e| {
-                        error!("Could not set value: {e:?}");
-                        e
-                    })?;
-                info!("Set {} to {:?}", self.attr.name(), tune);
+        if let Some(tuning) = config.get(&profile) {
+            if tuning.enabled {
+                if let Some(tune) = tuning.group.get(&self.name()) {
+                    self.attr
+                        .set_current_value(&AttrValue::Integer(*tune))
+                        .map_err(|e| {
+                            error!("Could not set {} value: {e:?}", self.attr.name());
+                            self.attr.base_path_exists();
+                            e
+                        })?;
+                    info!("Set {} to {:?}", self.attr.name(), tune);
+                }
             }
         }
 
@@ -191,12 +205,20 @@ impl AsusArmouryAttribute {
                 .unwrap_or_default();
 
             let mut config = self.config.lock().await;
-            let tunings = config.select_tunings(power_plugged == 1, profile);
-            if let Some(tune) = tunings.get_mut(&self.name()) {
+            let tuning = config.select_tunings(power_plugged == 1, profile);
+            if let Some(tune) = tuning.group.get_mut(&self.name()) {
                 if let AttrValue::Integer(i) = self.attr.default_value() {
                     *tune = *i;
                 }
             }
+            if tuning.enabled {
+                self.attr
+                    .set_current_value(self.attr.default_value())
+                    .map_err(|e| {
+                        error!("Could not set value: {e:?}");
+                        e
+                    })?;
+            }
             config.write();
         }
         Ok(())
@@ -236,6 +258,28 @@ impl AsusArmouryAttribute {
 
     #[zbus(property)]
     async fn current_value(&self) -> fdo::Result<i32> {
+        if self.name().is_ppt() {
+            let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+            let power_plugged = self
+                .power
+                .get_online()
+                .map_err(|e| {
+                    error!("Could not get power status: {e:?}");
+                    e
+                })
+                .unwrap_or_default();
+            let mut config = self.config.lock().await;
+            let tuning = config.select_tunings(power_plugged == 1, profile);
+            if let Some(tune) = tuning.group.get(&self.name()) {
+                return Ok(*tune);
+            } else if let AttrValue::Integer(i) = self.attr.default_value() {
+                return Ok(*i);
+            }
+            return Err(fdo::Error::Failed(
+                "Could not read current value".to_string()
+            ));
+        }
+
         if let Ok(AttrValue::Integer(i)) = self.attr.current_value() {
             return Ok(i);
         }
@@ -246,16 +290,8 @@ impl AsusArmouryAttribute {
 
     #[zbus(property)]
     async fn set_current_value(&mut self, value: i32) -> fdo::Result<()> {
-        self.attr
-            .set_current_value(&AttrValue::Integer(value))
-            .map_err(|e| {
-                error!("Could not set value: {e:?}");
-                e
-            })?;
-
         if self.name().is_ppt() {
             let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
-
             let power_plugged = self
                 .power
                 .get_online()
@@ -264,16 +300,32 @@ impl AsusArmouryAttribute {
                     e
                 })
                 .unwrap_or_default();
-            let mut config = self.config.lock().await;
-            let tunings = config.select_tunings(power_plugged == 1, profile);
 
-            if let Some(tune) = tunings.get_mut(&self.name()) {
+            let mut config = self.config.lock().await;
+            let tuning = config.select_tunings(power_plugged == 1, profile);
+
+            if let Some(tune) = tuning.group.get_mut(&self.name()) {
                 *tune = value;
             } else {
-                tunings.insert(self.name(), value);
-                debug!("Set tuning config for {} = {:?}", self.attr.name(), value);
+                tuning.group.insert(self.name(), value);
+                debug!("Store tuning config for {} = {:?}", self.attr.name(), value);
+            }
+            if tuning.enabled {
+                self.attr
+                    .set_current_value(&AttrValue::Integer(value))
+                    .map_err(|e| {
+                        error!("Could not set value: {e:?}");
+                        e
+                    })?;
             }
         } else {
+            self.attr
+                .set_current_value(&AttrValue::Integer(value))
+                .map_err(|e| {
+                    error!("Could not set value: {e:?}");
+                    e
+                })?;
+
             let has_attr = self
                 .config
                 .lock()
@@ -309,9 +361,10 @@ pub async fn start_attributes_zbus(
     conn: &Connection,
     platform: RogPlatform,
     power: AsusPower,
+    attributes: FirmwareAttributes,
     config: Arc<Mutex<Config>>
 ) -> Result<(), RogError> {
-    for attr in FirmwareAttributes::new().attributes() {
+    for attr in attributes.attributes() {
         let mut attr = AsusArmouryAttribute::new(
             attr.clone(),
             platform.clone(),
@@ -338,9 +391,13 @@ pub async fn set_config_or_default(
     for attr in attrs.attributes().iter() {
         let name: FirmwareAttribute = attr.name().into();
         if name.is_ppt() {
-            let tunings = config.select_tunings(power_plugged, profile);
+            let tuning = config.select_tunings(power_plugged, profile);
+            if !tuning.enabled {
+                debug!("Tuning group is not enabled, skipping");
+                return;
+            }
 
-            if let Some(tune) = tunings.get(&name) {
+            if let Some(tune) = tuning.group.get(&name) {
                 attr.set_current_value(&AttrValue::Integer(*tune))
                     .map_err(|e| {
                         error!("Failed to set {}: {e}", <&str>::from(name));
@@ -354,13 +411,13 @@ pub async fn set_config_or_default(
                     })
                     .ok();
                 if let AttrValue::Integer(i) = default {
-                    tunings.insert(name, *i);
+                    tuning.group.insert(name, *i);
                     info!(
                         "Set default tuning config for {} = {:?}",
                         <&str>::from(name),
                         i
                     );
-                    config.write();
+                    // config.write();
                 }
             }
         }

asusd/src/aura_anime/mod.rs

@@ -8,7 +8,7 @@ use std::sync::Arc;
 use std::thread::sleep;
 
 use config_traits::StdConfig;
-use log::{error, info, warn};
+use log::{debug, error, info, warn};
 use rog_anime::usb::{
     pkt_flush, pkt_set_brightness, pkt_set_enable_display, pkt_set_enable_powersave_anim,
     pkts_for_init, Brightness
@@ -16,7 +16,7 @@ use rog_anime::usb::{
 use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::usb_raw::USBRaw;
-use tokio::sync::{Mutex, MutexGuard};
+use tokio::sync::Mutex;
 
 use self::config::{AniMeConfig, AniMeConfigCached};
 use crate::error::RogError;
@@ -59,6 +59,8 @@ impl AniMe {
                 config.rename_file_old();
                 *config = AniMeConfig::new();
                 config.write();
+            } else {
+                debug!("Initialised AniMe cache");
             }
         } else {
             error!("AniMe Matrix could not init cache")
@@ -70,11 +72,9 @@ impl AniMe {
         self.do_init_cache().await;
         let pkts = pkts_for_init();
         self.write_bytes(&pkts[0]).await?;
-        self.write_bytes(&pkts[1]).await
-    }
-
-    pub async fn lock_config(&self) -> MutexGuard<AniMeConfig> {
-        self.config.lock().await
+        self.write_bytes(&pkts[1]).await?;
+        debug!("Succesfully initialised AniMe matrix display");
+        Ok(())
     }
 
     pub async fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
@@ -176,7 +176,7 @@ impl AniMe {
                                     return Ok(true); // Do safe exit
                                 }
                                 let inner = inner.clone();
-                                tokio::task::spawn_local(async move {
+                                tokio::task::spawn(async move {
                                     inner
                                         .write_data_buffer(frame)
                                         .await
@@ -227,10 +227,11 @@ impl AniMe {
                     })
                     .ok();
             }
+            // A write can block for many milliseconds so lets not hold the config lock for
+            // the same period
+            let enabled = inner.config.lock().await.builtin_anims_enabled;
             inner
-                .write_bytes(&pkt_set_enable_powersave_anim(
-                    inner.config.lock().await.builtin_anims_enabled
-                ))
+                .write_bytes(&pkt_set_enable_powersave_anim(enabled))
                 .await
                 .map_err(|err| {
                     warn!("rog_anime::run_animation:callback {}", err);

asusd/src/aura_anime/trait_impls.rs

@@ -1,7 +1,7 @@
 use std::sync::atomic::Ordering;
 
 use config_traits::StdConfig;
-use log::{error, warn};
+use log::{debug, error, warn};
 use logind_zbus::manager::ManagerProxy;
 use rog_anime::usb::{
     pkt_set_brightness, pkt_set_builtin_animations, pkt_set_enable_display,
@@ -51,8 +51,11 @@ impl AniMeZbus {
             .object_server()
             .at(path.clone(), self)
             .await
-            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
-            .ok();
+            .map_err(|e| {
+                error!("Couldn't add server at path: {path}, {e:?}");
+                e
+            })?;
+        debug!("start_tasks was successful");
         Ok(())
     }
 }
@@ -440,50 +443,60 @@ impl crate::CtrlTask for AniMeZbus {
 
 impl crate::Reloadable for AniMeZbus {
     async fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(config) = self.0.config.try_lock() {
-            let anim = &config.builtin_anims;
-            // Set builtins
-            if config.builtin_anims_enabled {
-                self.0
-                    .write_bytes(&pkt_set_builtin_animations(
-                        anim.boot, anim.awake, anim.sleep, anim.shutdown
-                    ))
-                    .await?;
-            }
-            // Builtins enabled or na?
+        let AniMeConfig {
+            builtin_anims_enabled,
+            builtin_anims,
+            display_enabled,
+            display_brightness,
+            off_when_lid_closed,
+            off_when_unplugged,
+            ..
+        } = *self.0.config.lock().await;
+
+        // Set builtins
+        if builtin_anims_enabled {
             self.0
-                .set_builtins_enabled(config.builtin_anims_enabled, config.display_brightness)
+                .write_bytes(&pkt_set_builtin_animations(
+                    builtin_anims.boot,
+                    builtin_anims.awake,
+                    builtin_anims.sleep,
+                    builtin_anims.shutdown
+                ))
                 .await?;
+        }
+        // Builtins enabled or na?
+        self.0
+            .set_builtins_enabled(builtin_anims_enabled, display_brightness)
+            .await?;
 
-            let manager = get_logind_manager().await;
-            let lid_closed = manager.lid_closed().await.unwrap_or_default();
-            let power_plugged = manager.on_external_power().await.unwrap_or_default();
+        let manager = get_logind_manager().await;
+        let lid_closed = manager.lid_closed().await.unwrap_or_default();
+        let power_plugged = manager.on_external_power().await.unwrap_or_default();
 
-            let turn_off = (lid_closed && config.off_when_lid_closed)
-                || (!power_plugged && config.off_when_unplugged);
+        let turn_off =
+            (lid_closed && off_when_lid_closed) || (!power_plugged && off_when_unplugged);
+        self.0
+            .write_bytes(&pkt_set_enable_display(!turn_off))
+            .await
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::reload {}", err);
+            })
+            .ok();
+
+        if turn_off || !display_enabled {
+            self.0.write_bytes(&pkt_set_enable_display(false)).await?;
+            // early return so we don't run animation thread
+            return Ok(());
+        }
+
+        if !builtin_anims_enabled && !self.0.cache.boot.is_empty() {
             self.0
-                .write_bytes(&pkt_set_enable_display(!turn_off))
+                .write_bytes(&pkt_set_enable_powersave_anim(false))
                 .await
-                .map_err(|err| {
-                    warn!("create_sys_event_tasks::reload {}", err);
-                })
                 .ok();
 
-            if turn_off || !config.display_enabled {
-                self.0.write_bytes(&pkt_set_enable_display(false)).await?;
-                // early return so we don't run animation thread
-                return Ok(());
-            }
-
-            if !config.builtin_anims_enabled && !self.0.cache.boot.is_empty() {
-                self.0
-                    .write_bytes(&pkt_set_enable_powersave_anim(false))
-                    .await
-                    .ok();
-
-                let action = self.0.cache.boot.clone();
-                self.0.run_thread(action, true).await;
-            }
+            let action = self.0.cache.boot.clone();
+            self.0.run_thread(action, true).await;
         }
         Ok(())
     }

asusd/src/aura_manager.rs

@@ -319,11 +319,17 @@ impl DeviceManager {
                 if let DeviceHandle::AniMe(anime) = dev_type.clone() {
                     let path = dbus_path_for_anime();
                     let ctrl = AniMeZbus::new(anime);
-                    ctrl.start_tasks(connection, path.clone()).await.unwrap();
-                    devices.push(AsusDevice {
-                        device: dev_type,
-                        dbus_path: path
-                    });
+                    if ctrl
+                        .start_tasks(connection, path.clone())
+                        .await
+                        .map_err(|e| error!("Failed to start tasks: {e:?}, not adding this device"))
+                        .is_ok()
+                    {
+                        devices.push(AsusDevice {
+                            device: dev_type,
+                            dbus_path: path
+                        });
+                    }
                 }
             } else {
                 info!("Tested device was not AniMe Matrix");
@@ -364,7 +370,9 @@ impl DeviceManager {
 
     pub async fn new(connection: Connection) -> Result<Self, RogError> {
         let conn_copy = connection.clone();
-        let devices = Arc::new(Mutex::new(Self::find_all_devices(&conn_copy).await));
+        let devices = Self::find_all_devices(&conn_copy).await;
+        info!("Found {} valid devices on startup", devices.len());
+        let devices = Arc::new(Mutex::new(devices));
         let manager = Self {
             _dbus_connection: connection
         };
@@ -372,8 +380,6 @@ impl DeviceManager {
         // TODO: The /sysfs/ LEDs don't cause events, so they need to be manually
         // checked for and added
 
-        // detect all plugged in aura devices (eventually)
-        // only USB devices are detected for here
         std::thread::spawn(move || {
             let mut monitor = MonitorBuilder::new()?.listen()?;
             let mut poll = Poll::new()?;
@@ -420,7 +426,10 @@ impl DeviceManager {
                                     {
                                         index
                                     } else {
-                                        warn!("No device for dbus path: {path:?}");
+                                        if dev_prop_matches(&event.device(), "ID_VENDOR_ID", "0b05")
+                                        {
+                                            warn!("No device for dbus path: {path:?}");
+                                        }
                                         return Ok(());
                                     };
                                     info!("removing: {path:?}");

asusd/src/config.rs

@@ -7,7 +7,13 @@ use rog_platform::platform::PlatformProfile;
 use serde::{Deserialize, Serialize};
 
 const CONFIG_FILE: &str = "asusd.ron";
-type Tunings = HashMap<PlatformProfile, HashMap<FirmwareAttribute, i32>>;
+
+#[derive(Default, Clone, Deserialize, Serialize, PartialEq)]
+pub struct Tuning {
+    pub enabled: bool,
+    pub group: HashMap<FirmwareAttribute, i32>
+}
+type Tunings = HashMap<PlatformProfile, Tuning>;
 
 #[derive(Deserialize, Serialize, PartialEq)]
 pub struct Config {
@@ -47,17 +53,13 @@ pub struct Config {
 }
 
 impl Config {
-    pub fn select_tunings(
-        &mut self,
-        power_plugged: bool,
-        profile: PlatformProfile
-    ) -> &mut HashMap<FirmwareAttribute, i32> {
+    pub fn select_tunings(&mut self, power_plugged: bool, profile: PlatformProfile) -> &mut Tuning {
         let config = if power_plugged {
             &mut self.ac_profile_tunings
         } else {
             &mut self.dc_profile_tunings
         };
-        config.entry(profile).or_insert_with(HashMap::new)
+        config.entry(profile).or_insert_with(Tuning::default)
     }
 }
 

asusd/src/ctrl_platform.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use config_traits::StdConfig;
 use log::{debug, error, info, warn};
-use rog_platform::asus_armoury::FirmwareAttributes;
+use rog_platform::asus_armoury::{AttrValue, FirmwareAttribute, FirmwareAttributes};
 use rog_platform::cpu::{CPUControl, CPUGovernor, CPUEPP};
 use rog_platform::platform::{PlatformProfile, Properties, RogPlatform};
 use rog_platform::power::AsusPower;
@@ -43,24 +43,27 @@ macro_rules! platform_get_value {
 pub struct CtrlPlatform {
     power: AsusPower,
     platform: RogPlatform,
+    attributes: FirmwareAttributes,
     cpu_control: Option<CPUControl>,
     config: Arc<Mutex<Config>>
 }
 
 impl CtrlPlatform {
     pub fn new(
+        platform: RogPlatform,
+        power: AsusPower,
+        attributes: FirmwareAttributes,
         config: Arc<Mutex<Config>>,
         config_path: &Path,
         signal_context: SignalEmitter<'static>
     ) -> Result<Self, RogError> {
-        let platform = RogPlatform::new()?;
-        let power = AsusPower::new()?;
         let config1 = config.clone();
         let config_path = config_path.to_owned();
 
         let ret_self = CtrlPlatform {
             power,
             platform,
+            attributes,
             config,
             cpu_control: CPUControl::new()
                 .map_err(|e| error!("Couldn't get CPU control sysfs: {e}"))
@@ -332,6 +335,7 @@ impl CtrlPlatform {
                     warn!("platform_profile {}", err);
                     FdoErr::Failed(format!("RogPlatform: platform_profile: {err}"))
                 })?;
+            self.enable_ppt_group_changed(&ctxt).await?;
             Ok(self.platform_profile_changed(&ctxt).await?)
         } else {
             Err(FdoErr::NotSupported(
@@ -346,19 +350,27 @@ impl CtrlPlatform {
     }
 
     #[zbus(property)]
-    async fn set_platform_profile(&mut self, policy: PlatformProfile) -> Result<(), FdoErr> {
+    async fn set_platform_profile(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        policy: PlatformProfile
+    ) -> Result<(), FdoErr> {
         // TODO: watch for external changes
         if self.platform.has_platform_profile() {
             let change_epp = self.config.lock().await.platform_profile_linked_epp;
             let epp = self.get_config_epp_for_throttle(policy).await;
             self.check_and_set_epp(epp, change_epp);
+
             self.config.lock().await.write();
+            // TODO: Need to get supported profiles here and ensure we translate to one
             self.platform
                 .set_platform_profile(policy.into())
                 .map_err(|err| {
                     warn!("platform_profile {}", err);
                     FdoErr::Failed(format!("RogPlatform: platform_profile: {err}"))
-                })
+                })?;
+            self.enable_ppt_group_changed(&ctxt).await?;
+            Ok(())
         } else {
             Err(FdoErr::NotSupported(
                 "RogPlatform: platform_profile not supported".to_owned()
@@ -386,10 +398,11 @@ impl CtrlPlatform {
     #[zbus(property)]
     async fn set_platform_profile_on_battery(
         &mut self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
         policy: PlatformProfile
     ) -> Result<(), FdoErr> {
         self.config.lock().await.platform_profile_on_battery = policy;
-        self.set_platform_profile(policy).await?;
+        self.set_platform_profile(ctxt, policy).await?;
         self.config.lock().await.write();
         Ok(())
     }
@@ -412,9 +425,13 @@ impl CtrlPlatform {
     }
 
     #[zbus(property)]
-    async fn set_platform_profile_on_ac(&mut self, policy: PlatformProfile) -> Result<(), FdoErr> {
+    async fn set_platform_profile_on_ac(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        policy: PlatformProfile
+    ) -> Result<(), FdoErr> {
         self.config.lock().await.platform_profile_on_ac = policy;
-        self.set_platform_profile(policy).await?;
+        self.set_platform_profile(ctxt, policy).await?;
         self.config.lock().await.write();
         Ok(())
     }
@@ -475,9 +492,92 @@ impl CtrlPlatform {
         let change_pp = self.config.lock().await.platform_profile_linked_epp;
         self.config.lock().await.profile_performance_epp = epp;
         self.check_and_set_epp(epp, change_pp);
+
         self.config.lock().await.write();
         Ok(())
     }
+
+    /// Set if the PPT tuning group for the current profile is enabled
+    #[zbus(property)]
+    async fn enable_ppt_group(&self) -> Result<bool, FdoErr> {
+        let power_plugged = self
+            .power
+            .get_online()
+            .map_err(|e| {
+                error!("Could not get power status: {e:?}");
+                e
+            })
+            .unwrap_or_default();
+        let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+        Ok(self
+            .config
+            .lock()
+            .await
+            .select_tunings(power_plugged == 1, profile)
+            .enabled)
+    }
+
+    /// Set if the PPT tuning group for the current profile is enabled
+    #[zbus(property)]
+    async fn set_enable_ppt_group(&mut self, enable: bool) -> Result<(), FdoErr> {
+        let power_plugged = self
+            .power
+            .get_online()
+            .map_err(|e| {
+                error!("Could not get power status: {e:?}");
+                e
+            })
+            .unwrap_or_default();
+        let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+
+        if enable {
+            // Clone to reduce blocking
+            let tuning = self
+                .config
+                .lock()
+                .await
+                .select_tunings(power_plugged == 1, profile)
+                .clone();
+
+            for attr in self.attributes.attributes() {
+                let name: FirmwareAttribute = attr.name().into();
+                if name.is_ppt() {
+                    // reset stored value
+                    if let Some(tune) = self
+                        .config
+                        .lock()
+                        .await
+                        .select_tunings(power_plugged == 1, profile)
+                        .group
+                        .get_mut(&name)
+                    {
+                        let value = tuning
+                            .group
+                            .get(&name)
+                            .map(|v| AttrValue::Integer(*v))
+                            .unwrap_or_else(|| attr.default_value().clone());
+                        // restore default
+                        attr.set_current_value(&value)?;
+                        if let AttrValue::Integer(i) = value {
+                            *tune = i
+                        }
+                    }
+                }
+            }
+        } else {
+            // finally, reapply the profile to ensure acpi does the thingy
+            self.platform.set_platform_profile(profile.into())?;
+        }
+
+        self.config
+            .lock()
+            .await
+            .select_tunings(power_plugged == 1, profile)
+            .enabled = enable;
+        self.config.lock().await.write();
+
+        Ok(())
+    }
 }
 
 impl crate::ZbusRun for CtrlPlatform {
@@ -576,6 +676,7 @@ impl CtrlTask for CtrlPlatform {
         let platform1 = self.clone();
         let platform2 = self.clone();
         let platform3 = self.clone();
+        let signal_ctxt_copy = signal_ctxt.clone();
         self.create_sys_event_tasks(
             move |sleeping| {
                 let platform1 = platform1.clone();
@@ -643,6 +744,7 @@ impl CtrlTask for CtrlPlatform {
             },
             move |power_plugged| {
                 let platform3 = platform3.clone();
+                let signal_ctxt_copy = signal_ctxt.clone();
                 // power change
                 async move {
                     if platform3.platform.has_platform_profile() {
@@ -665,6 +767,7 @@ impl CtrlTask for CtrlPlatform {
                             error!("Platform: get_platform_profile error: {e}");
                         })
                     {
+                        // TODO: manage this better, shouldn't need to create every time
                         let attrs = FirmwareAttributes::new();
                         set_config_or_default(
                             &attrs,
@@ -673,6 +776,10 @@ impl CtrlTask for CtrlPlatform {
                             profile
                         )
                         .await;
+                        platform3
+                            .enable_ppt_group_changed(&signal_ctxt_copy)
+                            .await
+                            .ok();
                     }
                 }
             }
@@ -681,7 +788,7 @@ impl CtrlTask for CtrlPlatform {
 
         // This spawns a new task for every item.
         // TODO: find a better way to manage this
-        self.watch_charge_control_end_threshold(signal_ctxt.clone())
+        self.watch_charge_control_end_threshold(signal_ctxt_copy.clone())
             .await?;
 
         let watch_platform_profile = self.platform.monitor_platform_profile()?;
@@ -708,7 +815,8 @@ impl CtrlTask for CtrlPlatform {
                         let change_epp = ctrl.config.lock().await.platform_profile_linked_epp;
                         let epp = ctrl.get_config_epp_for_throttle(profile).await;
                         ctrl.check_and_set_epp(epp, change_epp);
-                        ctrl.platform_profile_changed(&signal_ctxt).await.ok();
+                        ctrl.platform_profile_changed(&signal_ctxt_copy).await.ok();
+                        ctrl.enable_ppt_group_changed(&signal_ctxt_copy).await.ok();
                         let power_plugged = ctrl
                             .power
                             .get_online()

asusd/src/daemon.rs

@@ -12,6 +12,7 @@ use asusd::ctrl_platform::CtrlPlatform;
 use asusd::{print_board_info, start_tasks, CtrlTask, DBUS_NAME};
 use config_traits::{StdConfig, StdConfigLoad1};
 use log::{error, info};
+use rog_platform::asus_armoury::FirmwareAttributes;
 use rog_platform::platform::RogPlatform;
 use rog_platform::power::AsusPower;
 use zbus::fdo::ObjectManager;
@@ -69,7 +70,15 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     // supported.add_to_server(&mut connection).await;
     let platform = RogPlatform::new()?; // TODO: maybe needs async mutex?
     let power = AsusPower::new()?; // TODO: maybe needs async mutex?
-    start_attributes_zbus(&server, platform, power, config.clone()).await?;
+    let attributes = FirmwareAttributes::new();
+    start_attributes_zbus(
+        &server,
+        platform.clone(),
+        power.clone(),
+        attributes.clone(),
+        config.clone()
+    )
+    .await?;
 
     match CtrlFanCurveZbus::new() {
         Ok(ctrl) => {
@@ -82,6 +91,9 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     }
 
     match CtrlPlatform::new(
+        platform,
+        power,
+        attributes,
         config.clone(),
         &cfg_path,
         CtrlPlatform::signal_context(&server)?
@@ -100,6 +112,7 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     // Request dbus name after finishing initalizing all functions
     server.request_name(DBUS_NAME).await?;
 
+    info!("Startup success, begining dbus server loop");
     loop {
         // This is just a blocker to idle and ensure the reator reacts
         server.executor().tick().await;

data/asusd.service

@@ -6,7 +6,7 @@ After=nvidia-powerd.service systemd-udevd.service
 
 [Service]
 Environment=IS_SERVICE=1
-Environment=RUST_LOG="info"
+Environment=RUST_LOG="debug"
 # required to prevent init issues with hid_asus and MCU
 ExecStartPre=/bin/sleep 1
 ExecStart=/usr/bin/asusd
@@ -16,3 +16,4 @@ Type=dbus
 BusName=xyz.ljones.Asusd
 SELinuxContext=system_u:system_r:unconfined_t:s0
 #SELinuxContext=system_u:object_r:modules_object_t:s0
+TimeoutSec=10

rog-aura/data/aura_support.ron

@@ -80,6 +80,15 @@
         advanced_type: None,
         power_zones: [Keyboard],
     ),
+    (
+        device_name: "FX617X",
+        product_id: "",
+        layout_name: "fa506i",
+        basic_modes: [Static, Breathe, Pulse],
+        basic_zones: [],
+        advanced_type: None,
+        power_zones: [Keyboard],
+    ),
     (
         device_name: "FX705D",
         product_id: "",
@@ -139,7 +148,7 @@
         product_id: "",
         layout_name: "g513i",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
-        basic_zones: [],
+        basic_zones: [Key1, Key2, Key3, Key4],
         advanced_type: Zoned([ZonedKbLeft, ZonedKbLeftMid, ZonedKbRightMid, ZonedKbRight, LightbarRight, LightbarRightCorner, LightbarRightBottom, LightbarLeftBottom, LightbarLeftCorner, LightbarLeft]),
         power_zones: [Keyboard, Lightbar],
     ),
@@ -854,4 +863,4 @@
         advanced_type: None,
         power_zones: [Ally],
     ),
-])
+])

rog-aura/src/aura_detection.rs

@@ -91,7 +91,7 @@ impl LedSupportFile {
     /// to ensure we match to *whole names* first before doing a glob match
     fn match_device(&self, device_name: &str, product_id: &str) -> LedSupportData {
         for config in self.0.iter().rev() {
-            if device_name.contains(&config.device_name) {
+            if device_name.eq_ignore_ascii_case(&config.device_name) {
                 info!("Matched to {}", config.device_name);
                 if !config.product_id.is_empty() {
                     info!("Checking product ID");

rog-control-center/build.rs

@@ -5,7 +5,6 @@ use slint_build::CompilerConfiguration;
 
 fn main() {
     // write_locales();
-
     let root = env!("CARGO_MANIFEST_DIR");
     let mut main = PathBuf::from_str(root).unwrap();
     main.push("ui/main_window.slint");
@@ -14,7 +13,6 @@ fn main() {
     include.push("ui");
 
     slint_build::print_rustc_flags().unwrap();
-    // slint_build::compile("ui/main_window.slint").unwrap();
     slint_build::compile_with_config(
         main,
         CompilerConfiguration::new()

rog-control-center/data/rog-control-center.desktop

@@ -1,7 +1,6 @@
 [Desktop Entry]
 Version=1.0
 Type=Application
-
 Name=ROG Control Center
 Comment=Make your ASUS ROG Laptop go Brrrrr!
 Categories=Settings

rog-control-center/src/main.rs

@@ -1,4 +1,4 @@
-use std::env::args;
+use std::env::{self, args};
 use std::path::{Path, PathBuf};
 use std::process::exit;
 use std::sync::{Arc, Mutex};
@@ -32,6 +32,12 @@ async fn main() -> Result<()> {
         .format_timestamp(None)
         .init();
 
+    // If we're running under gamescope we have to set WAYLAND_DISPLAY for winit to
+    // use
+    if let Ok(gamescope) = env::var("GAMESCOPE_WAYLAND_DISPLAY") {
+        env::set_var("WAYLAND_DISPLAY", gamescope);
+    }
+
     // Try to open a proxy and check for app state first
     {
         let user_con = zbus::blocking::Connection::session()?;
@@ -49,7 +55,12 @@ async fn main() -> Result<()> {
     let self_version = env!("CARGO_PKG_VERSION");
     let zbus_con = zbus::blocking::Connection::system()?;
     let platform_proxy = rog_dbus::zbus_platform::PlatformProxyBlocking::new(&zbus_con)?;
-    let asusd_version = platform_proxy.version().unwrap();
+    let asusd_version = platform_proxy
+        .version()
+        .map_err(|e| {
+            println!("Could not get asusd version: {e:?}\nIs asusd.service running?");
+        })
+        .unwrap();
     if asusd_version != self_version {
         println!("Version mismatch: asusctl = {self_version}, asusd = {asusd_version}");
         return Ok(());
@@ -79,7 +90,7 @@ async fn main() -> Result<()> {
     let board_name = dmi.board_name;
     let prod_family = dmi.product_family;
     info!("Running on {board_name}, product: {prod_family}");
-    let is_rog_ally = prod_family == "RC71L";
+    let is_rog_ally = prod_family == "RC71L" || prod_family == "RC72L";
 
     let args: Vec<String> = args().skip(1).collect();
 
@@ -115,7 +126,9 @@ async fn main() -> Result<()> {
         config.enable_tray_icon = false;
         config.run_in_background = false;
         config.startup_in_background = false;
+        config.start_fullscreen = true;
     }
+    config.write();
 
     let enable_tray_icon = config.enable_tray_icon;
     let startup_in_background = config.startup_in_background;
@@ -131,8 +144,8 @@ async fn main() -> Result<()> {
     // i_slint_backend_selector::with_platform(|_| Ok(())).unwrap();
 
     if !startup_in_background {
-        if let Ok(mut lock) = app_state.lock() {
-            *lock = AppState::MainWindowShouldOpen;
+        if let Ok(mut app_state) = app_state.lock() {
+            *app_state = AppState::MainWindowShouldOpen;
         }
     }
 
@@ -149,15 +162,15 @@ async fn main() -> Result<()> {
         let mut state = AppState::StartingUp;
         loop {
             // save as a var, don't hold the lock the entire time or deadlocks happen
-            if let Ok(lock) = app_state.lock() {
-                state = *lock;
+            if let Ok(app_state) = app_state.lock() {
+                state = *app_state;
             }
 
             // This sleep is required to give the event loop time to react
             sleep(Duration::from_millis(300));
             if state == AppState::MainWindowShouldOpen {
-                if let Ok(mut lock) = app_state.lock() {
-                    *lock = AppState::MainWindowOpen;
+                if let Ok(mut app_state) = app_state.lock() {
+                    *app_state = AppState::MainWindowOpen;
                 }
 
                 let config_copy = config.clone();
@@ -169,20 +182,39 @@ async fn main() -> Result<()> {
                         if let Some(ui) = ui.as_mut() {
                             ui.window().show().unwrap();
                             ui.window().on_close_requested(move || {
-                                if let Ok(mut lock) = app_state_copy.lock() {
-                                    *lock = AppState::MainWindowClosed;
+                                if let Ok(mut app_state) = app_state_copy.lock() {
+                                    *app_state = AppState::MainWindowClosed;
                                 }
                                 slint::CloseRequestResponse::HideWindow
                             });
                         } else {
+                            let config_copy_2 = config_copy.clone();
                             let newui = setup_window(config_copy);
-                            newui.window().show().unwrap();
                             newui.window().on_close_requested(move || {
-                                if let Ok(mut lock) = app_state_copy.lock() {
-                                    *lock = AppState::MainWindowClosed;
+                                if let Ok(mut app_state) = app_state_copy.lock() {
+                                    *app_state = AppState::MainWindowClosed;
                                 }
                                 slint::CloseRequestResponse::HideWindow
                             });
+
+                            let ui_copy = newui.as_weak();
+                            newui
+                                .window()
+                                .set_rendering_notifier(move |s, _| {
+                                    if let slint::RenderingState::RenderingSetup = s {
+                                        let config = config_copy_2.clone();
+                                        ui_copy
+                                            .upgrade_in_event_loop(move |w| {
+                                                let fullscreen =
+                                                    config.lock().is_ok_and(|c| c.start_fullscreen);
+                                                if fullscreen && !w.window().is_fullscreen() {
+                                                    w.window().set_fullscreen(fullscreen);
+                                                }
+                                            })
+                                            .ok();
+                                    }
+                                })
+                                .ok();
                             ui.replace(newui);
                         }
                     });
@@ -192,8 +224,8 @@ async fn main() -> Result<()> {
                 slint::quit_event_loop().unwrap();
                 exit(0);
             } else if state != AppState::MainWindowOpen {
-                if let Ok(lock) = config.lock() {
-                    if !lock.run_in_background {
+                if let Ok(config) = config.lock() {
+                    if !config.run_in_background {
                         slint::quit_event_loop().unwrap();
                         exit(0);
                     }

rog-control-center/src/tray.rs

@@ -208,7 +208,15 @@ pub fn init_tray(_supported_properties: Vec<Properties>, config: Arc<Mutex<Confi
                         }
                     }
                 }
-                Err(e) => warn!("Couldn't get mode form supergfxd: {e:?}")
+                Err(e) => match e {
+                    zbus::Error::MethodError(_, _, message) => {
+                        warn!(
+                            "Couldn't get mode from supergfxd: {message:?}, the supergfxd service \
+                             may not be running or installed"
+                        )
+                    }
+                    _ => warn!("Couldn't get mode from supergfxd: {e:?}")
+                }
             }
 
             info!("Started ROGTray");

rog-control-center/src/ui/mod.rs

@@ -6,8 +6,9 @@ pub mod setup_system;
 use std::sync::{Arc, Mutex};
 
 use config_traits::StdConfig;
+use log::warn;
 use rog_dbus::list_iface_blocking;
-use slint::{ComponentHandle, PhysicalSize, SharedString, Weak};
+use slint::{ComponentHandle, SharedString, Weak};
 
 use crate::config::Config;
 use crate::ui::setup_anime::setup_anime_page;
@@ -82,16 +83,11 @@ pub fn show_toast(
 }
 
 pub fn setup_window(config: Arc<Mutex<Config>>) -> MainWindow {
+    slint::set_xdg_app_id("rog-control-center")
+        .map_err(|e| warn!("Couldn't set application ID: {e:?}"))
+        .ok();
     let ui = MainWindow::new().unwrap();
-    if let Ok(lock) = config.try_lock() {
-        let fullscreen = lock.start_fullscreen;
-        let width = lock.fullscreen_width;
-        let height = lock.fullscreen_height;
-        if fullscreen {
-            ui.window().set_fullscreen(fullscreen);
-            ui.window().set_size(PhysicalSize { width, height });
-        }
-    };
+    ui.window().show().unwrap();
 
     let available = list_iface_blocking().unwrap_or_default();
     ui.set_sidebar_items_avilable(
@@ -125,6 +121,7 @@ pub fn setup_window(config: Arc<Mutex<Config>>) -> MainWindow {
     if available.contains(&"xyz.ljones.FanCurves".to_string()) {
         setup_fan_curve_page(&ui, config);
     }
+
     ui
 }
 

rog-control-center/src/ui/setup_system.rs

@@ -16,12 +16,12 @@ use crate::{set_ui_callbacks, set_ui_props_async, AttrMinMax, MainWindow, System
 const MINMAX: AttrMinMax = AttrMinMax {
     min: 0,
     max: 0,
-    val: -1.0
+    current: -1.0
 };
 
 pub fn setup_system_page(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
     let conn = zbus::blocking::Connection::system().unwrap();
-    let platform = PlatformProxyBlocking::new(&conn).unwrap();
+    let platform = PlatformProxyBlocking::builder(&conn).build().unwrap();
     // let armoury_attrs =
     // find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury").unwrap();
 
@@ -93,13 +93,13 @@ macro_rules! init_minmax_property {
         tokio::spawn(async move {
             let min = proxy_copy.min_value().await.unwrap();
             let max = proxy_copy.max_value().await.unwrap();
-            let val = proxy_copy.current_value().await.unwrap() as f32;
+            let current = proxy_copy.current_value().await.unwrap() as f32;
             handle_copy
                 .upgrade_in_event_loop(move |handle| {
                     concat_idents!(setter = set_, $property {
                         handle
                             .global::<SystemPageData>()
-                            .setter(AttrMinMax { min, max, val });
+                            .setter(AttrMinMax { min, max, current });
                     });
                 })
                 .ok();
@@ -174,30 +174,40 @@ macro_rules! setup_external {
 }
 
 // For handling external value changes
-macro_rules! setup_minmax_external {
-    ($property:ident, $handle:expr, $attr:expr, $platform:expr) => {
+macro_rules! setup_value_watch {
+    ($property:ident, $handle:expr, $proxy:expr, $value_type:ident $($conv: tt)*) => {
         let handle_copy = $handle.as_weak();
-        let proxy_copy = $attr.clone();
+        let proxy_copy = $proxy.clone();
         tokio::spawn(async move {
-            let mut x = proxy_copy.receive_current_value_changed().await;
+            let mut x = concat_idents!(recv = receive_, $value_type, _value_changed {
+                proxy_copy.recv().await
+            });
             use zbus::export::futures_util::StreamExt;
             while let Some(e) = x.next().await {
                 if let Ok(out) = e.get().await {
                     concat_idents!(getter = get_, $property {
-                    handle_copy
-                        .upgrade_in_event_loop(move |handle| {
-                            let mut tmp: AttrMinMax =
-                                handle.global::<SystemPageData>().getter();
-                            tmp.val = out as f32;
-                            concat_idents!(setter = set_, $property {
-                                handle.global::<SystemPageData>().setter(tmp);
-                            });
-                        })
-                        .ok();
+                        handle_copy
+                            .upgrade_in_event_loop(move |handle| {
+                                let mut tmp: AttrMinMax =
+                                    handle.global::<SystemPageData>().getter();
+                                tmp.$value_type = out $($conv)*;
+                                concat_idents!(setter = set_, $property {
+                                    handle.global::<SystemPageData>().setter(tmp);
+                                });
+                            })
+                            .ok();
                     });
                 }
             }
         });
+    };
+}
+
+macro_rules! setup_minmax_external {
+    ($property:ident, $handle:expr, $attr:expr, $platform:expr) => {
+        setup_value_watch!($property, $handle, $attr, current as f32);
+        setup_value_watch!($property, $handle, $attr, min);
+        setup_value_watch!($property, $handle, $attr, max);
 
         let handle_copy = $handle.as_weak();
         let proxy_copy = $attr.clone();
@@ -210,13 +220,13 @@ macro_rules! setup_minmax_external {
                     debug!("receive_platform_profile_changed, getting new {}", stringify!(attr));
                     let min = proxy_copy.min_value().await.unwrap();
                     let max = proxy_copy.max_value().await.unwrap();
-                    let val = proxy_copy.current_value().await.unwrap() as f32;
+                    let current = proxy_copy.current_value().await.unwrap() as f32;
                     handle_copy
                         .upgrade_in_event_loop(move |handle| {
                             concat_idents!(setter = set_, $property {
                                 handle
                                     .global::<SystemPageData>()
-                                    .setter(AttrMinMax { min, max, val });
+                                    .setter(AttrMinMax { min, max, current });
                             });
                         })
                         .ok();
@@ -249,7 +259,7 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
     tokio::spawn(async move {
         // Create the connections/proxies here to prevent future delays in process
         let conn = zbus::Connection::system().await.unwrap();
-        let platform = PlatformProxy::new(&conn).await.unwrap();
+        let platform = PlatformProxy::builder(&conn).build().await.unwrap();
 
         set_ui_props_async!(
             handle,
@@ -288,9 +298,18 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
             change_platform_profile_on_ac
         );
 
+        set_ui_props_async!(handle, platform, SystemPageData, enable_ppt_group);
+
         let platform_copy = platform.clone();
         handle
             .upgrade_in_event_loop(move |handle| {
+                set_ui_callbacks!(handle,
+                    SystemPageData(as bool),
+                    platform_copy.enable_ppt_group(as bool),
+                    "Applied PPT group settings {}",
+                    "Setting PPT group settings failed"
+                );
+
                 set_ui_callbacks!(handle,
                     SystemPageData(as f32),
                     platform_copy.charge_control_end_threshold(as u8),

rog-control-center/translations/en/rog-control-center.po

@@ -2,7 +2,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
-"POT-Creation-Date: 2025-01-19 10:35+0000\n"
+"POT-Creation-Date: 2025-02-01 07:31+0000\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -47,198 +47,203 @@ msgctxt "SystemPageData"
 msgid "Power"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:139
+#: rog-control-center/ui/pages/system.slint:142
 msgctxt "PageSystem"
 msgid "Power settings"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:144
+#: rog-control-center/ui/pages/system.slint:147
 msgctxt "PageSystem"
 msgid "Charge limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:158
+#: rog-control-center/ui/pages/system.slint:161
 msgctxt "PageSystem"
 msgid "Platform Profile"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:168
+#: rog-control-center/ui/pages/system.slint:171
 msgctxt "PageSystem"
 msgid "Advanced"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:186
+#: rog-control-center/ui/pages/system.slint:189
 msgctxt "PageSystem"
 msgid "Armoury settings"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:194
-msgctxt "PageSystem"
-msgid "Panel Overdrive"
-msgstr ""
-
-#: rog-control-center/ui/pages/system.slint:202
-msgctxt "PageSystem"
-msgid "MiniLED Mode"
-msgstr ""
-
-#: rog-control-center/ui/pages/system.slint:210
-msgctxt "PageSystem"
-msgid "POST boot sound"
-msgstr ""
-
-#: rog-control-center/ui/pages/system.slint:224
-msgctxt "no_asus_armoury_driver_2"
+#: rog-control-center/ui/pages/system.slint:199
+msgctxt "no_asus_armoury_driver_1"
 msgid "The asus-armoury driver is not loaded"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:230
+#: rog-control-center/ui/pages/system.slint:205
 msgctxt "no_asus_armoury_driver_2"
 msgid "For advanced features you will require a kernel with this driver added."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:241
-msgctxt "ppt_warning"
-msgid "The following settings may not be safe, please review the help."
+#: rog-control-center/ui/pages/system.slint:216
+msgctxt "PageSystem"
+msgid "Panel Overdrive"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:246 rog-control-center/ui/pages/system.slint:247
+#: rog-control-center/ui/pages/system.slint:224
+msgctxt "PageSystem"
+msgid "MiniLED Mode"
+msgstr ""
+
+#: rog-control-center/ui/pages/system.slint:232
+msgctxt "PageSystem"
+msgid "POST boot sound"
+msgstr ""
+
+#: rog-control-center/ui/pages/system.slint:248
+msgctxt "ppt_warning"
+msgid "The following settings are not applied until the toggle is enabled."
+msgstr ""
+
+#: rog-control-center/ui/pages/system.slint:253
+msgctxt "ppt_group_enabled"
+msgid "Enable Tuning"
+msgstr ""
+
+#: rog-control-center/ui/pages/system.slint:262 rog-control-center/ui/pages/system.slint:263
 msgctxt "ppt_pl1_spl"
 msgid "CPU Sustained Power Limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:248
+#: rog-control-center/ui/pages/system.slint:264
 msgctxt "ppt_pl1_spl_help"
 msgid ""
 "Long-term CPU power limit that affects sustained workload performance. "
 "Higher values may increase heat and power consumption."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:263 rog-control-center/ui/pages/system.slint:264
+#: rog-control-center/ui/pages/system.slint:279 rog-control-center/ui/pages/system.slint:280
 msgctxt "ppt_pl2_sppt"
 msgid "CPU Turbo Power Limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:265
+#: rog-control-center/ui/pages/system.slint:281
 msgctxt "ppt_pl2_sppt_help"
 msgid ""
 "Short-term CPU power limit for boost periods. Controls maximum power during "
 "brief high-performance bursts."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:280 rog-control-center/ui/pages/system.slint:281
+#: rog-control-center/ui/pages/system.slint:296 rog-control-center/ui/pages/system.slint:297
 msgctxt "ppt_pl3_fppt"
 msgid "CPU Fast Burst Power Limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:282
+#: rog-control-center/ui/pages/system.slint:298
 msgctxt "ppt_pl3_fppt_help"
 msgid ""
 "Ultra-short duration power limit for instantaneous CPU bursts. Affects "
 "responsiveness during sudden workload spikes."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:296 rog-control-center/ui/pages/system.slint:297
+#: rog-control-center/ui/pages/system.slint:312 rog-control-center/ui/pages/system.slint:313
 msgctxt "ppt_fppt"
 msgid "Fast Package Power Limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:298
+#: rog-control-center/ui/pages/system.slint:314
 msgctxt "ppt_fppt_help"
 msgid ""
 "Ultra-short duration power limit for system package. Controls maximum power "
 "during millisecond-scale load spikes."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:313 rog-control-center/ui/pages/system.slint:314
+#: rog-control-center/ui/pages/system.slint:329 rog-control-center/ui/pages/system.slint:330
 msgctxt "ppt_apu_sppt"
 msgid "APU Sustained Power Limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:315
+#: rog-control-center/ui/pages/system.slint:331
 msgctxt "ppt_apu_sppt_help"
 msgid ""
 "Long-term power limit for integrated graphics and CPU combined. Affects "
 "sustained performance of APU-based workloads."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:330 rog-control-center/ui/pages/system.slint:331
+#: rog-control-center/ui/pages/system.slint:346 rog-control-center/ui/pages/system.slint:347
 msgctxt "ppt_platform_sppt"
 msgid "Platform Sustained Power Limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:332
+#: rog-control-center/ui/pages/system.slint:348
 msgctxt "ppt_platform_sppt_help"
 msgid ""
 "Overall system power limit for sustained operations. Controls total platform "
 "power consumption over extended periods."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:347 rog-control-center/ui/pages/system.slint:348
+#: rog-control-center/ui/pages/system.slint:363 rog-control-center/ui/pages/system.slint:364
 msgctxt "nv_dynamic_boost"
 msgid "GPU Power Boost"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:349
+#: rog-control-center/ui/pages/system.slint:365
 msgctxt "nv_dynamic_boost_help"
 msgid ""
 "Additional power allocation for GPU dynamic boost. Higher values increase "
 "GPU performance but generate more heat."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:364 rog-control-center/ui/pages/system.slint:365
+#: rog-control-center/ui/pages/system.slint:380 rog-control-center/ui/pages/system.slint:381
 msgctxt "nv_temp_target"
 msgid "GPU Temperature Limit"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:366
+#: rog-control-center/ui/pages/system.slint:382
 msgctxt "nv_temp_target_help"
 msgid ""
 "Maximum GPU temperature threshold in Celsius. GPU will throttle to maintain "
 "temperature below this limit."
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:417
+#: rog-control-center/ui/pages/system.slint:433
 msgctxt "PageSystem"
 msgid "Energy Performance Preference linked to Throttle Policy"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:421
+#: rog-control-center/ui/pages/system.slint:437
 msgctxt "PageSystem"
 msgid "Change EPP based on Throttle Policy"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:429
+#: rog-control-center/ui/pages/system.slint:445
 msgctxt "PageSystem"
 msgid "EPP for Balanced Policy"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:439
+#: rog-control-center/ui/pages/system.slint:455
 msgctxt "PageSystem"
 msgid "EPP for Performance Policy"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:449
+#: rog-control-center/ui/pages/system.slint:465
 msgctxt "PageSystem"
 msgid "EPP for Quiet Policy"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:467
+#: rog-control-center/ui/pages/system.slint:483
 msgctxt "PageSystem"
 msgid "Throttle Policy for power state"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:473
+#: rog-control-center/ui/pages/system.slint:489
 msgctxt "PageSystem"
 msgid "Throttle Policy on Battery"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:483 rog-control-center/ui/pages/system.slint:504
+#: rog-control-center/ui/pages/system.slint:499 rog-control-center/ui/pages/system.slint:520
 msgctxt "PageSystem"
 msgid "Enabled"
 msgstr ""
 
-#: rog-control-center/ui/pages/system.slint:494
+#: rog-control-center/ui/pages/system.slint:510
 msgctxt "PageSystem"
 msgid "Throttle Policy on AC"
 msgstr ""
@@ -728,42 +733,42 @@ msgctxt "confirm_reset"
 msgid "Are you sure you want to reset this?"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:51
+#: rog-control-center/ui/main_window.slint:55
 msgctxt "MainWindow"
 msgid "ROG"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:53
+#: rog-control-center/ui/main_window.slint:57
 msgctxt "Menu1"
 msgid "System Control"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:54
+#: rog-control-center/ui/main_window.slint:58
 msgctxt "Menu2"
 msgid "Keyboard Aura"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:55
+#: rog-control-center/ui/main_window.slint:59
 msgctxt "Menu3"
 msgid "AniMe Matrix"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:56
+#: rog-control-center/ui/main_window.slint:60
 msgctxt "Menu4"
 msgid "Fan Curves"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:57
+#: rog-control-center/ui/main_window.slint:61
 msgctxt "Menu5"
 msgid "App Settings"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:58
+#: rog-control-center/ui/main_window.slint:62
 msgctxt "Menu6"
 msgid "About"
 msgstr ""
 
-#: rog-control-center/ui/main_window.slint:70
+#: rog-control-center/ui/main_window.slint:74
 msgctxt "MainWindow"
 msgid "Quit App"
 msgstr ""

rog-control-center/ui/main_window.slint

@@ -19,7 +19,11 @@ export { AppSize, AttrMinMax, SystemPageData, AnimePageData, AppSettingsPageData
 
 export component MainWindow inherits Window {
     title: "ROG Control";
-    default-font-family: "DejaVu Sans";
+    always-on-top: true;
+    default-font-family: "Noto Sans";
+    default-font-size: 14px;
+    default-font-weight: 400;
+    icon: @image-url("../data/rog-control-center.png");
     in property <[bool]> sidebar_items_avilable: [true, true, true, true, true, true];
     private property <bool> show_notif;
     private property <bool> fade_cover;

rog-control-center/ui/pages/system.slint

@@ -1,15 +1,15 @@
 import { SystemSlider, SystemDropdown, SystemToggle, SystemToggleInt } from "../widgets/common.slint";
-import { Palette, HorizontalBox , VerticalBox, ScrollView, Slider, Button, Switch, ComboBox, GroupBox} from "std-widgets.slint";
+import { Palette, HorizontalBox , VerticalBox, ScrollView, Slider, Button, Switch, ComboBox, GroupBox, StandardButton} from "std-widgets.slint";
 
 export struct AttrMinMax {
   min: int,
   max: int,
-  val: float,
+  current: float,
 }
 
 export struct AttrPossible {
   range: [int],
-  val: int,
+  current: int,
 }
 
 export global SystemPageData {
@@ -54,7 +54,7 @@ export global SystemPageData {
     in-out property <AttrMinMax> ppt_pl1_spl: {
         min: 0,
         max: 100,
-        val: 20,
+        current: 20,
     };
     callback cb_ppt_pl1_spl(int);
     callback cb_default_ppt_pl1_spl();
@@ -62,7 +62,7 @@ export global SystemPageData {
     in-out property <AttrMinMax> ppt_pl2_sppt: {
         min: 0,
         max: 100,
-        val: 20,
+        current: 20,
     };
     callback cb_ppt_pl2_sppt(int);
     callback cb_default_ppt_pl2_sppt();
@@ -70,7 +70,7 @@ export global SystemPageData {
     in-out property <AttrMinMax> ppt_pl3_fppt: {
         min: 0,
         max: 100,
-        val: 20,
+        current: 20,
     };
     callback cb_ppt_pl3_fppt(int);
     callback cb_default_ppt_pl3_fppt();
@@ -78,7 +78,7 @@ export global SystemPageData {
     in-out property <AttrMinMax> ppt_fppt: {
         min: 0,
         max: 100,
-        val: 20,
+        current: 20,
     };
     callback cb_ppt_fppt(int);
     callback cb_default_ppt_fppt();
@@ -86,7 +86,7 @@ export global SystemPageData {
     in-out property <AttrMinMax> ppt_apu_sppt: {
         min: 0,
         max: 100,
-        val: 20,
+        current: 20,
     };
     callback cb_ppt_apu_sppt(int);
     callback cb_default_ppt_apu_sppt();
@@ -94,7 +94,7 @@ export global SystemPageData {
     in-out property <AttrMinMax> ppt_platform_sppt: {
         min: 0,
         max: 100,
-        val: 20,
+        current: 20,
     };
     callback cb_ppt_platform_sppt(int);
     callback cb_default_ppt_platform_sppt();
@@ -102,7 +102,7 @@ export global SystemPageData {
     in-out property <AttrMinMax> nv_dynamic_boost: {
         min: 0,
         max: 30,
-        val: 5,
+        current: 5,
     };
     callback cb_nv_dynamic_boost(int);
     callback cb_default_nv_dynamic_boost();
@@ -110,10 +110,13 @@ export global SystemPageData {
     in-out property <AttrMinMax> nv_temp_target: {
         min: 0,
         max: 80,
-        val: 75,
+        current: 75,
     };
     callback cb_nv_temp_target(int);
     callback cb_default_nv_temp_target();
+
+    in-out property <bool> enable_ppt_group;
+    callback cb_enable_ppt_group(bool);
 }
 
 export component PageSystem inherits Rectangle {
@@ -187,6 +190,25 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
+            if !SystemPageData.asus_armoury_loaded: Rectangle {
+                border-width: 3px;
+                border-color: red;
+                max-height: 30px;
+                VerticalBox {
+                    Text {
+                        text: @tr("no_asus_armoury_driver_1" => "The asus-armoury driver is not loaded");
+                        font-size: 16px;
+                        horizontal-alignment: TextHorizontalAlignment.center;
+                    }
+
+                    Text {
+                        text: @tr("no_asus_armoury_driver_2" => "For advanced features you will require a kernel with this driver added.");
+                        font-size: 16px;
+                        horizontal-alignment: TextHorizontalAlignment.center;
+                    }
+                }
+            }
+
             HorizontalBox {
                 padding: 0px;
                 spacing: 10px;
@@ -215,164 +237,166 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if !SystemPageData.asus_armoury_loaded: Rectangle {
-                border-width: 3px;
-                border-color: red;
-                max-height: 30px;
-                VerticalBox {
+            if SystemPageData.ppt_pl1_spl.current != -1 || SystemPageData.ppt_pl2_sppt.current != -1 || SystemPageData.nv_dynamic_boost.current != -1: HorizontalLayout {
+                padding-right: 10px;
+                padding-left: 10px;
+                alignment: LayoutAlignment.space-between;
+                Rectangle {
+                    height: 32px;
                     Text {
-                        text: @tr("no_asus_armoury_driver_2" => "The asus-armoury driver is not loaded");
                         font-size: 16px;
-                        horizontal-alignment: TextHorizontalAlignment.center;
+                        text: @tr("ppt_warning" => "The following settings are not applied until the toggle is enabled.");
                     }
+                }
 
-                    Text {
-                        text: @tr("no_asus_armoury_driver_2" => "For advanced features you will require a kernel with this driver added.");
-                        font-size: 16px;
-                        horizontal-alignment: TextHorizontalAlignment.center;
+                Switch {
+                text: @tr("ppt_group_enabled" => "Enable Tuning");
+                    checked <=> SystemPageData.enable_ppt_group;
+                    toggled => {
+                        SystemPageData.cb_enable_ppt_group(SystemPageData.enable_ppt_group)
                     }
                 }
             }
 
-            if SystemPageData.ppt_pl1_spl.val != -1: Rectangle {
-                height: 32px;
-                Text {
-                    font-size: 16px;
-                    text: @tr("ppt_warning" => "The following settings may not be safe, please review the help.");
-                }
-            }
-
-            if SystemPageData.ppt_pl1_spl.val != -1: SystemSlider {
+            if SystemPageData.ppt_pl1_spl.current != -1: SystemSlider {
                 text: @tr("ppt_pl1_spl" => "CPU Sustained Power Limit");
                 title: @tr("ppt_pl1_spl" => "CPU Sustained Power Limit");
                 help_text: @tr("ppt_pl1_spl_help" => "Long-term CPU power limit that affects sustained workload performance. Higher values may increase heat and power consumption.");
                 minimum: SystemPageData.ppt_pl1_spl.min;
                 maximum: SystemPageData.ppt_pl1_spl.max;
-                value: SystemPageData.ppt_pl1_spl.val;
+                value: SystemPageData.ppt_pl1_spl.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_ppt_pl1_spl();
                 }
                 released => {
-                    SystemPageData.ppt_pl1_spl.val = self.value;
-                    SystemPageData.cb_ppt_pl1_spl(Math.round(self.value))
+                    SystemPageData.ppt_pl1_spl.current = self.value;
+                    SystemPageData.cb_ppt_pl1_spl(Math.round(self.value));
                 }
             }
 
-            if SystemPageData.ppt_pl2_sppt.val != -1: SystemSlider {
+            if SystemPageData.ppt_pl2_sppt.current != -1: SystemSlider {
                 text: @tr("ppt_pl2_sppt" => "CPU Turbo Power Limit");
                 title: @tr("ppt_pl2_sppt" => "CPU Turbo Power Limit");
                 help_text: @tr("ppt_pl2_sppt_help" => "Short-term CPU power limit for boost periods. Controls maximum power during brief high-performance bursts.");
                 minimum: SystemPageData.ppt_pl2_sppt.min;
                 maximum: SystemPageData.ppt_pl2_sppt.max;
-                value: SystemPageData.ppt_pl2_sppt.val;
+                value: SystemPageData.ppt_pl2_sppt.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_ppt_pl2_sppt();
                 }
                 released => {
-                    SystemPageData.ppt_pl2_sppt.val = self.value;
+                    SystemPageData.ppt_pl2_sppt.current = self.value;
                     SystemPageData.cb_ppt_pl2_sppt(Math.round(self.value))
                 }
             }
 
-            if SystemPageData.ppt_pl3_fppt.val != -1: SystemSlider {
+            if SystemPageData.ppt_pl3_fppt.current != -1: SystemSlider {
                 text: @tr("ppt_pl3_fppt" => "CPU Fast Burst Power Limit");
                 title: @tr("ppt_pl3_fppt" => "CPU Fast Burst Power Limit");
                 help_text: @tr("ppt_pl3_fppt_help" => "Ultra-short duration power limit for instantaneous CPU bursts. Affects responsiveness during sudden workload spikes.");
                 minimum: SystemPageData.ppt_pl3_fppt.min;
                 maximum: SystemPageData.ppt_pl3_fppt.max;
-                value: SystemPageData.ppt_pl3_fppt.val;
+                value: SystemPageData.ppt_pl3_fppt.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_ppt_pl3_fppt();
                 }
                 released => {
-                    SystemPageData.ppt_pl3_fppt.val = self.value;
+                    SystemPageData.ppt_pl3_fppt.current = self.value;
                     SystemPageData.cb_ppt_pl3_fppt(Math.round(self.value))
                 }
             }
-            if SystemPageData.ppt_fppt.val != -1: SystemSlider {
+            if SystemPageData.ppt_fppt.current != -1: SystemSlider {
                 text: @tr("ppt_fppt" => "Fast Package Power Limit");
                 title: @tr("ppt_fppt" => "Fast Package Power Limit");
                 help_text: @tr("ppt_fppt_help" => "Ultra-short duration power limit for system package. Controls maximum power during millisecond-scale load spikes.");
                 minimum: SystemPageData.ppt_fppt.min;
                 maximum: SystemPageData.ppt_fppt.max;
-                value: SystemPageData.ppt_fppt.val;
+                value: SystemPageData.ppt_fppt.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_ppt_fppt();
                 }
                 released => {
-                    SystemPageData.ppt_fppt.val = self.value;
+                    SystemPageData.ppt_fppt.current = self.value;
                     SystemPageData.cb_ppt_fppt(Math.round(self.value))
                 }
             }
 
-            if SystemPageData.ppt_apu_sppt.val != -1: SystemSlider {
+            if SystemPageData.ppt_apu_sppt.current != -1: SystemSlider {
                 text: @tr("ppt_apu_sppt" => "APU Sustained Power Limit");
                 title: @tr("ppt_apu_sppt" => "APU Sustained Power Limit");
                 help_text: @tr("ppt_apu_sppt_help" => "Long-term power limit for integrated graphics and CPU combined. Affects sustained performance of APU-based workloads.");
                 minimum: SystemPageData.ppt_apu_sppt.min;
                 maximum: SystemPageData.ppt_apu_sppt.max;
-                value: SystemPageData.ppt_apu_sppt.val;
+                value: SystemPageData.ppt_apu_sppt.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_ppt_apu_sppt();
                 }
                 released => {
-                    SystemPageData.ppt_apu_sppt.val = self.value;
+                    SystemPageData.ppt_apu_sppt.current = self.value;
                     SystemPageData.cb_ppt_apu_sppt(Math.round(self.value))
                 }
             }
 
-            if SystemPageData.ppt_platform_sppt.val != -1: SystemSlider {
+            if SystemPageData.ppt_platform_sppt.current != -1: SystemSlider {
                 text: @tr("ppt_platform_sppt" => "Platform Sustained Power Limit");
                 title: @tr("ppt_platform_sppt" => "Platform Sustained Power Limit");
                 help_text: @tr("ppt_platform_sppt_help" => "Overall system power limit for sustained operations. Controls total platform power consumption over extended periods.");
                 minimum: SystemPageData.ppt_platform_sppt.min;
                 maximum: SystemPageData.ppt_platform_sppt.max;
-                value: SystemPageData.ppt_platform_sppt.val;
+                value: SystemPageData.ppt_platform_sppt.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_ppt_platform_sppt();
                 }
                 released => {
-                    SystemPageData.ppt_platform_sppt.val = self.value;
+                    SystemPageData.ppt_platform_sppt.current = self.value;
                     SystemPageData.cb_ppt_platform_sppt(Math.round(self.value))
                 }
             }
 
-            if SystemPageData.nv_dynamic_boost.val != -1: SystemSlider {
+            if SystemPageData.nv_dynamic_boost.current != -1: SystemSlider {
                 text: @tr("nv_dynamic_boost" => "GPU Power Boost");
                 title: @tr("nv_dynamic_boost" => "GPU Power Boost");
                 help_text: @tr("nv_dynamic_boost_help" => "Additional power allocation for GPU dynamic boost. Higher values increase GPU performance but generate more heat.");
                 minimum: SystemPageData.nv_dynamic_boost.min;
                 maximum: SystemPageData.nv_dynamic_boost.max;
-                value: SystemPageData.nv_dynamic_boost.val;
+                value: SystemPageData.nv_dynamic_boost.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_nv_dynamic_boost();
                 }
                 released => {
-                    SystemPageData.nv_dynamic_boost.val = self.value;
+                    SystemPageData.nv_dynamic_boost.current = self.value;
                     SystemPageData.cb_nv_dynamic_boost(Math.round(self.value))
                 }
             }
 
-            if SystemPageData.nv_temp_target.val != -1: SystemSlider {
+            if SystemPageData.nv_temp_target.current != -1: SystemSlider {
                 text: @tr("nv_temp_target" => "GPU Temperature Limit");
                 title: @tr("nv_temp_target" => "GPU Temperature Limit");
                 help_text: @tr("nv_temp_target_help" => "Maximum GPU temperature threshold in Celsius. GPU will throttle to maintain temperature below this limit.");
                 minimum: SystemPageData.nv_temp_target.min;
                 maximum: SystemPageData.nv_temp_target.max;
-                value: SystemPageData.nv_temp_target.val;
+                value: SystemPageData.nv_temp_target.current;
+                enabled <=> SystemPageData.enable_ppt_group;
                 has_reset: true;
                 cb_do_reset => {
                     SystemPageData.cb_default_nv_temp_target();
                 }
                 released => {
-                    SystemPageData.nv_temp_target.val = self.value;
+                    SystemPageData.nv_temp_target.current = self.value;
                     SystemPageData.cb_nv_temp_target(Math.round(self.value))
                 }
             }

rog-control-center/ui/widgets/common.slint

@@ -12,6 +12,7 @@ export component RogItem inherits Rectangle {
 export component SystemSlider inherits RogItem {
     in property <string> title;
     in property <string> text;
+    in-out property <bool> enabled;
     in-out property <float> value;
     in-out property <float> minimum;
     in-out property <float> maximum;
@@ -27,6 +28,7 @@ export component SystemSlider inherits RogItem {
             alignment: LayoutAlignment.stretch;
             padding-left: 10px;
             TouchArea {
+            enabled <=> root.enabled;
                 clicked => {
                     slider.value += 1;
                     if slider.value > slider.maximum {
@@ -57,6 +59,7 @@ export component SystemSlider inherits RogItem {
             // alignment: LayoutAlignment.end;
             padding-right: 20px;
             slider := Slider {
+                enabled <=> root.enabled;
                 maximum: root.maximum;
                 minimum: root.minimum;
                 value <=> root.value;
@@ -150,6 +153,7 @@ export component SystemSlider inherits RogItem {
         reset := HorizontalBox {
             if (has_reset): StandardButton {
                 kind: StandardButtonKind.reset;
+                enabled <=> root.enabled;
                 clicked => {
                     reset_popup.show();
                 }

rog-dbus/src/zbus_platform.rs

@@ -104,4 +104,12 @@ pub trait Platform {
     fn platform_profile(&self) -> zbus::Result<PlatformProfile>;
     #[zbus(property)]
     fn set_platform_profile(&self, platform_profile: PlatformProfile) -> zbus::Result<()>;
+
+    /// Set if the PPT tuning group for the current profile is enabled
+    #[zbus(property)]
+    fn enable_ppt_group(&self) -> zbus::Result<bool>;
+
+    /// Set if the PPT tuning group for the current profile is enabled
+    #[zbus(property)]
+    fn set_enable_ppt_group(&self, enable: bool) -> zbus::Result<()>;
 }

rog-platform/src/asus_armoury.rs

@@ -2,6 +2,7 @@ use std::fs::{read_dir, File, OpenOptions};
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
+use log::debug;
 use serde::{Deserialize, Serialize};
 use zbus::zvariant::{OwnedValue, Type, Value};
 
@@ -75,6 +76,15 @@ impl Attribute {
         }
     }
 
+    pub fn base_path_exists(&self) -> bool {
+        let exists = self.base_path.exists();
+        debug!(
+            "Attribute path {:?} exits? {exists}",
+            self.base_path.as_os_str()
+        );
+        exists
+    }
+
     /// Write the `current_value` directly to the attribute path
     pub fn set_current_value(&self, new_value: &AttrValue) -> Result<(), PlatformError> {
         let path = self.base_path.join("current_value");
@@ -162,8 +172,8 @@ impl Attribute {
         )
     }
 
-    pub fn get_watcher(&self) -> Result<inotify::Inotify, PlatformError> {
-        let path = self.base_path.join("current_value");
+    pub fn get_watcher(&self, attr: &str) -> Result<inotify::Inotify, PlatformError> {
+        let path = self.base_path.join(attr);
         if let Some(path) = path.to_str() {
             let inotify = inotify::Inotify::init()?;
             inotify
@@ -307,7 +317,13 @@ impl FirmwareAttribute {
                 | FirmwareAttribute::PptFppt
                 | FirmwareAttribute::PptApuSppt
                 | FirmwareAttribute::PptPlatformSppt
-                | FirmwareAttribute::NvDynamicBoost
+        )
+    }
+
+    pub fn is_dgpu(&self) -> bool {
+        matches!(
+            self,
+            FirmwareAttribute::NvDynamicBoost
                 | FirmwareAttribute::NvTempTarget
                 | FirmwareAttribute::DgpuTgp
         )
@@ -328,7 +344,7 @@ impl From<&str> for FirmwareAttribute {
             "ppt_platform_sppt" => Self::PptPlatformSppt,
             "nv_dynamic_boost" => Self::NvDynamicBoost,
             "nv_temp_target" => Self::NvTempTarget,
-            "dgpu_base_tgp" => Self::DgpuBaseTgp,
+            "nv_base_tgp" => Self::DgpuBaseTgp,
             "dgpu_tgp" => Self::DgpuTgp,
             "charge_mode" => Self::ChargeMode,
             "boot_sound" => Self::BootSound,