Extend GpuMode to include other modes

asus-notify/src/main.rs

@@ -1,8 +1,8 @@
 use notify_rust::{Hint, Notification, NotificationHandle};
 use rog_aura::AuraEffect;
 use rog_dbus::{
-    zbus_charge::ChargeProxy, zbus_led::LedProxy, zbus_profile::ProfileProxy,
+    zbus_charge::ChargeProxy, zbus_led::LedProxy, zbus_platform::RogBiosProxy,
-    zbus_platform::RogBiosProxy,
+    zbus_profile::ProfileProxy,
 };
 use rog_profiles::Profile;
 use smol::{future, Executor};

asusctl/src/main.rs

@@ -14,6 +14,7 @@ use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage,
 use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
 use rog_aura::{self, AuraEffect};
 use rog_dbus::RogDbusClientBlocking;
+use rog_platform::platform::GpuMode;
 use rog_platform::supported::*;
 use rog_profiles::error::ProfileError;
 
@@ -787,7 +788,9 @@ fn handle_bios_option(
 
         if let Some(opt) = cmd.gpu_mux_mode_set {
             println!("Rebuilding initrd to include drivers");
-            dbus.proxies().rog_bios().set_gpu_mux_mode(opt.into())?;
+            dbus.proxies()
+                .rog_bios()
+                .set_gpu_mux_mode(GpuMode::from_mux(opt))?;
             println!("The mode change is not active until you reboot, on boot the bios will make the required change");
         }
         if cmd.gpu_mux_mode_get {

daemon/src/ctrl_platform.rs

@@ -1,7 +1,7 @@
 use crate::{config::Config, error::RogError, GetSupported};
 use async_trait::async_trait;
 use log::{info, warn};
-use rog_platform::platform::{AsusPlatform, GpuMuxMode};
+use rog_platform::platform::{AsusPlatform, GpuMode};
 use rog_platform::supported::RogBiosSupportedFunctions;
 use std::fs::OpenOptions;
 use std::io::{Read, Write};
@@ -51,7 +51,7 @@ impl CtrlRogBios {
     async fn set_gpu_mux_mode(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        mode: GpuMuxMode,
+        mode: GpuMode,
     ) {
         self.set_gfx_mode(mode)
             .map_err(|err| {
@@ -62,12 +62,12 @@ impl CtrlRogBios {
         Self::notify_gpu_mux_mode(&ctxt, mode).await.ok();
     }
 
-    fn gpu_mux_mode(&self) -> GpuMuxMode {
+    fn gpu_mux_mode(&self) -> GpuMode {
         match self.platform.get_gpu_mux_mode() {
-            Ok(m) => m.into(),
+            Ok(m) => GpuMode::from_mux(m),
             Err(e) => {
                 warn!("CtrlRogBios: get_gfx_mode {}", e);
-                GpuMuxMode::Error
+                GpuMode::Error
             }
         }
     }
@@ -75,7 +75,7 @@ impl CtrlRogBios {
     #[dbus_interface(signal)]
     async fn notify_gpu_mux_mode(
         signal_ctxt: &SignalContext<'_>,
-        mode: GpuMuxMode,
+        mode: GpuMode,
     ) -> zbus::Result<()> {
     }
 
@@ -183,10 +183,10 @@ impl CtrlRogBios {
         Ok(())
     }
 
-    fn set_gfx_mode(&self, mode: GpuMuxMode) -> Result<(), RogError> {
+    fn set_gfx_mode(&self, mode: GpuMode) -> Result<(), RogError> {
-        self.platform.set_gpu_mux_mode(mode.into())?;
+        self.platform.set_gpu_mux_mode(mode.to_mux())?;
         // self.update_initramfs(enable)?;
-        if mode == GpuMuxMode::Discrete {
+        if mode == GpuMode::Discrete {
             info!("Set system-level graphics mode: Dedicated Nvidia");
         } else {
             info!("Set system-level graphics mode: Optimus");

daemon/src/ctrl_supported.rs

@@ -6,7 +6,7 @@ use zvariant::Type;
 
 use crate::{
     ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_charge::CtrlCharge,
-    ctrl_profiles::controller::CtrlPlatformProfile, ctrl_platform::CtrlRogBios, GetSupported,
+    ctrl_platform::CtrlRogBios, ctrl_profiles::controller::CtrlPlatformProfile, GetSupported,
 };
 
 use rog_platform::supported::*;

daemon/src/daemon.rs

@@ -17,8 +17,8 @@ use daemon::ctrl_aura::controller::{
     CtrlKbdLed, CtrlKbdLedReloader, CtrlKbdLedTask, CtrlKbdLedZbus,
 };
 use daemon::ctrl_charge::CtrlCharge;
-use daemon::ctrl_profiles::config::ProfileConfig;
 use daemon::ctrl_platform::CtrlRogBios;
+use daemon::ctrl_profiles::config::ProfileConfig;
 use daemon::{
     config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
 };

daemon/src/lib.rs

@@ -7,6 +7,8 @@ pub mod ctrl_anime;
 pub mod ctrl_aura;
 /// Control of battery charge level
 pub mod ctrl_charge;
+/// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
+pub mod ctrl_platform;
 /// Control CPU min/max freq and turbo, fan mode, fan curves
 ///
 /// Intel machines can control:
@@ -19,8 +21,6 @@ pub mod ctrl_charge;
 /// - Fan mode (normal, boost, silent)
 /// - Fan min/max RPM curve
 pub mod ctrl_profiles;
-/// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
-pub mod ctrl_platform;
 /// Laptop matching to determine capabilities
 pub mod laptops;
 

rog-control-center/src/notify.rs

@@ -5,7 +5,7 @@ use notify_rust::{Hint, Notification, NotificationHandle};
 use rog_aura::AuraEffect;
 use rog_dbus::{
     zbus_anime::AnimeProxy, zbus_charge::ChargeProxy, zbus_led::LedProxy,
-    zbus_profile::ProfileProxy, zbus_platform::RogBiosProxy,
+    zbus_platform::RogBiosProxy, zbus_profile::ProfileProxy,
 };
 use rog_profiles::Profile;
 use smol::{future, Executor};

rog-control-center/src/page_states.rs

@@ -8,7 +8,7 @@ use std::{
 
 use egui::Vec2;
 use rog_aura::{layouts::KeyLayout, usb::AuraPowerDev, AuraEffect, AuraModeNum};
-use rog_platform::{platform::GpuMuxMode, supported::SupportedFunctions};
+use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
 use rog_profiles::{fan_curve_set::FanCurveSet, FanCurvePU, Profile};
 
 use crate::{error::Result, RogDbusClientBlocking};
@@ -20,7 +20,7 @@ pub struct BiosState {
     /// updated, so the full state needs refresh
     pub was_notified: Arc<AtomicBool>,
     pub post_sound: bool,
-    pub dedicated_gfx: GpuMuxMode,
+    pub dedicated_gfx: GpuMode,
     pub panel_overdrive: bool,
     pub dgpu_disable: bool,
     pub egpu_enable: bool,
@@ -42,7 +42,7 @@ impl BiosState {
             dedicated_gfx: if supported.rog_bios_ctrl.dgpu_only {
                 dbus.proxies().rog_bios().gpu_mux_mode()?
             } else {
-                GpuMuxMode::NotSupported
+                GpuMode::NotSupported
             },
             panel_overdrive: if supported.rog_bios_ctrl.panel_overdrive {
                 dbus.proxies().rog_bios().panel_overdrive()?
@@ -337,7 +337,7 @@ impl Default for PageDataStates {
             bios: BiosState {
                 was_notified: Default::default(),
                 post_sound: Default::default(),
-                dedicated_gfx: GpuMuxMode::NotSupported,
+                dedicated_gfx: GpuMode::NotSupported,
                 panel_overdrive: Default::default(),
                 dgpu_disable: Default::default(),
                 egpu_enable: Default::default(),

rog-control-center/src/widgets/rog_bios.rs

@@ -1,6 +1,6 @@
 use crate::{page_states::PageDataStates, RogDbusClientBlocking};
 use egui::Ui;
-use rog_platform::{platform::GpuMuxMode, supported::SupportedFunctions};
+use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
 use rog_profiles::Profile;
 
 pub fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlocking, ui: &mut Ui) {
@@ -99,14 +99,14 @@ pub fn rog_bios_group(
                     changed = ui
                         .selectable_value(
                             &mut states.bios.dedicated_gfx,
-                            GpuMuxMode::Discrete,
+                            GpuMode::Discrete,
                             "Dedicated (Ultimate)",
                         )
                         .clicked()
                         || ui
                             .selectable_value(
                                 &mut states.bios.dedicated_gfx,
-                                GpuMuxMode::Optimus,
+                                GpuMode::Optimus,
                                 "Optimus (Hybrid)",
                             )
                             .clicked();

rog-dbus/src/lib.rs

@@ -5,8 +5,8 @@ pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
 pub mod zbus_anime;
 pub mod zbus_charge;
 pub mod zbus_led;
-pub mod zbus_profile;
 pub mod zbus_platform;
+pub mod zbus_profile;
 pub mod zbus_supported;
 
 // use rog_anime::AnimePowerStates;

rog-dbus/src/zbus_platform.rs

@@ -19,7 +19,7 @@
 //!
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 
-use rog_platform::platform::GpuMuxMode;
+use rog_platform::platform::GpuMode;
 use zbus_macros::dbus_proxy;
 
 #[dbus_proxy(
@@ -28,13 +28,13 @@ use zbus_macros::dbus_proxy;
 )]
 trait RogBios {
     /// DedicatedGraphicMode method
-    fn gpu_mux_mode(&self) -> zbus::Result<GpuMuxMode>;
+    fn gpu_mux_mode(&self) -> zbus::Result<GpuMode>;
 
     /// PostBootSound method
     fn post_boot_sound(&self) -> zbus::Result<i16>;
 
     /// SetDedicatedGraphicMode method
-    fn set_gpu_mux_mode(&self, mode: GpuMuxMode) -> zbus::Result<()>;
+    fn set_gpu_mux_mode(&self, mode: GpuMode) -> zbus::Result<()>;
 
     /// SetPostBootSound method
     fn set_post_boot_sound(&self, on: bool) -> zbus::Result<()>;
@@ -47,7 +47,7 @@ trait RogBios {
 
     /// NotifyDedicatedGraphicMode signal
     #[dbus_proxy(signal)]
-    fn notify_gpu_mux_mode(&self, mode: GpuMuxMode) -> zbus::Result<()>;
+    fn notify_gpu_mux_mode(&self, mode: GpuMode) -> zbus::Result<()>;
 
     /// NotifyPostBootSound signal
     #[dbus_proxy(signal)]

rog-platform/src/platform.rs

@@ -71,29 +71,57 @@ impl AsusPlatform {
 }
 
 #[derive(Serialize, Deserialize, Type, Debug, PartialEq, Clone, Copy)]
-pub enum GpuMuxMode {
+pub enum GpuMode {
     Discrete,
     Optimus,
+    Integrated,
+    Egpu,
     Error,
     NotSupported,
 }
 
-impl From<u8> for GpuMuxMode {
+impl GpuMode {
-    fn from(m: u8) -> Self {
+    pub fn to_mux(&self) -> u8 {
-        if m > 0 {
+        if *self == Self::Discrete {
-            return Self::Optimus;
+            return 0;
         }
-        Self::Discrete
+        1
     }
-}
 
-impl From<GpuMuxMode> for u8 {
+    pub fn to_dgpu(&self) -> u8 {
-    fn from(m: GpuMuxMode) -> Self {
+        if *self == Self::Integrated {
-        match m {
+            return 1;
-            GpuMuxMode::Discrete => 0,
-            GpuMuxMode::Optimus => 1,
-            GpuMuxMode::Error => 254,
-            GpuMuxMode::NotSupported => 255,
         }
+        0
+    }
+
+    pub fn to_egpu(&self) -> u8 {
+        if *self == Self::Egpu {
+            return 1;
+        }
+        0
+    }
+
+    pub fn from_mux(num: u8) -> Self {
+        if num == 0 {
+            return Self::Discrete;
+        }
+        Self::Optimus
+    }
+
+    pub fn from_dgpu(num: u8) -> Self {
+        if num == 1 {
+            return Self::Integrated;
+        }
+        Self::Optimus
+    }
+
+    // `from_dgpu()` should be called also, and should take precedence if result
+    // are not equal.
+    pub fn from_egpu(num: u8) -> Self {
+        if num == 1 {
+            return Self::Egpu;
+        }
+        Self::Optimus
     }
 }