ROGCC: Better handle the use of GPU MUX without supergfxd

CHANGELOG.md

@@ -5,10 +5,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-## [v4.5.6-RC2]
+## [v4.5.6-RC3]
 ### Changed
 - Fix tasks not always running correctly on boot/sleep/wake/shutdown by finishing the move to async
 - Change how the profile/fan change task monitors changes due to TUF laptops behaving slightly different
+- ROGCC: Better handle the use of GPU MUX without supergfxd
+- ROGCC: Track if reboot required when not using supergfxd
+- Add env var for logging levels to daemon and gui (`RUST_LOG=<error|warn|info|debug|trace`)
 
 ## [v4.5.5]
 ### Changed

Cargo.lock

@@ -149,7 +149,7 @@ checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
 
 [[package]]
 name = "asusctl"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "daemon",
  "gif",
@@ -727,7 +727,7 @@ checksum = "b365fabc795046672053e29c954733ec3b05e4be654ab130fe8f1f94d7051f35"
 
 [[package]]
 name = "daemon"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "async-trait",
  "concat-idents",
@@ -750,7 +750,7 @@ dependencies = [
 
 [[package]]
 name = "daemon-user"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "dirs",
  "rog_anime",
@@ -930,20 +930,10 @@ dependencies = [
  "wio",
 ]
 
-[[package]]
-name = "ecolor"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b601108bca3af7650440ace4ca55b2daf52c36f2635be3587d77b16efd8d0691"
-dependencies = [
- "bytemuck",
-]
-
 [[package]]
 name = "eframe"
-version = "0.20.0"
+version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
-checksum = "8128828b785ecf1552917330354ab2eb9d2c48fbe2ad075fa75f93d4a099a9f1"
 dependencies = [
  "bytemuck",
  "egui",
@@ -963,9 +953,8 @@ dependencies = [
 
 [[package]]
 name = "egui"
-version = "0.20.0"
+version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
-checksum = "2a4daecd807bfd4e30ad92f049b03d92f506a3fddfad852babaa03cba180adfa"
 dependencies = [
  "accesskit",
  "ahash",
@@ -976,9 +965,8 @@ dependencies = [
 
 [[package]]
 name = "egui-winit"
-version = "0.20.0"
+version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
-checksum = "2217c2c1e63b7b793753efd23dc68efb86bb09bd298e5de8010e9a82dc63f0a9"
 dependencies = [
  "accesskit_winit",
  "arboard",
@@ -992,9 +980,8 @@ dependencies = [
 
 [[package]]
 name = "egui_glow"
-version = "0.20.0"
+version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
-checksum = "67655a7138ce9d9617811622a3d81577fb477f4447f1a330e89814f16ad35574"
 dependencies = [
  "bytemuck",
  "egui",
@@ -1007,9 +994,8 @@ dependencies = [
 
 [[package]]
 name = "emath"
-version = "0.20.0"
+version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
-checksum = "5277249c8c3430e7127e4f2c40a77485e7baf11ae132ce9b3253a8ed710df0a0"
 dependencies = [
  "bytemuck",
 ]
@@ -1094,15 +1080,13 @@ dependencies = [
 
 [[package]]
 name = "epaint"
-version = "0.20.0"
+version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
-checksum = "de14b65fe5e423e0058f77a8beb2c863b056d0566d6c4ce0d097aa5814cb705a"
 dependencies = [
  "ab_glyph",
  "ahash",
  "atomic_refcell",
  "bytemuck",
- "ecolor",
  "emath",
  "nohash-hasher",
  "parking_lot",
@@ -2609,7 +2593,7 @@ dependencies = [
 
 [[package]]
 name = "rog-control-center"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "daemon",
  "dirs",
@@ -2639,7 +2623,7 @@ dependencies = [
 
 [[package]]
 name = "rog_anime"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "gif",
  "glam",
@@ -2654,7 +2638,7 @@ dependencies = [
 
 [[package]]
 name = "rog_aura"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "serde",
  "serde_derive",
@@ -2665,7 +2649,7 @@ dependencies = [
 
 [[package]]
 name = "rog_dbus"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "rog_anime",
  "rog_aura",
@@ -2676,7 +2660,7 @@ dependencies = [
 
 [[package]]
 name = "rog_platform"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "concat-idents",
  "inotify",
@@ -2692,7 +2676,7 @@ dependencies = [
 
 [[package]]
 name = "rog_profiles"
-version = "4.5.6-RC1"
+version = "4.5.6-RC3"
 dependencies = [
  "serde",
  "serde_derive",

Cargo.toml

@@ -2,7 +2,7 @@
 members = ["asusctl", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
 
 [workspace.package]
-version = "4.5.6-RC2"
+version = "4.5.6-RC3"
 
 [workspace.dependencies]
 async-trait = "^0.1"

daemon/src/ctrl_platform.rs

@@ -319,7 +319,8 @@ impl CtrlPlatform {
     task_watch_item!(panel_od platform);
     task_watch_item!(dgpu_disable platform);
     task_watch_item!(egpu_enable platform);
-    task_watch_item!(gpu_mux_mode platform);
+    // NOTE: see note further below
+    //task_watch_item!(gpu_mux_mode platform);
 }
 
 #[async_trait]
@@ -372,7 +373,9 @@ impl CtrlTask for CtrlPlatform {
         self.watch_panel_od(signal_ctxt.clone()).await?;
         self.watch_dgpu_disable(signal_ctxt.clone()).await?;
         self.watch_egpu_enable(signal_ctxt.clone()).await?;
-        self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
+        // NOTE: Can't have this as a watch because on a write to it, it reverts back to booted-with value
+        //  as it does not actually change until reboot.
+        //self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
 
         Ok(())
     }

daemon/src/daemon.rs

@@ -7,7 +7,6 @@ use std::time::Duration;
 use ::zbus::export::futures_util::lock::Mutex;
 use ::zbus::Connection;
 use daemon::ctrl_anime::CtrlAnime;
-use log::LevelFilter;
 use log::{error, info, warn};
 use tokio::time::sleep;
 use zbus::SignalContext;
@@ -33,9 +32,9 @@ static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut logger = env_logger::Builder::new();
     logger
+        .parse_default_env()
         .target(env_logger::Target::Stdout)
         .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
         .init();
 
     let is_service = match env::var_os("IS_SERVICE") {

data/asusd.service

@@ -6,6 +6,7 @@ Before=multi-user.target
 
 [Service]
 Environment=IS_SERVICE=1
+Environment=RUST_LOG="info"
 ExecStartPre=/bin/sleep 2
 ExecStart=/usr/bin/asusd
 Restart=on-failure

rog-control-center/src/main.rs

@@ -1,5 +1,5 @@
 use eframe::{IconData, NativeOptions};
-use log::{error, info, LevelFilter};
+use log::{error, info};
 use rog_aura::layouts::KeyLayout;
 use rog_control_center::tray::init_tray;
 use rog_control_center::update_and_notify::EnabledNotifications;
@@ -29,9 +29,9 @@ fn main() -> Result<()> {
     print_versions();
     let mut logger = env_logger::Builder::new();
     logger
+        .parse_default_env()
         .target(env_logger::Target::Stdout)
         .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
         .init();
 
     // start tokio

rog-control-center/src/tray.rs

@@ -4,6 +4,7 @@
 use std::{
     io::Write,
     sync::{
+        atomic::{AtomicBool, Ordering},
         mpsc::{channel, Receiver},
         Arc, Mutex,
     },
@@ -21,7 +22,7 @@ use supergfxctl::{
     zbus_proxy::DaemonProxyBlocking as GfxProxyBlocking,
 };
 
-use log::{debug, error, info, trace};
+use log::{debug, error, info, trace, warn};
 
 const TRAY_APP_ICON: &str = "rog-control-center";
 const TRAY_LABEL: &str = "ROG Control Center";
@@ -241,7 +242,10 @@ impl ROGTray {
     }
 
     fn menu_add_gpu(&mut self, supported: &SupportedFunctions, current_mode: GfxMode) {
+        let set_mux_off = Arc::new(AtomicBool::new(false));
+
         let gfx_dbus = self.gfx_proxy.clone();
+        let set_mux_off1 = set_mux_off.clone();
         let mut gpu_menu = RadioGroup::new("Integrated", move |_| {
             let mode = gfx_dbus
                 .mode()
@@ -259,9 +263,11 @@ impl ROGTray {
                     })
                     .ok();
             }
+            set_mux_off1.store(true, Ordering::Relaxed);
         });
 
         let gfx_dbus = self.gfx_proxy.clone();
+        let set_mux_off1 = set_mux_off.clone();
         gpu_menu.add("Hybrid", move |_| {
             let mode = gfx_dbus
                 .mode()
@@ -279,7 +285,31 @@ impl ROGTray {
                     })
                     .ok();
             }
+            set_mux_off1.store(true, Ordering::Relaxed);
         });
+        if supported.rog_bios_ctrl.egpu_enable {
+            let set_mux_off1 = set_mux_off.clone();
+            let gfx_dbus = self.gfx_proxy.clone();
+            gpu_menu.add("eGPU", move |_| {
+                let mode = gfx_dbus
+                    .mode()
+                    .map_err(|e| {
+                        error!("ROGTray: mode: {e}");
+                        e
+                    })
+                    .unwrap_or(GfxMode::None);
+                if mode != GfxMode::Egpu {
+                    gfx_dbus
+                        .set_mode(&GfxMode::Egpu)
+                        .map_err(|e| {
+                            error!("ROGTray: set_mode: {e}");
+                            e
+                        })
+                        .ok();
+                }
+                set_mux_off1.store(true, Ordering::Relaxed);
+            });
+        }
         if supported.rog_bios_ctrl.gpu_mux {
             let gfx_dbus = self.bios_proxy.clone();
             gpu_menu.add("Ultimate (Reboot required)", move |_| {
@@ -300,27 +330,17 @@ impl ROGTray {
                         .ok();
                 }
             });
-        }
+
-        if supported.rog_bios_ctrl.egpu_enable {
+            if set_mux_off.load(Ordering::Relaxed) {
-            let gfx_dbus = self.gfx_proxy.clone();
+                warn!("Selected non-dgpu mode, must set MUX to optimus");
-            gpu_menu.add("eGPU", move |_| {
+                self.bios_proxy
-                let mode = gfx_dbus
+                    .set_gpu_mux_mode(GpuMode::Optimus)
-                    .mode()
                     .map_err(|e| {
-                        error!("ROGTray: mode: {e}");
+                        error!("ROGTray: set_mode: {e}");
                         e
                     })
-                    .unwrap_or(GfxMode::None);
+                    .ok();
-                if mode != GfxMode::Egpu {
+            }
-                    gfx_dbus
-                        .set_mode(&GfxMode::Egpu)
-                        .map_err(|e| {
-                            error!("ROGTray: set_mode: {e}");
-                            e
-                        })
-                        .ok();
-                }
-            });
         }
 
         let active = match current_mode {
@@ -336,6 +356,61 @@ impl ROGTray {
         debug!("ROGTray: appended gpu menu");
     }
 
+    fn menu_add_mux(&mut self, current_mode: GfxMode) {
+        let gfx_dbus = self.bios_proxy.clone();
+        let mut reboot_required = false;
+
+        if let Ok(mode) = gfx_dbus.gpu_mux_mode() {
+            let mode = match mode {
+                GpuMode::Discrete => GfxMode::AsusMuxDiscreet,
+                _ => GfxMode::Hybrid,
+            };
+            reboot_required = mode != current_mode;
+        }
+
+        let mut gpu_menu = RadioGroup::new("Optimus", move |_| {
+            gfx_dbus
+                .set_gpu_mux_mode(GpuMode::Optimus)
+                .map_err(|e| {
+                    error!("ROGTray: set_mode: {e}");
+                    e
+                })
+                .ok();
+            debug!("Setting GPU mode: {}", GpuMode::Optimus);
+        });
+
+        let gfx_dbus = self.bios_proxy.clone();
+        gpu_menu.add("Ultimate", move |_| {
+            gfx_dbus
+                .set_gpu_mux_mode(GpuMode::Discrete)
+                .map_err(|e| {
+                    error!("ROGTray: set_mode: {e}");
+                    e
+                })
+                .ok();
+            debug!("Setting GPU mode: {}", GpuMode::Discrete);
+        });
+
+        let active = match current_mode {
+            GfxMode::AsusMuxDiscreet => "Ultimate".to_owned(),
+            GfxMode::Hybrid => "Optimus".to_owned(),
+            _ => current_mode.to_string(),
+        };
+        debug!("Current active GPU mode: {}", active);
+        let reboot_required = if reboot_required {
+            "(Reboot required)"
+        } else {
+            ""
+        };
+        self.add_radio_sub_menu(
+            &format!("GPU Mode: {active} {reboot_required}"),
+            active.as_str(),
+            &gpu_menu,
+        );
+
+        debug!("ROGTray: appended gpu menu");
+    }
+
     fn menu_clear(&mut self) {
         self.menu = gtk::Menu::new();
         debug!("ROGTray: cleared self");
@@ -362,6 +437,8 @@ impl ROGTray {
         self.menu_add_panel_od(supported, panel_od);
         if has_supergfx {
             self.menu_add_gpu(supported, current_gfx_mode);
+        } else if supported.rog_bios_ctrl.gpu_mux {
+            self.menu_add_mux(current_gfx_mode);
         }
         self.menu_update();
     }
@@ -412,10 +489,19 @@ pub fn init_tray(
         loop {
             if let Ok(mut lock) = states.lock() {
                 if lock.tray_should_update {
+                    // Supergfx ends up adding some complexity to handle if it isn't available
+                    let current_gpu_mode = if lock.gfx_state.has_supergfx {
+                        lock.gfx_state.mode
+                    } else {
+                        match lock.bios.dedicated_gfx {
+                            GpuMode::Discrete => GfxMode::AsusMuxDiscreet,
+                            _ => GfxMode::Hybrid,
+                        }
+                    };
                     tray.rebuild_and_update(
                         &supported,
                         has_supergfx,
-                        lock.gfx_state.mode,
+                        current_gpu_mode,
                         lock.power_state.charge_limit,
                         lock.bios.panel_overdrive,
                     );

rog-control-center/src/update_and_notify.rs

@@ -185,18 +185,6 @@ pub fn start_notifications(
         do_notification
     );
 
-    recv_notif!(
-        RogBiosProxy,
-        receive_notify_gpu_mux_mode,
-        last_notification,
-        enabled_notifications,
-        page_states,
-        (bios.dedicated_gfx),
-        (mode),
-        "Reboot required. BIOS GPU MUX mode set to",
-        do_mux_notification
-    );
-
     // Charge notif
     recv_notif!(
         PowerProxy,
@@ -277,6 +265,43 @@ pub fn start_notifications(
         };
     });
 
+    let page_states1 = page_states.clone();
+    let last_notification1 = last_notification.clone();
+    tokio::spawn(async move {
+        let conn = zbus::Connection::system()
+            .await
+            .map_err(|e| {
+                error!("zbus signal: receive_notify_gpu_mux_mode: {e}");
+                e
+            })
+            .unwrap();
+        let proxy = RogBiosProxy::new(&conn)
+            .await
+            .map_err(|e| {
+                error!("zbus signal: receive_notify_gpu_mux_mode: {e}");
+                e
+            })
+            .unwrap();
+        if let Ok(mut p) = proxy.receive_notify_gpu_mux_mode().await {
+            info!("Started zbus signal thread: receive_power_states");
+            while let Some(e) = p.next().await {
+                if let Ok(out) = e.args() {
+                    if let Ok(mut lock) = page_states1.lock() {
+                        lock.bios.dedicated_gfx = out.mode;
+                        lock.set_notified();
+                    }
+                    if let Ok(ref mut lock) = last_notification1.lock() {
+                        if let Some(notif) = lock.take() {
+                            notif.close();
+                        }
+                    }
+                    do_mux_notification("Reboot required. BIOS GPU MUX mode set to", &out.mode)
+                        .ok();
+                }
+            }
+        };
+    });
+
     if let Ok(lock) = page_states.try_lock() {
         use supergfxctl::pci_device::Device;
         let dev = Device::find().unwrap_or_default();
@@ -456,10 +481,24 @@ where
 }
 
 /// Actual `GpuMode` unused as data is never correct until switched by reboot
-fn do_mux_notification(message: &str, _: &GpuMode) -> Result<NotificationHandle> {
+fn do_mux_notification(message: &str, m: &GpuMode) -> Result<()> {
-    let mut notif = base_notification(message, &"");
+    let mut notif = base_notification(message, &m.to_string());
+    notif.action("gnome-session-quit", "Reboot");
     notif.urgency(Urgency::Critical);
     notif.icon("system-reboot-symbolic");
     notif.hint(Hint::Transient(true));
-    Ok(notif.show()?)
+    let handle = notif.show()?;
+
+    std::thread::spawn(|| {
+        handle.wait_for_action(|id| {
+            if id == "gnome-session-quit" {
+                let mut cmd = Command::new("gnome-session-quit");
+                cmd.arg("--reboot");
+                cmd.spawn().ok();
+            } else if id == "__closed" {
+                // TODO: cancel the switching
+            }
+        })
+    });
+    Ok(())
 }

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

@@ -93,6 +93,13 @@ pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut SystemState,
 
     if supported.rog_bios_ctrl.gpu_mux {
         let mut changed = false;
+        let mut dedicated_gfx = states.bios.dedicated_gfx;
+
+        let mut reboot_required = false;
+        if let Ok(mode) = states.asus_dbus.proxies().rog_bios().gpu_mux_mode() {
+            reboot_required = mode != states.bios.dedicated_gfx;
+        }
+
         ui.group(|ui| {
             ui.vertical(|ui| {
                 ui.horizontal_wrapped(|ui| ui.label("GPU MUX mode"));
@@ -100,19 +107,23 @@ pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut SystemState,
                 ui.horizontal_wrapped(|ui| {
                     changed = ui
                         .selectable_value(
-                            &mut states.bios.dedicated_gfx,
+                            &mut dedicated_gfx,
                             GpuMode::Discrete,
                             "Dedicated (Ultimate)",
                         )
                         .clicked()
                         || ui
                             .selectable_value(
-                                &mut states.bios.dedicated_gfx,
+                                &mut dedicated_gfx,
                                 GpuMode::Optimus,
                                 "Optimus (Hybrid)",
                             )
                             .clicked();
                 });
+
+                if reboot_required {
+                    ui.horizontal_wrapped(|ui| ui.heading("REBOOT REQUIRED"));
+                }
             });
         });
 
@@ -121,7 +132,7 @@ pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut SystemState,
                 .asus_dbus
                 .proxies()
                 .rog_bios()
-                .set_gpu_mux_mode(states.bios.dedicated_gfx)
+                .set_gpu_mux_mode(dedicated_gfx)
                 .map_err(|err| {
                     states.error = Some(err.to_string());
                 })