Prep release

More verbose and thorough checks for gfx switching

See merge request asus-linux/asus-nb-ctrl!30

CHANGELOG.md

@@ -5,6 +5,33 @@ 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]
+# [3.1.5] - 2021-03-11
+### Changed
+- Further tweaks to gfx switching
+- More logging on gfx switching
+- Filter bios help according to supported modes
+- Prevent gfx mode switching if in dedicated/G-Sync mode
+
+# [3.1.4] - 2021-03-10
+### Changed
+- Notify through dbus if user changes profile manually
+- Better help on CLI, show help only for supported items
+- Bugfix to gfx switcher
+
+# [3.1.3] - 2021-03-10
+### Changed
+- Hotfix: gracefully handle removing modules in use caused by display-manager not
+  fully shutdown at the time of trying to remove modules. It will now retry every
+  250ms per module
+
+# [3.1.2] - 2021-03-10
+### Changed
+- Test and create /etc/X11/xorg.conf.d/ if it doesn't exist
+- Hotfix to better report module issues
+
+# [3.1.1] - 2021-03-10
+### Changed
+- Add missing nvidia module nvidia_uvm to gfx ctrl list
 
 # [3.1.0] - 2021-03-09
 ### Added

Cargo.lock

@@ -33,8 +33,9 @@ dependencies = [
 
 [[package]]
 name = "asusctl"
-version = "3.1.0"
+version = "3.1.2"
 dependencies = [
+ "daemon",
  "gumdrop",
  "rog_dbus",
  "rog_types",
@@ -187,7 +188,7 @@ dependencies = [
 
 [[package]]
 name = "daemon"
-version = "3.1.1"
+version = "3.1.5"
 dependencies = [
  "env_logger",
  "intel-pstate",

asusctl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asusctl"
-version = "3.1.0"
+version = "3.1.2"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 
@@ -11,6 +11,7 @@ edition = "2018"
 serde_json = "^1.0"
 rog_dbus = { path = "../rog-dbus" }
 rog_types = { path = "../rog-types" }
+daemon = { path = "../daemon" }
 gumdrop = "^0.8"
 yansi-term = "^0.1"
 

asusctl/src/main.rs

@@ -1,3 +1,4 @@
+use daemon::{ctrl_fan_cpu::FanCpuSupportedFunctions, ctrl_leds::LedSupportedFunctions, ctrl_rog_bios::RogBiosSupportedFunctions, ctrl_supported::SupportedFunctions};
 use gumdrop::{Opt, Options};
 use rog_dbus::AuraDbusClient;
 use rog_types::{
@@ -93,19 +94,18 @@ struct AniMeCommand {
 struct BiosCommand {
     #[options(help = "print help message")]
     help: bool,
-    #[options(meta = "", no_long, help = "toggle bios POST sound")]
+    #[options(meta = "", no_long, help = "set bios POST sound <true/false>")]
     post_sound_set: Option<bool>,
     #[options(no_long, help = "read bios POST sound")]
     post_sound_get: bool,
-    #[options(meta = "", no_long, help = "toggle GPU to/from dedicated mode")]
+    #[options(meta = "", no_long, help = "activate dGPU dedicated/G-Sync <true/false>")]
     dedicated_gfx_set: Option<bool>,
     #[options(no_long, help = "get GPU mode")]
     dedicated_gfx_get: bool,
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut args: Vec<String> = args().collect();
-    args.remove(0);
+    let args: Vec<String> = args().skip(1).collect();
 
     let parsed: CLIStart;
     let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
@@ -125,65 +125,28 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    if parsed.help_requested() {
-        // As help option don't work with `parse_args_default`
-        // we will call `parse_args_default_or_exit` instead
-        CLIStart::parse_args_default_or_exit();
+    let (dbus, _) = AuraDbusClient::new()?;
+
+    let supported_tmp = dbus.proxies().supported().get_supported_functions()?;
+    let supported = serde_json::from_str::<SupportedFunctions>(&supported_tmp)?;
+
+    if parsed.help {
+        print_supported_help(&supported, &parsed);
+        std::process::exit(1);
     }
 
     if parsed.version {
-        println!("  asusctl version {}", env!("CARGO_PKG_VERSION"));
-        println!(" rog-dbus version {}", rog_dbus::VERSION);
-        println!("rog-types version {}", rog_types::VERSION);
+        println!("  asusctl v{}", env!("CARGO_PKG_VERSION"));
+        println!(" rog-dbus v{}", rog_dbus::VERSION);
+        println!("rog-types v{}", rog_types::VERSION);
+        println!("   daemon v{}", daemon::VERSION);
+        return Ok(());
     }
 
-    let (dbus, _) = AuraDbusClient::new()?;
-
     match parsed.command {
-        Some(CliCommand::LedMode(mode)) => {
-            if (mode.command.is_none() && !mode.prev_mode && !mode.next_mode) || mode.help {
-                println!("Missing arg or command\n\n{}", mode.self_usage());
-                if let Some(lst) = mode.self_command_list() {
-                    println!("\n{}", lst);
-                }
-                println!("\nHelp can also be requested on modes, e.g: static --help");
-            }
-            if mode.next_mode && mode.prev_mode {
-                println!("Please specify either next or previous")
-            }
-            if mode.next_mode {
-                dbus.proxies().led().next_led_mode()?;
-            } else if mode.prev_mode {
-                dbus.proxies().led().prev_led_mode()?;
-            } else if let Some(command) = mode.command {
-                dbus.proxies().led().set_led_mode(&command.into())?
-            }
-        }
-        Some(CliCommand::Profile(cmd)) => {
-            if (!cmd.next
-                && !cmd.create
-                && cmd.curve.is_none()
-                && cmd.max_percentage.is_none()
-                && cmd.min_percentage.is_none()
-                && cmd.preset.is_none()
-                && cmd.profile.is_none()
-                && cmd.turbo.is_none())
-                || cmd.help
-            {
-                println!("Missing arg or command\n\n{}", cmd.self_usage());
-                if let Some(lst) = cmd.self_command_list() {
-                    println!("\n{}", lst);
-                }
-            }
-            if cmd.next {
-                dbus.proxies().profile().next_fan()?;
-            } else {
-                dbus.proxies()
-                    .profile()
-                    .write_command(&ProfileEvent::Cli(cmd))?
-            }
-        }
-        Some(CliCommand::Graphics(cmd)) => do_gfx(cmd, &dbus)?,
+        Some(CliCommand::LedMode(mode)) => handle_led_mode(&dbus, &supported.keyboard_led, &mode)?,
+        Some(CliCommand::Profile(cmd)) => handle_profile(&dbus, &supported.fan_cpu_ctrl, &cmd)?,
+        Some(CliCommand::Graphics(cmd)) => do_gfx(&dbus, &supported.rog_bios_ctrl, cmd)?,
         Some(CliCommand::AniMe(cmd)) => {
             if (cmd.command.is_none() && cmd.boot.is_none() && cmd.turn.is_none()) || cmd.help {
                 println!("Missing arg or command\n\n{}", cmd.self_usage());
@@ -207,43 +170,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 }
             }
         }
-        Some(CliCommand::Bios(cmd)) => {
-            if (cmd.dedicated_gfx_set.is_none()
-                && !cmd.dedicated_gfx_get
-                && cmd.post_sound_set.is_none()
-                && !cmd.post_sound_get)
-                || cmd.help
-            {
-                println!("Missing arg or command\n\n{}", cmd.self_usage());
-                if let Some(lst) = cmd.self_command_list() {
-                    println!("\n{}", lst);
-                }
-            }
-
-            if let Some(opt) = cmd.post_sound_set {
-                dbus.proxies().rog_bios().set_post_sound(opt)?;
-            }
-            if cmd.post_sound_get {
-                let res = if dbus.proxies().rog_bios().get_post_sound()? == 1 {
-                    true
-                } else {
-                    false
-                };
-                println!("Bios POST sound on: {}", res);
-            }
-            if let Some(opt) = cmd.dedicated_gfx_set {
-                dbus.proxies().rog_bios().set_dedicated_gfx(opt)?;
-            }
-            if cmd.dedicated_gfx_get {
-                let res = if dbus.proxies().rog_bios().get_dedicated_gfx()? == 1 {
-                    true
-                } else {
-                    false
-                };
-                println!("Bios dedicated GPU on: {}", res);
-                println!("You must reboot your system to activate dedicated Nvidia mode");
-            }
-        }
+        Some(CliCommand::Bios(cmd)) => handle_bios_option(&dbus, &supported.rog_bios_ctrl, &cmd)?,
         None => {
             if (!parsed.show_supported
                 && parsed.kbd_bright.is_none()
@@ -282,11 +209,74 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
+fn print_supported_help(supported: &SupportedFunctions, parsed: &CLIStart) {
+    // As help option don't work with `parse_args_default`
+    // we will call `parse_args_default_or_exit` instead
+    let usage: Vec<String> = parsed.self_usage().lines().map(|s| s.to_string()).collect();
+    for line in usage.iter().filter(|line| {
+        if line.contains("--fan-mode") && !supported.fan_cpu_ctrl.stock_fan_modes {
+            return false;
+        }
+        if line.contains("--chg-limit") && !supported.charge_ctrl.charge_level_set {
+            return false;
+        }
+        true
+    }) {
+        println!("{}", line);
+    }
+
+    // command strings are in order of the struct
+    let commands: Vec<String> = CliCommand::usage().lines().map(|s| s.to_string()).collect();
+    println!("\nCommands available");
+    for line in commands.iter().filter(|line| {
+        if line.contains("profile")
+            && !supported.fan_cpu_ctrl.stock_fan_modes
+            && !supported.fan_cpu_ctrl.fan_curve_set
+        {
+            return false;
+        }
+        if line.contains("led-mode") && supported.keyboard_led.stock_led_modes.is_none() {
+            return false;
+        }
+        if line.contains("bios")
+            && (!supported.rog_bios_ctrl.dedicated_gfx_toggle
+                || !supported.rog_bios_ctrl.post_sound_toggle)
+        {
+            return false;
+        }
+        if line.contains("anime") && !supported.anime_ctrl.0 {
+            return false;
+        }
+        true
+    }) {
+        println!("{}", line);
+    }
+
+    if !supported.fan_cpu_ctrl.stock_fan_modes {
+        println!("Note: Fan mode control is not supported by this laptop");
+    }
+    if !supported.charge_ctrl.charge_level_set {
+        println!("Note: Charge control is not supported by this laptop");
+    }
+}
+
 fn do_gfx(
+    dbus: &AuraDbusClient,
+    supported: &RogBiosSupportedFunctions,
     command: GraphicsCommand,
-    dbus_client: &AuraDbusClient,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    if command.mode.is_none() && !command.get && !command.pow && !command.force || command.help {
+        println!("{}", command.self_usage());
+    }
+
     if let Some(mode) = command.mode {
+        if supported.dedicated_gfx_toggle {
+            if dbus.proxies().rog_bios().get_dedicated_gfx()? == 1 {
+                println!("You can not change modes until you turn dedicated/G-Sync off and reboot");
+                std::process::exit(-1);
+            }
+        }
+
         println!("Changing graphics modes...");
         println!("If this takes longer than 30s, ctrl+c then check `journalctl -b -u asusd`");
 
@@ -295,19 +285,19 @@ fn do_gfx(
             "This will restart your display-manager. Please save all work!",
             "Setting graphics mode...",
         ) {
-            dbus_client.proxies().gfx().gfx_write_mode(mode.into())?;
-            let res = dbus_client.gfx_wait_changed()?;
+            dbus.proxies().gfx().gfx_write_mode(mode.into())?;
+            let res = dbus.gfx_wait_changed()?;
             println!("{}", res);
             std::process::exit(1)
         }
         std::process::exit(-1)
     }
     if command.get {
-        let res = dbus_client.proxies().gfx().gfx_get_mode()?;
+        let res = dbus.proxies().gfx().gfx_get_mode()?;
         println!("Current graphics mode: {}", res);
     }
     if command.pow {
-        let res = dbus_client.proxies().gfx().gfx_get_pwr()?;
+        let res = dbus.proxies().gfx().gfx_get_pwr()?;
         if res.contains("active") {
             println!("Current power status: {}", Red.paint(&format!("{}", res)));
         } else {
@@ -331,3 +321,150 @@ fn do_gfx_action(no_confirm: bool, ask_msg: &str, ok_msg: &str) -> bool {
     }
     false
 }
+
+fn handle_led_mode(
+    dbus: &AuraDbusClient,
+    supported: &LedSupportedFunctions,
+    mode: &LedModeCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
+        if !mode.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}\n", mode.self_usage());
+        println!("Commands available");
+
+        let commands: Vec<String> = LedModeCommand::command_list()
+            .unwrap()
+            .lines()
+            .map(|s| s.to_string())
+            .collect();
+        for (_, command) in commands.iter().enumerate().filter(|(mode_num, _)| {
+            if let Some(modes) = supported.stock_led_modes.as_ref() {
+                return modes.contains(&(*mode_num as u8));
+            }
+            false
+        }) {
+            println!("{}", command);
+        }
+
+        println!("\nHelp can also be requested on modes, e.g: static --help");
+        std::process::exit(1);
+    }
+    if mode.next_mode && mode.prev_mode {
+        println!("Please specify either next or previous")
+    }
+    if mode.next_mode {
+        dbus.proxies().led().next_led_mode()?;
+    } else if mode.prev_mode {
+        dbus.proxies().led().prev_led_mode()?;
+    } else if let Some(command) = mode.command.as_ref() {
+        dbus.proxies().led().set_led_mode(&command.into())?
+    }
+    Ok(())
+}
+
+fn handle_profile(
+    dbus: &AuraDbusClient,
+    supported: &FanCpuSupportedFunctions,
+    cmd: &ProfileCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !cmd.next
+        && !cmd.create
+        && cmd.curve.is_none()
+        && cmd.max_percentage.is_none()
+        && cmd.min_percentage.is_none()
+        && cmd.fan_preset.is_none()
+        && cmd.profile.is_none()
+        && cmd.turbo.is_none()
+    {
+        if !cmd.help {
+            println!("Missing arg or command\n");
+        }
+        let usage: Vec<String> = ProfileCommand::usage()
+            .lines()
+            .map(|s| s.to_string())
+            .collect();
+        for line in usage
+            .iter()
+            .filter(|line| !(line.contains("--curve") && !supported.fan_curve_set))
+        {
+            println!("{}", line);
+        }
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+        std::process::exit(1);
+    }
+    if cmd.next {
+        dbus.proxies().profile().next_fan()?;
+    } else {
+        dbus.proxies()
+            .profile()
+            .write_command(&ProfileEvent::Cli(cmd.clone()))?
+    }
+
+    Ok(())
+}
+
+fn handle_bios_option(
+    dbus: &AuraDbusClient,
+    supported: &RogBiosSupportedFunctions,
+    cmd: &BiosCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    {
+        if (cmd.dedicated_gfx_set.is_none()
+            && !cmd.dedicated_gfx_get
+            && cmd.post_sound_set.is_none()
+            && !cmd.post_sound_get)
+            || cmd.help
+        {
+            println!("Missing arg or command\n");
+
+            let usage: Vec<String> = BiosCommand::usage()
+            .lines()
+            .map(|s| s.to_string())
+            .collect();
+
+            for line in usage
+                .iter()
+                .filter(|line| !(line.contains("sound") && !supported.post_sound_toggle)
+            || !(line.contains("GPU") && !supported.dedicated_gfx_toggle))
+            {
+                println!("{}", line);
+            }
+        }
+
+        if let Some(opt) = cmd.post_sound_set {
+            dbus.proxies().rog_bios().set_post_sound(opt)?;
+        }
+        if cmd.post_sound_get {
+            let res = if dbus.proxies().rog_bios().get_post_sound()? == 1 {
+                true
+            } else {
+                false
+            };
+            println!("Bios POST sound on: {}", res);
+        }
+        if let Some(opt) = cmd.dedicated_gfx_set {
+            println!("Rebuilding initrd to include drivers");
+            dbus.proxies().rog_bios().set_dedicated_gfx(opt)?;
+                println!("The mode change is not active until you reboot, on boot the bios will make the required change");
+            if opt {
+                println!("NOTE: on reboot your display manager will be forced to use Nvidia drivers");
+            } else {
+                println!("NOTE: after reboot you can then select regular graphics modes");
+            }
+        }
+        if cmd.dedicated_gfx_get {
+            let res = if dbus.proxies().rog_bios().get_dedicated_gfx()? == 1 {
+                true
+            } else {
+                false
+            };
+            println!("Bios dedicated GPU on: {}", res);
+        }
+    }
+    Ok(())
+}

daemon/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "daemon"
-version = "3.1.1"
+version = "3.1.5"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -40,4 +40,4 @@ toml = "^0.5"
 sysfs-class = "^0.1.2" # used for backlight control and baord ID
 rog_fan_curve = { version = "0.1", features = ["serde"] }
 # cpu power management
-intel-pstate = "^0.2"
+intel-pstate = "^0.2"

daemon/src/ctrl_anime.rs

@@ -30,7 +30,7 @@ use crate::GetSupported;
 
 use serde_derive::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize)]
-pub struct AnimeSupportedFunctions(bool);
+pub struct AnimeSupportedFunctions(pub bool);
 
 impl GetSupported for CtrlAnimeDisplay {
     type A = AnimeSupportedFunctions;

daemon/src/ctrl_fan_cpu.rs

@@ -62,7 +62,12 @@ impl DbusFanAndCpu {
                     cfg.read();
                     ctrl.handle_profile_event(&event, &mut cfg)
                         .unwrap_or_else(|err| warn!("{}", err));
-                    self.notify_profile(&cfg.active_profile).unwrap_or(());
+                    if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
+                        if let Ok(json) = serde_json::to_string(profile) {
+                            self.notify_profile(&json)
+                                .unwrap_or_else(|err| warn!("{}", err));
+                        }
+                    }
                 }
             }
         }
@@ -72,6 +77,7 @@ impl DbusFanAndCpu {
     fn next_profile(&mut self) {
         if let Ok(mut ctrl) = self.inner.try_lock() {
             if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
+                cfg.read();
                 ctrl.do_next_profile(&mut cfg)
                     .unwrap_or_else(|err| warn!("{}", err));
                 if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
@@ -258,7 +264,7 @@ impl CtrlFanAndCPU {
                 if let Some(max_perc) = command.max_percentage {
                     profile.max_percentage = max_perc;
                 }
-                if let Some(ref preset) = command.preset {
+                if let Some(ref preset) = command.fan_preset {
                     profile.fan_preset = preset.into();
                 }
                 if let Some(ref curve) = command.curve {

daemon/src/ctrl_gfx/error.rs

@@ -1,19 +1,15 @@
-use std::error;
 use std::fmt;
+use std::{error, process::ExitStatus};
 
 use crate::error::RogError;
 
 #[derive(Debug)]
 pub enum GfxError {
     ParseVendor,
-    Path(String, std::io::Error),
-    Read(String, std::io::Error),
-    Write(String, std::io::Error),
-    Module(String, std::io::Error),
     Bus(String, std::io::Error),
-    Command(String, std::io::Error),
-    Modprobe(String),
-    DisplayManager(String),
+    DisplayManagerAction(String, ExitStatus),
+    DisplayManagerTimeout(String),
+    GsyncModeActive,
 }
 
 impl fmt::Display for GfxError {
@@ -21,14 +17,14 @@ impl fmt::Display for GfxError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             GfxError::ParseVendor => write!(f, "Could not parse vendor name"),
-            GfxError::Path(path, error) => write!(f, "Path {}: {}", path, error),
-            GfxError::Read(path, error) => write!(f, "Read {}: {}", path, error),
-            GfxError::Write(path, error) => write!(f, "Write {}: {}", path, error),
-            GfxError::Module(func, error) => write!(f, "Module error: {}: {}", func, error),
             GfxError::Bus(func, error) => write!(f, "Bus error: {}: {}", func, error),
-            GfxError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
-            GfxError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
-            GfxError::DisplayManager(detail) => write!(f, "Display manager: {}", detail),
+            GfxError::DisplayManagerAction(action, status) => {
+                write!(f, "Display-manager action {} failed: {}", action, status)
+            }
+            GfxError::DisplayManagerTimeout(state) => {
+                write!(f, "Timed out waiting for display-manager {} state", state)
+            }
+            GfxError::GsyncModeActive => write!(f, "Can not switch gfx modes when dedicated/G-Sync mode is active"),
         }
     }
 }

daemon/src/ctrl_gfx/gfx.rs

@@ -1,11 +1,12 @@
 use ctrl_gfx::error::GfxError;
 use ctrl_gfx::*;
+use ctrl_rog_bios::CtrlRogBios;
 use log::{error, info, warn};
 use rog_types::gfx_vendors::GfxVendors;
-use std::io::Write;
 use std::iter::FromIterator;
 use std::process::Command;
 use std::str::FromStr;
+use std::{io::Write, ops::Add, path::Path};
 use std::{sync::Arc, sync::Mutex};
 use sysfs_class::{PciDevice, SysClass};
 use system::{GraphicsDevice, PciBus};
@@ -47,8 +48,9 @@ impl Dbus for CtrlGraphics {
 
     fn set_vendor(&mut self, vendor: String) {
         if let Ok(tmp) = GfxVendors::from_str(&vendor) {
+            info!("Switching gfx mode to {}", vendor);
             let msg = self.set_gfx_config(tmp).unwrap_or_else(|err| {
-                warn!("{}", err);
+                error!("{}", err);
                 format!("Failed: {}", err.to_string())
             });
             self.notify_gfx(&vendor)
@@ -173,7 +175,7 @@ impl CtrlGraphics {
 
     fn get_runtime_status() -> Result<String, RogError> {
         const PATH: &str = "/sys/bus/pci/devices/0000:01:00.0/power/runtime_status";
-        let buf = std::fs::read_to_string(PATH).map_err(|err| GfxError::Read(PATH.into(), err))?;
+        let buf = std::fs::read_to_string(PATH).map_err(|err| RogError::Read(PATH.into(), err))?;
         Ok(buf)
     }
 
@@ -190,7 +192,7 @@ impl CtrlGraphics {
             .arg(action)
             .arg("nvidia-fallback.service")
             .status()
-            .map_err(|err| GfxError::Command("systemctl".into(), err))?;
+            .map_err(|err| RogError::Command("systemctl".into(), err))?;
 
         if !status.success() {
             // Error is ignored in case this service is removed
@@ -210,17 +212,22 @@ impl CtrlGraphics {
             [PRIMARY_GPU_BEGIN, PRIMARY_GPU_END].concat()
         };
 
-        info!("Writing {}", PRIMARY_GPU_XORG_PATH);
+        if !Path::new(XORG_PATH).exists() {
+            std::fs::create_dir(XORG_PATH).map_err(|err| RogError::Write(XORG_PATH.into(), err))?;
+        }
+
+        let file = XORG_PATH.to_string().add(XORG_FILE);
+        info!("Writing {}", file);
         let mut file = std::fs::OpenOptions::new()
             .create(true)
             .truncate(true)
             .write(true)
-            .open(PRIMARY_GPU_XORG_PATH)
-            .map_err(|err| GfxError::Write(PRIMARY_GPU_XORG_PATH.into(), err))?;
+            .open(&file)
+            .map_err(|err| RogError::Write(file, err))?;
 
         file.write_all(&text)
             .and_then(|_| file.sync_all())
-            .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
+            .map_err(|err| RogError::Write(MODPROBE_PATH.into(), err))?;
         Ok(())
     }
 
@@ -232,11 +239,11 @@ impl CtrlGraphics {
             .truncate(true)
             .write(true)
             .open(MODPROBE_PATH)
-            .map_err(|err| GfxError::Path(MODPROBE_PATH.into(), err))?;
+            .map_err(|err| RogError::Path(MODPROBE_PATH.into(), err))?;
 
         file.write_all(MODPROBE_BASE)
             .and_then(|_| file.sync_all())
-            .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
+            .map_err(|err| RogError::Write(MODPROBE_PATH.into(), err))?;
 
         Ok(())
     }
@@ -249,64 +256,116 @@ impl CtrlGraphics {
         let removes = self.nvidia.iter().map(|dev| dev.remove());
 
         Result::from_iter(unbinds.chain(removes))
-            .map_err(|err| GfxError::Command("device unbind error".into(), err))?;
+            .map_err(|err| RogError::Command("device unbind error".into(), err))?;
 
         Ok(())
     }
 
+    fn log_uses_of_nvidia() {
+        // lsof /dev/nvidia*
+        let mut cmd = Command::new("lsof");
+        cmd.arg("/dev/nvidia*");
+
+        match cmd.output() {
+            Ok(output) => {
+                if !output.status.success() {
+                    error!("Failed to list uses of nvidia devices: {}",  String::from_utf8_lossy(&output.stderr));
+                } else if output.status.success() {
+                    warn!("{}", String::from_utf8_lossy(&output.stdout));
+                }
+            }
+            Err(err) => error!("Failed to list uses of nvidia devices: {}", err),
+        }
+    }
+
     fn do_driver_action(driver: &str, action: &str) -> Result<(), RogError> {
         let mut cmd = Command::new(action);
         cmd.arg(driver);
 
-        let status = cmd
-            .status()
-            .map_err(|err| GfxError::Command(format!("{:?}", cmd), err))?;
-        if !status.success() {
-            let msg = format!("{} {} failed: {:?}", action, driver, status);
-            error!("{}", msg);
-            return Err(GfxError::Modprobe(msg).into());
+        let mut count = 0;
+        const MAX_TRIES: i32 = 6;
+        loop {
+            if count > MAX_TRIES {
+                let msg = format!("{} {} failed for unknown reason", action, driver);
+                error!("{}", msg);
+                return Ok(()); //Err(RogError::Modprobe(msg));
+            }
+
+            let output = cmd
+                .output()
+                .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+            if !output.status.success() {
+                if output
+                    .stderr
+                    .ends_with("is not currently loaded\n".as_bytes())
+                {
+                    return Ok(());
+                }
+                if output.stderr.ends_with("Permission denied\n".as_bytes()) {
+                    let msg = format!(
+                        "{} {} failed: {:?}",
+                        action,
+                        driver,
+                        String::from_utf8_lossy(&output.stderr)
+                    );
+                    warn!("{}", msg);
+                    warn!("It may be safe to ignore the above error, run `lsmod |grep nvidia` to confirm modules loaded");
+                    return Ok(());
+                }
+                if count >= MAX_TRIES {
+                    let msg = format!(
+                        "{} {} failed: {:?}",
+                        action,
+                        driver,
+                        String::from_utf8_lossy(&output.stderr)
+                    );
+                    return Err(RogError::Modprobe(msg));
+                }
+            } else if output.status.success() {
+                return Ok(());
+            }
+
+            count += 1;
+            std::thread::sleep(std::time::Duration::from_millis(250));
         }
-        Ok(())
     }
 
     fn do_display_manager_action(action: &str) -> Result<(), RogError> {
-        let service = "display-manager.service";
         let mut cmd = Command::new("systemctl");
         cmd.arg(action);
-        cmd.arg(service);
+        cmd.arg(DISPLAY_MANAGER);
 
         let status = cmd
             .status()
-            .map_err(|err| GfxError::Command(format!("{:?}", cmd), err))?;
+            .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
         if !status.success() {
-            let msg = format!("systemctl {} {} failed: {:?}", action, service, status);
-            error!("{}", msg);
-            return Err(GfxError::DisplayManager(msg).into());
+            let msg = format!(
+                "systemctl {} {} failed: {:?}",
+                action, DISPLAY_MANAGER, status
+            );
+            return Err(GfxError::DisplayManagerAction(msg, status).into());
         }
         Ok(())
     }
 
-    fn wait_display_manager_inactive() -> Result<(), RogError> {
-        let service = "display-manager.service";
+    fn wait_display_manager_state(state: &str) -> Result<(), RogError> {
         let mut cmd = Command::new("systemctl");
         cmd.arg("is-active");
-        cmd.arg(service);
+        cmd.arg(DISPLAY_MANAGER);
 
         let mut count = 0;
 
-        while count <= 4 {
+        while count <= 5 {
             let output = cmd
                 .output()
-                .map_err(|err| GfxError::Command(format!("{:?}", cmd), err))?;
-            if output.stdout.starts_with("inactive".as_bytes()) {
+                .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+            if output.stdout.starts_with(state.as_bytes()) {
                 return Ok(());
             }
             std::thread::sleep(std::time::Duration::from_millis(500));
             count += 1;
         }
-        return Err(
-            GfxError::DisplayManager("display-manager did not completely stop".into()).into(),
-        );
+        return Err(GfxError::DisplayManagerTimeout(state.into()).into());
     }
 
     pub fn do_vendor_tasks(&mut self, vendor: GfxVendors) -> Result<(), RogError> {
@@ -318,18 +377,19 @@ impl CtrlGraphics {
             .rescan()
             .map_err(|err| GfxError::Bus("bus rescan error".into(), err))?;
 
-        let drivers = vec!["nvidia_drm", "nvidia_uvm", "nvidia_modeset", "nvidia"]; // i2c_nvidia_gpu?
-
         match vendor {
             GfxVendors::Nvidia | GfxVendors::Hybrid | GfxVendors::Compute => {
-                for driver in drivers {
-                    Self::do_driver_action(driver, "modprobe")?;
+                for driver in NVIDIA_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "modprobe").map_err(|err| {
+                        Self::log_uses_of_nvidia();
+                        err
+                    })?;
                 }
             }
             // TODO: compute mode, needs different setup
             // GfxVendors::Compute => {}
             GfxVendors::Integrated => {
-                for driver in drivers {
+                for driver in NVIDIA_DRIVERS.iter() {
                     Self::do_driver_action(driver, "rmmod")?;
                 }
                 self.unbind_remove_nvidia()?;
@@ -344,10 +404,41 @@ impl CtrlGraphics {
     ///
     /// Will stop and start display manager without warning
     pub fn set_gfx_config(&mut self, vendor: GfxVendors) -> Result<String, RogError> {
+        if let Ok(gsync) = CtrlRogBios::get_gfx_mode() {
+            if gsync == 1{
+                return Err(GfxError::GsyncModeActive.into());
+            }
+        }
+
         Self::do_display_manager_action("stop")?;
-        Self::wait_display_manager_inactive()?;
+        match Self::wait_display_manager_state("inactive") {
+            Ok(_) => info!("display-manager stopped"),
+            Err(err) => {
+                warn!("{}", err);
+                warn!("Retry stop display manager");
+                Self::do_display_manager_action("stop")?;
+                Self::wait_display_manager_state("inactive")?;
+            }
+        }
+
         self.do_vendor_tasks(vendor)?;
+
         Self::do_display_manager_action("start")?;
+        match Self::wait_display_manager_state("active") {
+            Ok(_) => info!("display-manager started"),
+            Err(err) => {
+                warn!("{}", err);
+                warn!("Retry start display manager");
+                Self::do_display_manager_action("restart")?;
+                Self::wait_display_manager_state("active")?;
+            }
+        }
+
+        if Self::wait_display_manager_state("active").is_err() {
+            error!("display-manager failed to start normally, attempting restart");
+            Self::do_display_manager_action("restart")?;
+        }
+        Self::wait_display_manager_state("active")?;
         // TODO: undo if failed? Save last mode, catch errors...
         let v: &str = vendor.into();
         Ok(format!("Graphics mode changed to {} successfully", v))

daemon/src/ctrl_gfx/mod.rs

@@ -4,9 +4,15 @@ pub mod gfx;
 
 pub mod system;
 
+const NVIDIA_DRIVERS: [&str; 4] = ["nvidia_drm", "nvidia_modeset", "nvidia_uvm", "nvidia"];
+
+const DISPLAY_MANAGER: &str = "display-manager.service";
+
 const MODPROBE_PATH: &str = "/etc/modprobe.d/asusd.conf";
 
 static MODPROBE_BASE: &[u8] = br#"# Automatically generated by asusd
+# If you have issues with i2c_nvidia_gpu, copy the 2 lines below to a
+# new blacklist file and uncomment
 #blacklist i2c_nvidia_gpu
 #alias i2c_nvidia_gpu off
 blacklist nouveau
@@ -15,7 +21,8 @@ options nvidia NVreg_DynamicPowerManagement=0x02
 options nvidia-drm modeset=1
 "#;
 
-const PRIMARY_GPU_XORG_PATH: &str = "/etc/X11/xorg.conf.d/90-nvidia-primary.conf";
+const XORG_FILE: &str = "90-nvidia-primary.conf";
+const XORG_PATH: &str = "/etc/X11/xorg.conf.d/";
 
 static PRIMARY_GPU_BEGIN: &[u8] = br#"# Automatically generated by asusd
 Section "OutputClass"

daemon/src/ctrl_rog_bios.rs

@@ -136,9 +136,7 @@ impl CtrlRogBios {
             }
         }
 
-        Ok(CtrlRogBios {
-            _config: config,
-        })
+        Ok(CtrlRogBios { _config: config })
     }
 
     fn set_path_mutable(path: &str) -> Result<(), RogError> {
@@ -271,6 +269,7 @@ impl CtrlRogBios {
         } else if Path::new(DRACUT_PATH).exists() {
             let mut cmd = Command::new("dracut");
             cmd.arg("-f");
+            cmd.arg("-q");
             initfs_cmd = Some(cmd);
             info!("Using initramfs update command 'dracut'");
         }

daemon/src/ctrl_supported.rs

@@ -15,11 +15,11 @@ use crate::{
 
 #[derive(Serialize, Deserialize)]
 pub struct SupportedFunctions {
-    anime_ctrl: AnimeSupportedFunctions,
-    charge_ctrl: ChargeSupportedFunctions,
-    fan_cpu_ctrl: FanCpuSupportedFunctions,
-    keyboard_led: LedSupportedFunctions,
-    rog_bios_ctrl: RogBiosSupportedFunctions,
+    pub anime_ctrl: AnimeSupportedFunctions,
+    pub charge_ctrl: ChargeSupportedFunctions,
+    pub fan_cpu_ctrl: FanCpuSupportedFunctions,
+    pub keyboard_led: LedSupportedFunctions,
+    pub rog_bios_ctrl: RogBiosSupportedFunctions,
 }
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]

daemon/src/daemon.rs

@@ -31,9 +31,9 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         .filter(None, LevelFilter::Info)
         .init();
 
-    info!("daemon version {}", daemon::VERSION);
-    info!(" rog-dbus version {}", rog_dbus::VERSION);
-    info!("rog-types version {}", rog_types::VERSION);
+    info!("   daemon v{}", daemon::VERSION);
+    info!(" rog-dbus v{}", rog_dbus::VERSION);
+    info!("rog-types v{}", rog_types::VERSION);
 
     start_daemon()?;
     Ok(())
@@ -111,8 +111,7 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                     if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
                         if let Ok(vendor) = ctrl.get_gfx_mode() {
                             if ded == 1 && vendor != GfxVendors::Nvidia {
-                                error!("Dedicated GFX toggle is on but driver mode is not nvidia \nSetting to nvidia driver mode");
-                                error!("You must reboot to enable Nvidia driver");
+                                warn!("Dedicated GFX toggle is on but driver mode is not nvidia \nSetting to nvidia driver mode");
                                 ctrl.do_vendor_tasks(GfxVendors::Nvidia)?;
                             } else if ded == 0 {
                                 info!("Dedicated GFX toggle is off");
@@ -121,7 +120,7 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                     }
                 }
                 ctrl.reload()
-                    .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
+                    .unwrap_or_else(|err| error!("Gfx controller: {}", err));
                 ctrl.add_to_server(&mut object_server);
             }
             Err(err) => {

daemon/src/error.rs

@@ -26,6 +26,8 @@ pub enum RogError {
     ReloadFail(String),
     GfxSwitching(GfxError),
     Initramfs(String),
+    Modprobe(String),
+    Command(String, std::io::Error),
 }
 
 impl fmt::Display for RogError {
@@ -50,6 +52,8 @@ impl fmt::Display for RogError {
             RogError::ReloadFail(deets) => write!(f, "Task error: {}", deets),
             RogError::GfxSwitching(deets) => write!(f, "Graphics switching error: {}", deets),
             RogError::Initramfs(detail) => write!(f, "Initiramfs error: {}", detail),
+            RogError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
+            RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
         }
     }
 }

data/asusd-ledmodes.toml

@@ -1,17 +1,17 @@
 [[led_modes]]
 prod_family = "Zephyrus S"
 board_names = ["GX502", "GX701", "G531", "GL531", "G532"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
+led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 255]
 
 [[led_modes]]
 prod_family = "Zephyrus M"
 board_names = ["GU502GV"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
+led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 255]
 
 [[led_modes]]
 prod_family = "ROG Zephyrus M15"
 board_names = ["GU502LW"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
+led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 255]
 
 [[led_modes]]
 prod_family = "ROG Zephyrus M15"
@@ -26,7 +26,7 @@ led_modes = [0, 1, 2, 3, 10, 13]
 [[led_modes]]
 prod_family = "ROG Strix"
 board_names = ["G531GW"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
+led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 255]
 
 [[led_modes]]
 prod_family = "ROG Strix"

data/asusd.service

@@ -2,6 +2,7 @@
 Description=ASUS Notebook Control
 StartLimitInterval=200
 StartLimitBurst=2
+Before=display-manager.service
 
 [Service]
 ExecStart=/usr/bin/asusd
@@ -9,5 +10,4 @@ Restart=on-failure
 Restart=always
 RestartSec=1
 Type=dbus
-BusName=org.asuslinux.Daemon
-Before=display-manager.service
+BusName=org.asuslinux.Daemon

rog-types/src/aura_modes.rs

@@ -223,6 +223,12 @@ impl From<SetAuraBuiltin> for AuraModes {
     }
 }
 
+impl From<&SetAuraBuiltin> for AuraModes {
+    fn from(mode: &SetAuraBuiltin) -> Self {
+        mode.clone().into()
+    }
+}
+
 /// Very specific mode conversion required because numbering isn't linear
 impl From<AuraModes> for u8 {
     fn from(mode: AuraModes) -> Self {

rog-types/src/profile.rs

@@ -81,16 +81,20 @@ pub struct ProfileCommand {
     #[options(help = "create the profile if it doesn't exist")]
     pub create: bool,
 
-    #[options(help = "enable or disable cpu turbo")]
+    #[options(meta = "", help = "enable or disable cpu turbo")]
     pub turbo: Option<bool>,
-    #[options(help = "set min cpu scaling (intel)")]
+    #[options(meta = "", help = "set min cpu scaling (intel)")]
     pub min_percentage: Option<u8>,
-    #[options(help = "set max cpu scaling (intel)")]
+    #[options(meta = "", help = "set max cpu scaling (intel)")]
     pub max_percentage: Option<u8>,
 
-    #[options(meta = "PWR", help = "<silent, normal, boost>")]
-    pub preset: Option<FanLevel>,
-    #[options(parse(try_from_str = "parse_fan_curve"), help = "set fan curve")]
+    #[options(meta = "", help = "<silent, normal, boost>")]
+    pub fan_preset: Option<FanLevel>,
+    #[options(
+        meta = "",
+        parse(try_from_str = "parse_fan_curve"),
+        help = "set fan curve"
+    )]
     pub curve: Option<Curve>,
     #[options(free)]
     pub profile: Option<String>,