split out types, dbus

daemon/src/config.rs

@@ -0,0 +1,210 @@
+use rog_types::aura_modes::AuraModes;
+use log::{error, info, warn};
+use rog_fan_curve::Curve;
+use serde_derive::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+use crate::VERSION;
+
+pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
+
+/// for parsing old v2.1.2 config
+#[derive(Deserialize)]
+struct ConfigV212 {
+    gfx_managed: bool,
+    bat_charge_limit: u8,
+    active_profile: String,
+    toggle_profiles: Vec<String>,
+    power_profiles: BTreeMap<String, Profile>,
+    // TODO: remove power_profile
+    power_profile: u8,
+    kbd_led_brightness: u8,
+    kbd_backlight_mode: u8,
+    kbd_backlight_modes: Vec<AuraModes>,
+}
+
+impl ConfigV212 {
+    fn into_current(self) -> Config {
+        Config {
+            gfx_managed: self.gfx_managed,
+            gfx_nv_mode_is_dedicated: true,
+            active_profile: self.active_profile,
+            toggle_profiles: self.toggle_profiles,
+            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,
+        }
+    }
+}
+
+#[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 {
+        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
+        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);
+            } else {
+                if let Ok(data) = serde_json::from_str(&buf) {
+                    return data;
+                } else if let Ok(data) = serde_json::from_str::<ConfigV212>(&buf) {
+                    let config = data.into_current();
+                    config.write();
+                    info!("Updated config version to: {}", VERSION);
+                    return config;
+                }
+                warn!("Could not deserialise {}", CONFIG_PATH);
+                panic!("Please remove {} then restart asusd", CONFIG_PATH);
+            }
+        }
+        Config::create_default(&mut file, &supported_led_modes)
+    }
+
+    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();
+
+        // 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())
+            .unwrap_or_else(|_| panic!("Could not write {}", CONFIG_PATH));
+        config
+    }
+
+    pub fn read(&mut self) {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(&CONFIG_PATH)
+            .unwrap_or_else(|err| panic!("Error reading {}: {}", 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 {}", CONFIG_PATH);
+            } else {
+                let x: Config = serde_json::from_str(&buf)
+                    .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
+                *self = x;
+            }
+        }
+    }
+
+    pub fn read_new() -> Result<Config, Box<dyn std::error::Error>> {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(&CONFIG_PATH)
+            .unwrap_or_else(|err| panic!("Error reading {}: {}", CONFIG_PATH, err));
+        let mut buf = String::new();
+        file.read_to_string(&mut buf)?;
+        let x: Config = serde_json::from_str(&buf)?;
+        Ok(x)
+    }
+
+    pub fn write(&self) {
+        let mut file = File::create(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));
+    }
+
+    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)]
+pub struct Profile {
+    pub min_percentage: u8,
+    pub max_percentage: u8,
+    pub turbo: bool,
+    pub fan_preset: u8,
+    pub fan_curve: Option<Curve>,
+}
+
+#[deprecated]
+pub type CPUSettings = Profile;
+
+impl Default for Profile {
+    fn default() -> Self {
+        Profile {
+            min_percentage: 0,
+            max_percentage: 100,
+            turbo: false,
+            fan_preset: 0,
+            fan_curve: None,
+        }
+    }
+}

daemon/src/ctrl_anime.rs

@@ -0,0 +1,266 @@
+const INIT_STR: &str = "ASUS Tech.Inc.";
+const PACKET_SIZE: usize = 640;
+
+// Only these two packets must be 17 bytes
+const DEV_PAGE: u8 = 0x5e;
+// These bytes are in [1] position of the array
+const WRITE: u8 = 0xc0;
+const INIT: u8 = 0xc2;
+const SET: u8 = 0xc3;
+const APPLY: u8 = 0xc4;
+
+// Used to turn the panel on and off
+// The next byte can be 0x03 for "on" and 0x00 for "off"
+const ON_OFF: u8 = 0x04;
+
+use rog_types::error::AuraError;
+use log::{error, info, warn};
+use rusb::{Device, DeviceHandle};
+use std::convert::TryInto;
+use std::error::Error;
+use std::time::Duration;
+use zbus::dbus_interface;
+
+use crate::GetSupported;
+
+use serde_derive::{Deserialize, Serialize};
+#[derive(Serialize, Deserialize)]
+pub struct AnimeSupportedFunctions(bool);
+
+impl GetSupported for CtrlAnimeDisplay {
+    type A = AnimeSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        AnimeSupportedFunctions(CtrlAnimeDisplay::get_device(0x0b05, 0x193b).is_ok())
+    }
+}
+
+#[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>>);
+
+    fn set_on_off(&mut self, status: bool);
+
+    fn set_boot_on_off(&mut 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)
+            .map_err(|err| {
+                warn!("CtrlAnimeDisplay: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}
+
+#[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))
+            .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),
+        );
+    }
+
+    fn set_boot_on_off(&mut 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),
+            );
+    }
+}
+
+impl CtrlAnimeDisplay {
+    #[inline]
+    pub fn new() -> Result<CtrlAnimeDisplay, Box<dyn Error>> {
+        // We don't expect this ID to ever change
+        let device = CtrlAnimeDisplay::get_device(0x0b05, 0x193b)?;
+
+        let mut device = device.open()?;
+        device.reset()?;
+
+        device.set_auto_detach_kernel_driver(true).map_err(|err| {
+            error!("Auto-detach kernel driver failed: {}", err);
+            err
+        })?;
+
+        device.claim_interface(0).map_err(|err| {
+            error!("Could not claim device interface: {}", err);
+            err
+        })?;
+
+        info!("Device has an AniMe Matrix display");
+        Ok(CtrlAnimeDisplay {
+            handle: device,
+            initialised: false,
+        })
+    }
+
+    #[inline]
+    fn get_device(vendor: u16, product: u16) -> Result<Device<rusb::GlobalContext>, rusb::Error> {
+        for device in rusb::devices()?.iter() {
+            let device_desc = device.device_descriptor()?;
+            if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
+                return Ok(device);
+            }
+        }
+        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> {
+        match self.handle.write_control(
+            0x21,  // request_type
+            0x09,  // request
+            0x35e, // value
+            0x00,  // index
+            message,
+            Duration::from_millis(200),
+        ) {
+            Ok(_) => {}
+            Err(err) => match err {
+                rusb::Error::Timeout => {}
+                _ => error!("Failed to write to led interrupt: {}", err),
+            },
+        }
+        Ok(())
+    }
+
+    /// 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 pane 1: 0x5e 0xc0 0x02 0x01 0x00 0x73 0x02 .. <led brightness>
+    /// - Write pane 2: 0x5e 0xc0 0x02 0x74 0x02 0x73 0x02 .. <led brightness>
+    ///
+    /// Where led brightness is 0..255, low to high
+    #[inline]
+    fn write_image(&mut self, image: Vec<Vec<u8>>) -> Result<(), AuraError> {
+        for row in image.iter() {
+            self.write_bytes(row)?;
+        }
+        self.do_flush()?;
+        Ok(())
+    }
+
+    #[inline]
+    fn do_initialization(&mut 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)?;
+
+        // clear the init array and write other init message
+        for ch in init.iter_mut() {
+            *ch = 0;
+        }
+        init[0] = DEV_PAGE; // write it to be sure?
+        init[1] = INIT;
+
+        self.write_bytes(&init)?;
+        self.initialised = true;
+        Ok(())
+    }
+
+    #[inline]
+    fn do_flush(&mut self) -> Result<(), AuraError> {
+        let mut flush = [0; PACKET_SIZE];
+        flush[0] = DEV_PAGE;
+        flush[1] = WRITE;
+        flush[2] = 0x03;
+
+        self.write_bytes(&flush)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn do_set_boot(&mut 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)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn do_apply(&mut 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)?;
+        Ok(())
+    }
+}

daemon/src/ctrl_charge.rs

@@ -0,0 +1,125 @@
+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;
+use std::sync::Arc;
+use std::sync::Mutex;
+use zbus::dbus_interface;
+
+static BAT_CHARGE_PATH: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
+
+#[derive(Serialize, Deserialize)]
+pub struct ChargeSupportedFunctions {
+    pub charge_level_set: bool,
+}
+
+impl GetSupported for CtrlCharge {
+    type A = ChargeSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        ChargeSupportedFunctions {
+            charge_level_set: CtrlCharge::get_battery_path().is_ok(),
+        }
+    }
+}
+
+pub struct CtrlCharge {
+    config: Arc<Mutex<Config>>,
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlCharge {
+    pub fn set_limit(&mut self, limit: u8) {
+        if let Ok(mut config) = self.config.try_lock() {
+            self.set(limit, &mut config)
+                .map_err(|err| {
+                    warn!("CtrlCharge: set_limit {}", err);
+                    err
+                })
+                .ok();
+            self.notify_charge(limit)
+                .map_err(|err| {
+                    warn!("CtrlCharge: set_limit {}", err);
+                    err
+                })
+                .ok();
+        }
+    }
+
+    pub fn limit(&self) -> i8 {
+        if let Ok(config) = self.config.try_lock() {
+            return config.bat_charge_limit as i8;
+        }
+        -1
+    }
+
+    #[dbus_interface(signal)]
+    pub fn notify_charge(&self, limit: u8) -> zbus::Result<()> {}
+}
+
+impl crate::ZbusAdd for CtrlCharge {
+    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at(&"/org/asuslinux/Charge".try_into().unwrap(), self)
+            .map_err(|err| {
+                warn!("CtrlCharge: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}
+
+impl crate::Reloadable for CtrlCharge {
+    fn reload(&mut self) -> Result<(), RogError> {
+        if let Ok(mut config) = self.config.try_lock() {
+            config.read();
+            self.set(config.bat_charge_limit, &mut config)?;
+        }
+        Ok(())
+    }
+}
+
+impl CtrlCharge {
+    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
+        CtrlCharge::get_battery_path()?;
+        Ok(CtrlCharge { config })
+    }
+
+    fn get_battery_path() -> Result<&'static str, RogError> {
+        if Path::new(BAT_CHARGE_PATH).exists() {
+            Ok(BAT_CHARGE_PATH)
+        } else {
+            Err(RogError::MissingFunction(
+                "Charge control not available, you may require a v5.8.10 series kernel or newer"
+                    .into(),
+            ))
+        }
+    }
+
+    pub(super) fn set(&self, limit: u8, config: &mut Config) -> Result<(), RogError> {
+        if limit < 20 || limit > 100 {
+            warn!(
+                "Unable to set battery charge limit, must be between 20-100: requested {}",
+                limit
+            );
+        }
+
+        let mut file = OpenOptions::new()
+            .write(true)
+            .open(BAT_CHARGE_PATH)
+            .map_err(|err| RogError::Path(BAT_CHARGE_PATH.into(), err))?;
+        file.write_all(limit.to_string().as_bytes())
+            .map_err(|err| RogError::Write(BAT_CHARGE_PATH.into(), err))?;
+        info!("Battery charge limit: {}", limit);
+
+        config.read();
+        config.bat_charge_limit = limit;
+        config.write();
+
+        Ok(())
+    }
+}

daemon/src/ctrl_fan_cpu.rs

@@ -0,0 +1,438 @@
+use crate::{
+    config::{Config, Profile},
+    GetSupported,
+};
+use rog_types::profile::ProfileEvent;
+use log::{info, warn};
+use serde_derive::{Deserialize, Serialize};
+use std::convert::TryInto;
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::path::Path;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::sync::Mutex;
+use zbus::dbus_interface;
+
+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";
+static AMD_BOOST_PATH: &str = "/sys/devices/system/cpu/cpufreq/boost";
+
+pub struct CtrlFanAndCPU {
+    pub path: &'static str,
+    config: Arc<Mutex<Config>>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct FanCpuSupportedFunctions {
+    pub stock_fan_modes: bool,
+    pub min_max_freq: bool,
+    pub fan_curve_set: bool,
+}
+
+impl GetSupported for CtrlFanAndCPU {
+    type A = FanCpuSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        FanCpuSupportedFunctions {
+            stock_fan_modes: CtrlFanAndCPU::get_fan_path().is_ok(),
+            min_max_freq: intel_pstate::PState::new().is_ok(),
+            fan_curve_set: rog_fan_curve::Board::from_board_name().is_some(),
+        }
+    }
+}
+
+pub struct DbusFanAndCpu {
+    inner: Arc<Mutex<CtrlFanAndCPU>>,
+}
+
+impl DbusFanAndCpu {
+    pub fn new(inner: Arc<Mutex<CtrlFanAndCPU>>) -> Self {
+        Self { inner }
+    }
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl DbusFanAndCpu {
+    /// Set profile details
+    fn set_profile(&self, profile: String) {
+        if let Ok(event) = serde_json::from_str(&profile) {
+            if let Ok(mut ctrl) = self.inner.try_lock() {
+                if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
+                    cfg.read();
+                    ctrl.handle_profile_event(&event, &mut cfg)
+                        .unwrap_or_else(|err| warn!("{}", err));
+                    self.notify_profile(&cfg.active_profile)
+                        .unwrap_or_else(|_| ());
+                }
+            }
+        }
+    }
+
+    /// Fetch the active profile name
+    fn next_profile(&mut self) {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
+                ctrl.do_next_profile(&mut cfg)
+                    .unwrap_or_else(|err| warn!("{}", err));
+                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));
+                    }
+                }
+            }
+        }
+    }
+
+    /// Fetch the active profile name
+    fn active_profile_name(&mut self) -> String {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Ok(mut cfg) = ctrl.config.try_lock() {
+                cfg.read();
+                return cfg.active_profile.clone();
+            }
+        }
+        "Failed".to_string()
+    }
+
+    /// Fetch the active profile details
+    fn profile(&mut self) -> String {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Ok(mut cfg) = ctrl.config.try_lock() {
+                cfg.read();
+                if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
+                    if let Ok(json) = serde_json::to_string(profile) {
+                        return json;
+                    }
+                }
+            }
+        }
+        "Failed".to_string()
+    }
+
+    fn profiles(&mut self) -> String {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Ok(mut cfg) = ctrl.config.try_lock() {
+                cfg.read();
+                if let Ok(json) = serde_json::to_string(&cfg.power_profiles) {
+                    return json;
+                }
+            }
+        }
+        "Failed".to_string()
+    }
+
+    #[dbus_interface(signal)]
+    fn notify_profile(&self, profile: &str) -> zbus::Result<()> {}
+}
+
+impl crate::ZbusAdd for DbusFanAndCpu {
+    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at(&"/org/asuslinux/Profile".try_into().unwrap(), self)
+            .map_err(|err| {
+                warn!("DbusFanAndCpu: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}
+
+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)
+            );
+        }
+        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()?;
+        info!("Device has thermal throttle control");
+        Ok(CtrlFanAndCPU { path, config })
+    }
+
+    fn get_fan_path() -> Result<&'static str, RogError> {
+        if Path::new(FAN_TYPE_1_PATH).exists() {
+            Ok(FAN_TYPE_1_PATH)
+        } else if Path::new(FAN_TYPE_2_PATH).exists() {
+            Ok(FAN_TYPE_2_PATH)
+        } else {
+            Err(RogError::MissingFunction(
+                "Fan mode not available, you may require a v5.8.10 series kernel or newer".into(),
+            ))
+        }
+    }
+
+    /// Toggle to next profile in list
+    pub(super) fn do_next_profile(&mut self, config: &mut Config) -> Result<(), RogError> {
+        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, config)?;
+
+        info!("Profile was changed: {}", &new_profile);
+        Ok(())
+    }
+
+    pub(super) 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)
+            .open(self.path)
+            .map_err(|err| RogError::Path(self.path.into(), err))?;
+        config.read();
+        let mut mode_config = config
+            .power_profiles
+            .get_mut(&mode)
+            .ok_or_else(|| RogError::MissingProfile(mode.clone()))?;
+        config.power_profile = 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(())
+    }
+
+    fn handle_profile_event(
+        &mut self,
+        event: &ProfileEvent,
+        config: &mut Config,
+    ) -> Result<(), RogError> {
+        match event {
+            ProfileEvent::Toggle => self.do_next_profile(config)?,
+            ProfileEvent::ChangeMode(mode) => {
+                self.set_fan_mode(*mode, config)?;
+            }
+            ProfileEvent::Cli(command) => {
+                let profile_key = match command.profile.as_ref() {
+                    Some(k) => k.clone(),
+                    None => config.active_profile.clone(),
+                };
+
+                let mut profile = if command.create {
+                    config
+                        .power_profiles
+                        .entry(profile_key.clone())
+                        .or_insert_with(Profile::default)
+                } else {
+                    config
+                        .power_profiles
+                        .get_mut(&profile_key)
+                        .ok_or_else(|| RogError::MissingProfile(profile_key.clone()))?
+                };
+
+                if command.turbo.is_some() {
+                    profile.turbo = command.turbo.unwrap();
+                }
+                if let Some(min_perc) = command.min_percentage {
+                    profile.min_percentage = min_perc;
+                }
+                if let Some(max_perc) = command.max_percentage {
+                    profile.max_percentage = max_perc;
+                }
+                if let Some(ref preset) = command.preset {
+                    profile.fan_preset = preset.into();
+                }
+                if let Some(ref curve) = command.curve {
+                    profile.fan_curve = Some(curve.clone());
+                }
+
+                self.set(&profile_key, config)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn set(&mut self, profile: &str, config: &mut Config) -> Result<(), RogError> {
+        let mode_config = config
+            .power_profiles
+            .get(profile)
+            .ok_or_else(|| RogError::MissingProfile(profile.into()))?;
+        let mut fan_ctrl = OpenOptions::new()
+            .write(true)
+            .open(self.path)
+            .map_err(|err| RogError::Path(self.path.into(), err))?;
+        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)?;
+
+        config.active_profile = profile.into();
+
+        config.write();
+        Ok(())
+    }
+
+    fn set_pstate_for_fan_mode(&self, mode: &str, config: &mut Config) -> Result<(), RogError> {
+        info!("Setting pstate");
+        let mode_config = config
+            .power_profiles
+            .get(mode)
+            .ok_or_else(|| RogError::MissingProfile(mode.into()))?;
+
+        // Set CPU pstate
+        if let Ok(pstate) = intel_pstate::PState::new() {
+            pstate.set_min_perf_pct(mode_config.min_percentage)?;
+            pstate.set_max_perf_pct(mode_config.max_percentage)?;
+            pstate.set_no_turbo(!mode_config.turbo)?;
+            info!(
+                "Intel CPU Power: min: {}%, max: {}%, turbo: {}",
+                mode_config.min_percentage, mode_config.max_percentage, mode_config.turbo
+            );
+        } else {
+            info!("Setting pstate for AMD CPU");
+            // must be AMD CPU
+            let mut file = OpenOptions::new()
+                .write(true)
+                .open(AMD_BOOST_PATH)
+                .map_err(|err| RogError::Path(self.path.into(), err))?;
+
+            let boost = if mode_config.turbo { "1" } else { "0" }; // opposite of Intel
+            file.write_all(boost.as_bytes())
+                .map_err(|err| RogError::Write(AMD_BOOST_PATH.into(), err))?;
+            info!("AMD CPU Turbo: {}", boost);
+        }
+        Ok(())
+    }
+
+    fn set_fan_curve_for_fan_mode(&self, mode: &str, config: &Config) -> Result<(), RogError> {
+        let mode_config = &config
+            .power_profiles
+            .get(mode)
+            .ok_or_else(|| RogError::MissingProfile(mode.into()))?;
+
+        if let Some(ref curve) = mode_config.fan_curve {
+            use rog_fan_curve::{Board, Fan};
+            if let Some(board) = Board::from_board_name() {
+                curve.apply(board, Fan::Cpu)?;
+                curve.apply(board, Fan::Gpu)?;
+            } else {
+                warn!("Fan curve unsupported on this board.")
+            }
+        }
+
+        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

@@ -0,0 +1,38 @@
+use std::error;
+use std::fmt;
+
+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),
+}
+
+impl fmt::Display for GfxError {
+    // This trait requires `fmt` with this exact signature.
+    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),
+        }
+    }
+}
+
+impl error::Error for GfxError {}
+
+impl From<GfxError> for RogError {
+    fn from(err: GfxError) -> Self {
+        RogError::GfxSwitching(err)
+    }
+}

daemon/src/ctrl_gfx/gfx.rs

@@ -0,0 +1,415 @@
+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")
+    }
+}

daemon/src/ctrl_gfx/mod.rs

@@ -0,0 +1,57 @@
+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"#;

daemon/src/ctrl_gfx/system.rs

@@ -0,0 +1,127 @@
+use log::{error, info, warn};
+use std::fs::read_to_string;
+use std::{fs::write, io, path::PathBuf};
+use sysfs_class::{PciDevice, SysClass};
+
+pub struct Module {
+    pub name: String,
+}
+
+impl Module {
+    fn parse(line: &str) -> io::Result<Module> {
+        let mut parts = line.split(' ');
+
+        let name = parts
+            .next()
+            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "module name not found"))?;
+
+        Ok(Module {
+            name: name.to_string(),
+        })
+    }
+
+    pub fn all() -> io::Result<Vec<Module>> {
+        let mut modules = Vec::new();
+
+        let data = read_to_string("/proc/modules")?;
+        for line in data.lines() {
+            let module = Module::parse(line)?;
+            modules.push(module);
+        }
+
+        Ok(modules)
+    }
+}
+
+pub struct PciBus {
+    path: PathBuf,
+}
+
+impl PciBus {
+    pub fn new() -> io::Result<PciBus> {
+        let path = PathBuf::from("/sys/bus/pci");
+        if path.is_dir() {
+            Ok(PciBus { path })
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "pci directory not found",
+            ))
+        }
+    }
+
+    pub fn rescan(&self) -> io::Result<()> {
+        write(self.path.join("rescan"), "1")
+    }
+}
+
+pub struct GraphicsDevice {
+    _id: String,
+    functions: Vec<PciDevice>,
+}
+
+impl GraphicsDevice {
+    pub fn new(id: String, functions: Vec<PciDevice>) -> GraphicsDevice {
+        GraphicsDevice { _id: id, functions }
+    }
+
+    pub fn exists(&self) -> bool {
+        self.functions.iter().any(|func| func.path().exists())
+    }
+
+    pub fn unbind(&self) -> Result<(), std::io::Error> {
+        for func in self.functions.iter() {
+            if func.path().exists() {
+                match func.driver() {
+                    Ok(driver) => {
+                        info!("{}: Unbinding {}", driver.id(), func.id());
+                        unsafe {
+                            driver.unbind(&func).map_err(|err| {
+                                error!("gfx unbind: {}", 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() {
+                match func.driver() {
+                    Ok(driver) => {
+                        error!("{}: in use by {}", func.id(), driver.id());
+                    }
+                    Err(why) => match why.kind() {
+                        std::io::ErrorKind::NotFound => {
+                            info!("{}: Removing", func.id());
+                            unsafe {
+                                // ignore errors and carry on
+                                if let Err(err) = func.remove() {
+                                    error!("gfx remove: {}", err);
+                                }
+                            }
+                        }
+                        _ => {
+                            error!("Remove device failed");
+                        }
+                    },
+                }
+            } else {
+                warn!("{}: Already removed", func.id());
+            }
+        }
+        info!("Removed all gfx devices");
+        Ok(())
+    }
+}

daemon/src/ctrl_gfx/vendors.rs

@@ -0,0 +1,86 @@
+#[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()
+    }
+}

daemon/src/ctrl_leds.rs

@@ -0,0 +1,573 @@
+// 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 rog_types::{
+    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);
+            } else {
+                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) {
+                                match ctrl.do_command(data, &mut cfg) {
+                                    Ok(_) => {
+                                        self.notify_led(&json).ok();
+                                    }
+                                    Err(err) => {
+                                        warn!("{}", err);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } 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 led_node = Self::get_node_failover(id_product, None, Self::scan_led_node).map_or_else(
+            |err| {
+                warn!("led_node: {}", err);
+                None
+            },
+            |node| Some(node),
+        );
+
+        let kbd_node = Self::get_node_failover(id_product, condev_iface, Self::scan_kbd_node)
+            .map_or_else(
+                |err| {
+                    warn!("kbd_node: {}", err);
+                    None
+                },
+                |node| Some(node),
+            );
+
+        let bright_node = Self::get_kbd_bright_path();
+
+        if led_node.is_none() && kbd_node.is_none() && Self::get_kbd_bright_path().is_err() {
+            return Err(RogError::MissingFunction(
+                "All keyboard features missing, you may require a v5.11 series kernel or newer"
+                    .into(),
+            ));
+        }
+
+        let ctrl = CtrlKbdBacklight {
+            // Using `ok` here so we can continue without keyboard features but
+            // still get brightness control at least... maybe...
+            led_node,
+            kbd_node,
+            // TODO: Check for existance
+            bright_node: bright_node?.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> {
+        match fun(id_product, iface) {
+            Ok(o) => return Ok(o),
+            Err(e) => {
+                warn!("Looking for node: {}", e.to_string());
+            }
+        }
+        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) {
+                // 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: 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> {
+        let mode_num: u8 = u8::from(mode);
+        if !self.supported_modes.contains(&mode_num) {
+            return Err(RogError::NotSupported);
+        }
+        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)?;
+                }
+            }
+            AuraModes::MultiStatic(_) | AuraModes::MultiBreathe(_) => {
+                let bytes: [[u8; LED_MSG_LEN]; 4] = mode.into();
+                for array in bytes.iter() {
+                    self.write_bytes(array)?;
+                }
+                self.write_bytes(&LED_SET)?;
+                // Changes won't persist unless apply is set
+                self.write_bytes(&LED_APPLY)?;
+                return Ok(());
+            }
+            _ => {
+                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

@@ -0,0 +1,261 @@
+use crate::{
+    config::Config,
+    ctrl_gfx::{gfx::CtrlGraphics, vendors::GfxVendors},
+    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::{Read, Write};
+use std::path::Path;
+use std::sync::Arc;
+use std::sync::Mutex;
+use zbus::dbus_interface;
+
+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>>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct RogBiosSupportedFunctions {
+    pub post_sound_toggle: bool,
+    pub dedicated_gfx_toggle: bool,
+}
+
+impl GetSupported for CtrlRogBios {
+    type A = RogBiosSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        RogBiosSupportedFunctions {
+            post_sound_toggle: CtrlRogBios::check_path_exists(ASUS_POST_LOGO_SOUND).is_ok(),
+            dedicated_gfx_toggle: CtrlRogBios::check_path_exists(ASUS_SWITCH_GRAPHIC_MODE).is_ok(),
+        }
+    }
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlRogBios {
+    pub fn set_dedicated_graphic_mode(&mut self, dedicated: bool) {
+        Self::set_gfx_mode(dedicated)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_asus_switch_graphic_mode {}", err);
+                err
+            })
+            .ok();
+        self.notify_dedicated_graphic_mode(dedicated)
+            .map_err(|err| {
+                warn!("CtrlRogBios: notify_asus_switch_graphic_mode {}", err);
+                err
+            })
+            .ok();
+    }
+
+    pub fn dedicated_graphic_mode(&self) -> i8 {
+        Self::get_gfx_mode()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_gfx_mode {}", err);
+                err
+            })
+            .unwrap_or(-1)
+    }
+
+    #[dbus_interface(signal)]
+    pub fn notify_dedicated_graphic_mode(&self, dedicated: bool) -> zbus::Result<()> {}
+
+    // // // // // // // // // //
+
+    pub fn set_post_boot_sound(&mut self, on: bool) {
+        Self::set_boot_sound(on)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_post_boot_sound {}", err);
+                err
+            })
+            .ok();
+        self.notify_post_boot_sound(on)
+            .map_err(|err| {
+                warn!("CtrlRogBios: notify_post_boot_sound {}", err);
+                err
+            })
+            .ok();
+    }
+
+    pub fn post_boot_sound(&self) -> i8 {
+        Self::get_boot_sound()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_boot_sound {}", err);
+                err
+            })
+            .unwrap_or(-1)
+    }
+
+    #[dbus_interface(signal)]
+    pub fn notify_post_boot_sound(&self, dedicated: bool) -> zbus::Result<()> {}
+}
+
+impl crate::ZbusAdd for CtrlRogBios {
+    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at(&"/org/asuslinux/RogBios".try_into().unwrap(), self)
+            .map_err(|err| {
+                warn!("CtrlRogBios: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}
+
+impl crate::Reloadable for CtrlRogBios {
+    fn reload(&mut self) -> Result<(), RogError> {
+        Ok(())
+    }
+}
+
+impl CtrlRogBios {
+    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
+        match CtrlRogBios::check_path_exists(ASUS_SWITCH_GRAPHIC_MODE) {
+            Ok(_) => {
+                CtrlRogBios::set_path_mutable(ASUS_SWITCH_GRAPHIC_MODE)?;
+            }
+            Err(err) => {
+                info!("ROG Switchable Graphics (bios) not detected: {}", err);
+            }
+        }
+
+        match CtrlRogBios::check_path_exists(ASUS_POST_LOGO_SOUND) {
+            Ok(_) => {
+                CtrlRogBios::set_path_mutable(ASUS_POST_LOGO_SOUND)?;
+            }
+            Err(err) => {
+                info!("ROG boot sound toggle (bios) not detected: {}", err);
+            }
+        }
+
+        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)
+            .output()
+            .map_err(|err| RogError::Path(path.into(), err))?;
+        info!("Set {} writeable: status: {}", path, output.status);
+        Ok(())
+    }
+
+    fn check_path_exists(path: &str) -> Result<(), RogError> {
+        if Path::new(path).exists() {
+            Ok(())
+        } else {
+            Err(RogError::MissingFunction(path.into()))
+        }
+    }
+
+    pub fn has_dedicated_gfx_toggle() -> bool {
+        if CtrlRogBios::check_path_exists(ASUS_SWITCH_GRAPHIC_MODE).is_ok() {
+            return true;
+        }
+        false
+    }
+
+    pub fn get_gfx_mode() -> Result<i8, RogError> {
+        let path = ASUS_SWITCH_GRAPHIC_MODE;
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(path)
+            .map_err(|err| RogError::Path(path.into(), err))?;
+
+        let mut data = Vec::new();
+        file.read_to_end(&mut data)
+            .map_err(|err| RogError::Read(path.into(), err))?;
+
+        let idx = data.len() - 1;
+        Ok(data[idx] as i8)
+    }
+
+    pub(super) fn set_gfx_mode(dedicated: bool) -> Result<(), RogError> {
+        let path = ASUS_SWITCH_GRAPHIC_MODE;
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(path)
+            .map_err(|err| RogError::Path(path.into(), err))?;
+
+        let mut data = Vec::new();
+        file.read_to_end(&mut data).unwrap();
+
+        let idx = data.len() - 1;
+        if dedicated {
+            data[idx] = 1;
+            info!("Set system-level graphics mode: Dedicated Nvidia");
+        } else {
+            data[idx] = 0;
+            info!("Set system-level graphics mode: Optimus");
+        }
+        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));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn get_boot_sound() -> Result<i8, RogError> {
+        let path = ASUS_POST_LOGO_SOUND;
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(path)
+            .map_err(|err| RogError::Path(path.into(), err))?;
+
+        let mut data = Vec::new();
+        file.read_to_end(&mut data)
+            .map_err(|err| RogError::Read(path.into(), err))?;
+
+        let idx = data.len() - 1;
+        Ok(data[idx] as i8)
+    }
+
+    pub(super) fn set_boot_sound(on: bool) -> Result<(), RogError> {
+        let path = ASUS_POST_LOGO_SOUND;
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(path)
+            .map_err(|err| RogError::Path(path.into(), err))?;
+
+        let mut data = Vec::new();
+        file.read_to_end(&mut data)
+            .map_err(|err| RogError::Read(path.into(), err))?;
+
+        let idx = data.len() - 1;
+        if on {
+            data[idx] = 1;
+            info!("Set boot POST sound on");
+        } else {
+            data[idx] = 0;
+            info!("Set boot POST sound off");
+        }
+        file.write_all(&data)
+            .map_err(|err| RogError::Path(path.into(), err))?;
+
+        Ok(())
+    }
+}

daemon/src/daemon.rs

@@ -0,0 +1,199 @@
+use daemon::ctrl_charge::CtrlCharge;
+use daemon::ctrl_fan_cpu::{CtrlFanAndCPU, DbusFanAndCpu};
+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},
+};
+
+use rog_dbus::DBUS_NAME;
+use daemon::{CtrlTask, Reloadable, ZbusAdd};
+use log::LevelFilter;
+use log::{error, info, warn};
+use std::error::Error;
+use std::io::Write;
+use std::sync::Arc;
+use std::sync::Mutex;
+
+use daemon::ctrl_rog_bios::CtrlRogBios;
+use std::convert::Into;
+use std::convert::TryInto;
+use zbus::fdo;
+use zbus::Connection;
+
+pub 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();
+
+    info!(   "daemon version {}", daemon::VERSION);
+    info!(" rog-dbus version {}", rog_dbus::VERSION);
+    info!("rog-types version {}", rog_types::VERSION);
+
+    start_daemon()?;
+    Ok(())
+}
+
+// Timing is such that:
+// - interrupt write is minimum 1ms (sometimes lower)
+// - read interrupt must timeout, minimum of 1ms
+// - for a single usb packet, 2ms total.
+// - to maintain constant times of 1ms, per-key colours should use
+//   the effect endpoint so that the complete colour block is written
+//   as fast as 1ms per row of the matrix inside it. (10ms total time)
+fn start_daemon() -> Result<(), Box<dyn Error>> {
+    let supported = SupportedFunctions::get_supported();
+    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 connection = Connection::new_system()?;
+    fdo::DBusProxy::new(&connection)?
+        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
+    let mut object_server = zbus::ObjectServer::new(&connection);
+
+    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
+            ctrl.reload()
+                .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
+            // Then register to dbus server
+            ctrl.add_to_server(&mut object_server);
+        }
+        Err(err) => {
+            error!("rog_bios_control: {}", err);
+        }
+    }
+
+    match CtrlCharge::new(config.clone()) {
+        Ok(mut ctrl) => {
+            // Do a reload of any settings
+            ctrl.reload()
+                .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
+            // Then register to dbus server
+            ctrl.add_to_server(&mut object_server);
+        }
+        Err(err) => {
+            error!("charge_control: {}", err);
+        }
+    }
+
+    match CtrlAnimeDisplay::new() {
+        Ok(ctrl) => {
+            ctrl.add_to_server(&mut object_server);
+        }
+        Err(err) => {
+            error!("AniMe control: {}", err);
+        }
+    }
+
+    if enable_gfx_switching {
+        match CtrlGraphics::new(config.clone()) {
+            Ok(mut ctrl) => {
+                // 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)?;
+                            } else if ded == 0 {
+                                info!("Dedicated GFX toggle is off");
+                            }
+                        }
+                    }
+                }
+                ctrl.reload()
+                    .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
+                ctrl.add_to_server(&mut object_server);
+            }
+            Err(err) => {
+                error!("Gfx control: {}", err);
+            }
+        }
+    }
+
+    // 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| {
+        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);
+    };
+
+    if let Some(laptop) = laptop {
+        if let Ok(ctrl) = CtrlKbdBacklight::new(
+            laptop.usb_product(),
+            laptop.condev_iface(),
+            laptop.supported_modes().to_owned(),
+            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
+    // change
+    let _handle = std::thread::Builder::new()
+        .name("asusd watch".to_string())
+        .spawn(move || loop {
+            std::thread::sleep(std::time::Duration::from_millis(100));
+
+            for ctrl in tasks.iter() {
+                if let Ok(mut lock) = ctrl.try_lock() {
+                    lock.do_task()
+                        .map_err(|err| {
+                            warn!("do_task error: {}", err);
+                        })
+                        .ok();
+                }
+            }
+        });
+
+    object_server
+        .with(&"/org/asuslinux/Charge".try_into()?, |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() {
+            eprintln!("{}", err);
+        }
+    }
+}

daemon/src/error.rs

@@ -0,0 +1,66 @@
+use intel_pstate::PStateError;
+use rog_fan_curve::CurveError;
+use std::convert::From;
+use std::fmt;
+
+use crate::ctrl_gfx::error::GfxError;
+
+#[derive(Debug)]
+pub enum RogError {
+    ParseFanLevel,
+    ParseVendor,
+    ParseLED,
+    MissingProfile(String),
+    Udev(String, std::io::Error),
+    Path(String, std::io::Error),
+    Read(String, std::io::Error),
+    Write(String, std::io::Error),
+    NotSupported,
+    NotFound(String),
+    IntelPstate(PStateError),
+    FanCurve(CurveError),
+    DoTask(String),
+    MissingFunction(String),
+    MissingLedBrightNode(String, std::io::Error),
+    ReloadFail(String),
+    GfxSwitching(GfxError),
+}
+
+impl fmt::Display for RogError {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            RogError::ParseFanLevel => write!(f, "Parse profile error"),
+            RogError::ParseVendor => write!(f, "Parse gfx vendor error"),
+            RogError::ParseLED => write!(f, "Parse LED error"),
+            RogError::MissingProfile(profile) => write!(f, "Profile does not exist {}", profile),
+            RogError::Udev(deets, error) => write!(f, "udev {}: {}", deets, error),
+            RogError::Path(path, error) => write!(f, "Path {}: {}", path, error),
+            RogError::Read(path, error) => write!(f, "Read {}: {}", path, error),
+            RogError::Write(path, error) => write!(f, "Write {}: {}", path, error),
+            RogError::NotSupported => write!(f, "Not supported"),
+            RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
+            RogError::IntelPstate(err) => write!(f, "Intel pstate error: {}", err),
+            RogError::FanCurve(err) => write!(f, "Custom fan-curve error: {}", err),
+            RogError::DoTask(deets) => write!(f, "Task error: {}", deets),
+            RogError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
+            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),
+        }
+    }
+}
+
+impl std::error::Error for RogError {}
+
+impl From<PStateError> for RogError {
+    fn from(err: PStateError) -> Self {
+        RogError::IntelPstate(err)
+    }
+}
+
+impl From<CurveError> for RogError {
+    fn from(err: CurveError) -> Self {
+        RogError::FanCurve(err)
+    }
+}

daemon/src/laptops.rs

@@ -0,0 +1,153 @@
+use rog_types::aura_modes::{AuraModes, BREATHING, STATIC};
+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";
+
+static LAPTOP_DEVICES: [u16; 3] = [0x1866, 0x1869, 0x1854];
+
+#[derive(Debug)]
+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("Couldn't get device").iter() {
+        let device_desc = device
+            .device_descriptor()
+            .expect("Couldn't get device descriptor");
+        if device_desc.vendor_id() == 0x0b05 {
+            if LAPTOP_DEVICES.contains(&device_desc.product_id()) {
+                let prod_str = format!("{:x?}", device_desc.product_id());
+
+                if device_desc.product_id() == 0x1854 {
+                    let mut laptop = laptop(prod_str, None);
+                    if laptop.supported_modes.is_empty() {
+                        laptop.supported_modes = vec![STATIC, BREATHING];
+                    }
+                    return Some(laptop);
+                }
+
+                let laptop = laptop(prod_str, Some("02".to_owned()));
+                return Some(laptop);
+            }
+        }
+    }
+    warn!(
+        "Unsupported laptop, please request support at {}",
+        HELP_ADDRESS
+    );
+    warn!("Continuing with minimal support");
+    None
+}
+
+fn laptop(prod: String, condev_iface: Option<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,
+        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>,
+}

daemon/src/lib.rs

@@ -0,0 +1,52 @@
+#![deny(unused_must_use)]
+/// Configuration loading, saving
+pub mod config;
+///
+pub mod ctrl_anime;
+///
+pub mod ctrl_charge;
+///
+pub mod ctrl_fan_cpu;
+///
+pub mod ctrl_gfx;
+///
+pub mod ctrl_leds;
+/// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
+pub mod ctrl_rog_bios;
+/// Laptop matching to determine capabilities
+pub mod laptops;
+
+/// Fetch all supported functions for the laptop
+pub mod supported;
+
+mod error;
+
+use crate::error::RogError;
+use config::Config;
+use zbus::ObjectServer;
+
+pub static VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub trait Reloadable {
+    fn reload(&mut self) -> Result<(), RogError>;
+}
+
+pub trait ZbusAdd {
+    fn add_to_server(self, server: &mut ObjectServer);
+}
+
+pub trait CtrlTask {
+    fn do_task(&mut self) -> Result<(), RogError>;
+}
+
+pub trait CtrlTaskComplex {
+    type A;
+
+    fn do_task(&mut self, config: &mut Config, event: Self::A);
+}
+
+pub trait GetSupported {
+    type A;
+
+    fn get_supported() -> Self::A;
+}

daemon/src/supported.rs

@@ -0,0 +1,56 @@
+use std::convert::TryInto;
+
+use log::warn;
+use serde_derive::{Deserialize, Serialize};
+use zbus::dbus_interface;
+
+use crate::{
+    ctrl_anime::{AnimeSupportedFunctions, CtrlAnimeDisplay},
+    ctrl_charge::{ChargeSupportedFunctions, CtrlCharge},
+    ctrl_fan_cpu::{CtrlFanAndCPU, FanCpuSupportedFunctions},
+    ctrl_leds::{CtrlKbdBacklight, LedSupportedFunctions},
+    ctrl_rog_bios::{CtrlRogBios, RogBiosSupportedFunctions},
+    GetSupported,
+};
+
+#[derive(Serialize, Deserialize)]
+pub struct SupportedFunctions {
+    anime_ctrl: AnimeSupportedFunctions,
+    charge_ctrl: ChargeSupportedFunctions,
+    fan_cpu_ctrl: FanCpuSupportedFunctions,
+    keyboard_led: LedSupportedFunctions,
+    rog_bios_ctrl: RogBiosSupportedFunctions,
+}
+
+#[dbus_interface(name = "org.asuslinux.Supported")]
+impl SupportedFunctions {
+    fn supported_functions(&self) -> String {
+        serde_json::to_string_pretty(self).unwrap()
+    }
+}
+
+impl crate::ZbusAdd for SupportedFunctions {
+    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at(&"/org/asuslinux/Supported".try_into().unwrap(), self)
+            .map_err(|err| {
+                warn!("SupportedFunctions: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}
+
+impl GetSupported for SupportedFunctions {
+    type A = SupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        SupportedFunctions {
+            keyboard_led: CtrlKbdBacklight::get_supported(),
+            anime_ctrl: CtrlAnimeDisplay::get_supported(),
+            charge_ctrl: CtrlCharge::get_supported(),
+            fan_cpu_ctrl: CtrlFanAndCPU::get_supported(),
+            rog_bios_ctrl: CtrlRogBios::get_supported(),
+        }
+    }
+}