diff --git a/CHANGELOG.md b/CHANGELOG.md index e5ff78de..ec94fe02 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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 GU604V LED modes - Support for GX650P LED modes +- Add device code for the Z13 ACRNM keyboard +- Add device code for the plain Z13 keyboard ### Changed - Adjustments to Anime system events thread - 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] ### Added diff --git a/asusctl/src/main.rs b/asusctl/src/main.rs index ea20c754..20d3fbc1 100644 --- a/asusctl/src/main.rs +++ b/asusctl/src/main.rs @@ -10,7 +10,7 @@ use gumdrop::{Opt, Options}; use profiles_cli::{FanCurveCommand, ProfileCommand}; use rog_anime::usb::get_anime_type; 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_dbus::RogDbusClientBlocking; use rog_platform::platform::GpuMode; @@ -157,7 +157,7 @@ fn do_parsed( { 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") { return false; @@ -472,10 +472,10 @@ fn handle_led_power_1_do_1866( dbus: &RogDbusClientBlocking<'_>, power: &LedPowerCommand1, ) -> Result<(), Box> { - let mut enabled: Vec = Vec::new(); - let mut disabled: Vec = Vec::new(); + let mut enabled: Vec = Vec::new(); + let mut disabled: Vec = Vec::new(); - let mut check = |e: Option, a: AuraDev1866| { + let mut check = |e: Option, a: AuraDevRog1| { if let Some(arg) = e { if arg { enabled.push(a); @@ -485,11 +485,11 @@ fn handle_led_power_1_do_1866( } }; - check(power.awake, AuraDev1866::Awake); - check(power.boot, AuraDev1866::Boot); - check(power.sleep, AuraDev1866::Sleep); - check(power.keyboard, AuraDev1866::Keyboard); - check(power.lightbar, AuraDev1866::Lightbar); + check(power.awake, AuraDevRog1::Awake); + check(power.boot, AuraDevRog1::Boot); + check(power.sleep, AuraDevRog1::Sleep); + check(power.keyboard, AuraDevRog1::Keyboard); + check(power.lightbar, AuraDevRog1::Lightbar); let data = AuraPowerDev { x1866: enabled, @@ -576,13 +576,13 @@ fn handle_led_power2( 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"); } - let mut enabled: Vec = Vec::new(); - let mut disabled: Vec = Vec::new(); - let mut check = |e: Option, a: AuraDev19b6| { + let mut enabled: Vec = Vec::new(); + let mut disabled: Vec = Vec::new(); + let mut check = |e: Option, a: AuraDevRog2| { if let Some(arg) = e { if arg { enabled.push(a); @@ -594,28 +594,28 @@ fn handle_led_power2( match pow { aura_cli::SetAuraEnabled::Boot(arg) => { - check(arg.keyboard, AuraDev19b6::BootKeyb); - check(arg.logo, AuraDev19b6::BootLogo); - check(arg.lightbar, AuraDev19b6::BootBar); - check(arg.lid, AuraDev19b6::AwakeLid); + check(arg.keyboard, AuraDevRog2::BootKeyb); + check(arg.logo, AuraDevRog2::BootLogo); + check(arg.lightbar, AuraDevRog2::BootBar); + check(arg.lid, AuraDevRog2::AwakeLid); } aura_cli::SetAuraEnabled::Sleep(arg) => { - check(arg.keyboard, AuraDev19b6::SleepKeyb); - check(arg.logo, AuraDev19b6::SleepLogo); - check(arg.lightbar, AuraDev19b6::SleepBar); - check(arg.lid, AuraDev19b6::SleepLid); + check(arg.keyboard, AuraDevRog2::SleepKeyb); + check(arg.logo, AuraDevRog2::SleepLogo); + check(arg.lightbar, AuraDevRog2::SleepBar); + check(arg.lid, AuraDevRog2::SleepLid); } aura_cli::SetAuraEnabled::Awake(arg) => { - check(arg.keyboard, AuraDev19b6::AwakeKeyb); - check(arg.logo, AuraDev19b6::AwakeLogo); - check(arg.lightbar, AuraDev19b6::AwakeBar); - check(arg.lid, AuraDev19b6::AwakeLid); + check(arg.keyboard, AuraDevRog2::AwakeKeyb); + check(arg.logo, AuraDevRog2::AwakeLogo); + check(arg.lightbar, AuraDevRog2::AwakeBar); + check(arg.lid, AuraDevRog2::AwakeLid); } aura_cli::SetAuraEnabled::Shutdown(arg) => { - check(arg.keyboard, AuraDev19b6::ShutdownKeyb); - check(arg.logo, AuraDev19b6::ShutdownLogo); - check(arg.lightbar, AuraDev19b6::ShutdownBar); - check(arg.lid, AuraDev19b6::ShutdownBar); + check(arg.keyboard, AuraDevRog2::ShutdownKeyb); + check(arg.logo, AuraDevRog2::ShutdownLogo); + check(arg.lightbar, AuraDevRog2::ShutdownBar); + check(arg.lid, AuraDevRog2::ShutdownBar); } } diff --git a/daemon/src/ctrl_aura/config.rs b/daemon/src/ctrl_aura/config.rs index a2996bda..fcbfeaa6 100644 --- a/daemon/src/ctrl_aura/config.rs +++ b/daemon/src/ctrl_aura/config.rs @@ -1,11 +1,9 @@ use std::collections::{BTreeMap, HashSet}; use config_traits::{StdConfig, StdConfigLoad}; -use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES}; -use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev}; +use rog_aura::aura_detection::LaptopLedData; +use rog_aura::usb::{AuraDevRog1, AuraDevRog2, AuraDevTuf, AuraDevice, AuraPowerDev}; 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}; const CONFIG_FILE: &str = "aura.ron"; @@ -16,8 +14,8 @@ const CONFIG_FILE: &str = "aura.ron"; #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub enum AuraPowerConfig { AuraDevTuf(HashSet), - AuraDev1866(HashSet), - AuraDev19b6(HashSet), + AuraDevRog1(HashSet), + AuraDevRog2(HashSet), } impl AuraPowerConfig { @@ -25,13 +23,13 @@ impl AuraPowerConfig { pub fn to_bytes(control: &Self) -> [u8; 3] { match control { AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0], - AuraPowerConfig::AuraDev1866(c) => { - let c: Vec = c.iter().copied().collect(); - AuraDev1866::to_bytes(&c) + AuraPowerConfig::AuraDevRog1(c) => { + let c: Vec = c.iter().copied().collect(); + AuraDevRog1::to_bytes(&c) } - AuraPowerConfig::AuraDev19b6(c) => { - let c: Vec = c.iter().copied().collect(); - AuraDev19b6::to_bytes(&c) + AuraPowerConfig::AuraDevRog2(c) => { + let c: Vec = c.iter().copied().collect(); + AuraDevRog2::to_bytes(&c) } } } @@ -47,13 +45,13 @@ impl AuraPowerConfig { ]); } - if let Self::AuraDev1866(c) = control { + if let Self::AuraDevRog1(c) = control { return Some([ true, - c.contains(&AuraDev1866::Boot), - c.contains(&AuraDev1866::Awake), - c.contains(&AuraDev1866::Sleep), - c.contains(&AuraDev1866::Keyboard), + c.contains(&AuraDevRog1::Boot), + c.contains(&AuraDevRog1::Awake), + c.contains(&AuraDevRog1::Sleep), + c.contains(&AuraDevRog1::Keyboard), ]); } @@ -70,8 +68,8 @@ impl AuraPowerConfig { } } - pub fn set_0x1866(&mut self, power: AuraDev1866, on: bool) { - if let Self::AuraDev1866(p) = self { + pub fn set_0x1866(&mut self, power: AuraDevRog1, on: bool) { + if let Self::AuraDevRog1(p) = self { if on { p.insert(power); } else { @@ -80,8 +78,8 @@ impl AuraPowerConfig { } } - pub fn set_0x19b6(&mut self, power: AuraDev19b6, on: bool) { - if let Self::AuraDev19b6(p) = self { + pub fn set_0x19b6(&mut self, power: AuraDevRog2, on: bool) { + if let Self::AuraDevRog2(p) = self { if on { p.insert(power); } else { @@ -99,12 +97,12 @@ impl From<&AuraPowerConfig> for AuraPowerDev { x1866: vec![], x19b6: vec![], }, - AuraPowerConfig::AuraDev1866(d) => AuraPowerDev { + AuraPowerConfig::AuraDevRog1(d) => AuraPowerDev { tuf: vec![], x1866: d.iter().copied().collect(), x19b6: vec![], }, - AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev { + AuraPowerConfig::AuraDevRog2(d) => AuraPowerDev { tuf: vec![], x1866: vec![], x19b6: d.iter().copied().collect(), @@ -124,70 +122,9 @@ pub struct AuraConfig { 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 { fn new() -> Self { - Self::create_default(&LaptopLedData::get_data()) + Self::create_default(AuraDevice::X19b6, &LaptopLedData::get_data()) } fn config_dir() -> std::path::PathBuf { @@ -202,9 +139,47 @@ impl StdConfig for AuraConfig { impl StdConfigLoad for 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 - 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 { config @@ -276,13 +251,15 @@ impl AuraConfig { #[cfg(test)] mod tests { + use rog_aura::aura_detection::LaptopLedData; + use rog_aura::usb::AuraDevice; use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour}; use super::AuraConfig; #[test] fn set_multizone_4key_config() { - let mut config = AuraConfig::default(); + let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default()); let effect = AuraEffect { colour1: Colour(0xff, 0x00, 0xff), @@ -328,7 +305,7 @@ mod tests { #[test] fn set_multizone_multimode_config() { - let mut config = AuraConfig::default(); + let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default()); let effect = AuraEffect { zone: AuraZone::Key1, diff --git a/daemon/src/ctrl_aura/controller.rs b/daemon/src/ctrl_aura/controller.rs index bf65016f..a5e40353 100644 --- a/daemon/src/ctrl_aura/controller.rs +++ b/daemon/src/ctrl_aura/controller.rs @@ -1,6 +1,6 @@ use std::collections::BTreeMap; -use config_traits::StdConfig; +use config_traits::{StdConfig, StdConfigLoad}; use log::{info, warn}; use rog_aura::advanced::{LedUsbPackets, UsbPackets}; use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES}; @@ -25,9 +25,9 @@ impl GetSupported for CtrlKbdLed { let advanced_type = laptop.advanced_type; let mut prod_id = AuraDevice::Unknown; - for prod in &ASUS_KEYBOARD_DEVICES { - if HidRaw::new(prod).is_ok() { - prod_id = AuraDevice::from(*prod); + for prod in ASUS_KEYBOARD_DEVICES { + if HidRaw::new(prod.into()).is_ok() { + prod_id = prod; break; } } @@ -58,7 +58,7 @@ pub enum LEDNode { pub struct CtrlKbdLed { // TODO: config stores the keyboard type as an AuraPower, use or update this - pub led_prod: Option, + pub led_prod: AuraDevice, pub led_node: LEDNode, pub kd_brightness: KeyboardLed, pub supported_modes: LaptopLedData, @@ -68,34 +68,43 @@ pub struct CtrlKbdLed { } impl CtrlKbdLed { - pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result { - let mut led_prod = None; - let mut led_node = None; - for prod in &ASUS_KEYBOARD_DEVICES { - match HidRaw::new(prod) { + pub fn new(supported_modes: LaptopLedData) -> Result { + let mut led_prod = AuraDevice::Unknown; + let mut usb_node = None; + for prod in ASUS_KEYBOARD_DEVICES { + match HidRaw::new(prod.into()) { Ok(node) => { - led_prod = Some((*prod).to_owned()); - led_node = Some(node); - info!("Looked for keyboard controller 0x{prod}: Found"); + led_prod = prod; + usb_node = Some(node); + info!( + "Looked for keyboard controller 0x{}: Found", + <&str>::from(prod) + ); 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()?; - 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(); if let Ok(prod_family) = dmi.product_family() { 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); } - let led_node = if let Some(rog) = led_node { + let led_node = if let Some(rog) = usb_node { info!("Found ROG USB keyboard"); LEDNode::Rog(rog) } else if rgb_led.has_kbd_rgb_mode() { @@ -105,9 +114,10 @@ impl CtrlKbdLed { LEDNode::None }; + let config = AuraConfig::create_default(led_prod, &supported_modes).load(); let ctrl = CtrlKbdLed { 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 supported_modes, flip_effect_write: false, @@ -356,6 +366,7 @@ impl CtrlKbdLed { #[cfg(test)] mod tests { use rog_aura::aura_detection::LaptopLedData; + use rog_aura::usb::AuraDevice; use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour}; use rog_platform::keyboard_led::KeyboardLed; @@ -367,7 +378,7 @@ mod tests { // #[ignore = "Must be manually run due to detection stage"] fn check_set_mode_errors() { // 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 { board_name: String::new(), layout_name: "ga401".to_owned(), @@ -376,7 +387,7 @@ mod tests { advanced_type: rog_aura::AdvancedAuraType::None, }; let mut controller = CtrlKbdLed { - led_prod: None, + led_prod: AuraDevice::X19b6, led_node: LEDNode::None, kd_brightness: KeyboardLed::default(), supported_modes, @@ -430,7 +441,7 @@ mod tests { #[test] fn create_multizone_if_no_config() { // 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 { board_name: String::new(), layout_name: "ga401".to_owned(), @@ -439,7 +450,7 @@ mod tests { advanced_type: rog_aura::AdvancedAuraType::None, }; let mut controller = CtrlKbdLed { - led_prod: None, + led_prod: AuraDevice::X19b6, led_node: LEDNode::None, kd_brightness: KeyboardLed::default(), supported_modes, @@ -468,7 +479,7 @@ mod tests { #[test] fn next_mode_create_multizone_if_no_config() { // 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 { board_name: String::new(), layout_name: "ga401".to_owned(), @@ -477,7 +488,7 @@ mod tests { advanced_type: rog_aura::AdvancedAuraType::None, }; let mut controller = CtrlKbdLed { - led_prod: None, + led_prod: AuraDevice::X19b6, led_node: LEDNode::None, kd_brightness: KeyboardLed::default(), supported_modes, diff --git a/daemon/src/daemon.rs b/daemon/src/daemon.rs index 75cb8e2b..d7888251 100644 --- a/daemon/src/daemon.rs +++ b/daemon/src/daemon.rs @@ -11,7 +11,6 @@ use daemon::config::Config; use daemon::ctrl_anime::config::AnimeConfig; use daemon::ctrl_anime::trait_impls::CtrlAnimeZbus; use daemon::ctrl_anime::CtrlAnime; -use daemon::ctrl_aura::config::AuraConfig; use daemon::ctrl_aura::controller::CtrlKbdLed; use daemon::ctrl_aura::trait_impls::CtrlKbdLedZbus; use daemon::ctrl_platform::CtrlPlatform; @@ -124,8 +123,9 @@ async fn start_daemon() -> Result<(), Box> { } let laptop = LaptopLedData::get_data(); - let aura_config = AuraConfig::new().load(); - match CtrlKbdLed::new(laptop, aura_config) { + // CtrlKbdLed deviates from the config pattern above due to requiring a keyboard + // detection first + match CtrlKbdLed::new(laptop) { Ok(ctrl) => { let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl))); let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?; diff --git a/rog-aura/src/aura_detection.rs b/rog-aura/src/aura_detection.rs index 54a8fdfb..564ef5b8 100644 --- a/rog-aura/src/aura_detection.rs +++ b/rog-aura/src/aura_detection.rs @@ -1,11 +1,20 @@ use log::{error, info, warn}; use serde_derive::{Deserialize, Serialize}; +use crate::usb::AuraDevice; use crate::{AdvancedAuraType, AuraModeNum, AuraZone}; 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_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)] pub struct LedSupportFile(Vec); diff --git a/rog-aura/src/usb.rs b/rog-aura/src/usb.rs index ee149843..06cf7780 100644 --- a/rog-aura/src/usb.rs +++ b/rog-aura/src/usb.rs @@ -23,7 +23,7 @@ pub const fn aura_brightness_bytes(brightness: u8) -> [u8; 17] { } #[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 { Tuf, X1854, @@ -31,11 +31,26 @@ pub enum AuraDevice { X1866, X18c6, #[default] - X19B6, + X19b6, X1a30, Unknown, } +impl From 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 { fn from(s: &str) -> Self { match s.to_lowercase().as_str() { @@ -44,7 +59,7 @@ impl From<&str> for AuraDevice { "18c6" | "0x18c6" => AuraDevice::X18c6, "1869" | "0x1869" => AuraDevice::X1869, "1854" | "0x1854" => AuraDevice::X1854, - "19b6" | "0x19b6" => AuraDevice::X19B6, + "19b6" | "0x19b6" => AuraDevice::X19b6, "1a30" | "0x1a30" => AuraDevice::X1a30, _ => AuraDevice::Unknown, } @@ -59,7 +74,7 @@ impl Debug for AuraDevice { Self::X1869 => write!(f, "0x1869"), Self::X1866 => write!(f, "0x1866"), Self::X18c6 => write!(f, "0x18c6"), - Self::X19B6 => write!(f, "0x19B6"), + Self::X19b6 => write!(f, "0x19B6"), Self::X1a30 => write!(f, "0x1A30"), Self::Unknown => write!(f, "Unknown"), } @@ -71,8 +86,8 @@ impl Debug for AuraDevice { #[derive(Clone, Default, Debug, Serialize, Deserialize)] pub struct AuraPowerDev { pub tuf: Vec, - pub x1866: Vec, - pub x19b6: Vec, + pub x1866: Vec, + pub x19b6: Vec, } #[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 regardless of if either are enabled (or Awake is @@ -108,7 +123,7 @@ impl AuraDevTuf { #[cfg_attr(feature = "dbus", derive(Type))] #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)] #[repr(u32)] -pub enum AuraDev1866 { +pub enum AuraDevRog1 { Awake = 0x000002, Keyboard = 0x080000, Lightbar = 0x040500, @@ -116,13 +131,13 @@ pub enum AuraDev1866 { Sleep = 0x300804, } -impl From for u32 { - fn from(a: AuraDev1866) -> Self { +impl From for u32 { + fn from(a: AuraDevRog1) -> Self { a as u32 } } -impl AuraDev1866 { +impl AuraDevRog1 { pub fn to_bytes(control: &[Self]) -> [u8; 3] { let mut a: u32 = 0; for n in control { @@ -140,23 +155,23 @@ impl AuraDev1866 { } } -impl BitOr for AuraDev1866 { +impl BitOr for AuraDevRog1 { type Output = u32; - fn bitor(self, rhs: AuraDev1866) -> Self::Output { + fn bitor(self, rhs: AuraDevRog1) -> Self::Output { self as u32 | rhs as u32 } } -impl BitAnd for AuraDev1866 { +impl BitAnd for AuraDevRog1 { type Output = u32; - fn bitand(self, rhs: AuraDev1866) -> Self::Output { + fn bitand(self, rhs: AuraDevRog1) -> Self::Output { 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 /// default is on, `ff` @@ -185,7 +200,7 @@ impl BitAnd for AuraDev1866 { #[cfg_attr(feature = "dbus", derive(Type))] #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)] #[repr(u32)] -pub enum AuraDev19b6 { +pub enum AuraDevRog2 { BootLogo = 1, BootKeyb = 1 << 1, AwakeLogo = 1 << 2, @@ -204,13 +219,13 @@ pub enum AuraDev19b6 { ShutdownLid = 1 << (15 + 4), } -impl From for u32 { - fn from(a: AuraDev19b6) -> Self { +impl From for u32 { + fn from(a: AuraDevRog2) -> Self { a as u32 } } -impl AuraDev19b6 { +impl AuraDevRog2 { pub fn to_bytes(control: &[Self]) -> [u8; 3] { let mut a: u32 = 0; for n in control { @@ -228,58 +243,58 @@ impl AuraDev19b6 { } } -impl BitOr for AuraDev19b6 { +impl BitOr for AuraDevRog2 { type Output = u16; - fn bitor(self, rhs: AuraDev19b6) -> Self::Output { + fn bitor(self, rhs: AuraDevRog2) -> Self::Output { self as u16 | rhs as u16 } } -impl BitAnd for AuraDev19b6 { +impl BitAnd for AuraDevRog2 { type Output = u16; - fn bitand(self, rhs: AuraDev19b6) -> Self::Output { + fn bitand(self, rhs: AuraDevRog2) -> Self::Output { self as u16 & rhs as u16 } } #[cfg(test)] mod tests { - use super::AuraDev1866; - use crate::usb::AuraDev19b6; + use super::AuraDevRog1; + use crate::usb::AuraDevRog2; #[test] fn check_0x1866_control_bytes() { - let bytes = [AuraDev1866::Keyboard, AuraDev1866::Awake]; - let bytes = AuraDev1866::to_bytes(&bytes); + let bytes = [AuraDevRog1::Keyboard, AuraDevRog1::Awake]; + let bytes = AuraDevRog1::to_bytes(&bytes); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes, [0x08, 0x00, 0x02]); - let bytes = [AuraDev1866::Lightbar, AuraDev1866::Awake]; - let bytes = AuraDev1866::to_bytes(&bytes); + let bytes = [AuraDevRog1::Lightbar, AuraDevRog1::Awake]; + let bytes = AuraDevRog1::to_bytes(&bytes); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes, [0x04, 0x05, 0x02]); - let bytes = [AuraDev1866::Sleep]; - let bytes = AuraDev1866::to_bytes(&bytes); + let bytes = [AuraDevRog1::Sleep]; + let bytes = AuraDevRog1::to_bytes(&bytes); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes, [0x30, 0x08, 0x04]); - let bytes = [AuraDev1866::Boot]; - let bytes = AuraDev1866::to_bytes(&bytes); + let bytes = [AuraDevRog1::Boot]; + let bytes = AuraDevRog1::to_bytes(&bytes); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes, [0xc3, 0x12, 0x09]); let bytes = [ - AuraDev1866::Keyboard, - AuraDev1866::Lightbar, - AuraDev1866::Awake, - AuraDev1866::Sleep, - AuraDev1866::Boot, + AuraDevRog1::Keyboard, + AuraDevRog1::Lightbar, + AuraDevRog1::Awake, + AuraDevRog1::Sleep, + AuraDevRog1::Boot, ]; - let bytes = AuraDev1866::to_bytes(&bytes); + let bytes = AuraDevRog1::to_bytes(&bytes); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes, [0xff, 0x1f, 0x000f]); } @@ -288,143 +303,143 @@ mod tests { fn check_0x19b6_control_bytes() { // All on let byte1 = [ - AuraDev19b6::BootLogo, - AuraDev19b6::BootKeyb, - AuraDev19b6::SleepLogo, - AuraDev19b6::SleepKeyb, - AuraDev19b6::AwakeLogo, - AuraDev19b6::AwakeKeyb, - AuraDev19b6::ShutdownLogo, - AuraDev19b6::ShutdownKeyb, + AuraDevRog2::BootLogo, + AuraDevRog2::BootKeyb, + AuraDevRog2::SleepLogo, + AuraDevRog2::SleepKeyb, + AuraDevRog2::AwakeLogo, + AuraDevRog2::AwakeKeyb, + AuraDevRog2::ShutdownLogo, + AuraDevRog2::ShutdownKeyb, ]; - let bytes = AuraDev19b6::to_bytes(&byte1); + let bytes = AuraDevRog2::to_bytes(&byte1); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes[0], 0xff); // let byte1 = [ // AuraControl::BootLogo, - AuraDev19b6::BootKeyb, - AuraDev19b6::SleepLogo, - AuraDev19b6::SleepKeyb, - AuraDev19b6::AwakeLogo, - AuraDev19b6::AwakeKeyb, - AuraDev19b6::ShutdownLogo, - AuraDev19b6::ShutdownKeyb, + AuraDevRog2::BootKeyb, + AuraDevRog2::SleepLogo, + AuraDevRog2::SleepKeyb, + AuraDevRog2::AwakeLogo, + AuraDevRog2::AwakeKeyb, + AuraDevRog2::ShutdownLogo, + AuraDevRog2::ShutdownKeyb, ]; - let bytes = AuraDev19b6::to_bytes(&byte1); + let bytes = AuraDevRog2::to_bytes(&byte1); println!("{:08b}", bytes[0]); assert_eq!(bytes[0], 0xfe); let byte1 = [ - AuraDev19b6::BootLogo, + AuraDevRog2::BootLogo, // AuraControl::BootKeyb, - AuraDev19b6::SleepLogo, - AuraDev19b6::SleepKeyb, - AuraDev19b6::AwakeLogo, - AuraDev19b6::AwakeKeyb, - AuraDev19b6::ShutdownLogo, - AuraDev19b6::ShutdownKeyb, + AuraDevRog2::SleepLogo, + AuraDevRog2::SleepKeyb, + AuraDevRog2::AwakeLogo, + AuraDevRog2::AwakeKeyb, + AuraDevRog2::ShutdownLogo, + AuraDevRog2::ShutdownKeyb, ]; - let bytes = AuraDev19b6::to_bytes(&byte1); + let bytes = AuraDevRog2::to_bytes(&byte1); println!("{:08b}", bytes[0]); assert_eq!(bytes[0], 0xfd); let byte1 = [ - AuraDev19b6::BootLogo, - AuraDev19b6::BootKeyb, + AuraDevRog2::BootLogo, + AuraDevRog2::BootKeyb, // AuraControl::SleepLogo, - AuraDev19b6::SleepKeyb, - AuraDev19b6::AwakeLogo, - AuraDev19b6::AwakeKeyb, - AuraDev19b6::ShutdownLogo, - AuraDev19b6::ShutdownKeyb, + AuraDevRog2::SleepKeyb, + AuraDevRog2::AwakeLogo, + AuraDevRog2::AwakeKeyb, + AuraDevRog2::ShutdownLogo, + AuraDevRog2::ShutdownKeyb, ]; - let bytes = AuraDev19b6::to_bytes(&byte1); + let bytes = AuraDevRog2::to_bytes(&byte1); println!("{:08b}", bytes[0]); assert_eq!(bytes[0], 0xef); let byte1 = [ - AuraDev19b6::BootLogo, - AuraDev19b6::BootKeyb, - AuraDev19b6::SleepLogo, + AuraDevRog2::BootLogo, + AuraDevRog2::BootKeyb, + AuraDevRog2::SleepLogo, // AuraControl::SleepKeyb, - AuraDev19b6::AwakeLogo, - AuraDev19b6::AwakeKeyb, - AuraDev19b6::ShutdownLogo, - AuraDev19b6::ShutdownKeyb, + AuraDevRog2::AwakeLogo, + AuraDevRog2::AwakeKeyb, + AuraDevRog2::ShutdownLogo, + AuraDevRog2::ShutdownKeyb, ]; - let bytes = AuraDev19b6::to_bytes(&byte1); + let bytes = AuraDevRog2::to_bytes(&byte1); println!("{:08b}", bytes[0]); assert_eq!(bytes[0], 0xdf); let byte2 = [ - AuraDev19b6::BootBar, - AuraDev19b6::AwakeBar, - AuraDev19b6::SleepBar, - AuraDev19b6::ShutdownBar, + AuraDevRog2::BootBar, + AuraDevRog2::AwakeBar, + AuraDevRog2::SleepBar, + AuraDevRog2::ShutdownBar, ]; - let bytes = AuraDev19b6::to_bytes(&byte2); + let bytes = AuraDevRog2::to_bytes(&byte2); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes[1], 0x1e); let byte2 = [ - AuraDev19b6::BootBar, - AuraDev19b6::AwakeBar, + AuraDevRog2::BootBar, + AuraDevRog2::AwakeBar, // 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]); assert_eq!(bytes[1], 0x16); let byte3 = [ - AuraDev19b6::AwakeLid, - AuraDev19b6::BootLid, - AuraDev19b6::SleepLid, - AuraDev19b6::ShutdownLid, + AuraDevRog2::AwakeLid, + AuraDevRog2::BootLid, + AuraDevRog2::SleepLid, + AuraDevRog2::ShutdownLid, ]; - let bytes = AuraDev19b6::to_bytes(&byte3); + let bytes = AuraDevRog2::to_bytes(&byte3); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes[2], 0x0f); let byte3 = [ // AuraDev19b6::AwakeLid, - AuraDev19b6::BootLid, - AuraDev19b6::SleepLid, - AuraDev19b6::ShutdownLid, + AuraDevRog2::BootLid, + AuraDevRog2::SleepLid, + AuraDevRog2::ShutdownLid, ]; - let bytes = AuraDev19b6::to_bytes(&byte3); + let bytes = AuraDevRog2::to_bytes(&byte3); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes[2], 0x0d); let byte3 = [ - AuraDev19b6::AwakeLid, - AuraDev19b6::BootLid, + AuraDevRog2::AwakeLid, + AuraDevRog2::BootLid, // 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]); assert_eq!(bytes[2], 0x0b); let byte3 = [ - AuraDev19b6::AwakeLid, - AuraDev19b6::BootLid, - AuraDev19b6::SleepLid, + AuraDevRog2::AwakeLid, + AuraDevRog2::BootLid, + AuraDevRog2::SleepLid, // AuraDev19b6::ShutdownLid, ]; - let bytes = AuraDev19b6::to_bytes(&byte3); + let bytes = AuraDevRog2::to_bytes(&byte3); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes[2], 0x07); let byte3 = [ - AuraDev19b6::AwakeLid, + AuraDevRog2::AwakeLid, // AuraDev19b6::BootLid, - AuraDev19b6::SleepLid, + AuraDevRog2::SleepLid, // AuraDev19b6::ShutdownLid, ]; - let bytes = AuraDev19b6::to_bytes(&byte3); + let bytes = AuraDevRog2::to_bytes(&byte3); println!("{:08b}, {:08b}, {:08b}", bytes[0], bytes[1], bytes[2]); assert_eq!(bytes[2], 0x06); } diff --git a/rog-control-center/src/widgets/aura_power.rs b/rog-control-center/src/widgets/aura_power.rs index 9528cdab..6b6ed4b5 100644 --- a/rog-control-center/src/widgets/aura_power.rs +++ b/rog-control-center/src/widgets/aura_power.rs @@ -1,5 +1,5 @@ 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_platform::supported::SupportedFunctions; @@ -9,10 +9,12 @@ pub fn aura_power_group(supported: &SupportedFunctions, states: &mut SystemState ui.heading("LED settings"); 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); } - 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::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) { let enabled_states = &mut states.aura.enabled; - let mut boot = enabled_states.x1866.contains(&AuraDev1866::Boot); - let mut sleep = enabled_states.x1866.contains(&AuraDev1866::Sleep); - let mut keyboard = enabled_states.x1866.contains(&AuraDev1866::Keyboard); - let mut lightbar = enabled_states.x1866.contains(&AuraDev1866::Lightbar); + let mut boot = enabled_states.x1866.contains(&AuraDevRog1::Boot); + let mut sleep = enabled_states.x1866.contains(&AuraDevRog1::Sleep); + let mut keyboard = enabled_states.x1866.contains(&AuraDevRog1::Keyboard); + let mut lightbar = enabled_states.x1866.contains(&AuraDevRog1::Lightbar); if supported.keyboard_led.dev_id == AuraDevice::Tuf { boot = enabled_states.tuf.contains(&AuraDevTuf::Boot); 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 disabled = Vec::new(); - let mut modify_x1866 = |b: bool, a: AuraDev1866| { + let mut modify_x1866 = |b: bool, a: AuraDevRog1| { if b { enabled.push(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(sleep, AuraDev1866::Sleep); - modify_x1866(keyboard, AuraDev1866::Keyboard); + modify_x1866(boot, AuraDevRog1::Boot); + modify_x1866(sleep, AuraDevRog1::Sleep); + modify_x1866(keyboard, AuraDevRog1::Keyboard); 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| { + let mut send = |enable: bool, data: Vec| { let options = AuraPowerDev { tuf: vec![], x1866: data, @@ -211,17 +213,17 @@ fn aura_power2(supported: &SupportedFunctions, states: &mut SystemState, ui: &mu .basic_zones .contains(&AuraZone::BarRight); - let boot_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeBar); - let boot_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootLogo); - let boot_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootKeyb); + let boot_bar = &mut enabled_states.x19b6.contains(&AuraDevRog2::AwakeBar); + let boot_logo = &mut enabled_states.x19b6.contains(&AuraDevRog2::BootLogo); + let boot_keyb = &mut enabled_states.x19b6.contains(&AuraDevRog2::BootKeyb); - let awake_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootBar); - let awake_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeLogo); - let awake_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeKeyb); + let awake_bar = &mut enabled_states.x19b6.contains(&AuraDevRog2::BootBar); + let awake_logo = &mut enabled_states.x19b6.contains(&AuraDevRog2::AwakeLogo); + let awake_keyb = &mut enabled_states.x19b6.contains(&AuraDevRog2::AwakeKeyb); - let sleep_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepBar); - let sleep_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepLogo); - let sleep_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepKeyb); + let sleep_bar = &mut enabled_states.x19b6.contains(&AuraDevRog2::SleepBar); + let sleep_logo = &mut enabled_states.x19b6.contains(&AuraDevRog2::SleepLogo); + let sleep_keyb = &mut enabled_states.x19b6.contains(&AuraDevRog2::SleepKeyb); 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 disabled = Vec::new(); - let mut modify = |b: bool, a: AuraDev19b6| { + let mut modify = |b: bool, a: AuraDevRog2| { if b { enabled.push(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(*sleep_keyb, AuraDev19b6::SleepKeyb); - modify(*awake_keyb, AuraDev19b6::AwakeKeyb); + modify(*boot_keyb, AuraDevRog2::BootKeyb); + modify(*sleep_keyb, AuraDevRog2::SleepKeyb); + modify(*awake_keyb, AuraDevRog2::AwakeKeyb); if supported.keyboard_led.basic_zones.contains(&AuraZone::Logo) { - modify(*boot_logo, AuraDev19b6::BootLogo); - modify(*sleep_logo, AuraDev19b6::SleepLogo); - modify(*awake_logo, AuraDev19b6::AwakeLogo); + modify(*boot_logo, AuraDevRog2::BootLogo); + modify(*sleep_logo, AuraDevRog2::SleepLogo); + modify(*awake_logo, AuraDevRog2::AwakeLogo); } if supported .keyboard_led .basic_zones .contains(&AuraZone::BarLeft) { - modify(*boot_bar, AuraDev19b6::AwakeBar); - modify(*sleep_bar, AuraDev19b6::SleepBar); - modify(*awake_bar, AuraDev19b6::BootBar); + modify(*boot_bar, AuraDevRog2::AwakeBar); + modify(*sleep_bar, AuraDevRog2::SleepBar); + modify(*awake_bar, AuraDevRog2::BootBar); } - let mut send = |enable: bool, data: Vec| { + let mut send = |enable: bool, data: Vec| { let options = AuraPowerDev { tuf: vec![], x1866: vec![],