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

Unify the laptop aura power stuff

Browse Source
This commit is contained in:
Luke D. Jones
2024-04-08 21:33:28 +12:00
parent 635d0378ac
commit 91ca049298
14 changed files with 425 additions and 501 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
asusd/src/ctrl_aura/config.rs
View File

@@ -1,112 +1,13 @@
use std::collections::{BTreeMap, HashSet};
use std::collections::BTreeMap;
use config_traits::{StdConfig, StdConfigLoad};
use log::{debug, info};
use rog_aura::aura_detection::LaptopLedData;
use rog_aura::keyboard::{LaptopAuraPower, LaptopOldAuraPower, LaptopTufAuraPower};
use rog_aura::usb::{AuraDevice, AuraPowerDev};
use rog_aura::keyboard::{LaptopAuraPower, LaptopAuraType};
use rog_aura::usb::AuraDevice;
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
use serde_derive::{Deserialize, Serialize};
/// Enable/disable LED control in various states such as
/// when the device is awake, suspended, shutting down or
/// booting.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum AuraPowerConfig {
AuraDevTuf(HashSet<LaptopTufAuraPower>),
AuraDevRog1(HashSet<LaptopOldAuraPower>),
AuraDevRog2(LaptopAuraPower),
}
impl Default for AuraPowerConfig {
fn default() -> Self {
Self::AuraDevTuf(HashSet::default())
}
}
impl AuraPowerConfig {
/// Invalid for TUF laptops
pub fn to_bytes(control: &Self) -> [u8; 4] {
match control {
AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0, 0],
AuraPowerConfig::AuraDevRog1(c) => {
let c: Vec<LaptopOldAuraPower> = c.iter().copied().collect();
LaptopOldAuraPower::to_bytes(&c)
}
AuraPowerConfig::AuraDevRog2(c) => c.to_bytes(),
}
}
pub fn to_tuf_bool_array(control: &Self) -> Option<[bool; 5]> {
if let Self::AuraDevTuf(c) = control {
return Some([
true,
c.contains(&LaptopTufAuraPower::Boot),
c.contains(&LaptopTufAuraPower::Awake),
c.contains(&LaptopTufAuraPower::Sleep),
c.contains(&LaptopTufAuraPower::Keyboard),
]);
}
if let Self::AuraDevRog1(c) = control {
return Some([
true,
c.contains(&LaptopOldAuraPower::Boot),
c.contains(&LaptopOldAuraPower::Awake),
c.contains(&LaptopOldAuraPower::Sleep),
c.contains(&LaptopOldAuraPower::Keyboard),
]);
}
None
}
pub fn set_tuf(&mut self, power: LaptopTufAuraPower, on: bool) {
if let Self::AuraDevTuf(p) = self {
if on {
p.insert(power);
} else {
p.remove(&power);
}
}
}
pub fn set_0x1866(&mut self, power: LaptopOldAuraPower, on: bool) {
if let Self::AuraDevRog1(p) = self {
if on {
p.insert(power);
} else {
p.remove(&power);
}
}
}
pub fn set_0x19b6(&mut self, power: LaptopAuraPower) {
if let Self::AuraDevRog2(p) = self {
*p = power;
}
}
}
impl From<&AuraPowerConfig> for AuraPowerDev {
fn from(config: &AuraPowerConfig) -> Self {
match config {
AuraPowerConfig::AuraDevTuf(d) => AuraPowerDev {
tuf: d.iter().copied().collect(),
..Default::default()
},
AuraPowerConfig::AuraDevRog1(d) => AuraPowerDev {
old_rog: d.iter().copied().collect(),
..Default::default()
},
AuraPowerConfig::AuraDevRog2(d) => AuraPowerDev {
rog: d.clone(),
..Default::default()
},
}
}
}
#[derive(Deserialize, Serialize, Default, Debug, Clone)]
// #[serde(default)]
pub struct AuraConfig {
@@ -116,7 +17,7 @@ pub struct AuraConfig {
pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
pub multizone_on: bool,
pub enabled: AuraPowerConfig,
pub enabled: LaptopAuraPower,
}
impl AuraConfig {
@@ -151,22 +52,11 @@ impl AuraConfig {
pub fn from_default_support(prod_id: AuraDevice, support_data: &LaptopLedData) -> Self {
// create a default config here
let enabled = if prod_id.is_new_style() {
AuraPowerConfig::AuraDevRog2(LaptopAuraPower::new_all_on())
LaptopAuraPower::new(LaptopAuraType::New, support_data)
} else if prod_id.is_tuf_style() {
AuraPowerConfig::AuraDevTuf(HashSet::from([
LaptopTufAuraPower::Awake,
LaptopTufAuraPower::Boot,
LaptopTufAuraPower::Sleep,
LaptopTufAuraPower::Keyboard,
]))
LaptopAuraPower::new(LaptopAuraType::Tuf, support_data)
} else {
AuraPowerConfig::AuraDevRog1(HashSet::from([
LaptopOldAuraPower::Awake,
LaptopOldAuraPower::Boot,
LaptopOldAuraPower::Sleep,
LaptopOldAuraPower::Keyboard,
LaptopOldAuraPower::Lightbar,
]))
LaptopAuraPower::new(LaptopAuraType::Old, support_data)
};
let mut config = AuraConfig {
config_name: format!("aura_{prod_id:?}.ron"),

14
asusd/src/ctrl_aura/controller.rs
View File

@@ -11,7 +11,7 @@ use rog_platform::hid_raw::HidRaw;
use rog_platform::keyboard_led::KeyboardLed;
use zbus::zvariant::OwnedObjectPath;
use super::config::{AuraConfig, AuraPowerConfig};
use super::config::AuraConfig;
use crate::ctrl_aura::manager::dbus_path_for_dev;
use crate::error::RogError;
@@ -191,12 +191,14 @@ impl CtrlKbdLed {
/// leds/side leds LED active
pub(super) fn set_power_states(&mut self) -> Result<(), RogError> {
if let LEDNode::KbdLed(platform) = &mut self.led_node {
if let Some(pwr) = AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
let buf = [1, pwr[1] as u8, pwr[2] as u8, pwr[3] as u8, pwr[4] as u8];
platform.set_kbd_rgb_state(&buf)?;
}
// TODO: tuf bool array
// if let Some(pwr) =
// AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
// let buf = [1, pwr[1] as u8, pwr[2] as u8, pwr[3] as u8,
// pwr[4] as u8]; platform.set_kbd_rgb_state(&buf)?;
// }
} else if let LEDNode::Rog(_, hid_raw) = &self.led_node {
let bytes = AuraPowerConfig::to_bytes(&self.config.enabled);
let bytes = self.config.enabled.to_bytes(self.led_prod.into());
let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], bytes[3]];
hid_raw.write_bytes(&message)?;

26
asusd/src/ctrl_aura/trait_impls.rs
View File

@@ -4,8 +4,8 @@ use std::sync::Arc;
use config_traits::StdConfig;
use log::{debug, error, info, warn};
use rog_aura::aura_detection::PowerZones;
use rog_aura::keyboard::UsbPackets;
use rog_aura::usb::{AuraDevice, AuraPowerDev};
use rog_aura::keyboard::{LaptopAuraPower, UsbPackets};
use rog_aura::usb::AuraDevice;
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, LedBrightness};
use zbus::export::futures_util::lock::{Mutex, MutexGuard};
use zbus::export::futures_util::StreamExt;
@@ -167,9 +167,9 @@ impl CtrlAuraZbus {
// As property doesn't work for AuraPowerDev (complexity of serialization?)
#[zbus(property)]
async fn led_power(&self) -> AuraPowerDev {
async fn led_power(&self) -> LaptopAuraPower {
let ctrl = self.0.lock().await;
AuraPowerDev::from(&ctrl.config.enabled)
ctrl.config.enabled.clone()
}
/// Set a variety of states, input is array of enum.
@@ -177,16 +177,16 @@ impl CtrlAuraZbus {
///
/// For Modern ROG devices the "enabled" flag is ignored.
#[zbus(property)]
async fn set_led_power(&mut self, options: AuraPowerDev) -> Result<(), ZbErr> {
async fn set_led_power(&mut self, options: LaptopAuraPower) -> Result<(), ZbErr> {
let mut ctrl = self.0.lock().await;
// TODO: set the older devices
// for p in options.tuf {
// ctrl.config.enabled.set_tuf(p, enabled);
// }
// for p in options.old_rog {
// ctrl.config.enabled.set_0x1866(p, enabled);
// }
ctrl.config.enabled.set_0x19b6(options.rog);
for opt in options.states {
let zone = opt.zone;
for config in ctrl.config.enabled.states.iter_mut() {
if config.zone == zone {
*config = opt;
}
}
}
ctrl.config.write();
Ok(ctrl.set_power_states().map_err(|e| {
warn!("{}", e);