Add more support detection for bios/system level components

daemon/src/ctrl_aura/controller.rs

@@ -490,7 +490,7 @@ mod tests {
                 .set_effect(effect.clone())
                 .unwrap_err()
                 .to_string(),
-            "Aura efect not supported"
+            "Aura effect not supported"
         );
 
         effect.mode = AuraModeNum::Static;
@@ -500,7 +500,7 @@ mod tests {
                 .set_effect(effect.clone())
                 .unwrap_err()
                 .to_string(),
-            "Aura efect not supported"
+            "Aura effect not supported"
         );
 
         controller.supported_modes.multizone.push(AuraZone::Key2);

daemon/src/ctrl_aura/zbus.rs

@@ -46,7 +46,7 @@ impl CtrlKbdLedZbus {
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
         enabled: Vec<AuraControl>,
-    ) {
+    ) -> zbus::fdo::Result<()> {
         let mut states = None;
         if let Ok(mut ctrl) = self.0.try_lock() {
             for s in enabled {
@@ -54,9 +54,10 @@ impl CtrlKbdLedZbus {
             }
             ctrl.config.write();
 
-            ctrl.set_power_states(&ctrl.config)
-                .map_err(|err| warn!("{}", err))
-                .ok();
+            ctrl.set_power_states(&ctrl.config).map_err(|e| {
+                warn!("{}", e);
+                e
+            })?;
 
             let set: Vec<AuraControl> = ctrl.config.enabled.iter().map(|v| *v).collect();
             states = Some(set);
@@ -67,13 +68,14 @@ impl CtrlKbdLedZbus {
                 .await
                 .unwrap_or_else(|err| warn!("{}", err));
         }
+        Ok(())
     }
 
     async fn set_leds_disabled(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
         disabled: Vec<AuraControl>,
-    ) {
+    ) -> zbus::fdo::Result<()> {
         let mut states = None;
         if let Ok(mut ctrl) = self.0.try_lock() {
             for s in disabled {
@@ -81,9 +83,10 @@ impl CtrlKbdLedZbus {
             }
             ctrl.config.write();
 
-            ctrl.set_power_states(&ctrl.config)
-                .map_err(|err| warn!("{}", err))
-                .ok();
+            ctrl.set_power_states(&ctrl.config).map_err(|e| {
+                warn!("{}", e);
+                e
+            })?;
 
             let set: Vec<AuraControl> = ctrl.config.enabled.iter().map(|v| *v).collect();
             states = Some(set);
@@ -94,24 +97,22 @@ impl CtrlKbdLedZbus {
                 .await
                 .unwrap_or_else(|err| warn!("{}", err));
         }
+        Ok(())
     }
 
     async fn set_led_mode(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
         effect: AuraEffect,
-    ) {
+    ) -> zbus::fdo::Result<()> {
         let mut led = None;
         if let Ok(mut ctrl) = self.0.try_lock() {
-            match ctrl.set_effect(effect) {
-                Ok(_) => {
-                    if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                        led = Some(mode.clone());
-                    }
-                }
-                Err(err) => {
-                    warn!("{}", err);
-                }
+            ctrl.set_effect(effect).map_err(|e| {
+                warn!("{}", e);
+                e
+            })?;
+            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                led = Some(mode.clone());
             }
         }
         if let Some(led) = led {
@@ -119,13 +120,19 @@ impl CtrlKbdLedZbus {
                 .await
                 .unwrap_or_else(|err| warn!("{}", err));
         }
+        Ok(())
     }
 
-    async fn next_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+    async fn next_led_mode(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+    ) -> zbus::fdo::Result<()> {
         let mut led = None;
         if let Ok(mut ctrl) = self.0.lock() {
-            ctrl.toggle_mode(false)
-                .unwrap_or_else(|err| warn!("{}", err));
+            ctrl.toggle_mode(false).map_err(|e| {
+                warn!("{}", e);
+                e
+            })?;
 
             if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
                 led = Some(mode.clone());
@@ -136,13 +143,19 @@ impl CtrlKbdLedZbus {
                 .await
                 .unwrap_or_else(|err| warn!("{}", err));
         }
+        Ok(())
     }
 
-    async fn prev_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+    async fn prev_led_mode(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+    ) -> zbus::fdo::Result<()> {
         let mut led = None;
         if let Ok(mut ctrl) = self.0.lock() {
-            ctrl.toggle_mode(true)
-                .unwrap_or_else(|err| warn!("{}", err));
+            ctrl.toggle_mode(true).map_err(|e| {
+                warn!("{}", e);
+                e
+            })?;
 
             if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
                 led = Some(mode.clone());
@@ -153,20 +166,27 @@ impl CtrlKbdLedZbus {
                 .await
                 .unwrap_or_else(|err| warn!("{}", err));
         }
+        Ok(())
     }
 
-    async fn next_led_brightness(&self) {
+    async fn next_led_brightness(&self) -> zbus::fdo::Result<()> {
         if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.next_brightness()
-                .unwrap_or_else(|err| warn!("{}", err));
+            ctrl.next_brightness().map_err(|e| {
+                warn!("{}", e);
+                e
+            })?;
         }
+        Ok(())
     }
 
-    async fn prev_led_brightness(&self) {
+    async fn prev_led_brightness(&self) -> zbus::fdo::Result<()> {
         if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.prev_brightness()
-                .unwrap_or_else(|err| warn!("{}", err));
+            ctrl.prev_brightness().map_err(|e| {
+                warn!("{}", e);
+                e
+            })?;
         }
+        Ok(())
     }
 
     #[dbus_interface(property)]

daemon/src/ctrl_rog_bios.rs

@@ -20,6 +20,8 @@ static ASUS_SWITCH_GRAPHIC_MODE: &str =
 static ASUS_POST_LOGO_SOUND: &str =
     "/sys/firmware/efi/efivars/AsusPostLogoSound-607005d5-3f75-4b2e-98f0-85ba66797a3e";
 static ASUS_PANEL_OD_PATH: &str = "/sys/devices/platform/asus-nb-wmi/panel_od";
+static ASUS_DGPU_DISABLE_PATH: &str = "/sys/devices/platform/asus-nb-wmi/dgpu_disable";
+static ASUS_EGPU_ENABLE_PATH: &str = "/sys/devices/platform/asus-nb-wmi/egpu_enable";
 
 pub struct CtrlRogBios {
     _config: Arc<Mutex<Config>>,
@@ -30,9 +32,11 @@ impl GetSupported for CtrlRogBios {
 
     fn get_supported() -> Self::A {
         RogBiosSupportedFunctions {
-            post_sound_toggle: Path::new(ASUS_POST_LOGO_SOUND).exists(),
-            dedicated_gfx_toggle: Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists(),
+            post_sound: Path::new(ASUS_POST_LOGO_SOUND).exists(),
+            dedicated_gfx: Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists(),
             panel_overdrive: Path::new(ASUS_PANEL_OD_PATH).exists(),
+            dgpu_disable: Path::new(ASUS_DGPU_DISABLE_PATH).exists(),
+            egpu_enable: Path::new(ASUS_EGPU_ENABLE_PATH).exists(),
         }
     }
 }

daemon/src/error.rs

@@ -51,7 +51,7 @@ impl fmt::Display for RogError {
             RogError::Io(detail) => write!(f, "std::io error: {}", detail),
             RogError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
             RogError::ChargeLimit(value) => write!(f, "Invalid charging limit, not in range 20-100%: {}", value),
-            RogError::AuraEffectNotSupported => write!(f, "Aura efect not supported"),
+            RogError::AuraEffectNotSupported => write!(f, "Aura effect not supported"),
             RogError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
             RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
         }