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

Is smol blocking or inotify blocking it?

Browse Source
This commit is contained in:
Luke D. Jones
2022-09-21 22:17:55 +12:00
parent 56285916cd
commit 5d87747d96
13 changed files with 142 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
daemon/src/ctrl_aura/controller.rs
View File

@@ -140,7 +140,7 @@ impl CtrlTask for CtrlKbdLedTask {
},
move || loop {
if let Ok(lock) = inner3.clone().try_lock() {
load_save(false, lock);
load_save(true, lock);
break;
}
},
@@ -153,6 +153,25 @@ impl CtrlTask for CtrlKbdLedTask {
)
.await;
let ctrl2 = self.inner.clone();
if let Ok(ctrl) = self.inner.lock() {
let mut watch = ctrl.kd_brightness.monitor_brightness()?;
executor
.spawn(async move {
let mut buffer = [0; 1024];
loop {
if let Ok(events) = watch.read_events_blocking(&mut buffer) {
for _ in events {
if let Ok(lock) = ctrl2.try_lock() {
load_save(true, lock);
}
}
}
}
})
.detach();
}
Ok(())
}
}

48
daemon/src/ctrl_platform.rs
View File

@@ -1,4 +1,4 @@
use crate::CtrlTask;
use crate::{CtrlTask, task_watch_item};
use crate::{config::Config, error::RogError, GetSupported};
use async_trait::async_trait;
use log::{info, warn};
@@ -154,7 +154,7 @@ impl CtrlRogBios {
Self::notify_gpu_mux_mode(&ctxt, mode).await.ok();
}
fn get_gpu_mux_mode(&self) -> GpuMode {
fn gpu_mux_mode(&self) -> GpuMode {
match self.platform.get_gpu_mux_mode() {
Ok(m) => GpuMode::from_mux(m),
Err(e) => {
@@ -220,7 +220,7 @@ impl CtrlRogBios {
}
/// Get the `panel_od` value from platform. Updates the stored value in internal config also.
fn get_panel_od(&self) -> bool {
fn panel_od(&self) -> bool {
let od = self
.platform
.get_panel_od()
@@ -262,42 +262,9 @@ impl crate::Reloadable for CtrlRogBios {
}
}
macro_rules! watch_item {
($name:ident) => {
concat_idents::concat_idents!(fn_name = watch_, $name {
async fn fn_name<'a>(
&self,
executor: &mut Executor<'a>,
signal_ctxt: SignalContext<'a>,
) -> Result<(), RogError> {
let ctrl = self.clone();
concat_idents::concat_idents!(watch_fn = monitor_, $name {
let mut watch = self.platform.watch_fn()?;
executor
.spawn(async move {
let mut buffer = [0; 1024];
loop {
if let Ok(events) = watch.read_events_blocking(&mut buffer) {
for _ in events {
let value = concat_idents::concat_idents!(get_fn = get_, $name { ctrl.get_fn() });
concat_idents::concat_idents!(notif_fn = notify_, $name {
Self::notif_fn(&signal_ctxt, value).await.unwrap();
});
}
}
}
})
.detach();
});
Ok(())
}
});
};
}
impl CtrlRogBios {
watch_item!(panel_od);
watch_item!(gpu_mux_mode);
task_watch_item!(panel_od platform);
task_watch_item!(gpu_mux_mode platform);
}
#[async_trait]
@@ -344,9 +311,8 @@ impl CtrlTask for CtrlRogBios {
)
.await;
self.watch_panel_od(executor, signal_ctxt.clone()).await?;
self.watch_gpu_mux_mode(executor, signal_ctxt.clone())
.await?;
self.watch_panel_od(executor, signal_ctxt.clone())?;
self.watch_gpu_mux_mode(executor, signal_ctxt.clone())?;
Ok(())
}

41
daemon/src/ctrl_power.rs
View File

@@ -1,5 +1,5 @@
use crate::CtrlTask;
use crate::{config::Config, error::RogError, GetSupported};
use crate::{task_watch_item, CtrlTask};
use async_trait::async_trait;
use log::{info, warn};
use rog_platform::power::AsusPower;
@@ -33,7 +33,7 @@ pub struct CtrlPower {
#[dbus_interface(name = "org.asuslinux.Daemon")]
impl CtrlPower {
async fn set_limit(
async fn set_charge_control_end_threshold(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
limit: u8,
@@ -47,19 +47,38 @@ impl CtrlPower {
err
})
.ok();
Self::notify_charge(&ctxt, limit).await?;
Self::notify_charge_control_end_threshold(&ctxt, limit).await?;
Ok(())
}
fn limit(&self) -> i8 {
if let Ok(config) = self.config.try_lock() {
return config.bat_charge_limit as i8;
fn charge_control_end_threshold(&self) -> u8 {
loop {
if let Ok(config) = self.config.try_lock() {
let limit = self
.power
.get_charge_control_end_threshold()
.map_err(|err| {
warn!("CtrlCharge: get_charge_control_end_threshold {}", err);
err
})
.unwrap_or(100);
self.set(limit)
.map_err(|err| {
warn!("CtrlCharge: set_limit {}", err);
err
})
.ok();
return config.bat_charge_limit;
}
}
-1
}
#[dbus_interface(signal)]
async fn notify_charge(ctxt: &SignalContext<'_>, limit: u8) -> zbus::Result<()>;
async fn notify_charge_control_end_threshold(
ctxt: &SignalContext<'_>,
limit: u8,
) -> zbus::Result<()>;
}
#[async_trait]
@@ -104,6 +123,8 @@ impl CtrlPower {
Ok(())
}
task_watch_item!(charge_control_end_threshold power);
}
#[async_trait]
@@ -111,7 +132,7 @@ impl CtrlTask for CtrlPower {
async fn create_tasks<'a>(
&self,
executor: &mut Executor<'a>,
_: SignalContext<'a>,
signal_ctxt: SignalContext<'a>,
) -> Result<(), RogError> {
let power1 = self.clone();
let power2 = self.clone();
@@ -146,6 +167,8 @@ impl CtrlTask for CtrlPower {
)
.await;
self.watch_charge_control_end_threshold(executor, signal_ctxt)?;
Ok(())
}
}

52
daemon/src/lib.rs
View File

@@ -58,6 +58,58 @@ pub trait ZbusAdd {
}
}
/// This macro adds a function which spawns an `inotify` task on the passed in `Executor`.
///
/// The generated function is `watch_<name>()`. Self requires the following methods to be available:
/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have side effects.
/// - `notify_<name>(SignalContext, SomeValue)`
///
/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is expected to update it.
///
/// # Example
///
/// ```ignore
/// impl CtrlRogBios {
/// task_watch_item!(panel_od platform);
/// task_watch_item!(gpu_mux_mode platform);
/// }
/// ```
#[macro_export]
macro_rules! task_watch_item {
($name:ident $self_inner:ident) => {
concat_idents::concat_idents!(fn_name = watch_, $name {
fn fn_name<'a>(
&self,
executor: &mut Executor<'a>,
signal_ctxt: SignalContext<'a>,
) -> Result<(), RogError> {
let ctrl = self.clone();
concat_idents::concat_idents!(watch_fn = monitor_, $name {
let mut watch = self.$self_inner.watch_fn()?;
executor
.spawn(async move {
let mut buffer = [0; 1024];
loop {
if let Ok(events) = watch.read_events_blocking(&mut buffer) {
for _ in events {
let value = ctrl.$name();
dbg!(value);
concat_idents::concat_idents!(notif_fn = notify_, $name {
Self::notif_fn(&signal_ctxt, value).await.unwrap();
});
}
}
}
})
.detach();
dbg!("SPWADEWFWEFE");
});
Ok(())
}
});
};
}
/// Set up a task to run on the async executor
#[async_trait]
pub trait CtrlTask {