gilles/asusctl
1
0
Fork 0
mirror of https://gitlab.com/asus-linux/asusctl.git synced 2026-02-06 00:15:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fixes: Handle keyboard nodes better.

Browse Source 
- 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
This commit is contained in:
Luke D Jones
2020-09-10 10:43:08 +12:00
parent 1b427c6c07
commit cddff32757
13 changed files with 143 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
asus-nb-ctrl/src/config.rs
View File

@@ -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,
}

19
asus-nb-ctrl/src/ctrl_anime.rs
View File

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

6
asus-nb-ctrl/src/ctrl_charge.rs
View File

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

43
asus-nb-ctrl/src/ctrl_fan_cpu.rs
View File

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

90
asus-nb-ctrl/src/ctrl_leds.rs
View File

@@ -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))
}

13
asus-nb-ctrl/src/daemon.rs
View File

@@ -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
};

20
asus-nb-ctrl/src/laptops.rs
View File

@@ -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
}

2
asus-nb-ctrl/src/lib.rs
View File

@@ -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};