gilles/asusctl
1
0
Fork 0
mirror of https://gitlab.com/asus-linux/asusctl.git synced 2026-01-22 17:33:19 +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

12
CHANGELOG.md
View File

@@ -5,8 +5,20 @@ 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 - 4.4.1]
### Added
- intofy watches on:
- `charge_control_end_threshold`
- `panel_od`
- `gpu_mux_mode`
- `platform_profile`
- These allow for updating any associated config and sending dbus notifications.
### Changed
- Use loops to ensure that mutex is gained for LED changes.
### Breaking
- DBUS: all charge control methods renamed:
- `ChargeControlEndThreshold`
- `SetChargeControlEndThreshold`
- `NotifyChargeControlEndThreshold`
## [v4.4.0] - 2022-08-29
### Added

2
asus-notify/src/main.rs
View File

@@ -70,7 +70,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
.spawn(async move {
let conn = zbus::Connection::system().await.unwrap();
let proxy = ChargeProxy::new(&conn).await.unwrap();
if let Ok(p) = proxy.receive_notify_charge().await {
if let Ok(p) = proxy.receive_notify_charge_control_end_threshold().await {
p.for_each(|e| {
if let Ok(out) = e.args() {
if let Ok(ref mut lock) = x.try_lock() {

6
asusctl/src/main.rs
View File

@@ -211,7 +211,7 @@ fn do_parsed(
}
if let Some(chg_limit) = parsed.chg_limit {
dbus.proxies().charge().set_limit(chg_limit)?;
dbus.proxies().charge().set_charge_control_end_threshold(chg_limit)?;
}
Ok(())
@@ -803,10 +803,10 @@ fn handle_bios_option(
}
if let Some(opt) = cmd.panel_overdrive_set {
dbus.proxies().rog_bios().set_panel_overdrive(opt)?;
dbus.proxies().rog_bios().set_panel_od(opt)?;
}
if cmd.panel_overdrive_get {
let res = dbus.proxies().rog_bios().panel_overdrive()?;
let res = dbus.proxies().rog_bios().panel_od()?;
println!("Panel overdrive on: {}", res);
}
}

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 {

2
rog-control-center/src/notify.rs
View File

@@ -103,7 +103,7 @@ pub fn start_notifications(
.spawn(async move {
let conn = zbus::Connection::system().await.unwrap();
let proxy = ChargeProxy::new(&conn).await.unwrap();
if let Ok(p) = proxy.receive_notify_charge().await {
if let Ok(p) = proxy.receive_notify_charge_control_end_threshold().await {
p.for_each(|e| {
if let Ok(out) = e.args() {
if notifs_enabled1.load(Ordering::SeqCst) {

8
rog-control-center/src/page_states.rs
View File

@@ -45,7 +45,7 @@ impl BiosState {
GpuMode::NotSupported
},
panel_overdrive: if supported.rog_bios_ctrl.panel_overdrive {
dbus.proxies().rog_bios().panel_overdrive()?
dbus.proxies().rog_bios().panel_od()?
} else {
false
},
@@ -258,7 +258,7 @@ pub struct PageDataStates {
pub anime: AnimeState,
pub profiles: ProfilesState,
pub fan_curves: FanCurvesState,
pub charge_limit: i16,
pub charge_limit: u8,
pub error: Option<String>,
}
@@ -279,7 +279,7 @@ impl PageDataStates {
keyboard_layout,
notifs_enabled,
was_notified: charge_notified,
charge_limit: dbus.proxies().charge().limit()?,
charge_limit: dbus.proxies().charge().charge_control_end_threshold()?,
bios: BiosState::new(bios_notified, supported, dbus)?,
aura: AuraState::new(aura_notified, supported, dbus)?,
anime: AnimeState::new(anime_notified, supported, dbus)?,
@@ -296,7 +296,7 @@ impl PageDataStates {
) -> Result<bool> {
let mut notified = false;
if self.was_notified.load(Ordering::SeqCst) {
self.charge_limit = dbus.proxies().charge().limit()?;
self.charge_limit = dbus.proxies().charge().charge_control_end_threshold()?;
self.was_notified.store(false, Ordering::SeqCst);
notified = true;
}

4
rog-control-center/src/widgets/rog_bios.rs
View File

@@ -47,7 +47,7 @@ pub fn rog_bios_group(
if ui.add(slider).drag_released() {
dbus.proxies()
.charge()
.set_limit(states.charge_limit as u8)
.set_charge_control_end_threshold(states.charge_limit as u8)
.map_err(|err| {
states.error = Some(err.to_string());
})
@@ -82,7 +82,7 @@ pub fn rog_bios_group(
{
dbus.proxies()
.rog_bios()
.set_panel_overdrive(states.bios.panel_overdrive)
.set_panel_od(states.bios.panel_overdrive)
.map_err(|err| {
states.error = Some(err.to_string());
})

10
rog-dbus/src/zbus_charge.rs
View File

@@ -26,13 +26,13 @@ use zbus_macros::dbus_proxy;
default_path = "/org/asuslinux/Charge"
)]
trait Charge {
/// Limit method
fn limit(&self) -> zbus::Result<i16>;
/// charge_control_end_threshold method
fn charge_control_end_threshold(&self) -> zbus::Result<u8>;
/// SetLimit method
fn set_limit(&self, limit: u8) -> zbus::Result<()>;
/// set_charge_control_end_threshold method
fn set_charge_control_end_threshold(&self, limit: u8) -> zbus::Result<()>;
/// NotifyCharge signal
#[dbus_proxy(signal)]
fn notify_charge(&self, limit: u8) -> zbus::Result<u8>;
fn notify_charge_control_end_threshold(&self, limit: u8) -> zbus::Result<u8>;
}

4
rog-dbus/src/zbus_platform.rs
View File

@@ -40,10 +40,10 @@ trait RogBios {
fn set_post_boot_sound(&self, on: bool) -> zbus::Result<()>;
/// PanelOverdrive method
fn panel_overdrive(&self) -> zbus::Result<bool>;
fn panel_od(&self) -> zbus::Result<bool>;
/// SetPanelOverdrive method
fn set_panel_overdrive(&self, overdrive: bool) -> zbus::Result<()>;
fn set_panel_od(&self, overdrive: bool) -> zbus::Result<()>;
/// NotifyDedicatedGraphicMode signal
#[dbus_proxy(signal)]

1
rog-platform/src/macros.rs
View File

@@ -21,6 +21,7 @@ macro_rules! watch_attr {
pub fn fn_name(&self) -> Result<inotify::Inotify> {
let mut path = self.$item.clone();
path.push($attr_name);
dbg!(&path);
let mut inotify = inotify::Inotify::init().unwrap();
inotify.add_watch(path.to_str().unwrap(), inotify::WatchMask::MODIFY).unwrap();
Ok(inotify)