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

Combination for power state leds boot/sleep/all/keys/side LEDS

Browse Source
This commit is contained in:
mpiffault
2022-06-19 22:03:23 +00:00
committed by Luke Jones
parent 9a50278b98
commit a0a0efabbb
8 changed files with 308 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
daemon/src/ctrl_aura/config.rs
View File

@@ -23,8 +23,10 @@ impl AuraConfigV320 {
current_mode: self.current_mode,
builtins: self.builtins,
multizone: self.multizone,
awake_enabled: true,
boot_anim_enabled: true,
sleep_anim_enabled: true,
all_leds_enabled: true,
keys_leds_enabled: true,
side_leds_enabled: true,
}
}
@@ -45,15 +47,17 @@ impl AuraConfigV352 {
current_mode: self.current_mode,
builtins: self.builtins,
multizone: self.multizone,
awake_enabled: true,
boot_anim_enabled: true,
sleep_anim_enabled: true,
all_leds_enabled: true,
keys_leds_enabled: true,
side_leds_enabled: true,
}
}
}
#[derive(Deserialize, Serialize)]
pub struct AuraConfig {
pub struct AuraConfigV407 {
pub brightness: LedBrightness,
pub current_mode: AuraModeNum,
pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
@@ -63,6 +67,36 @@ pub struct AuraConfig {
pub side_leds_enabled: bool,
}
impl AuraConfigV407 {
pub(crate) fn into_current(self) -> AuraConfig {
AuraConfig {
brightness: self.brightness,
current_mode: self.current_mode,
builtins: self.builtins,
multizone: self.multizone,
boot_anim_enabled: true,
sleep_anim_enabled: self.sleep_anim_enabled,
all_leds_enabled: self.awake_enabled,
keys_leds_enabled: self.awake_enabled,
side_leds_enabled: self.side_leds_enabled,
}
}
}
#[derive(Deserialize, Serialize)]
pub struct AuraConfig {
pub brightness: LedBrightness,
pub current_mode: AuraModeNum,
pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
pub multizone: Option<AuraMultiZone>,
pub boot_anim_enabled: bool,
pub sleep_anim_enabled: bool,
pub all_leds_enabled: bool,
pub keys_leds_enabled: bool,
pub side_leds_enabled: bool
}
impl Default for AuraConfig {
fn default() -> Self {
AuraConfig {
@@ -70,8 +104,10 @@ impl Default for AuraConfig {
current_mode: AuraModeNum::Static,
builtins: BTreeMap::new(),
multizone: None,
awake_enabled: true,
boot_anim_enabled: true,
sleep_anim_enabled: true,
all_leds_enabled: true,
keys_leds_enabled: true,
side_leds_enabled: true,
}
}
@@ -108,6 +144,11 @@ impl AuraConfig {
config.write();
info!("Updated AuraConfig version");
return config;
} else if let Ok(data) = serde_json::from_str::<AuraConfigV407>(&buf) {
let config = data.into_current();
config.write();
info!("Updated AuraConfig version");
return config;
}
warn!(
"Could not deserialise {}.\nWill rename to {}-old and recreate config",

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

@@ -11,8 +11,7 @@ use log::{error, info, warn};
use logind_zbus::manager::ManagerProxy;
use rog_aura::{
usb::{
LED_APPLY, LED_AWAKE_OFF_SLEEP_OFF, LED_AWAKE_OFF_SLEEP_ON, LED_AWAKE_ON_SLEEP_OFF,
LED_AWAKE_ON_SLEEP_ON, LED_SET, SIDE_LEDS_OFF, SIDE_LEDS_ON,
LED_APPLY, LED_SET
},
AuraEffect, LedBrightness, LED_MSG_LEN,
};
@@ -24,11 +23,14 @@ use std::path::Path;
use std::sync::Arc;
use std::sync::Mutex;
use zbus::Connection;
use rog_aura::usb::leds_message;
use crate::GetSupported;
use super::config::AuraConfig;
impl GetSupported for CtrlKbdLed {
type A = LedSupportedFunctions;
@@ -120,11 +122,6 @@ impl CtrlTask for CtrlKbdLedTask {
// lock.set_brightness(lock.config.brightness)
// .map_err(|e| error!("CtrlKbdLedTask: {e}"))
// .ok();
lock.set_side_leds_states(
lock.config.side_leds_enabled,
)
.map_err(|e| error!("CtrlKbdLedTask: {e}"))
.ok();
if let Some(mode) =
lock.config.builtins.get(&lock.config.current_mode)
{
@@ -165,11 +162,7 @@ impl crate::Reloadable for CtrlKbdLedReloader {
ctrl.do_command(mode).ok();
}
ctrl.set_states_enabled(ctrl.config.awake_enabled, ctrl.config.sleep_anim_enabled)
.map_err(|err| warn!("{err}"))
.ok();
ctrl.set_side_leds_states(ctrl.config.side_leds_enabled)
ctrl.set_power_states(&ctrl.config)
.map_err(|err| warn!("{err}"))
.ok();
}
@@ -288,33 +281,23 @@ impl CtrlKbdLed {
self.set_brightness(self.config.brightness)
}
/// Set if awake/on LED active, and/or sleep animation active
pub(super) fn set_states_enabled(&self, awake: bool, sleep: bool) -> Result<(), RogError> {
let bytes = if awake && sleep {
LED_AWAKE_ON_SLEEP_ON
} else if awake && !sleep {
LED_AWAKE_ON_SLEEP_OFF
} else if !awake && sleep {
LED_AWAKE_OFF_SLEEP_ON
} else if !awake && !sleep {
LED_AWAKE_OFF_SLEEP_OFF
} else {
LED_AWAKE_ON_SLEEP_ON
};
self.write_bytes(&bytes)?;
self.write_bytes(&LED_SET)?;
// Changes won't persist unless apply is set
self.write_bytes(&LED_APPLY)?;
Ok(())
}
pub(super) fn set_side_leds_states(&self, activated: bool) -> Result<(), RogError> {
let bytes: [u8; LED_MSG_LEN] = if activated {
SIDE_LEDS_ON
} else {
SIDE_LEDS_OFF
};
self.write_bytes(&bytes)?;
/// Set combination state for boot animation/sleep animation/all leds/keys leds/side leds LED active
pub(super) fn set_power_states(&self, config: &AuraConfig) -> Result<(), RogError> {
let bytes = leds_message(config.boot_anim_enabled,
config.sleep_anim_enabled,
config.all_leds_enabled,
config.keys_leds_enabled,
config.side_leds_enabled);
// Quite ugly, must be a more idiomatic way to do
let message = [
0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
];
self.write_bytes(&message)?;
self.write_bytes(&LED_SET)?;
// Changes won't persist unless apply is set
self.write_bytes(&LED_APPLY)?;

143
daemon/src/ctrl_aura/zbus.rs
View File

@@ -27,22 +27,26 @@ impl CtrlKbdLedZbus {
}
/// Set the keyboard LED to enabled while the device is awake
async fn set_awake_enabled(
async fn set_boot_enabled(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
enabled: bool,
) {
let mut states = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.set_states_enabled(enabled, ctrl.config.sleep_anim_enabled)
.map_err(|err| warn!("{}", err))
.ok();
ctrl.config.awake_enabled = enabled;
ctrl.config.boot_anim_enabled = enabled;
ctrl.config.write();
ctrl.set_power_states(&ctrl.config)
.map_err(|err| warn!("{}", err))
.ok();
states = Some(LedPowerStates {
enabled: ctrl.config.awake_enabled,
sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
boot_anim: ctrl.config.boot_anim_enabled,
sleep_anim: ctrl.config.sleep_anim_enabled,
all_leds: ctrl.config.all_leds_enabled,
keys_leds: ctrl.config.keys_leds_enabled,
side_leds: ctrl.config.side_leds_enabled
});
}
// Need to pull state out like this due to MutexGuard
@@ -61,14 +65,19 @@ impl CtrlKbdLedZbus {
) {
let mut states = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.set_states_enabled(ctrl.config.awake_enabled, enabled)
.map_err(|err| warn!("{}", err))
.ok();
ctrl.config.sleep_anim_enabled = enabled;
ctrl.config.write();
ctrl.set_power_states(&ctrl.config)
.map_err(|err| warn!("{}", err))
.ok();
states = Some(LedPowerStates {
enabled: ctrl.config.awake_enabled,
sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
boot_anim: ctrl.config.boot_anim_enabled,
sleep_anim: ctrl.config.sleep_anim_enabled,
all_leds: ctrl.config.all_leds_enabled,
keys_leds: ctrl.config.keys_leds_enabled,
side_leds: ctrl.config.side_leds_enabled
});
}
if let Some(states) = states {
@@ -78,23 +87,96 @@ impl CtrlKbdLedZbus {
}
}
/// Set all the keyboard LEDs (keys and side) to enabled
async fn set_all_leds_enabled(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
enabled: bool,
) {
let mut states = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.config.all_leds_enabled = enabled;
ctrl.config.keys_leds_enabled = enabled;
ctrl.config.side_leds_enabled = enabled;
ctrl.config.write();
ctrl.set_power_states(&ctrl.config)
.map_err(|err| warn!("{}", err))
.ok();
states = Some(LedPowerStates {
boot_anim: ctrl.config.boot_anim_enabled,
sleep_anim: ctrl.config.sleep_anim_enabled,
all_leds: ctrl.config.all_leds_enabled,
keys_leds: ctrl.config.keys_leds_enabled,
side_leds: ctrl.config.side_leds_enabled
});
}
// Need to pull state out like this due to MutexGuard
if let Some(states) = states {
Self::notify_power_states(&ctxt, &states)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
/// Set the keyboard keys LEDs to enabled
async fn set_keys_leds_enabled(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
enabled: bool,
) {
let mut states = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.config.keys_leds_enabled = enabled;
ctrl.config.write();
ctrl.set_power_states(&ctrl.config)
.map_err(|err| warn!("{}", err))
.ok();
states = Some(LedPowerStates {
boot_anim: ctrl.config.boot_anim_enabled,
sleep_anim: ctrl.config.sleep_anim_enabled,
all_leds: ctrl.config.all_leds_enabled,
keys_leds: ctrl.config.keys_leds_enabled,
side_leds: ctrl.config.side_leds_enabled
});
}
// Need to pull state out like this due to MutexGuard
if let Some(states) = states {
Self::notify_power_states(&ctxt, &states)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
/// Set the keyboard side LEDs to enabled
async fn set_side_leds_enabled(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
enabled: bool,
) {
let mut led = None;
let mut states = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.set_side_leds_states(enabled)
.map_err(|err| warn!("{}", err))
.ok();
ctrl.config.side_leds_enabled = enabled;
ctrl.config.write();
led = Some(enabled);
ctrl.set_power_states(&ctrl.config)
.map_err(|err| warn!("{}", err))
.ok();
states = Some(LedPowerStates {
boot_anim: ctrl.config.boot_anim_enabled,
sleep_anim: ctrl.config.sleep_anim_enabled,
all_leds: ctrl.config.all_leds_enabled,
keys_leds: ctrl.config.keys_leds_enabled,
side_leds: ctrl.config.side_leds_enabled
});
}
if let Some(led) = led {
Self::notify_side_leds(&ctxt, led)
// Need to pull state out like this due to MutexGuard
if let Some(states) = states {
Self::notify_power_states(&ctxt, &states)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
@@ -174,9 +256,9 @@ impl CtrlKbdLedZbus {
}
#[dbus_interface(property)]
async fn awake_enabled(&self) -> bool {
async fn boot_enabled(&self) -> bool {
if let Ok(ctrl) = self.0.try_lock() {
return ctrl.config.awake_enabled;
return ctrl.config.boot_anim_enabled;
}
true
}
@@ -189,6 +271,22 @@ impl CtrlKbdLedZbus {
true
}
#[dbus_interface(property)]
async fn all_leds_enabled(&self) -> bool {
if let Ok(ctrl) = self.0.try_lock() {
return ctrl.config.all_leds_enabled;
}
true
}
#[dbus_interface(property)]
async fn keys_leds_enabled(&self) -> bool {
if let Ok(ctrl) = self.0.try_lock() {
return ctrl.config.keys_leds_enabled;
}
true
}
#[dbus_interface(property)]
fn side_leds_enabled(&self) -> bool {
if let Ok(ctrl) = self.0.try_lock() {
@@ -236,9 +334,6 @@ impl CtrlKbdLedZbus {
#[dbus_interface(signal)]
async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
#[dbus_interface(signal)]
async fn notify_side_leds(signal_ctxt: &SignalContext<'_>, data: bool) -> zbus::Result<()>;
#[dbus_interface(signal)]
async fn notify_power_states(
signal_ctxt: &SignalContext<'_>,