Merge branch 'fluke/fixup' into 'next'

Fixes: Handle keyboard nodes better.

Closes #4, #8, #10, and #7

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

.gitlab-ci.yml

@@ -18,7 +18,7 @@ build:
     - make && make vendor
   artifacts:
     paths:
-    - vendor-$(grep -P 'version = "(\d.\d.\d)"' asus-nb-ctrl/Cargo.toml | cut -d'"' -f2).tar.xz
+    - vendor_asus-nb-ctrl_*.tar.xz
     - cargo-config
 
 variables:

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

Cargo.lock

@@ -17,10 +17,11 @@ dependencies = [
 
 [[package]]
 name = "asus-nb"
-version = "0.15.0"
+version = "1.1.0"
 dependencies = [
  "dbus",
  "gumdrop",
+ "rog_fan_curve",
  "serde",
  "serde_derive",
  "serde_json",
@@ -30,7 +31,7 @@ dependencies = [
 
 [[package]]
 name = "asus-nb-ctrl"
-version = "1.0.3"
+version = "1.1.0"
 dependencies = [
  "asus-nb",
  "async-trait",
@@ -40,6 +41,7 @@ dependencies = [
  "gumdrop",
  "intel-pstate",
  "log",
+ "rog_fan_curve",
  "rusb",
  "serde",
  "serde_derive",
@@ -52,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",
@@ -462,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",
@@ -579,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",
 ]
@@ -632,10 +634,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cabe4fa914dec5870285fa7f71f602645da47c486e68486d2b4ceb4a343e90ac"
 
 [[package]]
-name = "rusb"
-version = "0.6.2"
+name = "rog_fan_curve"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fac7576c07e31f5885d67ec09fd8509e4b730cea4266fecfe7f068f3a5d1f3b3"
+checksum = "38efab84f3f5a9f4ff26eb916b32810a263eb2d340d62acb8d64d8a37795c5b9"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "rusb"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "327ba984f811d7e34f52f08b5745911ce89c432e1098879f2f8288c76a88aa0c"
 dependencies = [
  "libc",
  "libusb1-sys",
@@ -705,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",
@@ -743,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",

Makefile

@@ -14,7 +14,7 @@ SRC = Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.r
 BIN_C=asusctl
 BIN_D=asusd
 LEDCONFIG=asusd-ledmodes.toml
-VERSION:=$(shell grep -P 'version = "(\d.\d.\d)"' asus-nb-ctrl/Cargo.toml | cut -d'"' -f2)
+VERSION:=$(shell grep -Pm1 'version = "(\d.\d.\d)"' asus-nb-ctrl/Cargo.toml | cut -d'"' -f2)
 
 DEBUG ?= 0
 ifeq ($(DEBUG),0)
@@ -59,12 +59,12 @@ vendor:
 	echo 'directory = "vendor"' >> .cargo/config
 	mv .cargo/config ./cargo-config
 	rm -rf .cargo
-	tar pcfJ vendor-$(VERSION).tar.xz vendor
+	tar pcfJ vendor_asus-nb-ctrl_$(VERSION).tar.xz vendor
 	rm -rf vendor
 
 target/release/$(BIN_D): $(SRC)
 ifeq ($(VENDORED),1)
 	@echo "version = $(VERSION)"
-	tar pxf vendor-$(VERSION).tar.xz
+	tar pxf vendor_asus-nb-ctrl_$(VERSION).tar.xz
 endif
 	cargo build $(ARGS)

README.md

@@ -197,6 +197,25 @@ Optional arguments:
 
 Available commands:
   led-mode  Set the keyboard lighting from built-in modes
+  profile   Create and configure profiles
+
+$ asusctl profile --help
+Usage: asusctl profile [OPTIONS]
+
+Positional arguments:
+  profile
+
+Optional arguments:
+  -h, --help         print help message
+  -c, --create       create the profile if it doesn't exist
+  -t, --turbo        enable cpu turbo (AMD)
+  -n, --no-turbo     disable cpu turbo (AMD)
+  -m, --min-percentage MIN-PERCENTAGE
+                     set min cpu scaling (intel)
+  -M, --max-percentage MAX-PERCENTAGE
+                     set max cpu scaling (intel)
+  -p, --preset PWR   <silent, normal, boost>
+  -C, --curve CURVE  set fan curve
 
 $ asusctl led-mode --help
 Usage: asusctl led-mode [OPTIONS]

asus-nb-ctrl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "asus-nb-ctrl"
-version = "1.0.3"
+version = "1.1.0"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -45,5 +45,6 @@ toml = "0.4.6"
 
 # Device control
 sysfs-class = "^0.1.2" # used for backlight control and baord ID
+rog_fan_curve = { version = "0.1.4", features = ["serde"] }
 # cpu power management
-intel-pstate = "^0.2.1"
+intel-pstate = "^0.2.1"

asus-nb-ctrl/src/config.rs

@@ -1,6 +1,8 @@
 use asus_nb::aura_modes::AuraModes;
 use log::{error, 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};
 
@@ -8,12 +10,15 @@ pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
 
 #[derive(Default, Deserialize, Serialize)]
 pub struct Config {
+    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: FanModeProfile,
+    pub power_profiles: BTreeMap<String, Profile>,
 }
 
 impl Config {
@@ -32,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)
                 });
             }
@@ -51,6 +59,20 @@ impl Config {
             c.kbd_backlight_modes.push(AuraModes::from(*n))
         }
 
+        let profile = Profile::default();
+        c.power_profiles.insert("normal".into(), profile);
+        let mut profile = Profile::default();
+        profile.fan_preset = 1;
+        c.power_profiles.insert("boost".into(), profile);
+        let mut profile = Profile::default();
+        profile.fan_preset = 2;
+        c.power_profiles.insert("silent".into(), profile);
+
+        c.toggle_profiles.push("normal".into());
+        c.toggle_profiles.push("boost".into());
+        c.toggle_profiles.push("silent".into());
+        c.active_profile = "normal".into();
+
         // Should be okay to unwrap this as is since it is a Default
         let json = serde_json::to_string_pretty(&c).unwrap();
         file.write_all(json.as_bytes())
@@ -103,26 +125,26 @@ impl Config {
     }
 }
 
-#[derive(Default, Deserialize, Serialize)]
-pub struct FanModeProfile {
-    pub normal: CPUSettings,
-    pub boost: CPUSettings,
-    pub silent: CPUSettings,
-}
-
 #[derive(Deserialize, Serialize)]
-pub struct CPUSettings {
+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>,
 }
 
-impl Default for CPUSettings {
+#[deprecated]
+pub type CPUSettings = Profile;
+
+impl Default for Profile {
     fn default() -> Self {
-        CPUSettings {
+        Profile {
             min_percentage: 0,
             max_percentage: 100,
-            no_turbo: false,
+            turbo: false,
+            fan_preset: 0,
+            fan_curve: None,
         }
     }
 }

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(())

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();

asus-nb-ctrl/src/ctrl_fan_cpu.rs

@@ -1,4 +1,6 @@
 use crate::config::Config;
+use crate::config::Profile;
+use asus_nb::profile::ProfileEvent;
 use log::{error, info, warn};
 use std::error::Error;
 use std::fs::OpenOptions;
@@ -23,7 +25,7 @@ use async_trait::async_trait;
 
 #[async_trait]
 impl crate::Controller for CtrlFanAndCPU {
-    type A = u8;
+    type A = ProfileEvent;
 
     /// Spawns two tasks which continuously check for changes
     fn spawn_task_loop(
@@ -39,11 +41,13 @@ impl crate::Controller for CtrlFanAndCPU {
         // spawn an endless loop
         vec![
             tokio::spawn(async move {
-                while let Some(mode) = recv.recv().await {
+                while let Some(event) = recv.recv().await {
                     let mut config = config1.lock().await;
                     let mut lock = gate1.lock().await;
-                    lock.set_fan_mode(mode, &mut config)
-                        .unwrap_or_else(|err| warn!("{:?}", err));
+
+                    config.read();
+                    lock.handle_profile_event(&event, &mut config)
+                        .unwrap_or_else(|err| warn!("{}", err));
                 }
             }),
             // need to watch file path
@@ -53,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));
                 }
             }),
         ]
@@ -61,9 +65,10 @@ 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));
-        self.set_pstate_for_fan_mode(FanLevel::from(config.power_profile), config)?;
+        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!(
             "Reloaded fan mode: {:?}",
             FanLevel::from(config.power_profile)
@@ -87,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",
             ))
         }
     }
@@ -102,13 +107,26 @@ impl CtrlFanAndCPU {
         if let Some(num) = char::from(buf[0]).to_digit(10) {
             if config.power_profile != num as u8 {
                 config.read();
-                config.power_profile = num as u8;
-                config.write();
-                self.set_pstate_for_fan_mode(FanLevel::from(config.power_profile), config)?;
-                info!(
-                    "Fan mode was changed: {:?}",
-                    FanLevel::from(config.power_profile)
-                );
+
+                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_profile(&new_profile, config)?;
+
+                info!("Profile was changed: {}", &new_profile);
             }
             return Ok(());
         }
@@ -121,66 +139,118 @@ impl CtrlFanAndCPU {
 
     pub(super) fn set_fan_mode(
         &mut self,
-        n: u8,
+        preset: u8,
         config: &mut Config,
     ) -> Result<(), Box<dyn Error>> {
+        let mode = config.active_profile.clone();
         let mut fan_ctrl = OpenOptions::new().write(true).open(self.path)?;
         config.read();
-        config.power_profile = n;
+        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", config.power_profile).as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", self.path, err));
-        info!(
-            "Fan mode set to: {:?}",
-            FanLevel::from(config.power_profile)
-        );
-        self.set_pstate_for_fan_mode(FanLevel::from(n), config)?;
+            .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)?;
+        Ok(())
+    }
+
+    fn handle_profile_event(
+        &mut self,
+        event: &ProfileEvent,
+        config: &mut Config,
+    ) -> Result<(), Box<dyn Error>> {
+        match event {
+            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(&profile_key, config)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn set_profile(&mut self, profile: &str, config: &mut Config) -> Result<(), Box<dyn Error>> {
+        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)?;
+        fan_ctrl
+            .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)?;
+        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: FanLevel,
+        // mode: FanLevel,
+        mode: &str,
         config: &mut Config,
     ) -> Result<(), Box<dyn Error>> {
+        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() {
-            match mode {
-                FanLevel::Normal => {
-                    pstate.set_min_perf_pct(config.power_profiles.normal.min_percentage)?;
-                    pstate.set_max_perf_pct(config.power_profiles.normal.max_percentage)?;
-                    pstate.set_no_turbo(config.power_profiles.normal.no_turbo)?;
-                    info!(
-                        "Intel CPU Power: min: {:?}%, max: {:?}%, turbo: {:?}",
-                        config.power_profiles.normal.min_percentage,
-                        config.power_profiles.normal.max_percentage,
-                        !config.power_profiles.normal.no_turbo
-                    );
-                }
-                FanLevel::Boost => {
-                    pstate.set_min_perf_pct(config.power_profiles.boost.min_percentage)?;
-                    pstate.set_max_perf_pct(config.power_profiles.boost.max_percentage)?;
-                    pstate.set_no_turbo(config.power_profiles.boost.no_turbo)?;
-                    info!(
-                        "Intel CPU Power: min: {:?}%, max: {:?}%, turbo: {:?}",
-                        config.power_profiles.boost.min_percentage,
-                        config.power_profiles.boost.max_percentage,
-                        !config.power_profiles.boost.no_turbo
-                    );
-                }
-                FanLevel::Silent => {
-                    pstate.set_min_perf_pct(config.power_profiles.silent.min_percentage)?;
-                    pstate.set_max_perf_pct(config.power_profiles.silent.max_percentage)?;
-                    pstate.set_no_turbo(config.power_profiles.silent.no_turbo)?;
-                    info!(
-                        "Intel CPU Power: min: {:?}%, max: {:?}%, turbo: {:?}",
-                        config.power_profiles.silent.min_percentage,
-                        config.power_profiles.silent.max_percentage,
-                        !config.power_profiles.silent.no_turbo
-                    );
-                }
-            }
+            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
@@ -188,45 +258,39 @@ 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
                 })?;
-            match mode {
-                FanLevel::Normal => {
-                    let boost = if config.power_profiles.normal.no_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);
-                }
-                FanLevel::Boost => {
-                    let boost = if config.power_profiles.boost.no_turbo {
-                        "0"
-                    } else {
-                        "1"
-                    };
-                    file.write_all(boost.as_bytes()).unwrap_or_else(|err| {
-                        error!("Could not write to {}, {:?}", AMD_BOOST_PATH, err)
-                    });
-                    info!("AMD CPU Turbo: {:?}", boost);
-                }
-                FanLevel::Silent => {
-                    let boost = if config.power_profiles.silent.no_turbo {
-                        "0"
-                    } else {
-                        "1"
-                    };
-                    file.write_all(boost.as_bytes()).unwrap_or_else(|err| {
-                        error!("Could not write to {}, {:?}", AMD_BOOST_PATH, err)
-                    });
-                    info!("AMD CPU Turbo: {:?}", boost);
-                }
+
+            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);
+        }
+        Ok(())
+    }
+
+    fn set_fan_curve_for_fan_mode(
+        &self,
+        // mode: FanLevel,
+        mode: &str,
+        config: &Config,
+    ) -> Result<(), Box<dyn Error>> {
+        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(())
     }
 }

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,8 +18,9 @@ use tokio::sync::Mutex;
 use tokio::task::JoinHandle;
 
 pub struct CtrlKbdBacklight {
-    led_node: String,
-    kbd_node: String,
+    led_node: Option<String>,
+    #[allow(dead_code)]
+    kbd_node: Option<String>,
     bright_node: String,
     supported_modes: Vec<u8>,
     flip_effect_write: bool,
@@ -80,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));
                 }
             }),
         ]
@@ -130,23 +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>) -> Result<String, std::io::Error> {
-        for n in 0..2 {
-            match fun(id_product) {
+    fn get_node_failover(
+        id_product: &str,
+        iface: Option<&String>,
+        fun: fn(&str, Option<&String>) -> Result<String, std::io::Error>,
+    ) -> Result<String, std::io::Error> {
+        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 {
@@ -156,19 +163,28 @@ impl CtrlKbdBacklight {
             }
         }
         // Shouldn't be possible to reach this...
-        let err = std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "node not found",
-        );
+        let err = std::io::Error::new(std::io::ErrorKind::NotFound, "node not found");
         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() {
@@ -182,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)
     }
 
@@ -237,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))
     }

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
     };
@@ -114,8 +111,9 @@ pub async fn start_daemon() -> Result<(), Box<dyn Error>> {
         tree,
         aura_command_recv,
         animatrix_recv,
-        fan_mode_recv,
+        _fan_mode_recv,
         charge_limit_recv,
+        profile_recv,
         led_changed_signal,
         fanmode_signal,
         charge_limit_signal,
@@ -149,7 +147,7 @@ pub async fn start_daemon() -> Result<(), Box<dyn Error>> {
     }
 
     if let Some(ctrl) = fan_control.take() {
-        handles.append(&mut ctrl.spawn_task_loop(config.clone(), fan_mode_recv, None, None));
+        handles.append(&mut ctrl.spawn_task_loop(config.clone(), profile_recv, None, None));
     }
 
     if let Some(ctrl) = charge_control.take() {

asus-nb-ctrl/src/dbus.rs

@@ -1,4 +1,5 @@
 use crate::config::Config;
+use asus_nb::profile::ProfileEvent;
 use asus_nb::{aura_modes::AuraModes, DBUS_IFACE, DBUS_PATH};
 use dbus::tree::{Factory, MTSync, Method, MethodErr, Signal, Tree};
 use log::warn;
@@ -170,6 +171,25 @@ fn set_charge_limit(sender: Mutex<Sender<u8>>) -> Method<MTSync, ()> {
         .annotate("org.freedesktop.DBus.Method.NoReply", "true")
 }
 
+fn set_profile(sender: Sender<ProfileEvent>) -> Method<MTSync, ()> {
+    let factory = Factory::new_sync::<()>();
+    factory
+        // method for profile
+        .method("ProfileCommand", (), {
+            move |m| {
+                let mut iter = m.msg.iter_init();
+                let byte: String = iter.read()?;
+                if let Ok(byte) = serde_json::from_str(&byte) {
+                    sender.clone().try_send(byte).unwrap_or_else(|_err| {});
+                }
+
+                Ok(vec![])
+            }
+        })
+        .inarg::<String, _>("limit")
+        .annotate("org.freedesktop.DBus.Method.NoReply", "true")
+}
+
 #[allow(clippy::type_complexity)]
 pub fn dbus_create_tree(
     config: Arc<Mutex<Config>>,
@@ -179,6 +199,7 @@ pub fn dbus_create_tree(
     Receiver<Vec<Vec<u8>>>,
     Receiver<u8>,
     Receiver<u8>,
+    Receiver<ProfileEvent>,
     Arc<Signal<()>>,
     Arc<Signal<()>>,
     Arc<Signal<()>>,
@@ -186,6 +207,7 @@ pub fn dbus_create_tree(
     let (aura_command_send, aura_command_recv) = channel::<AuraModes>(1);
     let (animatrix_send, animatrix_recv) = channel::<Vec<Vec<u8>>>(1);
     let (fan_mode_send, fan_mode_recv) = channel::<u8>(1);
+    let (profile_send, profile_recv) = channel::<ProfileEvent>(1);
     let (charge_send, charge_recv) = channel::<u8>(1);
 
     let factory = Factory::new_sync::<()>();
@@ -211,6 +233,7 @@ pub fn dbus_create_tree(
                     .add_m(set_keyboard_backlight(Mutex::new(aura_command_send)))
                     .add_m(set_animatrix(Mutex::new(animatrix_send)))
                     .add_m(set_fan_mode(Mutex::new(fan_mode_send)))
+                    .add_m(set_profile(profile_send))
                     .add_m(set_charge_limit(Mutex::new(charge_send)))
                     .add_m(get_fan_mode(config.clone()))
                     .add_m(get_charge_limit(config.clone()))
@@ -228,6 +251,7 @@ pub fn dbus_create_tree(
         animatrix_recv,
         fan_mode_recv,
         charge_recv,
+        profile_recv,
         key_backlight_changed,
         fanmode_changed,
         chrg_limit_changed,

asus-nb-ctrl/src/error.rs

@@ -3,6 +3,7 @@ use std::fmt;
 #[derive(Debug)]
 pub enum RogError {
     ParseFanLevel,
+    MissingProfile(String),
     NotSupported,
 }
 
@@ -13,6 +14,7 @@ impl fmt::Display for RogError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             RogError::ParseFanLevel => write!(f, "Parse error"),
+            RogError::MissingProfile(profile) => write!(f, "Profile does not exist {}", profile),
             RogError::NotSupported => write!(f, "Not supported"),
         }
     }

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
 }
 

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.3";
+pub static VERSION: &str = "1.1.0";
 
 use ::dbus::{nonblock::SyncConnection, tree::Signal};
 

asus-nb-ctrl/src/main.rs

@@ -1,6 +1,7 @@
 use asus_nb::{
     cli_options::{LedBrightness, SetAuraBuiltin},
     core_dbus::AuraDbusClient,
+    profile::{ProfileCommand, ProfileEvent},
 };
 use daemon::ctrl_fan_cpu::FanLevel;
 use gumdrop::Options;
@@ -27,6 +28,8 @@ struct CLIStart {
 enum Command {
     #[options(help = "Set the keyboard lighting from built-in modes")]
     LedMode(LedModeCommand),
+    #[options(help = "Create and configure profiles")]
+    Profile(ProfileCommand),
 }
 
 #[derive(Options)]
@@ -54,11 +57,18 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let writer = AuraDbusClient::new()?;
 
-    if let Some(Command::LedMode(mode)) = parsed.command {
-        if let Some(command) = mode.command {
-            writer.write_builtin_mode(&command.into())?
+    match parsed.command {
+        Some(Command::LedMode(mode)) => {
+            if let Some(command) = mode.command {
+                writer.write_builtin_mode(&command.into())?
+            }
         }
+        Some(Command::Profile(command)) => {
+            writer.write_profile_command(&ProfileEvent::Cli(command))?
+        }
+        None => (),
     }
+
     if let Some(brightness) = parsed.kbd_bright {
         writer.write_brightness(brightness.level())?;
     }

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>"]
@@ -16,6 +16,7 @@ serde = "^1.0"
 serde_derive = "^1.0"
 serde_json = "^1.0"
 yansi-term = "^0.1"
+rog_fan_curve = { version = "0.1", features = ["serde"] }
 
 [dev-dependencies]
 tinybmp = "^0.2.3"

asus-nb/src/core_dbus.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::fancy::KeyColourArray;
+use crate::profile::ProfileEvent;
 use dbus::channel::Sender;
 use dbus::{blocking::Connection, channel::Token, Message};
 use std::error::Error;
@@ -95,8 +96,20 @@ impl AuraDbusClient {
 
     #[inline]
     pub fn write_fan_mode(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetFanMode")?
-            .append1(level);
+        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ProfileCommand")?
+            .append1(serde_json::to_string(&ProfileEvent::ChangeMode(level))?);
+        msg.set_no_reply(true);
+        self.connection.send(msg).unwrap();
+        Ok(())
+    }
+
+    #[inline]
+    pub fn write_profile_command(
+        &self,
+        cmd: &ProfileEvent,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ProfileCommand")?
+            .append1(serde_json::to_string(cmd)?);
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
         Ok(())

asus-nb/src/lib.rs

@@ -6,6 +6,8 @@ pub const LED_MSG_LEN: usize = 17;
 pub mod aura_modes;
 use aura_modes::AuraModes;
 
+pub mod profile;
+
 /// Contains mostly only what is required for parsing CLI options
 pub mod cli_options;
 

asus-nb/src/profile.rs

@@ -0,0 +1,94 @@
+use gumdrop::Options;
+use rog_fan_curve::{Curve, Fan};
+use serde_derive::{Deserialize, Serialize};
+use std::str::FromStr;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum ProfileEvent {
+    Cli(ProfileCommand),
+    ChangeMode(u8),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum FanLevel {
+    Normal,
+    Boost,
+    Silent,
+}
+
+impl FromStr for FanLevel {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "normal" => Ok(FanLevel::Normal),
+            "boost" => Ok(FanLevel::Boost),
+            "silent" => Ok(FanLevel::Silent),
+            _ => Err("Invalid fan level"),
+        }
+    }
+}
+
+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,
+        }
+    }
+}
+
+impl From<&FanLevel> for u8 {
+    fn from(n: &FanLevel) -> Self {
+        match n {
+            FanLevel::Normal => 0,
+            FanLevel::Boost => 1,
+            FanLevel::Silent => 2,
+        }
+    }
+}
+
+fn parse_fan_curve(data: &str) -> Result<Curve, String> {
+    let curve = Curve::from_config_str(data)?;
+    if let Err(err) = curve.check_safety(Fan::Cpu) {
+        return Err(format!("Unsafe curve {:?}", err));
+    }
+    if let Err(err) = curve.check_safety(Fan::Gpu) {
+        return Err(format!("Unsafe curve {:?}", err));
+    }
+    Ok(curve)
+}
+
+#[derive(Debug, Clone, Options, Serialize, Deserialize)]
+pub struct ProfileCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(help = "create the profile if it doesn't exist")]
+    pub create: 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)")]
+    pub max_percentage: Option<u8>,
+
+    #[options(meta = "PWR", help = "<silent, normal, boost>")]
+    pub preset: Option<FanLevel>,
+    #[options(parse(try_from_str = "parse_fan_curve"), help = "set fan curve")]
+    pub curve: Option<Curve>,
+    #[options(free)]
+    pub profile: Option<String>,
+}