Prep v3.2.1

Fluke/led work

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

.gitlab-ci.yml

@@ -13,7 +13,7 @@ test:
 
 build:
   only:
-    - next
+    - main
   script:
     - make && make vendor
   artifacts:

CHANGELOG.md

@@ -6,6 +6,91 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+# [3.2.1] - 2021-03-21
+### Changed
+- Fix brightness control
+- Large cleanup of code relating to LED controls
+
+# [3.2.0] - 2021-03-21
+### Changed
+- Refactor keyboard LED handling
+- Added --list for profiles (Thanks @aqez)
+- Added --remove for profiles (Thanks @aqez)
+- Added a graphics mode: vfio. This attaches Nvidia devices to vfio module.
+### Broken
+- Per-key LED modes, which need thinking about how to go ahead with for future
+
+# [3.1.7] - 2021-03-11
+### Changed
+- Refactor many parts of daemon
+- Switch out session monitoring to logind-zbus
+
+# [3.1.6] - 2021-03-11
+### Changed
+- Graphics switching will now wait until all users logged out before switching
+
+### 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
+- Write set+apply after each array in multizone
+- Remove misc bad logic
+- Use same code path as 0x1866 device to configure led support for 0x1854 device
+- Remove duplicate code
+- Set correct speeds for multizone
+- Remove dbus crate in favour of zbus. This removes the external dbus lib requirement.
+- Huge internal refactor
+- BREAKING CHANGE: Anime code refactor. DBUS method names have changed
+- Cleanup fan and cpu control + configs
+
+# [2.2.2] - 2021-01-31
+### Changed
+- Fix for dedicated gfx capable laptops in integrated mode
+- Fix for 0x1854 device
+
 # [2.2.1] - 2021-01-27
 ### Added
 - Add ROG Zephyrus M15 LED config

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["asus-notify", "asus-nb-ctrl", "asus-nb"]
+members = ["asusctl", "asus-notify", "daemon", "rog-types", "rog-dbus"]
 
 [profile.release]
 lto = true

Makefile

@@ -1,4 +1,4 @@
-VERSION := $(shell grep -Pm1 'version = "(\d.\d.\d)"' asus-nb-ctrl/Cargo.toml | cut -d'"' -f2)
+VERSION := $(shell grep -Pm1 'version = "(\d.\d.\d)"' daemon/Cargo.toml | cut -d'"' -f2)
 
 INSTALL = install
 INSTALL_PROGRAM = ${INSTALL} -D -m 0755
@@ -54,6 +54,7 @@ install:
 	$(INSTALL_DATA) "./data/icons/asus_notif_green.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_red.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
 	$(INSTALL_DATA) "./data/_asusctl" "$(DESTDIR)$(zshcpl)/_asusctl"
+	$(INSTALL_DATA) "./data/completions/asusctl.fish" "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
 
 uninstall:
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_C)"
@@ -70,6 +71,7 @@ uninstall:
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
 	rm -f "$(DESTDIR)$(zshcpl)/_asusctl"
+	rm -f "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
 
 update:
 	cargo update

README.md

@@ -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.
 
@@ -144,9 +146,9 @@ To switch Fan/Thermal profiles you need to bind the Fn+F5 key to `asusctl profil
 
 Requirements are rust >= 1.40 installed from rustup.io if the distro provided version is too old, and `make`.
 
-**Ubuntu*:** `apt install libdbus-1-dev libclang-dev libudev-dev`
+**Ubuntu*:** `apt install libclang-dev libudev-dev`
 
-**fedora:** `dnf install clang-devel dbus-devel systemd-devel`
+**fedora:** `dnf install clang-devel systemd-devel`
 
 ## Installing
 

asus-nb-ctrl/src/ctrl_gfx/gfx.rs

@@ -1,415 +0,0 @@
-use ctrl_gfx::error::GfxError;
-use ctrl_gfx::*;
-use ctrl_rog_bios::CtrlRogBios;
-use log::{error, info, warn};
-use std::io::Write;
-use std::iter::FromIterator;
-use std::path::Path;
-use std::process::Command;
-use std::str::FromStr;
-use std::{sync::Arc, sync::Mutex};
-use sysfs_class::{PciDevice, SysClass};
-use system::{GraphicsDevice, Module, PciBus};
-use vendors::{GfxCtrlAction, GfxVendors};
-use zbus::dbus_interface;
-
-use crate::*;
-
-pub struct CtrlGraphics {
-    bus: PciBus,
-    _amd: Vec<GraphicsDevice>,
-    _intel: Vec<GraphicsDevice>,
-    nvidia: Vec<GraphicsDevice>,
-    #[allow(dead_code)]
-    other: Vec<GraphicsDevice>,
-    initfs_cmd: Option<Command>,
-    config: Arc<Mutex<Config>>,
-}
-
-trait Dbus {
-    fn vendor(&self) -> String;
-    fn power(&self) -> String;
-    fn set_vendor(&mut self, vendor: String);
-    fn notify_gfx(&self, vendor: &str) -> zbus::Result<()>;
-    fn notify_action(&self, action: &str) -> zbus::Result<()>;
-}
-
-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))
-    }
-
-    fn power(&self) -> String {
-        Self::get_runtime_status().unwrap_or_else(|err| format!("Get power status failed: {}", err))
-    }
-
-    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);
-                format!("Failed: {}", err.to_string())
-            });
-            self.notify_gfx(&vendor)
-                .unwrap_or_else(|err| warn!("{}", err));
-            self.notify_action(&action)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_gfx(&self, vendor: &str) -> zbus::Result<()> {}
-
-    #[dbus_interface(signal)]
-    fn notify_action(&self, action: &str) -> zbus::Result<()> {}
-}
-
-impl ZbusAdd for CtrlGraphics {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &"/org/asuslinux/Gfx"
-                    .try_into()
-                    .expect("Couldn't add to zbus"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlGraphics: add_to_server {}", err);
-                err
-            })
-            .ok();
-    }
-}
-
-impl Reloadable for CtrlGraphics {
-    fn reload(&mut self) -> Result<(), RogError> {
-        self.auto_power()?;
-        info!("Reloaded gfx mode: {:?}", CtrlGraphics::get_vendor()?);
-        Ok(())
-    }
-}
-
-impl CtrlGraphics {
-    pub fn new(config: Arc<Mutex<Config>>) -> std::io::Result<CtrlGraphics> {
-        let bus = PciBus::new()?;
-
-        info!("Rescanning PCI bus");
-        bus.rescan()?;
-
-        let devs = PciDevice::all()?;
-
-        let functions = |parent: &PciDevice| -> Vec<PciDevice> {
-            let mut functions = Vec::new();
-            if let Some(parent_slot) = parent.id().split('.').next() {
-                for func in devs.iter() {
-                    if let Some(func_slot) = func.id().split('.').next() {
-                        if func_slot == parent_slot {
-                            info!("{}: Function for {}", func.id(), parent.id());
-                            functions.push(func.clone());
-                        }
-                    }
-                }
-            }
-            functions
-        };
-
-        let mut amd = Vec::new();
-        let mut intel = Vec::new();
-        let mut nvidia = Vec::new();
-        let mut other = Vec::new();
-        for dev in devs.iter() {
-            let c = dev.class()?;
-            if 0x03 == (c >> 16) & 0xFF {
-                match dev.vendor()? {
-                    0x1002 => {
-                        info!("{}: AMD graphics", dev.id());
-                        amd.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    0x10DE => {
-                        info!("{}: NVIDIA graphics", dev.id());
-                        nvidia.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    0x8086 => {
-                        info!("{}: Intel graphics", dev.id());
-                        intel.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    vendor => {
-                        info!("{}: Other({:X}) graphics", dev.id(), vendor);
-                        other.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                }
-            }
-        }
-
-        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))?;
-        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 = if modules
-            .iter()
-            .any(|module| module.name == "nouveau" || module.name == "nvidia")
-        {
-            true
-        } else {
-            false
-        };
-
-        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)
-    }
-
-    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)
-    }
-
-    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))?;
-
-        let action = if vendor == GfxVendors::Nvidia {
-            info!("Enabling nvidia-fallback.service");
-            "enable"
-        } else {
-            info!("Disabling nvidia-fallback.service");
-            "disable"
-        };
-
-        let status = Command::new("systemctl")
-            .arg(action)
-            .arg("nvidia-fallback.service")
-            .status()
-            .map_err(|err| GfxError::Command("systemctl".into(), err))?;
-
-        if !status.success() {
-            // Error is ignored in case this service is removed
-            warn!(
-                "systemctl: {} (ignore warning if service does not exist!)",
-                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))?;
-        } else {
-            info!("Disabling graphics power");
-
-            // 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))?;
-        }
-
-        Ok(())
-    }
-
-    fn auto_power(&self) -> Result<(), RogError> {
-        let vendor = CtrlGraphics::get_vendor()?;
-        self.set_power(vendor != "integrated")
-    }
-}

asus-nb-ctrl/src/ctrl_gfx/mod.rs

@@ -1,57 +0,0 @@
-pub mod vendors;
-
-pub mod error;
-
-pub mod gfx;
-
-pub mod system;
-
-const PRIME_DISCRETE_PATH: &str = "/etc/prime-discrete";
-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
-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";
-
-static PRIMARY_GPU_BEGIN: &[u8] = br#"# Automatically generated by asusd
-Section "OutputClass"
-    Identifier "nvidia"
-    MatchDriver "nvidia-drm"
-    Driver "nvidia"
-    Option "AllowEmptyInitialConfiguration"
-    Option "AllowExternalGpus""#;
-
-static PRIMARY_GPU_NVIDIA: &[u8] = br#"
-    Option "PrimaryGPU" "true""#;
-
-static PRIMARY_GPU_END: &[u8] = br#"
-EndSection"#;

asus-nb-ctrl/src/ctrl_gfx/vendors.rs

@@ -1,86 +0,0 @@
-#[derive(Debug, PartialEq, Clone)]
-pub enum GfxVendors {
-    Nvidia,
-    Integrated,
-    Compute,
-    Hybrid,
-}
-
-use std::str::FromStr;
-
-use super::error::GfxError;
-
-impl FromStr for GfxVendors {
-    type Err = GfxError;
-
-    fn from_str(s: &str) -> Result<Self, GfxError> {
-        match s.to_lowercase().as_str() {
-            "nvidia" => Ok(GfxVendors::Nvidia),
-            "hybrid" => Ok(GfxVendors::Hybrid),
-            "compute" => Ok(GfxVendors::Compute),
-            "integrated" => Ok(GfxVendors::Integrated),
-            "nvidia\n" => Ok(GfxVendors::Nvidia),
-            "hybrid\n" => Ok(GfxVendors::Hybrid),
-            "compute\n" => Ok(GfxVendors::Compute),
-            "integrated\n" => Ok(GfxVendors::Integrated),
-            _ => Err(GfxError::ParseVendor),
-        }
-    }
-}
-
-impl From<&GfxVendors> for &str {
-    fn from(mode: &GfxVendors) -> Self {
-        match mode {
-            GfxVendors::Nvidia => "nvidia",
-            GfxVendors::Hybrid => "hybrid",
-            GfxVendors::Compute => "compute",
-            GfxVendors::Integrated => "integrated",
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum GfxCtrlAction {
-    Reboot,
-    RestartX,
-    None,
-}
-
-impl FromStr for GfxCtrlAction {
-    type Err = GfxError;
-
-    fn from_str(s: &str) -> Result<Self, GfxError> {
-        match s.to_lowercase().as_str() {
-            "reboot" => Ok(GfxCtrlAction::Reboot),
-            "restartx" => Ok(GfxCtrlAction::RestartX),
-            "none" => Ok(GfxCtrlAction::None),
-            _ => Err(GfxError::ParseVendor),
-        }
-    }
-}
-
-impl From<&GfxCtrlAction> for &str {
-    fn from(mode: &GfxCtrlAction) -> Self {
-        match mode {
-            GfxCtrlAction::Reboot => "reboot",
-            GfxCtrlAction::RestartX => "restartx",
-            GfxCtrlAction::None => "none",
-        }
-    }
-}
-
-impl From<&GfxCtrlAction> for String {
-    fn from(mode: &GfxCtrlAction) -> Self {
-        match mode {
-            GfxCtrlAction::Reboot => "reboot".into(),
-            GfxCtrlAction::RestartX => "restartx".into(),
-            GfxCtrlAction::None => "none".into(),
-        }
-    }
-}
-
-impl From<GfxCtrlAction> for String {
-    fn from(mode: GfxCtrlAction) -> Self {
-        (&mode).into()
-    }
-}

asus-nb-ctrl/src/ctrl_leds.rs

@@ -1,559 +0,0 @@
-// Only these two packets must be 17 bytes
-static LED_APPLY: [u8; 17] = [0x5d, 0xb4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-static LED_SET: [u8; 17] = [0x5d, 0xb5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-static KBD_BRIGHT_PATH: &str = "/sys/class/leds/asus::kbd_backlight/brightness";
-
-use crate::{
-    config::Config,
-    error::RogError,
-    laptops::{match_laptop, HELP_ADDRESS},
-};
-use asus_nb::{
-    aura_brightness_bytes,
-    aura_modes::{AuraModes, PER_KEY},
-    fancy::KeyColourArray,
-    LED_MSG_LEN,
-};
-use log::{error, info, warn};
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::{convert::TryInto, path::Path};
-use zbus::dbus_interface;
-
-use crate::GetSupported;
-
-use serde_derive::{Deserialize, Serialize};
-#[derive(Serialize, Deserialize)]
-pub struct LedSupportedFunctions {
-    pub brightness_set: bool,
-    pub stock_led_modes: Option<Vec<u8>>,
-    pub per_key_led_mode: bool,
-}
-
-impl GetSupported for CtrlKbdBacklight {
-    type A = LedSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        // let mode = <&str>::from(&<AuraModes>::from(*mode));
-        let mut stock_led_modes = None;
-        let mut per_key_led_mode = false;
-        if let Some(laptop) = match_laptop() {
-            let modes = laptop.supported_modes().to_vec();
-            if modes.contains(&PER_KEY) {
-                per_key_led_mode = true;
-                let modes = modes
-                    .iter()
-                    .filter(|x| **x != PER_KEY)
-                    .map(|x| *x)
-                    .collect();
-                stock_led_modes = Some(modes);
-            }
-        }
-
-        LedSupportedFunctions {
-            brightness_set: CtrlKbdBacklight::get_kbd_bright_path().is_ok(),
-            stock_led_modes,
-            per_key_led_mode,
-        }
-    }
-}
-
-pub struct CtrlKbdBacklight {
-    led_node: Option<String>,
-    #[allow(dead_code)]
-    kbd_node: Option<String>,
-    pub bright_node: String,
-    supported_modes: Vec<u8>,
-    flip_effect_write: bool,
-    config: Arc<Mutex<Config>>,
-}
-
-pub struct DbusKbdBacklight {
-    inner: Arc<Mutex<CtrlKbdBacklight>>,
-}
-
-impl DbusKbdBacklight {
-    pub fn new(inner: Arc<Mutex<CtrlKbdBacklight>>) -> Self {
-        Self { inner }
-    }
-}
-
-trait Dbus {
-    fn set_led(&mut self, data: String);
-    fn ledmode(&self) -> String;
-    fn notify_led(&self, data: &str) -> zbus::Result<()>;
-}
-
-impl crate::ZbusAdd for DbusKbdBacklight {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&"/org/asuslinux/Led".try_into().unwrap(), self)
-            .map_err(|err| {
-                error!("DbusKbdBacklight: add_to_server {}", err);
-            })
-            .ok();
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl DbusKbdBacklight {
-    fn set_led_mode(&mut self, data: String) {
-        if let Ok(data) = serde_json::from_str(&data) {
-            if let Ok(mut ctrl) = self.inner.try_lock() {
-                if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
-                    match &data {
-                        AuraModes::PerKey(_) => {
-                            ctrl.do_command(data, &mut cfg)
-                                .unwrap_or_else(|err| warn!("{}", err));
-                        }
-                        _ => {
-                            if let Ok(json) = serde_json::to_string(&data) {
-                                ctrl.do_command(data, &mut cfg)
-                                    .unwrap_or_else(|err| warn!("{}", err));
-                                self.notify_led(&json).ok();
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            warn!("SetKeyBacklight could not deserialise");
-        }
-    }
-
-    fn next_led_mode(&self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
-                ctrl.toggle_mode(false, &mut cfg)
-                    .unwrap_or_else(|err| warn!("{}", err));
-
-                if let Some(mode) = cfg.get_led_mode_data(cfg.kbd_backlight_mode) {
-                    if let Ok(json) = serde_json::to_string(&mode) {
-                        self.notify_led(&json)
-                            .unwrap_or_else(|err| warn!("{}", err));
-                    }
-                }
-            }
-        }
-    }
-
-    fn prev_led_mode(&self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
-                ctrl.toggle_mode(true, &mut cfg)
-                    .unwrap_or_else(|err| warn!("{}", err));
-
-                if let Some(mode) = cfg.get_led_mode_data(cfg.kbd_backlight_mode) {
-                    if let Ok(json) = serde_json::to_string(&mode) {
-                        self.notify_led(&json)
-                            .unwrap_or_else(|err| warn!("{}", err));
-                    }
-                }
-            }
-        }
-    }
-
-    /// Return the current mode data
-    fn led_mode(&self) -> String {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(cfg) = ctrl.config.clone().try_lock() {
-                if let Some(mode) = cfg.get_led_mode_data(cfg.kbd_backlight_mode) {
-                    if let Ok(json) = serde_json::to_string(&mode) {
-                        return json;
-                    }
-                }
-            }
-        }
-        warn!("SetKeyBacklight could not deserialise");
-        "SetKeyBacklight could not deserialise".to_string()
-    }
-
-    /// Return a list of available modes
-    fn led_modes(&self) -> String {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(cfg) = ctrl.config.clone().try_lock() {
-                if let Ok(json) = serde_json::to_string(&cfg.kbd_backlight_modes) {
-                    return json;
-                }
-            }
-        }
-        warn!("SetKeyBacklight could not deserialise");
-        "SetKeyBacklight could not deserialise".to_string()
-    }
-
-    /// Return the current LED brightness
-    fn led_brightness(&self) -> i8 {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(cfg) = ctrl.config.clone().try_lock() {
-                return cfg.kbd_led_brightness as i8;
-            }
-        }
-        warn!("SetKeyBacklight could not deserialise");
-        -1
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_led(&self, data: &str) -> zbus::Result<()>;
-}
-
-impl crate::Reloadable for CtrlKbdBacklight {
-    fn reload(&mut self) -> Result<(), RogError> {
-        // set current mode (if any)
-        if let Ok(mut config) = self.config.clone().try_lock() {
-            if self.supported_modes.len() > 1 {
-                if self.supported_modes.contains(&config.kbd_backlight_mode) {
-                    let mode = config
-                        .get_led_mode_data(config.kbd_backlight_mode)
-                        .ok_or(RogError::NotSupported)?
-                        .to_owned();
-                    self.write_mode(&mode)?;
-                    info!("Reloaded last used mode");
-                } else {
-                    warn!(
-                        "An unsupported mode was set: {}, reset to first mode available",
-                        <&str>::from(&<AuraModes>::from(config.kbd_backlight_mode))
-                    );
-                    for (idx, mode) in config.kbd_backlight_modes.iter_mut().enumerate() {
-                        if !self.supported_modes.contains(&mode.into()) {
-                            config.kbd_backlight_modes.remove(idx);
-                            config.write();
-                            break;
-                        }
-                    }
-                    config.kbd_backlight_mode = self.supported_modes[0];
-                    // TODO: do a recursive call with a boxed dyn future later
-                    let mode = config
-                        .get_led_mode_data(config.kbd_backlight_mode)
-                        .ok_or(RogError::NotSupported)?
-                        .to_owned();
-                    self.write_mode(&mode)?;
-                    info!("Reloaded last used mode");
-                }
-            }
-
-            // Reload brightness
-            let bright = config.kbd_led_brightness;
-            let bytes = aura_brightness_bytes(bright);
-            self.write_bytes(&bytes)?;
-            info!("Reloaded last used brightness");
-        }
-        Ok(())
-    }
-}
-
-impl crate::CtrlTask for CtrlKbdBacklight {
-    fn do_task(&mut self) -> Result<(), RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&self.bright_node)
-            .map_err(|err| match err.kind() {
-                std::io::ErrorKind::NotFound => {
-                    RogError::MissingLedBrightNode((&self.bright_node).into(), err)
-                }
-                _ => RogError::Path((&self.bright_node).into(), err),
-            })?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if let Ok(mut config) = self.config.clone().try_lock() {
-                if config.kbd_led_brightness != num as u8 {
-                    config.read();
-                    config.kbd_led_brightness = num as u8;
-                    config.write();
-                }
-            }
-            return Ok(());
-        }
-        Err(RogError::ParseLED)
-    }
-}
-
-impl CtrlKbdBacklight {
-    #[inline]
-    pub fn new(
-        id_product: &str,
-        condev_iface: Option<&String>,
-        supported_modes: Vec<u8>,
-        config: Arc<Mutex<Config>>,
-    ) -> Result<Self, RogError> {
-        // TODO: return error if *all* nodes are None
-        let ctrl = CtrlKbdBacklight {
-            // Using `ok` here so we can continue without keyboard features but
-            // still get brightness control at least... maybe...
-            led_node: Some(Self::get_node_failover(
-                id_product,
-                None,
-                Self::scan_led_node,
-            )?),
-            kbd_node: Some(Self::get_node_failover(
-                id_product,
-                condev_iface,
-                Self::scan_kbd_node,
-            )?),
-            // TODO: Check for existance
-            bright_node: Self::get_kbd_bright_path()?.to_owned(),
-            supported_modes,
-            flip_effect_write: false,
-            config,
-        };
-        Ok(ctrl)
-    }
-
-    fn get_kbd_bright_path() -> Result<&'static str, RogError> {
-        if Path::new(KBD_BRIGHT_PATH).exists() {
-            Ok(KBD_BRIGHT_PATH)
-        } else {
-            Err(RogError::MissingFunction(
-                "Keyboard features missing, you may require a v5.11 series kernel or newer".into(),
-            ))
-        }
-    }
-
-    fn get_node_failover(
-        id_product: &str,
-        iface: Option<&String>,
-        fun: fn(&str, Option<&String>) -> Result<String, RogError>,
-    ) -> Result<String, RogError> {
-        // We do three tries here just to be certain that we avoid systemd unit
-        // load order issues
-        for n in 0..=2 {
-            // 0,1,2 inclusive
-            match fun(id_product, iface) {
-                Ok(o) => return Ok(o),
-                Err(e) => {
-                    if n == 2 {
-                        warn!("Looking for node: {}", e.to_string());
-                        std::thread::sleep(std::time::Duration::from_secs(1));
-                    } else {
-                        break;
-                    }
-                }
-            }
-        }
-        // Shouldn't be possible to reach this...
-        Err(RogError::NotFound(format!("{}, {:?}", id_product, iface)))
-    }
-
-    fn scan_led_node(id_product: &str, _: Option<&String>) -> Result<String, RogError> {
-        let mut enumerator = udev::Enumerator::new().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("enumerator failed".into(), err)
-        })?;
-        enumerator.match_subsystem("hidraw").map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("match_subsystem failed".into(), err)
-        })?;
-
-        for device in enumerator.scan_devices().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("scan_devices failed".into(), err)
-        })? {
-            if let Some(parent) = device
-                .parent_with_subsystem_devtype("usb", "usb_device")
-                .map_err(|err| {
-                    warn!("{}", err);
-                    RogError::Udev("parent_with_subsystem_devtype failed".into(), err)
-                })?
-            {
-                if parent
-                    .attribute_value("idProduct")
-                    .ok_or(RogError::NotFound("LED idProduct".into()))?
-                    == id_product
-                {
-                    if let Some(dev_node) = device.devnode() {
-                        info!("Using device at: {:?} for LED control", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
-                    }
-                }
-            }
-        }
-        warn!("Did not find a hidraw node for LED control, your device may be unsupported or require a kernel patch, see: {}", HELP_ADDRESS);
-        Err(RogError::MissingFunction(
-            "ASUS LED device node not found".into(),
-        ))
-    }
-
-    fn scan_kbd_node(id_product: &str, iface: Option<&String>) -> Result<String, RogError> {
-        let mut enumerator = udev::Enumerator::new().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("enumerator failed".into(), err)
-        })?;
-        enumerator.match_subsystem("input").map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("match_subsystem failed".into(), err)
-        })?;
-        enumerator
-            .match_property("ID_MODEL_ID", id_product)
-            .map_err(|err| {
-                warn!("{}", err);
-                RogError::Udev("match_property failed".into(), err)
-            })?;
-
-        for device in enumerator
-            .scan_devices()
-            .map_err(|err| {
-                warn!("{}", err);
-                err
-            })
-            .map_err(|err| {
-                warn!("{}", err);
-                RogError::Udev("scan_devices failed".into(), err)
-            })?
-        {
-            if let Some(dev_node) = device.devnode() {
-                if let Some(inum) = device.property_value("ID_USB_INTERFACE_NUM") {
-                    if let Some(iface) = iface {
-                        if inum == iface.as_str() {
-                            info!("Using device at: {:?} for keyboard polling", dev_node);
-                            return Ok(dev_node.to_string_lossy().to_string());
-                        }
-                    }
-                }
-            }
-        }
-
-        warn!("Did not find keyboard consumer device node, if expected functions are missing please file an issue at {}", HELP_ADDRESS);
-        Err(RogError::MissingFunction(
-            "ASUS keyboard 'Consumer Device' node not found".into(),
-        ))
-    }
-
-    pub fn do_command(&mut self, mode: AuraModes, config: &mut Config) -> Result<(), RogError> {
-        self.set_and_save(mode, config)
-    }
-
-    /// Should only be used if the bytes you are writing are verified correct
-    #[inline]
-    fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
-        if let Some(led_node) = &self.led_node {
-            if let Ok(mut file) = OpenOptions::new().write(true).open(led_node) {
-                return file
-                    .write_all(message)
-                    .map_err(|err| RogError::Write("write_bytes".into(), err));
-            }
-        }
-        Err(RogError::NotSupported)
-    }
-
-    /// Write an effect block
-    #[inline]
-    fn write_effect(&mut self, effect: &[Vec<u8>]) -> Result<(), RogError> {
-        if self.flip_effect_write {
-            for row in effect.iter().rev() {
-                self.write_bytes(row)?;
-            }
-        } else {
-            for row in effect.iter() {
-                self.write_bytes(row)?;
-            }
-        }
-        self.flip_effect_write = !self.flip_effect_write;
-        Ok(())
-    }
-
-    /// Used to set a builtin mode and save the settings for it
-    ///
-    /// This needs to be universal so that settings applied by dbus stick
-    #[inline]
-    fn set_and_save(&mut self, mode: AuraModes, config: &mut Config) -> Result<(), RogError> {
-        match mode {
-            AuraModes::LedBrightness(n) => {
-                let bytes: [u8; LED_MSG_LEN] = (&mode).into();
-                self.write_bytes(&bytes)?;
-                config.read();
-                config.kbd_led_brightness = n;
-                config.write();
-                info!("LED brightness set to {:#?}", n);
-            }
-            AuraModes::PerKey(v) => {
-                if v.is_empty() || v[0].is_empty() {
-                    let bytes = KeyColourArray::get_init_msg();
-                    self.write_bytes(&bytes)?;
-                } else {
-                    self.write_effect(&v)?;
-                }
-            }
-            _ => {
-                config.read();
-                let mode_num: u8 = u8::from(&mode);
-                self.write_mode(&mode)?;
-                config.kbd_backlight_mode = mode_num;
-                config.set_mode_data(mode);
-                config.write();
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn toggle_mode(&mut self, reverse: bool, config: &mut Config) -> Result<(), RogError> {
-        let current = config.kbd_backlight_mode;
-        if let Some(idx) = self.supported_modes.iter().position(|v| *v == current) {
-            let mut idx = idx;
-            // goes past end of array
-            if reverse {
-                if idx == 0 {
-                    idx = self.supported_modes.len() - 1;
-                } else {
-                    idx -= 1;
-                }
-            } else {
-                idx += 1;
-                if idx == self.supported_modes.len() {
-                    idx = 0;
-                }
-            }
-            let next = self.supported_modes[idx];
-
-            config.read();
-            if let Some(data) = config.get_led_mode_data(next) {
-                self.write_mode(&data)?;
-                config.kbd_backlight_mode = next;
-            }
-            config.write();
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    fn write_mode(&mut self, mode: &AuraModes) -> Result<(), RogError> {
-        match mode {
-            AuraModes::PerKey(v) => {
-                if v.is_empty() || v[0].is_empty() {
-                    let bytes = KeyColourArray::get_init_msg();
-                    self.write_bytes(&bytes)?;
-                } else {
-                    self.write_effect(v)?;
-                }
-            }
-            _ => {
-                let mode_num: u8 = u8::from(mode);
-                match mode {
-                    AuraModes::MultiStatic(_) => {
-                        if self.supported_modes.contains(&mode_num) {
-                            let bytes: [[u8; LED_MSG_LEN]; 4] = mode.into();
-                            for array in bytes.iter() {
-                                self.write_bytes(array)?;
-                            }
-                        }
-                    }
-                    _ => {
-                        if self.supported_modes.contains(&mode_num) {
-                            let bytes: [u8; LED_MSG_LEN] = mode.into();
-                            self.write_bytes(&bytes)?;
-                        }
-                    }
-                }
-                self.write_bytes(&LED_SET)?;
-                // Changes won't persist unless apply is set
-                self.write_bytes(&LED_APPLY)?;
-            }
-        }
-        Ok(())
-    }
-}

asus-nb-ctrl/src/laptops.rs

@@ -1,150 +0,0 @@
-use asus_nb::aura_modes::{AuraModes, BREATHING, STATIC, STROBE};
-use log::{info, warn};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::OpenOptions;
-use std::io::Read;
-
-pub static LEDMODE_CONFIG_PATH: &str = "/etc/asusd/asusd-ledmodes.toml";
-
-pub static HELP_ADDRESS: &str = "https://gitlab.com/asus-linux/asus-nb-ctrl";
-
-pub struct LaptopBase {
-    usb_product: String,
-    condev_iface: Option<String>, // required for finding the Consumer Device interface
-    supported_modes: Vec<u8>,
-}
-
-impl LaptopBase {
-    pub fn usb_product(&self) -> &str {
-        &self.usb_product
-    }
-    pub fn condev_iface(&self) -> Option<&String> {
-        self.condev_iface.as_ref()
-    }
-    pub fn supported_modes(&self) -> &[u8] {
-        &self.supported_modes
-    }
-}
-
-pub fn match_laptop() -> Option<LaptopBase> {
-    for device in rusb::devices().expect("Failed here").iter() {
-        let device_desc = device.device_descriptor().expect("Failed there");
-        if device_desc.vendor_id() == 0x0b05 {
-            match device_desc.product_id() {
-                0x1866 => {
-                    let laptop = select_1866_device("1866".to_owned());
-                    return Some(laptop);
-                }
-                0x1869 => return Some(select_1866_device("1869".to_owned())),
-                0x1854 => {
-                    info!("Found GL753 or similar");
-                    return Some(LaptopBase {
-                        usb_product: "1854".to_string(),
-                        condev_iface: None,
-                        supported_modes: vec![STATIC, BREATHING, STROBE],
-                    });
-                }
-                _ => {}
-            }
-        }
-    }
-    warn!(
-        "Unsupported laptop, please request support at {}",
-        HELP_ADDRESS
-    );
-    warn!("Continuing with minimal support");
-    None
-}
-
-fn select_1866_device(prod: String) -> LaptopBase {
-    let dmi = sysfs_class::DmiId::default();
-    let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_family = dmi.product_family().expect("Could not get product_family");
-
-    let mut laptop = LaptopBase {
-        usb_product: prod,
-        condev_iface: Some("02".to_owned()),
-        supported_modes: vec![],
-    };
-
-    if let Some(modes) = LEDModeGroup::load_from_config() {
-        if let Some(led_modes) = modes.matcher(&prod_family, &board_name) {
-            laptop.supported_modes = led_modes;
-            return laptop;
-        }
-    }
-    laptop
-}
-
-pub fn print_board_info() {
-    let dmi = sysfs_class::DmiId::default();
-    let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_name = dmi.product_name().expect("Could not get product_name");
-    let prod_family = dmi.product_family().expect("Could not get product_family");
-
-    info!("Product name: {}", prod_name.trim());
-    info!("Product family: {}", prod_family.trim());
-    info!("Board name: {}", board_name.trim());
-}
-
-pub fn print_modes(supported_modes: &[u8]) {
-    if !supported_modes.is_empty() {
-        info!("Supported Keyboard LED modes are:");
-        for mode in supported_modes {
-            let mode = <&str>::from(&<AuraModes>::from(*mode));
-            info!("- {}", mode);
-        }
-        info!(
-            "If these modes are incorrect or missing please request support at {}",
-            HELP_ADDRESS
-        );
-    } else {
-        info!("No RGB control available");
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct LEDModeGroup {
-    led_modes: Vec<LEDModes>,
-}
-
-impl LEDModeGroup {
-    /// Consumes the LEDModes
-    fn matcher(self, prod_family: &str, board_name: &str) -> Option<Vec<u8>> {
-        for led_modes in self.led_modes {
-            if prod_family.contains(&led_modes.prod_family) {
-                for board in led_modes.board_names {
-                    if board_name.contains(&board) {
-                        info!("Matched to {} {}", led_modes.prod_family, board);
-                        return Some(led_modes.led_modes);
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    fn load_from_config() -> Option<Self> {
-        if let Ok(mut file) = OpenOptions::new().read(true).open(&LEDMODE_CONFIG_PATH) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", LEDMODE_CONFIG_PATH);
-                } else {
-                    return Some(toml::from_str(&buf).unwrap_or_else(|_| {
-                        panic!("Could not deserialise {}", LEDMODE_CONFIG_PATH)
-                    }));
-                }
-            }
-        }
-        warn!("Does {} exist?", LEDMODE_CONFIG_PATH);
-        None
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct LEDModes {
-    prod_family: String,
-    board_names: Vec<String>,
-    led_modes: Vec<u8>,
-}

asus-nb-ctrl/src/main.rs

@@ -1,377 +0,0 @@
-use asus_nb::{
-    anime_dbus::AniMeDbusWriter,
-    cli_options::{AniMeActions, AniMeStatusValue, LedBrightness, SetAuraBuiltin},
-    core_dbus::AuraDbusClient,
-    profile::{ProfileCommand, ProfileEvent},
-};
-use daemon::{ctrl_fan_cpu::FanLevel, ctrl_gfx::vendors::GfxVendors};
-use gumdrop::{Opt, Options};
-use log::LevelFilter;
-use std::{env::args, io::Write, process::Command};
-use yansi_term::Colour::Green;
-use yansi_term::Colour::Red;
-
-#[derive(Default, Options)]
-struct CLIStart {
-    #[options(help_flag, help = "print help message")]
-    help: bool,
-    #[options(help = "show program version number")]
-    version: bool,
-    #[options(help = "show supported functions of this laptop")]
-    show_supported: bool,
-    #[options(meta = "", help = "<off, low, med, high>")]
-    kbd_bright: Option<LedBrightness>,
-    #[options(
-        meta = "",
-        help = "<silent, normal, boost>, set fan mode independent of profile"
-    )]
-    fan_mode: Option<FanLevel>,
-    #[options(meta = "", help = "<20-100>")]
-    chg_limit: Option<u8>,
-    #[options(command)]
-    command: Option<CliCommand>,
-}
-
-#[derive(Options)]
-enum CliCommand {
-    #[options(help = "Set the keyboard lighting from built-in modes")]
-    LedMode(LedModeCommand),
-    #[options(help = "Create and configure profiles")]
-    Profile(ProfileCommand),
-    #[options(help = "Set the graphics mode")]
-    Graphics(GraphicsCommand),
-    #[options(name = "anime", help = "Manage AniMe Matrix")]
-    AniMe(AniMeCommand),
-    #[options(help = "Change bios settings")]
-    Bios(BiosCommand),
-}
-
-#[derive(Options)]
-struct LedModeCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(help = "switch to next aura mode")]
-    next_mode: bool,
-    #[options(help = "switch to previous aura mode")]
-    prev_mode: bool,
-    #[options(command)]
-    command: Option<SetAuraBuiltin>,
-}
-
-#[derive(Options)]
-struct GraphicsCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        meta = "",
-        help = "Set graphics mode: <nvidia, hybrid, compute, integrated>"
-    )]
-    mode: Option<GfxVendors>,
-    #[options(help = "Get the current mode")]
-    get: bool,
-    #[options(help = "Get the current power status")]
-    pow: bool,
-    #[options(help = "Do not ask for confirmation")]
-    force: bool,
-}
-
-#[derive(Options)]
-struct AniMeCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        meta = "",
-        help = "turn on/off the panel (accept/reject write requests)"
-    )]
-    turn: Option<AniMeStatusValue>,
-    #[options(meta = "", help = "turn on/off the panel at boot (with Asus effect)")]
-    boot: Option<AniMeStatusValue>,
-    #[options(command)]
-    command: Option<AniMeActions>,
-}
-
-#[derive(Options, Debug)]
-struct BiosCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(meta = "", no_long, help = "toggle bios POST sound")]
-    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")]
-    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 logger = env_logger::Builder::new();
-    logger
-        .target(env_logger::Target::Stdout)
-        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
-        .init();
-
-    let mut args: Vec<String> = args().collect();
-    args.remove(0);
-
-    let parsed: CLIStart;
-    let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
-    match CLIStart::parse_args_default(&args) {
-        Ok(p) => {
-            parsed = p;
-        }
-        Err(err) if err.to_string() == missing_argument_k.to_string() => {
-            parsed = CLIStart {
-                kbd_bright: Some(LedBrightness::new(None)),
-                ..Default::default()
-            };
-        }
-        Err(err) => {
-            eprintln!("source {}", err);
-            std::process::exit(2);
-        }
-    }
-
-    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();
-    }
-
-    if parsed.version {
-        println!("Version: {}", daemon::VERSION);
-    }
-
-    let dbus_client = AuraDbusClient::new()?;
-    let anime_dbus_client = AniMeDbusWriter::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);
-                }
-            }
-            if mode.next_mode && mode.prev_mode {
-                println!("Please specify either next or previous")
-            }
-            if mode.next_mode {
-                dbus_client.next_keyboard_led_mode()?;
-            } else if mode.prev_mode {
-                dbus_client.prev_keyboard_led_mode()?;
-            } else if let Some(command) = mode.command {
-                dbus_client.write_builtin_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_client.next_fan_profile()?;
-            } else {
-                dbus_client.write_profile_command(&ProfileEvent::Cli(cmd))?
-            }
-        }
-        Some(CliCommand::Graphics(cmd)) => do_gfx(cmd, &dbus_client)?,
-        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());
-                if let Some(lst) = cmd.self_command_list() {
-                    println!("\n{}", lst);
-                }
-            }
-            if let Some(anime_turn) = cmd.turn {
-                anime_dbus_client.turn_on_off(anime_turn.into())?
-            }
-            if let Some(anime_boot) = cmd.boot {
-                anime_dbus_client.turn_boot_on_off(anime_boot.into())?
-            }
-            if let Some(action) = cmd.command {
-                match action {
-                    AniMeActions::Leds(anime_leds) => {
-                        let led_brightness = anime_leds.led_brightness();
-                        anime_dbus_client.set_leds_brightness(led_brightness)?;
-                    }
-                }
-            }
-        }
-        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_client.set_bios_post_sound(opt)?;
-            }
-            if cmd.post_sound_get {
-                let res = if dbus_client.get_bios_post_sound()? == 1 {
-                    true
-                } else {
-                    false
-                };
-                println!("Bios POST sound on: {}", res);
-            }
-            if let Some(opt) = cmd.dedicated_gfx_set {
-                dbus_client.set_bios_dedicated_gfx(opt)?;
-            }
-            if cmd.dedicated_gfx_get {
-                let res = if dbus_client.get_bios_dedicated_gfx()? == 1 {
-                    true
-                } else {
-                    false
-                };
-                println!("Bios dedicated GPU on: {}", res);
-            }
-        }
-        None => {
-            if (!parsed.show_supported
-                && parsed.kbd_bright.is_none()
-                && parsed.fan_mode.is_none()
-                && parsed.chg_limit.is_none())
-                || parsed.help
-            {
-                println!("{}", CLIStart::usage());
-                println!();
-                println!("{}", CLIStart::command_list().unwrap());
-            }
-        }
-    }
-
-    if let Some(brightness) = parsed.kbd_bright {
-        match brightness.level() {
-            None => {
-                let level = dbus_client.get_led_brightness()?;
-                println!("Current keyboard led brightness: {}", level.to_string());
-            }
-            Some(level) => dbus_client.write_brightness(level)?,
-        }
-    }
-
-    if parsed.show_supported {
-        let dat = dbus_client.get_supported_functions()?;
-        println!("Supported laptop functions:\n{}", dat.to_string());
-    }
-
-    if let Some(fan_level) = parsed.fan_mode {
-        dbus_client.write_fan_mode(fan_level.into())?;
-    }
-    if let Some(chg_limit) = parsed.chg_limit {
-        dbus_client.write_charge_limit(chg_limit)?;
-    }
-    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`");
-
-        dbus_client.write_gfx_mode(<&str>::from(&mode).into())?;
-        let res = dbus_client.wait_gfx_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())),);
-                std::process::exit(-1);
-            }
-        }
-        std::process::exit(-1)
-    }
-    if command.get {
-        let res = dbus_client.get_gfx_mode()?;
-        println!("Current graphics mode: {}", res);
-    }
-    if command.pow {
-        let res = dbus_client.get_gfx_pwr()?;
-        if res.contains("active") {
-            println!("Current power status: {}", Red.paint(&format!("{}", res)));
-        } else {
-            println!("Current power status: {}", Green.paint(&format!("{}", res)));
-        }
-    }
-    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);
-
-    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()?;
-
-        if !status.success() {
-            println!("systemctl: returned with {}", status);
-        }
-    } else {
-        println!("{}", Red.paint(&format!("{}", cancel_msg)));
-    }
-    Ok(())
-}

asus-nb/src/anime_dbus.rs

@@ -1,107 +0,0 @@
-const DBUS_ANIME_PATH: &str = "/org/asuslinux/Anime";
-pub const ANIME_PANE1_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
-pub const ANIME_PANE2_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
-
-use crate::anime_matrix::{AniMeMatrix, AniMePacketType};
-use crate::DBUS_NAME;
-use dbus::blocking::{Connection, Proxy};
-use std::error::Error;
-use std::{thread, time::Duration};
-
-use crate::dbus_anime::OrgAsuslinuxDaemon as OrgAsuslinuxDaemonAniMe;
-
-/// Interface for the AniMe dot-matrix display
-///
-/// The resolution is 34x56 (1904) but only 1,215 LEDs in the top-left are used.
-/// The display is available only on select GA401 models.
-///
-/// Actual image ratio when displayed is stretched width.
-///
-/// Data structure should be nested array of [[u8; 33]; 56]
-pub struct AniMeDbusWriter {
-    connection: Box<Connection>,
-    block_time: u64,
-}
-
-impl AniMeDbusWriter {
-    #[inline]
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let connection = Connection::new_system()?;
-        Ok(AniMeDbusWriter {
-            connection: Box::new(connection),
-            block_time: 25,
-        })
-    }
-
-    // Create D-Bus proxy
-    fn new_proxy(&self) -> Proxy<&Connection> {
-        self.connection
-            .with_proxy(DBUS_NAME, DBUS_ANIME_PATH, Duration::from_millis(200))
-    }
-
-    fn thread_sleep(&self) {
-        thread::sleep(Duration::from_millis(self.block_time));
-    }
-
-    pub fn write_image_to_buf(_buf: &mut AniMePacketType, _image_data: &[u8]) {
-        unimplemented!("Image format is in progress of being worked out")
-    }
-
-    /// Write an Animatrix image
-    ///
-    /// The expected input here is *two* Vectors, 640 bytes in length.
-    /// The two vectors are each one half of the full image write.
-    ///
-    /// After each write a flush is written, it is assumed that this tells the
-    /// device to go ahead and display the written bytes
-    ///
-    /// # Note: The vectors are expected to contain the full sequence of bytes
-    /// as follows
-    ///
-    /// - Write packet 1: 0x5e 0xc0 0x02 0x01 0x00 0x73 0x02 .. <led brightness>
-    /// - Write packet 2: 0x5e 0xc0 0x02 0x74 0x02 0x73 0x02 .. <led brightness>
-    ///
-    /// Where led brightness is 0..255, low to high
-    #[inline]
-    pub fn write_image(&self, image: &mut AniMePacketType) -> Result<(), Box<dyn Error>> {
-        let proxy = self.new_proxy();
-
-        image[0][..7].copy_from_slice(&ANIME_PANE1_PREFIX);
-        image[1][..7].copy_from_slice(&ANIME_PANE2_PREFIX);
-
-        proxy.set_anime(vec![image[0].to_vec(), image[1].to_vec()])?;
-        self.thread_sleep();
-
-        Ok(())
-    }
-
-    #[inline]
-    pub fn set_leds_brightness(&self, led_brightness: u8) -> Result<(), Box<dyn Error>> {
-        let mut anime_matrix = AniMeMatrix::new();
-
-        anime_matrix.fill_with(led_brightness);
-        self.write_image(&mut AniMePacketType::from(anime_matrix))?;
-
-        Ok(())
-    }
-
-    #[inline]
-    pub fn turn_on_off(&self, status: bool) -> Result<(), Box<dyn Error>> {
-        let proxy = self.new_proxy();
-
-        proxy.set_on_off(status)?;
-        self.thread_sleep();
-
-        Ok(())
-    }
-
-    #[inline]
-    pub fn turn_boot_on_off(&self, status: bool) -> Result<(), Box<dyn Error>> {
-        let proxy = self.new_proxy();
-
-        proxy.set_boot_on_off(status)?;
-        self.thread_sleep();
-
-        Ok(())
-    }
-}

asus-nb/src/aura_modes.rs

@@ -1,287 +0,0 @@
-use crate::cli_options;
-use crate::cli_options::SetAuraBuiltin;
-use serde_derive::{Deserialize, Serialize};
-
-pub const STATIC: u8 = 0x00;
-pub const BREATHING: u8 = 0x01;
-pub const STROBE: u8 = 0x02;
-pub const RAINBOW: u8 = 0x03;
-pub const STAR: u8 = 0x04;
-pub const RAIN: u8 = 0x05;
-pub const HIGHLIGHT: u8 = 0x06;
-pub const LASER: u8 = 0x07;
-pub const RIPPLE: u8 = 0x08;
-pub const PULSE: u8 = 0x0a;
-pub const COMET: u8 = 0x0b;
-pub const FLASH: u8 = 0x0c;
-pub const MULTISTATIC: u8 = 0x0d;
-pub const PER_KEY: u8 = 0xff;
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Colour(pub u8, pub u8, pub u8);
-impl From<cli_options::Colour> for Colour {
-    fn from(c: cli_options::Colour) -> Self {
-        Colour(c.0, c.1, c.2)
-    }
-}
-impl Default for Colour {
-    fn default() -> Self {
-        Colour(128, 0, 0)
-    }
-}
-
-#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
-pub enum Speed {
-    Low = 0xe1,
-    Med = 0xeb,
-    High = 0xf5,
-}
-impl From<cli_options::Speed> for Speed {
-    fn from(s: cli_options::Speed) -> Self {
-        match s {
-            cli_options::Speed::Low => Speed::Low,
-            cli_options::Speed::Med => Speed::Med,
-            cli_options::Speed::High => Speed::High,
-        }
-    }
-}
-impl Default for Speed {
-    fn default() -> Self {
-        Speed::Med
-    }
-}
-
-/// Used for Rainbow mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
-pub enum Direction {
-    Right,
-    Left,
-    Up,
-    Down,
-}
-impl From<cli_options::Direction> for Direction {
-    fn from(s: cli_options::Direction) -> Self {
-        match s {
-            cli_options::Direction::Right => Direction::Right,
-            cli_options::Direction::Left => Direction::Left,
-            cli_options::Direction::Up => Direction::Up,
-            cli_options::Direction::Down => Direction::Down,
-        }
-    }
-}
-impl Default for Direction {
-    fn default() -> Self {
-        Direction::Right
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct TwoColourSpeed {
-    pub colour: Colour,
-    pub colour2: Colour,
-    pub speed: Speed,
-}
-impl From<cli_options::TwoColourSpeed> for TwoColourSpeed {
-    fn from(mode: cli_options::TwoColourSpeed) -> Self {
-        TwoColourSpeed {
-            colour: mode.colour.into(),
-            colour2: mode.colour2.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleSpeed {
-    pub speed: Speed,
-}
-impl From<cli_options::SingleSpeed> for SingleSpeed {
-    fn from(mode: cli_options::SingleSpeed) -> Self {
-        SingleSpeed {
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleColour {
-    pub colour: Colour,
-}
-impl From<cli_options::SingleColour> for SingleColour {
-    fn from(mode: cli_options::SingleColour) -> Self {
-        SingleColour {
-            colour: mode.colour.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct MultiColour {
-    pub colour1: Colour,
-    pub colour2: Colour,
-    pub colour3: Colour,
-    pub colour4: Colour,
-}
-impl From<cli_options::MultiColour> for MultiColour {
-    fn from(mode: cli_options::MultiColour) -> Self {
-        MultiColour {
-            colour1: mode.colour1.into(),
-            colour2: mode.colour2.into(),
-            colour3: mode.colour3.into(),
-            colour4: mode.colour4.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleSpeedDirection {
-    pub direction: Direction,
-    pub speed: Speed,
-}
-impl From<cli_options::SingleSpeedDirection> for SingleSpeedDirection {
-    fn from(mode: cli_options::SingleSpeedDirection) -> Self {
-        SingleSpeedDirection {
-            direction: mode.direction.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleColourSpeed {
-    pub colour: Colour,
-    pub speed: Speed,
-}
-impl From<cli_options::SingleColourSpeed> for SingleColourSpeed {
-    fn from(mode: cli_options::SingleColourSpeed) -> Self {
-        SingleColourSpeed {
-            colour: mode.colour.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub enum AuraModes {
-    Static(SingleColour),
-    Breathe(TwoColourSpeed),
-    Strobe(SingleSpeed),
-    Rainbow(SingleSpeedDirection),
-    Star(TwoColourSpeed),
-    Rain(SingleSpeed),
-    Highlight(SingleColourSpeed),
-    Laser(SingleColourSpeed),
-    Ripple(SingleColourSpeed),
-    Pulse(SingleColour),
-    Comet(SingleColour),
-    Flash(SingleColour),
-    MultiStatic(MultiColour),
-    LedBrightness(u8),
-    // TODO: use a serializable structure for this (KeyColourArray)
-    PerKey(Vec<Vec<u8>>),
-}
-
-impl From<SetAuraBuiltin> for AuraModes {
-    fn from(mode: SetAuraBuiltin) -> Self {
-        match mode {
-            SetAuraBuiltin::Static(x) => AuraModes::Static(x.into()),
-            SetAuraBuiltin::Breathe(x) => AuraModes::Breathe(x.into()),
-            SetAuraBuiltin::Strobe(x) => AuraModes::Strobe(x.into()),
-            SetAuraBuiltin::Rainbow(x) => AuraModes::Rainbow(x.into()),
-            SetAuraBuiltin::Star(x) => AuraModes::Star(x.into()),
-            SetAuraBuiltin::Rain(x) => AuraModes::Rain(x.into()),
-            SetAuraBuiltin::Highlight(x) => AuraModes::Highlight(x.into()),
-            SetAuraBuiltin::Laser(x) => AuraModes::Laser(x.into()),
-            SetAuraBuiltin::Ripple(x) => AuraModes::Ripple(x.into()),
-            SetAuraBuiltin::Pulse(x) => AuraModes::Pulse(x.into()),
-            SetAuraBuiltin::Comet(x) => AuraModes::Comet(x.into()),
-            SetAuraBuiltin::Flash(x) => AuraModes::Flash(x.into()),
-            SetAuraBuiltin::MultiStatic(x) => AuraModes::MultiStatic(x.into()),
-        }
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<AuraModes> for u8 {
-    fn from(mode: AuraModes) -> Self {
-        u8::from(&mode)
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<&mut AuraModes> for u8 {
-    fn from(mode: &mut AuraModes) -> Self {
-        u8::from(&*mode)
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<&AuraModes> for u8 {
-    fn from(mode: &AuraModes) -> Self {
-        match mode {
-            AuraModes::Static(_) => STATIC,
-            AuraModes::Breathe(_) => BREATHING,
-            AuraModes::Strobe(_) => STROBE,
-            AuraModes::Rainbow(_) => RAINBOW,
-            AuraModes::Star(_) => STAR,
-            AuraModes::Rain(_) => RAIN,
-            AuraModes::Highlight(_) => HIGHLIGHT,
-            AuraModes::Laser(_) => LASER,
-            AuraModes::Ripple(_) => RIPPLE,
-            AuraModes::Pulse(_) => PULSE,
-            AuraModes::Comet(_) => COMET,
-            AuraModes::Flash(_) => FLASH,
-            AuraModes::MultiStatic(_) => MULTISTATIC,
-            AuraModes::PerKey(_) => PER_KEY,
-            _ => panic!("Invalid mode"),
-        }
-    }
-}
-
-impl From<&AuraModes> for &str {
-    fn from(mode: &AuraModes) -> Self {
-        match mode {
-            AuraModes::Static(_) => "Static",
-            AuraModes::Breathe(_) => "Breathing",
-            AuraModes::Strobe(_) => "Strobing",
-            AuraModes::Rainbow(_) => "Rainbow",
-            AuraModes::Star(_) => "Stars",
-            AuraModes::Rain(_) => "Rain",
-            AuraModes::Highlight(_) => "Keypress Highlight",
-            AuraModes::Laser(_) => "Keypress Laser",
-            AuraModes::Ripple(_) => "Keypress Ripple",
-            AuraModes::Pulse(_) => "Pulse",
-            AuraModes::Comet(_) => "Comet",
-            AuraModes::Flash(_) => "Flash",
-            AuraModes::MultiStatic(_) => "4-Zone Static Colours",
-            AuraModes::PerKey(_) => "RGB per-key",
-            _ => panic!("Invalid mode"),
-        }
-    }
-}
-
-/// Exists to convert back from correct bytes. PER_KEY byte intentionally left off as it
-/// does not correspond to an actual pre-set mode, nor does brightness.
-impl From<u8> for AuraModes {
-    fn from(byte: u8) -> Self {
-        match byte {
-            STATIC => AuraModes::Static(SingleColour::default()),
-            BREATHING => AuraModes::Breathe(TwoColourSpeed::default()),
-            STROBE => AuraModes::Strobe(SingleSpeed::default()),
-            RAINBOW => AuraModes::Rainbow(SingleSpeedDirection::default()),
-            STAR => AuraModes::Star(TwoColourSpeed::default()),
-            RAIN => AuraModes::Rain(SingleSpeed::default()),
-            HIGHLIGHT => AuraModes::Highlight(SingleColourSpeed::default()),
-            LASER => AuraModes::Laser(SingleColourSpeed::default()),
-            RIPPLE => AuraModes::Ripple(SingleColourSpeed::default()),
-            PULSE => AuraModes::Pulse(SingleColour::default()),
-            COMET => AuraModes::Comet(SingleColour::default()),
-            FLASH => AuraModes::Flash(SingleColour::default()),
-            MULTISTATIC => AuraModes::MultiStatic(MultiColour::default()),
-            PER_KEY => AuraModes::PerKey(vec![]),
-            _ => panic!("Invalid mode byte"),
-        }
-    }
-}

asus-nb/src/cli_options.rs

@@ -1,287 +0,0 @@
-use crate::error::AuraError;
-use gumdrop::Options;
-use serde_derive::{Deserialize, Serialize};
-use std::str::FromStr;
-
-#[derive(Options)]
-pub struct LedBrightness {
-    level: Option<u8>,
-}
-impl LedBrightness {
-    pub fn new(level: Option<u8>) -> Self {
-        LedBrightness { level }
-    }
-
-    pub fn level(&self) -> Option<u8> {
-        self.level
-    }
-}
-impl FromStr for LedBrightness {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "off" => Ok(LedBrightness { level: Some(0x00) }),
-            "low" => Ok(LedBrightness { level: Some(0x01) }),
-            "med" => Ok(LedBrightness { level: Some(0x02) }),
-            "high" => Ok(LedBrightness { level: Some(0x03) }),
-            _ => {
-                print!(
-                    "{}\n{}\n",
-                    "Invalid argument, must be one of:", "off, low, med, high"
-                );
-                Err(AuraError::ParseBrightness)
-            }
-        }
-    }
-}
-impl ToString for LedBrightness {
-    fn to_string(&self) -> String {
-        let s = match self.level {
-            Some(0x00) => "low",
-            Some(0x01) => "med",
-            Some(0x02) => "high",
-            _ => "unknown",
-        };
-        s.to_string()
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Colour(pub u8, pub u8, pub u8);
-impl Default for Colour {
-    fn default() -> Self {
-        Colour(255, 0, 0)
-    }
-}
-impl FromStr for Colour {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.len() < 6 {
-            return Err(AuraError::ParseColour);
-        }
-        let r = u8::from_str_radix(&s[0..2], 16).or(Err(AuraError::ParseColour))?;
-        let g = u8::from_str_radix(&s[2..4], 16).or(Err(AuraError::ParseColour))?;
-        let b = u8::from_str_radix(&s[4..6], 16).or(Err(AuraError::ParseColour))?;
-        Ok(Colour(r, g, b))
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub enum Speed {
-    Low = 0xe1,
-    Med = 0xeb,
-    High = 0xf5,
-}
-impl Default for Speed {
-    fn default() -> Self {
-        Speed::Med
-    }
-}
-impl FromStr for Speed {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "low" => Ok(Speed::Low),
-            "med" => Ok(Speed::Med),
-            "high" => Ok(Speed::High),
-            _ => Err(AuraError::ParseSpeed),
-        }
-    }
-}
-
-/// Used for Rainbow mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Deserialize, Serialize)]
-pub enum Direction {
-    Right,
-    Left,
-    Up,
-    Down,
-}
-impl Default for Direction {
-    fn default() -> Self {
-        Direction::Right
-    }
-}
-impl FromStr for Direction {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "right" => Ok(Direction::Right),
-            "up" => Ok(Direction::Up),
-            "down" => Ok(Direction::Down),
-            "left" => Ok(Direction::Left),
-            _ => Err(AuraError::ParseDirection),
-        }
-    }
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct TwoColourSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the first RGB value e.g, ff00ff")]
-    pub colour: Colour,
-    #[options(no_long, meta = "HEX", help = "set the second RGB value e.g, ff00ff")]
-    pub colour2: Colour,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleColour {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour: Colour,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct MultiColour {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour1: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour2: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour3: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour4: Colour,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleSpeedDirection {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        no_long,
-        meta = "DIR",
-        help = "set the direction: up, down, left, right"
-    )]
-    pub direction: Direction,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleColourSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour: Colour,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-/// Byte value for setting the built-in mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Options, Deserialize, Serialize)]
-pub enum SetAuraBuiltin {
-    #[options(help = "set a single static colour")]
-    Static(SingleColour),
-    #[options(help = "pulse between one or two colours")]
-    Breathe(TwoColourSpeed),
-    #[options(help = "strobe through all colours")]
-    Strobe(SingleSpeed),
-    #[options(help = "rainbow cycling in one of four directions")]
-    Rainbow(SingleSpeedDirection),
-    #[options(help = "rain pattern mimicking raindrops")]
-    Star(TwoColourSpeed),
-    #[options(help = "rain pattern of three preset colours")]
-    Rain(SingleSpeed),
-    #[options(help = "pressed keys are highlighted to fade")]
-    Highlight(SingleColourSpeed),
-    #[options(help = "pressed keys generate horizontal laser")]
-    Laser(SingleColourSpeed),
-    #[options(help = "pressed keys ripple outwards like a splash")]
-    Ripple(SingleColourSpeed),
-    #[options(help = "set a rapid pulse")]
-    Pulse(SingleColour),
-    #[options(help = "set a vertical line zooming from left")]
-    Comet(SingleColour),
-    #[options(help = "set a wide vertical line zooming from left")]
-    Flash(SingleColour),
-    #[options(help = "4-zone multi-colour")]
-    MultiStatic(MultiColour),
-}
-
-impl Default for SetAuraBuiltin {
-    fn default() -> Self {
-        SetAuraBuiltin::Static(SingleColour {
-            help: false,
-            colour: Colour(255, 0, 0),
-        })
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub enum AniMeStatusValue {
-    On,
-    Off,
-}
-impl FromStr for AniMeStatusValue {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "on" => Ok(AniMeStatusValue::On),
-            "off" => Ok(AniMeStatusValue::Off),
-            _ => {
-                print!("{}\n{}\n", "Invalid argument, must be one of:", "on, off");
-                Err(AuraError::ParseAnime)
-            }
-        }
-    }
-}
-impl From<AniMeStatusValue> for bool {
-    fn from(value: AniMeStatusValue) -> Self {
-        match value {
-            AniMeStatusValue::On => true,
-            AniMeStatusValue::Off => false,
-        }
-    }
-}
-
-#[derive(Options)]
-pub struct AniMeLeds {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        no_long,
-        required,
-        short = "b",
-        meta = "BYTE",
-        help = "set all leds brightness value"
-    )]
-    led_brightness: u8,
-}
-impl AniMeLeds {
-    pub fn led_brightness(&self) -> u8 {
-        self.led_brightness
-    }
-}
-
-#[derive(Options)]
-pub enum AniMeActions {
-    #[options(help = "change all leds brightness")]
-    Leds(AniMeLeds),
-}

asus-nb/src/core_dbus.rs

@@ -1,418 +0,0 @@
-use super::*;
-use crate::cli_options::LedBrightness;
-use crate::fancy::KeyColourArray;
-use crate::profile::ProfileEvent;
-use dbus::{blocking::Connection, Message};
-use std::error::Error;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc, Mutex,
-};
-use std::{thread, time::Duration};
-
-use crate::dbus_charge::{
-    OrgAsuslinuxDaemon as OrgAsuslinuxDaemonCharge, OrgAsuslinuxDaemonNotifyCharge,
-};
-use crate::dbus_gfx::{
-    OrgAsuslinuxDaemon as OrgAsuslinuxDaemonGfx, OrgAsuslinuxDaemonNotifyAction,
-    OrgAsuslinuxDaemonNotifyGfx,
-};
-use crate::dbus_ledmode::{
-    OrgAsuslinuxDaemon as OrgAsuslinuxDaemonLed, OrgAsuslinuxDaemonNotifyLed,
-};
-use crate::dbus_profile::{
-    OrgAsuslinuxDaemon as OrgAsuslinuxDaemonProfile, OrgAsuslinuxDaemonNotifyProfile,
-};
-use crate::dbus_rogbios::OrgAsuslinuxDaemon as OrgAsuslinuxDaemonRogBios;
-use crate::dbus_supported::OrgAsuslinuxDaemon as OrgAsuslinuxDaemonSupported;
-
-// Signals separated out
-pub struct CtrlSignals {
-    pub gfx_vendor_signal: Arc<Mutex<Option<String>>>,
-    pub gfx_action_signal: Arc<Mutex<Option<String>>>,
-    pub profile_signal: Arc<Mutex<Option<String>>>,
-    pub ledmode_signal: Arc<Mutex<Option<AuraModes>>>,
-    pub charge_signal: Arc<Mutex<Option<u8>>>,
-}
-
-impl CtrlSignals {
-    #[inline]
-    pub fn new(connection: &Connection) -> Result<Self, Box<dyn Error>> {
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Gfx",
-            Duration::from_secs(2),
-        );
-
-        let gfx_vendor_signal = Arc::new(Mutex::new(None));
-        let gfx_res1 = gfx_vendor_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyGfx, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = gfx_res1.lock() {
-                    *lock = Some(sig.vendor);
-                }
-                true
-            },
-        )?;
-
-        let gfx_action_signal = Arc::new(Mutex::new(None));
-        let gfx_res1 = gfx_action_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyAction, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = gfx_res1.lock() {
-                    *lock = Some(sig.action);
-                }
-                true
-            },
-        )?;
-
-        //
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Profile",
-            Duration::from_secs(2),
-        );
-
-        let profile_signal = Arc::new(Mutex::new(None));
-        let prof_res1 = profile_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyProfile, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = prof_res1.lock() {
-                    *lock = Some(sig.profile);
-                }
-                true
-            },
-        )?;
-
-        //
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Led",
-            Duration::from_secs(2),
-        );
-
-        let ledmode_signal = Arc::new(Mutex::new(None));
-        let led_res1 = ledmode_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyLed, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = led_res1.lock() {
-                    if let Ok(dat) = serde_json::from_str(&sig.data) {
-                        *lock = Some(dat);
-                    }
-                }
-                true
-            },
-        )?;
-
-        //
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Charge",
-            Duration::from_secs(2),
-        );
-
-        let charge_signal = Arc::new(Mutex::new(None));
-        let charge_res1 = charge_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyCharge, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = charge_res1.lock() {
-                    *lock = Some(sig.limit);
-                }
-                true
-            },
-        )?;
-
-        Ok(CtrlSignals {
-            gfx_vendor_signal,
-            gfx_action_signal,
-            profile_signal,
-            ledmode_signal,
-            charge_signal,
-        })
-    }
-}
-
-/// Simplified way to write a effect block
-pub struct AuraDbusClient {
-    connection: Box<Connection>,
-    block_time: u64,
-    stop: Arc<AtomicBool>,
-    signals: CtrlSignals,
-}
-
-impl AuraDbusClient {
-    #[inline]
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let connection = Connection::new_system()?;
-
-        let stop = Arc::new(AtomicBool::new(false));
-        let match_rule = dbus::message::MatchRule::new_signal(DBUS_IFACE, "NotifyLed");
-        let stop1 = stop.clone();
-        connection.add_match(match_rule, move |_: (), _, msg| {
-            if msg.read1::<&str>().is_ok() {
-                stop1.clone().store(true, Ordering::Relaxed);
-            }
-            true
-        })?;
-
-        let signals = CtrlSignals::new(&connection)?;
-
-        Ok(AuraDbusClient {
-            connection: Box::new(connection),
-            block_time: 33333,
-            stop,
-            signals,
-        })
-    }
-
-    pub fn wait_gfx_changed(&self) -> Result<String, Box<dyn Error>> {
-        loop {
-            self.connection.process(Duration::from_millis(1))?;
-            if let Ok(lock) = self.signals.gfx_action_signal.lock() {
-                if let Some(stuff) = lock.as_ref() {
-                    return Ok(stuff.to_string());
-                }
-            }
-        }
-    }
-
-    /// This method must always be called before the very first write to initialise
-    /// the keyboard LED EC in the correct mode
-    #[inline]
-    pub fn init_effect(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let mode = AuraModes::PerKey(vec![vec![]]);
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Led",
-            Duration::from_secs(2),
-        );
-        proxy.set_led_mode(&serde_json::to_string(&mode)?)?;
-        Ok(())
-    }
-
-    /// Write a single colour block.
-    ///
-    /// Intentionally blocks for 10ms after sending to allow the block to
-    /// be written to the keyboard EC. This should not be async.
-    #[inline]
-    pub fn write_colour_block(
-        &mut self,
-        key_colour_array: &KeyColourArray,
-    ) -> Result<(), Box<dyn Error>> {
-        let group = key_colour_array.get();
-        let mut vecs = Vec::with_capacity(group.len());
-        for v in group {
-            vecs.push(v.to_vec());
-        }
-        let mode = AuraModes::PerKey(vecs);
-
-        self.write_keyboard_leds(&mode)?;
-
-        thread::sleep(Duration::from_micros(self.block_time));
-        self.connection.process(Duration::from_micros(500))?;
-
-        if self.stop.load(Ordering::Relaxed) {
-            println!("Keyboard backlight was changed, exiting");
-            std::process::exit(1)
-        }
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_keyboard_leds(&self, mode: &AuraModes) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Led",
-            Duration::from_secs(2),
-        );
-        proxy.set_led_mode(&serde_json::to_string(mode)?)?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn next_keyboard_led_mode(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Led",
-            Duration::from_secs(2),
-        );
-        proxy.next_led_mode()?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn prev_keyboard_led_mode(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Led",
-            Duration::from_secs(2),
-        );
-        proxy.prev_led_mode()?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn get_gfx_pwr(&self) -> Result<String, Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Gfx",
-            Duration::from_secs(2),
-        );
-        let x = proxy.power()?;
-        Ok(x)
-    }
-
-    #[inline]
-    pub fn get_gfx_mode(&self) -> Result<String, Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Gfx",
-            Duration::from_secs(2),
-        );
-        let x = proxy.vendor()?;
-        Ok(x)
-    }
-
-    #[inline]
-    pub fn write_gfx_mode(&self, vendor: String) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Gfx",
-            Duration::from_secs(30),
-        );
-        proxy.set_vendor(&vendor)?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn next_fan_profile(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Profile",
-            Duration::from_secs(2),
-        );
-        proxy.next_profile()?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_fan_mode(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Profile",
-            Duration::from_secs(2),
-        );
-        proxy.set_profile(&serde_json::to_string(&ProfileEvent::ChangeMode(level))?)?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_profile_command(
-        &self,
-        cmd: &ProfileEvent,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Profile",
-            Duration::from_secs(2),
-        );
-        proxy.set_profile(&serde_json::to_string(cmd)?)?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_charge_limit(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Charge",
-            Duration::from_secs(2),
-        );
-        proxy.set_limit(level)?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_builtin_mode(&self, mode: &AuraModes) -> Result<(), Box<dyn std::error::Error>> {
-        self.write_keyboard_leds(mode)
-    }
-
-    #[inline]
-    pub fn get_led_brightness(&self) -> Result<LedBrightness, Box<dyn Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Led",
-            Duration::from_secs(2),
-        );
-        match proxy.led_brightness()? {
-            -1 => Ok(LedBrightness::new(None)),
-            level => Ok(LedBrightness::new(Some(level as u8))),
-        }
-    }
-
-    #[inline]
-    pub fn write_brightness(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        self.write_keyboard_leds(&AuraModes::LedBrightness(level))?;
-        Ok(())
-    }
-
-    //
-    #[inline]
-    pub fn get_bios_dedicated_gfx(&self) -> Result<i16, Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/RogBios",
-            Duration::from_secs(2),
-        );
-        let x = proxy.dedicated_graphic_mode()?;
-        Ok(x)
-    }
-
-    #[inline]
-    pub fn set_bios_dedicated_gfx(&self, on: bool) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/RogBios",
-            Duration::from_secs(2),
-        );
-        proxy.set_dedicated_graphic_mode(<bool>::from(on))?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn get_bios_post_sound(&self) -> Result<i16, Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/RogBios",
-            Duration::from_secs(2),
-        );
-        let x = proxy.post_boot_sound()?;
-        Ok(x)
-    }
-
-    #[inline]
-    pub fn set_bios_post_sound(&self, on: bool) -> Result<(), Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/RogBios",
-            Duration::from_secs(2),
-        );
-        proxy.set_post_boot_sound(<bool>::from(on))?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn get_supported_functions(&self) -> Result<String, Box<dyn std::error::Error>> {
-        let proxy = self.connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Supported",
-            Duration::from_secs(2),
-        );
-        let x = proxy.supported_functions()?;
-        Ok(x)
-    }
-}

asus-nb/src/dbus_anime.rs

@@ -1,27 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -p /org/asuslinux/Anime -m None -f org.asuslinux.Daemon -c blocking`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_anime(&self, input: Vec<Vec<u8>>) -> Result<(), dbus::Error>;
-    fn set_on_off(&self, status: bool) -> Result<(), dbus::Error>;
-    fn set_boot_on_off(&self, status: bool) -> Result<(), dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn set_anime(&self, input: Vec<Vec<u8>>) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetAnime", (input,))
-    }
-
-    fn set_on_off(&self, status: bool) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetOnOff", (status,))
-    }
-
-    fn set_boot_on_off(&self, status: bool) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetBootOnOff", (status,))
-    }
-}

asus-nb/src/dbus_charge.rs

@@ -1,45 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Charge -m None`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_limit(&self, limit: u8) -> Result<(), dbus::Error>;
-    fn limit(&self) -> Result<i16, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn set_limit(&self, limit: u8) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetLimit", (limit,))
-    }
-
-    fn limit(&self) -> Result<i16, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Limit", ())
-            .and_then(|r: (i16,)| Ok(r.0))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyCharge {
-    pub limit: u8,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyCharge {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.limit, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyCharge {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyCharge { limit: i.read()? })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyCharge {
-    const NAME: &'static str = "NotifyCharge";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_gfx.rs

@@ -1,73 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -p /org/asuslinux/Gfx -m None -f org.asuslinux.Daemon -c blocking`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn vendor(&self) -> Result<String, dbus::Error>;
-    fn power(&self) -> Result<String, dbus::Error>;
-    fn set_vendor(&self, vendor: &str) -> Result<(), dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn vendor(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Vendor", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-
-    fn power(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Power", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-
-    fn set_vendor(&self, vendor: &str) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetVendor", (vendor,))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyGfx {
-    pub vendor: String,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyGfx {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.vendor, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyGfx {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyGfx { vendor: i.read()? })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyGfx {
-    const NAME: &'static str = "NotifyGfx";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyAction {
-    pub action: String,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyAction {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.action, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyAction {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyAction { action: i.read()? })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyAction {
-    const NAME: &'static str = "NotifyAction";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_ledmode.rs

@@ -1,67 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Led -m None`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_led_mode(&self, data: &str) -> Result<(), dbus::Error>;
-    fn next_led_mode(&self) -> Result<(), dbus::Error>;
-    fn prev_led_mode(&self) -> Result<(), dbus::Error>;
-    fn led_mode(&self) -> Result<String, dbus::Error>;
-    fn led_modes(&self) -> Result<String, dbus::Error>;
-    fn led_brightness(&self) -> Result<i16, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn set_led_mode(&self, data: &str) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetLedMode", (data,))
-    }
-
-    fn next_led_mode(&self) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "NextLedMode", ())
-    }
-
-    fn prev_led_mode(&self) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "PrevLedMode", ())
-    }
-
-    fn led_mode(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "LedMode", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-
-    fn led_modes(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "LedModes", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-
-    fn led_brightness(&self) -> Result<i16, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "LedBrightness", ())
-            .and_then(|r: (i16,)| Ok(r.0))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyLed {
-    pub data: String,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyLed {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.data, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyLed {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyLed { data: i.read()? })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyLed {
-    const NAME: &'static str = "NotifyLed";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_profile.rs

@@ -1,62 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -p /org/asuslinux/Profile -m None -f org.asuslinux.Daemon -c blocking`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_profile(&self, profile: &str) -> Result<(), dbus::Error>;
-    fn next_profile(&self) -> Result<(), dbus::Error>;
-    fn active_profile_name(&self) -> Result<String, dbus::Error>;
-    fn profile(&self) -> Result<String, dbus::Error>;
-    fn profiles(&self) -> Result<String, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn set_profile(&self, profile: &str) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetProfile", (profile,))
-    }
-
-    fn next_profile(&self) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "NextProfile", ())
-    }
-
-    fn active_profile_name(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "ActiveProfileName", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-
-    fn profile(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Profile", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-
-    fn profiles(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Profiles", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyProfile {
-    pub profile: String,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyProfile {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.profile, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyProfile {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyProfile { profile: i.read()? })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyProfile {
-    const NAME: &'static str = "NotifyProfile";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_rogbios.rs

@@ -1,86 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/RogBios -m None -o asus-nb/src/dbus_rogbios.rs`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_dedicated_graphic_mode(&self, dedicated: bool) -> Result<(), dbus::Error>;
-    fn dedicated_graphic_mode(&self) -> Result<i16, dbus::Error>;
-    fn set_post_boot_sound(&self, on: bool) -> Result<(), dbus::Error>;
-    fn post_boot_sound(&self) -> Result<i16, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn set_dedicated_graphic_mode(&self, dedicated: bool) -> Result<(), dbus::Error> {
-        self.method_call(
-            "org.asuslinux.Daemon",
-            "SetDedicatedGraphicMode",
-            (dedicated,),
-        )
-    }
-
-    fn dedicated_graphic_mode(&self) -> Result<i16, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "DedicatedGraphicMode", ())
-            .and_then(|r: (i16,)| Ok(r.0))
-    }
-
-    fn set_post_boot_sound(&self, on: bool) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetPostBootSound", (on,))
-    }
-
-    fn post_boot_sound(&self) -> Result<i16, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "PostBootSound", ())
-            .and_then(|r: (i16,)| Ok(r.0))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyDedicatedGraphicMode {
-    pub dedicated: bool,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyDedicatedGraphicMode {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.dedicated, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyDedicatedGraphicMode {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyDedicatedGraphicMode {
-            dedicated: i.read()?,
-        })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyDedicatedGraphicMode {
-    const NAME: &'static str = "NotifyDedicatedGraphicMode";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyPostBootSound {
-    pub dedicated: bool,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyPostBootSound {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.dedicated, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyPostBootSound {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyPostBootSound {
-            dedicated: i.read()?,
-        })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyPostBootSound {
-    const NAME: &'static str = "NotifyPostBootSound";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_supported.rs

@@ -1,18 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Supported -m None -o asus-nb/src/dbus_supported.rs`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn supported_functions(&self) -> Result<String, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn supported_functions(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SupportedFunctions", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-}

asus-nb/src/lib.rs

@@ -1,262 +0,0 @@
-pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
-pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
-pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
-pub const LED_MSG_LEN: usize = 17;
-
-pub mod aura_modes;
-use aura_modes::AuraModes;
-
-pub mod profile;
-
-/// Contains mostly only what is required for parsing CLI options
-pub mod cli_options;
-
-/// Enables you to create fancy RGB effects
-pub mod fancy;
-
-/// The main dbus group for system controls, e.g, fan control, keyboard LED's
-pub mod core_dbus;
-
-/// Specific dbus for writing to the AniMe Matrix display (if supported)
-pub mod anime_dbus;
-
-/// Helper functions for the AniMe display
-pub mod anime_matrix;
-
-pub mod error;
-
-pub mod dbus_anime;
-pub mod dbus_charge;
-pub mod dbus_gfx;
-pub mod dbus_ledmode;
-pub mod dbus_profile;
-pub mod dbus_rogbios;
-pub mod dbus_supported;
-
-// static LED_INIT1: [u8; 2] = [0x5d, 0xb9];
-// static LED_INIT2: &str = "]ASUS Tech.Inc."; // ] == 0x5d
-// static LED_INIT3: [u8; 6] = [0x5d, 0x05, 0x20, 0x31, 0, 0x08];
-// static LED_INIT4: &str = "^ASUS Tech.Inc."; // ^ == 0x5e
-// static LED_INIT5: [u8; 6] = [0x5e, 0x05, 0x20, 0x31, 0, 0x08];
-
-/// Writes aout the correct byte string for brightness
-///
-/// The HID descriptor looks like:
-///
-/// ```ignore
-/// 0x06, 0x31, 0xFF,  // Usage Page (Vendor Defined 0xFF31)
-/// 0x09, 0x76,        // Usage (0x76)
-/// 0xA1, 0x01,        // Collection (Application)
-/// 0x85, 0x5A,        //   Report ID (90)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x05,        //   Report Count (5)
-/// 0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0xB1, 0x00,        //   Feature (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0xC0,              // End Collection
-/// ```
-pub fn aura_brightness_bytes(brightness: u8) -> [u8; 17] {
-    // TODO: check brightness range
-    [
-        0x5A, 0xBA, 0xC5, 0xC4, brightness, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ]
-}
-
-/// Parses `AuraCommands` in to packet data
-///
-/// Byte structure:
-///
-/// ```ignore
-/// | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12|
-/// |---|---|---|---|---|---|---|---|---|---|---|---|---|
-/// |5d |b3 |00 |03 |ff |00 |00 |00 |00 |00 |00 |ff |00 |
-/// ```
-///
-/// Bytes 0 and 1 should always be 5d, b3
-///
-/// On multizone laptops byte 2 is the zone number, RGB in usual
-/// place, byte 3 set to zero
-///
-/// Byte 3 sets the mode type:
-/// - 00 = static
-/// - 01 = breathe (can set two colours)
-/// - 02 = strobe (through all colours)
-/// - 03 = rainbow
-/// - 04 = star (byte 9 sets rain colour)
-/// - 05 = rain keys, red, white, turquoise
-/// - 06 = pressed keys light up and fade
-/// - 07 = pressed key emits laser
-/// - 08 = pressed key emits water ripple
-/// - 09 = no effect/not used
-/// - 0a fast pulse (no speed setting)
-/// - 0b vertical line racing to right (no speed setting)
-/// - 0c wider vertical line racing to right (no speed setting)
-///
-/// Bytes 4, 5, 6 are Red, Green, Blue
-///
-/// Byte 7 sets speed from
-/// - 0x00 = Off
-/// - 0xe1 = Slow
-/// - 0xeb = Medium
-/// - 0xf5 = Fast
-///
-/// Byte 8 sets rainbow direction:
-/// - 0x00 = rightwards
-/// - 0x01 = leftwards
-/// - 0x02 = upwards
-/// - 0x03 = downwards
-///
-/// Bytes 10, 11, 12 are Red, Green, Blue for second colour if mode supports it
-///
-/// The HID descriptor looks like:
-/// ```ignore
-/// 0x06, 0x31, 0xFF,  // Usage Page (Vendor Defined 0xFF31)
-/// 0x09, 0x79,        // Usage (0x79)
-/// 0xA1, 0x01,        // Collection (Application)
-/// 0x85, 0x5D,        //   Report ID (93)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x1F,        //   Report Count (31)
-/// 0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0x91, 0x00,        //   Output (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0xB1, 0x00,        //   Feature (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0xC0,              // End Collection
-/// ```
-///
-/// This descriptor is also used for the per-key LED settings
-impl From<&AuraModes> for [u8; LED_MSG_LEN] {
-    fn from(mode: &AuraModes) -> Self {
-        let mut msg = [0u8; LED_MSG_LEN];
-        msg[0] = 0x5d;
-        msg[1] = 0xb3;
-        match mode {
-            AuraModes::LedBrightness(n) => return aura_brightness_bytes(*n),
-            AuraModes::Static(_) => msg[3] = 0x00,
-            AuraModes::Breathe(_) => msg[3] = 0x01,
-            AuraModes::Strobe(_) => msg[3] = 0x02,
-            AuraModes::Rainbow(_) => msg[3] = 0x03,
-            AuraModes::Star(_) => msg[3] = 0x04,
-            AuraModes::Rain(_) => msg[3] = 0x05,
-            AuraModes::Highlight(_) => msg[3] = 0x06,
-            AuraModes::Laser(_) => msg[3] = 0x07,
-            AuraModes::Ripple(_) => msg[3] = 0x08,
-            AuraModes::Pulse(_) => msg[3] = 0x0a,
-            AuraModes::Comet(_) => msg[3] = 0x0b,
-            AuraModes::Flash(_) => msg[3] = 0x0c,
-            _ => panic!("Mode not convertable to 1D array: {}", <&str>::from(mode)),
-        }
-
-        match mode {
-            AuraModes::Rainbow(settings) => {
-                msg[7] = settings.speed as u8;
-                msg[8] = settings.direction as u8;
-            }
-            AuraModes::Star(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-                msg[9] = settings.colour2.2;
-            }
-            AuraModes::Breathe(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-                msg[10] = settings.colour2.0;
-                msg[11] = settings.colour2.1;
-                msg[12] = settings.colour2.2;
-            }
-            AuraModes::Strobe(settings) | AuraModes::Rain(settings) => {
-                msg[7] = settings.speed as u8;
-            }
-            AuraModes::Highlight(settings)
-            | AuraModes::Laser(settings)
-            | AuraModes::Ripple(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-            }
-            AuraModes::Static(settings)
-            | AuraModes::Pulse(settings)
-            | AuraModes::Comet(settings)
-            | AuraModes::Flash(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-            }
-            _ => panic!("Mode not convertable to 1D array: {}", <&str>::from(mode)),
-        }
-        msg
-    }
-}
-
-impl From<AuraModes> for [u8; LED_MSG_LEN] {
-    #[inline]
-    fn from(mode: AuraModes) -> Self {
-        <[u8; LED_MSG_LEN]>::from(&mode)
-    }
-}
-
-impl From<AuraModes> for [[u8; LED_MSG_LEN]; 4] {
-    #[inline]
-    fn from(mode: AuraModes) -> Self {
-        <[[u8; LED_MSG_LEN]; 4]>::from(&mode)
-    }
-}
-
-impl From<&AuraModes> for [[u8; LED_MSG_LEN]; 4] {
-    #[inline]
-    fn from(mode: &AuraModes) -> Self {
-        let mut msg = [[0u8; LED_MSG_LEN]; 4];
-        for (i, row) in msg.iter_mut().enumerate() {
-            row[0] = 0x5d;
-            row[1] = 0xb3;
-            row[2] = i as u8 + 1;
-        }
-
-        match mode {
-            AuraModes::MultiStatic(settings) => {
-                msg[0][4] = settings.colour1.0;
-                msg[0][5] = settings.colour1.1;
-                msg[0][6] = settings.colour1.2;
-                msg[1][4] = settings.colour2.0;
-                msg[1][5] = settings.colour2.1;
-                msg[1][6] = settings.colour2.2;
-                msg[2][4] = settings.colour3.0;
-                msg[2][5] = settings.colour3.1;
-                msg[2][6] = settings.colour3.2;
-                msg[3][4] = settings.colour4.0;
-                msg[3][5] = settings.colour4.1;
-                msg[3][6] = settings.colour4.2;
-            }
-            _ => panic!("Mode not convertable to 2D array: {}", <&str>::from(mode)),
-        }
-        msg
-    }
-}

asus-notify/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asus-notify"
-version = "2.0.4"
+version = "3.0.0"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 
@@ -8,14 +8,11 @@ edition = "2018"
 
 [dependencies]
 # serialisation
-serde = "^1.0"
-serde_derive = "^1.0"
 serde_json = "^1.0"
-dbus = { version = "^0.8" }
-asus-nb = { path = "../asus-nb" }
-asus-nb-ctrl = { path = "../asus-nb-ctrl" }
+rog_dbus = { path = "../rog-dbus" }
+daemon = { path = "../daemon" }
 
 [dependencies.notify-rust]
-version = "^4.0.0"
+version = "^4.0"
 default-features = false
 features = ["z"]

asus-notify/src/main.rs

@@ -1,74 +1,80 @@
-use asus_nb::core_dbus::CtrlSignals;
-use daemon::config::{Config, Profile};
-use dbus::blocking::Connection;
+use daemon::config::Profile;
 use notify_rust::{Hint, Notification, NotificationHandle};
+use rog_dbus::{DbusProxies, Signals};
 use std::error::Error;
 use std::time::Duration;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("Version {}", env!("CARGO_PKG_VERSION"));
+    println!("asus-notify version {}", env!("CARGO_PKG_VERSION"));
+    println!("     daemon version {}", daemon::VERSION);
+    println!("   rog-dbus version {}", rog_dbus::VERSION);
 
-    let mut cfg = Config::read_new()?;
-    let mut last_profile = String::new();
+    // let mut cfg = Config::read_new()?;
+    // let mut last_profile = String::new();
 
-    let connection = Connection::new_system()?;
-    let signals = CtrlSignals::new(&connection)?;
+    let (proxies, conn) = DbusProxies::new()?;
+    let signals = Signals::new(&proxies)?;
 
     let mut last_profile_notif: Option<NotificationHandle> = None;
     let mut last_led_notif: Option<NotificationHandle> = None;
     let mut last_gfx_notif: Option<NotificationHandle> = None;
     let mut last_chrg_notif: Option<NotificationHandle> = None;
 
+    let recv = proxies.setup_recv(conn);
     loop {
         std::thread::sleep(Duration::from_millis(100));
-        connection.process(std::time::Duration::from_millis(200))?;
+        recv.next_signal().unwrap();
 
-        if let Ok(mut lock) = signals.gfx_vendor_signal.lock() {
+        if let Ok(mut lock) = signals.gfx_vendor.lock() {
             if let Some(vendor) = lock.take() {
                 if let Some(notif) = last_gfx_notif.take() {
                     notif.close();
                 }
-                let x = do_notif(&format!("Graphics mode changed to {}", vendor))?;
+                let x = do_notif(&format!(
+                    "Graphics mode changed to {}",
+                    <&str>::from(vendor)
+                ))?;
                 last_gfx_notif = Some(x);
             }
         }
 
-        if let Ok(mut lock) = signals.charge_signal.lock() {
+        if let Ok(mut lock) = signals.charge.lock() {
             if let Some(limit) = lock.take() {
                 if let Some(notif) = last_chrg_notif.take() {
                     notif.close();
                 }
                 let x = do_notif(&format!("Battery charge limit changed to {}", limit))?;
-                last_led_notif = Some(x);
+                last_chrg_notif = Some(x);
             }
         }
 
-        if let Ok(mut lock) = signals.ledmode_signal.lock() {
+        if let Ok(mut lock) = signals.profile.lock() {
+            if let Some(profile) = lock.take() {
+                if let Some(notif) = last_profile_notif.take() {
+                    notif.close();
+                }
+                if let Ok(profile) = serde_json::from_str(&profile) {
+                    let profile: Profile = profile;
+                    if let Ok(name) = proxies.profile().active_profile_name() {
+                        let x = do_thermal_notif(&profile, &name)?;
+                        last_profile_notif = Some(x);
+                    }
+                }
+            }
+        }
+
+        if let Ok(mut lock) = signals.led_mode.lock() {
             if let Some(ledmode) = lock.take() {
                 if let Some(notif) = last_led_notif.take() {
                     notif.close();
                 }
                 let x = do_notif(&format!(
                     "Keyboard LED mode changed to {}",
-                    <&str>::from(&ledmode)
+                    ledmode.mode_name()
                 ))?;
                 last_led_notif = Some(x);
             }
         }
-
-        // We need to do the config read because of a limitation preventing
-        // easy dbus notification from the profile controller
-        cfg.read();
-        if last_profile != cfg.active_profile {
-            if let Some(notif) = last_profile_notif.take() {
-                notif.close();
-            }
-            if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                let x = do_thermal_notif(&profile, &cfg.active_profile)?;
-                last_profile_notif = Some(x);
-                last_profile = cfg.active_profile.clone();
-            }
-        }
     }
 }
 

asusctl/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "asusctl"
+version = "3.1.4"
+authors = ["Luke D Jones <luke@ljones.dev>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# serialisation
+serde_json = "^1.0"
+rog_dbus = { path = "../rog-dbus" }
+rog_types = { path = "../rog-types" }
+daemon = { path = "../daemon" }
+gumdrop = "^0.8"
+yansi-term = "^0.1"
+
+
+[dev-dependencies]
+tinybmp = "^0.2.3"
+rog_dbus = { path = "../rog-dbus" }

asusctl/examples/animatrix.rs

@@ -1,9 +1,9 @@
-use asus_nb::anime_dbus::AniMeDbusWriter;
-use asus_nb::anime_matrix::{AniMeMatrix, AniMePacketType, HEIGHT, WIDTH};
+use rog_dbus::AuraDbusClient;
+use rog_types::anime_matrix::{AniMeImageBuffer, AniMePacketType, HEIGHT, WIDTH};
 use tinybmp::{Bmp, Pixel};
 
 fn main() {
-    let mut writer = AniMeDbusWriter::new().unwrap();
+    let (client, _) = AuraDbusClient::new().unwrap();
 
     let bmp =
         Bmp::from_slice(include_bytes!("non-skewed_r.bmp")).expect("Failed to parse BMP image");
@@ -11,7 +11,7 @@ fn main() {
     //assert_eq!(pixels.len(), 56 * 56);
 
     // Try an outline, top and right
-    let mut matrix = AniMeMatrix::new();
+    let mut matrix = AniMeImageBuffer::new();
 
     // Aligned left
     for (i, px) in pixels.iter().enumerate() {
@@ -38,5 +38,5 @@ fn main() {
     // println!("{:?}", matrix[0].to_vec());
     // println!("{:?}", matrix[1].to_vec());
 
-    writer.write_image(&mut matrix).unwrap();
+    //client.proxies().anime().set_brightness(&mut matrix).unwrap();
 }

asusctl/examples/ball.rs

@@ -1,7 +1,5 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, Key, KeyColourArray, KeyLayout},
-};
+use rog_dbus::AuraDbusClient;
+use rog_types::aura_perkey::{GX502Layout, Key, KeyColourArray, KeyLayout};
 use std::collections::LinkedList;
 
 #[derive(Debug, Clone)]
@@ -54,7 +52,7 @@ impl Ball {
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
+    let (dbus, _) = AuraDbusClient::new()?;
 
     let mut colours = KeyColourArray::new();
 
@@ -62,7 +60,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut balls = [Ball::new(2, 1, 12), Ball::new(4, 6, 12)];
 
-    writer.init_effect()?;
+    dbus.proxies().led().init_effect()?;
 
     let rows = layout.get_rows();
     loop {
@@ -89,10 +87,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 *c.2 = 255;
             };
         }
+        dbus.proxies().led().set_per_key(&colours)?;
 
-        writer.write_colour_block(&colours)?;
-
-        // can change 100 times per second, so need to slow it down
-        std::thread::sleep(std::time::Duration::from_millis(30));
+        std::thread::sleep(std::time::Duration::from_millis(10));
     }
 }

asusctl/examples/comet.rs

@@ -1,14 +1,12 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, KeyColourArray, KeyLayout},
-};
+use rog_dbus::AuraDbusClient;
+use rog_types::aura_perkey::{GX502Layout, KeyColourArray, KeyLayout};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
+    let (dbus, _) = AuraDbusClient::new()?;
 
     let layout = GX502Layout::default();
 
-    writer.init_effect()?;
+    dbus.proxies().led().init_effect()?;
     let rows = layout.get_rows();
 
     let mut column = 0;
@@ -25,7 +23,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             column += 1;
         }
 
-        writer.write_colour_block(&key_colours)?;
-        std::thread::sleep(std::time::Duration::from_millis(30));
+        dbus.proxies().led().set_per_key(&key_colours)?;
     }
 }

asusctl/examples/iterate-keys.rs

@@ -1,15 +1,13 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, Key, KeyColourArray, KeyLayout},
-};
+use rog_dbus::AuraDbusClient;
+use rog_types::aura_perkey::{GX502Layout, Key, KeyColourArray, KeyLayout};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
+    let (dbus, _) = AuraDbusClient::new()?;
 
     let mut key_colours = KeyColourArray::new();
     let layout = GX502Layout::default();
 
-    writer.init_effect()?;
+    dbus.proxies().led().init_effect()?;
     let rows = layout.get_rows();
     loop {
         for (r, row) in rows.iter().enumerate() {
@@ -48,7 +46,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 *key_colours.key(Key::S).unwrap().0 = 255;
                 *key_colours.key(Key::D).unwrap().0 = 255;
 
-                writer.write_colour_block(&key_colours)?;
+                dbus.proxies().led().set_per_key(&key_colours)?;
                 std::thread::sleep(std::time::Duration::from_millis(100));
             }
         }

asusctl/examples/per-key-effect-2.rs

@@ -1,14 +1,12 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{Key, KeyColourArray},
-};
+use rog_dbus::AuraDbusClient;
+use rog_types::aura_perkey::{Key, KeyColourArray};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
+    let (dbus, _) = AuraDbusClient::new()?;
 
     let mut key_colours = KeyColourArray::new();
 
-    writer.init_effect()?;
+    dbus.proxies().led().init_effect()?;
     loop {
         let count = 49;
         for _ in 0..count {
@@ -18,7 +16,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             *key_colours.key(Key::N).unwrap().0 += 5;
             *key_colours.key(Key::U).unwrap().0 += 5;
             *key_colours.key(Key::X).unwrap().0 += 5;
-            writer.write_colour_block(&key_colours)?;
+            dbus.proxies().led().set_per_key(&key_colours)?;
         }
         for _ in 0..count {
             *key_colours.key(Key::ROG).unwrap().0 -= 5;
@@ -27,7 +25,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             *key_colours.key(Key::N).unwrap().0 -= 5;
             *key_colours.key(Key::U).unwrap().0 -= 5;
             *key_colours.key(Key::X).unwrap().0 -= 5;
-            writer.write_colour_block(&key_colours)?;
+            dbus.proxies().led().set_per_key(&key_colours)?;
         }
     }
 }

asusctl/examples/pulser.rs

@@ -1,15 +1,13 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, KeyColourArray, KeyLayout},
-};
+use rog_dbus::AuraDbusClient;
+use rog_types::aura_perkey::{GX502Layout, KeyColourArray, KeyLayout};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
+    let (dbus, _) = AuraDbusClient::new()?;
 
     let mut key_colours = KeyColourArray::new();
     let layout = GX502Layout::default();
 
-    writer.init_effect()?;
+    dbus.proxies().led().init_effect()?;
     let rows = layout.get_rows();
 
     let mut fade = 50;
@@ -23,7 +21,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
         }
 
-        writer.write_colour_block(&key_colours)?;
+        dbus.proxies().led().set_per_key(&key_colours)?;
 
         if flip {
             if fade > 1 {

asusctl/src/aura_cli.rs

@@ -0,0 +1,330 @@
+use gumdrop::Options;
+use rog_types::{
+    aura_modes::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed},
+    error::AuraError,
+};
+use std::str::FromStr;
+
+#[derive(Options)]
+pub struct LedBrightness {
+    level: Option<u32>,
+}
+impl LedBrightness {
+    pub fn new(level: Option<u32>) -> Self {
+        LedBrightness { level }
+    }
+
+    pub fn level(&self) -> Option<u32> {
+        self.level
+    }
+}
+impl FromStr for LedBrightness {
+    type Err = AuraError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.as_str() {
+            "off" => Ok(LedBrightness { level: Some(0x00) }),
+            "low" => Ok(LedBrightness { level: Some(0x01) }),
+            "med" => Ok(LedBrightness { level: Some(0x02) }),
+            "high" => Ok(LedBrightness { level: Some(0x03) }),
+            _ => {
+                print!("Invalid argument, must be one of: off, low, med, high");
+                Err(AuraError::ParseBrightness)
+            }
+        }
+    }
+}
+impl ToString for LedBrightness {
+    fn to_string(&self) -> String {
+        let s = match self.level {
+            Some(0x00) => "low",
+            Some(0x01) => "med",
+            Some(0x02) => "high",
+            _ => "unknown",
+        };
+        s.to_string()
+    }
+}
+
+#[derive(Debug, Clone, Options, Default)]
+pub struct SingleSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+}
+#[derive(Debug, Clone, Options, Default)]
+pub struct SingleSpeedDirection {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the direction: up, down, left, right")]
+    pub direction: Direction,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct SingleColour {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour: Colour,
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct SingleColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour: Colour,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+}
+
+#[derive(Debug, Clone, Options, Default)]
+pub struct TwoColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the first RGB value e.g, ff00ff")]
+    pub colour: Colour,
+    #[options(no_long, meta = "", help = "set the second RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct MultiColour {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour1: Colour,
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour3: Colour,
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour4: Colour,
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct MultiColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour1: Colour,
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour3: Colour,
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour4: Colour,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+}
+
+/// Byte value for setting the built-in mode.
+///
+/// Enum corresponds to the required integer value
+#[derive(Options)]
+pub enum SetAuraBuiltin {
+    #[options(help = "set a single static colour")]
+    Static(SingleColour),
+    #[options(help = "pulse between one or two colours")]
+    Breathe(TwoColourSpeed),
+    #[options(help = "strobe through all colours")]
+    Strobe(SingleSpeed),
+    #[options(help = "rainbow cycling in one of four directions")]
+    Rainbow(SingleSpeedDirection),
+    #[options(help = "rain pattern mimicking raindrops")]
+    Star(TwoColourSpeed),
+    #[options(help = "rain pattern of three preset colours")]
+    Rain(SingleSpeed),
+    #[options(help = "pressed keys are highlighted to fade")]
+    Highlight(SingleColourSpeed),
+    #[options(help = "pressed keys generate horizontal laser")]
+    Laser(SingleColourSpeed),
+    #[options(help = "pressed keys ripple outwards like a splash")]
+    Ripple(SingleColourSpeed),
+    #[options(help = "set a rapid pulse")]
+    Pulse(SingleColour),
+    #[options(help = "set a vertical line zooming from left")]
+    Comet(SingleColour),
+    #[options(help = "set a wide vertical line zooming from left")]
+    Flash(SingleColour),
+    #[options(help = "4-zone multi-colour")]
+    MultiStatic(MultiColour),
+    #[options(help = "4-zone multi-colour breathing")]
+    MultiBreathe(MultiColourSpeed),
+}
+
+impl Default for SetAuraBuiltin {
+    fn default() -> Self {
+        SetAuraBuiltin::Static(SingleColour::default())
+    }
+}
+
+impl From<&SingleColour> for AuraEffect {
+    fn from(aura: &SingleColour) -> Self {
+        Self {
+            colour1: aura.colour,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleSpeed> for AuraEffect {
+    fn from(aura: &SingleSpeed) -> Self {
+        Self {
+            speed: aura.speed,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleColourSpeed> for AuraEffect {
+    fn from(aura: &SingleColourSpeed) -> Self {
+        Self {
+            colour1: aura.colour,
+            speed: aura.speed,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&TwoColourSpeed> for AuraEffect {
+    fn from(aura: &TwoColourSpeed) -> Self {
+        Self {
+            colour1: aura.colour,
+            colour2: aura.colour2,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleSpeedDirection> for AuraEffect {
+    fn from(aura: &SingleSpeedDirection) -> Self {
+        Self {
+            speed: aura.speed,
+            direction: aura.direction,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SetAuraBuiltin> for AuraEffect {
+    fn from(aura: &SetAuraBuiltin) -> Self {
+        match aura {
+            SetAuraBuiltin::Static(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Static;
+                data
+            }
+            SetAuraBuiltin::Breathe(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Breathe;
+                data
+            }
+            SetAuraBuiltin::Strobe(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Strobe;
+                data
+            }
+            SetAuraBuiltin::Rainbow(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Rainbow;
+                data
+            }
+            SetAuraBuiltin::Star(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Star;
+                data
+            }
+            SetAuraBuiltin::Rain(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Rain;
+                data
+            }
+            SetAuraBuiltin::Highlight(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Highlight;
+                data
+            }
+            SetAuraBuiltin::Laser(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Laser;
+                data
+            }
+            SetAuraBuiltin::Ripple(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Ripple;
+                data
+            }
+            SetAuraBuiltin::Pulse(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Pulse;
+                data
+            }
+            SetAuraBuiltin::Comet(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Comet;
+                data
+            }
+            SetAuraBuiltin::Flash(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Flash;
+                data
+            }
+            _ => AuraEffect::default(),
+        }
+    }
+}
+
+impl From<&SetAuraBuiltin> for Vec<AuraEffect> {
+    fn from(aura: &SetAuraBuiltin) -> Vec<AuraEffect> {
+        let mut zones = vec![AuraEffect::default(); 4];
+        match aura {
+            SetAuraBuiltin::MultiStatic(data) => {
+                zones[0].mode = AuraModeNum::Static;
+                zones[0].zone = AuraZone::One;
+                zones[0].colour1 = data.colour1;
+
+                zones[1].mode = AuraModeNum::Static;
+                zones[1].zone = AuraZone::Two;
+                zones[1].colour1 = data.colour2;
+
+                zones[2].mode = AuraModeNum::Static;
+                zones[2].zone = AuraZone::Three;
+                zones[2].colour1 = data.colour3;
+
+                zones[3].mode = AuraModeNum::Static;
+                zones[3].zone = AuraZone::Four;
+                zones[3].colour1 = data.colour4;
+            }
+            SetAuraBuiltin::MultiBreathe(data) => {
+                zones[0].mode = AuraModeNum::Breathe;
+                zones[0].zone = AuraZone::One;
+                zones[0].colour1 = data.colour1;
+                zones[0].speed = data.speed;
+
+                zones[1].mode = AuraModeNum::Breathe;
+                zones[1].zone = AuraZone::Two;
+                zones[1].colour1 = data.colour2;
+                zones[1].speed = data.speed;
+
+                zones[2].mode = AuraModeNum::Breathe;
+                zones[2].zone = AuraZone::Three;
+                zones[2].colour1 = data.colour3;
+                zones[2].speed = data.speed;
+
+                zones[3].mode = AuraModeNum::Breathe;
+                zones[3].zone = AuraZone::Four;
+                zones[3].colour1 = data.colour4;
+                zones[3].speed = data.speed;
+            }
+            _ => {}
+        }
+        zones
+    }
+}

asusctl/src/main.rs

@@ -0,0 +1,479 @@
+mod aura_cli;
+
+use crate::aura_cli::{LedBrightness, SetAuraBuiltin};
+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::{anime_matrix::{AniMeDataBuffer, FULL_PANE_LEN}, aura_modes::{self, AuraEffect, AuraModeNum}, cli_options::{AniMeActions, AniMeStatusValue}, gfx_vendors::GfxVendors, profile::{FanLevel, ProfileCommand, ProfileEvent}};
+use std::env::args;
+use yansi_term::Colour::Green;
+use yansi_term::Colour::Red;
+
+#[derive(Default, Options)]
+struct CLIStart {
+    #[options(help_flag, help = "print help message")]
+    help: bool,
+    #[options(help = "show program version number")]
+    version: bool,
+    #[options(help = "show supported functions of this laptop")]
+    show_supported: bool,
+    #[options(meta = "", help = "<off, low, med, high>")]
+    kbd_bright: Option<LedBrightness>,
+    #[options(
+        meta = "",
+        help = "<silent, normal, boost>, set fan mode independent of profile"
+    )]
+    fan_mode: Option<FanLevel>,
+    #[options(meta = "", help = "<20-100>")]
+    chg_limit: Option<u8>,
+    #[options(command)]
+    command: Option<CliCommand>,
+}
+
+#[derive(Options)]
+enum CliCommand {
+    #[options(help = "Set the keyboard lighting from built-in modes")]
+    LedMode(LedModeCommand),
+    #[options(help = "Create and configure profiles")]
+    Profile(ProfileCommand),
+    #[options(help = "Set the graphics mode")]
+    Graphics(GraphicsCommand),
+    #[options(name = "anime", help = "Manage AniMe Matrix")]
+    AniMe(AniMeCommand),
+    #[options(help = "Change bios settings")]
+    Bios(BiosCommand),
+}
+
+#[derive(Options)]
+struct LedModeCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(help = "switch to next aura mode")]
+    next_mode: bool,
+    #[options(help = "switch to previous aura mode")]
+    prev_mode: bool,
+    #[options(command)]
+    command: Option<SetAuraBuiltin>,
+}
+
+#[derive(Options)]
+struct GraphicsCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(
+        meta = "",
+        help = "Set graphics mode: <nvidia, hybrid, compute, integrated>"
+    )]
+    mode: Option<GfxVendors>,
+    #[options(help = "Get the current mode")]
+    get: bool,
+    #[options(help = "Get the current power status")]
+    pow: bool,
+    #[options(help = "Do not ask for confirmation")]
+    force: bool,
+}
+
+#[derive(Options)]
+struct AniMeCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(
+        meta = "",
+        help = "turn on/off the panel (accept/reject write requests)"
+    )]
+    turn: Option<AniMeStatusValue>,
+    #[options(meta = "", help = "turn on/off the panel at boot (with Asus effect)")]
+    boot: Option<AniMeStatusValue>,
+    #[options(command)]
+    command: Option<AniMeActions>,
+}
+
+#[derive(Options, Debug)]
+struct BiosCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[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 = "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 args: Vec<String> = args().skip(1).collect();
+
+    let parsed: CLIStart;
+    let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
+    match CLIStart::parse_args_default(&args) {
+        Ok(p) => {
+            parsed = p;
+        }
+        Err(err) if err.to_string() == missing_argument_k.to_string() => {
+            parsed = CLIStart {
+                kbd_bright: Some(LedBrightness::new(None)),
+                ..Default::default()
+            };
+        }
+        Err(err) => {
+            eprintln!("source {}", err);
+            std::process::exit(2);
+        }
+    }
+
+    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 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(());
+    }
+
+    match parsed.command {
+        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());
+                if let Some(lst) = cmd.self_command_list() {
+                    println!("\n{}", lst);
+                }
+            }
+            if let Some(anime_turn) = cmd.turn {
+                dbus.proxies().anime().toggle_on(anime_turn.into())?
+            }
+            if let Some(anime_boot) = cmd.boot {
+                dbus.proxies().anime().toggle_boot_on(anime_boot.into())?
+            }
+            if let Some(action) = cmd.command {
+                match action {
+                    AniMeActions::Leds(anime_leds) => {
+                        let mut data = AniMeDataBuffer::new();
+                        data.set([anime_leds.led_brightness(); FULL_PANE_LEN]);
+                        dbus.proxies().anime().write_direct(data)?;
+                    }
+                }
+            }
+        }
+        Some(CliCommand::Bios(cmd)) => handle_bios_option(&dbus, &supported.rog_bios_ctrl, &cmd)?,
+        None => {
+            if (!parsed.show_supported
+                && parsed.kbd_bright.is_none()
+                && parsed.fan_mode.is_none()
+                && parsed.chg_limit.is_none())
+                || parsed.help
+            {
+                println!("{}", CLIStart::usage());
+                println!();
+                println!("{}", CLIStart::command_list().unwrap());
+            }
+        }
+    }
+
+    if let Some(brightness) = parsed.kbd_bright {
+        match brightness.level() {
+            None => {
+                let level = dbus.proxies().led().get_led_brightness()?;
+                println!("Current keyboard led brightness: {}", level.to_string());
+            }
+            Some(level) => dbus.proxies().led().set_led_brightness(<aura_modes::LedBrightness>::from(level))?,
+        }
+    }
+
+    if parsed.show_supported {
+        let dat = dbus.proxies().supported().get_supported_functions()?;
+        println!("Supported laptop functions:\n{}", dat);
+    }
+
+    if let Some(fan_level) = parsed.fan_mode {
+        dbus.proxies().profile().write_fan_mode(fan_level.into())?;
+    }
+    if let Some(chg_limit) = parsed.chg_limit {
+        dbus.proxies().charge().write_limit(chg_limit)?;
+    }
+    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,
+) -> 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 && 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!("If anything fails check `journalctl -b -u asusd`\n");
+
+        dbus.proxies().gfx().gfx_write_mode(&mode).map_err(|err|{
+            println!("Graphics mode change error. You may be in an invalid state.");
+            println!("Check mode with `asusctl graphics -g` and switch to opposite\nmode to correct it, e.g: if integrated, switch to hybrid, or if nvidia, switch to integrated.\n");
+            err
+        })?;
+        let res = dbus.gfx_wait_changed()?;
+        println!(
+            "Graphics mode changed to {}. User action required is: {}",
+            <&str>::from(mode),
+            <&str>::from(&res)
+        );
+        std::process::exit(0)
+    }
+    if command.get {
+        let res = dbus.proxies().gfx().gfx_get_mode()?;
+        println!("Current graphics mode: {}", <&str>::from(res));
+    }
+    if command.pow {
+        let res = dbus.proxies().gfx().gfx_get_pwr()?;
+        if res.contains("active") {
+            println!("Current power status: {}", Red.paint(&res));
+        } else {
+            println!("Current power status: {}", Green.paint(&res));
+        }
+    }
+    Ok(())
+}
+
+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().filter(|mode| {
+            if let Some(modes) = supported.stock_led_modes.as_ref() {
+                return modes.contains(&<AuraModeNum>::from(mode.as_str()));
+            }
+            if supported.multizone_led_mode {
+                return true;
+            }
+            false
+        }) {
+            println!("{}", command);
+        }
+
+        println!("\nHelp can also be requested on modes, e.g: static --help");
+        return Ok(());
+    }
+
+    if mode.next_mode && mode.prev_mode {
+        println!("Please specify either next or previous");
+        return Ok(());
+    }
+    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(mode) = mode.command.as_ref() {
+        if mode.help_requested() {
+            println!("{}", mode.self_usage());
+            return Ok(());
+        }
+        match mode {
+            SetAuraBuiltin::MultiStatic(_) | SetAuraBuiltin::MultiBreathe(_) => {
+                let zones = <Vec<AuraEffect>>::from(mode);
+                for eff in zones {
+                    dbus.proxies().led().set_led_mode(&eff)?
+                }
+            }
+            _ => dbus
+                .proxies()
+                .led()
+                .set_led_mode(&<AuraEffect>::from(mode))?,
+        }
+    }
+    Ok(())
+}
+
+fn handle_profile(
+    dbus: &AuraDbusClient,
+    supported: &FanCpuSupportedFunctions,
+    cmd: &ProfileCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !cmd.next
+        && !cmd.create
+        && !cmd.list
+        && cmd.remove.is_none()
+        && 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 if cmd.list {
+        let profile_names = dbus.proxies().profile().profile_names()?;
+        println!("Available profiles are {}", profile_names);
+    } else if let Some(profile) = &cmd.remove {
+        dbus.proxies().profile().remove(profile)?
+    } 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 = dbus.proxies().rog_bios().get_post_sound()? == 1;
+            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 = dbus.proxies().rog_bios().get_dedicated_gfx()? == 1;
+            println!("Bios dedicated GPU on: {}", res);
+        }
+    }
+    Ok(())
+}

daemon/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "asus-nb-ctrl"
-version = "2.2.1"
+name = "daemon"
+version = "3.2.1"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -13,37 +13,32 @@ edition = "2018"
 name = "daemon"
 path = "src/lib.rs"
 
-[[bin]]
-name = "asusctl"
-path = "src/main.rs"
-
 [[bin]]
 name = "asusd"
 path = "src/daemon.rs"
 
 [dependencies]
-asus-nb = { path = "../asus-nb" }
-rusb = "^0.6.0"
-udev = "^0.4.0"
+rog_types = { path = "../rog-types" }
+rog_dbus = { path = "../rog-dbus" }
+rusb = "^0.7"
+udev = "^0.6"
 
 # cli and logging
-gumdrop = "^0.8.0"
-log = "^0.4.8"
-env_logger = "^0.7.1"
+log = "^0.4"
+env_logger = "^0.8"
 
-zbus = "^1.8.0"
-zvariant = "^2.4.0"
+zbus = "^2.0.0-beta.3"
+zvariant = "^2.5"
+logind-zbus = "*"
 
 # serialisation
 serde = "^1.0"
 serde_derive = "^1.0"
 serde_json = "^1.0"
-toml = "0.4.6"
+toml = "^0.5"
 
 # Device control
 sysfs-class = "^0.1.2" # used for backlight control and baord ID
-rog_fan_curve = { version = "0.1.5", features = ["serde"] }
+rog_fan_curve = { version = "0.1", features = ["serde"] }
 # cpu power management
-intel-pstate = "^0.2.1"
-
-yansi-term = "^0.1"
+intel-pstate = "^0.2"

daemon/src/config.rs

@@ -1,81 +1,84 @@
-use asus_nb::aura_modes::AuraModes;
 use log::{error, info, warn};
 use rog_fan_curve::Curve;
+use rog_types::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";
+pub static AURA_CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
 
-/// for parsing old v2.1.2 config
-#[derive(Deserialize)]
-struct ConfigV212 {
-    gfx_managed: bool,
-    active_profile: String,
-    toggle_profiles: Vec<String>,
-    // TODO: remove power_profile
-    power_profile: u8,
-    bat_charge_limit: u8,
-    kbd_led_brightness: u8,
-    kbd_backlight_mode: u8,
-    kbd_backlight_modes: Vec<AuraModes>,
-    power_profiles: BTreeMap<String, Profile>,
+#[derive(Deserialize, Serialize)]
+pub struct Config {
+    pub gfx_mode: GfxVendors,
+    pub gfx_managed: bool,
+    pub active_profile: String,
+    pub toggle_profiles: Vec<String>,
+    #[serde(skip)]
+    pub curr_fan_mode: u8,
+    pub bat_charge_limit: u8,
+    pub power_profiles: BTreeMap<String, Profile>,
 }
 
-impl ConfigV212 {
-    fn into_current(self) -> Config {
+impl Default for Config {
+    fn default() -> Self {
+        let mut pwr = BTreeMap::new();
+        pwr.insert("normal".into(), Profile::new(0, 100, true, 0, None));
+        pwr.insert("boost".into(), Profile::new(0, 100, true, 1, None));
+        pwr.insert("silent".into(), Profile::new(0, 100, true, 2, None));
+
         Config {
-            gfx_managed: self.gfx_managed,
-            gfx_nv_mode_is_dedicated: true,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            power_profile: 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,
+            gfx_mode: GfxVendors::Hybrid,
+            gfx_managed: true,
+            active_profile: "normal".into(),
+            toggle_profiles: vec!["normal".into(), "boost".into(), "silent".into()],
+            curr_fan_mode: 0,
+            bat_charge_limit: 100,
+            power_profiles: pwr,
         }
     }
 }
 
-#[derive(Default, Deserialize, Serialize)]
-pub struct Config {
-    pub gfx_managed: bool,
-    pub gfx_nv_mode_is_dedicated: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    // TODO: remove power_profile
-    pub power_profile: 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 Config {
     /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load(supported_led_modes: &[u8]) -> Self {
+    pub fn load() -> Self {
         let mut file = OpenOptions::new()
             .read(true)
             .write(true)
             .create(true)
             .open(&CONFIG_PATH)
-            .expect(&format!(
-                "The file {} or directory /etc/asusd/ is missing",
-                CONFIG_PATH
-            )); // okay to cause panic here
+            .unwrap_or_else(|_| {
+                panic!(
+                    "The file {} or directory /etc/asusd/ is missing",
+                    CONFIG_PATH
+                )
+            }); // okay to cause panic here
         let mut buf = String::new();
         if let Ok(read_len) = file.read_to_string(&mut buf) {
             if read_len == 0 {
-                return Config::create_default(&mut file, &supported_led_modes);
+                return Config::create_default(&mut file);
             } else {
                 if let Ok(data) = serde_json::from_str(&buf) {
                     return data;
+                } else if let Ok(data) = serde_json::from_str::<ConfigV317>(&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::<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();
+                    info!("Updated config version to: {}", VERSION);
+                    return config;
                 } else if let Ok(data) = serde_json::from_str::<ConfigV212>(&buf) {
                     let config = data.into_current();
                     config.write();
@@ -86,42 +89,11 @@ impl Config {
                 panic!("Please remove {} then restart asusd", CONFIG_PATH);
             }
         }
-        Config::create_default(&mut file, &supported_led_modes)
+        Config::create_default(&mut file)
     }
 
-    fn create_default(file: &mut File, supported_led_modes: &[u8]) -> Self {
-        // create a default config here
-        let mut config = Config::default();
-        config.gfx_managed = true;
-        config.gfx_nv_mode_is_dedicated = true;
-
-        config.bat_charge_limit = 100;
-        config.kbd_backlight_mode = 0;
-        config.kbd_led_brightness = 1;
-
-        for n in supported_led_modes {
-            config.kbd_backlight_modes.push(AuraModes::from(*n))
-        }
-
-        let mut profile = Profile::default();
-        profile.fan_preset = 0;
-        profile.turbo = true;
-        config.power_profiles.insert("normal".into(), profile);
-
-        let mut profile = Profile::default();
-        profile.fan_preset = 1;
-        profile.turbo = true;
-        config.power_profiles.insert("boost".into(), profile);
-
-        let mut profile = Profile::default();
-        profile.fan_preset = 2;
-        config.power_profiles.insert("silent".into(), profile);
-
-        config.toggle_profiles.push("normal".into());
-        config.toggle_profiles.push("boost".into());
-        config.toggle_profiles.push("silent".into());
-        config.active_profile = "normal".into();
-
+    fn create_default(file: &mut File) -> Self {
+        let config = Config::default();
         // Should be okay to unwrap this as is since it is a Default
         let json = serde_json::to_string_pretty(&config).unwrap();
         file.write_all(json.as_bytes())
@@ -163,26 +135,6 @@ impl Config {
         file.write_all(json.as_bytes())
             .unwrap_or_else(|err| error!("Could not write config: {}", err));
     }
-
-    pub fn set_mode_data(&mut self, mode: AuraModes) {
-        let byte: u8 = (&mode).into();
-        for (index, n) in self.kbd_backlight_modes.iter().enumerate() {
-            if byte == u8::from(n) {
-                // Consume it, OMNOMNOMNOM
-                self.kbd_backlight_modes[index] = mode;
-                break;
-            }
-        }
-    }
-
-    pub fn get_led_mode_data(&self, num: u8) -> Option<&AuraModes> {
-        for mode in &self.kbd_backlight_modes {
-            if u8::from(mode) == num {
-                return Some(mode);
-            }
-        }
-        None
-    }
 }
 
 #[derive(Deserialize, Serialize)]
@@ -208,3 +160,21 @@ impl Default for Profile {
         }
     }
 }
+
+impl Profile {
+    pub fn new(
+        min_percentage: u8,
+        max_percentage: u8,
+        turbo: bool,
+        fan_preset: u8,
+        fan_curve: Option<Curve>,
+    ) -> Self {
+        Profile {
+            min_percentage,
+            max_percentage,
+            turbo,
+            fan_preset,
+            fan_curve,
+        }
+    }
+}

daemon/src/config_aura.rs

@@ -0,0 +1,148 @@
+use crate::laptops::LaptopLedData;
+use log::{error, info, warn};
+use rog_types::aura_modes::{AuraEffect, AuraModeNum, AuraMultiZone, AuraZone, LedBrightness};
+use serde_derive::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
+
+#[derive(Deserialize, Serialize)]
+pub struct AuraConfigV320 {
+    pub brightness: u32,
+    pub current_mode: AuraModeNum,
+    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    pub multizone: Option<AuraMultiZone>,
+}
+
+impl AuraConfigV320 {
+    pub(crate) fn into_current(self) -> AuraConfig {
+        AuraConfig {
+            brightness: <LedBrightness>::from(self.brightness),
+            current_mode: self.current_mode,
+            builtins: self.builtins,
+            multizone: self.multizone,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct AuraConfig {
+    pub brightness: LedBrightness,
+    pub current_mode: AuraModeNum,
+    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    pub multizone: Option<AuraMultiZone>,
+}
+
+impl Default for AuraConfig {
+    fn default() -> Self {
+        AuraConfig {
+            brightness: LedBrightness::Med,
+            current_mode: AuraModeNum::Static,
+            builtins: BTreeMap::new(),
+            multizone: None,
+        }
+    }
+}
+
+impl AuraConfig {
+    /// `load` will attempt to read the config, and panic if the dir is missing
+    pub fn load(supported_led_modes: &LaptopLedData) -> Self {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(&AURA_CONFIG_PATH)
+            .unwrap_or_else(|_| {
+                panic!(
+                    "The file {} or directory /etc/asusd/ is missing",
+                    AURA_CONFIG_PATH
+                )
+            }); // okay to cause panic here
+        let mut buf = String::new();
+        if let Ok(read_len) = file.read_to_string(&mut buf) {
+            if read_len == 0 {
+                return AuraConfig::create_default(&mut file, &supported_led_modes);
+            } else {
+                if let Ok(data) = serde_json::from_str(&buf) {
+                    return data;
+                }  else if let Ok(data) = serde_json::from_str::<AuraConfigV320>(&buf) {
+                    let config = data.into_current();
+                    config.write();
+                    info!("Updated AuraConfig version");
+                    return config;
+                }
+                warn!("Could not deserialise {}", AURA_CONFIG_PATH);
+                panic!("Please remove {} then restart asusd", AURA_CONFIG_PATH);
+            }
+        }
+        AuraConfig::create_default(&mut file, &supported_led_modes)
+    }
+
+    fn create_default(file: &mut File, support_data: &LaptopLedData) -> Self {
+        // create a default config here
+        let mut config = AuraConfig::default();
+
+        for n in &support_data.standard {
+            config
+                .builtins
+                .insert(*n, AuraEffect::default_with_mode(*n));
+        }
+
+        // Should be okay to unwrap this as is since it is a Default
+        let json = serde_json::to_string(&config).unwrap();
+        file.write_all(json.as_bytes())
+            .unwrap_or_else(|_| panic!("Could not write {}", AURA_CONFIG_PATH));
+        config
+    }
+
+    pub fn read(&mut self) {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(&AURA_CONFIG_PATH)
+            .unwrap_or_else(|err| panic!("Error reading {}: {}", AURA_CONFIG_PATH, err));
+        let mut buf = String::new();
+        if let Ok(l) = file.read_to_string(&mut buf) {
+            if l == 0 {
+                warn!("File is empty {}", AURA_CONFIG_PATH);
+            } else {
+                let x: AuraConfig = serde_json::from_str(&buf)
+                    .unwrap_or_else(|_| panic!("Could not deserialise {}", AURA_CONFIG_PATH));
+                *self = x;
+            }
+        }
+    }
+
+    pub fn write(&self) {
+        let mut file = File::create(AURA_CONFIG_PATH).expect("Couldn't overwrite config");
+        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
+        file.write_all(json.as_bytes())
+            .unwrap_or_else(|err| error!("Could not write config: {}", err));
+    }
+
+    /// Multipurpose, will accecpt AuraEffect with zones and put in the correct store
+    pub fn set_builtin(&mut self, effect: AuraEffect) {
+        match effect.zone() {
+            AuraZone::None => {
+                self.builtins.insert(*effect.mode(), effect);
+            }
+            _ => {
+                if let Some(multi) = self.multizone.as_mut() {
+                    multi.set(effect)
+                }
+            }
+        }
+    }
+
+    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect; 4]> {
+        if let Some(multi) = &self.multizone {
+            if aura_type == AuraModeNum::Static {
+                return Some(multi.static_());
+            } else if aura_type == AuraModeNum::Breathe {
+                return Some(multi.breathe());
+            }
+        }
+        None
+    }
+}

daemon/src/config_old.rs

@@ -0,0 +1,125 @@
+use rog_types::{aura_modes::AuraEffect, gfx_vendors::GfxVendors};
+use serde_derive::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+use crate::config::{Config, Profile};
+
+/// for parsing old v2.1.2 config
+#[allow(dead_code)]
+#[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<AuraEffect>,
+}
+
+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,
+            power_profiles: self.power_profiles,
+        }
+    }
+}
+
+/// for parsing old v2.2.2 config
+#[allow(dead_code)]
+#[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<AuraEffect>,
+}
+
+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,
+            power_profiles: self.power_profiles,
+        }
+    }
+}
+
+/// for parsing old v3.0.1 config
+#[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<AuraEffect>,
+    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,
+            power_profiles: self.power_profiles,
+        }
+    }
+}
+
+/// for parsing old v3.1.7 config
+#[derive(Deserialize, Serialize)]
+pub(crate) struct ConfigV317 {
+    pub gfx_mode: GfxVendors,
+    pub gfx_managed: bool,
+    pub active_profile: String,
+    pub toggle_profiles: Vec<String>,
+    #[serde(skip)]
+    pub curr_fan_mode: u8,
+    pub bat_charge_limit: u8,
+    pub kbd_led_brightness: u8,
+    pub kbd_backlight_mode: u8,
+    #[serde(skip)]
+    pub kbd_backlight_modes: Option<bool>,
+    pub power_profiles: BTreeMap<String, Profile>,
+}
+
+impl ConfigV317 {
+    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,
+            power_profiles: self.power_profiles,
+        }
+    }
+}

daemon/src/ctrl_anime.rs

@@ -13,10 +13,14 @@ const APPLY: u8 = 0xc4;
 // The next byte can be 0x03 for "on" and 0x00 for "off"
 const ON_OFF: u8 = 0x04;
 
-use asus_nb::error::AuraError;
 use log::{error, info, warn};
+use rog_types::{
+    anime_matrix::{
+        AniMeDataBuffer, AniMeImageBuffer, AniMePacketType, ANIME_PANE1_PREFIX, ANIME_PANE2_PREFIX,
+    },
+    error::AuraError,
+};
 use rusb::{Device, DeviceHandle};
-use std::convert::TryInto;
 use std::error::Error;
 use std::time::Duration;
 use zbus::dbus_interface;
@@ -25,7 +29,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;
@@ -35,34 +39,27 @@ impl GetSupported for CtrlAnimeDisplay {
     }
 }
 
-#[allow(dead_code)]
-#[derive(Debug)]
-pub enum AnimatrixCommand {
-    Apply,
-    SetBoot(bool),
-    Write(Vec<u8>),
-    WriteImage(Vec<Vec<u8>>),
-    //ReloadLast,
-}
-
 pub struct CtrlAnimeDisplay {
     handle: DeviceHandle<rusb::GlobalContext>,
-    initialised: bool,
 }
 
 //AnimatrixWrite
 pub trait Dbus {
-    fn set_anime(&mut self, input: Vec<Vec<u8>>);
+    /// Write an image 34x56 pixels. Each pixel is 0-255 greyscale.
+    fn write_image(&self, input: AniMeImageBuffer);
 
-    fn set_on_off(&mut self, status: bool);
+    /// Write a direct stream of data
+    fn write_direct(&self, input: AniMeDataBuffer);
 
-    fn set_boot_on_off(&mut self, status: bool);
+    fn set_on_off(&self, status: bool);
+
+    fn set_boot_on_off(&self, status: bool);
 }
 
 impl crate::ZbusAdd for CtrlAnimeDisplay {
     fn add_to_server(self, server: &mut zbus::ObjectServer) {
         server
-            .at(&"/org/asuslinux/Anime".try_into().unwrap(), self)
+            .at("/org/asuslinux/Anime", self)
             .map_err(|err| {
                 warn!("CtrlAnimeDisplay: add_to_server {}", err);
                 err
@@ -73,41 +70,44 @@ impl crate::ZbusAdd for CtrlAnimeDisplay {
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl Dbus for CtrlAnimeDisplay {
-    fn set_anime(&mut self, input: Vec<Vec<u8>>) {
-        self.do_command(AnimatrixCommand::WriteImage(input))
+    /// Writes a 34x56 image
+    fn write_image(&self, input: AniMeImageBuffer) {
+        self.write_image_buffer(input)
             .map_or_else(|err| warn!("{}", err), |()| info!("Writing image to Anime"));
     }
 
-    fn set_on_off(&mut self, status: bool) {
-        let mut flush: Vec<u8> = vec![0; PACKET_SIZE];
-        flush[0] = DEV_PAGE;
-        flush[1] = WRITE;
-        flush[2] = ON_OFF;
-
-        let status_str;
-        if status {
-            flush[3] = 0x03;
-            status_str = "on";
-        } else {
-            flush[3] = 0x00;
-            status_str = "off";
-        }
-
-        self.do_command(AnimatrixCommand::Write(flush)).map_or_else(
-            |err| warn!("{}", err),
-            |()| info!("Turning {} the AniMe", status_str),
-        );
+    /// Writes a data stream of length
+    fn write_direct(&self, input: AniMeDataBuffer) {
+        self.write_data_buffer(input)
+            .map_or_else(|err| warn!("{}", err), |()| info!("Writing data to Anime"));
     }
 
-    fn set_boot_on_off(&mut self, status: bool) {
+    fn set_on_off(&self, status: bool) {
+        let mut buffer = [0u8; PACKET_SIZE];
+        buffer[0] = DEV_PAGE;
+        buffer[1] = WRITE;
+        buffer[2] = ON_OFF;
+
+        if status {
+            buffer[3] = 0x03;
+        } else {
+            buffer[3] = 0x00;
+        }
+
+        self.write_bytes(&buffer);
+    }
+
+    fn set_boot_on_off(&self, status: bool) {
         let status_str = if status { "on" } else { "off" };
 
-        self.do_command(AnimatrixCommand::SetBoot(status))
-            .and_then(|()| self.do_command(AnimatrixCommand::Apply))
-            .map_or_else(
-                |err| warn!("{}", err),
-                |()| info!("Turning {} the AniMe at boot/shutdown", status_str),
-            );
+        self.do_set_boot(status).map_or_else(
+            |err| warn!("{}", err),
+            |()| info!("Turning {} the AniMe at boot/shutdown", status_str),
+        );
+        self.do_apply().map_or_else(
+            |err| warn!("{}", err),
+            |()| info!("Turning {} the AniMe at boot/shutdown", status_str),
+        );
     }
 }
 
@@ -131,10 +131,10 @@ impl CtrlAnimeDisplay {
         })?;
 
         info!("Device has an AniMe Matrix display");
-        Ok(CtrlAnimeDisplay {
-            handle: device,
-            initialised: false,
-        })
+        let ctrl = CtrlAnimeDisplay { handle: device };
+        ctrl.do_initialization()?;
+
+        Ok(ctrl)
     }
 
     #[inline]
@@ -148,25 +148,9 @@ impl CtrlAnimeDisplay {
         Err(rusb::Error::NoDevice)
     }
 
-    pub fn do_command(&mut self, command: AnimatrixCommand) -> Result<(), AuraError> {
-        if !self.initialised {
-            self.do_initialization()?
-        }
-
-        match command {
-            AnimatrixCommand::Apply => self.do_apply()?,
-            //AnimatrixCommand::Set => self.do_set_boot()?,
-            AnimatrixCommand::SetBoot(status) => self.do_set_boot(status)?,
-            AnimatrixCommand::Write(bytes) => self.write_bytes(&bytes)?,
-            AnimatrixCommand::WriteImage(effect) => self.write_image(effect)?,
-            //AnimatrixCommand::ReloadLast => self.reload_last_builtin(&config).await?,
-        }
-        Ok(())
-    }
-
     /// Should only be used if the bytes you are writing are verified correct
     #[inline]
-    fn write_bytes(&self, message: &[u8]) -> Result<(), AuraError> {
+    fn write_bytes(&self, message: &[u8]) {
         match self.handle.write_control(
             0x21,  // request_type
             0x09,  // request
@@ -181,12 +165,23 @@ impl CtrlAnimeDisplay {
                 _ => error!("Failed to write to led interrupt: {}", err),
             },
         }
+    }
+    #[inline]
+    fn write_data_buffer(&self, buffer: AniMeDataBuffer) -> Result<(), AuraError> {
+        let mut image = AniMePacketType::from(buffer);
+        image[0][..7].copy_from_slice(&ANIME_PANE1_PREFIX);
+        image[1][..7].copy_from_slice(&ANIME_PANE2_PREFIX);
+
+        for row in image.iter() {
+            self.write_bytes(row);
+        }
+        self.do_flush()?;
         Ok(())
     }
 
     /// Write an Animatrix image
     ///
-    /// The expected input here is *two* Vectors, 640 bytes in length. The two vectors
+    /// The expected USB input here is *two* Vectors, 640 bytes in length. The two vectors
     /// are each one half of the full image write.
     ///
     /// After each write a flush is written, it is assumed that this tells the device to
@@ -200,22 +195,26 @@ impl CtrlAnimeDisplay {
     ///
     /// Where led brightness is 0..255, low to high
     #[inline]
-    fn write_image(&mut self, image: Vec<Vec<u8>>) -> Result<(), AuraError> {
+    fn write_image_buffer(&self, buffer: AniMeImageBuffer) -> Result<(), AuraError> {
+        let mut image = AniMePacketType::from(buffer);
+        image[0][..7].copy_from_slice(&ANIME_PANE1_PREFIX);
+        image[1][..7].copy_from_slice(&ANIME_PANE2_PREFIX);
+
         for row in image.iter() {
-            self.write_bytes(row)?;
+            self.write_bytes(row);
         }
         self.do_flush()?;
         Ok(())
     }
 
     #[inline]
-    fn do_initialization(&mut self) -> Result<(), AuraError> {
+    fn do_initialization(&self) -> Result<(), AuraError> {
         let mut init = [0; PACKET_SIZE];
         init[0] = DEV_PAGE; // This is the USB page we're using throughout
         for (idx, byte) in INIT_STR.as_bytes().iter().enumerate() {
             init[idx + 1] = *byte
         }
-        self.write_bytes(&init)?;
+        self.write_bytes(&init);
 
         // clear the init array and write other init message
         for ch in init.iter_mut() {
@@ -224,43 +223,42 @@ impl CtrlAnimeDisplay {
         init[0] = DEV_PAGE; // write it to be sure?
         init[1] = INIT;
 
-        self.write_bytes(&init)?;
-        self.initialised = true;
+        self.write_bytes(&init);
         Ok(())
     }
 
     #[inline]
-    fn do_flush(&mut self) -> Result<(), AuraError> {
+    fn do_flush(&self) -> Result<(), AuraError> {
         let mut flush = [0; PACKET_SIZE];
         flush[0] = DEV_PAGE;
         flush[1] = WRITE;
         flush[2] = 0x03;
 
-        self.write_bytes(&flush)?;
+        self.write_bytes(&flush);
         Ok(())
     }
 
     #[inline]
-    fn do_set_boot(&mut self, status: bool) -> Result<(), AuraError> {
+    fn do_set_boot(&self, status: bool) -> Result<(), AuraError> {
         let mut flush = [0; PACKET_SIZE];
         flush[0] = DEV_PAGE;
         flush[1] = SET;
         flush[2] = 0x01;
         flush[3] = if status { 0x00 } else { 0x80 };
 
-        self.write_bytes(&flush)?;
+        self.write_bytes(&flush);
         Ok(())
     }
 
     #[inline]
-    fn do_apply(&mut self) -> Result<(), AuraError> {
+    fn do_apply(&self) -> Result<(), AuraError> {
         let mut flush = [0; PACKET_SIZE];
         flush[0] = DEV_PAGE;
         flush[1] = APPLY;
         flush[2] = 0x01;
         flush[3] = 0x80;
 
-        self.write_bytes(&flush)?;
+        self.write_bytes(&flush);
         Ok(())
     }
 }

daemon/src/ctrl_charge.rs

@@ -2,7 +2,6 @@ use crate::{config::Config, error::RogError, GetSupported};
 //use crate::dbus::DbusEvents;
 use log::{info, warn};
 use serde_derive::{Deserialize, Serialize};
-use std::convert::TryInto;
 use std::fs::OpenOptions;
 use std::io::Write;
 use std::path::Path;
@@ -64,7 +63,7 @@ impl CtrlCharge {
 impl crate::ZbusAdd for CtrlCharge {
     fn add_to_server(self, server: &mut zbus::ObjectServer) {
         server
-            .at(&"/org/asuslinux/Charge".try_into().unwrap(), self)
+            .at("/org/asuslinux/Charge", self)
             .map_err(|err| {
                 warn!("CtrlCharge: add_to_server {}", err);
                 err
@@ -101,7 +100,7 @@ impl CtrlCharge {
     }
 
     pub(super) fn set(&self, limit: u8, config: &mut Config) -> Result<(), RogError> {
-        if limit < 20 || limit > 100 {
+        if !(20..=100).contains(&limit) {
             warn!(
                 "Unable to set battery charge limit, must be between 20-100: requested {}",
                 limit

daemon/src/ctrl_fan_cpu.rs

@@ -1,18 +1,17 @@
+use crate::error::RogError;
 use crate::{
     config::{Config, Profile},
     GetSupported,
 };
-use asus_nb::profile::ProfileEvent;
 use log::{info, warn};
+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::str::FromStr;
 use std::sync::Arc;
 use std::sync::Mutex;
-use zbus::dbus_interface;
+use zbus::{dbus_interface, fdo::Error};
 
 static FAN_TYPE_1_PATH: &str = "/sys/devices/platform/asus-nb-wmi/throttle_thermal_policy";
 static FAN_TYPE_2_PATH: &str = "/sys/devices/platform/asus-nb-wmi/fan_boost_mode";
@@ -62,8 +61,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_else(|_| ());
+                    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));
+                        }
+                    }
                 }
             }
         }
@@ -73,6 +76,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) {
@@ -123,6 +127,54 @@ impl DbusFanAndCpu {
         "Failed".to_string()
     }
 
+    fn profile_names(&self) -> String {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Ok(mut cfg) = ctrl.config.try_lock() {
+                cfg.read();
+
+                let profile_names: String = cfg
+                    .power_profiles
+                    .keys()
+                    .cloned()
+                    .collect::<Vec<String>>()
+                    .join(", ");
+
+                return profile_names;
+            }
+        }
+
+        "Failed".to_string()
+    }
+
+    fn remove(&self, profile: &str) -> zbus::fdo::Result<()> {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Ok(mut cfg) = ctrl.config.try_lock() {
+                cfg.read();
+
+                if !cfg.power_profiles.contains_key(profile) {
+                    return Err(Error::Failed("Invalid profile specified".to_string()));
+                }
+
+                if cfg.power_profiles.keys().len() == 1 {
+                    return Err(Error::Failed("Cannot delete the last profile".to_string()));
+                }
+
+                if cfg.active_profile == *profile {
+                    return Err(Error::Failed(
+                        "Cannot delete the active profile".to_string(),
+                    ));
+                }
+
+                cfg.power_profiles.remove(profile);
+                cfg.write();
+
+                return Ok(());
+            }
+        }
+
+        return Err(Error::Failed("Failed to lock configuration".to_string()));
+    }
+
     #[dbus_interface(signal)]
     fn notify_profile(&self, profile: &str) -> zbus::Result<()> {}
 }
@@ -130,7 +182,7 @@ impl DbusFanAndCpu {
 impl crate::ZbusAdd for DbusFanAndCpu {
     fn add_to_server(self, server: &mut zbus::ObjectServer) {
         server
-            .at(&"/org/asuslinux/Profile".try_into().unwrap(), self)
+            .at("/org/asuslinux/Profile", self)
             .map_err(|err| {
                 warn!("DbusFanAndCpu: add_to_server {}", err);
                 err
@@ -142,65 +194,17 @@ impl crate::ZbusAdd for DbusFanAndCpu {
 impl crate::Reloadable for CtrlFanAndCPU {
     fn reload(&mut self) -> Result<(), RogError> {
         if let Ok(mut config) = self.config.clone().try_lock() {
-            let mut file = OpenOptions::new()
-                .write(true)
-                .open(self.path)
-                .map_err(|err| RogError::Path(self.path.into(), err))?;
-            file.write_all(format!("{}\n", config.power_profile).as_bytes())
-                .map_err(|err| RogError::Write(self.path.into(), err))?;
             let profile = config.active_profile.clone();
             self.set(&profile, &mut config)?;
-            info!(
-                "Reloaded fan mode: {:?}",
-                FanLevel::from(config.power_profile)
-            );
+            // info!(
+            //     "Reloaded fan mode: {:?}",
+            //     FanLevel::from(config.power_profile)
+            // );
         }
         Ok(())
     }
 }
 
-impl crate::CtrlTask for CtrlFanAndCPU {
-    fn do_task(&mut self) -> Result<(), RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(self.path)
-            .map_err(|err| RogError::Path(self.path.into(), err))?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read(self.path.into(), err))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if let Ok(mut config) = self.config.clone().try_lock() {
-                if config.power_profile != num as u8 {
-                    config.read();
-
-                    let mut i = config
-                        .toggle_profiles
-                        .iter()
-                        .position(|x| x == &config.active_profile)
-                        .map(|i| i + 1)
-                        .unwrap_or(0);
-                    if i >= config.toggle_profiles.len() {
-                        i = 0;
-                    }
-
-                    let new_profile = config
-                        .toggle_profiles
-                        .get(i)
-                        .unwrap_or(&config.active_profile)
-                        .clone();
-
-                    self.set(&new_profile, &mut config)?;
-
-                    info!("Profile was changed: {}", &new_profile);
-                }
-            }
-            return Ok(());
-        }
-
-        Err(RogError::DoTask("Fan-level could not be parsed".into()))
-    }
-}
-
 impl CtrlFanAndCPU {
     pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
         let path = CtrlFanAndCPU::get_fan_path()?;
@@ -246,7 +250,7 @@ impl CtrlFanAndCPU {
         Ok(())
     }
 
-    pub(super) fn set_fan_mode(&mut self, preset: u8, config: &mut Config) -> Result<(), RogError> {
+    fn set_fan_mode(&mut self, preset: u8, config: &mut Config) -> Result<(), RogError> {
         let mode = config.active_profile.clone();
         let mut fan_ctrl = OpenOptions::new()
             .write(true)
@@ -257,15 +261,13 @@ impl CtrlFanAndCPU {
             .power_profiles
             .get_mut(&mode)
             .ok_or_else(|| RogError::MissingProfile(mode.clone()))?;
-        config.power_profile = preset;
+        config.curr_fan_mode = preset;
         mode_config.fan_preset = preset;
         config.write();
         fan_ctrl
             .write_all(format!("{}\n", preset).as_bytes())
             .map_err(|err| RogError::Write(self.path.into(), err))?;
         info!("Fan mode set to: {:?}", FanLevel::from(preset));
-        self.set_pstate_for_fan_mode(&mode, config)?;
-        self.set_fan_curve_for_fan_mode(&mode, config)?;
         Ok(())
     }
 
@@ -278,6 +280,9 @@ impl CtrlFanAndCPU {
             ProfileEvent::Toggle => self.do_next_profile(config)?,
             ProfileEvent::ChangeMode(mode) => {
                 self.set_fan_mode(*mode, config)?;
+                let mode = config.active_profile.clone();
+                self.set_pstate_for_fan_mode(&mode, config)?;
+                self.set_fan_curve_for_fan_mode(&mode, config)?;
             }
             ProfileEvent::Cli(command) => {
                 let profile_key = match command.profile.as_ref() {
@@ -306,7 +311,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 {
@@ -328,10 +333,10 @@ impl CtrlFanAndCPU {
             .write(true)
             .open(self.path)
             .map_err(|err| RogError::Path(self.path.into(), err))?;
+        config.curr_fan_mode = mode_config.fan_preset;
         fan_ctrl
             .write_all(format!("{}\n", mode_config.fan_preset).as_bytes())
             .map_err(|err| RogError::Write(self.path.into(), err))?;
-        config.power_profile = mode_config.fan_preset;
 
         self.set_pstate_for_fan_mode(profile, config)?;
         self.set_fan_curve_for_fan_mode(profile, config)?;
@@ -393,46 +398,3 @@ impl CtrlFanAndCPU {
         Ok(())
     }
 }
-
-use crate::error::RogError;
-
-#[derive(Debug)]
-pub enum FanLevel {
-    Normal,
-    Boost,
-    Silent,
-}
-
-impl FromStr for FanLevel {
-    type Err = RogError;
-
-    fn from_str(s: &str) -> Result<Self, RogError> {
-        match s.to_lowercase().as_str() {
-            "normal" => Ok(FanLevel::Normal),
-            "boost" => Ok(FanLevel::Boost),
-            "silent" => Ok(FanLevel::Silent),
-            _ => Err(RogError::ParseFanLevel),
-        }
-    }
-}
-
-impl From<u8> for FanLevel {
-    fn from(n: u8) -> Self {
-        match n {
-            0 => FanLevel::Normal,
-            1 => FanLevel::Boost,
-            2 => FanLevel::Silent,
-            _ => FanLevel::Normal,
-        }
-    }
-}
-
-impl From<FanLevel> for u8 {
-    fn from(n: FanLevel) -> Self {
-        match n {
-            FanLevel::Normal => 0,
-            FanLevel::Boost => 1,
-            FanLevel::Silent => 2,
-        }
-    }
-}

daemon/src/ctrl_gfx/error.rs

@@ -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,17 @@ 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"
+            ),
         }
     }
 }

daemon/src/ctrl_gfx/gfx.rs

@@ -0,0 +1,636 @@
+use ctrl_gfx::error::GfxError;
+use ctrl_gfx::*;
+use ctrl_rog_bios::CtrlRogBios;
+use log::{error, info, warn};
+use logind_zbus::{
+    types::{SessionClass, SessionInfo, SessionType},
+    ManagerProxy, SessionProxy,
+};
+use rog_types::gfx_vendors::{GfxRequiredUserAction, GfxVendors};
+use std::sync::mpsc;
+use std::{io::Write, ops::Add, path::Path, time::Instant};
+use std::{iter::FromIterator, thread::JoinHandle};
+use std::{process::Command, thread::sleep, time::Duration};
+use std::{sync::Arc, sync::Mutex};
+use sysfs_class::{PciDevice, SysClass};
+use system::{GraphicsDevice, PciBus};
+use zbus::{dbus_interface, Connection};
+
+use crate::*;
+
+const THREAD_TIMEOUT_MSG: &str = "GFX: thread time exceeded 3 minutes, exiting";
+
+pub struct CtrlGraphics {
+    bus: PciBus,
+    _amd: Vec<GraphicsDevice>,
+    _intel: Vec<GraphicsDevice>,
+    nvidia: Vec<GraphicsDevice>,
+    #[allow(dead_code)]
+    other: Vec<GraphicsDevice>,
+    config: Arc<Mutex<Config>>,
+    thread_kill: Arc<Mutex<Option<mpsc::Sender<bool>>>>,
+}
+
+trait Dbus {
+    fn vendor(&self) -> zbus::fdo::Result<GfxVendors>;
+    fn power(&self) -> String;
+    fn set_vendor(&mut self, vendor: GfxVendors) -> zbus::fdo::Result<GfxRequiredUserAction>;
+    fn notify_gfx(&self, vendor: &GfxVendors) -> zbus::Result<()>;
+    fn notify_action(&self, action: &GfxRequiredUserAction) -> zbus::Result<()>;
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl Dbus for CtrlGraphics {
+    fn vendor(&self) -> zbus::fdo::Result<GfxVendors> {
+        self.get_gfx_mode().map_err(|err| {
+            error!("GFX: {}", err);
+            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
+        })
+    }
+
+    fn power(&self) -> String {
+        Self::get_runtime_status().unwrap_or_else(|err| format!("Get power status failed: {}", err))
+    }
+
+    fn set_vendor(&mut self, vendor: GfxVendors) -> zbus::fdo::Result<GfxRequiredUserAction> {
+        info!("GFX: Switching gfx mode to {}", <&str>::from(vendor));
+        let msg = self.set_gfx_config(vendor).map_err(|err| {
+            error!("GFX: {}", err);
+            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
+        })?;
+        self.notify_gfx(&vendor)
+            .unwrap_or_else(|err| warn!("GFX: {}", err));
+        self.notify_action(&msg)
+            .unwrap_or_else(|err| warn!("GFX: {}", err));
+        Ok(msg)
+    }
+
+    #[dbus_interface(signal)]
+    fn notify_gfx(&self, vendor: &GfxVendors) -> zbus::Result<()> {}
+
+    #[dbus_interface(signal)]
+    fn notify_action(&self, action: &GfxRequiredUserAction) -> zbus::Result<()> {}
+}
+
+impl ZbusAdd for CtrlGraphics {
+    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at("/org/asuslinux/Gfx", self)
+            .map_err(|err| {
+                warn!("GFX: CtrlGraphics: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}
+
+impl Reloadable for CtrlGraphics {
+    fn reload(&mut self) -> Result<(), RogError> {
+        self.auto_power()?;
+        info!("GFX: Reloaded gfx mode: {:?}", self.get_gfx_mode()?);
+        Ok(())
+    }
+}
+
+impl CtrlGraphics {
+    pub fn new(config: Arc<Mutex<Config>>) -> std::io::Result<CtrlGraphics> {
+        let bus = PciBus::new()?;
+
+        info!("GFX: Rescanning PCI bus");
+        bus.rescan()?;
+
+        let devs = PciDevice::all()?;
+
+        let functions = |parent: &PciDevice| -> Vec<PciDevice> {
+            let mut functions = Vec::new();
+            if let Some(parent_slot) = parent.id().split('.').next() {
+                for func in devs.iter() {
+                    if let Some(func_slot) = func.id().split('.').next() {
+                        if func_slot == parent_slot {
+                            info!("GFX: {}: Function for {}", func.id(), parent.id());
+                            functions.push(func.clone());
+                        }
+                    }
+                }
+            }
+            functions
+        };
+
+        let mut amd = Vec::new();
+        let mut intel = Vec::new();
+        let mut nvidia = Vec::new();
+        let mut other = Vec::new();
+        for dev in devs.iter() {
+            let c = dev.class()?;
+            if 0x03 == (c >> 16) & 0xFF {
+                match dev.vendor()? {
+                    0x1002 => {
+                        info!("GFX: {}: AMD graphics", dev.id());
+                        amd.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
+                    }
+                    0x10DE => {
+                        info!("GFX: {}: NVIDIA graphics", dev.id());
+                        nvidia.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
+                    }
+                    0x8086 => {
+                        info!("GFX: {}: Intel graphics", dev.id());
+                        intel.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
+                    }
+                    vendor => {
+                        info!("GFX: {}: Other({:X}) graphics", dev.id(), vendor);
+                        other.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
+                    }
+                }
+            }
+        }
+
+        Ok(CtrlGraphics {
+            bus,
+            _amd: amd,
+            _intel: intel,
+            nvidia,
+            other,
+            config,
+            thread_kill: Arc::new(Mutex::new(None)),
+        })
+    }
+
+    pub fn bus(&self) -> PciBus {
+        self.bus.clone()
+    }
+
+    pub fn devices(&self) -> Vec<GraphicsDevice> {
+        self.nvidia.clone()
+    }
+
+    /// Save the selected `Vendor` mode to config
+    fn save_gfx_mode(vendor: GfxVendors, config: Arc<Mutex<Config>>) {
+        if let Ok(mut config) = config.lock() {
+            config.gfx_mode = vendor;
+            config.write();
+        }
+        // TODO: Error here
+    }
+
+    /// Associated method to get which vendor mode is set
+    pub fn get_gfx_mode(&self) -> Result<GfxVendors, RogError> {
+        if let Ok(config) = self.config.lock() {
+            return Ok(config.gfx_mode);
+        }
+        // TODO: Error here
+        Ok(GfxVendors::Hybrid)
+    }
+
+    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)
+    }
+
+    fn toggle_fallback_service(vendor: GfxVendors) -> Result<(), RogError> {
+        let action = if vendor == GfxVendors::Nvidia {
+            info!("GFX: Enabling nvidia-fallback.service");
+            "enable"
+        } else {
+            info!("GFX: Disabling nvidia-fallback.service");
+            "disable"
+        };
+
+        let status = Command::new("systemctl")
+            .arg(action)
+            .arg("nvidia-fallback.service")
+            .status()
+            .map_err(|err| RogError::Command("systemctl".into(), err))?;
+
+        if !status.success() {
+            // Error is ignored in case this service is removed
+            warn!(
+                "systemctl: {} (ignore warning if service does not exist!)",
+                status
+            );
+        }
+
+        Ok(())
+    }
+
+    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 {
+            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_END].concat()
+        };
+
+        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!("GFX: 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 get_vfio_conf(devices: &[GraphicsDevice]) -> Vec<u8> {
+        let mut vifo = MODPROBE_VFIO.to_vec();
+        for (d_count, dev) in devices.iter().enumerate() {
+            for (f_count, func) in dev.functions().iter().enumerate() {
+                let vendor = func.vendor().unwrap();
+                let device = func.device().unwrap();
+                unsafe {
+                    vifo.append(format!("{:x}", vendor).as_mut_vec());
+                }
+                vifo.append(&mut vec![b':']);
+                unsafe {
+                    vifo.append(format!("{:x}", device).as_mut_vec());
+                }
+                if f_count < dev.functions().len() - 1 {
+                    vifo.append(&mut vec![b',']);
+                }
+            }
+            if d_count < dev.functions().len() - 1 {
+                vifo.append(&mut vec![b',']);
+            }
+        }
+        let mut conf = MODPROBE_INTEGRATED.to_vec();
+        conf.append(&mut vifo);
+        conf
+    }
+
+    fn write_modprobe_conf(vendor: GfxVendors, devices: &[GraphicsDevice]) -> Result<(), RogError> {
+        info!("GFX: Writing {}", MODPROBE_PATH);
+        let content = match vendor {
+            GfxVendors::Nvidia | GfxVendors::Hybrid | GfxVendors::Compute => MODPROBE_BASE.to_vec(),
+            GfxVendors::Vfio => Self::get_vfio_conf(devices),
+            // GfxVendors::Compute => {}
+            GfxVendors::Integrated => MODPROBE_INTEGRATED.to_vec(),
+        };
+
+        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(&content)
+            .and_then(|_| file.sync_all())
+            .map_err(|err| RogError::Write(MODPROBE_PATH.into(), err))?;
+
+        Ok(())
+    }
+
+    fn unbind_remove_nvidia(devices: &[GraphicsDevice]) -> Result<(), RogError> {
+        // Unbind NVIDIA graphics devices and their functions
+        let unbinds = devices.iter().map(|dev| dev.unbind());
+        // Remove NVIDIA graphics devices and their functions
+        let removes = devices.iter().map(|dev| dev.remove());
+        Result::from_iter(unbinds.chain(removes))
+            .map_err(|err| RogError::Command("device unbind error".into(), err))
+    }
+
+    fn unbind_only(devices: &[GraphicsDevice]) -> Result<(), RogError> {
+        let unbinds = devices.iter().map(|dev| dev.unbind());
+        Result::from_iter(unbinds)
+            .map_err(|err| RogError::Command("device unbind error".into(), 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!("GFX: {}", 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()) {
+                    warn!(
+                        "{} {} failed: {:?}",
+                        action,
+                        driver,
+                        String::from_utf8_lossy(&output.stderr)
+                    );
+                    warn!("GFX: It may be safe to ignore the above error, run `lsmod |grep {}` to confirm modules loaded", driver);
+                    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;
+        }
+        Err(GfxError::DisplayManagerTimeout(state.into()).into())
+    }
+
+    /// Determine if we need to logout/thread. Integrated<->Vfio mode does not
+    /// require logout.
+    fn logout_required(&self, vendor: GfxVendors) -> GfxRequiredUserAction {
+        if let Ok(config) = self.config.lock() {
+            let current = config.gfx_mode;
+            if matches!(current, GfxVendors::Integrated | GfxVendors::Vfio)
+                && matches!(vendor, GfxVendors::Integrated | GfxVendors::Vfio)
+            {
+                return GfxRequiredUserAction::None;
+            }
+        }
+        GfxRequiredUserAction::Logout
+    }
+
+    /// Write the config changes and add/remove drivers and devices depending
+    /// on selected mode:
+    ///
+    /// Tasks:
+    /// - write xorg config
+    /// - write modprobe config
+    /// - rescan for devices
+    ///   + add drivers
+    ///   + or remove drivers and devices
+    ///
+    /// The daemon needs direct access to this function when it detects that the
+    pub fn do_vendor_tasks(
+        vendor: GfxVendors,
+        devices: &[GraphicsDevice],
+        bus: &PciBus,
+    ) -> Result<(), RogError> {
+        // Rescan before doing remove or add drivers
+        bus.rescan()?;
+        //
+        Self::write_xorg_conf(vendor)?;
+        // Write different modprobe to enable boot control to work
+        Self::write_modprobe_conf(vendor, devices)?;
+
+        match vendor {
+            GfxVendors::Nvidia | GfxVendors::Hybrid | GfxVendors::Compute => {
+                for driver in VFIO_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "rmmod")?;
+                }
+                for driver in NVIDIA_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "modprobe")?;
+                }
+            }
+            GfxVendors::Vfio => {
+                for driver in NVIDIA_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "rmmod")?;
+                }
+                Self::unbind_only(&devices)?;
+                Self::do_driver_action("vfio-pci", "modprobe")?;
+            }
+            GfxVendors::Integrated => {
+                for driver in VFIO_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "rmmod")?;
+                }
+                for driver in NVIDIA_DRIVERS.iter() {
+                    Self::do_driver_action(driver, "rmmod")?;
+                }
+                Self::unbind_remove_nvidia(&devices)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn graphical_session_alive(
+        connection: &Connection,
+        sessions: &[SessionInfo],
+    ) -> Result<bool, RogError> {
+        for session in sessions {
+            let session_proxy = SessionProxy::new(&connection, session)?;
+            if session_proxy.get_class()? == SessionClass::User {
+                match session_proxy.get_type()? {
+                    SessionType::X11 | SessionType::Wayland | SessionType::MIR => {
+                        //if session_proxy.get_active()? {
+                        return Ok(true);
+                        //}
+                    }
+                    _ => {}
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Spools until all user sessions are ended then switches to requested mode
+    fn fire_starter(
+        vendor: GfxVendors,
+        devices: Vec<GraphicsDevice>,
+        bus: PciBus,
+        thread_stop: mpsc::Receiver<bool>,
+        config: Arc<Mutex<Config>>,
+    ) -> Result<String, RogError> {
+        info!("GFX: display-manager thread started");
+
+        const SLEEP_PERIOD: Duration = Duration::from_millis(100);
+        let start_time = Instant::now();
+
+        let connection = Connection::new_system()?;
+        let manager = ManagerProxy::new(&connection)?;
+        let mut sessions = manager.list_sessions()?;
+
+        loop {
+            let tmp = manager.list_sessions()?;
+            if !tmp.iter().eq(&sessions) {
+                warn!("GFX: Sessions list changed");
+                warn!("GFX: Old list:\n{:?}\nNew list:\n{:?}", &sessions, &tmp);
+                sessions = tmp;
+            }
+
+            if !Self::graphical_session_alive(&connection, &sessions)? {
+                break;
+            }
+
+            if let Ok(stop) = thread_stop.try_recv() {
+                if stop {
+                    return Ok("Graphics mode change was cancelled".into());
+                }
+            }
+            // exit if 3 minutes pass
+            if Instant::now().duration_since(start_time).as_secs() > 180 {
+                warn!("{}", THREAD_TIMEOUT_MSG);
+                return Ok(THREAD_TIMEOUT_MSG.into());
+            }
+
+            // Don't spin at max speed
+            sleep(SLEEP_PERIOD);
+        }
+
+        info!("GFX: all graphical user sessions ended, continuing");
+        Self::do_display_manager_action("stop")?;
+
+        match Self::wait_display_manager_state("inactive") {
+            Ok(_) => info!("GFX: display-manager stopped"),
+            Err(err) => {
+                warn!("GFX: {}", err);
+                warn!("GFX: Retry stop display manager");
+                Self::do_display_manager_action("stop")?;
+                Self::wait_display_manager_state("inactive")?;
+            }
+        }
+
+        Self::do_vendor_tasks(vendor, &devices, &bus)?;
+        Self::do_display_manager_action("start")?;
+
+        if Self::wait_display_manager_state("active").is_err() {
+            error!("GFX: display-manager failed to start normally, attempting restart");
+            Self::do_display_manager_action("restart")?;
+            Self::wait_display_manager_state("active")?;
+        }
+        // Save selected mode in case of reboot
+        Self::save_gfx_mode(vendor, config);
+        info!("GFX: display-manager started");
+
+        let v: &str = vendor.into();
+        info!("GFX: Graphics mode changed to {} successfully", v);
+        Ok(format!("Graphics mode changed to {} successfully", v))
+    }
+
+    fn cancel_thread(&self) {
+        if let Ok(lock) = self.thread_kill.lock() {
+            if let Some(tx) = lock.as_ref() {
+                // Cancel the running thread
+                info!("GFX: Cancelling previous thread");
+                tx.send(true)
+                    .map_err(|err| {
+                        warn!("GFX: {}", err);
+                    })
+                    .ok();
+            }
+        }
+    }
+
+    /// The thread is used only in cases where a logout is required
+    fn setup_thread(&mut self, vendor: GfxVendors) {
+        let config = self.config.clone();
+        let devices = self.nvidia.clone();
+        let bus = self.bus.clone();
+        let (tx, rx) = mpsc::channel();
+        if let Ok(mut lock) = self.thread_kill.lock() {
+            *lock = Some(tx);
+        }
+        let killer = self.thread_kill.clone();
+
+        let _join: JoinHandle<()> = std::thread::spawn(move || {
+            Self::fire_starter(vendor, devices, bus, rx, config)
+                .map_err(|err| {
+                    error!("GFX: {}", err);
+                })
+                .ok();
+            // clear the tx/rx when done
+            if let Ok(mut lock) = killer.try_lock() {
+                *lock = None;
+            }
+        });
+    }
+
+    /// Initiates a mode change by starting a thread that will wait until all
+    /// graphical sessions are exited before performing the tasks required
+    /// to switch modes.
+    ///
+    /// For manually calling (not on boot/startup) via dbus
+    pub fn set_gfx_config(
+        &mut self,
+        vendor: GfxVendors,
+    ) -> Result<GfxRequiredUserAction, RogError> {
+        if let Ok(gsync) = CtrlRogBios::get_gfx_mode() {
+            if gsync == 1 {
+                return Err(GfxError::GsyncModeActive.into());
+            }
+        }
+        // Must always cancel any thread running
+        self.cancel_thread();
+        // determine which method we need here
+        let action_required = self.logout_required(vendor);
+        if matches!(action_required, GfxRequiredUserAction::Logout) {
+            // Yeah need the thread to check if all users are logged out
+            info!("GFX: mode change requires a logout to complete");
+            self.setup_thread(vendor);
+        } else {
+            // Okay cool, we can switch on/off vfio
+            info!("GFX: mode change does not require logout");
+            let devices = self.nvidia.clone();
+            let bus = self.bus.clone();
+            Self::do_vendor_tasks(vendor, &devices, &bus)?;
+        }
+        // TODO: undo if failed? Save last mode, catch errors...
+        Ok(action_required)
+    }
+
+    /// Used only on boot to set correct mode
+    fn auto_power(&mut self) -> Result<(), RogError> {
+        let vendor = self.get_gfx_mode()?;
+        let devices = self.nvidia.clone();
+        let bus = self.bus.clone();
+        Self::do_vendor_tasks(vendor, &devices, &bus)?;
+        Self::toggle_fallback_service(vendor)?;
+        Ok(())
+    }
+}

daemon/src/ctrl_gfx/mod.rs

@@ -0,0 +1,57 @@
+pub mod error;
+
+pub mod gfx;
+
+pub mod system;
+
+const NVIDIA_DRIVERS: [&str; 4] = ["nvidia_drm", "nvidia_modeset", "nvidia_uvm", "nvidia"];
+
+const VFIO_DRIVERS: [&str; 5] = [
+    "vfio-pci",
+    "vfio_iommu_type1",
+    "vfio_virqfd",
+    "vfio_mdev",
+    "vfio",
+];
+
+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
+alias nouveau off
+options nvidia NVreg_DynamicPowerManagement=0x02
+options nvidia-drm modeset=1
+"#;
+
+static MODPROBE_INTEGRATED: &[u8] = br#"# Automatically generated by asusd
+blacklist i2c_nvidia_gpu
+blacklist nvidia
+blacklist nvidia-drm
+blacklist nvidia-modeset
+blacklist nouveau
+alias nouveau off
+"#;
+
+static MODPROBE_VFIO: &[u8] = br#"options vfio-pci ids="#;
+
+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"
+    Identifier "nvidia"
+    MatchDriver "nvidia-drm"
+    Driver "nvidia"
+    Option "AllowEmptyInitialConfiguration" "true""#;
+
+static PRIMARY_GPU_NVIDIA: &[u8] = br#"
+    Option "PrimaryGPU" "true""#;
+
+static PRIMARY_GPU_END: &[u8] = br#"
+EndSection"#;

daemon/src/ctrl_gfx/system.rs

@@ -33,6 +33,7 @@ impl Module {
     }
 }
 
+#[derive(Clone)]
 pub struct PciBus {
     path: PathBuf,
 }
@@ -50,25 +51,31 @@ 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")
     }
 }
 
+#[derive(Clone)]
 pub struct GraphicsDevice {
-    id: String,
+    _id: String,
     functions: Vec<PciDevice>,
 }
 
 impl GraphicsDevice {
     pub fn new(id: String, functions: Vec<PciDevice>) -> GraphicsDevice {
-        GraphicsDevice { id, functions }
+        GraphicsDevice { _id: id, functions }
     }
 
     pub fn exists(&self) -> bool {
         self.functions.iter().any(|func| func.path().exists())
     }
 
+    pub fn functions(&self) -> &[PciDevice] {
+        &self.functions
+    }
+
     pub fn unbind(&self) -> Result<(), std::io::Error> {
         for func in self.functions.iter() {
             if func.path().exists() {
@@ -95,6 +102,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() {

daemon/src/ctrl_leds.rs

@@ -0,0 +1,468 @@
+// Only these two packets must be 17 bytes
+static LED_APPLY: [u8; 17] = [0x5d, 0xb4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+static LED_SET: [u8; 17] = [0x5d, 0xb5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+static KBD_BRIGHT_PATH: &str = "/sys/class/leds/asus::kbd_backlight/brightness";
+
+use crate::{
+    config_aura::AuraConfig,
+    error::RogError,
+    laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
+};
+use log::{error, info, warn};
+use rog_types::{LED_MSG_LEN, aura_modes::{AuraEffect, AuraModeNum, LedBrightness}};
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::path::Path;
+use std::sync::Arc;
+use std::sync::Mutex;
+use zbus::dbus_interface;
+
+use crate::GetSupported;
+
+use serde_derive::{Deserialize, Serialize};
+#[derive(Serialize, Deserialize)]
+pub struct LedSupportedFunctions {
+    pub brightness_set: bool,
+    pub stock_led_modes: Option<Vec<AuraModeNum>>,
+    pub multizone_led_mode: bool,
+    pub per_key_led_mode: bool,
+}
+
+impl GetSupported for CtrlKbdBacklight {
+    type A = LedSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        // let mode = <&str>::from(&<AuraModes>::from(*mode));
+        let multizone_led_mode = false;
+        let per_key_led_mode = false;
+        let laptop = LaptopLedData::get_data();
+        let stock_led_modes = if let Some(data) = laptop {
+            if data.standard.is_empty() {
+                None
+            } else {
+                Some(data.standard)
+            }
+        } else {
+            None
+        };
+
+        LedSupportedFunctions {
+            brightness_set: CtrlKbdBacklight::get_kbd_bright_path().is_some(),
+            stock_led_modes,
+            multizone_led_mode,
+            per_key_led_mode,
+        }
+    }
+}
+
+pub struct CtrlKbdBacklight {
+    led_node: Option<String>,
+    pub bright_node: String,
+    supported_modes: LaptopLedData,
+    flip_effect_write: bool,
+    config: AuraConfig,
+}
+
+pub struct DbusKbdBacklight {
+    inner: Arc<Mutex<CtrlKbdBacklight>>,
+}
+
+impl DbusKbdBacklight {
+    pub fn new(inner: Arc<Mutex<CtrlKbdBacklight>>) -> Self {
+        Self { inner }
+    }
+}
+
+trait Dbus {
+    fn set_led(&mut self, data: String);
+    fn ledmode(&self) -> String;
+    fn notify_led(&self, data: &str) -> zbus::Result<()>;
+}
+
+impl crate::ZbusAdd for DbusKbdBacklight {
+    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at("/org/asuslinux/Led", self)
+            .map_err(|err| {
+                error!("DbusKbdBacklight: add_to_server {}", err);
+            })
+            .ok();
+    }
+}
+
+/// The main interface for changing, reading, or notfying signals
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl DbusKbdBacklight {
+    fn set_brightness(&mut self, brightness: LedBrightness) {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            ctrl.set_brightness(brightness)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+        }
+    }
+
+    fn set_led_mode(&mut self, effect: AuraEffect) {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            let mode_name = effect.mode_name();
+            match ctrl.do_command(effect) {
+                Ok(_) => {
+                    self.notify_led(&mode_name).ok();
+                }
+                Err(err) => {
+                    warn!("{}", err);
+                }
+            }
+        }
+    }
+
+    fn next_led_mode(&self) {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.toggle_mode(false)
+                .unwrap_or_else(|err| warn!("{}", err));
+
+            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                if let Ok(json) = serde_json::to_string(&mode) {
+                    self.notify_led(&json)
+                        .unwrap_or_else(|err| warn!("{}", err));
+                }
+            }
+        }
+    }
+
+    fn prev_led_mode(&self) {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.toggle_mode(true)
+                .unwrap_or_else(|err| warn!("{}", err));
+
+            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                if let Ok(json) = serde_json::to_string(&mode) {
+                    self.notify_led(&json)
+                        .unwrap_or_else(|err| warn!("{}", err));
+                }
+            }
+        }
+    }
+
+    /// Return the current mode data
+    #[dbus_interface(property)]
+    fn led_mode(&self) -> String {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                if let Ok(json) = serde_json::to_string(&mode) {
+                    return json;
+                }
+            }
+        }
+        warn!("SetKeyBacklight could not deserialise");
+        "SetKeyBacklight could not deserialise".to_string()
+    }
+
+    /// Return a list of available modes
+    #[dbus_interface(property)]
+    fn led_modes(&self) -> String {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Ok(json) = serde_json::to_string(&ctrl.config.builtins) {
+                return json;
+            }
+        }
+        warn!("SetKeyBacklight could not deserialise");
+        "SetKeyBacklight could not serialise".to_string()
+    }
+
+    /// Return the current LED brightness
+    #[dbus_interface(property)]
+    fn led_brightness(&self) -> i8 {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            return ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1);
+        }
+        warn!("SetKeyBacklight could not serialise");
+        -1
+    }
+
+    #[dbus_interface(signal)]
+    fn notify_led(&self, data: &str) -> zbus::Result<()>;
+}
+
+impl crate::Reloadable for CtrlKbdBacklight {
+    fn reload(&mut self) -> Result<(), RogError> {
+        // set current mode (if any)
+        if self.supported_modes.standard.len() > 1 {
+            let current_mode = self.config.current_mode;
+            if self.supported_modes.standard.contains(&(current_mode)) {
+                let mode = self
+                    .config
+                    .builtins
+                    .get(&current_mode)
+                    .ok_or(RogError::NotSupported)?
+                    .to_owned();
+                self.write_mode(&mode)?;
+                info!("Reloaded last used mode");
+            } else {
+                warn!(
+                    "An unsupported mode was set: {}, reset to first mode available",
+                    <&str>::from(&self.config.current_mode)
+                );
+                self.config.builtins.remove(&current_mode);
+                self.config.current_mode = AuraModeNum::Static;
+                // TODO: do a recursive call with a boxed dyn future later
+                let mode = self
+                    .config
+                    .builtins
+                    .get(&current_mode)
+                    .ok_or(RogError::NotSupported)?
+                    .to_owned();
+                self.write_mode(&mode)?;
+                info!("Reloaded last used mode");
+            }
+        }
+
+        // Reload brightness
+        let bright = self.config.brightness;
+        self.set_brightness(bright)?;
+        info!("Reloaded last used brightness");
+        Ok(())
+    }
+}
+
+impl crate::CtrlTask for CtrlKbdBacklight {
+    fn do_task(&mut self) -> Result<(), RogError> {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(&self.bright_node)
+            .map_err(|err| match err.kind() {
+                std::io::ErrorKind::NotFound => {
+                    RogError::MissingLedBrightNode((&self.bright_node).into(), err)
+                }
+                _ => RogError::Path((&self.bright_node).into(), err),
+            })?;
+        let mut buf = [0u8; 1];
+        file.read_exact(&mut buf)
+            .map_err(|err| RogError::Read("buffer".into(), err))?;
+        if let Some(num) = char::from(buf[0]).to_digit(10) {
+            if self.config.brightness != num.into() {
+                self.config.read();
+                self.config.brightness = num.into();
+                self.config.write();
+            }
+            return Ok(());
+        }
+        Err(RogError::ParseLED)
+    }
+}
+
+impl CtrlKbdBacklight {
+    #[inline]
+    pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> {
+        // TODO: return error if *all* nodes are None
+        let mut led_node = None;
+        for prod in ASUS_KEYBOARD_DEVICES.iter() {
+            match Self::find_led_node(prod) {
+                Ok(node) => {
+                    led_node = Some(node);
+                    break;
+                }
+                Err(err) => warn!("led_node: {}", err),
+            }
+        }
+
+        let bright_node = Self::get_kbd_bright_path();
+
+        if led_node.is_none() && bright_node.is_none() {
+            return Err(RogError::MissingFunction(
+                "All keyboard features missing, you may require a v5.11 series kernel or newer"
+                    .into(),
+            ));
+        }
+
+        if bright_node.is_none() {
+            return Err(RogError::MissingFunction(
+                "No brightness control, you may require a v5.11 series kernel or newer".into(),
+            ));
+        }
+
+        let ctrl = CtrlKbdBacklight {
+            led_node,
+            bright_node: bright_node.unwrap(), // If was none then we already returned above
+            supported_modes,
+            flip_effect_write: false,
+            config,
+        };
+        Ok(ctrl)
+    }
+
+    fn get_kbd_bright_path() -> Option<String> {
+        if Path::new(KBD_BRIGHT_PATH).exists() {
+            return Some(KBD_BRIGHT_PATH.to_string());
+        }
+        None
+    }
+
+    pub fn get_brightness(&self) -> Result<u8, RogError> {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(&self.bright_node)
+            .map_err(|err| match err.kind() {
+                std::io::ErrorKind::NotFound => {
+                    RogError::MissingLedBrightNode((&self.bright_node).into(), err)
+                }
+                _ => RogError::Path((&self.bright_node).into(), err),
+            })?;
+        let mut buf = [0u8; 1];
+        file.read_exact(&mut buf)
+            .map_err(|err| RogError::Read("buffer".into(), err))?;
+        Ok(buf[0])
+    }
+
+    pub fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
+        let path = Path::new(&self.bright_node);
+        let mut file = OpenOptions::new()
+            .write(true)
+            .open(&path)
+            .map_err(|err| match err.kind() {
+                std::io::ErrorKind::NotFound => {
+                    RogError::MissingLedBrightNode((&self.bright_node).into(), err)
+                }
+                _ => RogError::Path((&self.bright_node).into(), err),
+            })?;
+        file.write_all(&[brightness.as_char_code()])
+            .map_err(|err| RogError::Read("buffer".into(), err))?;
+        Ok(())
+    }
+
+    fn find_led_node(id_product: &str) -> Result<String, RogError> {
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            RogError::Udev("enumerator failed".into(), err)
+        })?;
+        enumerator.match_subsystem("hidraw").map_err(|err| {
+            warn!("{}", err);
+            RogError::Udev("match_subsystem failed".into(), err)
+        })?;
+
+        for device in enumerator.scan_devices().map_err(|err| {
+            warn!("{}", err);
+            RogError::Udev("scan_devices failed".into(), err)
+        })? {
+            if let Some(parent) = device
+                .parent_with_subsystem_devtype("usb", "usb_device")
+                .map_err(|err| {
+                    warn!("{}", err);
+                    RogError::Udev("parent_with_subsystem_devtype failed".into(), err)
+                })?
+            {
+                if parent
+                    .attribute_value("idProduct")
+                    .ok_or_else(|| RogError::NotFound("LED idProduct".into()))?
+                    == id_product
+                {
+                    if let Some(dev_node) = device.devnode() {
+                        info!("Using device at: {:?} for LED control", dev_node);
+                        return Ok(dev_node.to_string_lossy().to_string());
+                    }
+                }
+            }
+        }
+        Err(RogError::MissingFunction(
+            "ASUS LED device node not found".into(),
+        ))
+    }
+
+    pub(crate) fn do_command(&mut self, mode: AuraEffect) -> Result<(), RogError> {
+        self.set_and_save(mode)
+    }
+
+    /// Should only be used if the bytes you are writing are verified correct
+    #[inline]
+    fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        if let Some(led_node) = &self.led_node {
+            if let Ok(mut file) = OpenOptions::new().write(true).open(led_node) {
+                // println!("write: {:02x?}", &message);
+                return file
+                    .write_all(message)
+                    .map_err(|err| RogError::Write("write_bytes".into(), err));
+            }
+        }
+        Err(RogError::NotSupported)
+    }
+
+    /// Write an effect block
+    #[inline]
+    fn write_effect(&mut self, effect: &[Vec<u8>]) -> Result<(), RogError> {
+        if self.flip_effect_write {
+            for row in effect.iter().rev() {
+                self.write_bytes(row)?;
+            }
+        } else {
+            for row in effect.iter() {
+                self.write_bytes(row)?;
+            }
+        }
+        self.flip_effect_write = !self.flip_effect_write;
+        Ok(())
+    }
+
+    /// Used to set a builtin mode and save the settings for it
+    ///
+    /// This needs to be universal so that settings applied by dbus stick
+    #[inline]
+    fn set_and_save(&mut self, mode: AuraEffect) -> Result<(), RogError> {
+        self.config.read();
+        self.write_mode(&mode)?;
+        self.config.current_mode = *mode.mode();
+        self.config.set_builtin(mode);
+        self.config.write();
+        Ok(())
+    }
+
+    #[inline]
+    fn toggle_mode(&mut self, reverse: bool) -> Result<(), RogError> {
+        let current = self.config.current_mode;
+        if let Some(idx) = self
+            .supported_modes
+            .standard
+            .iter()
+            .position(|v| *v == current)
+        {
+            let mut idx = idx;
+            // goes past end of array
+            if reverse {
+                if idx == 0 {
+                    idx = self.supported_modes.standard.len() - 1;
+                } else {
+                    idx -= 1;
+                }
+            } else {
+                idx += 1;
+                if idx == self.supported_modes.standard.len() {
+                    idx = 0;
+                }
+            }
+            let next = self.supported_modes.standard[idx];
+
+            self.config.read();
+            if let Some(data) = self.config.builtins.get(&next) {
+                self.write_mode(&data)?;
+                self.config.current_mode = next;
+            }
+            self.config.write();
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    fn write_mode(&self, mode: &AuraEffect) -> Result<(), RogError> {
+        if !self.supported_modes.standard.contains(&mode.mode()) {
+            return Err(RogError::NotSupported);
+        }
+        let bytes: [u8; LED_MSG_LEN] = mode.into();
+        self.write_bytes(&bytes)?;
+        self.write_bytes(&LED_SET)?;
+        // Changes won't persist unless apply is set
+        self.write_bytes(&LED_APPLY)?;
+        Ok(())
+    }
+}

daemon/src/ctrl_rog_bios.rs

@@ -1,27 +1,25 @@
-use crate::{
-    config::Config,
-    ctrl_gfx::{gfx::CtrlGraphics, vendors::GfxVendors},
-    error::RogError,
-    GetSupported,
-};
-//use crate::dbus::DbusEvents;
-use log::{info, warn};
+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::BufRead;
 use std::io::{Read, Write};
 use std::path::Path;
+use std::process::Command;
 use std::sync::Arc;
 use std::sync::Mutex;
 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 =
     "/sys/firmware/efi/efivars/AsusPostLogoSound-607005d5-3f75-4b2e-98f0-85ba66797a3e";
 
 pub struct CtrlRogBios {
-    config: Arc<Mutex<Config>>,
+    _config: Arc<Mutex<Config>>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -44,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
@@ -103,7 +101,7 @@ impl CtrlRogBios {
 impl crate::ZbusAdd for CtrlRogBios {
     fn add_to_server(self, server: &mut zbus::ObjectServer) {
         server
-            .at(&"/org/asuslinux/RogBios".try_into().unwrap(), self)
+            .at("/org/asuslinux/RogBios", self)
             .map_err(|err| {
                 warn!("CtrlRogBios: add_to_server {}", err);
                 err
@@ -138,12 +136,10 @@ impl CtrlRogBios {
             }
         }
 
-        Ok(CtrlRogBios { config })
+        Ok(CtrlRogBios { _config: config })
     }
 
     fn set_path_mutable(path: &str) -> Result<(), RogError> {
-        use std::process::Command;
-
         let output = Command::new("/usr/bin/chattr")
             .arg("-i")
             .arg(path)
@@ -183,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)
@@ -205,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(())
     }
@@ -258,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()));
+            } else {
+                info!("Successfully updated initramfs");
+            }
+        }
+        Ok(())
+    }
 }

daemon/src/ctrl_supported.rs

@@ -1,5 +1,3 @@
-use std::convert::TryInto;
-
 use log::warn;
 use serde_derive::{Deserialize, Serialize};
 use zbus::dbus_interface;
@@ -15,11 +13,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")]
@@ -32,7 +30,7 @@ impl SupportedFunctions {
 impl crate::ZbusAdd for SupportedFunctions {
     fn add_to_server(self, server: &mut zbus::ObjectServer) {
         server
-            .at(&"/org/asuslinux/Supported".try_into().unwrap(), self)
+            .at("/org/asuslinux/Supported", self)
             .map_err(|err| {
                 warn!("SupportedFunctions: add_to_server {}", err);
                 err

daemon/src/daemon.rs

@@ -1,19 +1,16 @@
-use daemon::ctrl_charge::CtrlCharge;
-use daemon::ctrl_fan_cpu::{CtrlFanAndCPU, DbusFanAndCpu};
+use daemon::{ctrl_fan_cpu::{CtrlFanAndCPU, DbusFanAndCpu}, laptops::LaptopLedData};
 use daemon::ctrl_leds::{CtrlKbdBacklight, DbusKbdBacklight};
-use daemon::laptops::match_laptop;
 use daemon::{
-    config::Config, laptops::print_board_info, supported::SupportedFunctions, GetSupported,
-};
-use daemon::{
-    ctrl_anime::CtrlAnimeDisplay,
-    ctrl_gfx::{gfx::CtrlGraphics, vendors::GfxVendors},
+    config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
 };
+use daemon::{config_aura::AuraConfig, ctrl_charge::CtrlCharge};
+use daemon::{ctrl_anime::CtrlAnimeDisplay, ctrl_gfx::gfx::CtrlGraphics};
 
-use asus_nb::DBUS_NAME;
 use daemon::{CtrlTask, Reloadable, ZbusAdd};
 use log::LevelFilter;
 use log::{error, info, warn};
+use rog_dbus::DBUS_NAME;
+use rog_types::gfx_vendors::GfxVendors;
 use std::error::Error;
 use std::io::Write;
 use std::sync::Arc;
@@ -21,7 +18,6 @@ use std::sync::Mutex;
 
 use daemon::ctrl_rog_bios::CtrlRogBios;
 use std::convert::Into;
-use std::convert::TryInto;
 use zbus::fdo;
 use zbus::Connection;
 
@@ -33,7 +29,10 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         .filter(None, LevelFilter::Info)
         .init();
 
-    info!("Version: {}", daemon::VERSION);
+    info!("   daemon v{}", daemon::VERSION);
+    info!(" rog-dbus v{}", rog_dbus::VERSION);
+    info!("rog-types v{}", rog_types::VERSION);
+
     start_daemon()?;
     Ok(())
 }
@@ -50,12 +49,9 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
     print_board_info();
     println!("{}", serde_json::to_string_pretty(&supported).unwrap());
 
-    let laptop = match_laptop();
-    let config = if let Some(laptop) = laptop.as_ref() {
-        Config::load(laptop.supported_modes())
-    } else {
-        Config::load(&[])
-    };
+    let config = Config::load();
+    let enable_gfx_switching = config.gfx_managed;
+    let config = Arc::new(Mutex::new(config));
 
     let connection = Connection::new_system()?;
     fdo::DBusProxy::new(&connection)?
@@ -64,9 +60,6 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
 
     supported.add_to_server(&mut object_server);
 
-    let enable_gfx_switching = config.gfx_managed;
-    let config = Arc::new(Mutex::new(config));
-
     match CtrlRogBios::new(config.clone()) {
         Ok(mut ctrl) => {
             // Do a reload of any settings
@@ -108,20 +101,20 @@ 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");
+                                let devices = ctrl.devices();
+                                let bus = ctrl.bus();
+                                CtrlGraphics::do_vendor_tasks(GfxVendors::Nvidia, &devices, &bus)?;
                             } else if ded == 0 {
                                 info!("Dedicated GFX toggle is off");
                             }
                         }
                     }
-                } else {
-                    ctrl.reload()
-                        .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
                 }
+                ctrl.reload()
+                    .unwrap_or_else(|err| error!("Gfx controller: {}", err));
                 ctrl.add_to_server(&mut object_server);
             }
             Err(err) => {
@@ -133,31 +126,32 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
     // Collect tasks for task thread
     let mut tasks: Vec<Arc<Mutex<dyn CtrlTask + Send>>> = Vec::new();
 
-    if let Ok(mut ctrl) = CtrlFanAndCPU::new(config.clone()).map_err(|err| {
+    if let Ok(mut ctrl) = CtrlFanAndCPU::new(config).map_err(|err| {
         error!("Profile control: {}", err);
     }) {
         ctrl.reload()
             .unwrap_or_else(|err| warn!("Profile control: {}", err));
         let tmp = Arc::new(Mutex::new(ctrl));
-        DbusFanAndCpu::new(tmp.clone()).add_to_server(&mut object_server);
-        tasks.push(tmp);
+        DbusFanAndCpu::new(tmp).add_to_server(&mut object_server);
     };
 
-    if let Some(laptop) = laptop {
+    if let Some(laptop) = LaptopLedData::get_data() {
+    if !laptop.standard.is_empty() {
+        let aura_config = AuraConfig::load(&laptop);
+
         if let Ok(ctrl) = CtrlKbdBacklight::new(
-            laptop.usb_product(),
-            laptop.condev_iface(),
-            laptop.supported_modes().to_owned(),
-            config,
+            laptop,
+            aura_config,
         )
         .map_err(|err| {
             error!("Keyboard control: {}", err);
+            err
         }) {
             let tmp = Arc::new(Mutex::new(ctrl));
             DbusKbdBacklight::new(tmp.clone()).add_to_server(&mut object_server);
             tasks.push(tmp);
         }
-    }
+    }}
 
     // TODO: implement messaging between threads to check fails
     // These tasks generally read a sys path or file to check for a
@@ -178,10 +172,15 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
             }
         });
 
-    object_server.with(&"/org/asuslinux/Charge".try_into()?, |obj: &CtrlCharge| {
-        let x = obj.limit();
-        obj.notify_charge(x as u8)
-    })?;
+    object_server
+        .with("/org/asuslinux/Charge", |obj: &CtrlCharge| {
+            let x = obj.limit();
+            obj.notify_charge(x as u8)
+        })
+        .map_err(|err| {
+            warn!("object_server notify_charge error: {}", err);
+        })
+        .ok();
 
     loop {
         if let Err(err) = object_server.try_handle_next() {

daemon/src/error.rs

@@ -1,5 +1,6 @@
 use intel_pstate::PStateError;
 use rog_fan_curve::CurveError;
+use rog_types::error::GraphicsError;
 use std::convert::From;
 use std::fmt;
 
@@ -24,6 +25,11 @@ pub enum RogError {
     MissingLedBrightNode(String, std::io::Error),
     ReloadFail(String),
     GfxSwitching(GfxError),
+    Initramfs(String),
+    Modprobe(String),
+    Command(String, std::io::Error),
+    Io(std::io::Error),
+    Zbus(zbus::Error),
 }
 
 impl fmt::Display for RogError {
@@ -47,6 +53,11 @@ 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),
+            RogError::Io(detail) => write!(f, "std::io error: {}", detail),
+            RogError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
         }
     }
 }
@@ -64,3 +75,23 @@ impl From<CurveError> for RogError {
         RogError::FanCurve(err)
     }
 }
+
+impl From<GraphicsError> for RogError {
+    fn from(err: GraphicsError) -> Self {
+        match err {
+            GraphicsError::ParseVendor => RogError::GfxSwitching(GfxError::ParseVendor),
+        }
+    }
+}
+
+impl From<zbus::Error> for RogError {
+    fn from(err: zbus::Error) -> Self {
+        RogError::Zbus(err)
+    }
+}
+
+impl From<std::io::Error> for RogError {
+    fn from(err: std::io::Error) -> Self {
+        RogError::Io(err)
+    }
+}

daemon/src/laptops.rs

@@ -0,0 +1,96 @@
+use log::{info, warn};
+use rog_types::aura_modes::AuraModeNum;
+use serde_derive::{Deserialize, Serialize};
+use std::fs::OpenOptions;
+use std::io::Read;
+
+pub const ASUS_LED_MODE_CONF: &str = "/etc/asusd/asusd-ledmodes.toml";
+pub const ASUS_KEYBOARD_DEVICES: [&str; 4] = ["1866", "1869", "1854", "19b6"];
+
+pub fn print_board_info() {
+    let dmi = sysfs_class::DmiId::default();
+    let board_name = dmi.board_name().expect("Could not get board_name");
+    let prod_name = dmi.product_name().expect("Could not get product_name");
+    let prod_family = dmi.product_family().expect("Could not get product_family");
+
+    info!("Product name: {}", prod_name.trim());
+    info!("Product family: {}", prod_family.trim());
+    info!("Board name: {}", board_name.trim());
+}
+
+pub fn print_modes(supported_modes: &[u8]) {
+    if !supported_modes.is_empty() {
+        info!("Supported Keyboard LED modes are:");
+        for mode in supported_modes {
+            let mode = <&str>::from(&<AuraModeNum>::from(*mode));
+            info!("- {}", mode);
+        }
+        info!(
+            "If these modes are incorrect you can edit {}",
+            ASUS_LED_MODE_CONF
+        );
+    } else {
+        info!("No RGB control available");
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct LedSupportFile {
+    led_data: Vec<LaptopLedData>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct LaptopLedData {
+    pub prod_family: String,
+    pub board_names: Vec<String>,
+    pub standard: Vec<AuraModeNum>,
+    pub multizone: bool,
+    pub per_key: bool,
+}
+
+impl LaptopLedData {
+    pub fn get_data() -> Option<Self> {
+        let dmi = sysfs_class::DmiId::default();
+        let board_name = dmi.board_name().expect("Could not get board_name");
+        let prod_family = dmi.product_family().expect("Could not get product_family");
+
+        if let Some(modes) = LedSupportFile::load_from_config() {
+            return modes.matcher(&prod_family, &board_name);
+        }
+        None
+    }
+}
+
+impl LedSupportFile {
+    /// Consumes the LEDModes
+    fn matcher(self, prod_family: &str, board_name: &str) -> Option<LaptopLedData> {
+        for config in self.led_data {
+            if prod_family.contains(&config.prod_family) {
+                for board in &config.board_names {
+                    if board_name.contains(board) {
+                        info!("Matched to {} {}", config.prod_family, board);
+                        return Some(config);
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    fn load_from_config() -> Option<Self> {
+        if let Ok(mut file) = OpenOptions::new().read(true).open(&ASUS_LED_MODE_CONF) {
+            let mut buf = String::new();
+            if let Ok(l) = file.read_to_string(&mut buf) {
+                if l == 0 {
+                    warn!("{} is empty", ASUS_LED_MODE_CONF);
+                } else {
+                    return Some(toml::from_str(&buf).unwrap_or_else(|_| {
+                        panic!("Could not deserialise {}", ASUS_LED_MODE_CONF)
+                    }));
+                }
+            }
+        }
+        warn!("Does {} exist?", ASUS_LED_MODE_CONF);
+        None
+    }
+}

daemon/src/lib.rs

@@ -1,15 +1,27 @@
 #![deny(unused_must_use)]
 /// Configuration loading, saving
 pub mod config;
-///
+pub mod config_aura;
+pub(crate) mod config_old;
+/// Control of AniMe matrix display
 pub mod ctrl_anime;
-///
+/// Control of battery charge level
 pub mod ctrl_charge;
+/// Control CPU min/max freq and turbo, fan mode, fan curves
 ///
+/// Intel machines can control:
+/// - CPU min/max frequency
+/// - CPU turbo enable/disable
+/// - Fan mode (normal, boost, silent)
+///
+/// AMD machines can control:
+/// - CPU turbo enable/disable
+/// - Fan mode (normal, boost, silent)
+/// - Fan min/max RPM curve
 pub mod ctrl_fan_cpu;
-///
+/// GPU switching and power
 pub mod ctrl_gfx;
-///
+/// Keyboard LED brightness control, RGB, and LED display modes
 pub mod ctrl_leds;
 /// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
 pub mod ctrl_rog_bios;
@@ -17,7 +29,7 @@ pub mod ctrl_rog_bios;
 pub mod laptops;
 
 /// Fetch all supported functions for the laptop
-pub mod supported;
+pub mod ctrl_supported;
 
 mod error;
 

data/asusd-ledmodes.toml

@@ -1,49 +1,83 @@
-[[led_modes]]
+[[led_data]]
 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]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = false
+per_key = true
 
-[[led_modes]]
+[[led_data]]
 prod_family = "Zephyrus M"
 board_names = ["GU502GV"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = false
+per_key = true
 
-[[led_modes]]
+[[led_data]]
 prod_family = "ROG Zephyrus M15"
 board_names = ["GU502LW"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = false
+per_key = true
 
-[[led_modes]]
+[[led_data]]
+prod_family = "ROG Zephyrus M15"
+board_names = ["GU502LU"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = false
+per_key = false
+
+[[led_data]]
 prod_family = "Zephyrus"
 board_names = ["GM501GM", "GX531"]
-led_modes = [0, 1, 2, 3, 10, 13]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = true
+per_key = false
 
-[[led_modes]]
+[[led_data]]
 prod_family = "ROG Strix"
 board_names = ["G531GW"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = false
+per_key = true
 
-[[led_modes]]
+[[led_data]]
 prod_family = "ROG Strix"
 board_names = ["GX531", "G512LV", "G712LV"]
-led_modes = [0, 1, 2, 3, 10, 13]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = true
+per_key = false
 
-[[led_modes]]
+[[led_data]]
 prod_family = "ROG Strix"
-board_names = ["G512LI", "G712LI"]
-led_modes = [0, 1, 2, 3, 10]
+board_names = ["G512LI", "G712LI", "G531GD"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = false
+per_key = false
 
-[[led_modes]]
+[[led_data]]
 prod_family = "Strix"
 board_names = ["G731GV", "G731GW", "G531GV"]
-led_modes = [0, 1, 2, 3, 13]
+standard = ["Static", "Breathe", "Strobe", "Rainbow"]
+multizone = true
+per_key = false
 
-[[led_modes]]
+[[led_data]]
 prod_family = "Strix"
 board_names = ["G731GT", "G731GU", "G531GT", "G531GU"]
-led_modes = [0, 1, 2, 3]
+standard = ["Static", "Breathe", "Strobe", "Rainbow"]
+multizone = false
+per_key = false
 
-[[led_modes]]
+[[led_data]]
 prod_family = "Strix Scar"
 board_names = ["G531", "G731"]
-led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 255]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = true
+per_key = true
+
+[[led_data]]
+prod_family = "ROG"
+board_names = ["GL553VE"]
+standard = ["Static", "Breathe", "Strobe"]
+multizone = true
+per_key = false

data/asusd.conf

@@ -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"/>

data/asusd.rules

@@ -1 +1,2 @@
-ACTION=="add|change", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="18[0-9][0-9]", ENV{ID_TYPE}=="hid", TAG+="systemd", ENV{SYSTEMD_WANTS}="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"

data/asusd.service

@@ -2,6 +2,7 @@
 Description=ASUS Notebook Control
 StartLimitInterval=200
 StartLimitBurst=2
+Before=display-manager.service
 
 [Service]
 ExecStart=/usr/bin/asusd

data/completions/asusctl.fish

@@ -0,0 +1,77 @@
+# Author: AlenPaulVarghese <alenpaul2001@gmail.com>
+
+set -l progname asusctl
+
+set -l noopt "not __fish_contains_opt -s -s h -s v -s s -s k -s f -s c help version show-supported kbd-bright fan-mode chg-limit; and not __fish_seen_subcommand_from led-mode profile graphics;"
+
+
+set -l gmod_options '__fish_contains_opt -s m mode;'
+set -l fan_options '__fish_contains_opt -s f fan-mode;'
+set -l led_options '__fish_seen_subcommand_from led-mode;'
+set -l profile_options '__fish_seen_subcommand_from profile;'
+set -l keyboard_options '__fish_contains_opt -s k kbd-bright;'
+set -l graphics_options '__fish_seen_subcommand_from graphics;'
+
+set -l fan_modes 'silent normal boost'
+set -l brightness_modes 'off low med high'
+set -l led_modes 'static breathe strobe rainbow comet'
+set -l graphics_modes 'nvidia hybird compute integrated'
+
+
+complete -c $progname -e
+complete -c $progname -f
+
+# asusctl completion
+complete -c $progname -s h -f -l help -n "$noopt" -d "print help message"
+complete -c $progname -s v -f -l version -n "$noopt" -d "show program version number"
+complete -c $progname -s s -f -l show-supported -n "$noopt" -d "show supported functions of this laptop"
+complete -c $progname -s k -f -l kbd-bright -n "$noopt" -d "set led brightness"
+complete -c $progname -s f -f -l fan-mode -n "$noopt" -d "set fan mode independent of profile"
+complete -c $progname -s c -f -l chg-limit -n "$noopt" -d "set charge limit <20-100>"
+complete -c $progname -f -a "led-mode" -n "$noopt" -d "Set the keyboard lighting from built-in modes"
+complete -c $progname -f -a "profile" -n "$noopt" -d "Create and configure profiles"
+complete -c $progname -f -a "graphics" -n "$noopt" -d "Set the graphics mode"
+
+# brightness completion
+complete -c $progname -n "$keyboard_options" -d "available brightness modes" -a "$brightness_modes"
+
+# fan completion
+complete -c $progname -n "$fan_options" -d "available fan modes" -a $fan_modes
+
+# graphics completion
+set -l gopt 'not __fish_contains_opt -s h -s g -s m -s p help mode get pow;'
+
+complete -c $progname -n "$graphics_options and $gopt" -a "-h" -d "print help message"
+complete -c $progname -n "$graphics_options and $gopt" -a "-g" -d "Get the current mode"
+
+complete -c $progname -s h -f -l help -n "$graphics_options and $gopt" -d "print help message"
+complete -c $progname -s m -f -l mode -n "$graphics_options and $gopt" -d "Set graphics mode: <nvidia, hybrid, compute, integrated>"
+complete -c $progname -s g -f -l get -n "$graphics_options and $gopt" -d "Get the current mode"
+complete -c $progname -s p -f -l pow -n "$graphics_options and $gopt" -d "Get the current power status"
+
+complete -c $progname -n "$graphics_options and $gmod_options" -d "available graphics modes" -a "$graphics_modes"
+
+# led-mode completion
+complete -c $progname -n "$led_options" -a "-h" -d "print help message"
+complete -c $progname -n "$led_options" -a "-n" -d "switch to next aura mode"
+
+complete -c $progname -s h -f -l help -n "$led_options" -d "print help message"
+complete -c $progname -s n -f -l next-mode -n "$led_options" -d "switch to nex aura mode"
+complete -c $progname -s p -f -l prev-mode -n "$led_options" -d "switch to previous aura mode"
+complete -c $progname -n "$led_options" -d "available led modes" -a "$led_modes"
+
+# profile completion
+set -l popt 'not __fish_contains_opt -s h -s n -s c -s t -s m -s M -s f help next create turbo min-percentage max-percentage fan-preset;'
+
+complete -c $progname -n "$profile_options and $popt" -a "-h" -d "print help message"
+complete -c $progname -n "$profile_options and $popt" -a "-n" -d "toggle to next profile in list"
+
+complete -c $progname -s h -f -l help -n "$profile_options and $popt" -d "print help message"
+complete -c $progname -s n -f -l next -n "$profile_options and $popt" -d "toggle to next profile in list"
+complete -c $progname -s c -f -l create -n "$profile_options and $popt" -d "create the profile if it doesn't exist"
+complete -c $progname -s t -f -l turbo -n "$profile_options and $popt" -d "enable or disable cpu turbo"
+complete -c $progname -s m -f -l min-percentage -n "$profile_options and $popt" -d "set min cpu scaling (intel)"
+complete -c $progname -s M -f -l max-percentage -n "$profile_options and $popt" -d "set max cpu scaling (intel)"
+complete -c $progname -s f -f -l fan-preset -n "$profile_options and $popt" -d "<silent, normal, boost>"
+complete -c $progname -n "$profile_option and __fish_contains_opt fan-preset" -d "available fan modes" -a $fan_modes
+

rog-dbus/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rog_dbus"
+version = "3.0.0"
+license = "MPL-2.0"
+readme = "README.md"
+authors = ["Luke <luke@ljones.dev>"]
+repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
+homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
+description = "dbus interface methods for asusctl"
+edition = "2018"
+
+[dependencies]
+serde_json = "^1.0"
+rog_types = { path = "../rog-types" }
+rog_fan_curve = { version = "^0.1", features = ["serde"] }
+zbus = "^1.8"
+zbus_macros = "^1.8"
+zvariant = "^2.5"

rog-dbus/src/lib.rs

@@ -0,0 +1,171 @@
+pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
+pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
+pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
+pub const LED_MSG_LEN: usize = 17;
+
+pub mod zbus_anime;
+pub mod zbus_charge;
+pub mod zbus_gfx;
+pub mod zbus_led;
+pub mod zbus_profile;
+pub mod zbus_rogbios;
+pub mod zbus_supported;
+
+use rog_types::{
+    aura_modes::AuraEffect,
+    gfx_vendors::{GfxRequiredUserAction, GfxVendors},
+};
+use std::sync::{Arc, Mutex};
+use zbus::{Connection, Result, SignalReceiver};
+
+pub static VERSION: &str = env!("CARGO_PKG_VERSION");
+pub struct DbusProxies<'a> {
+    anime: zbus_anime::AnimeProxy<'a>,
+    charge: zbus_charge::ChargeProxy<'a>,
+    gfx: zbus_gfx::GfxProxy<'a>,
+    led: zbus_led::LedProxy<'a>,
+    profile: zbus_profile::ProfileProxy<'a>,
+    rog_bios: zbus_rogbios::RogBiosProxy<'a>,
+    supported: zbus_supported::SupportProxy<'a>,
+}
+
+impl<'a> DbusProxies<'a> {
+    #[inline]
+    pub fn new() -> Result<(Self, Connection)> {
+        let conn = Connection::new_system()?;
+
+        Ok((
+            DbusProxies {
+                anime: zbus_anime::AnimeProxy::new(&conn)?,
+                led: zbus_led::LedProxy::new(&conn)?,
+                charge: zbus_charge::ChargeProxy::new(&conn)?,
+                gfx: zbus_gfx::GfxProxy::new(&conn)?,
+                profile: zbus_profile::ProfileProxy::new(&conn)?,
+                rog_bios: zbus_rogbios::RogBiosProxy::new(&conn)?,
+                supported: zbus_supported::SupportProxy::new(&conn)?,
+            },
+            conn,
+        ))
+    }
+
+    pub fn setup_recv(&'a self, conn: Connection) -> SignalReceiver {
+        let mut recv = SignalReceiver::new(conn);
+        //recv.receive_for(&self.proxy_anime);
+        recv.receive_for(self.led.proxy());
+        recv.receive_for(self.charge.proxy());
+        recv.receive_for(self.gfx.proxy());
+        recv.receive_for(self.profile.proxy());
+        recv
+    }
+
+    pub fn anime(&self) -> &zbus_anime::AnimeProxy<'a> {
+        &self.anime
+    }
+
+    pub fn charge(&self) -> &zbus_charge::ChargeProxy<'a> {
+        &self.charge
+    }
+
+    pub fn gfx(&self) -> &zbus_gfx::GfxProxy<'a> {
+        &self.gfx
+    }
+
+    pub fn led(&self) -> &zbus_led::LedProxy<'a> {
+        &self.led
+    }
+
+    pub fn profile(&self) -> &zbus_profile::ProfileProxy<'a> {
+        &self.profile
+    }
+
+    pub fn rog_bios(&self) -> &zbus_rogbios::RogBiosProxy<'a> {
+        &self.rog_bios
+    }
+
+    pub fn supported(&self) -> &zbus_supported::SupportProxy<'a> {
+        &self.supported
+    }
+}
+
+// Signals separated out
+pub struct Signals {
+    pub gfx_vendor: Arc<Mutex<Option<GfxVendors>>>,
+    pub gfx_action: Arc<Mutex<Option<GfxRequiredUserAction>>>,
+    pub profile: Arc<Mutex<Option<String>>>,
+    pub led_mode: Arc<Mutex<Option<AuraEffect>>>,
+    pub charge: Arc<Mutex<Option<u8>>>,
+}
+
+impl Signals {
+    #[inline]
+    pub fn new(proxies: &DbusProxies) -> Result<Self> {
+        //
+        let charge_signal = Arc::new(Mutex::new(None));
+        proxies
+            .charge
+            .connect_notify_charge(charge_signal.clone())?;
+
+        //
+        let ledmode_signal = Arc::new(Mutex::new(None));
+        proxies.led.connect_notify_led(ledmode_signal.clone())?;
+
+        let gfx_action_signal = Arc::new(Mutex::new(None));
+        proxies
+            .gfx
+            .connect_notify_action(gfx_action_signal.clone())?;
+
+        let gfx_vendor_signal = Arc::new(Mutex::new(None));
+        proxies.gfx.connect_notify_gfx(gfx_vendor_signal.clone())?;
+
+        let profile_signal = Arc::new(Mutex::new(None));
+        proxies
+            .profile
+            .connect_notify_profile(profile_signal.clone())?;
+
+        Ok(Signals {
+            gfx_vendor: gfx_vendor_signal,
+            gfx_action: gfx_action_signal,
+            profile: profile_signal,
+            led_mode: ledmode_signal,
+            charge: charge_signal,
+        })
+    }
+}
+
+/// This is the main way to communicate with the DBUS interface
+pub struct AuraDbusClient<'a> {
+    proxies: DbusProxies<'a>,
+    signals: Signals,
+}
+
+impl<'a> AuraDbusClient<'a> {
+    #[inline]
+    pub fn new() -> Result<(Self, Connection)> {
+        let (proxies, conn) = DbusProxies::new()?;
+        let signals = Signals::new(&proxies)?;
+
+        Ok((AuraDbusClient { proxies, signals }, conn))
+    }
+
+    pub fn proxies(&self) -> &DbusProxies {
+        &self.proxies
+    }
+
+    /*
+     * GFX
+     */
+    pub fn gfx_wait_changed(&self) -> Result<GfxRequiredUserAction> {
+        loop {
+            if let Ok(res) = self.proxies.gfx.proxy().next_signal() {
+                if res.is_none() {
+                    if let Ok(lock) = self.signals.gfx_action.lock() {
+                        if let Some(stuff) = lock.as_ref() {
+                            return Ok(*stuff);
+                        }
+                    }
+                    // return Ok("Failed for unknown reason".to_owned());
+                }
+            }
+        }
+    }
+}

rog-dbus/src/zbus_anime.rs

@@ -0,0 +1,74 @@
+//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/Anime' from service 'org.asuslinux.Daemon' on system bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://zeenix.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::IntrospectableProxy`]
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::PropertiesProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use rog_types::anime_matrix::{AniMeDataBuffer, AniMeImageBuffer};
+use zbus::{dbus_proxy, Connection, Result};
+
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Anime"
+)]
+trait Daemon {
+    /// SetBootOnOff method
+    fn set_boot_on_off(&self, status: bool) -> zbus::Result<()>;
+
+    /// SetOnOff method
+    fn set_on_off(&self, status: bool) -> zbus::Result<()>;
+
+    /// WriteDirect method
+    fn write_direct(&self, input: &[u8]) -> zbus::Result<()>;
+
+    /// WriteImage method
+    fn write_image(&self, input: &[Vec<u8>]) -> zbus::Result<()>;
+}
+
+pub struct AnimeProxy<'a>(DaemonProxy<'a>);
+
+impl<'a> AnimeProxy<'a> {
+    #[inline]
+    pub fn new(conn: &Connection) -> Result<Self> {
+        Ok(AnimeProxy(DaemonProxy::new(&conn)?))
+    }
+
+    pub fn proxy(&self) -> &DaemonProxy<'a> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn toggle_boot_on(&self, on: bool) -> Result<()> {
+        self.0.set_boot_on_off(on)
+    }
+
+    #[inline]
+    pub fn toggle_on(&self, on: bool) -> Result<()> {
+        self.0.set_on_off(on)
+    }
+
+    #[inline]
+    pub fn write_direct(&self, input: AniMeDataBuffer) -> Result<()> {
+        self.0.write_direct(input.get())
+    }
+
+    #[inline]
+    pub fn write_image(&self, input: AniMeImageBuffer) -> Result<()> {
+        self.0.write_image(input.get())
+    }
+}

rog-dbus/src/zbus_charge.rs

@@ -0,0 +1,73 @@
+//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/Charge' from service 'org.asuslinux.Daemon' on system bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://zeenix.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PropertiesProxy`]
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use std::sync::{Arc, Mutex};
+
+use zbus::{dbus_proxy, Connection, Result};
+
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Charge"
+)]
+trait Daemon {
+    /// Limit method
+    fn limit(&self) -> zbus::Result<i16>;
+
+    /// SetLimit method
+    fn set_limit(&self, limit: u8) -> zbus::Result<()>;
+
+    /// NotifyCharge signal
+    #[dbus_proxy(signal)]
+    fn notify_charge(&self, limit: u8) -> zbus::Result<()>;
+}
+
+pub struct ChargeProxy<'a>(DaemonProxy<'a>);
+
+impl<'a> ChargeProxy<'a> {
+    #[inline]
+    pub fn new(conn: &Connection) -> Result<Self> {
+        Ok(ChargeProxy(DaemonProxy::new(&conn)?))
+    }
+
+    pub fn proxy(&self) -> &DaemonProxy<'a> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn write_limit(&self, level: u8) -> Result<()> {
+        self.0.set_limit(level)
+    }
+
+    #[inline]
+    pub fn get_limit(&self) -> Result<i16> {
+        self.0.limit()
+    }
+
+    #[inline]
+    pub fn connect_notify_charge(&self, charge: Arc<Mutex<Option<u8>>>) -> zbus::fdo::Result<()> {
+        self.0.connect_notify_charge(move |data| {
+            if let Ok(mut lock) = charge.lock() {
+                *lock = Some(data);
+            }
+            Ok(())
+        })
+    }
+}

rog-dbus/src/zbus_gfx.rs

@@ -0,0 +1,102 @@
+//! # DBus interface proxy for: `org.asuslinux.Gfx`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/Gfx' from service 'org.asuslinux.Daemon' on system bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://zeenix.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PropertiesProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//! * [`zbus::fdo::PeerProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use std::sync::{Arc, Mutex};
+
+use rog_types::gfx_vendors::{GfxRequiredUserAction, GfxVendors};
+use zbus::{dbus_proxy, Connection, Result};
+
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Gfx"
+)]
+trait Daemon {
+    /// Power method
+    fn power(&self) -> zbus::Result<String>;
+
+    /// SetVendor method
+    fn set_vendor(&self, vendor: &GfxVendors) -> zbus::Result<GfxRequiredUserAction>;
+
+    /// Vendor method
+    fn vendor(&self) -> zbus::Result<GfxVendors>;
+
+    /// NotifyAction signal
+    #[dbus_proxy(signal)]
+    fn notify_action(&self, action: GfxRequiredUserAction) -> zbus::Result<()>;
+
+    /// NotifyGfx signal
+    #[dbus_proxy(signal)]
+    fn notify_gfx(&self, vendor: GfxVendors) -> zbus::Result<()>;
+}
+
+pub struct GfxProxy<'a>(DaemonProxy<'a>);
+
+impl<'a> GfxProxy<'a> {
+    #[inline]
+    pub fn new(conn: &Connection) -> Result<Self> {
+        Ok(GfxProxy(DaemonProxy::new(&conn)?))
+    }
+
+    pub fn proxy(&self) -> &DaemonProxy<'a> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn gfx_get_pwr(&self) -> Result<String> {
+        self.0.power()
+    }
+
+    #[inline]
+    pub fn gfx_get_mode(&self) -> Result<GfxVendors> {
+        self.0.vendor()
+    }
+
+    #[inline]
+    pub fn gfx_write_mode(&self, vendor: &GfxVendors) -> Result<GfxRequiredUserAction> {
+        self.0.set_vendor(vendor)
+    }
+
+    #[inline]
+    pub fn connect_notify_action(
+        &self,
+        action: Arc<Mutex<Option<GfxRequiredUserAction>>>,
+    ) -> zbus::fdo::Result<()> {
+        self.0.connect_notify_action(move |data| {
+            if let Ok(mut lock) = action.lock() {
+                *lock = Some(data);
+            }
+            Ok(())
+        })
+    }
+
+    #[inline]
+    pub fn connect_notify_gfx(
+        &self,
+        vendor: Arc<Mutex<Option<GfxVendors>>>,
+    ) -> zbus::fdo::Result<()> {
+        self.0.connect_notify_gfx(move |data| {
+            if let Ok(mut lock) = vendor.lock() {
+                *lock = Some(data);
+            }
+            Ok(())
+        })
+    }
+}

rog-dbus/src/zbus_led.rs

@@ -0,0 +1,146 @@
+//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/Led' from service 'org.asuslinux.Daemon' on system bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://zeenix.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//! * [`zbus::fdo::PropertiesProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use std::sync::{Arc, Mutex};
+
+use zbus::{dbus_proxy, Connection, Result};
+
+use rog_types::{aura_modes::{AuraEffect, LedBrightness}, aura_perkey::KeyColourArray};
+
+const BLOCKING_TIME: u64 = 40; // 100ms = 10 FPS, max 50ms = 20 FPS, 40ms = 25 FPS
+
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Led"
+)]
+trait Daemon {
+    /// NextLedMode method
+    fn next_led_mode(&self) -> zbus::Result<()>;
+
+    /// PrevLedMode method
+    fn prev_led_mode(&self) -> zbus::Result<()>;
+
+    /// SetBrightness method
+    fn set_brightness(&self, brightness: LedBrightness) -> zbus::Result<()>;
+
+    /// SetLedMode method
+    fn set_led_mode(&self, effect: &AuraEffect) -> zbus::Result<()>;
+
+    /// NotifyLed signal
+    /// NotifyLed signal
+    #[dbus_proxy(signal)]
+    fn notify_led(&self, data: &str) -> zbus::Result<()>;
+
+    /// LedBrightness property
+    #[dbus_proxy(property)]
+    fn led_brightness(&self) -> zbus::Result<i16>;
+
+    /// LedMode property
+    #[dbus_proxy(property)]
+    fn led_mode(&self) -> zbus::Result<String>;
+
+    /// LedModes property
+    #[dbus_proxy(property)]
+    fn led_modes(&self) -> zbus::Result<String>;
+}
+
+pub struct LedProxy<'a>(DaemonProxy<'a>);
+
+impl<'a> LedProxy<'a> {
+    #[inline]
+    pub fn new(conn: &Connection) -> Result<Self> {
+        Ok(LedProxy(DaemonProxy::new(&conn)?))
+    }
+
+    pub fn proxy(&self) -> &DaemonProxy<'a> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn get_led_brightness(&self) -> Result<i16> {
+        self.0.led_brightness()
+    }
+
+    #[inline]
+    pub fn set_led_brightness(&self, level: LedBrightness) -> Result<()> {
+        self.0.set_brightness(level)?;
+        Ok(())
+    }
+
+    #[inline]
+    pub fn next_led_mode(&self) -> Result<()> {
+        self.0.next_led_mode()
+    }
+
+    #[inline]
+    pub fn prev_led_mode(&self) -> Result<()> {
+        self.0.prev_led_mode()
+    }
+
+    #[inline]
+    pub fn set_led_mode(&self, mode: &AuraEffect) -> Result<()> {
+        self.0.set_led_mode(mode)
+    }
+
+    /// Write a single colour block.
+    ///
+    /// Intentionally blocks for 10ms after sending to allow the block to
+    /// be written to the keyboard EC. This should not be async.
+    #[inline]
+    pub fn set_per_key(&self, key_colour_array: &KeyColourArray) -> Result<()> {
+        let group = key_colour_array.get();
+        let mut vecs = Vec::with_capacity(group.len());
+        for v in group {
+            vecs.push(v.to_vec());
+        }
+        // TODO: let mode = AuraModes::PerKey(vecs);
+        // self.set_led_mode(&mode)?;
+
+        std::thread::sleep(std::time::Duration::from_millis(BLOCKING_TIME));
+
+        // if self.stop.load(Ordering::Relaxed) {
+        //     println!("Keyboard backlight was changed, exiting");
+        //     std::process::exit(1)
+        // }
+        Ok(())
+    }
+
+    /// This method must always be called before the very first write to initialise
+    /// the keyboard LED EC in the correct mode
+    #[inline]
+    pub fn init_effect(&self) -> Result<()> {
+        // TODO: let mode = AuraModes::PerKey(vec![vec![]]);
+        // self.0.set_led_mode(&serde_json::to_string(&mode).unwrap())
+        Ok(())
+    }
+
+    #[inline]
+    pub fn connect_notify_led(&self, led: Arc<Mutex<Option<AuraEffect>>>) -> zbus::fdo::Result<()> {
+        self.0.connect_notify_led(move |data| {
+            if let Ok(mut lock) = led.lock() {
+                if let Ok(dat) = serde_json::from_str(&data) {
+                    *lock = Some(dat);
+                }
+            }
+            Ok(())
+        })
+    }
+}

rog-dbus/src/zbus_profile.rs

@@ -0,0 +1,113 @@
+//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/Profile' from service 'org.asuslinux.Daemon' on system bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://zeenix.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::IntrospectableProxy`]
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::PropertiesProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use std::sync::{Arc, Mutex};
+
+use rog_types::profile::ProfileEvent;
+use zbus::{dbus_proxy, Connection, Result};
+
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Profile"
+)]
+trait Daemon {
+    /// ActiveProfileName method
+    fn active_profile_name(&self) -> zbus::Result<String>;
+
+    /// NextProfile method
+    fn next_profile(&self) -> zbus::Result<()>;
+
+    /// Profile method
+    fn profile(&self) -> zbus::Result<String>;
+
+    /// Profiles method
+    fn profiles(&self) -> zbus::Result<String>;
+
+    /// ProfileNames method
+    fn profile_names(&self) -> zbus::Result<String>;
+
+    /// Remove method
+    fn remove(&self, profile: &str) -> zbus::Result<()>;
+
+    /// SetProfile method
+    fn set_profile(&self, profile: &str) -> zbus::Result<()>;
+
+    /// NotifyProfile signal
+    #[dbus_proxy(signal)]
+    fn notify_profile(&self, profile: &str) -> zbus::Result<()>;
+}
+
+pub struct ProfileProxy<'a>(DaemonProxy<'a>);
+
+impl<'a> ProfileProxy<'a> {
+    #[inline]
+    pub fn new(conn: &Connection) -> Result<Self> {
+        Ok(ProfileProxy(DaemonProxy::new(&conn)?))
+    }
+
+    pub fn proxy(&self) -> &DaemonProxy<'a> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn active_profile_name(&self) -> Result<String> {
+        self.0.active_profile_name()
+    }
+
+    #[inline]
+    pub fn next_fan(&self) -> Result<()> {
+        self.0.next_profile()
+    }
+
+    #[inline]
+    pub fn write_fan_mode(&self, level: u8) -> Result<()> {
+        self.0
+            .set_profile(&serde_json::to_string(&ProfileEvent::ChangeMode(level)).unwrap())
+    }
+
+    #[inline]
+    pub fn write_command(&self, cmd: &ProfileEvent) -> Result<()> {
+        self.0.set_profile(&serde_json::to_string(cmd).unwrap())
+    }
+
+    #[inline]
+    pub fn profile_names(&self) -> Result<String> {
+        self.0.profile_names()
+    }
+
+    #[inline]
+    pub fn remove(&self, profile: &str) -> Result<()> {
+        self.0.remove(profile)
+    }
+
+    #[inline]
+    pub fn connect_notify_profile(
+        &self,
+        charge: Arc<Mutex<Option<String>>>,
+    ) -> zbus::fdo::Result<()> {
+        self.0.connect_notify_profile(move |data| {
+            if let Ok(mut lock) = charge.lock() {
+                *lock = Some(data.to_owned());
+            }
+            Ok(())
+        })
+    }
+}

rog-dbus/src/zbus_rogbios.rs

@@ -0,0 +1,109 @@
+//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/RogBios' from service 'org.asuslinux.Daemon' on system bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://zeenix.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PropertiesProxy`]
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use std::sync::{Arc, Mutex};
+
+use zbus::{dbus_proxy, Connection, Result};
+
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/RogBios"
+)]
+trait Daemon {
+    /// DedicatedGraphicMode method
+    fn dedicated_graphic_mode(&self) -> zbus::Result<i16>;
+
+    /// PostBootSound method
+    fn post_boot_sound(&self) -> zbus::Result<i16>;
+
+    /// SetDedicatedGraphicMode method
+    fn set_dedicated_graphic_mode(&self, dedicated: bool) -> zbus::Result<()>;
+
+    /// SetPostBootSound method
+    fn set_post_boot_sound(&self, on: bool) -> zbus::Result<()>;
+
+    /// NotifyDedicatedGraphicMode signal
+    #[dbus_proxy(signal)]
+    fn notify_dedicated_graphic_mode(&self, dedicated: bool) -> zbus::Result<()>;
+
+    /// NotifyPostBootSound signal
+    #[dbus_proxy(signal)]
+    fn notify_post_boot_sound(&self, dedicated: bool) -> zbus::Result<()>;
+}
+
+pub struct RogBiosProxy<'a>(DaemonProxy<'a>);
+
+impl<'a> RogBiosProxy<'a> {
+    #[inline]
+    pub fn new(conn: &Connection) -> Result<Self> {
+        Ok(RogBiosProxy(DaemonProxy::new(&conn)?))
+    }
+
+    pub fn proxy(&self) -> &DaemonProxy<'a> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn get_dedicated_gfx(&self) -> Result<i16> {
+        self.0.dedicated_graphic_mode()
+    }
+
+    #[inline]
+    pub fn set_dedicated_gfx(&self, on: bool) -> Result<()> {
+        self.0.set_dedicated_graphic_mode(on)
+    }
+
+    #[inline]
+    pub fn get_post_sound(&self) -> Result<i16> {
+        self.0.post_boot_sound()
+    }
+
+    #[inline]
+    pub fn set_post_sound(&self, on: bool) -> Result<()> {
+        self.0.set_post_boot_sound(on)
+    }
+
+    #[inline]
+    pub fn connect_notify_dedicated_graphic_mode(
+        &self,
+        dedicated: Arc<Mutex<Option<bool>>>,
+    ) -> zbus::fdo::Result<()> {
+        self.0.connect_notify_dedicated_graphic_mode(move |data| {
+            if let Ok(mut lock) = dedicated.lock() {
+                *lock = Some(data);
+            }
+            Ok(())
+        })
+    }
+
+    #[inline]
+    pub fn connect_notify_post_boot_sound(
+        &self,
+        sound: Arc<Mutex<Option<bool>>>,
+    ) -> zbus::fdo::Result<()> {
+        self.0.connect_notify_post_boot_sound(move |data| {
+            if let Ok(mut lock) = sound.lock() {
+                *lock = Some(data);
+            }
+            Ok(())
+        })
+    }
+}

rog-dbus/src/zbus_supported.rs

@@ -0,0 +1,49 @@
+//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/Supported' from service 'org.asuslinux.Daemon' on system bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://zeenix.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::PropertiesProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use zbus::{dbus_proxy, Connection, Result};
+
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Supported"
+)]
+trait Daemon {
+    /// SupportedFunctions method
+    fn supported_functions(&self) -> zbus::Result<String>;
+}
+
+pub struct SupportProxy<'a>(DaemonProxy<'a>);
+
+impl<'a> SupportProxy<'a> {
+    #[inline]
+    pub fn new(conn: &Connection) -> Result<Self> {
+        Ok(SupportProxy(DaemonProxy::new(&conn)?))
+    }
+
+    pub fn proxy(&self) -> &DaemonProxy<'a> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn get_supported_functions(&self) -> Result<String> {
+        self.0.supported_functions()
+    }
+}

rog-types/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "asus-nb"
-version = "2.2.1"
+name = "rog_types"
+version = "3.1.1"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -11,14 +11,8 @@ edition = "2018"
 
 [dependencies]
 gumdrop = "^0.8"
-dbus = { version = "^0.8" }
 serde = "^1.0"
 serde_derive = "^1.0"
-serde_json = "^1.0"
-yansi-term = "^0.1"
-rog_fan_curve = { version = "0.1", features = ["serde"] }
-zbus = "^1.8.0"
-zvariant = "^2.4.0"
-
-[dev-dependencies]
-tinybmp = "^0.2.3"
+rog_fan_curve = { version = "^0.1", features = ["serde"] }
+zvariant = "^2.5"
+zvariant_derive = "^2.5"

rog-types/src/anime_matrix.rs

@@ -1,32 +1,76 @@
+use serde_derive::{Deserialize, Serialize};
+use zvariant_derive::Type;
+
 pub const WIDTH: usize = 34; // Width is definitely 34 items
 pub const HEIGHT: usize = 56;
-pub type AniMeBufferType = [[u8; WIDTH]; HEIGHT];
 pub type AniMePacketType = [[u8; 640]; 2];
 const BLOCK_START: usize = 7;
+/// *Not* inclusive, the byte before this is the final for each "pane"
 const BLOCK_END: usize = 634;
-use yansi_term::Colour::RGB;
+pub const PANE_LEN: usize = BLOCK_END - BLOCK_START;
+/// The length of usable data
+pub const FULL_PANE_LEN: usize = PANE_LEN * 2;
 
-/// Helper structure for writing images.
-///
-///  See the examples for ways to write an image to `AniMeMatrix` format.
-pub struct AniMeMatrix(AniMeBufferType);
+pub const ANIME_PANE1_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
+pub const ANIME_PANE2_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
 
-impl Default for AniMeMatrix {
+#[derive(Debug, Deserialize, Serialize, Type)]
+pub struct AniMeDataBuffer(Vec<u8>);
+
+impl Default for AniMeDataBuffer {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl AniMeMatrix {
+impl AniMeDataBuffer {
     pub fn new() -> Self {
-        AniMeMatrix([[0u8; WIDTH]; HEIGHT])
+        AniMeDataBuffer(vec![0u8; FULL_PANE_LEN])
     }
 
-    pub fn get(&self) -> &AniMeBufferType {
+    pub fn get(&self) -> &[u8] {
         &self.0
     }
 
-    pub fn get_mut(&mut self) -> &mut AniMeBufferType {
+    pub fn set(&mut self, input: [u8; FULL_PANE_LEN]) {
+        self.0 = input.to_vec();
+    }
+}
+
+impl From<AniMeDataBuffer> for AniMePacketType {
+    #[inline]
+    fn from(anime: AniMeDataBuffer) -> Self {
+        assert!(anime.0.len() == FULL_PANE_LEN);
+        let mut buffers = [[0; 640]; 2];
+        for (idx, chunk) in anime.0.as_slice().chunks(PANE_LEN).enumerate() {
+            buffers[idx][BLOCK_START..BLOCK_END].copy_from_slice(chunk);
+        }
+        buffers
+    }
+}
+
+/// Helper structure for writing images.
+///
+///  See the examples for ways to write an image to `AniMeMatrix` format.
+#[derive(Debug, Deserialize, Serialize, Type)]
+pub struct AniMeImageBuffer(Vec<Vec<u8>>);
+
+impl Default for AniMeImageBuffer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AniMeImageBuffer {
+    pub fn new() -> Self {
+        AniMeImageBuffer(vec![vec![0u8; WIDTH]; HEIGHT])
+    }
+
+    pub fn get(&self) -> &Vec<Vec<u8>> {
+        &self.0
+    }
+
+    pub fn get_mut(&mut self) -> &mut Vec<Vec<u8>> {
         &mut self.0
     }
 
@@ -55,8 +99,8 @@ impl AniMeMatrix {
                 } else {
                     row.iter()
                 };
-                for x in tmp {
-                    print!(" {}", RGB(*x, *x, *x).paint("XY"));
+                for _ in tmp {
+                    print!(" XY");
                 }
 
                 println!();
@@ -78,9 +122,9 @@ impl AniMeMatrix {
                 if count % 2 == 0 {
                     print!(" ");
                 }
-                for (i, x) in row.iter().enumerate() {
+                for (i, _) in row.iter().enumerate() {
                     if i >= index {
-                        print!(" {}", RGB(*x, *x, *x).paint("XY"));
+                        print!(" XY");
                     } else {
                         print!("   ");
                     }
@@ -91,11 +135,11 @@ impl AniMeMatrix {
     }
 }
 
-impl From<AniMeMatrix> for AniMePacketType {
+impl From<AniMeImageBuffer> for AniMePacketType {
     /// Do conversion from the nested Vec in AniMeMatrix to the two required
     /// packets suitable for sending over USB
     #[inline]
-    fn from(anime: AniMeMatrix) -> Self {
+    fn from(anime: AniMeImageBuffer) -> Self {
         let mut buffers = [[0; 640]; 2];
 
         let mut write_index = BLOCK_START;
@@ -153,15 +197,26 @@ impl From<AniMeMatrix> for AniMePacketType {
 
 #[cfg(test)]
 mod tests {
-    use crate::anime_matrix::{AniMeMatrix, AniMePacketType};
+    use crate::anime_matrix::*;
+
+    use super::AniMeDataBuffer;
+
+    #[test]
+    fn check_from_data_buffer() {
+        let mut data = AniMeDataBuffer::new();
+        data.set([42u8; FULL_PANE_LEN]);
+
+        let out: AniMePacketType = data.into();
+    }
 
     #[test]
     fn check_data_alignment() {
-        let mut matrix = AniMeMatrix::new();
+        let mut matrix = AniMeImageBuffer::new();
         {
             let tmp = matrix.get_mut();
             for row in tmp.iter_mut() {
-                row[row.len() - 1] = 0xff;
+                let idx = row.len() - 1;
+                row[idx] = 0xff;
             }
         }
 

rog-types/src/aura_modes.rs

@@ -0,0 +1,378 @@
+// static LED_INIT1: [u8; 2] = [0x5d, 0xb9];
+// static LED_INIT2: &str = "]ASUS Tech.Inc."; // ] == 0x5d
+// static LED_INIT3: [u8; 6] = [0x5d, 0x05, 0x20, 0x31, 0, 0x08];
+// static LED_INIT4: &str = "^ASUS Tech.Inc."; // ^ == 0x5e
+// static LED_INIT5: [u8; 6] = [0x5e, 0x05, 0x20, 0x31, 0, 0x08];
+
+use crate::error::AuraError;
+use crate::LED_MSG_LEN;
+use serde_derive::{Deserialize, Serialize};
+use std::str::FromStr;
+use zvariant_derive::Type;
+
+#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize, Type)]
+pub enum LedBrightness {
+    Off,
+    Low,
+    Med,
+    High,
+}
+
+impl LedBrightness {
+    pub fn as_char_code(&self) -> u8 {
+        std::char::from_digit(*self as u32, 10).unwrap() as u8
+    }
+}
+
+impl From<u32> for LedBrightness {
+    fn from(bright: u32) -> Self {
+        match bright {
+            0 => LedBrightness::Off,
+            1 => LedBrightness::Low,
+            2 => LedBrightness::Med,
+            3 => LedBrightness::High,
+            _ => LedBrightness::Med,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Copy, Deserialize, Serialize, Type)]
+pub struct Colour(pub u8, pub u8, pub u8);
+
+impl Default for Colour {
+    fn default() -> Self {
+        Colour(166, 0, 0)
+    }
+}
+
+impl FromStr for Colour {
+    type Err = AuraError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.len() < 6 {
+            return Err(AuraError::ParseColour);
+        }
+        let r = u8::from_str_radix(&s[0..2], 16).or(Err(AuraError::ParseColour))?;
+        let g = u8::from_str_radix(&s[2..4], 16).or(Err(AuraError::ParseColour))?;
+        let b = u8::from_str_radix(&s[4..6], 16).or(Err(AuraError::ParseColour))?;
+        Ok(Colour(r, g, b))
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize, Type)]
+pub enum Speed {
+    Low = 0xe1,
+    Med = 0xeb,
+    High = 0xf5,
+}
+impl Default for Speed {
+    fn default() -> Self {
+        Speed::Med
+    }
+}
+impl FromStr for Speed {
+    type Err = AuraError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.as_str() {
+            "low" => Ok(Speed::Low),
+            "med" => Ok(Speed::Med),
+            "high" => Ok(Speed::High),
+            _ => Err(AuraError::ParseSpeed),
+        }
+    }
+}
+
+/// Used for Rainbow mode.
+///
+/// Enum corresponds to the required integer value
+#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize, Type)]
+pub enum Direction {
+    Right,
+    Left,
+    Up,
+    Down,
+}
+impl Default for Direction {
+    fn default() -> Self {
+        Direction::Right
+    }
+}
+impl FromStr for Direction {
+    type Err = AuraError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.as_str() {
+            "right" => Ok(Direction::Right),
+            "up" => Ok(Direction::Up),
+            "down" => Ok(Direction::Down),
+            "left" => Ok(Direction::Left),
+            _ => Err(AuraError::ParseDirection),
+        }
+    }
+}
+
+/// Writes out the correct byte string for brightness
+pub const fn aura_brightness_bytes(brightness: u8) -> [u8; 17] {
+    [
+        0x5A, 0xBA, 0xC5, 0xC4, brightness, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]
+}
+
+#[derive(
+    Debug, Type, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Deserialize, Serialize,
+)]
+pub enum AuraModeNum {
+    Static = 0,
+    Breathe = 1,
+    Strobe = 2,
+    Rainbow = 3,
+    Star = 4,
+    Rain = 5,
+    Highlight = 6,
+    Laser = 7,
+    Ripple = 8,
+    Pulse = 10,
+    Comet = 11,
+    Flash = 12,
+}
+
+impl From<&AuraModeNum> for &str {
+    fn from(mode: &AuraModeNum) -> Self {
+        match mode {
+            AuraModeNum::Static => "Static",
+            AuraModeNum::Breathe => "Breathing",
+            AuraModeNum::Strobe => "Strobing",
+            AuraModeNum::Rainbow => "Rainbow",
+            AuraModeNum::Star => "Stars",
+            AuraModeNum::Rain => "Rain",
+            AuraModeNum::Highlight => "Keypress Highlight",
+            AuraModeNum::Laser => "Keypress Laser",
+            AuraModeNum::Ripple => "Keypress Ripple",
+            AuraModeNum::Pulse => "Pulse",
+            AuraModeNum::Comet => "Comet",
+            AuraModeNum::Flash => "Flash",
+        }
+    }
+}
+impl From<&str> for AuraModeNum {
+    fn from(mode: &str) -> Self {
+        match mode {
+            "Static" => AuraModeNum::Static,
+            "Breathing" => AuraModeNum::Breathe,
+            "Strobing" => AuraModeNum::Strobe,
+            "Rainbow" => AuraModeNum::Rainbow,
+            "Stars" => AuraModeNum::Star,
+            "Rain" => AuraModeNum::Rain,
+            "Keypress Highlight" => AuraModeNum::Highlight,
+            "Keypress Laser" => AuraModeNum::Laser,
+            "Keypress Ripple" => AuraModeNum::Ripple,
+            "Pulse" => AuraModeNum::Pulse,
+            "Comet" => AuraModeNum::Comet,
+            "Flash" => AuraModeNum::Flash,
+            _ => AuraModeNum::Static,
+        }
+    }
+}
+
+impl From<u8> for AuraModeNum {
+    fn from(mode: u8) -> Self {
+        match mode {
+            0 => AuraModeNum::Static,
+            1 => AuraModeNum::Breathe,
+            2 => AuraModeNum::Strobe,
+            3 => AuraModeNum::Rainbow,
+            4 => AuraModeNum::Star,
+            5 => AuraModeNum::Rain,
+            6 => AuraModeNum::Highlight,
+            7 => AuraModeNum::Laser,
+            8 => AuraModeNum::Ripple,
+            10 => AuraModeNum::Pulse,
+            11 => AuraModeNum::Comet,
+            12 => AuraModeNum::Flash,
+            _ => AuraModeNum::Static,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct AuraMultiZone {
+    static_: [AuraEffect; 4],
+    breathe: [AuraEffect; 4],
+}
+
+impl AuraMultiZone {
+    pub fn set(&mut self, effect: AuraEffect) {
+        if effect.mode == AuraModeNum::Static {
+            match effect.zone {
+                AuraZone::None => {}
+                AuraZone::One => self.static_[0] = effect,
+                AuraZone::Two => self.static_[1] = effect,
+                AuraZone::Three => self.static_[2] = effect,
+                AuraZone::Four => self.static_[3] = effect,
+            }
+        } else if effect.mode == AuraModeNum::Breathe {
+            match effect.zone {
+                AuraZone::None => {}
+                AuraZone::One => self.breathe[0] = effect,
+                AuraZone::Two => self.breathe[1] = effect,
+                AuraZone::Three => self.breathe[2] = effect,
+                AuraZone::Four => self.breathe[3] = effect,
+            }
+        }
+    }
+
+    pub fn static_(&self) -> &[AuraEffect; 4] {
+        &self.static_
+    }
+
+    pub fn breathe(&self) -> &[AuraEffect; 4] {
+        &self.breathe
+    }
+}
+
+impl Default for AuraMultiZone {
+    fn default() -> Self {
+        Self {
+            static_: [
+                AuraEffect {
+                    mode: AuraModeNum::Static,
+                    zone: AuraZone::One,
+                    ..Default::default()
+                },
+                AuraEffect {
+                    mode: AuraModeNum::Static,
+                    zone: AuraZone::Two,
+                    ..Default::default()
+                },
+                AuraEffect {
+                    mode: AuraModeNum::Static,
+                    zone: AuraZone::Three,
+                    ..Default::default()
+                },
+                AuraEffect {
+                    mode: AuraModeNum::Static,
+                    zone: AuraZone::Four,
+                    ..Default::default()
+                },
+            ],
+            breathe: [
+                AuraEffect {
+                    mode: AuraModeNum::Breathe,
+                    zone: AuraZone::One,
+                    ..Default::default()
+                },
+                AuraEffect {
+                    mode: AuraModeNum::Breathe,
+                    zone: AuraZone::Two,
+                    ..Default::default()
+                },
+                AuraEffect {
+                    mode: AuraModeNum::Breathe,
+                    zone: AuraZone::Three,
+                    ..Default::default()
+                },
+                AuraEffect {
+                    mode: AuraModeNum::Breathe,
+                    zone: AuraZone::Four,
+                    ..Default::default()
+                },
+            ],
+        }
+    }
+}
+
+/// Base effects have no zoning, while multizone is 1-4
+#[derive(Debug, Type, Copy, Clone, PartialEq, Deserialize, Serialize)]
+pub enum AuraZone {
+    None,
+    One,
+    Two,
+    Three,
+    Four,
+}
+
+/// Default factory modes structure
+#[derive(Debug, Type, Clone, Deserialize, Serialize)]
+pub struct AuraEffect {
+    /// The effect type
+    pub mode: AuraModeNum,
+    /// `AuraZone::None` for no zone or zoneless keyboards
+    pub zone: AuraZone,
+    /// Primary colour for all modes
+    pub colour1: Colour,
+    /// Secondary colour in some modes like Breathing or Stars
+    pub colour2: Colour,
+    /// One of three speeds for modes that support speed (most that animate)
+    pub speed: Speed,
+    /// Up, down, left, right. Only Rainbow mode seems to use this
+    pub direction: Direction,
+}
+
+impl AuraEffect {
+    pub fn mode(&self) -> &AuraModeNum {
+        &self.mode
+    }
+
+    pub fn mode_name(&self) -> String {
+        (<&str>::from(&self.mode)).to_string()
+    }
+
+    pub fn mode_num(&self) -> u8 {
+        self.mode as u8
+    }
+
+    pub fn default_with_mode(mode: AuraModeNum) -> Self {
+        Self {
+            mode,
+            ..Default::default()
+        }
+    }
+
+    pub fn zone(&self) -> AuraZone {
+        self.zone
+    }
+}
+
+impl Default for AuraEffect {
+    fn default() -> Self {
+        Self {
+            mode: AuraModeNum::Static,
+            zone: AuraZone::None,
+            colour1: Colour(166, 0, 0),
+            colour2: Colour(0, 0, 0),
+            speed: Speed::Med,
+            direction: Direction::Right,
+        }
+    }
+}
+
+/// Parses `AuraEffect` in to packet data for writing to the USB interface
+///
+/// Byte structure:
+/// ```ignore
+/// | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12|
+/// |---|---|---|---|---|---|---|---|---|---|---|---|---|
+/// |5d |b3 |00 |03 |ff |00 |00 |00 |00 |00 |00 |ff |00 |
+/// ```
+impl From<&AuraEffect> for [u8; LED_MSG_LEN] {
+    fn from(aura: &AuraEffect) -> Self {
+        let mut msg = [0u8; LED_MSG_LEN];
+        msg[0] = 0x5d;
+        msg[1] = 0xb3;
+        msg[2] = aura.zone as u8;
+        msg[3] = aura.mode as u8;
+        msg[4] = aura.colour1.0;
+        msg[5] = aura.colour1.1;
+        msg[6] = aura.colour1.2;
+        msg[7] = aura.speed as u8;
+        msg[8] = aura.direction as u8;
+        msg[10] = aura.colour2.0;
+        msg[11] = aura.colour2.1;
+        msg[12] = aura.colour2.2;
+
+        msg
+    }
+}

rog-types/src/aura_perkey.rs

@@ -35,8 +35,8 @@ impl KeyColourArray {
 
     /// Initialise and clear the keyboard for custom effects
     #[inline]
-    pub fn get_init_msg() -> Vec<u8> {
-        let mut init = vec![0u8; 64];
+    pub const fn get_init_msg() -> [u8; 64] {
+        let mut init = [0u8; 64];
         init[0] = 0x5d; // Report ID
         init[1] = 0xbc; // Mode = custom??, 0xb3 is builtin
         init

rog-types/src/cli_options.rs

@@ -0,0 +1,57 @@
+use crate::error::AuraError;
+use gumdrop::Options;
+use std::str::FromStr;
+
+#[derive(Copy, Clone, Debug)]
+pub enum AniMeStatusValue {
+    On,
+    Off,
+}
+impl FromStr for AniMeStatusValue {
+    type Err = AuraError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.as_str() {
+            "on" => Ok(AniMeStatusValue::On),
+            "off" => Ok(AniMeStatusValue::Off),
+            _ => {
+                print!("Invalid argument, must be one of: on, off");
+                Err(AuraError::ParseAnime)
+            }
+        }
+    }
+}
+impl From<AniMeStatusValue> for bool {
+    fn from(value: AniMeStatusValue) -> Self {
+        match value {
+            AniMeStatusValue::On => true,
+            AniMeStatusValue::Off => false,
+        }
+    }
+}
+
+#[derive(Options)]
+pub struct AniMeLeds {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(
+        no_long,
+        required,
+        short = "b",
+        meta = "",
+        help = "set all leds brightness value"
+    )]
+    led_brightness: u8,
+}
+impl AniMeLeds {
+    pub fn led_brightness(&self) -> u8 {
+        self.led_brightness
+    }
+}
+
+#[derive(Options)]
+pub enum AniMeActions {
+    #[options(help = "change all leds brightness")]
+    Leds(AniMeLeds),
+}

rog-types/src/gfx_vendors.rs

@@ -0,0 +1,68 @@
+use crate::error::GraphicsError;
+use serde_derive::{Deserialize, Serialize};
+use std::str::FromStr;
+use zvariant_derive::Type;
+
+#[derive(Debug, Type, PartialEq, Copy, Clone, Deserialize, Serialize)]
+pub enum GfxVendors {
+    Nvidia,
+    Integrated,
+    Compute,
+    Vfio,
+    Hybrid,
+}
+
+impl FromStr for GfxVendors {
+    type Err = GraphicsError;
+
+    fn from_str(s: &str) -> Result<Self, GraphicsError> {
+        match s.to_lowercase().as_str() {
+            "nvidia" => Ok(GfxVendors::Nvidia),
+            "hybrid" => Ok(GfxVendors::Hybrid),
+            "compute" => Ok(GfxVendors::Compute),
+            "vfio" => Ok(GfxVendors::Vfio),
+            "integrated" => Ok(GfxVendors::Integrated),
+            "nvidia\n" => Ok(GfxVendors::Nvidia),
+            "hybrid\n" => Ok(GfxVendors::Hybrid),
+            "compute\n" => Ok(GfxVendors::Compute),
+            "vfio\n" => Ok(GfxVendors::Vfio),
+            "integrated\n" => Ok(GfxVendors::Integrated),
+            _ => Err(GraphicsError::ParseVendor),
+        }
+    }
+}
+
+impl From<&GfxVendors> for &str {
+    fn from(gfx: &GfxVendors) -> &'static str {
+        match gfx {
+            GfxVendors::Nvidia => "nvidia",
+            GfxVendors::Hybrid => "hybrid",
+            GfxVendors::Compute => "compute",
+            GfxVendors::Vfio => "vfio",
+            GfxVendors::Integrated => "integrated",
+        }
+    }
+}
+
+impl From<GfxVendors> for &str {
+    fn from(gfx: GfxVendors) -> &'static str {
+        (&gfx).into()
+    }
+}
+
+#[derive(Debug, Type, PartialEq, Copy, Clone, Deserialize, Serialize)]
+pub enum GfxRequiredUserAction {
+    Logout,
+    Reboot,
+    None,
+}
+
+impl From<&GfxRequiredUserAction> for &str {
+    fn from(gfx: &GfxRequiredUserAction) -> &'static str {
+        match gfx {
+            GfxRequiredUserAction::Logout => "logout",
+            GfxRequiredUserAction::Reboot => "reboot",
+            GfxRequiredUserAction::None => "no action",
+        }
+    }
+}

rog-types/src/lib.rs

@@ -0,0 +1,27 @@
+//! This crate is intended for shared types (eg, between daemon and CLI), or
+//! for types that might be useful in third-party crates perhaps for
+//! sending messages over dbus wire
+
+pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
+pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
+pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
+pub const LED_MSG_LEN: usize = 17;
+
+pub mod aura_modes;
+
+pub mod profile;
+
+/// Contains mostly only what is required for parsing CLI options
+pub mod cli_options;
+
+/// Enables you to create fancy RGB effects
+pub mod aura_perkey;
+
+/// Helper functions for the AniMe display
+pub mod anime_matrix;
+
+pub mod gfx_vendors;
+
+pub mod error;
+
+pub static VERSION: &str = env!("CARGO_PKG_VERSION");

rog-types/src/profile.rs

@@ -80,18 +80,26 @@ pub struct ProfileCommand {
     pub next: bool,
     #[options(help = "create the profile if it doesn't exist")]
     pub create: bool,
+    #[options(help = "list available profiles")]
+    pub list: 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>,
+    #[options(help = "remove a profile by name")]
+    pub remove: Option<String>,
 }