Feat: config reload and do not apply properties if max==min

asusd/src/asus_armoury.rs

@@ -27,6 +27,28 @@ fn dbus_path_for_attr(attr_name: &str) -> OwnedObjectPath {
     ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/{attr_name}")).into()
 }
 
+// Helper: return true when the attribute is effectively unsupported for
+// the current power mode/device. We consider an attribute unsupported when
+// its resolved min and max are equal (no available range), which indicates
+// writes would be invalid. When true, callers should avoid attempting writes.
+fn attr_unsupported(attr: &Attribute) -> bool {
+    let min = attr
+        .refresh_min_value()
+        .or(match attr.min_value() {
+            AttrValue::Integer(i) => Some(*i),
+            _ => None,
+        })
+        .unwrap_or(-1);
+    let max = attr
+        .refresh_max_value()
+        .or(match attr.max_value() {
+            AttrValue::Integer(i) => Some(*i),
+            _ => None,
+        })
+        .unwrap_or(-2); // different default so equality is false unless both present
+    min == max
+}
+
 #[derive(Clone)]
 pub struct AsusArmouryAttribute {
     attr: Attribute,
@@ -204,14 +226,24 @@ impl crate::Reloadable for AsusArmouryAttribute {
             };
 
             if let Some(tune) = apply_value {
-                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);
+                // Don't attempt writes for attributes that report min==0 and max==0
+                // (commonly means not supported in this power mode/device); skip
+                // applying stored tune in that case.
+                if self.attr.base_path_exists() && !attr_unsupported(&self.attr) {
+                    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);
+                } else {
+                    debug!(
+                        "Skipping apply for {} because attribute missing or unsupported (min==max)",
+                        self.attr.name()
+                    );
+                }
             }
         } else {
             // Handle non-PPT attributes (boolean and other settings)
@@ -442,13 +474,23 @@ impl AsusArmouryAttribute {
                 .unwrap_or_default()
                 != 0;
 
-            if power_plugged == on_ac {
-                self.attr
-                    .set_current_value(&AttrValue::Integer(value))
-                    .map_err(|e| {
-                        error!("Could not set value: {e:?}");
-                        e
-                    })?;
+            // Don't attempt writes for attributes that report min==0 and max==0
+            // (commonly means not supported in this power mode/device); skip
+            // applying stored value in that case.
+            if self.attr.base_path_exists() && !attr_unsupported(&self.attr) {
+                if power_plugged == on_ac {
+                    self.attr
+                        .set_current_value(&AttrValue::Integer(value))
+                        .map_err(|e| {
+                            error!("Could not set value: {e:?}");
+                            e
+                        })?;
+                }
+            } else {
+                debug!(
+                    "Skipping immediate apply for {} because attribute missing or unsupported (min==max)",
+                    self.attr.name()
+                );
             }
         }
 
@@ -478,12 +520,22 @@ impl AsusArmouryAttribute {
                 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
-                    })?;
+                // Don't attempt writes for attributes that report min==0 and max==0
+                // (commonly means not supported in this power mode/device); skip
+                // applying stored value in that case.
+                if self.attr.base_path_exists() && !attr_unsupported(&self.attr) {
+                    self.attr
+                        .set_current_value(&AttrValue::Integer(value))
+                        .map_err(|e| {
+                            error!("Could not set value: {e:?}");
+                            e
+                        })?;
+                } else {
+                    debug!(
+                        "Skipping apply for {} on set_current_value because attribute missing or unsupported (min==max)",
+                        self.attr.name()
+                    );
+                }
             }
         } else {
             self.attr
@@ -676,28 +728,44 @@ pub async fn set_config_or_default(
                 debug!("Tuning group is not enabled, skipping");
                 return;
             }
-
+            // Determine once whether attribute is present and supports a writable range
+            let supported = attr.base_path_exists() && !attr_unsupported(attr);
             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));
-                    })
-                    .ok();
-            } else {
-                let default = attr.default_value();
-                attr.set_current_value(default)
-                    .map_err(|e| {
-                        error!("Failed to set {}: {e}", <&str>::from(name));
-                    })
-                    .ok();
-                if let AttrValue::Integer(i) = default {
-                    tuning.group.insert(name, *i);
-                    info!(
-                        "Set default tuning config for {} = {:?}",
-                        <&str>::from(name),
-                        i
+                if supported {
+                    attr.set_current_value(&AttrValue::Integer(*tune))
+                        .map_err(|e| {
+                            error!("Failed to set {}: {e}", <&str>::from(name));
+                        })
+                        .ok();
+                } else {
+                    debug!(
+                        "Skipping apply for {} in set_config_or_default because attribute missing or unsupported",
+                        <&str>::from(name)
+                    );
+                }
+            } else {
+                // Only attempt to apply defaults when the attribute supports a range
+                if supported {
+                    let default = attr.default_value();
+                    attr.set_current_value(default)
+                        .map_err(|e| {
+                            error!("Failed to set {}: {e}", <&str>::from(name));
+                        })
+                        .ok();
+                    if let AttrValue::Integer(i) = default {
+                        tuning.group.insert(name, *i);
+                        info!(
+                            "Set default tuning config for {} = {:?}",
+                            <&str>::from(name),
+                            i
+                        );
+                        // config.write();
+                    }
+                } else {
+                    debug!(
+                        "Skipping default apply for {} in set_config_or_default because attribute missing or unsupported",
+                        <&str>::from(name)
                     );
-                    // config.write();
                 }
             }
         } else {

asusd/tests/attr_unsupported_min_eq_max.rs

@@ -0,0 +1,68 @@
+use std::fs::{create_dir_all, File};
+use std::io::Write;
+use std::path::PathBuf;
+
+use tempfile::tempdir;
+
+use asusd::asus_armoury::set_config_or_default;
+use asusd::config::Config;
+use rog_platform::asus_armoury::FirmwareAttributes;
+use rog_platform::platform::PlatformProfile;
+
+fn write_attr_dir_with_min_max(base: &PathBuf, name: &str, default: &str, min: &str, max: &str) {
+    let attr_dir = base.join(name);
+    create_dir_all(&attr_dir).unwrap();
+
+    let mut f = File::create(attr_dir.join("default_value")).unwrap();
+    write!(f, "{}", default).unwrap();
+    let mut f = File::create(attr_dir.join("display_name")).unwrap();
+    write!(f, "{}", name).unwrap();
+    // create current_value file so set_current_value can open for write
+    let mut f = File::create(attr_dir.join("current_value")).unwrap();
+    write!(f, "{}", default).unwrap();
+    // write explicit min and max
+    let mut f = File::create(attr_dir.join("min_value")).unwrap();
+    write!(f, "{}", min).unwrap();
+    let mut f = File::create(attr_dir.join("max_value")).unwrap();
+    write!(f, "{}", max).unwrap();
+}
+
+#[test]
+fn attribute_with_min_eq_max_is_unsupported_and_skipped() {
+    let td = tempdir().unwrap();
+    let base = td.path().join("attributes");
+    create_dir_all(&base).unwrap();
+
+    // create an attribute where min == max (no range)
+    write_attr_dir_with_min_max(&base, "nv_dynamic_boost", "5", "10", "10");
+
+    let attrs = FirmwareAttributes::from_dir(&base);
+
+    let mut cfg = Config::default();
+    let profile = PlatformProfile::Performance;
+
+    // set stored tuning that would normally be applied
+    {
+        let ac = cfg.select_tunings(true, profile);
+        ac.enabled = true;
+        ac.group.insert(
+            rog_platform::asus_armoury::FirmwareAttribute::NvDynamicBoost,
+            9,
+        );
+    }
+
+    let rt = tokio::runtime::Runtime::new().unwrap();
+
+    // apply AC
+    rt.block_on(async {
+        set_config_or_default(&attrs, &mut cfg, true, profile).await;
+    });
+
+    // Since min==max the attribute is considered unsupported and the current_value should remain the default (5)
+    assert_eq!(
+        std::fs::read_to_string(base.join("nv_dynamic_boost").join("current_value"))
+            .unwrap()
+            .trim(),
+        "5"
+    );
+}