Fixes: Handle keyboard nodes better.

- Uses string instead of debug print for some errors - Add interface num arg for LED controller (should help support older laptops better) - Some slightly better error messages - Fix an idiotic mistake in `for i in 0..2.. if i > 0` -_- - Remove "unsupported" warning on laptop ctrl - Silence warning about AniMe not existing - Adjust the turbo-toggle CLI arg - Version bump for new release with fancurves Closes #7 #10 #8 #4
2026-01-22 17:33:19 +01:00 · 2020-09-10 10:43:08 +12:00
parent 1b427c6c07
commit cddff32757
13 changed files with 143 additions and 126 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

 ## [Unreleased]
+# [1.1.0] - 2020-09-10
+### Changed
+- Uses string instead of debug print for some errors
+- Add interface num arg for LED controller (should help support
+    older laptops better)
+- Some slightly better error messages
+- Fix an idiotic mistake in `for i in 0..2.. if i > 0` -_-
+- Remove "unsupported" warning on laptop ctrl
+- Silence warning about AniMe not existing
+- Adjust the turbo-toggle CLI arg
+- Version bump for new release with fancurves

 ## [1.0.2] - 2020-08-13
 ### Changed
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,7 +17,7 @@ dependencies = [

 [[package]]
 name = "asus-nb"
-version = "0.15.0"
+version = "1.1.0"
 dependencies = [
 "dbus",
 "gumdrop",
@@ -31,7 +31,7 @@ dependencies = [

 [[package]]
 name = "asus-nb-ctrl"
-version = "1.0.4"
+version = "1.1.0"
 dependencies = [
 "asus-nb",
 "async-trait",
@@ -54,9 +54,9 @@ dependencies = [

 [[package]]
 name = "async-trait"
-version = "0.1.38"
+version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e1a4a2f97ce50c9d0282c1468816208588441492b40d813b2e0419c22c05e7f"
+checksum = "687c230d85c0a52504709705fc8a53e4a692b83a2184f03dae73e38e1e93a783"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -74,21 +74,6 @@ dependencies = [
 "winapi 0.3.9",
 ]

-[[package]]
-name = "bit-set"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e11e16035ea35e4e5997b393eacbf6f63983188f7a2ad25bfb13465f5ad59de"
-dependencies = [
- "bit-vec",
-]
-
-[[package]]
-name = "bit-vec"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0dc55f2d8a1a85650ac47858bb001b4c0dd73d79e3c455a842925e68d29cd3"
-
 [[package]]
 name = "bitflags"
 version = "1.2.1"
@@ -479,9 +464,9 @@ dependencies = [

 [[package]]
 name = "net2"
-version = "0.2.34"
+version = "0.2.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ba7c918ac76704fb42afcbbb43891e72731f3dcca3bef2a19786297baf14af7"
+checksum = "3ebc3ec692ed7c9a255596c67808dee269f64655d8baf7b4f0638e51ba1d6853"
 dependencies = [
 "cfg-if",
 "libc",
@@ -596,9 +581,9 @@ checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"

 [[package]]
 name = "proc-macro2"
-version = "1.0.19"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04f5f085b5d71e2188cb8271e5da0161ad52c3f227a661a3c135fdf28e258b12"
+checksum = "36e28516df94f3dd551a587da5357459d9b36d945a7c37c3557928c1c2ff2a2c"
 dependencies = [
 "unicode-xid",
 ]
@@ -659,11 +644,10 @@ dependencies = [

 [[package]]
 name = "rusb"
-version = "0.6.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "884a9ee2c66cdb5ca6c5243ea91cdbba9865506792c3d175d1ad8de8bb0ea64a"
+checksum = "327ba984f811d7e34f52f08b5745911ce89c432e1098879f2f8288c76a88aa0c"
 dependencies = [
- "bit-set",
 "libc",
 "libusb1-sys",
 ]
@@ -732,9 +716,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "1.0.39"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d8d6567fe7c7f8835a3a98af4208f3846fba258c1bc3c31d6e506239f11f9"
+checksum = "963f7d3cc59b59b9325165add223142bbf1df27655d07789f109896d353d8350"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -770,9 +754,9 @@ checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"

 [[package]]
 name = "tar"
-version = "0.4.29"
+version = "0.4.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8a4c1d0bee3230179544336c15eefb563cf0302955d962e456542323e8c2e8a"
+checksum = "489997b7557e9a43e192c527face4feacc78bfbe6eed67fd55c4c9e381cba290"
 dependencies = [
 "filetime",
 "libc",
--- a/asus-nb-ctrl/Cargo.toml
+++ b/asus-nb-ctrl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "asus-nb-ctrl"
-version = "1.0.4"
+version = "1.1.0"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -23,7 +23,7 @@ path = "src/daemon.rs"

 [dependencies]
 asus-nb = { path = "../asus-nb" }
-rusb = "=0.6.0"
+rusb = "^0.6.0"
 udev = "^0.4.0"
 async-trait = "0.1.36"

--- a/asus-nb-ctrl/src/config.rs
+++ b/asus-nb-ctrl/src/config.rs
@@ -37,7 +37,10 @@ impl Config {
                self = Config::create_default(&mut file, &supported_led_modes);
            } else {
                self = serde_json::from_str(&buf).unwrap_or_else(|_| {
-                    warn!("Could not deserialise {}", CONFIG_PATH);
+                    warn!(
+                        "Could not deserialise {}. Overwriting with default",
+                        CONFIG_PATH
+                    );
                    Config::create_default(&mut file, &supported_led_modes)
                });
            }
@@ -126,7 +129,7 @@ impl Config {
 pub struct Profile {
    pub min_percentage: u8,
    pub max_percentage: u8,
-    pub no_turbo: bool,
+    pub turbo: bool,
    pub fan_preset: u8,
    pub fan_curve: Option<Curve>,
 }
@@ -139,7 +142,7 @@ impl Default for Profile {
        Profile {
            min_percentage: 0,
            max_percentage: 100,
-            no_turbo: false,
+            turbo: false,
            fan_preset: 0,
            fan_curve: None,
        }
--- a/asus-nb-ctrl/src/ctrl_anime.rs
+++ b/asus-nb-ctrl/src/ctrl_anime.rs
@@ -67,21 +67,18 @@ 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).map_err(|err| {
-            warn!("Could not get AniMe display handle: {:?}", err);
-            err
-        })?;
+        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);
+            error!("Auto-detach kernel driver failed: {}", err);
            err
        })?;

        device.claim_interface(0).map_err(|err| {
-            error!("Could not claim device interface: {:?}", err);
+            error!("Could not claim device interface: {}", err);
            err
        })?;

@@ -120,7 +117,6 @@ impl CtrlAnimeDisplay {
    /// Should only be used if the bytes you are writing are verified correct
    #[inline]
    async fn write_bytes(&self, message: &[u8]) -> Result<(), AuraError> {
-        let prev = std::time::Instant::now();
        match self.handle.write_control(
            0x21,  // request_type
            0x09,  // request
@@ -129,15 +125,10 @@ impl CtrlAnimeDisplay {
            message,
            Duration::from_millis(200),
        ) {
-            Ok(_) => {
-                println!(
-                    "{:?}",
-                    std::time::Instant::now().duration_since(prev).as_micros()
-                );
-            }
+            Ok(_) => {}
            Err(err) => match err {
                rusb::Error::Timeout => {}
-                _ => error!("Failed to write to led interrupt: {:?}", err),
+                _ => error!("Failed to write to led interrupt: {}", err),
            },
        }
        Ok(())
--- a/asus-nb-ctrl/src/ctrl_charge.rs
+++ b/asus-nb-ctrl/src/ctrl_charge.rs
@@ -34,7 +34,7 @@ impl crate::Controller for CtrlCharge {
            while let Some(n) = recv.recv().await {
                let mut config = config.lock().await;
                self.set_charge_limit(n, &mut config)
-                    .unwrap_or_else(|err| warn!("charge_limit: {:?}", err));
+                    .unwrap_or_else(|err| warn!("charge_limit: {}", err));
            }
        })]
    }
@@ -80,11 +80,11 @@ impl CtrlCharge {
            .write(true)
            .open(self.path)
            .map_err(|err| {
-                warn!("Failed to open battery charge limit path: {:?}", err);
+                warn!("Failed to open battery charge limit path: {}", err);
                err
            })?;
        file.write_all(limit.to_string().as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", BAT_CHARGE_PATH, err));
+            .unwrap_or_else(|err| error!("Could not write to {}, {}", BAT_CHARGE_PATH, err));
        info!("Battery charge limit: {}", limit);

        config.read();
--- a/asus-nb-ctrl/src/ctrl_fan_cpu.rs
+++ b/asus-nb-ctrl/src/ctrl_fan_cpu.rs
@@ -47,7 +47,7 @@ impl crate::Controller for CtrlFanAndCPU {

                    config.read();
                    lock.handle_profile_event(&event, &mut config)
-                        .unwrap_or_else(|err| warn!("{:?}", err));
+                        .unwrap_or_else(|err| warn!("{}", err));
                }
            }),
            // need to watch file path
@@ -57,7 +57,7 @@ impl crate::Controller for CtrlFanAndCPU {
                    let mut lock = gate2.lock().await;
                    let mut config = config.lock().await;
                    lock.fan_mode_check_change(&mut config)
-                        .unwrap_or_else(|err| warn!("fan_ctrl: {:?}", err));
+                        .unwrap_or_else(|err| warn!("fan_ctrl: {}", err));
                }
            }),
        ]
@@ -65,8 +65,8 @@ impl crate::Controller for CtrlFanAndCPU {

    async fn reload_from_config(&mut self, config: &mut Config) -> Result<(), Box<dyn Error>> {
        let mut file = OpenOptions::new().write(true).open(self.path)?;
-        file.write_all(format!("{:?}\n", config.power_profile).as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", self.path, err));
+        file.write_all(format!("{}\n", config.power_profile).as_bytes())
+            .unwrap_or_else(|err| error!("Could not write to {}, {}", self.path, err));
        let profile = config.active_profile.clone();
        self.set_profile(&profile, config)?;
        info!(
@@ -92,7 +92,7 @@ impl CtrlFanAndCPU {
        } else {
            Err(std::io::Error::new(
                std::io::ErrorKind::NotFound,
-                "Fan mode not available",
+                "Fan mode not available, you may require a v5.8 series kernel or newer",
            ))
        }
    }
@@ -126,7 +126,7 @@ impl CtrlFanAndCPU {

                self.set_profile(&new_profile, config)?;

-                info!("Profile was changed: {:?}", &new_profile);
+                info!("Profile was changed: {}", &new_profile);
            }
            return Ok(());
        }
@@ -153,8 +153,8 @@ impl CtrlFanAndCPU {
        mode_config.fan_preset = preset;
        config.write();
        fan_ctrl
-            .write_all(format!("{:?}\n", preset).as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", self.path, err));
+            .write_all(format!("{}\n", preset).as_bytes())
+            .unwrap_or_else(|err| error!("Could not write to {}, {}", self.path, 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)?;
@@ -180,7 +180,7 @@ impl CtrlFanAndCPU {
                    config
                        .power_profiles
                        .entry(profile_key.clone())
-                        .or_insert_with(|| Profile::default())
+                        .or_insert_with(Profile::default)
                } else {
                    config
                        .power_profiles
@@ -188,11 +188,8 @@ impl CtrlFanAndCPU {
                        .ok_or_else(|| RogError::MissingProfile(profile_key.clone()))?
                };

-                if command.turbo {
-                    profile.no_turbo = false;
-                }
-                if command.no_turbo {
-                    profile.no_turbo = true;
+                if command.turbo.is_some() {
+                    profile.turbo = command.turbo.unwrap();
                }
                if let Some(min_perc) = command.min_percentage {
                    profile.min_percentage = min_perc;
@@ -220,8 +217,8 @@ impl CtrlFanAndCPU {
            .ok_or_else(|| RogError::MissingProfile(profile.into()))?;
        let mut fan_ctrl = OpenOptions::new().write(true).open(self.path)?;
        fan_ctrl
-            .write_all(format!("{:?}\n", mode_config.fan_preset).as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", self.path, err));
+            .write_all(format!("{}\n", mode_config.fan_preset).as_bytes())
+            .unwrap_or_else(|err| error!("Could not write to {}, {}", self.path, err));
        config.power_profile = mode_config.fan_preset;

        self.set_pstate_for_fan_mode(profile, config)?;
@@ -249,10 +246,10 @@ impl CtrlFanAndCPU {
        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.no_turbo)?;
+            pstate.set_no_turbo(!mode_config.turbo)?;
            info!(
-                "Intel CPU Power: min: {:?}%, max: {:?}%, turbo: {:?}",
-                mode_config.min_percentage, mode_config.max_percentage, !mode_config.no_turbo
+                "Intel CPU Power: min: {}%, max: {}%, turbo: {}",
+                mode_config.min_percentage, mode_config.max_percentage, mode_config.turbo
            );
        } else {
            info!("Setting pstate for AMD CPU");
@@ -261,14 +258,14 @@ impl CtrlFanAndCPU {
                .write(true)
                .open(AMD_BOOST_PATH)
                .map_err(|err| {
-                    warn!("Failed to open AMD boost: {:?}", err);
+                    warn!("Failed to open AMD boost: {}", err);
                    err
                })?;

-            let boost = if mode_config.no_turbo { "0" } else { "1" }; // opposite of Intel
+            let boost = if mode_config.turbo { "0" } else { "1" }; // opposite of Intel
            file.write_all(boost.as_bytes())
-                .unwrap_or_else(|err| error!("Could not write to {}, {:?}", AMD_BOOST_PATH, err));
-            info!("AMD CPU Turbo: {:?}", boost);
+                .unwrap_or_else(|err| error!("Could not write to {}, {}", AMD_BOOST_PATH, err));
+            info!("AMD CPU Turbo: {}", boost);
        }
        Ok(())
    }
--- a/asus-nb-ctrl/src/ctrl_leds.rs
+++ b/asus-nb-ctrl/src/ctrl_leds.rs
@@ -2,7 +2,7 @@
 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];

-use crate::{config::Config, error::RogError};
+use crate::{config::Config, error::RogError, laptops::HELP_ADDRESS};
 use asus_nb::{
    aura_brightness_bytes, aura_modes::AuraModes, fancy::KeyColourArray, DBUS_IFACE, DBUS_PATH,
    LED_MSG_LEN,
@@ -18,9 +18,9 @@ use tokio::sync::Mutex;
 use tokio::task::JoinHandle;

 pub struct CtrlKbdBacklight {
-    led_node: String,
+    led_node: Option<String>,
    #[allow(dead_code)]
-    kbd_node: String,
+    kbd_node: Option<String>,
    bright_node: String,
    supported_modes: Vec<u8>,
    flip_effect_write: bool,
@@ -81,7 +81,7 @@ impl crate::Controller for CtrlKbdBacklight {
                    let mut lock = gate2.lock().await;
                    let mut config = config.lock().await;
                    lock.let_bright_check_change(&mut config)
-                        .unwrap_or_else(|err| warn!("led_ctrl: {:?}", err));
+                        .unwrap_or_else(|err| warn!("led_ctrl: {}", err));
                }
            }),
        ]
@@ -131,26 +131,29 @@ impl crate::Controller for CtrlKbdBacklight {

 impl CtrlKbdBacklight {
    #[inline]
-    pub fn new(id_product: &str, supported_modes: Vec<u8>) -> Result<Self, std::io::Error> {
-        Ok(CtrlKbdBacklight {
-            led_node: Self::get_node_failover(id_product, Self::scan_led_node)?,
-            kbd_node: Self::get_node_failover(id_product, Self::scan_kbd_node)?,
-            // brightness node path should always be constant but this *might* change?
+    pub fn new(id_product: &str, condev_iface: Option<&String>, supported_modes: Vec<u8>) -> Self {
+        // TODO: return error if *all* nodes are None
+        CtrlKbdBacklight {
+            led_node: Self::get_node_failover(id_product, None, Self::scan_led_node).ok(),
+            kbd_node: Self::get_node_failover(id_product, condev_iface, Self::scan_kbd_node).ok(),
+            // TODO: Check for existance
            bright_node: "/sys/class/leds/asus::kbd_backlight/brightness".to_string(),
            supported_modes,
            flip_effect_write: false,
-        })
+        }
    }

    fn get_node_failover(
        id_product: &str,
-        fun: fn(&str) -> Result<String, std::io::Error>,
+        iface: Option<&String>,
+        fun: fn(&str, Option<&String>) -> Result<String, std::io::Error>,
    ) -> Result<String, std::io::Error> {
-        for n in 0..2 {
-            match fun(id_product) {
+        for n in 0..=2 {
+            // 0,1,2 inclusive
+            match fun(id_product, iface) {
                Ok(o) => return Ok(o),
                Err(e) => {
-                    if n > 0 {
+                    if n == 2 {
                        warn!("Looking for node: {}", e.to_string());
                        std::thread::sleep(std::time::Duration::from_secs(1));
                    } else {
@@ -164,12 +167,24 @@ impl CtrlKbdBacklight {
        Err(err)
    }

-    fn scan_led_node(id_product: &str) -> Result<String, std::io::Error> {
-        let mut enumerator = udev::Enumerator::new()?;
-        enumerator.match_subsystem("hidraw")?;
+    fn scan_led_node(id_product: &str, _: Option<&String>) -> Result<String, std::io::Error> {
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            err
+        })?;
+        enumerator.match_subsystem("hidraw").map_err(|err| {
+            warn!("{}", err);
+            err
+        })?;

        for device in enumerator.scan_devices()? {
-            if let Some(parent) = device.parent_with_subsystem_devtype("usb", "usb_device")? {
+            if let Some(parent) = device
+                .parent_with_subsystem_devtype("usb", "usb_device")
+                .map_err(|err| {
+                    warn!("{}", err);
+                    err
+                })?
+            {
                if parent.attribute_value("idProduct").unwrap() == id_product {
                    // && device.parent().unwrap().sysnum().unwrap() == 3
                    if let Some(dev_node) = device.devnode() {
@@ -183,28 +198,43 @@ impl CtrlKbdBacklight {
            std::io::ErrorKind::NotFound,
            "ASUS LED device node not found",
        );
+        warn!("Did not find a hidraw node for LED control, your device may be unsupported or require a kernel patch, see: {}", HELP_ADDRESS);
        Err(err)
    }

-    fn scan_kbd_node(id_product: &str) -> Result<String, std::io::Error> {
+    fn scan_kbd_node(id_product: &str, iface: Option<&String>) -> Result<String, std::io::Error> {
        let mut enumerator = udev::Enumerator::new()?;
-        enumerator.match_subsystem("input")?;
-        enumerator.match_property("ID_MODEL_ID", id_product)?;
+        enumerator.match_subsystem("input").map_err(|err| {
+            warn!("{}", err);
+            err
+        })?;
+        enumerator
+            .match_property("ID_MODEL_ID", id_product)
+            .map_err(|err| {
+                warn!("{}", err);
+                err
+            })?;

-        for device in enumerator.scan_devices()? {
+        for device in enumerator.scan_devices().map_err(|err| {
+            warn!("{}", err);
+            err
+        })? {
            if let Some(dev_node) = device.devnode() {
                if let Some(inum) = device.property_value("ID_USB_INTERFACE_NUM") {
-                    if inum == "02" {
-                        info!("Using device at: {:?} for keyboard polling", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
+                    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());
+                        }
                    }
                }
            }
        }
        let err = std::io::Error::new(
            std::io::ErrorKind::NotFound,
-            "ASUS N-Key Consumer Device node not found",
+            "ASUS keyboard 'Consumer Device' node not found",
        );
+        warn!("Did not find keyboard consumer device node, if expected functions are missing please file an issue at {}", HELP_ADDRESS);
        Err(err)
    }

@@ -238,9 +268,11 @@ impl CtrlKbdBacklight {
    /// Should only be used if the bytes you are writing are verified correct
    #[inline]
    async fn write_bytes(&self, message: &[u8]) -> Result<(), Box<dyn Error>> {
-        if let Ok(mut file) = OpenOptions::new().write(true).open(&self.led_node) {
-            file.write_all(message).unwrap();
-            return Ok(());
+        if let Some(led_node) = &self.led_node {
+            if let Ok(mut file) = OpenOptions::new().write(true).open(led_node) {
+                file.write_all(message).unwrap();
+                return Ok(());
+            }
        }
        Err(Box::new(RogError::NotSupported))
    }
--- a/asus-nb-ctrl/src/daemon.rs
+++ b/asus-nb-ctrl/src/daemon.rs
@@ -52,14 +52,11 @@ pub async fn start_daemon() -> Result<(), Box<dyn Error>> {
    };

    let mut led_control = if let Some(laptop) = laptop {
-        CtrlKbdBacklight::new(laptop.usb_product(), laptop.supported_modes().to_owned())
-            .map_or_else(
-                |err| {
-                    error!("{}", err);
-                    None
-                },
-                Some,
-            )
+        Some(CtrlKbdBacklight::new(
+            laptop.usb_product(),
+            laptop.condev_iface(),
+            laptop.supported_modes().to_owned(),
+        ))
    } else {
        None
    };
--- a/asus-nb-ctrl/src/laptops.rs
+++ b/asus-nb-ctrl/src/laptops.rs
@@ -6,10 +6,11 @@ use std::io::Read;

 pub static LEDMODE_CONFIG_PATH: &str = "/etc/asusd/asusd-ledmodes.toml";

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

 pub struct LaptopBase {
    usb_product: String,
+    condev_iface: Option<String>, // required for finding the Consumer Device interface
    supported_modes: Vec<u8>,
 }

@@ -17,6 +18,9 @@ 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
    }
@@ -37,6 +41,7 @@ pub fn match_laptop() -> Option<LaptopBase> {
                    info!("Found GL753 or similar");
                    return Some(LaptopBase {
                        usb_product: "1854".to_string(),
+                        condev_iface: None,
                        supported_modes: vec![STATIC, BREATHING, STROBE],
                    });
                }
@@ -44,6 +49,11 @@ pub fn match_laptop() -> Option<LaptopBase> {
            }
        }
    }
+    warn!(
+        "Unsupported laptop, please request support at {}",
+        HELP_ADDRESS
+    );
+    warn!("Continuing with minimal support");
    None
 }

@@ -58,6 +68,7 @@ fn select_1866_device(prod: String) -> LaptopBase {

    let mut laptop = LaptopBase {
        usb_product: prod,
+        condev_iface: Some("02".to_owned()),
        supported_modes: vec![],
    };

@@ -67,13 +78,6 @@ fn select_1866_device(prod: String) -> LaptopBase {
            return laptop;
        }
    }
-
-    warn!(
-        "Unsupported laptop, please request support at {}",
-        HELP_ADDRESS
-    );
-    warn!("Continuing with minimal support");
-
    laptop
 }

--- a/asus-nb-ctrl/src/lib.rs
+++ b/asus-nb-ctrl/src/lib.rs
@@ -23,7 +23,7 @@ use std::sync::Arc;
 use tokio::sync::{mpsc::Receiver, Mutex};
 use tokio::task::JoinHandle;

-pub static VERSION: &str = "1.0.4";
+pub static VERSION: &str = "1.1.0";

 use ::dbus::{nonblock::SyncConnection, tree::Signal};

--- a/asus-nb/Cargo.toml
+++ b/asus-nb/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "asus-nb"
-version = "0.15.0"
+version = "1.1.0"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
--- a/asus-nb/src/profile.rs
+++ b/asus-nb/src/profile.rs
@@ -78,10 +78,8 @@ pub struct ProfileCommand {
    #[options(help = "create the profile if it doesn't exist")]
    pub create: bool,

-    #[options(help = "enable cpu turbo (AMD)")]
-    pub turbo: bool,
-    #[options(help = "disable cpu turbo (AMD)")]
-    pub no_turbo: bool,
+    #[options(help = "enable or disable cpu turbo")]
+    pub turbo: Option<bool>,
    #[options(help = "set min cpu scaling (intel)")]
    pub min_percentage: Option<u8>,
    #[options(help = "set max cpu scaling (intel)")]