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

Optimise keyboard detection

Browse Source
This commit is contained in:
Luke D. Jones
2023-04-24 22:23:42 +12:00
parent 869ab90299
commit c819fa458a
8 changed files with 308 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@@ -9,10 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- Support for G733Z LED modes - Support for G733Z LED modes
- Support for GU604V LED modes - Support for GU604V LED modes
- Support for GX650P LED modes - Support for GX650P LED modes
- Add device code for the Z13 ACRNM keyboard
- Add device code for the plain Z13 keyboard
### Changed ### Changed
- Adjustments to Anime system events thread - Adjustments to Anime system events thread
- Add "sleep" animetion config options to anime config - Add "sleep" animetion config options to anime config
- rog-control-center dark/light mode persisency - rog-control-center dark/light mode persistency
- Adjustments to keyboard detection
## [v4.6.0] ## [v4.6.0]
### Added ### Added

60
asusctl/src/main.rs
View File

@@ -10,7 +10,7 @@ use gumdrop::{Opt, Options};
use profiles_cli::{FanCurveCommand, ProfileCommand}; use profiles_cli::{FanCurveCommand, ProfileCommand};
use rog_anime::usb::get_anime_type; use rog_anime::usb::get_anime_type;
use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2}; use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2};
use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev}; use rog_aura::usb::{AuraDevRog1, AuraDevRog2, AuraDevTuf, AuraDevice, AuraPowerDev};
use rog_aura::{self, AuraEffect}; use rog_aura::{self, AuraEffect};
use rog_dbus::RogDbusClientBlocking; use rog_dbus::RogDbusClientBlocking;
use rog_platform::platform::GpuMode; use rog_platform::platform::GpuMode;
@@ -157,7 +157,7 @@ fn do_parsed(
{ {
return false; return false;
} }
if supported.keyboard_led.dev_id != AuraDevice::X19B6 if supported.keyboard_led.dev_id != AuraDevice::X19b6
&& command.trim().starts_with("led-pow-2") && command.trim().starts_with("led-pow-2")
{ {
return false; return false;
@@ -472,10 +472,10 @@ fn handle_led_power_1_do_1866(
dbus: &RogDbusClientBlocking<'_>, dbus: &RogDbusClientBlocking<'_>,
power: &LedPowerCommand1, power: &LedPowerCommand1,
) -> Result<(), Box<dyn std::error::Error>> { ) -> Result<(), Box<dyn std::error::Error>> {
let mut enabled: Vec<AuraDev1866> = Vec::new(); let mut enabled: Vec<AuraDevRog1> = Vec::new();
let mut disabled: Vec<AuraDev1866> = Vec::new(); let mut disabled: Vec<AuraDevRog1> = Vec::new();
let mut check = |e: Option<bool>, a: AuraDev1866| { let mut check = |e: Option<bool>, a: AuraDevRog1| {
if let Some(arg) = e { if let Some(arg) = e {
if arg { if arg {
enabled.push(a); enabled.push(a);
@@ -485,11 +485,11 @@ fn handle_led_power_1_do_1866(
} }
}; };
check(power.awake, AuraDev1866::Awake); check(power.awake, AuraDevRog1::Awake);
check(power.boot, AuraDev1866::Boot); check(power.boot, AuraDevRog1::Boot);
check(power.sleep, AuraDev1866::Sleep); check(power.sleep, AuraDevRog1::Sleep);
check(power.keyboard, AuraDev1866::Keyboard); check(power.keyboard, AuraDevRog1::Keyboard);
check(power.lightbar, AuraDev1866::Lightbar); check(power.lightbar, AuraDevRog1::Lightbar);
let data = AuraPowerDev { let data = AuraPowerDev {
x1866: enabled, x1866: enabled,
@@ -576,13 +576,13 @@ fn handle_led_power2(
return Ok(()); return Ok(());
} }
if supported.dev_id != AuraDevice::X19B6 { if supported.dev_id != AuraDevice::X19b6 {
println!("This option applies only to keyboards with product ID 0x19b6"); println!("This option applies only to keyboards with product ID 0x19b6");
} }
let mut enabled: Vec<AuraDev19b6> = Vec::new(); let mut enabled: Vec<AuraDevRog2> = Vec::new();
let mut disabled: Vec<AuraDev19b6> = Vec::new(); let mut disabled: Vec<AuraDevRog2> = Vec::new();
let mut check = |e: Option<bool>, a: AuraDev19b6| { let mut check = |e: Option<bool>, a: AuraDevRog2| {
if let Some(arg) = e { if let Some(arg) = e {
if arg { if arg {
enabled.push(a); enabled.push(a);
@@ -594,28 +594,28 @@ fn handle_led_power2(
match pow { match pow {
aura_cli::SetAuraEnabled::Boot(arg) => { aura_cli::SetAuraEnabled::Boot(arg) => {
check(arg.keyboard, AuraDev19b6::BootKeyb); check(arg.keyboard, AuraDevRog2::BootKeyb);
check(arg.logo, AuraDev19b6::BootLogo); check(arg.logo, AuraDevRog2::BootLogo);
check(arg.lightbar, AuraDev19b6::BootBar); check(arg.lightbar, AuraDevRog2::BootBar);
check(arg.lid, AuraDev19b6::AwakeLid); check(arg.lid, AuraDevRog2::AwakeLid);
} }
aura_cli::SetAuraEnabled::Sleep(arg) => { aura_cli::SetAuraEnabled::Sleep(arg) => {
check(arg.keyboard, AuraDev19b6::SleepKeyb); check(arg.keyboard, AuraDevRog2::SleepKeyb);
check(arg.logo, AuraDev19b6::SleepLogo); check(arg.logo, AuraDevRog2::SleepLogo);
check(arg.lightbar, AuraDev19b6::SleepBar); check(arg.lightbar, AuraDevRog2::SleepBar);
check(arg.lid, AuraDev19b6::SleepLid); check(arg.lid, AuraDevRog2::SleepLid);
} }
aura_cli::SetAuraEnabled::Awake(arg) => { aura_cli::SetAuraEnabled::Awake(arg) => {
check(arg.keyboard, AuraDev19b6::AwakeKeyb); check(arg.keyboard, AuraDevRog2::AwakeKeyb);
check(arg.logo, AuraDev19b6::AwakeLogo); check(arg.logo, AuraDevRog2::AwakeLogo);
check(arg.lightbar, AuraDev19b6::AwakeBar); check(arg.lightbar, AuraDevRog2::AwakeBar);
check(arg.lid, AuraDev19b6::AwakeLid); check(arg.lid, AuraDevRog2::AwakeLid);
} }
aura_cli::SetAuraEnabled::Shutdown(arg) => { aura_cli::SetAuraEnabled::Shutdown(arg) => {
check(arg.keyboard, AuraDev19b6::ShutdownKeyb); check(arg.keyboard, AuraDevRog2::ShutdownKeyb);
check(arg.logo, AuraDev19b6::ShutdownLogo); check(arg.logo, AuraDevRog2::ShutdownLogo);
check(arg.lightbar, AuraDev19b6::ShutdownBar); check(arg.lightbar, AuraDevRog2::ShutdownBar);
check(arg.lid, AuraDev19b6::ShutdownBar); check(arg.lid, AuraDevRog2::ShutdownBar);
} }
} }

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

@@ -1,11 +1,9 @@
use std::collections::{BTreeMap, HashSet}; use std::collections::{BTreeMap, HashSet};
use config_traits::{StdConfig, StdConfigLoad}; use config_traits::{StdConfig, StdConfigLoad};
use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES}; use rog_aura::aura_detection::LaptopLedData;
use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev}; use rog_aura::usb::{AuraDevRog1, AuraDevRog2, AuraDevTuf, AuraDevice, AuraPowerDev};
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT}; use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
use rog_platform::hid_raw::HidRaw;
use rog_platform::keyboard_led::KeyboardLed;
use serde_derive::{Deserialize, Serialize}; use serde_derive::{Deserialize, Serialize};
const CONFIG_FILE: &str = "aura.ron"; const CONFIG_FILE: &str = "aura.ron";
@@ -16,8 +14,8 @@ const CONFIG_FILE: &str = "aura.ron";
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum AuraPowerConfig { pub enum AuraPowerConfig {
AuraDevTuf(HashSet<AuraDevTuf>), AuraDevTuf(HashSet<AuraDevTuf>),
AuraDev1866(HashSet<AuraDev1866>), AuraDevRog1(HashSet<AuraDevRog1>),
AuraDev19b6(HashSet<AuraDev19b6>), AuraDevRog2(HashSet<AuraDevRog2>),
} }
impl AuraPowerConfig { impl AuraPowerConfig {
@@ -25,13 +23,13 @@ impl AuraPowerConfig {
pub fn to_bytes(control: &Self) -> [u8; 3] { pub fn to_bytes(control: &Self) -> [u8; 3] {
match control { match control {
AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0], AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0],
AuraPowerConfig::AuraDev1866(c) => { AuraPowerConfig::AuraDevRog1(c) => {
let c: Vec<AuraDev1866> = c.iter().copied().collect(); let c: Vec<AuraDevRog1> = c.iter().copied().collect();
AuraDev1866::to_bytes(&c) AuraDevRog1::to_bytes(&c)
} }
AuraPowerConfig::AuraDev19b6(c) => { AuraPowerConfig::AuraDevRog2(c) => {
let c: Vec<AuraDev19b6> = c.iter().copied().collect(); let c: Vec<AuraDevRog2> = c.iter().copied().collect();
AuraDev19b6::to_bytes(&c) AuraDevRog2::to_bytes(&c)
} }
} }
} }
@@ -47,13 +45,13 @@ impl AuraPowerConfig {
]); ]);
} }
if let Self::AuraDev1866(c) = control { if let Self::AuraDevRog1(c) = control {
return Some([ return Some([
true, true,
c.contains(&AuraDev1866::Boot), c.contains(&AuraDevRog1::Boot),
c.contains(&AuraDev1866::Awake), c.contains(&AuraDevRog1::Awake),
c.contains(&AuraDev1866::Sleep), c.contains(&AuraDevRog1::Sleep),
c.contains(&AuraDev1866::Keyboard), c.contains(&AuraDevRog1::Keyboard),
]); ]);
} }
@@ -70,8 +68,8 @@ impl AuraPowerConfig {
} }
} }
pub fn set_0x1866(&mut self, power: AuraDev1866, on: bool) { pub fn set_0x1866(&mut self, power: AuraDevRog1, on: bool) {
if let Self::AuraDev1866(p) = self { if let Self::AuraDevRog1(p) = self {
if on { if on {
p.insert(power); p.insert(power);
} else { } else {
@@ -80,8 +78,8 @@ impl AuraPowerConfig {
} }
} }
pub fn set_0x19b6(&mut self, power: AuraDev19b6, on: bool) { pub fn set_0x19b6(&mut self, power: AuraDevRog2, on: bool) {
if let Self::AuraDev19b6(p) = self { if let Self::AuraDevRog2(p) = self {
if on { if on {
p.insert(power); p.insert(power);
} else { } else {
@@ -99,12 +97,12 @@ impl From<&AuraPowerConfig> for AuraPowerDev {
x1866: vec![], x1866: vec![],
x19b6: vec![], x19b6: vec![],
}, },
AuraPowerConfig::AuraDev1866(d) => AuraPowerDev { AuraPowerConfig::AuraDevRog1(d) => AuraPowerDev {
tuf: vec![], tuf: vec![],
x1866: d.iter().copied().collect(), x1866: d.iter().copied().collect(),
x19b6: vec![], x19b6: vec![],
}, },
AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev { AuraPowerConfig::AuraDevRog2(d) => AuraPowerDev {
tuf: vec![], tuf: vec![],
x1866: vec![], x1866: vec![],
x19b6: d.iter().copied().collect(), x19b6: d.iter().copied().collect(),
@@ -124,70 +122,9 @@ pub struct AuraConfig {
pub enabled: AuraPowerConfig, pub enabled: AuraPowerConfig,
} }
impl Default for AuraConfig {
fn default() -> Self {
let mut prod_id = AuraDevice::Unknown;
for prod in &ASUS_KEYBOARD_DEVICES {
if HidRaw::new(prod).is_ok() {
prod_id = AuraDevice::from(*prod);
break;
}
}
if prod_id == AuraDevice::Unknown {
if let Ok(p) = KeyboardLed::new() {
if p.has_kbd_rgb_mode() {
prod_id = AuraDevice::Tuf;
}
}
}
let enabled = if prod_id == AuraDevice::X19B6 {
AuraPowerConfig::AuraDev19b6(HashSet::from([
AuraDev19b6::BootLogo,
AuraDev19b6::BootKeyb,
AuraDev19b6::SleepLogo,
AuraDev19b6::SleepKeyb,
AuraDev19b6::AwakeLogo,
AuraDev19b6::AwakeKeyb,
AuraDev19b6::ShutdownLogo,
AuraDev19b6::ShutdownKeyb,
AuraDev19b6::BootBar,
AuraDev19b6::AwakeBar,
AuraDev19b6::SleepBar,
AuraDev19b6::ShutdownBar,
]))
} else if prod_id == AuraDevice::Tuf {
AuraPowerConfig::AuraDevTuf(HashSet::from([
AuraDevTuf::Awake,
AuraDevTuf::Boot,
AuraDevTuf::Sleep,
AuraDevTuf::Keyboard,
]))
} else {
AuraPowerConfig::AuraDev1866(HashSet::from([
AuraDev1866::Awake,
AuraDev1866::Boot,
AuraDev1866::Sleep,
AuraDev1866::Keyboard,
AuraDev1866::Lightbar,
]))
};
AuraConfig {
brightness: LedBrightness::Med,
current_mode: AuraModeNum::Static,
builtins: BTreeMap::new(),
multizone: None,
multizone_on: false,
enabled,
}
}
}
impl StdConfig for AuraConfig { impl StdConfig for AuraConfig {
fn new() -> Self { fn new() -> Self {
Self::create_default(&LaptopLedData::get_data()) Self::create_default(AuraDevice::X19b6, &LaptopLedData::get_data())
} }
fn config_dir() -> std::path::PathBuf { fn config_dir() -> std::path::PathBuf {
@@ -202,9 +139,47 @@ impl StdConfig for AuraConfig {
impl StdConfigLoad for AuraConfig {} impl StdConfigLoad for AuraConfig {}
impl AuraConfig { impl AuraConfig {
fn create_default(support_data: &LaptopLedData) -> Self { pub fn create_default(prod_id: AuraDevice, support_data: &LaptopLedData) -> Self {
// create a default config here // create a default config here
let mut config = AuraConfig::default(); let enabled = if prod_id == AuraDevice::X19b6 {
AuraPowerConfig::AuraDevRog2(HashSet::from([
AuraDevRog2::BootLogo,
AuraDevRog2::BootKeyb,
AuraDevRog2::SleepLogo,
AuraDevRog2::SleepKeyb,
AuraDevRog2::AwakeLogo,
AuraDevRog2::AwakeKeyb,
AuraDevRog2::ShutdownLogo,
AuraDevRog2::ShutdownKeyb,
AuraDevRog2::BootBar,
AuraDevRog2::AwakeBar,
AuraDevRog2::SleepBar,
AuraDevRog2::ShutdownBar,
]))
} else if prod_id == AuraDevice::Tuf {
AuraPowerConfig::AuraDevTuf(HashSet::from([
AuraDevTuf::Awake,
AuraDevTuf::Boot,
AuraDevTuf::Sleep,
AuraDevTuf::Keyboard,
]))
} else {
AuraPowerConfig::AuraDevRog1(HashSet::from([
AuraDevRog1::Awake,
AuraDevRog1::Boot,
AuraDevRog1::Sleep,
AuraDevRog1::Keyboard,
AuraDevRog1::Lightbar,
]))
};
let mut config = AuraConfig {
brightness: LedBrightness::Med,
current_mode: AuraModeNum::Static,
builtins: BTreeMap::new(),
multizone: None,
multizone_on: false,
enabled,
};
for n in &support_data.basic_modes { for n in &support_data.basic_modes {
config config
@@ -276,13 +251,15 @@ impl AuraConfig {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use rog_aura::aura_detection::LaptopLedData;
use rog_aura::usb::AuraDevice;
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour}; use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
use super::AuraConfig; use super::AuraConfig;
#[test] #[test]
fn set_multizone_4key_config() { fn set_multizone_4key_config() {
let mut config = AuraConfig::default(); let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
let effect = AuraEffect { let effect = AuraEffect {
colour1: Colour(0xff, 0x00, 0xff), colour1: Colour(0xff, 0x00, 0xff),
@@ -328,7 +305,7 @@ mod tests {
#[test] #[test]
fn set_multizone_multimode_config() { fn set_multizone_multimode_config() {
let mut config = AuraConfig::default(); let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
let effect = AuraEffect { let effect = AuraEffect {
zone: AuraZone::Key1, zone: AuraZone::Key1,

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

@@ -1,6 +1,6 @@
use std::collections::BTreeMap; use std::collections::BTreeMap;
use config_traits::StdConfig; use config_traits::{StdConfig, StdConfigLoad};
use log::{info, warn}; use log::{info, warn};
use rog_aura::advanced::{LedUsbPackets, UsbPackets}; use rog_aura::advanced::{LedUsbPackets, UsbPackets};
use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES}; use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
@@ -25,9 +25,9 @@ impl GetSupported for CtrlKbdLed {
let advanced_type = laptop.advanced_type; let advanced_type = laptop.advanced_type;
let mut prod_id = AuraDevice::Unknown; let mut prod_id = AuraDevice::Unknown;
for prod in &ASUS_KEYBOARD_DEVICES { for prod in ASUS_KEYBOARD_DEVICES {
if HidRaw::new(prod).is_ok() { if HidRaw::new(prod.into()).is_ok() {
prod_id = AuraDevice::from(*prod); prod_id = prod;
break; break;
} }
} }
@@ -58,7 +58,7 @@ pub enum LEDNode {
pub struct CtrlKbdLed { pub struct CtrlKbdLed {
// TODO: config stores the keyboard type as an AuraPower, use or update this // TODO: config stores the keyboard type as an AuraPower, use or update this
pub led_prod: Option<String>, pub led_prod: AuraDevice,
pub led_node: LEDNode, pub led_node: LEDNode,
pub kd_brightness: KeyboardLed, pub kd_brightness: KeyboardLed,
pub supported_modes: LaptopLedData, pub supported_modes: LaptopLedData,
@@ -68,34 +68,43 @@ pub struct CtrlKbdLed {
} }
impl CtrlKbdLed { impl CtrlKbdLed {
pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> { pub fn new(supported_modes: LaptopLedData) -> Result<Self, RogError> {
let mut led_prod = None; let mut led_prod = AuraDevice::Unknown;
let mut led_node = None; let mut usb_node = None;
for prod in &ASUS_KEYBOARD_DEVICES { for prod in ASUS_KEYBOARD_DEVICES {
match HidRaw::new(prod) { match HidRaw::new(prod.into()) {
Ok(node) => { Ok(node) => {
led_prod = Some((*prod).to_owned()); led_prod = prod;
led_node = Some(node); usb_node = Some(node);
info!("Looked for keyboard controller 0x{prod}: Found"); info!(
"Looked for keyboard controller 0x{}: Found",
<&str>::from(prod)
);
break; break;
} }
Err(err) => info!("Looked for keyboard controller 0x{prod}: {err}"), Err(err) => info!(
"Looked for keyboard controller 0x{}: {err}",
<&str>::from(prod)
),
} }
} }
let rgb_led = KeyboardLed::new()?; let rgb_led = KeyboardLed::new()?;
if led_node.is_none() && !rgb_led.has_kbd_rgb_mode() { if usb_node.is_none() && !rgb_led.has_kbd_rgb_mode() {
let dmi = sysfs_class::DmiId::default(); let dmi = sysfs_class::DmiId::default();
if let Ok(prod_family) = dmi.product_family() { if let Ok(prod_family) = dmi.product_family() {
if prod_family.contains("TUF") { if prod_family.contains("TUF") {
warn!("A kernel patch is in progress for TUF RGB support"); warn!(
"kbd_rgb_mode was not found in the /sys/. You require a minimum 6.1 \
kernel and a supported TUF laptop"
);
} }
} }
return Err(RogError::NoAuraKeyboard); return Err(RogError::NoAuraKeyboard);
} }
let led_node = if let Some(rog) = led_node { let led_node = if let Some(rog) = usb_node {
info!("Found ROG USB keyboard"); info!("Found ROG USB keyboard");
LEDNode::Rog(rog) LEDNode::Rog(rog)
} else if rgb_led.has_kbd_rgb_mode() { } else if rgb_led.has_kbd_rgb_mode() {
@@ -105,9 +114,10 @@ impl CtrlKbdLed {
LEDNode::None LEDNode::None
}; };
let config = AuraConfig::create_default(led_prod, &supported_modes).load();
let ctrl = CtrlKbdLed { let ctrl = CtrlKbdLed {
led_prod, led_prod,
led_node, led_node, // on TUF this is the same as rgb_led / kd_brightness
kd_brightness: rgb_led, // If was none then we already returned above kd_brightness: rgb_led, // If was none then we already returned above
supported_modes, supported_modes,
flip_effect_write: false, flip_effect_write: false,
@@ -356,6 +366,7 @@ impl CtrlKbdLed {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use rog_aura::aura_detection::LaptopLedData; use rog_aura::aura_detection::LaptopLedData;
use rog_aura::usb::AuraDevice;
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour}; use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
use rog_platform::keyboard_led::KeyboardLed; use rog_platform::keyboard_led::KeyboardLed;
@@ -367,7 +378,7 @@ mod tests {
// #[ignore = "Must be manually run due to detection stage"] // #[ignore = "Must be manually run due to detection stage"]
fn check_set_mode_errors() { fn check_set_mode_errors() {
// Checking to ensure set_mode errors when unsupported modes are tried // Checking to ensure set_mode errors when unsupported modes are tried
let config = AuraConfig::default(); let config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
let supported_modes = LaptopLedData { let supported_modes = LaptopLedData {
board_name: String::new(), board_name: String::new(),
layout_name: "ga401".to_owned(), layout_name: "ga401".to_owned(),
@@ -376,7 +387,7 @@ mod tests {
advanced_type: rog_aura::AdvancedAuraType::None, advanced_type: rog_aura::AdvancedAuraType::None,
}; };
let mut controller = CtrlKbdLed { let mut controller = CtrlKbdLed {
led_prod: None, led_prod: AuraDevice::X19b6,
led_node: LEDNode::None, led_node: LEDNode::None,
kd_brightness: KeyboardLed::default(), kd_brightness: KeyboardLed::default(),
supported_modes, supported_modes,
@@ -430,7 +441,7 @@ mod tests {
#[test] #[test]
fn create_multizone_if_no_config() { fn create_multizone_if_no_config() {
// Checking to ensure set_mode errors when unsupported modes are tried // Checking to ensure set_mode errors when unsupported modes are tried
let config = AuraConfig::default(); let config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
let supported_modes = LaptopLedData { let supported_modes = LaptopLedData {
board_name: String::new(), board_name: String::new(),
layout_name: "ga401".to_owned(), layout_name: "ga401".to_owned(),
@@ -439,7 +450,7 @@ mod tests {
advanced_type: rog_aura::AdvancedAuraType::None, advanced_type: rog_aura::AdvancedAuraType::None,
}; };
let mut controller = CtrlKbdLed { let mut controller = CtrlKbdLed {
led_prod: None, led_prod: AuraDevice::X19b6,
led_node: LEDNode::None, led_node: LEDNode::None,
kd_brightness: KeyboardLed::default(), kd_brightness: KeyboardLed::default(),
supported_modes, supported_modes,
@@ -468,7 +479,7 @@ mod tests {
#[test] #[test]
fn next_mode_create_multizone_if_no_config() { fn next_mode_create_multizone_if_no_config() {
// Checking to ensure set_mode errors when unsupported modes are tried // Checking to ensure set_mode errors when unsupported modes are tried
let config = AuraConfig::default(); let config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
let supported_modes = LaptopLedData { let supported_modes = LaptopLedData {
board_name: String::new(), board_name: String::new(),
layout_name: "ga401".to_owned(), layout_name: "ga401".to_owned(),
@@ -477,7 +488,7 @@ mod tests {
advanced_type: rog_aura::AdvancedAuraType::None, advanced_type: rog_aura::AdvancedAuraType::None,
}; };
let mut controller = CtrlKbdLed { let mut controller = CtrlKbdLed {
led_prod: None, led_prod: AuraDevice::X19b6,
led_node: LEDNode::None, led_node: LEDNode::None,
kd_brightness: KeyboardLed::default(), kd_brightness: KeyboardLed::default(),
supported_modes, supported_modes,

6
daemon/src/daemon.rs
View File

@@ -11,7 +11,6 @@ use daemon::config::Config;
use daemon::ctrl_anime::config::AnimeConfig; use daemon::ctrl_anime::config::AnimeConfig;
use daemon::ctrl_anime::trait_impls::CtrlAnimeZbus; use daemon::ctrl_anime::trait_impls::CtrlAnimeZbus;
use daemon::ctrl_anime::CtrlAnime; use daemon::ctrl_anime::CtrlAnime;
use daemon::ctrl_aura::config::AuraConfig;
use daemon::ctrl_aura::controller::CtrlKbdLed; use daemon::ctrl_aura::controller::CtrlKbdLed;
use daemon::ctrl_aura::trait_impls::CtrlKbdLedZbus; use daemon::ctrl_aura::trait_impls::CtrlKbdLedZbus;
use daemon::ctrl_platform::CtrlPlatform; use daemon::ctrl_platform::CtrlPlatform;
@@ -124,8 +123,9 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
} }
let laptop = LaptopLedData::get_data(); let laptop = LaptopLedData::get_data();
let aura_config = AuraConfig::new().load(); // CtrlKbdLed deviates from the config pattern above due to requiring a keyboard
match CtrlKbdLed::new(laptop, aura_config) { // detection first
match CtrlKbdLed::new(laptop) {
Ok(ctrl) => { Ok(ctrl) => {
let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl))); let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl)));
let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?; let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?;

11
rog-aura/src/aura_detection.rs
View File

@@ -1,11 +1,20 @@
use log::{error, info, warn}; use log::{error, info, warn};
use serde_derive::{Deserialize, Serialize}; use serde_derive::{Deserialize, Serialize};
use crate::usb::AuraDevice;
use crate::{AdvancedAuraType, AuraModeNum, AuraZone}; use crate::{AdvancedAuraType, AuraModeNum, AuraZone};
pub const ASUS_LED_MODE_CONF: &str = "/usr/share/asusd/aura_support.ron"; pub const ASUS_LED_MODE_CONF: &str = "/usr/share/asusd/aura_support.ron";
pub const ASUS_LED_MODE_USER_CONF: &str = "/etc/asusd/asusd_user_ledmodes.ron"; pub const ASUS_LED_MODE_USER_CONF: &str = "/etc/asusd/asusd_user_ledmodes.ron";
pub const ASUS_KEYBOARD_DEVICES: [&str; 6] = ["1866", "18c6", "1869", "1854", "19b6", "1a30"]; pub const ASUS_KEYBOARD_DEVICES: [AuraDevice; 7] = [
AuraDevice::Tuf,
AuraDevice::X1854,
AuraDevice::X1869,
AuraDevice::X1866,
AuraDevice::X18c6,
AuraDevice::X19b6,
AuraDevice::X1a30,
];
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)] #[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct LedSupportFile(Vec<LaptopLedData>); pub struct LedSupportFile(Vec<LaptopLedData>);

235
rog-aura/src/usb.rs
View File

@@ -23,7 +23,7 @@ pub const fn aura_brightness_bytes(brightness: u8) -> [u8; 17] {
} }
#[cfg_attr(feature = "dbus", derive(Type))] #[cfg_attr(feature = "dbus", derive(Type))]
#[derive(Clone, PartialEq, Eq, PartialOrd, Serialize, Deserialize, Default)] #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Serialize, Deserialize, Default)]
pub enum AuraDevice { pub enum AuraDevice {
Tuf, Tuf,
X1854, X1854,
@@ -31,11 +31,26 @@ pub enum AuraDevice {
X1866, X1866,
X18c6, X18c6,
#[default] #[default]
X19B6, X19b6,
X1a30, X1a30,
Unknown, Unknown,
} }
impl From<AuraDevice> for &str {
fn from(a: AuraDevice) -> Self {
match a {
AuraDevice::Tuf => "tuf",
AuraDevice::X1854 => "1854",
AuraDevice::X1869 => "1869",
AuraDevice::X1866 => "1866",
AuraDevice::X18c6 => "18c6",
AuraDevice::X19b6 => "19b6",
AuraDevice::X1a30 => "1a30",
AuraDevice::Unknown => "unknown",
}
}
}
impl From<&str> for AuraDevice { impl From<&str> for AuraDevice {
fn from(s: &str) -> Self { fn from(s: &str) -> Self {
match s.to_lowercase().as_str() { match s.to_lowercase().as_str() {
@@ -44,7 +59,7 @@ impl From<&str> for AuraDevice {
"18c6" | "0x18c6" => AuraDevice::X18c6, "18c6" | "0x18c6" => AuraDevice::X18c6,
"1869" | "0x1869" => AuraDevice::X1869, "1869" | "0x1869" => AuraDevice::X1869,
"1854" | "0x1854" => AuraDevice::X1854, "1854" | "0x1854" => AuraDevice::X1854,
"19b6" | "0x19b6" => AuraDevice::X19B6, "19b6" | "0x19b6" => AuraDevice::X19b6,
"1a30" | "0x1a30" => AuraDevice::X1a30, "1a30" | "0x1a30" => AuraDevice::X1a30,
_ => AuraDevice::Unknown, _ => AuraDevice::Unknown,
} }
@@ -59,7 +74,7 @@ impl Debug for AuraDevice {
Self::X1869 => write!(f, "0x1869"), Self::X1869 => write!(f, "0x1869"),
Self::X1866 => write!(f, "0x1866"), Self::X1866 => write!(f, "0x1866"),
Self::X18c6 => write!(f, "0x18c6"), Self::X18c6 => write!(f, "0x18c6"),
Self::X19B6 => write!(f, "0x19B6"), Self::X19b6 => write!(f, "0x19B6"),
Self::X1a30 => write!(f, "0x1A30"), Self::X1a30 => write!(f, "0x1A30"),
Self::Unknown => write!(f, "Unknown"), Self::Unknown => write!(f, "Unknown"),
} }
@@ -71,8 +86,8 @@ impl Debug for AuraDevice {
#[derive(Clone, Default, Debug, Serialize, Deserialize)] #[derive(Clone, Default, Debug, Serialize, Deserialize)]
pub struct AuraPowerDev { pub struct AuraPowerDev {
pub tuf: Vec<AuraDevTuf>, pub tuf: Vec<AuraDevTuf>,
pub x1866: Vec<AuraDev1866>, pub x1866: Vec<AuraDevRog1>,
pub x19b6: Vec<AuraDev19b6>, pub x19b6: Vec<AuraDevRog2>,
} }
#[cfg_attr(feature = "dbus", derive(Type))] #[cfg_attr(feature = "dbus", derive(Type))]
@@ -91,7 +106,7 @@ impl AuraDevTuf {
} }
} }
/// # Bits for older 0x1866 keyboard model /// # Bits for older 0x1866, 0x1869, 0x1854 keyboard models
/// ///
/// Keybord and Lightbar require Awake, Boot and Sleep apply to both /// Keybord and Lightbar require Awake, Boot and Sleep apply to both
/// Keybord and Lightbar regardless of if either are enabled (or Awake is /// Keybord and Lightbar regardless of if either are enabled (or Awake is
@@ -108,7 +123,7 @@ impl AuraDevTuf {
#[cfg_attr(feature = "dbus", derive(Type))] #[cfg_attr(feature = "dbus", derive(Type))]
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)] #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
#[repr(u32)] #[repr(u32)]
pub enum AuraDev1866 { pub enum AuraDevRog1 {
Awake = 0x000002, Awake = 0x000002,
Keyboard = 0x080000, Keyboard = 0x080000,
Lightbar = 0x040500, Lightbar = 0x040500,
@@ -116,13 +131,13 @@ pub enum AuraDev1866 {
Sleep = 0x300804, Sleep = 0x300804,
} }
impl From<AuraDev1866> for u32 { impl From<AuraDevRog1> for u32 {
fn from(a: AuraDev1866) -> Self { fn from(a: AuraDevRog1) -> Self {
a as u32 a as u32
} }
} }
impl AuraDev1866 { impl AuraDevRog1 {
pub fn to_bytes(control: &[Self]) -> [u8; 3] { pub fn to_bytes(control: &[Self]) -> [u8; 3] {
let mut a: u32 = 0; let mut a: u32 = 0;
for n in control { for n in control {
@@ -140,23 +155,23 @@ impl AuraDev1866 {
} }
} }
impl BitOr<AuraDev1866> for AuraDev1866 { impl BitOr<AuraDevRog1> for AuraDevRog1 {
type Output = u32; type Output = u32;
fn bitor(self, rhs: AuraDev1866) -> Self::Output { fn bitor(self, rhs: AuraDevRog1) -> Self::Output {
self as u32 | rhs as u32 self as u32 | rhs as u32
} }
} }
impl BitAnd<AuraDev1866> for AuraDev1866 { impl BitAnd<AuraDevRog1> for AuraDevRog1 {
type Output = u32; type Output = u32;
fn bitand(self, rhs: AuraDev1866) -> Self::Output { fn bitand(self, rhs: AuraDevRog1) -> Self::Output {
self as u32 & rhs as u32 self as u32 & rhs as u32
} }
} }
/// # Bits for 0x19b6 keyboard model /// # Bits for newer 0x18c6, 0x19B6, 0x1a30, keyboard models
/// ///
/// byte 4 in the USB packet is for keyboard + logo power states /// byte 4 in the USB packet is for keyboard + logo power states
/// default is on, `ff` /// default is on, `ff`
@@ -185,7 +200,7 @@ impl BitAnd<AuraDev1866> for AuraDev1866 {
#[cfg_attr(feature = "dbus", derive(Type))] #[cfg_attr(feature = "dbus", derive(Type))]
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)] #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
#[repr(u32)] #[repr(u32)]
pub enum AuraDev19b6 { pub enum AuraDevRog2 {
BootLogo = 1, BootLogo = 1,
BootKeyb = 1 << 1, BootKeyb = 1 << 1,
AwakeLogo = 1 << 2, AwakeLogo = 1 << 2,
@@ -204,13 +219,13 @@ pub enum AuraDev19b6 {
ShutdownLid = 1 << (15 + 4), ShutdownLid = 1 << (15 + 4),
} }
impl From<AuraDev19b6> for u32 { impl From<AuraDevRog2> for u32 {
fn from(a: AuraDev19b6) -> Self { fn from(a: AuraDevRog2) -> Self {
a as u32 a as u32
} }
} }
impl AuraDev19b6 { impl AuraDevRog2 {
pub fn to_bytes(control: &[Self]) -> [u8; 3] { pub fn to_bytes(control: &[Self]) -> [u8; 3] {
let mut a: u32 = 0; let mut a: u32 = 0;
for n in control { for n in control {
@@ -228,58 +243,58 @@ impl AuraDev19b6 {
} }
} }
impl BitOr<AuraDev19b6> for AuraDev19b6 { impl BitOr<AuraDevRog2> for AuraDevRog2 {
type Output = u16; type Output = u16;
fn bitor(self, rhs: AuraDev19b6) -> Self::Output { fn bitor(self, rhs: AuraDevRog2) -> Self::Output {
self as u16 | rhs as u16 self as u16 | rhs as u16
} }
} }
impl BitAnd<AuraDev19b6> for AuraDev19b6 { impl BitAnd<AuraDevRog2> for AuraDevRog2 {
type Output = u16; type Output = u16;
fn bitand(self, rhs: AuraDev19b6) -> Self::Output { fn bitand(self, rhs: AuraDevRog2) -> Self::Output {
self as u16 & rhs as u16 self as u16 & rhs as u16
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::AuraDev1866; use super::AuraDevRog1;
use crate::usb::AuraDev19b6; use crate::usb::AuraDevRog2;
#[test] #[test]
fn check_0x1866_control_bytes() { fn check_0x1866_control_bytes() {
let bytes = [AuraDev1866::Keyboard, AuraDev1866::Awake]; let bytes = [AuraDevRog1::Keyboard, AuraDevRog1::Awake];
let bytes = AuraDev1866::to_bytes(&bytes); let bytes = AuraDevRog1::to_bytes(&bytes);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes, [0x08, 0x00, 0x02]); assert_eq!(bytes, [0x08, 0x00, 0x02]);
let bytes = [AuraDev1866::Lightbar, AuraDev1866::Awake]; let bytes = [AuraDevRog1::Lightbar, AuraDevRog1::Awake];
let bytes = AuraDev1866::to_bytes(&bytes); let bytes = AuraDevRog1::to_bytes(&bytes);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes, [0x04, 0x05, 0x02]); assert_eq!(bytes, [0x04, 0x05, 0x02]);
let bytes = [AuraDev1866::Sleep]; let bytes = [AuraDevRog1::Sleep];
let bytes = AuraDev1866::to_bytes(&bytes); let bytes = AuraDevRog1::to_bytes(&bytes);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes, [0x30, 0x08, 0x04]); assert_eq!(bytes, [0x30, 0x08, 0x04]);
let bytes = [AuraDev1866::Boot]; let bytes = [AuraDevRog1::Boot];
let bytes = AuraDev1866::to_bytes(&bytes); let bytes = AuraDevRog1::to_bytes(&bytes);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes, [0xc3, 0x12, 0x09]); assert_eq!(bytes, [0xc3, 0x12, 0x09]);
let bytes = [ let bytes = [
AuraDev1866::Keyboard, AuraDevRog1::Keyboard,
AuraDev1866::Lightbar, AuraDevRog1::Lightbar,
AuraDev1866::Awake, AuraDevRog1::Awake,
AuraDev1866::Sleep, AuraDevRog1::Sleep,
AuraDev1866::Boot, AuraDevRog1::Boot,
]; ];
let bytes = AuraDev1866::to_bytes(&bytes); let bytes = AuraDevRog1::to_bytes(&bytes);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes, [0xff, 0x1f, 0x000f]); assert_eq!(bytes, [0xff, 0x1f, 0x000f]);
} }
@@ -288,143 +303,143 @@ mod tests {
fn check_0x19b6_control_bytes() { fn check_0x19b6_control_bytes() {
// All on // All on
let byte1 = [ let byte1 = [
AuraDev19b6::BootLogo, AuraDevRog2::BootLogo,
AuraDev19b6::BootKeyb, AuraDevRog2::BootKeyb,
AuraDev19b6::SleepLogo, AuraDevRog2::SleepLogo,
AuraDev19b6::SleepKeyb, AuraDevRog2::SleepKeyb,
AuraDev19b6::AwakeLogo, AuraDevRog2::AwakeLogo,
AuraDev19b6::AwakeKeyb, AuraDevRog2::AwakeKeyb,
AuraDev19b6::ShutdownLogo, AuraDevRog2::ShutdownLogo,
AuraDev19b6::ShutdownKeyb, AuraDevRog2::ShutdownKeyb,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte1); let bytes = AuraDevRog2::to_bytes(&byte1);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[0], 0xff); assert_eq!(bytes[0], 0xff);
// //
let byte1 = [ let byte1 = [
// AuraControl::BootLogo, // AuraControl::BootLogo,
AuraDev19b6::BootKeyb, AuraDevRog2::BootKeyb,
AuraDev19b6::SleepLogo, AuraDevRog2::SleepLogo,
AuraDev19b6::SleepKeyb, AuraDevRog2::SleepKeyb,
AuraDev19b6::AwakeLogo, AuraDevRog2::AwakeLogo,
AuraDev19b6::AwakeKeyb, AuraDevRog2::AwakeKeyb,
AuraDev19b6::ShutdownLogo, AuraDevRog2::ShutdownLogo,
AuraDev19b6::ShutdownKeyb, AuraDevRog2::ShutdownKeyb,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte1); let bytes = AuraDevRog2::to_bytes(&byte1);
println!("{:08b}", bytes[0]); println!("{:08b}", bytes[0]);
assert_eq!(bytes[0], 0xfe); assert_eq!(bytes[0], 0xfe);
let byte1 = [ let byte1 = [
AuraDev19b6::BootLogo, AuraDevRog2::BootLogo,
// AuraControl::BootKeyb, // AuraControl::BootKeyb,
AuraDev19b6::SleepLogo, AuraDevRog2::SleepLogo,
AuraDev19b6::SleepKeyb, AuraDevRog2::SleepKeyb,
AuraDev19b6::AwakeLogo, AuraDevRog2::AwakeLogo,
AuraDev19b6::AwakeKeyb, AuraDevRog2::AwakeKeyb,
AuraDev19b6::ShutdownLogo, AuraDevRog2::ShutdownLogo,
AuraDev19b6::ShutdownKeyb, AuraDevRog2::ShutdownKeyb,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte1); let bytes = AuraDevRog2::to_bytes(&byte1);
println!("{:08b}", bytes[0]); println!("{:08b}", bytes[0]);
assert_eq!(bytes[0], 0xfd); assert_eq!(bytes[0], 0xfd);
let byte1 = [ let byte1 = [
AuraDev19b6::BootLogo, AuraDevRog2::BootLogo,
AuraDev19b6::BootKeyb, AuraDevRog2::BootKeyb,
// AuraControl::SleepLogo, // AuraControl::SleepLogo,
AuraDev19b6::SleepKeyb, AuraDevRog2::SleepKeyb,
AuraDev19b6::AwakeLogo, AuraDevRog2::AwakeLogo,
AuraDev19b6::AwakeKeyb, AuraDevRog2::AwakeKeyb,
AuraDev19b6::ShutdownLogo, AuraDevRog2::ShutdownLogo,
AuraDev19b6::ShutdownKeyb, AuraDevRog2::ShutdownKeyb,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte1); let bytes = AuraDevRog2::to_bytes(&byte1);
println!("{:08b}", bytes[0]); println!("{:08b}", bytes[0]);
assert_eq!(bytes[0], 0xef); assert_eq!(bytes[0], 0xef);
let byte1 = [ let byte1 = [
AuraDev19b6::BootLogo, AuraDevRog2::BootLogo,
AuraDev19b6::BootKeyb, AuraDevRog2::BootKeyb,
AuraDev19b6::SleepLogo, AuraDevRog2::SleepLogo,
// AuraControl::SleepKeyb, // AuraControl::SleepKeyb,
AuraDev19b6::AwakeLogo, AuraDevRog2::AwakeLogo,
AuraDev19b6::AwakeKeyb, AuraDevRog2::AwakeKeyb,
AuraDev19b6::ShutdownLogo, AuraDevRog2::ShutdownLogo,
AuraDev19b6::ShutdownKeyb, AuraDevRog2::ShutdownKeyb,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte1); let bytes = AuraDevRog2::to_bytes(&byte1);
println!("{:08b}", bytes[0]); println!("{:08b}", bytes[0]);
assert_eq!(bytes[0], 0xdf); assert_eq!(bytes[0], 0xdf);
let byte2 = [ let byte2 = [
AuraDev19b6::BootBar, AuraDevRog2::BootBar,
AuraDev19b6::AwakeBar, AuraDevRog2::AwakeBar,
AuraDev19b6::SleepBar, AuraDevRog2::SleepBar,
AuraDev19b6::ShutdownBar, AuraDevRog2::ShutdownBar,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte2); let bytes = AuraDevRog2::to_bytes(&byte2);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[1], 0x1e); assert_eq!(bytes[1], 0x1e);
let byte2 = [ let byte2 = [
AuraDev19b6::BootBar, AuraDevRog2::BootBar,
AuraDev19b6::AwakeBar, AuraDevRog2::AwakeBar,
// AuraControl::SleepBar, // AuraControl::SleepBar,
AuraDev19b6::ShutdownBar, AuraDevRog2::ShutdownBar,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte2); let bytes = AuraDevRog2::to_bytes(&byte2);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[1], 0x16); assert_eq!(bytes[1], 0x16);
let byte3 = [ let byte3 = [
AuraDev19b6::AwakeLid, AuraDevRog2::AwakeLid,
AuraDev19b6::BootLid, AuraDevRog2::BootLid,
AuraDev19b6::SleepLid, AuraDevRog2::SleepLid,
AuraDev19b6::ShutdownLid, AuraDevRog2::ShutdownLid,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte3); let bytes = AuraDevRog2::to_bytes(&byte3);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[2], 0x0f); assert_eq!(bytes[2], 0x0f);
let byte3 = [ let byte3 = [
// AuraDev19b6::AwakeLid, // AuraDev19b6::AwakeLid,
AuraDev19b6::BootLid, AuraDevRog2::BootLid,
AuraDev19b6::SleepLid, AuraDevRog2::SleepLid,
AuraDev19b6::ShutdownLid, AuraDevRog2::ShutdownLid,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte3); let bytes = AuraDevRog2::to_bytes(&byte3);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[2], 0x0d); assert_eq!(bytes[2], 0x0d);
let byte3 = [ let byte3 = [
AuraDev19b6::AwakeLid, AuraDevRog2::AwakeLid,
AuraDev19b6::BootLid, AuraDevRog2::BootLid,
// AuraControl::SleepLid, // AuraControl::SleepLid,
AuraDev19b6::ShutdownLid, AuraDevRog2::ShutdownLid,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte3); let bytes = AuraDevRog2::to_bytes(&byte3);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[2], 0x0b); assert_eq!(bytes[2], 0x0b);
let byte3 = [ let byte3 = [
AuraDev19b6::AwakeLid, AuraDevRog2::AwakeLid,
AuraDev19b6::BootLid, AuraDevRog2::BootLid,
AuraDev19b6::SleepLid, AuraDevRog2::SleepLid,
// AuraDev19b6::ShutdownLid, // AuraDev19b6::ShutdownLid,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte3); let bytes = AuraDevRog2::to_bytes(&byte3);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[2], 0x07); assert_eq!(bytes[2], 0x07);
let byte3 = [ let byte3 = [
AuraDev19b6::AwakeLid, AuraDevRog2::AwakeLid,
// AuraDev19b6::BootLid, // AuraDev19b6::BootLid,
AuraDev19b6::SleepLid, AuraDevRog2::SleepLid,
// AuraDev19b6::ShutdownLid, // AuraDev19b6::ShutdownLid,
]; ];
let bytes = AuraDev19b6::to_bytes(&byte3); let bytes = AuraDevRog2::to_bytes(&byte3);
println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]);
assert_eq!(bytes[2], 0x06); assert_eq!(bytes[2], 0x06);
} }

68
rog-control-center/src/widgets/aura_power.rs
View File

@@ -1,5 +1,5 @@
use egui::{RichText, Ui}; use egui::{RichText, Ui};
use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev}; use rog_aura::usb::{AuraDevRog1, AuraDevRog2, AuraDevTuf, AuraDevice, AuraPowerDev};
use rog_aura::AuraZone; use rog_aura::AuraZone;
use rog_platform::supported::SupportedFunctions; use rog_platform::supported::SupportedFunctions;
@@ -9,10 +9,12 @@ pub fn aura_power_group(supported: &SupportedFunctions, states: &mut SystemState
ui.heading("LED settings"); ui.heading("LED settings");
match supported.keyboard_led.dev_id { match supported.keyboard_led.dev_id {
AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866 | AuraDevice::X18c6 => { AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866 => {
aura_power1(supported, states, ui); aura_power1(supported, states, ui);
} }
AuraDevice::X19B6 => aura_power2(supported, states, ui), AuraDevice::X19b6 | AuraDevice::X18c6 | AuraDevice::X1a30 => {
aura_power2(supported, states, ui)
}
AuraDevice::Tuf => aura_power1(supported, states, ui), AuraDevice::Tuf => aura_power1(supported, states, ui),
AuraDevice::Unknown => {} AuraDevice::Unknown => {}
} }
@@ -20,10 +22,10 @@ pub fn aura_power_group(supported: &SupportedFunctions, states: &mut SystemState
fn aura_power1(supported: &SupportedFunctions, states: &mut SystemState, ui: &mut Ui) { fn aura_power1(supported: &SupportedFunctions, states: &mut SystemState, ui: &mut Ui) {
let enabled_states = &mut states.aura.enabled; let enabled_states = &mut states.aura.enabled;
let mut boot = enabled_states.x1866.contains(&AuraDev1866::Boot); let mut boot = enabled_states.x1866.contains(&AuraDevRog1::Boot);
let mut sleep = enabled_states.x1866.contains(&AuraDev1866::Sleep); let mut sleep = enabled_states.x1866.contains(&AuraDevRog1::Sleep);
let mut keyboard = enabled_states.x1866.contains(&AuraDev1866::Keyboard); let mut keyboard = enabled_states.x1866.contains(&AuraDevRog1::Keyboard);
let mut lightbar = enabled_states.x1866.contains(&AuraDev1866::Lightbar); let mut lightbar = enabled_states.x1866.contains(&AuraDevRog1::Lightbar);
if supported.keyboard_led.dev_id == AuraDevice::Tuf { if supported.keyboard_led.dev_id == AuraDevice::Tuf {
boot = enabled_states.tuf.contains(&AuraDevTuf::Boot); boot = enabled_states.tuf.contains(&AuraDevTuf::Boot);
sleep = enabled_states.tuf.contains(&AuraDevTuf::Sleep); sleep = enabled_states.tuf.contains(&AuraDevTuf::Sleep);
@@ -148,7 +150,7 @@ fn aura_power1(supported: &SupportedFunctions, states: &mut SystemState, ui: &mu
let mut enabled = Vec::new(); let mut enabled = Vec::new();
let mut disabled = Vec::new(); let mut disabled = Vec::new();
let mut modify_x1866 = |b: bool, a: AuraDev1866| { let mut modify_x1866 = |b: bool, a: AuraDevRog1| {
if b { if b {
enabled.push(a); enabled.push(a);
if !enabled_states.x1866.contains(&a) { if !enabled_states.x1866.contains(&a) {
@@ -169,14 +171,14 @@ fn aura_power1(supported: &SupportedFunctions, states: &mut SystemState, ui: &mu
} }
} }
}; };
modify_x1866(boot, AuraDev1866::Boot); modify_x1866(boot, AuraDevRog1::Boot);
modify_x1866(sleep, AuraDev1866::Sleep); modify_x1866(sleep, AuraDevRog1::Sleep);
modify_x1866(keyboard, AuraDev1866::Keyboard); modify_x1866(keyboard, AuraDevRog1::Keyboard);
if !supported.keyboard_led.basic_zones.is_empty() { if !supported.keyboard_led.basic_zones.is_empty() {
modify_x1866(lightbar, AuraDev1866::Lightbar); modify_x1866(lightbar, AuraDevRog1::Lightbar);
} }
let mut send = |enable: bool, data: Vec<AuraDev1866>| { let mut send = |enable: bool, data: Vec<AuraDevRog1>| {
let options = AuraPowerDev { let options = AuraPowerDev {
tuf: vec![], tuf: vec![],
x1866: data, x1866: data,
@@ -211,17 +213,17 @@ fn aura_power2(supported: &SupportedFunctions, states: &mut SystemState, ui: &mu
.basic_zones .basic_zones
.contains(&AuraZone::BarRight); .contains(&AuraZone::BarRight);
let boot_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeBar); let boot_bar = &mut enabled_states.x19b6.contains(&AuraDevRog2::AwakeBar);
let boot_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootLogo); let boot_logo = &mut enabled_states.x19b6.contains(&AuraDevRog2::BootLogo);
let boot_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootKeyb); let boot_keyb = &mut enabled_states.x19b6.contains(&AuraDevRog2::BootKeyb);
let awake_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootBar); let awake_bar = &mut enabled_states.x19b6.contains(&AuraDevRog2::BootBar);
let awake_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeLogo); let awake_logo = &mut enabled_states.x19b6.contains(&AuraDevRog2::AwakeLogo);
let awake_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeKeyb); let awake_keyb = &mut enabled_states.x19b6.contains(&AuraDevRog2::AwakeKeyb);
let sleep_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepBar); let sleep_bar = &mut enabled_states.x19b6.contains(&AuraDevRog2::SleepBar);
let sleep_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepLogo); let sleep_logo = &mut enabled_states.x19b6.contains(&AuraDevRog2::SleepLogo);
let sleep_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepKeyb); let sleep_keyb = &mut enabled_states.x19b6.contains(&AuraDevRog2::SleepKeyb);
let mut changed = false; let mut changed = false;
@@ -265,7 +267,7 @@ fn aura_power2(supported: &SupportedFunctions, states: &mut SystemState, ui: &mu
let mut enabled = Vec::new(); let mut enabled = Vec::new();
let mut disabled = Vec::new(); let mut disabled = Vec::new();
let mut modify = |b: bool, a: AuraDev19b6| { let mut modify = |b: bool, a: AuraDevRog2| {
if b { if b {
enabled.push(a); enabled.push(a);
if !enabled_states.x19b6.contains(&a) { if !enabled_states.x19b6.contains(&a) {
@@ -286,25 +288,25 @@ fn aura_power2(supported: &SupportedFunctions, states: &mut SystemState, ui: &mu
} }
} }
}; };
modify(*boot_keyb, AuraDev19b6::BootKeyb); modify(*boot_keyb, AuraDevRog2::BootKeyb);
modify(*sleep_keyb, AuraDev19b6::SleepKeyb); modify(*sleep_keyb, AuraDevRog2::SleepKeyb);
modify(*awake_keyb, AuraDev19b6::AwakeKeyb); modify(*awake_keyb, AuraDevRog2::AwakeKeyb);
if supported.keyboard_led.basic_zones.contains(&AuraZone::Logo) { if supported.keyboard_led.basic_zones.contains(&AuraZone::Logo) {
modify(*boot_logo, AuraDev19b6::BootLogo); modify(*boot_logo, AuraDevRog2::BootLogo);
modify(*sleep_logo, AuraDev19b6::SleepLogo); modify(*sleep_logo, AuraDevRog2::SleepLogo);
modify(*awake_logo, AuraDev19b6::AwakeLogo); modify(*awake_logo, AuraDevRog2::AwakeLogo);
} }
if supported if supported
.keyboard_led .keyboard_led
.basic_zones .basic_zones
.contains(&AuraZone::BarLeft) .contains(&AuraZone::BarLeft)
{ {
modify(*boot_bar, AuraDev19b6::AwakeBar); modify(*boot_bar, AuraDevRog2::AwakeBar);
modify(*sleep_bar, AuraDev19b6::SleepBar); modify(*sleep_bar, AuraDevRog2::SleepBar);
modify(*awake_bar, AuraDev19b6::BootBar); modify(*awake_bar, AuraDevRog2::BootBar);
} }
let mut send = |enable: bool, data: Vec<AuraDev19b6>| { let mut send = |enable: bool, data: Vec<AuraDevRog2>| {
let options = AuraPowerDev { let options = AuraPowerDev {
tuf: vec![], tuf: vec![],
x1866: vec![], x1866: vec![],