Create rog-platform, refactor rogcc ipc-file handling

- Create new rog-platform crate to manage all i/o in a universal way
  + kbd-led handling
  + platform handling (asus-nb-wmi)
  + hidraw
  + usbraw
- Refactor how ROGCC handles IPC for background open, run-in-bg

daemon/Cargo.toml

@@ -21,15 +21,13 @@ path = "src/daemon.rs"
 rog_anime = { path = "../rog-anime", features = ["dbus"] }
 rog_aura = { path = "../rog-aura", features = ["dbus"] }
 rog_supported = { path = "../rog-supported" }
+rog_platform = { path = "../rog-platform" }
 rog_profiles = { path = "../rog-profiles" }
 rog_dbus = { path = "../rog-dbus" }
 
 async-trait = "^0.1"
 smol = "^1.2"
 
-rusb = "^0.9"
-udev = "^0.6"
-
 # cli and logging
 log = "^0.4"
 env_logger = "^0.9"

daemon/src/ctrl_anime/mod.rs

@@ -8,25 +8,21 @@ use logind_zbus::manager::ManagerProxy;
 use rog_anime::{
     error::AnimeError,
     usb::{
-        find_node, get_anime_type, pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on,
-        pkts_for_init, PROD_ID, VENDOR_ID,
+        get_anime_type, pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on,
+        pkts_for_init,
     },
     ActionData, AnimeDataBuffer, AnimePacketType, AnimeType,
 };
+use rog_platform::{hid_raw::HidRaw, usb_raw::USBRaw};
 use rog_supported::AnimeSupportedFunctions;
-use rusb::{Device, DeviceHandle};
 use smol::{stream::StreamExt, Executor};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::{
-    cell::RefCell,
     convert::TryFrom,
     error::Error,
     sync::{Arc, Mutex, MutexGuard},
     thread::sleep,
 };
-use std::{
-    sync::atomic::{AtomicBool, Ordering},
-    time::Duration,
-};
 
 use crate::{error::RogError, GetSupported};
 
@@ -36,14 +32,13 @@ impl GetSupported for CtrlAnime {
     type A = AnimeSupportedFunctions;
 
     fn get_supported() -> Self::A {
-        AnimeSupportedFunctions(CtrlAnime::get_device(VENDOR_ID, PROD_ID).is_ok())
+        AnimeSupportedFunctions(HidRaw::new("193b").is_ok())
     }
 }
 
 pub struct CtrlAnime {
-    _node: String,
+    node: USBRaw,
     anime_type: AnimeType,
-    handle: RefCell<DeviceHandle<rusb::GlobalContext>>,
     cache: AnimeConfigCached,
     config: AnimeConfig,
     // set to force thread to exit
@@ -55,57 +50,26 @@ pub struct CtrlAnime {
 impl CtrlAnime {
     #[inline]
     pub fn new(config: AnimeConfig) -> Result<CtrlAnime, Box<dyn Error>> {
-        let node = find_node("193b")?;
+        let node = USBRaw::new(0x193b)?;
         let anime_type = get_anime_type()?;
-        let device = Self::get_dev_handle()?;
 
         info!("Device has an AniMe Matrix display");
         let mut cache = AnimeConfigCached::default();
         cache.init_from_config(&config, anime_type)?;
 
         let ctrl = CtrlAnime {
-            _node: node,
+            node,
             anime_type,
-            handle: RefCell::new(device),
             cache,
             config,
             thread_exit: Arc::new(AtomicBool::new(false)),
             thread_running: Arc::new(AtomicBool::new(false)),
         };
-        ctrl.do_initialization();
+        ctrl.do_initialization()?;
 
         Ok(ctrl)
     }
-
-    fn get_dev_handle() -> Result<DeviceHandle<rusb::GlobalContext>, Box<dyn Error>> {
-        // We don't expect this ID to ever change
-        let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
-
-        let mut device = device.open()?;
-        device.reset()?;
-
-        device.set_auto_detach_kernel_driver(true).map_err(|err| {
-            error!("Auto-detach kernel driver failed: {}", err);
-            err
-        })?;
-
-        device.claim_interface(0).map_err(|err| {
-            error!("Could not claim device interface: {}", err);
-            err
-        })?;
-
-        Ok(device)
-    }
-
-    fn get_device(vendor: u16, product: u16) -> Result<Device<rusb::GlobalContext>, rusb::Error> {
-        for device in rusb::devices()?.iter() {
-            let device_desc = device.device_descriptor()?;
-            if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
-                return Ok(device);
-            }
-        }
-        Err(rusb::Error::NoDevice)
-    }
+    // let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
 
     /// Start an action thread. This is classed as a singleton and there should be only
     /// one running - so the thread uses atomics to signal run/exit.
@@ -230,45 +194,6 @@ impl CtrlAnime {
             .ok();
     }
 
-    fn write_bytes(&self, message: &[u8]) {
-        // if let Ok(mut file) = OpenOptions::new().write(true).open(&self.node) {
-        //     println!("write: {:02x?}", &message);
-        //     return file
-        //         .write_all(message).unwrap();
-        // }
-        let mut error = false;
-
-        match self.handle.borrow().write_control(
-            0x21,  // request_type
-            0x09,  // request
-            0x35e, // value
-            0x00,  // index
-            message,
-            Duration::from_millis(200),
-        ) {
-            Ok(_) => {}
-            Err(err) => match err {
-                rusb::Error::Timeout => {}
-                _ => {
-                    error = true;
-                    error!("Failed to write to led interrupt: {}", err);
-                }
-            },
-        }
-
-        if error {
-            warn!("Will attempt to get AniMe device handle again");
-            match Self::get_dev_handle() {
-                Ok(dev) => {
-                    self.handle.replace(dev);
-                }
-                Err(err) => {
-                    error!("Failed to get AniMe device: {}", err);
-                }
-            }
-        }
-    }
-
     /// Write only a data packet. This will modify the leds brightness using the
     /// global brightness set in config.
     fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) -> Result<(), RogError> {
@@ -281,16 +206,17 @@ impl CtrlAnime {
         }
         let data = AnimePacketType::try_from(buffer)?;
         for row in data.iter() {
-            self.write_bytes(row);
+            self.node.write_bytes(row)?;
         }
-        self.write_bytes(&pkt_for_flush());
+        self.node.write_bytes(&pkt_for_flush())?;
         Ok(())
     }
 
-    fn do_initialization(&self) {
+    fn do_initialization(&self) -> Result<(), RogError> {
         let pkts = pkts_for_init();
-        self.write_bytes(&pkts[0]);
-        self.write_bytes(&pkts[1]);
+        self.node.write_bytes(&pkts[0])?;
+        self.node.write_bytes(&pkts[1])?;
+        Ok(())
     }
 }
 
@@ -380,10 +306,12 @@ pub struct CtrlAnimeReloader(pub Arc<Mutex<CtrlAnime>>);
 impl crate::Reloadable for CtrlAnimeReloader {
     fn reload(&mut self) -> Result<(), RogError> {
         if let Ok(lock) = self.0.try_lock() {
-            lock.write_bytes(&pkt_for_set_on(lock.config.awake_enabled));
-            lock.write_bytes(&pkt_for_apply());
-            lock.write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled));
-            lock.write_bytes(&pkt_for_apply());
+            lock.node
+                .write_bytes(&pkt_for_set_on(lock.config.awake_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
+            lock.node
+                .write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
 
             let action = lock.cache.boot.clone();
             CtrlAnime::run_thread(self.0.clone(), action, true);

daemon/src/ctrl_anime/zbus.rs

@@ -64,7 +64,12 @@ impl CtrlAnimeZbus {
         let states;
         'outer: loop {
             if let Ok(mut lock) = self.0.try_lock() {
-                lock.write_bytes(&pkt_for_set_on(status));
+                lock.node
+                    .write_bytes(&pkt_for_set_on(status))
+                    .map_err(|err| {
+                        warn!("rog_anime::run_animation:callback {}", err);
+                    })
+                    .ok();
                 lock.config.awake_enabled = status;
                 lock.config.write();
 
@@ -86,8 +91,18 @@ impl CtrlAnimeZbus {
         let states;
         'outer: loop {
             if let Ok(mut lock) = self.0.try_lock() {
-                lock.write_bytes(&pkt_for_set_boot(on));
-                lock.write_bytes(&pkt_for_apply());
+                lock.node
+                    .write_bytes(&pkt_for_set_boot(on))
+                    .map_err(|err| {
+                        warn!("rog_anime::run_animation:callback {}", err);
+                    })
+                    .ok();
+                lock.node
+                    .write_bytes(&pkt_for_apply())
+                    .map_err(|err| {
+                        warn!("rog_anime::run_animation:callback {}", err);
+                    })
+                    .ok();
                 lock.config.boot_anim_enabled = on;
                 lock.config.write();
 

daemon/src/ctrl_aura/config.rs

@@ -2,13 +2,13 @@ use crate::laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
 use log::{error, warn};
 use rog_aura::usb::{AuraDev1866, AuraDev19b6, 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};
 use std::collections::{BTreeMap, HashSet};
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
 
-use super::controller::CtrlKbdLed;
-
 pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
 
 /// Enable/disable LED control in various states such as
@@ -128,14 +128,16 @@ impl Default for AuraConfig {
     fn default() -> Self {
         let mut prod_id = AuraDevice::Unknown;
         for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            if let Ok(_) = CtrlKbdLed::find_led_node(prod) {
+            if let Ok(_) = HidRaw::new(prod) {
                 prod_id = AuraDevice::from(*prod);
                 break;
             }
         }
 
-        if CtrlKbdLed::get_tuf_mode_path().is_some() {
-            prod_id = AuraDevice::Tuf;
+        if let Ok(p) = KeyboardLed::new() {
+            if p.has_keyboard_rgb_mode() {
+                prod_id = AuraDevice::Tuf;
+            }
         }
 
         let enabled = if prod_id == AuraDevice::X19B6 {

daemon/src/ctrl_aura/controller.rs

@@ -1,8 +1,3 @@
-// Only these two packets must be 17 bytes
-static KBD_BRIGHT_PATH: &str = "/sys/class/leds/asus::kbd_backlight/brightness";
-static TUF_RGB_MODE_PATH: &str = "/sys/devices/platform/asus-nb-wmi/tuf_krgb_mode";
-static TUF_RGB_STATE_PATH: &str = "/sys/devices/platform/asus-nb-wmi/tuf_krgb_state";
-
 use crate::{
     error::RogError,
     laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
@@ -16,16 +11,13 @@ use rog_aura::{
     AuraEffect, LedBrightness, LED_MSG_LEN,
 };
 use rog_aura::{AuraZone, Direction, Speed, GRADIENT};
+use rog_platform::{hid_raw::HidRaw, keyboard_led::KeyboardLed};
 use rog_supported::LedSupportedFunctions;
 use smol::{stream::StreamExt, Executor};
-use std::path::Path;
+use std::collections::BTreeMap;
 use std::sync::Arc;
 use std::sync::Mutex;
-use std::{
-    collections::BTreeMap,
-    io::{Read, Write},
-};
-use std::{fs::OpenOptions, sync::MutexGuard};
+use std::sync::MutexGuard;
 use zbus::Connection;
 
 use crate::GetSupported;
@@ -44,19 +36,21 @@ impl GetSupported for CtrlKbdLed {
 
         let mut prod_id = AuraDevice::Unknown;
         for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            if let Ok(_) = Self::find_led_node(prod) {
+            if let Ok(_) = HidRaw::new(prod) {
                 prod_id = AuraDevice::from(*prod);
                 break;
             }
         }
 
-        if Self::get_tuf_mode_path().is_some() {
-            prod_id = AuraDevice::Tuf;
+        if let Ok(p) = KeyboardLed::new() {
+            if p.has_keyboard_rgb_mode() {
+                prod_id = AuraDevice::Tuf;
+            }
         }
 
         LedSupportedFunctions {
             prod_id,
-            brightness_set: CtrlKbdLed::get_kbd_bright_path().is_some(),
+            brightness_set: KeyboardLed::new().is_ok(),
             stock_led_modes,
             multizone_led_mode,
             per_key_led_mode,
@@ -66,8 +60,8 @@ impl GetSupported for CtrlKbdLed {
 
 #[derive(Debug, PartialEq, PartialOrd)]
 pub enum LEDNode {
-    Tuf,
-    Rog(String),
+    KbdLed(KeyboardLed),
+    Rog(HidRaw),
     None,
 }
 
@@ -75,7 +69,7 @@ pub struct CtrlKbdLed {
     // TODO: config stores the keyboard type as an AuraPower, use or update this
     pub led_prod: Option<String>,
     pub led_node: LEDNode,
-    pub bright_node: String,
+    pub kd_brightness: KeyboardLed,
     pub supported_modes: LaptopLedData,
     pub flip_effect_write: bool,
     pub config: AuraConfig,
@@ -91,27 +85,11 @@ impl CtrlKbdLedTask {
     }
 
     fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&lock.bright_node)
-            .map_err(|err| match err.kind() {
-                std::io::ErrorKind::NotFound => {
-                    RogError::MissingLedBrightNode((&lock.bright_node).into(), err)
-                }
-                _ => RogError::Path((&lock.bright_node).into(), err),
-            })?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if lock.config.brightness != num.into() {
-                lock.config.read();
-                lock.config.brightness = num.into();
-                lock.config.write();
-            }
-            return Ok(());
-        }
-        Err(RogError::ParseLed)
+        let bright = lock.kd_brightness.get_brightness()?;
+        lock.config.read();
+        lock.config.brightness = (bright as u32).into();
+        lock.config.write();
+        return Ok(());
     }
 }
 
@@ -189,9 +167,7 @@ impl crate::Reloadable for CtrlKbdLedReloader {
     fn reload(&mut self) -> Result<(), RogError> {
         if let Ok(mut ctrl) = self.0.try_lock() {
             ctrl.write_current_config_mode()?;
-            ctrl.set_power_states(&ctrl.config)
-                .map_err(|err| warn!("{err}"))
-                .ok();
+            ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
         }
         Ok(())
     }
@@ -210,7 +186,7 @@ impl CtrlKbdLed {
         let mut led_prod = None;
         let mut led_node = None;
         for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            match Self::find_led_node(prod) {
+            match HidRaw::new(prod) {
                 Ok(node) => {
                     led_prod = Some(prod.to_string());
                     led_node = Some(node);
@@ -221,10 +197,10 @@ impl CtrlKbdLed {
             }
         }
 
-        let bright_node = Self::get_kbd_bright_path();
-        let tuf_node = Self::get_tuf_mode_path().is_some() || Self::get_tuf_state_path().is_some();
+        let bright_node = KeyboardLed::new();
+        let platform = KeyboardLed::new()?;
 
-        if led_node.is_none() && tuf_node && bright_node.is_none() {
+        if led_node.is_none() && !platform.has_keyboard_rgb_mode() {
             let dmi = sysfs_class::DmiId::default();
             if let Ok(prod_family) = dmi.product_family() {
                 if prod_family.contains("TUF") {
@@ -237,9 +213,9 @@ impl CtrlKbdLed {
         let led_node = if let Some(rog) = led_node {
             info!("Found ROG USB keyboard");
             LEDNode::Rog(rog)
-        } else if tuf_node {
+        } else if platform.has_keyboard_rgb_mode() {
             info!("Found TUF keyboard");
-            LEDNode::Tuf
+            LEDNode::KbdLed(platform)
         } else {
             LEDNode::None
         };
@@ -247,7 +223,7 @@ impl CtrlKbdLed {
         let ctrl = CtrlKbdLed {
             led_prod,
             led_node,
-            bright_node: bright_node.unwrap(), // If was none then we already returned above
+            kd_brightness: bright_node?, // If was none then we already returned above
             supported_modes,
             flip_effect_write: false,
             config,
@@ -255,58 +231,16 @@ impl CtrlKbdLed {
         Ok(ctrl)
     }
 
-    fn get_kbd_bright_path() -> Option<String> {
-        if Path::new(KBD_BRIGHT_PATH).exists() {
-            return Some(KBD_BRIGHT_PATH.to_string());
-        }
-        None
-    }
-
-    pub fn get_tuf_mode_path() -> Option<String> {
-        if Path::new(TUF_RGB_MODE_PATH).exists() {
-            return Some(TUF_RGB_MODE_PATH.to_string());
-        }
-        None
-    }
-
-    fn get_tuf_state_path() -> Option<String> {
-        if Path::new(TUF_RGB_STATE_PATH).exists() {
-            return Some(TUF_RGB_STATE_PATH.to_string());
-        }
-        None
-    }
-
     pub(super) fn get_brightness(&self) -> Result<u8, RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&self.bright_node)
-            .map_err(|err| match err.kind() {
-                std::io::ErrorKind::NotFound => {
-                    RogError::MissingLedBrightNode((&self.bright_node).into(), err)
-                }
-                _ => RogError::Path((&self.bright_node).into(), err),
-            })?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        Ok(buf[0])
+        self.kd_brightness
+            .get_brightness()
+            .map_err(|e| RogError::Platform(e))
     }
 
     pub(super) fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
-        let path = Path::new(&self.bright_node);
-        let mut file =
-            OpenOptions::new()
-                .write(true)
-                .open(&path)
-                .map_err(|err| match err.kind() {
-                    std::io::ErrorKind::NotFound => {
-                        RogError::MissingLedBrightNode((&self.bright_node).into(), err)
-                    }
-                    _ => RogError::Path((&self.bright_node).into(), err),
-                })?;
-        file.write_all(&[brightness.as_char_code()])
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        Ok(())
+        self.kd_brightness
+            .set_brightness(brightness.as_char_code())
+            .map_err(|e| RogError::Platform(e))
     }
 
     pub fn next_brightness(&mut self) -> Result<(), RogError> {
@@ -332,68 +266,24 @@ impl CtrlKbdLed {
     }
 
     /// 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> {
-        if LEDNode::Tuf == self.led_node {
-            if let Some(path) = Self::get_tuf_state_path() {
-                let mut file = OpenOptions::new().write(true).open(path)?;
-                if let Some(pwr) = AuraPowerConfig::to_tuf_bool_array(&config.enabled) {
-                    let buf = format!(
-                        "1 {} {} {} {}",
-                        pwr[1] as u8, pwr[2] as u8, pwr[3] as u8, pwr[4] as u8,
-                    );
-                    file.write_all(buf.as_bytes())?;
-                }
+    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_keyboard_rgb_state(&buf)?;
             }
-        } else {
-            let bytes = AuraPowerConfig::to_bytes(&config.enabled);
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
+            let bytes = AuraPowerConfig::to_bytes(&self.config.enabled);
             let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2]];
 
-            self.write_bytes(&message)?;
-            self.write_bytes(&LED_SET)?;
+            hid_raw.write_bytes(&message)?;
+            hid_raw.write_bytes(&LED_SET)?;
             // Changes won't persist unless apply is set
-            self.write_bytes(&LED_APPLY)?;
+            hid_raw.write_bytes(&LED_APPLY)?;
         }
         Ok(())
     }
 
-    pub(crate) fn find_led_node(id_product: &str) -> Result<String, RogError> {
-        let mut enumerator = udev::Enumerator::new().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("enumerator failed".into(), err)
-        })?;
-        enumerator.match_subsystem("hidraw").map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("match_subsystem failed".into(), err)
-        })?;
-
-        for device in enumerator.scan_devices().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("scan_devices failed".into(), err)
-        })? {
-            if let Some(parent) = device
-                .parent_with_subsystem_devtype("usb", "usb_device")
-                .map_err(|err| {
-                    warn!("{}", err);
-                    RogError::Udev("parent_with_subsystem_devtype failed".into(), err)
-                })?
-            {
-                if parent
-                    .attribute_value("idProduct")
-                    .ok_or_else(|| RogError::NotFound("LED idProduct".into()))?
-                    == id_product
-                {
-                    if let Some(dev_node) = device.devnode() {
-                        info!("Using device at: {:?} for LED control", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
-                    }
-                }
-            }
-        }
-        Err(RogError::MissingFunction(
-            "ASUS LED device node not found".into(),
-        ))
-    }
-
     /// Set an Aura effect if the effect mode or zone is supported.
     ///
     /// On success the aura config file is read to refresh cached values, then the effect is
@@ -414,28 +304,17 @@ impl CtrlKbdLed {
         Ok(())
     }
 
-    /// Should only be used if the bytes you are writing are verified correct
-    fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
-        if let LEDNode::Rog(led_node) = &self.led_node {
-            if let Ok(mut file) = OpenOptions::new().write(true).open(led_node) {
-                // println!("write: {:02x?}", &message);
-                return file
-                    .write_all(message)
-                    .map_err(|err| RogError::Write("write_bytes".into(), err));
-            }
-        }
-        Err(RogError::NoAuraNode)
-    }
-
     /// Write an effect block. This is for per-key
     fn _write_effect(&mut self, effect: &[Vec<u8>]) -> Result<(), RogError> {
-        if self.flip_effect_write {
-            for row in effect.iter().rev() {
-                self.write_bytes(row)?;
-            }
-        } else {
-            for row in effect.iter() {
-                self.write_bytes(row)?;
+        if let LEDNode::Rog(hid_raw) = &self.led_node {
+            if self.flip_effect_write {
+                for row in effect.iter().rev() {
+                    hid_raw.write_bytes(row)?;
+                }
+            } else {
+                for row in effect.iter() {
+                    hid_raw.write_bytes(row)?;
+                }
             }
         }
         self.flip_effect_write = !self.flip_effect_write;
@@ -478,19 +357,24 @@ impl CtrlKbdLed {
     }
 
     fn write_mode(&self, mode: &AuraEffect) -> Result<(), RogError> {
-        if LEDNode::Tuf == self.led_node {
-            let mut file = OpenOptions::new().write(true).open(TUF_RGB_MODE_PATH)?;
-            let buf = format!(
-                "1 {} {} {} {} {}",
-                mode.mode as u8, mode.colour1.0, mode.colour1.1, mode.colour1.2, mode.speed as u8,
-            );
-            file.write_all(buf.as_bytes())?;
-        } else {
+        if let LEDNode::KbdLed(platform) = &self.led_node {
+            let buf = [
+                1,
+                mode.mode as u8,
+                mode.colour1.0,
+                mode.colour1.1,
+                mode.colour1.2,
+                mode.speed as u8,
+            ];
+            platform.set_keyboard_rgb_mode(&buf)?;
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
             let bytes: [u8; LED_MSG_LEN] = mode.into();
-            self.write_bytes(&bytes)?;
-            self.write_bytes(&LED_SET)?;
+            hid_raw.write_bytes(&bytes)?;
+            hid_raw.write_bytes(&LED_SET)?;
             // Changes won't persist unless apply is set
-            self.write_bytes(&LED_APPLY)?;
+            hid_raw.write_bytes(&LED_APPLY)?;
+        } else {
+            return Err(RogError::NoAuraKeyboard);
         }
         Ok(())
     }
@@ -562,6 +446,7 @@ impl CtrlKbdLed {
 #[cfg(test)]
 mod tests {
     use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+    use rog_platform::keyboard_led::KeyboardLed;
 
     use crate::{
         ctrl_aura::{config::AuraConfig, controller::LEDNode},
@@ -585,7 +470,7 @@ mod tests {
         let mut controller = CtrlKbdLed {
             led_prod: None,
             led_node: LEDNode::None,
-            bright_node: String::new(),
+            kd_brightness: KeyboardLed::default(),
             supported_modes,
             flip_effect_write: false,
             config,
@@ -601,7 +486,7 @@ mod tests {
                 .set_effect(effect.clone())
                 .unwrap_err()
                 .to_string(),
-            "No Aura keyboard node found"
+            "No supported Aura keyboard"
         );
 
         effect.mode = AuraModeNum::Laser;
@@ -629,7 +514,7 @@ mod tests {
                 .set_effect(effect.clone())
                 .unwrap_err()
                 .to_string(),
-            "No Aura keyboard node found"
+            "No supported Aura keyboard"
         );
     }
 
@@ -647,7 +532,7 @@ mod tests {
         let mut controller = CtrlKbdLed {
             led_prod: None,
             led_node: LEDNode::None,
-            bright_node: String::new(),
+            kd_brightness: KeyboardLed::default(),
             supported_modes,
             flip_effect_write: false,
             config,
@@ -684,7 +569,7 @@ mod tests {
         let mut controller = CtrlKbdLed {
             led_prod: None,
             led_node: LEDNode::None,
-            bright_node: String::new(),
+            kd_brightness: KeyboardLed::default(),
             supported_modes,
             flip_effect_write: false,
             config,
@@ -699,7 +584,7 @@ mod tests {
                 .write_current_config_mode()
                 .unwrap_err()
                 .to_string(),
-            "No Aura keyboard node found"
+            "No supported Aura keyboard"
         );
         assert!(controller.config.multizone.is_some());
 

daemon/src/ctrl_aura/zbus.rs

@@ -78,7 +78,7 @@ impl CtrlKbdLedZbus {
 
             ctrl.config.write();
 
-            ctrl.set_power_states(&ctrl.config).map_err(|e| {
+            ctrl.set_power_states().map_err(|e| {
                 warn!("{}", e);
                 e
             })?;

daemon/src/ctrl_rog_bios.rs

@@ -1,6 +1,7 @@
 use crate::{config::Config, error::RogError, GetSupported};
 use async_trait::async_trait;
 use log::{error, info, warn};
+use rog_platform::platform::AsusPlatform;
 use rog_supported::RogBiosSupportedFunctions;
 use std::fs::OpenOptions;
 use std::io::BufRead;
@@ -15,15 +16,13 @@ use zbus::{dbus_interface, SignalContext};
 const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
 const DRACUT_PATH: &str = "/usr/bin/dracut";
 
-static ASUS_SWITCH_GRAPHIC_MODE: &str =
-    "/sys/firmware/efi/efivars/AsusSwitchGraphicMode-607005d5-3f75-4b2e-98f0-85ba66797a3e";
+// static ASUS_SWITCH_GRAPHIC_MODE: &str =
+//     "/sys/firmware/efi/efivars/AsusSwitchGraphicMode-607005d5-3f75-4b2e-98f0-85ba66797a3e";
 static ASUS_POST_LOGO_SOUND: &str =
     "/sys/firmware/efi/efivars/AsusPostLogoSound-607005d5-3f75-4b2e-98f0-85ba66797a3e";
-static ASUS_PANEL_OD_PATH: &str = "/sys/devices/platform/asus-nb-wmi/panel_od";
-static ASUS_DGPU_DISABLE_PATH: &str = "/sys/devices/platform/asus-nb-wmi/dgpu_disable";
-static ASUS_EGPU_ENABLE_PATH: &str = "/sys/devices/platform/asus-nb-wmi/egpu_enable";
 
 pub struct CtrlRogBios {
+    platform: AsusPlatform,
     _config: Arc<Mutex<Config>>,
 }
 
@@ -31,12 +30,24 @@ impl GetSupported for CtrlRogBios {
     type A = RogBiosSupportedFunctions;
 
     fn get_supported() -> Self::A {
+        let mut panel_overdrive = false;
+        let mut dgpu_disable = false;
+        let mut egpu_enable = false;
+        let mut dgpu_only = false;
+
+        if let Ok(platform) = AsusPlatform::new() {
+            panel_overdrive = platform.has_panel_od();
+            dgpu_disable = platform.has_dgpu_disable();
+            egpu_enable = platform.has_egpu_enable();
+            dgpu_only = platform.has_gpu_mux_mode();
+        }
+
         RogBiosSupportedFunctions {
             post_sound: Path::new(ASUS_POST_LOGO_SOUND).exists(),
-            dedicated_gfx: Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists(),
-            panel_overdrive: Path::new(ASUS_PANEL_OD_PATH).exists(),
-            dgpu_disable: Path::new(ASUS_DGPU_DISABLE_PATH).exists(),
-            egpu_enable: Path::new(ASUS_EGPU_ENABLE_PATH).exists(),
+            dgpu_only,
+            panel_overdrive,
+            dgpu_disable,
+            egpu_enable,
         }
     }
 }
@@ -59,13 +70,14 @@ impl CtrlRogBios {
             .ok();
     }
 
-    fn dedicated_graphic_mode(&self) -> i8 {
-        Self::get_gfx_mode()
+    fn dedicated_graphic_mode(&self) -> bool {
+        self.platform
+            .get_gpu_mux_mode()
             .map_err(|err| {
                 warn!("CtrlRogBios: get_gfx_mode {}", err);
                 err
             })
-            .unwrap_or(-1)
+            .unwrap_or(false)
     }
 
     #[dbus_interface(signal)]
@@ -118,26 +130,14 @@ impl CtrlRogBios {
         }
     }
 
-    fn panel_overdrive(&self) -> i8 {
-        let path = ASUS_PANEL_OD_PATH;
-        if let Ok(mut file) = OpenOptions::new().read(true).open(path).map_err(|err| {
-            warn!("CtrlRogBios: panel_overdrive {}", err);
-            err
-        }) {
-            let mut buf = Vec::new();
-            file.read_to_end(&mut buf)
-                .map_err(|err| {
-                    warn!("CtrlRogBios: set_panel_overdrive {}", err);
-                    err
-                })
-                .ok();
-
-            if buf.len() >= 1 {
-                let tmp = String::from_utf8_lossy(&buf[0..1]);
-                return tmp.parse::<i8>().unwrap_or(-1);
-            }
-        }
-        -1
+    fn panel_overdrive(&self) -> bool {
+        self.platform
+            .get_panel_od()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get panel overdrive {}", err);
+                err
+            })
+            .unwrap_or(false)
     }
 
     #[dbus_interface(signal)]
@@ -163,9 +163,8 @@ impl crate::Reloadable for CtrlRogBios {
 
 impl CtrlRogBios {
     pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        if Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists() {
-            CtrlRogBios::set_path_mutable(ASUS_SWITCH_GRAPHIC_MODE)?;
-        } else {
+        let platform = AsusPlatform::new()?;
+        if !platform.has_gpu_mux_mode() {
             info!("G-Sync Switchable Graphics not detected");
             info!("If your laptop is not a G-Sync enabled laptop then you can ignore this. Standard graphics switching will still work.");
         }
@@ -176,7 +175,10 @@ impl CtrlRogBios {
             info!("Switch for POST boot sound not detected");
         }
 
-        Ok(CtrlRogBios { _config: config })
+        Ok(CtrlRogBios {
+            platform,
+            _config: config,
+        })
     }
 
     fn set_path_mutable(path: &str) -> Result<(), RogError> {
@@ -189,48 +191,14 @@ impl CtrlRogBios {
         Ok(())
     }
 
-    pub fn has_dedicated_gfx_toggle() -> bool {
-        Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists()
-    }
-
-    pub fn get_gfx_mode() -> Result<i8, RogError> {
-        let path = ASUS_SWITCH_GRAPHIC_MODE;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)
-            .map_err(|err| RogError::Read(path.into(), err))?;
-
-        let idx = data.len() - 1;
-        Ok(data[idx] as i8)
-    }
-
-    pub(super) fn set_gfx_mode(&self, dedicated: bool) -> Result<(), RogError> {
-        let path = ASUS_SWITCH_GRAPHIC_MODE;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)?;
-
-        let idx = data.len() - 1;
-        if dedicated {
-            data[idx] = 1;
+    pub(super) fn set_gfx_mode(&self, enable: bool) -> Result<(), RogError> {
+        self.platform.set_gpu_mux_mode(enable)?;
+        self.update_initramfs(enable)?;
+        if enable {
             info!("Set system-level graphics mode: Dedicated Nvidia");
         } else {
-            data[idx] = 0;
             info!("Set system-level graphics mode: Optimus");
         }
-        file.write_all(&data)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        self.update_initramfs(dedicated)?;
         Ok(())
     }
 
@@ -358,42 +326,11 @@ impl CtrlRogBios {
         Ok(())
     }
 
-    fn set_panel_od(&mut self, overdrive: bool) -> Result<(), RogError> {
-        let path = ASUS_PANEL_OD_PATH;
-        let mut file = OpenOptions::new().write(true).open(path).map_err(|err| {
-            warn!("CtrlRogBios: set_panel_overdrive {}", err);
-            err
-        })?;
-
-        let s = if overdrive { '1' } else { '0' };
-        file.write(&[s as u8]).map_err(|err| {
+    fn set_panel_od(&mut self, enable: bool) -> Result<(), RogError> {
+        self.platform.set_panel_od(enable).map_err(|err| {
             warn!("CtrlRogBios: set_panel_overdrive {}", err);
             err
         })?;
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::CtrlRogBios;
-    use crate::config::Config;
-    use std::sync::{Arc, Mutex};
-
-    #[test]
-    #[ignore = "Must be manually tested"]
-    fn set_multizone_4key_config() {
-        let config = Config::default();
-
-        let controller = CtrlRogBios {
-            _config: Arc::new(Mutex::new(config)),
-        };
-
-        let res = controller.panel_overdrive();
-        assert_eq!(res, 1);
-
-        // controller.set_panel_od(false).unwrap();
-        // let res = controller.panel_overdrive();
-        // assert_eq!(res, 0);
-    }
-}

daemon/src/error.rs

@@ -1,4 +1,5 @@
 use rog_anime::error::AnimeError;
+use rog_platform::error::PlatformError;
 use rog_profiles::error::ProfileError;
 use std::convert::From;
 use std::fmt;
@@ -28,6 +29,7 @@ pub enum RogError {
     NoAuraKeyboard,
     NoAuraNode,
     Anime(AnimeError),
+    Platform(PlatformError),
 }
 
 impl fmt::Display for RogError {
@@ -57,6 +59,7 @@ impl fmt::Display for RogError {
             RogError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
             RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
             RogError::Anime(deets) => write!(f, "AniMe Matrix error: {}", deets),
+            RogError::Platform(deets) => write!(f, "Asus Platform error: {}", deets),
         }
     }
 }
@@ -75,6 +78,12 @@ impl From<AnimeError> for RogError {
     }
 }
 
+impl From<PlatformError> for RogError {
+    fn from(err: PlatformError) -> Self {
+        RogError::Platform(err)
+    }
+}
+
 impl From<zbus::Error> for RogError {
     fn from(err: zbus::Error) -> Self {
         RogError::Zbus(err)