Prep release

Merge branch 'fluke/testing-gfx-switch' into 'main'
More verbose and thorough checks for gfx switching See merge request asus-linux/asus-nb-ctrl!30
2026-02-06 00:15:04 +01:00 · 2021-03-11 12:32:34 +13:00 · 2021-03-10 23:28:02 +00:00 · 2021-03-11 12:24:01 +13:00 · 2021-03-10 21:23:35 +13:00 · 2021-03-10 18:42:44 +13:00
27 changed files with 1003 additions and 580 deletions
@@ -5,6 +5,51 @@ 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
+- GU502LU led-modes
+### Changed
+- Graphics switching is now rebootless, the daemon will now restart the
+  display-manager to switch modes instead. Caveats are:
+  + There is no confirmation from the daemon, the program issuing the command
+    must confirm the request.
+  + systemd only
+- Laptops with dedicated Nvidia mode:
+  + You still must reboot for the bios to switch modes
+  + On boot if dedicated mode is active then asusd will update the required configs
+    to put display-manager in nvidia mode
+
+# [3.0.0] - 2021-02-22
+### Added
+- G531GD led modes

 # [3.0.0] - 2021-02-14
 ### Changed
@@ -33,8 +33,9 @@ dependencies = [

 [[package]]
 name = "asusctl"
-version = "3.0.0"
+version = "3.1.2"
 dependencies = [
+ "daemon",
 "gumdrop",
 "rog_dbus",
 "rog_types",
@@ -129,9 +130,9 @@ checksum = "631ae5198c9be5e753e5cc215e1bd73c2b466a3565173db433f52bb9d3e66dba"

 [[package]]
 name = "cc"
-version = "1.0.66"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c0496836a84f8d0495758516b8621a622beb77c0fed418570e50764093ced48"
+checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"

 [[package]]
 name = "cfg-if"
@@ -175,18 +176,19 @@ checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"

 [[package]]
 name = "crossbeam-utils"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02d96d1e189ef58269ebe5b97953da3274d83a93af647c2ddd6f9dab28cedb8d"
+checksum = "bae8f328835f8f5a6ceb6a7842a7f2d0c03692adb5c889347235d59194731fe3"
 dependencies = [
 "autocfg",
 "cfg-if 1.0.0",
 "lazy_static",
+ "loom",
 ]

 [[package]]
 name = "daemon"
-version = "3.0.0"
+version = "3.1.5"
 dependencies = [
 "env_logger",
 "intel-pstate",
@@ -212,7 +214,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

@@ -244,15 +246,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "946ee94e3dbf58fdd324f9ce245c7b238d46a66f00e86a020b71996349e46cce"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

 [[package]]
 name = "env_logger"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26ecb66b4bdca6c1409b40fb255eefc2bd4f6d135dab3c3124f80ffa2a9661e"
+checksum = "17392a012ea30ef05a610aa97dfb49496e71c9f676b27879922ea5bdf60d9d3f"
 dependencies = [
 "atty",
 "humantime",
@@ -269,7 +271,7 @@ checksum = "22deed3a8124cff5fa835713fa105621e43bbdc46690c3a6b68328a012d350d4"
 dependencies = [
 "proc-macro-error",
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "rustversion",
 "syn 1.0.60",
 "synstructure",
@@ -355,7 +357,7 @@ checksum = "c287d25add322d9f9abdcdc5927ca398917996600182178774032e9f8258fedd"
 dependencies = [
 "proc-macro-hack",
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

@@ -394,6 +396,19 @@ dependencies = [
 "slab",
 ]

+[[package]]
+name = "generator"
+version = "0.6.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9fed24fd1e18827652b4d55652899a1e9da8e54d91624dc3437a5bc3a9f9a9c"
+dependencies = [
+ "cc",
+ "libc",
+ "log",
+ "rustversion",
+ "winapi",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.1.16"
@@ -421,7 +436,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "915ef07c710d84733522461de2a734d4d62a3fd39a4d4f404c2f385ef8618d05"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

@@ -473,9 +488,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.85"
+version = "0.2.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ccac4b00700875e6a07c6cde370d44d32fa01c5a65cdd2fca6858c479d28bb3"
+checksum = "b7282d924be3275cec7f6756ff4121987bc6481325397dde6ba3e7802b1a8b1c"

 [[package]]
 name = "libudev-sys"
@@ -508,6 +523,17 @@ dependencies = [
 "cfg-if 1.0.0",
 ]

+[[package]]
+name = "loom"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d44c73b4636e497b4917eb21c33539efa3816741a2d3ff26c6316f1b529481a4"
+dependencies = [
+ "cfg-if 1.0.0",
+ "generator",
+ "scoped-tls",
+]
+
 [[package]]
 name = "mac-notification-sys"
 version = "0.3.0"
@@ -537,12 +563,12 @@ checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"

 [[package]]
 name = "nb-connect"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8123a81538e457d44b933a02faf885d3fe8408806b23fa700e8f01c6c3a98998"
+checksum = "670361df1bc2399ee1ff50406a0d422587dd3bb0da596e1978fe8e05dabddf4f"
 dependencies = [
 "libc",
- "winapi",
+ "socket2",
 ]

 [[package]]
@@ -696,7 +722,7 @@ checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
 dependencies = [
 "proc-macro-error-attr",
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 "version_check",
 ]
@@ -708,7 +734,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "version_check",
 ]

@@ -741,9 +767,9 @@ checksum = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"

 [[package]]
 name = "quote"
-version = "1.0.8"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "991431c3519a3f36861882da93630ce66b52918dcf1b8e2fd66b397fc96f28df"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
 dependencies = [
 "proc-macro2",
 ]
@@ -872,15 +898,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9391c295d64fc0abb2c556bad848f33cb8296276b1ad2677d1ae1ace4f258f31"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

 [[package]]
 name = "serde_json"
-version = "1.0.61"
+version = "1.0.62"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fceb2595057b6891a4ee808f70054bd2d12f0e97f1cbb78689b59f676df325a"
+checksum = "ea1c6153794552ea7cf7cf63b1231a25de00ec90db326ba6264440fa08e31486"
 dependencies = [
 "itoa",
 "ryu",
@@ -894,7 +920,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dc6b7951b17b051f3210b063f12cc17320e2fe30ae05b0fe2a3abb068551c76"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

@@ -911,10 +937,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "133659a15339456eeeb07572eb02a91c91e9815e9cbc89566944d2c8d3efdbf6"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

+[[package]]
+name = "socket2"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "strum"
 version = "0.8.0"
@@ -949,7 +986,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c700597eca8a5a762beb35753ef6b94df201c81cca676604f547495a0d7f0081"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "unicode-xid 0.2.1",
 ]

@@ -969,7 +1006,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
 dependencies = [
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 "unicode-xid 0.2.1",
 ]
@@ -994,9 +1031,9 @@ dependencies = [

 [[package]]
 name = "thread_local"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8208a331e1cb318dd5bd76951d2b8fc48ca38a69f5f4e4af1b6a9f8c6236915"
+checksum = "8018d24e04c95ac8790716a5987d0fec4f8b27249ffa0f7d33f1369bdfb88cbd"
 dependencies = [
 "once_cell",
 ]
@@ -1146,9 +1183,9 @@ dependencies = [

 [[package]]
 name = "winrt-notification"
-version = "0.2.2"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c31a65da50d792c6f9bd2e3216249566c4fb1d2d34f9b7d2d66d2e93f62a242"
+checksum = "57790eb281688a4682dab44df2a1ba8b78373233bd71cb291c3e75fecb1a01c4"
 dependencies = [
 "strum",
 "strum_macros",
@@ -1206,7 +1243,7 @@ checksum = "87cc141cda72384bef359badf1808e391d3968f9299e8f3c3cbb78dafa1e0930"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]

@@ -1230,6 +1267,6 @@ checksum = "eaee686340b5bff077d52423d8cc4f0f7cb323fe3f31ef676b8a3a2810bc53c5"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
- "quote 1.0.8",
+ "quote 1.0.9",
 "syn 1.0.60",
 ]
@@ -1,5 +1,7 @@
 # ASUS NB Ctrl

+[![](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/donate/?hosted_button_id=4V2DEPS7K6APC) - [Asus Linux Website](https://asus-linux.org/)
+
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.

@@ -1,6 +1,6 @@
 [package]
 name = "asusctl"
-version = "3.0.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"

@@ -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::{
@@ -6,7 +7,7 @@ use rog_types::{
    gfx_vendors::GfxVendors,
    profile::{FanLevel, ProfileCommand, ProfileEvent},
 };
-use std::{env::args, process::Command};
+use std::env::args;
 use yansi_term::Colour::Green;
 use yansi_term::Colour::Red;

@@ -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,42 +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);
-            }
-        }
+        Some(CliCommand::Bios(cmd)) => handle_bios_option(&dbus, &supported.rog_bios_ctrl, &cmd)?,
        None => {
            if (!parsed.show_supported
                && parsed.kbd_bright.is_none()
@@ -281,60 +209,95 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

-fn do_gfx(
-    command: GraphicsCommand,
-    dbus_client: &AuraDbusClient,
-) -> Result<(), Box<dyn std::error::Error>> {
-    if let Some(mode) = command.mode {
-        println!("Updating settings, please wait...");
-        println!("If this takes longer than 30s, ctrl+c then check `journalctl -b -u asusd`");
+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);
+    }

-        dbus_client
-            .proxies()
-            .gfx()
-            .gfx_write_mode(<&str>::from(&mode).into())?;
-        let res = dbus_client.gfx_wait_changed()?;
-        match res.as_str() {
-            "reboot" => {
-                println!(
-                    "{}",
-                    Green.paint("\nGraphics vendor mode changed successfully\n"),
-                );
-                do_gfx_action(
-                    command.force,
-                    Command::new("systemctl").arg("reboot").arg("-i"),
-                    "Reboot Linux PC",
-                    "Please reboot when ready",
-                )?;
-            }
-            "restartx" => {
-                println!(
-                    "{}",
-                    Green.paint("\nGraphics vendor mode changed successfully\n")
-                );
-                do_gfx_action(
-                    command.force,
-                    Command::new("systemctl")
-                        .arg("restart")
-                        .arg("display-manager.service"),
-                    "Restart display-manager server",
-                    "Please restart display-manager when ready",
-                )?;
-                std::process::exit(1)
-            }
-            _ => {
-                println!("{}", Red.paint(&format!("\n{}\n", res.as_str())),);
+    // 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,
+) -> 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`");
+
+        if do_gfx_action(
+            command.force,
+            "This will restart your display-manager. Please save all work!",
+            "Setting graphics mode...",
+        ) {
+            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 {
@@ -344,34 +307,164 @@ fn do_gfx(
    Ok(())
 }

-fn do_gfx_action(
-    no_confirm: bool,
-    command: &mut Command,
-    ask_msg: &str,
-    cancel_msg: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    println!("{}? y/n", ask_msg);
+fn do_gfx_action(no_confirm: bool, ask_msg: &str, ok_msg: &str) -> bool {
+    println!("{}", Red.paint(&format!("{} Continue?", ask_msg)));

    let mut buf = String::new();
-    if no_confirm {
-        let status = command.status()?;
-
-        if !status.success() {
-            println!("systemctl: returned with {}", status);
-        }
-    }

    std::io::stdin().read_line(&mut buf).expect("Input failed");
    let input = buf.chars().next().unwrap() as char;

    if input == 'Y' || input == 'y' || no_confirm {
-        let status = command.status()?;
+        println!("{}", Green.paint(&format!("{}", ok_msg)));
+        return true;
+    }
+    false
+}

-        if !status.success() {
-            println!("systemctl: returned with {}", status);
+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);
        }
-    } else {
-        println!("{}", Red.paint(&format!("{}", cancel_msg)));
    }
    Ok(())
 }
@@ -1,6 +1,6 @@
 [package]
 name = "daemon"
-version = "3.0.0"
+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"
@@ -1,84 +1,22 @@
 use log::{error, info, warn};
 use rog_fan_curve::Curve;
-use rog_types::aura_modes::AuraModes;
+use rog_types::{aura_modes::AuraModes, gfx_vendors::GfxVendors};
 use serde_derive::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};

+use crate::config_old::*;
 use crate::VERSION;

 pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";

-/// for parsing old v2.1.2 config
-#[derive(Deserialize)]
-struct ConfigV212 {
-    gfx_managed: bool,
-    bat_charge_limit: u8,
-    active_profile: String,
-    toggle_profiles: Vec<String>,
-    power_profiles: BTreeMap<String, Profile>,
-    power_profile: u8,
-    kbd_led_brightness: u8,
-    kbd_backlight_mode: u8,
-    kbd_backlight_modes: Vec<AuraModes>,
-}
-
-impl ConfigV212 {
-    fn into_current(self) -> Config {
-        Config {
-            gfx_managed: self.gfx_managed,
-            gfx_nv_mode_is_dedicated: true,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.power_profile,
-            bat_charge_limit: self.bat_charge_limit,
-            kbd_led_brightness: self.kbd_led_brightness,
-            kbd_backlight_mode: self.kbd_backlight_mode,
-            kbd_backlight_modes: self.kbd_backlight_modes,
-            power_profiles: self.power_profiles,
-        }
-    }
-}
-
-/// for parsing old v2.2.2 config
-#[derive(Deserialize)]
-struct ConfigV222 {
-    gfx_managed: bool,
-    bat_charge_limit: u8,
-    active_profile: String,
-    toggle_profiles: Vec<String>,
-    power_profiles: BTreeMap<String, Profile>,
-    power_profile: u8,
-    kbd_led_brightness: u8,
-    kbd_backlight_mode: u8,
-    kbd_backlight_modes: Vec<AuraModes>,
-}
-
-impl ConfigV222 {
-    fn into_current(self) -> Config {
-        Config {
-            gfx_managed: self.gfx_managed,
-            gfx_nv_mode_is_dedicated: true,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.power_profile,
-            bat_charge_limit: self.bat_charge_limit,
-            kbd_led_brightness: self.kbd_led_brightness,
-            kbd_backlight_mode: self.kbd_backlight_mode,
-            kbd_backlight_modes: self.kbd_backlight_modes,
-            power_profiles: self.power_profiles,
-        }
-    }
-}
-
 #[derive(Deserialize, Serialize)]
 pub struct Config {
+    pub gfx_mode: GfxVendors,
    pub gfx_managed: bool,
-    pub gfx_nv_mode_is_dedicated: bool,
    pub active_profile: String,
    pub toggle_profiles: Vec<String>,
-    // TODO: remove power_profile
    #[serde(skip)]
    pub curr_fan_mode: u8,
    pub bat_charge_limit: u8,
@@ -96,8 +34,8 @@ impl Default for Config {
        pwr.insert("silent".into(), Profile::new(0, 100, true, 2, None));

        Config {
+            gfx_mode: GfxVendors::Hybrid,
            gfx_managed: true,
-            gfx_nv_mode_is_dedicated: true,
            active_profile: "normal".into(),
            toggle_profiles: vec!["normal".into(), "boost".into(), "silent".into()],
            curr_fan_mode: 0,
@@ -129,6 +67,11 @@ impl Config {
            } else {
                if let Ok(data) = serde_json::from_str(&buf) {
                    return data;
+                } else if let Ok(data) = serde_json::from_str::<ConfigV301>(&buf) {
+                    let config = data.into_current();
+                    config.write();
+                    info!("Updated config version to: {}", VERSION);
+                    return config;
                } else if let Ok(data) = serde_json::from_str::<ConfigV222>(&buf) {
                    let config = data.into_current();
                    config.write();
@@ -0,0 +1,100 @@
+use rog_types::{aura_modes::AuraModes, gfx_vendors::GfxVendors};
+use serde_derive::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+use crate::config::{Config, Profile};
+
+/// for parsing old v2.1.2 config
+#[derive(Deserialize)]
+pub(crate) struct ConfigV212 {
+    gfx_managed: bool,
+    bat_charge_limit: u8,
+    active_profile: String,
+    toggle_profiles: Vec<String>,
+    power_profiles: BTreeMap<String, Profile>,
+    power_profile: u8,
+    kbd_led_brightness: u8,
+    kbd_backlight_mode: u8,
+    kbd_backlight_modes: Vec<AuraModes>,
+}
+
+impl ConfigV212 {
+    pub(crate) fn into_current(self) -> Config {
+        Config {
+            gfx_mode: GfxVendors::Hybrid,
+            gfx_managed: self.gfx_managed,
+            active_profile: self.active_profile,
+            toggle_profiles: self.toggle_profiles,
+            curr_fan_mode: self.power_profile,
+            bat_charge_limit: self.bat_charge_limit,
+            kbd_led_brightness: self.kbd_led_brightness,
+            kbd_backlight_mode: self.kbd_backlight_mode,
+            kbd_backlight_modes: self.kbd_backlight_modes,
+            power_profiles: self.power_profiles,
+        }
+    }
+}
+
+/// for parsing old v2.2.2 config
+#[derive(Deserialize)]
+pub(crate) struct ConfigV222 {
+    gfx_managed: bool,
+    bat_charge_limit: u8,
+    active_profile: String,
+    toggle_profiles: Vec<String>,
+    power_profiles: BTreeMap<String, Profile>,
+    power_profile: u8,
+    kbd_led_brightness: u8,
+    kbd_backlight_mode: u8,
+    kbd_backlight_modes: Vec<AuraModes>,
+}
+
+impl ConfigV222 {
+    pub(crate) fn into_current(self) -> Config {
+        Config {
+            gfx_mode: GfxVendors::Hybrid,
+            gfx_managed: self.gfx_managed,
+            active_profile: self.active_profile,
+            toggle_profiles: self.toggle_profiles,
+            curr_fan_mode: self.power_profile,
+            bat_charge_limit: self.bat_charge_limit,
+            kbd_led_brightness: self.kbd_led_brightness,
+            kbd_backlight_mode: self.kbd_backlight_mode,
+            kbd_backlight_modes: self.kbd_backlight_modes,
+            power_profiles: self.power_profiles,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub(crate) struct ConfigV301 {
+    pub gfx_managed: bool,
+    pub gfx_nv_mode_is_dedicated: bool,
+    pub active_profile: String,
+    pub toggle_profiles: Vec<String>,
+    // TODO: remove power_profile
+    #[serde(skip)]
+    pub curr_fan_mode: u8,
+    pub bat_charge_limit: u8,
+    pub kbd_led_brightness: u8,
+    pub kbd_backlight_mode: u8,
+    pub kbd_backlight_modes: Vec<AuraModes>,
+    pub power_profiles: BTreeMap<String, Profile>,
+}
+
+impl ConfigV301 {
+    pub(crate) fn into_current(self) -> Config {
+        Config {
+            gfx_mode: GfxVendors::Hybrid,
+            gfx_managed: self.gfx_managed,
+            active_profile: self.active_profile,
+            toggle_profiles: self.toggle_profiles,
+            curr_fan_mode: self.curr_fan_mode,
+            bat_charge_limit: self.bat_charge_limit,
+            kbd_led_brightness: self.kbd_led_brightness,
+            kbd_backlight_mode: self.kbd_backlight_mode,
+            kbd_backlight_modes: self.kbd_backlight_modes,
+            power_profiles: self.power_profiles,
+        }
+    }
+}
@@ -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;
@@ -8,7 +8,7 @@ use rog_types::profile::{FanLevel, ProfileEvent};
 use serde_derive::{Deserialize, Serialize};
 use std::convert::TryInto;
 use std::fs::OpenOptions;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::Path;
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -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 {
@@ -1,17 +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),
+    DisplayManagerAction(String, ExitStatus),
+    DisplayManagerTimeout(String),
+    GsyncModeActive,
 }

 impl fmt::Display for GfxError {
@@ -19,12 +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::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"),
        }
    }
 }
@@ -2,15 +2,14 @@ use ctrl_gfx::error::GfxError;
 use ctrl_gfx::*;
 use ctrl_rog_bios::CtrlRogBios;
 use log::{error, info, warn};
-use rog_types::gfx_vendors::{GfxCtrlAction, GfxVendors};
-use std::io::Write;
+use rog_types::gfx_vendors::GfxVendors;
 use std::iter::FromIterator;
-use std::path::Path;
 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, Module, PciBus};
+use system::{GraphicsDevice, PciBus};
 use zbus::dbus_interface;

 use crate::*;
@@ -22,7 +21,6 @@ pub struct CtrlGraphics {
    nvidia: Vec<GraphicsDevice>,
    #[allow(dead_code)]
    other: Vec<GraphicsDevice>,
-    initfs_cmd: Option<Command>,
    config: Arc<Mutex<Config>>,
 }

@@ -39,7 +37,9 @@ use std::convert::TryInto;
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl Dbus for CtrlGraphics {
    fn vendor(&self) -> String {
-        Self::get_vendor().unwrap_or_else(|err| format!("Get vendor failed: {}", err))
+        self.get_gfx_mode()
+            .map(|gfx| gfx.into())
+            .unwrap_or_else(|err| format!("Get vendor failed: {}", err))
    }

    fn power(&self) -> String {
@@ -48,13 +48,14 @@ impl Dbus for CtrlGraphics {

    fn set_vendor(&mut self, vendor: String) {
        if let Ok(tmp) = GfxVendors::from_str(&vendor) {
-            let action = self.set(tmp).unwrap_or_else(|err| {
-                warn!("{}", err);
+            info!("Switching gfx mode to {}", vendor);
+            let msg = self.set_gfx_config(tmp).unwrap_or_else(|err| {
+                error!("{}", err);
                format!("Failed: {}", err.to_string())
            });
            self.notify_gfx(&vendor)
                .unwrap_or_else(|err| warn!("{}", err));
-            self.notify_action(&action)
+            self.notify_action(&msg)
                .unwrap_or_else(|err| warn!("{}", err));
        }
    }
@@ -86,7 +87,7 @@ impl ZbusAdd for CtrlGraphics {
 impl Reloadable for CtrlGraphics {
    fn reload(&mut self) -> Result<(), RogError> {
        self.auto_power()?;
-        info!("Reloaded gfx mode: {:?}", CtrlGraphics::get_vendor()?);
+        info!("Reloaded gfx mode: {:?}", self.get_gfx_mode()?);
        Ok(())
    }
 }
@@ -143,161 +144,42 @@ impl CtrlGraphics {
            }
        }

-        let mut initfs_cmd = None;
-
-        if Path::new(INITRAMFS_PATH).exists() {
-            let mut cmd = Command::new("update-initramfs");
-            cmd.arg("-u");
-            initfs_cmd = Some(cmd);
-            info!("Using initramfs update command 'update-initramfs'");
-        } else if Path::new(DRACUT_PATH).exists() {
-            let mut cmd = Command::new("dracut");
-            cmd.arg("-f");
-            initfs_cmd = Some(cmd);
-            info!("Using initramfs update command 'dracut'");
-        }
-
        Ok(CtrlGraphics {
            bus,
            _amd: amd,
            _intel: intel,
            nvidia,
            other,
-            initfs_cmd,
            config,
        })
    }

-    fn get_prime_discrete() -> Result<String, RogError> {
-        let s = std::fs::read_to_string(PRIME_DISCRETE_PATH)
-            .map_err(|err| GfxError::Read(PRIME_DISCRETE_PATH.into(), err))?
-            .trim()
-            .to_owned();
-        Ok(s)
-    }
-
-    fn set_prime_discrete(mode: &str) -> Result<(), RogError> {
-        std::fs::write(PRIME_DISCRETE_PATH, mode)
-            .map_err(|err| GfxError::Read(PRIME_DISCRETE_PATH.into(), err))?;
+    fn save_gfx_mode(&self, vendor: GfxVendors) -> Result<(), RogError> {
+        if let Ok(mut config) = self.config.lock() {
+            config.gfx_mode = vendor.clone();
+            config.write();
+            return Ok(());
+        }
+        // TODO: Error here
        Ok(())
    }

    /// Associated method to get which vendor mode is set
-    pub fn get_vendor() -> Result<String, RogError> {
-        let mode = match Self::get_prime_discrete() {
-            Ok(m) => m,
-            Err(_) => "nvidia".to_string(),
-        };
-        let modules = Module::all().map_err(|err| GfxError::Read("get_vendor".into(), err))?;
-
-        let driver_loaded = modules
-            .iter()
-            .any(|module| module.name == "nouveau" || module.name == "nvidia");
-
-        let vendor = if mode == "off" {
-            if driver_loaded {
-                info!("dGPU driver loaded for compute mode");
-                "compute".to_string()
-            } else {
-                info!("No dGPU driver loaded");
-                "integrated".to_string()
-            }
-        } else {
-            info!("Assuming dGPU driver loaded");
-            if mode == "on-demand" {
-                "hybrid".to_string()
-            } else {
-                "nvidia".to_string()
-            }
-        };
-
-        Ok(vendor)
+    pub fn get_gfx_mode(&self) -> Result<GfxVendors, RogError> {
+        if let Ok(config) = self.config.lock() {
+            return Ok(config.gfx_mode.clone());
+        }
+        // TODO: Error here
+        Ok(GfxVendors::Hybrid)
    }

-    fn is_switching_prime_modes(&self, vendor: &GfxVendors) -> Result<bool, RogError> {
-        let prev_mode = GfxVendors::from_str(&Self::get_vendor()?)?;
-        if prev_mode == GfxVendors::Integrated
-            && (*vendor == GfxVendors::Hybrid || *vendor == GfxVendors::Nvidia)
-        {
-            return Ok(true);
-        }
-        if (prev_mode == GfxVendors::Hybrid || prev_mode == GfxVendors::Nvidia)
-            && *vendor == GfxVendors::Integrated
-        {
-            return Ok(true);
-        }
-        if let Ok(config) = self.config.clone().try_lock() {
-            if CtrlRogBios::has_dedicated_gfx_toggle() && config.gfx_nv_mode_is_dedicated {
-                if prev_mode == GfxVendors::Hybrid && *vendor == GfxVendors::Nvidia {
-                    return Ok(true);
-                }
-                if *vendor == GfxVendors::Hybrid && prev_mode == GfxVendors::Nvidia {
-                    return Ok(true);
-                }
-            }
-        }
-        Ok(false)
+    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| RogError::Read(PATH.into(), err))?;
+        Ok(buf)
    }

-    pub fn set_gfx_config(vendor: GfxVendors) -> Result<(), RogError> {
-        let mode = if vendor == GfxVendors::Hybrid {
-            "on-demand\n"
-        } else if vendor == GfxVendors::Nvidia {
-            "on\n"
-        } else {
-            // Integrated or Compute
-            "off\n"
-        };
-
-        info!("Setting {} to {}", PRIME_DISCRETE_PATH, mode);
-        Self::set_prime_discrete(mode)?;
-
-        {
-            info!("Writing {}", MODPROBE_PATH);
-
-            let mut file = std::fs::OpenOptions::new()
-                .create(true)
-                .truncate(true)
-                .write(true)
-                .open(MODPROBE_PATH)
-                .map_err(|err| GfxError::Path(MODPROBE_PATH.into(), err))?;
-
-            let text = if vendor == GfxVendors::Hybrid {
-                MODPROBE_HYBRID
-            } else if vendor == GfxVendors::Compute {
-                MODPROBE_COMPUTE
-            } else if vendor == GfxVendors::Nvidia {
-                MODPROBE_NVIDIA
-            } else {
-                MODPROBE_INTEGRATED
-            };
-
-            file.write_all(text)
-                .and_then(|_| file.sync_all())
-                .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
-        }
-
-        info!("Writing {}", PRIMARY_GPU_XORG_PATH);
-
-        // begin section for non-separated Nvidia xorg modules
-        // eg, not put in their own directory
-        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))?;
-
-        let text = if vendor == GfxVendors::Nvidia {
-            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_NVIDIA, PRIMARY_GPU_END].concat()
-        } else {
-            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_END].concat()
-        };
-
-        file.write_all(&text)
-            .and_then(|_| file.sync_all())
-            .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
-
+    fn toggle_fallback_service(vendor: GfxVendors) -> Result<(), RogError> {
        let action = if vendor == GfxVendors::Nvidia {
            info!("Enabling nvidia-fallback.service");
            "enable"
@@ -310,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
@@ -319,92 +201,269 @@ impl CtrlGraphics {
                status
            );
        }
+
        Ok(())
    }

-    /// Write out config files if required, enable/disable relevant services, and update the ramdisk
-    fn set(&mut self, vendor: GfxVendors) -> Result<String, RogError> {
-        // Switching from hybrid to/from nvidia shouldn't require a ramdisk update
-        // or a reboot.
-        let reboot = self.is_switching_prime_modes(&vendor)?;
-
-        if CtrlRogBios::has_dedicated_gfx_toggle() {
-            if let Ok(config) = self.config.clone().try_lock() {
-                // Switch to dedicated if config says to do so
-                if config.gfx_nv_mode_is_dedicated && vendor == GfxVendors::Nvidia {
-                    CtrlRogBios::set_gfx_mode(true)
-                        .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
-                } else if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
-                    // otherwise if switching to non-Nvidia mode turn off dedicated mode
-                    if ded == 1 && vendor != GfxVendors::Nvidia {
-                        CtrlRogBios::set_gfx_mode(false)
-                            .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
-                    }
-                }
-            }
-        }
-
-        Self::set_gfx_config(vendor.clone())?;
-
-        let mut required_action = GfxCtrlAction::None;
-        if reboot {
-            info!("Updating initramfs");
-            if let Some(cmd) = self.initfs_cmd.as_mut() {
-                // If switching to Nvidia dedicated we need these modules included
-                if Path::new(DRACUT_PATH).exists() && vendor == GfxVendors::Nvidia {
-                    cmd.arg("--add-drivers");
-                    cmd.arg("nvidia nvidia-drm nvidia-modeset nvidia-uvm");
-                    info!("System uses dracut, forcing nvidia modules to be included in init");
-                }
-
-                let status = cmd
-                    .status()
-                    .map_err(|err| GfxError::Write(format!("{:?}", cmd), err))?;
-                if !status.success() {
-                    error!("Ram disk update failed");
-                    return Ok("Ram disk update failed".into());
-                } else {
-                    info!("Successfully updated iniramfs");
-                }
-            }
-            required_action = GfxCtrlAction::Reboot;
-        } else if !reboot {
-            required_action = GfxCtrlAction::RestartX;
-        }
-
-        Ok(required_action.into())
-    }
-
-    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))?;
-        Ok(buf)
-    }
-
-    fn set_power(&self, power: bool) -> Result<(), RogError> {
-        if power {
-            info!("Enabling graphics power");
-            self.bus
-                .rescan()
-                .map_err(|err| GfxError::Bus("bus rescan error".into(), err))?;
+    fn write_xorg_conf(vendor: GfxVendors) -> Result<(), RogError> {
+        let text = if vendor == GfxVendors::Nvidia {
+            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_NVIDIA, PRIMARY_GPU_END].concat()
        } else {
-            info!("Disabling graphics power");
+            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_END].concat()
+        };

-            // Unbind NVIDIA graphics devices and their functions
-            let unbinds = self.nvidia.iter().map(|dev| dev.unbind());
-
-            // Remove NVIDIA graphics devices and their functions
-            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))?;
+        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(&file)
+            .map_err(|err| RogError::Write(file, err))?;
+
+        file.write_all(&text)
+            .and_then(|_| file.sync_all())
+            .map_err(|err| RogError::Write(MODPROBE_PATH.into(), err))?;
+        Ok(())
+    }
+
+    fn write_modprobe_conf() -> Result<(), RogError> {
+        info!("Writing {}", MODPROBE_PATH);
+
+        let mut file = std::fs::OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .open(MODPROBE_PATH)
+            .map_err(|err| RogError::Path(MODPROBE_PATH.into(), err))?;
+
+        file.write_all(MODPROBE_BASE)
+            .and_then(|_| file.sync_all())
+            .map_err(|err| RogError::Write(MODPROBE_PATH.into(), err))?;
+
        Ok(())
    }

-    fn auto_power(&self) -> Result<(), RogError> {
-        let vendor = CtrlGraphics::get_vendor()?;
-        self.set_power(vendor != "integrated")
+    fn unbind_remove_nvidia(&self) -> Result<(), RogError> {
+        // Unbind NVIDIA graphics devices and their functions
+        let unbinds = self.nvidia.iter().map(|dev| dev.unbind());
+
+        // Remove NVIDIA graphics devices and their functions
+        let removes = self.nvidia.iter().map(|dev| dev.remove());
+
+        Result::from_iter(unbinds.chain(removes))
+            .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 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));
+        }
+    }
+
+    fn do_display_manager_action(action: &str) -> Result<(), RogError> {
+        let mut cmd = Command::new("systemctl");
+        cmd.arg(action);
+        cmd.arg(DISPLAY_MANAGER);
+
+        let status = cmd
+            .status()
+            .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+        if !status.success() {
+            let msg = format!(
+                "systemctl {} {} failed: {:?}",
+                action, DISPLAY_MANAGER, status
+            );
+            return Err(GfxError::DisplayManagerAction(msg, status).into());
+        }
+        Ok(())
+    }
+
+    fn wait_display_manager_state(state: &str) -> Result<(), RogError> {
+        let mut cmd = Command::new("systemctl");
+        cmd.arg("is-active");
+        cmd.arg(DISPLAY_MANAGER);
+
+        let mut count = 0;
+
+        while count <= 5 {
+            let output = cmd
+                .output()
+                .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::DisplayManagerTimeout(state.into()).into());
+    }
+
+    pub fn do_vendor_tasks(&mut self, vendor: GfxVendors) -> Result<(), RogError> {
+        Self::write_xorg_conf(vendor)?;
+        Self::write_modprobe_conf()?; // TODO: Not required here, should put in startup?
+
+        // Rescan before doing remove or add drivers
+        self.bus
+            .rescan()
+            .map_err(|err| GfxError::Bus("bus rescan error".into(), err))?;
+
+        match vendor {
+            GfxVendors::Nvidia | GfxVendors::Hybrid | GfxVendors::Compute => {
+                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 NVIDIA_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "rmmod")?;
+                }
+                self.unbind_remove_nvidia()?;
+            }
+        }
+
+        self.save_gfx_mode(vendor)?;
+        Ok(())
+    }
+
+    /// For manually calling (not on boot/startup)
+    ///
+    /// 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")?;
+        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))
+    }
+
+    // if CtrlRogBios::has_dedicated_gfx_toggle() {
+    //     if let Ok(config) = self.config.clone().try_lock() {
+    //         // Switch to dedicated if config says to do so
+    //         if config.gfx_nv_mode_is_dedicated && vendor == GfxVendors::Nvidia {
+    //             CtrlRogBios::set_gfx_mode(true)
+    //                 .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
+    //         } else if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
+    //             // otherwise if switching to non-Nvidia mode turn off dedicated mode
+    //             if ded == 1 && vendor != GfxVendors::Nvidia {
+    //                 CtrlRogBios::set_gfx_mode(false)
+    //                     .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
+    //             }
+    //         }
+    //     }
+    // }
+
+    fn auto_power(&mut self) -> Result<(), RogError> {
+        let vendor = self.get_gfx_mode()?;
+        self.do_vendor_tasks(vendor)?;
+        Self::toggle_fallback_service(vendor)?;
+        Ok(())
    }
 }
@@ -4,41 +4,25 @@ pub mod gfx;

 pub mod system;

-const PRIME_DISCRETE_PATH: &str = "/etc/prime-discrete";
+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";
-const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
-const DRACUT_PATH: &str = "/usr/bin/dracut";

-static MODPROBE_NVIDIA: &[u8] = MODPROBE_HYBRID;
-
-static MODPROBE_HYBRID: &[u8] = br#"# Automatically generated by asusd
-blacklist i2c_nvidia_gpu
-alias i2c_nvidia_gpu off
+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
+alias nouveau off
 options nvidia NVreg_DynamicPowerManagement=0x02
 options nvidia-drm modeset=1
 "#;

-static MODPROBE_COMPUTE: &[u8] = br#"# Automatically generated by asusd
-blacklist i2c_nvidia_gpu
-alias i2c_nvidia_gpu off
-options nvidia NVreg_DynamicPowerManagement=0x02
-options nvidia-drm modeset=0
-"#;
-
-static MODPROBE_INTEGRATED: &[u8] = br#"# Automatically generated by asusd
-blacklist i2c_nvidia_gpu
-blacklist nouveau
-blacklist nvidia
-blacklist nvidia-drm
-blacklist nvidia-modeset
-alias i2c_nvidia_gpu off
-alias nouveau off
-alias nvidia off
-alias nvidia-drm off
-alias nvidia-modeset off
-"#;
-
-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"
@@ -50,6 +50,7 @@ impl PciBus {
        }
    }

+    /// Will rescan the device tree, which adds all removed devices back
    pub fn rescan(&self) -> io::Result<()> {
        write(self.path.join("rescan"), "1")
    }
@@ -95,6 +96,32 @@ impl GraphicsDevice {
        Ok(())
    }

+    pub fn rebind(&self) -> Result<(), std::io::Error> {
+        for func in self.functions.iter() {
+            if func.path().exists() {
+                match func.driver() {
+                    Ok(driver) => {
+                        info!("{}: Binding {}", driver.id(), func.id());
+                        unsafe {
+                            driver.bind(&func).map_err(|err| {
+                                error!("gfx bind: {}", err);
+                                err
+                            })?;
+                        }
+                    }
+                    Err(err) => match err.kind() {
+                        io::ErrorKind::NotFound => (),
+                        _ => {
+                            error!("gfx driver: {:?}, {}", func.path(), err);
+                            return Err(err);
+                        }
+                    },
+                }
+            }
+        }
+        Ok(())
+    }
+
    pub fn remove(&self) -> Result<(), std::io::Error> {
        for func in self.functions.iter() {
            if func.path().exists() {
@@ -1,16 +1,18 @@
-use crate::{config::Config, ctrl_gfx::gfx::CtrlGraphics, error::RogError, GetSupported};
-//use crate::dbus::DbusEvents;
-use log::{info, warn};
-use rog_types::gfx_vendors::GfxVendors;
+use crate::{config::Config, error::RogError, GetSupported};
+use log::{error, info, warn};
 use serde_derive::{Deserialize, Serialize};
-use std::convert::TryInto;
 use std::fs::OpenOptions;
 use std::io::{Read, Write};
 use std::path::Path;
+use std::process::Command;
 use std::sync::Arc;
 use std::sync::Mutex;
+use std::{convert::TryInto, io::BufRead};
 use zbus::dbus_interface;

+const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
+const DRACUT_PATH: &str = "/usr/bin/dracut";
+
 static ASUS_SWITCH_GRAPHIC_MODE: &str =
    "/sys/firmware/efi/efivars/AsusSwitchGraphicMode-607005d5-3f75-4b2e-98f0-85ba66797a3e";
 static ASUS_POST_LOGO_SOUND: &str =
@@ -40,7 +42,7 @@ impl GetSupported for CtrlRogBios {
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlRogBios {
    pub fn set_dedicated_graphic_mode(&mut self, dedicated: bool) {
-        Self::set_gfx_mode(dedicated)
+        self.set_gfx_mode(dedicated)
            .map_err(|err| {
                warn!("CtrlRogBios: set_asus_switch_graphic_mode {}", err);
                err
@@ -138,8 +140,6 @@ impl CtrlRogBios {
    }

    fn set_path_mutable(path: &str) -> Result<(), RogError> {
-        use std::process::Command;
-
        let output = Command::new("/usr/bin/chattr")
            .arg("-i")
            .arg(path)
@@ -179,7 +179,7 @@ impl CtrlRogBios {
        Ok(data[idx] as i8)
    }

-    pub(super) fn set_gfx_mode(dedicated: bool) -> Result<(), RogError> {
+    pub(super) fn set_gfx_mode(&self, dedicated: bool) -> Result<(), RogError> {
        let path = ASUS_SWITCH_GRAPHIC_MODE;
        let mut file = OpenOptions::new()
            .read(true)
@@ -201,15 +201,17 @@ impl CtrlRogBios {
        file.write_all(&data)
            .map_err(|err| RogError::Path(path.into(), err))?;

-        if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
-            if let Ok(vendor) = CtrlGraphics::get_vendor() {
-                if ded == 1 && vendor != "nvidia" {
-                    warn!("Dedicated GFX toggle is on but driver mode is not nvidia \nSetting to nvidia driver mode");
-                    CtrlGraphics::set_gfx_config(GfxVendors::Nvidia)
-                        .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
-                }
-            }
-        }
+        self.update_initramfs(dedicated)?;
+
+        // if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
+        //     if let Ok(vendor) = CtrlGraphics::get_vendor() {
+        //         if ded == 1 && vendor != "nvidia" {
+        //             warn!("Dedicated GFX toggle is on but driver mode is not nvidia \nSetting to nvidia driver mode");
+        //             CtrlGraphics::set_gfx_config(&GfxVendors::Nvidia)
+        //                 .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
+        //         }
+        //     }
+        // }

        Ok(())
    }
@@ -254,4 +256,89 @@ impl CtrlRogBios {

        Ok(())
    }
+
+    // required for g-sync mode
+    fn update_initramfs(&self, dedicated: bool) -> Result<(), RogError> {
+        let mut initfs_cmd = None;
+
+        if Path::new(INITRAMFS_PATH).exists() {
+            let mut cmd = Command::new("update-initramfs");
+            cmd.arg("-u");
+            initfs_cmd = Some(cmd);
+            info!("Using initramfs update command 'update-initramfs'");
+        } 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'");
+        }
+
+        if let Some(mut cmd) = initfs_cmd {
+            info!("Updating initramfs");
+
+            // If switching to Nvidia dedicated we need these modules included
+            if Path::new(DRACUT_PATH).exists() && dedicated {
+                cmd.arg("--add-drivers");
+                cmd.arg("nvidia nvidia-drm nvidia-modeset nvidia-uvm");
+                info!("System uses dracut, forcing nvidia modules to be included in init");
+            } else if Path::new(INITRAMFS_PATH).exists() {
+                let modules = vec![
+                    "nvidia\n",
+                    "nvidia-drm\n",
+                    "nvidia-modeset\n",
+                    "nvidia-uvm\n",
+                ];
+
+                let module_include = Path::new("/etc/initramfs-tools/modules");
+
+                if dedicated {
+                    let mut file = std::fs::OpenOptions::new()
+                        .append(true)
+                        .open(module_include)
+                        .map_err(|err| {
+                            RogError::Write(module_include.to_string_lossy().to_string(), err)
+                        })?;
+                    // add nvidia modules to module_include
+                    file.write_all(modules.concat().as_bytes()).unwrap();
+                } else {
+                    let file = std::fs::OpenOptions::new()
+                        .read(true)
+                        .open(module_include)
+                        .map_err(|err| {
+                            RogError::Write(module_include.to_string_lossy().to_string(), err)
+                        })?;
+
+                    let mut buf = Vec::new();
+                    // remove modules
+                    for line in std::io::BufReader::new(file).lines() {
+                        if let Ok(l) = line {
+                            if !modules.contains(&l.as_ref()) {
+                                buf.append(&mut l.as_bytes().to_vec());
+                            }
+                        }
+                    }
+
+                    let file = std::fs::OpenOptions::new()
+                        .write(true)
+                        .open(module_include)
+                        .map_err(|err| {
+                            RogError::Write(module_include.to_string_lossy().to_string(), err)
+                        })?;
+                    std::io::BufWriter::new(file).write_all(&buf).unwrap();
+                }
+            }
+
+            let status = cmd
+                .status()
+                .map_err(|err| RogError::Write(format!("{:?}", cmd), err))?;
+            if !status.success() {
+                error!("Ram disk update failed");
+                return Err(RogError::Initramfs("Ram disk update failed".into()).into());
+            } else {
+                info!("Successfully updated initramfs");
+            }
+        }
+        Ok(())
+    }
 }
@@ -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")]
@@ -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(())
@@ -109,11 +109,10 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                // Need to check if a laptop has the dedicated gfx switch
                if CtrlRogBios::has_dedicated_gfx_toggle() {
                    if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
-                        if let Ok(vendor) = CtrlGraphics::get_vendor() {
-                            if ded == 1 && vendor != "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");
-                                CtrlGraphics::set_gfx_config(GfxVendors::Nvidia)?;
+                        if let Ok(vendor) = ctrl.get_gfx_mode() {
+                            if ded == 1 && vendor != GfxVendors::Nvidia {
+                                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) => {
@@ -25,6 +25,9 @@ pub enum RogError {
    MissingLedBrightNode(String, std::io::Error),
    ReloadFail(String),
    GfxSwitching(GfxError),
+    Initramfs(String),
+    Modprobe(String),
+    Command(String, std::io::Error),
 }

 impl fmt::Display for RogError {
@@ -48,6 +51,9 @@ impl fmt::Display for RogError {
            RogError::MissingLedBrightNode(path, error) => write!(f, "Led node at {} is missing, please check you have the required patch or dkms module installed: {}", path, error),
            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),
        }
    }
 }
@@ -8,7 +8,7 @@ pub static LEDMODE_CONFIG_PATH: &str = "/etc/asusd/asusd-ledmodes.toml";

 pub static HELP_ADDRESS: &str = "https://gitlab.com/asus-linux/asus-nb-ctrl";

-static LAPTOP_DEVICES: [u16; 3] = [0x1866, 0x1869, 0x1854];
+static LAPTOP_DEVICES: [u16; 4] = [0x1866, 0x1869, 0x1854, 0x19b6];

 #[derive(Debug)]
 pub struct LaptopBase {
@@ -1,6 +1,7 @@
 #![deny(unused_must_use)]
 /// Configuration loading, saving
 pub mod config;
+pub(crate) mod config_old;
 /// Control of AniMe matrix display
 pub mod ctrl_anime;
 /// Control of battery charge level
@@ -1,17 +1,22 @@
 [[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"
+board_names = ["GU502LU"]
+led_modes = [0, 1, 2, 10]

 [[led_modes]]
 prod_family = "Zephyrus"
@@ -21,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"
@@ -30,7 +35,7 @@ led_modes = [0, 1, 2, 3, 10, 13, 14]

 [[led_modes]]
 prod_family = "ROG Strix"
-board_names = ["G512LI", "G712LI"]
+board_names = ["G512LI", "G712LI", "G531GD"]
 led_modes = [0, 1, 2, 3, 10]

 [[led_modes]]
@@ -10,6 +10,10 @@
        <allow send_destination="org.asuslinux.Daemon"/>
        <allow receive_sender="org.asuslinux.Daemon"/>
    </policy>
+    <policy group="users">
+        <allow send_destination="org.asuslinux.Daemon"/>
+        <allow receive_sender="org.asuslinux.Daemon"/>
+    </policy>
    <policy group="wheel">
        <allow send_destination="org.asuslinux.Daemon"/>
        <allow receive_sender="org.asuslinux.Daemon"/>
@@ -1,2 +1,2 @@
-ACTION=="add|change", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="18[0-9][0-9]|193b", ENV{ID_TYPE}=="hid", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
-ACTION=="add|remove", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="18[0-9][0-9]|193b", RUN+="systemctl restart asusd.service"
+ACTION=="add|change", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", ENV{ID_TYPE}=="hid", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
+ACTION=="add|remove", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", RUN+="systemctl restart asusd.service"
@@ -2,6 +2,7 @@
 Description=ASUS Notebook Control
 StartLimitInterval=200
 StartLimitBurst=2
+Before=display-manager.service

 [Service]
 ExecStart=/usr/bin/asusd
@@ -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 {
@@ -1,4 +1,6 @@
-#[derive(Debug, PartialEq, Clone)]
+use serde_derive::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Copy, Clone, Deserialize, Serialize)]
 pub enum GfxVendors {
    Nvidia,
    Integrated,
@@ -28,9 +30,9 @@ impl FromStr for GfxVendors {
    }
 }

-impl From<&GfxVendors> for &str {
-    fn from(mode: &GfxVendors) -> Self {
-        match mode {
+impl Into<&str> for GfxVendors {
+    fn into(self) -> &'static str {
+        match self {
            GfxVendors::Nvidia => "nvidia",
            GfxVendors::Hybrid => "hybrid",
            GfxVendors::Compute => "compute",
@@ -39,6 +41,17 @@ impl From<&GfxVendors> for &str {
    }
 }

+impl Into<String> for GfxVendors {
+    fn into(self) -> String {
+        match self {
+            GfxVendors::Nvidia => "nvidia".to_string(),
+            GfxVendors::Hybrid => "hybrid".to_string(),
+            GfxVendors::Compute => "compute".to_string(),
+            GfxVendors::Integrated => "integrated".to_string(),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum GfxCtrlAction {
    Reboot,
@@ -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>,
Author	SHA1	Message	Date
Luke D Jones	89f4dd6ec4	Prep release	2021-03-11 12:32:34 +13:00
Luke Jones	85e0b79fb9	Merge branch 'fluke/testing-gfx-switch' into 'main' More verbose and thorough checks for gfx switching See merge request asus-linux/asus-nb-ctrl!30	2021-03-10 23:28:02 +00:00
Luke D Jones	fba5f26f7e	More verbose and thorough checks for gfx switching - Small fixes - Cleanup bios help - g-sync warnings on toggling	2021-03-11 12:24:01 +13:00
Luke D Jones	90b0fc434d	Hotfix: graphics help display	2021-03-10 21:23:35 +13:00
Luke D Jones	6743d5bc78	Add display-manager restart check	2021-03-10 18:42:44 +13:00
Luke D Jones	def0259d24	Bump version	2021-03-10 16:47:22 +13:00
Luke D Jones	a678f54f59	:sadface:	2021-03-10 16:45:06 +13:00
Luke D Jones	ebe7e61355	Slightly change how module load error is reported	2021-03-10 16:30:42 +13:00
Luke D Jones	bda58c9695	Trial of logging for gfx switch	2021-03-10 16:21:53 +13:00
Luke D Jones	e335133bf8	refactor help again	2021-03-10 16:17:22 +13:00
Luke D Jones	47432524e1	Further improve CLI feedback	2021-03-10 16:01:04 +13:00
Luke D Jones	707b3bcc2d	Notify on manually select profile	2021-03-10 15:24:24 +13:00
Luke D Jones	60014b8a40	Customise initial help for laptop	2021-03-10 14:43:48 +13:00
Luke D Jones	2e4ce27f6b	Hotfix: try to handle module remove gracefully Try to handle module remove more gracefully if in-use when the display manager is shutting down	2021-03-10 14:07:08 +13:00
Luke D Jones	b8384c55c3	Bump changelog version	2021-03-10 11:21:09 +13:00
Luke D Jones	dfe1f02101	Hotfix: Catch some edge-cases exposed on fedora 34	2021-03-10 11:20:19 +13:00
Luke D Jones	7c2fb0be81	Hotfix: Nvidia module handling improved	2021-03-10 10:15:59 +13:00
Luke D Jones	b05f680650	Test and create /etc/X11/xorg.conf.d/ if not exist	2021-03-10 09:20:59 +13:00
Luke D Jones	2a9a436f9c	Add nvidia-uvm to module list	2021-03-10 07:34:03 +13:00
Luke D Jones	0d6faf3fda	Mark as new release	2021-03-09 17:23:19 +13:00
Luke Jones	aede000218	Merge branch 'fluke/rebootless-gfx-switch' into 'main' Fluke/rebootless gfx switch See merge request asus-linux/asus-nb-ctrl!29	2021-03-09 04:20:29 +00:00
Luke D Jones	176ab0a639	Rebootless graphics switching This changes out how the current graphics switching works, enabling asusd to stop/start the display-manager to enable/disable PCI devices and add/remove drivers as required. All existing graphics modes and commands still work as normal. G-Sync enable is now only through the bios setting, and on reboot will set all relevant settings to Nvidia mode.	2021-03-09 16:45:43 +13:00
Luke D Jones	4efb2caa56	GU502LU led-modes	2021-03-07 21:48:44 +13:00
Luke D Jones	6f81f86483	Version bump	2021-02-22 11:48:08 +13:00
Luke D Jones	b64b8a38e4	cargo update, update udev rules	2021-02-22 11:34:47 +13:00
Luke Jones	ff56170ac5	Merge branch 'main' into 'main' added G531GD stock_led_modes See merge request asus-linux/asus-nb-ctrl!28	2021-02-21 08:47:51 +00:00
alenpaul2001	733f1f827e	added G531GD stock_led_modes	2021-02-21 13:00:04 +05:30
Luke Jones	ac903a05da	Merge branch 'donate-button' into 'main' Test donate button See merge request asus-linux/asus-nb-ctrl!27	2021-02-19 21:39:49 +00:00
Luke D Jones	838e6f789b	Test donate button	2021-02-20 10:36:28 +13:00
Luke D Jones	d462393e8b	Add 'users' group to dbus config	2021-02-20 10:15:38 +13:00
Luke D Jones	e98cf8d50b	Add 0x19b6 to supported keyb list	2021-02-19 19:32:14 +13:00