Merge branch 'devel'

Makefile

@@ -113,7 +113,7 @@ install-data-asusd_user:
 
 .PHONY: install-data-asusd install-data-asusd_user
 
-install-data: install-data-asusd install-data-rog_gui
+install-data: install-data-asusd install-data-asusd_user install-data-rog_gui
 
 install: install-program install-data
 	$(INSTALL_DATA) "./LICENSE" "$(DESTDIR)$(datarootdir)/asusctl/LICENSE"

asusctl/examples/anime-gif.rs

@@ -21,11 +21,14 @@ fn main() {
     let brightness = args[2].parse::<f32>().unwrap();
     let anime_type = get_anime_type();
     let mut seq = Sequences::new(anime_type);
-    seq.insert(0, &ActionLoader::AsusAnimation {
+    seq.insert(
-        file: path.into(),
+        0,
-        time: rog_anime::AnimTime::Infinite,
+        &ActionLoader::AsusAnimation {
-        brightness,
+            file: path.into(),
-    })
+            time: rog_anime::AnimTime::Infinite,
+            brightness,
+        },
+    )
     .unwrap();
 
     loop {

asusctl/src/main.rs

@@ -1179,7 +1179,7 @@ fn handle_armoury_command(cmd: &ArmouryCommand) -> Result<(), Box<dyn std::error
     {
         if cmd.free.is_empty() || !cmd.free.len().is_multiple_of(2) || cmd.help {
             const USAGE: &str = "Usage: asusctl platform panel_overdrive 1 nv_dynamic_boost 5";
-            if !cmd.free.len().is_multiple_of(2) {
+            if !(cmd.free.len() % 2 == 0) {
                 println!(
                     "Incorrect number of args, each attribute label must be paired with a setting:"
                 );

asusd/src/asus_armoury.rs

@@ -1,12 +1,12 @@
 use std::sync::Arc;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
 use log::{debug, error, info};
 use rog_platform::asus_armoury::{AttrValue, Attribute, FirmwareAttribute, FirmwareAttributes};
 use rog_platform::platform::{PlatformProfile, RogPlatform};
 use rog_platform::power::AsusPower;
 use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
 use zbus::object_server::SignalEmitter;
 use zbus::zvariant::{ObjectPath, OwnedObjectPath, OwnedValue, Type, Value};
 use zbus::{fdo, interface, Connection};

asusd/src/aura_anime/mod.rs

@@ -8,7 +8,6 @@ use std::sync::Arc;
 use std::thread::sleep;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
 use rog_anime::usb::{
     pkt_flush, pkt_set_brightness, pkt_set_enable_display, pkt_set_enable_powersave_anim,
@@ -17,6 +16,7 @@ use rog_anime::usb::{
 use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::usb_raw::USBRaw;
+use tokio::sync::Mutex;
 
 use self::config::{AniMeConfig, AniMeConfigCached};
 use crate::error::RogError;
@@ -51,7 +51,7 @@ impl AniMe {
 
     /// Will fail if something is already holding the config lock
     async fn do_init_cache(&mut self) {
-        if let Some(mut config) = self.config.try_lock() {
+        if let Ok(mut config) = self.config.try_lock() {
             if let Err(e) = self.cache.init_from_config(&config, config.anime_type) {
                 error!(
                     "Trying to cache the Anime Config failed, will reset to default config: {e:?}"

asusd/src/aura_anime/trait_impls.rs

@@ -85,7 +85,7 @@ impl AniMeZbus {
     /// Set base brightness level
     #[zbus(property)]
     async fn brightness(&self) -> Brightness {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.display_brightness;
         }
         Brightness::Off
@@ -117,7 +117,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn builtins_enabled(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.builtin_anims_enabled;
         }
         false
@@ -162,7 +162,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn builtin_animations(&self) -> Animations {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.builtin_anims;
         }
         Animations::default()
@@ -195,7 +195,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn enable_display(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.display_enabled;
         }
         false
@@ -218,7 +218,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn off_when_unplugged(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.off_when_unplugged;
         }
         false
@@ -245,7 +245,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn off_when_suspended(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.off_when_suspended;
         }
         false
@@ -261,7 +261,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn off_when_lid_closed(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.off_when_lid_closed;
         }
         false

asusd/src/aura_laptop/config.rs

@@ -309,26 +309,38 @@ mod tests {
         let res = config.multizone.unwrap();
         let sta = res.get(&AuraModeNum::Static).unwrap();
         assert_eq!(sta.len(), 4);
-        assert_eq!(sta[0].colour1, Colour {
+        assert_eq!(
-            r: 0xff,
+            sta[0].colour1,
-            g: 0x00,
+            Colour {
-            b: 0xff
+                r: 0xff,
-        });
+                g: 0x00,
-        assert_eq!(sta[1].colour1, Colour {
+                b: 0xff
-            r: 0x00,
+            }
-            g: 0xff,
+        );
-            b: 0xff
+        assert_eq!(
-        });
+            sta[1].colour1,
-        assert_eq!(sta[2].colour1, Colour {
+            Colour {
-            r: 0xff,
+                r: 0x00,
-            g: 0xff,
+                g: 0xff,
-            b: 0x00
+                b: 0xff
-        });
+            }
-        assert_eq!(sta[3].colour1, Colour {
+        );
-            r: 0x00,
+        assert_eq!(
-            g: 0xff,
+            sta[2].colour1,
-            b: 0x00
+            Colour {
-        });
+                r: 0xff,
+                g: 0xff,
+                b: 0x00
+            }
+        );
+        assert_eq!(
+            sta[3].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00
+            }
+        );
     }
 
     #[test]
@@ -388,22 +400,28 @@ mod tests {
 
         assert_eq!(config.brightness, LedBrightness::Med);
         assert_eq!(config.builtins.len(), 5);
-        assert_eq!(config.builtins.first_entry().unwrap().get(), &AuraEffect {
+        assert_eq!(
-            mode: AuraModeNum::Static,
+            config.builtins.first_entry().unwrap().get(),
-            zone: AuraZone::None,
+            &AuraEffect {
-            colour1: Colour { r: 166, g: 0, b: 0 },
+                mode: AuraModeNum::Static,
-            colour2: Colour { r: 0, g: 0, b: 0 },
+                zone: AuraZone::None,
-            speed: Speed::Med,
+                colour1: Colour { r: 166, g: 0, b: 0 },
-            direction: Direction::Right
+                colour2: Colour { r: 0, g: 0, b: 0 },
-        });
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
         assert_eq!(config.enabled.states.len(), 1);
-        assert_eq!(config.enabled.states[0], AuraPowerState {
+        assert_eq!(
-            zone: PowerZones::KeyboardAndLightbar,
+            config.enabled.states[0],
-            boot: true,
+            AuraPowerState {
-            awake: true,
+                zone: PowerZones::KeyboardAndLightbar,
-            sleep: true,
+                boot: true,
-            shutdown: true
+                awake: true,
-        });
+                sleep: true,
+                shutdown: true
+            }
+        );
     }
 
     #[test]
@@ -414,21 +432,27 @@ mod tests {
 
         assert_eq!(config.brightness, LedBrightness::Med);
         assert_eq!(config.builtins.len(), 12);
-        assert_eq!(config.builtins.first_entry().unwrap().get(), &AuraEffect {
+        assert_eq!(
-            mode: AuraModeNum::Static,
+            config.builtins.first_entry().unwrap().get(),
-            zone: AuraZone::None,
+            &AuraEffect {
-            colour1: Colour { r: 166, g: 0, b: 0 },
+                mode: AuraModeNum::Static,
-            colour2: Colour { r: 0, g: 0, b: 0 },
+                zone: AuraZone::None,
-            speed: Speed::Med,
+                colour1: Colour { r: 166, g: 0, b: 0 },
-            direction: Direction::Right
+                colour2: Colour { r: 0, g: 0, b: 0 },
-        });
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
         assert_eq!(config.enabled.states.len(), 4);
-        assert_eq!(config.enabled.states[0], AuraPowerState {
+        assert_eq!(
-            zone: PowerZones::Keyboard,
+            config.enabled.states[0],
-            boot: true,
+            AuraPowerState {
-            awake: true,
+                zone: PowerZones::Keyboard,
-            sleep: true,
+                boot: true,
-            shutdown: true
+                awake: true,
-        });
+                sleep: true,
+                shutdown: true
+            }
+        );
     }
 }

asusd/src/aura_laptop/mod.rs

@@ -2,13 +2,13 @@ use std::sync::Arc;
 
 use config::AuraConfig;
 use config_traits::StdConfig;
-use futures_util::lock::{Mutex, MutexGuard};
 use log::info;
 use rog_aura::keyboard::{AuraLaptopUsbPackets, LedUsbPackets};
 use rog_aura::usb::{AURA_LAPTOP_LED_APPLY, AURA_LAPTOP_LED_SET};
 use rog_aura::{AuraDeviceType, AuraEffect, LedBrightness, PowerZones, AURA_LAPTOP_LED_MSG_LEN};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::keyboard_led::KeyboardBacklight;
+use tokio::sync::{Mutex, MutexGuard};
 
 use crate::error::RogError;
 

asusd/src/aura_laptop/trait_impls.rs

@@ -112,7 +112,7 @@ impl AuraZbus {
         // entirely possible to deadlock here, so use try instead of lock()
         // let ctrl = self.0.lock().await;
         // Ok(config.current_mode)
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             Ok(config.current_mode)
         } else {
             Err(ZbErr::Failed("Aura control couldn't lock self".to_string()))
@@ -140,7 +140,7 @@ impl AuraZbus {
     #[zbus(property)]
     async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
         // entirely possible to deadlock here, so use try instead of lock()
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             let mode = config.current_mode;
             match config.builtins.get(&mode) {
                 Some(effect) => Ok(effect.clone()),

asusd/src/aura_manager.rs

@@ -4,15 +4,16 @@
 // - Add it to Zbus server
 // - If udev sees device removed then remove the zbus path
 
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use dmi_id::DMIID;
 use futures_lite::future::block_on;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
 use mio::{Events, Interest, Poll, Token};
 use rog_platform::error::PlatformError;
 use rog_platform::hid_raw::HidRaw;
+use tokio::sync::Mutex;
 use udev::{Device, MonitorBuilder};
 use zbus::zvariant::{ObjectPath, OwnedObjectPath};
 use zbus::Connection;
@@ -92,16 +93,38 @@ fn dev_prop_matches(dev: &Device, prop: &str, value: &str) -> bool {
 pub struct AsusDevice {
     device: DeviceHandle,
     dbus_path: OwnedObjectPath,
+    hid_key: Option<String>,
 }
 
 pub struct DeviceManager {
     _dbus_connection: Connection,
+    _hid_handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
 }
 
 impl DeviceManager {
+    async fn get_or_create_hid_handle(
+        handles: &Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+        endpoint: &Device,
+    ) -> Result<(Arc<Mutex<HidRaw>>, String), RogError> {
+        let dev_node = endpoint
+            .devnode()
+            .ok_or_else(|| RogError::MissingFunction("hidraw devnode missing".to_string()))?;
+        let key = dev_node.to_string_lossy().to_string();
+
+        if let Some(existing) = handles.lock().await.get(&key).cloned() {
+            return Ok((existing, key));
+        }
+
+        let hidraw = HidRaw::from_device(endpoint.clone())?;
+        let handle = Arc::new(Mutex::new(hidraw));
+        handles.lock().await.insert(key.clone(), handle.clone());
+        Ok((handle, key))
+    }
+
     async fn init_hid_devices(
         connection: &Connection,
         device: Device,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
     ) -> Result<Vec<AsusDevice>, RogError> {
         let mut devices = Vec::new();
         if let Some(usb_device) = device.parent_with_subsystem_devtype("usb", "usb_device")? {
@@ -116,9 +139,10 @@ impl DeviceManager {
                     // 1. Generate an interface path
                     // 2. Create the device
                     // Use the top-level endpoint, not the parent
-                    if let Ok(hidraw) = HidRaw::from_device(device) {
+                    if let Ok((dev, hid_key)) =
+                        Self::get_or_create_hid_handle(&handles, &device).await
+                    {
                         debug!("Testing device {usb_id:?}");
-                        let dev = Arc::new(Mutex::new(hidraw));
                         // SLASH DEVICE
                         if let Ok(dev_type) = DeviceHandle::new_slash_hid(
                             dev.clone(),
@@ -134,6 +158,7 @@ impl DeviceManager {
                                 devices.push(AsusDevice {
                                     device: dev_type,
                                     dbus_path: path,
+                                    hid_key: Some(hid_key.clone()),
                                 });
                             }
                         }
@@ -152,6 +177,7 @@ impl DeviceManager {
                                 devices.push(AsusDevice {
                                     device: dev_type,
                                     dbus_path: path,
+                                    hid_key: Some(hid_key.clone()),
                                 });
                             }
                         }
@@ -170,9 +196,12 @@ impl DeviceManager {
                                 devices.push(AsusDevice {
                                     device: dev_type,
                                     dbus_path: path,
+                                    hid_key: Some(hid_key),
                                 });
                             }
                         }
+                    } else {
+                        warn!("Failed to initialise shared hid handle for {usb_id:?}");
                     }
                 }
             }
@@ -181,7 +210,10 @@ impl DeviceManager {
     }
 
     /// To be called on daemon startup
-    async fn init_all_hid(connection: &Connection) -> Result<Vec<AsusDevice>, RogError> {
+    async fn init_all_hid(
+        connection: &Connection,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+    ) -> Result<Vec<AsusDevice>, RogError> {
         // track and ensure we use only one hidraw per prod_id
         // let mut interfaces = HashSet::new();
         let mut devices: Vec<AsusDevice> = Vec::new();
@@ -200,7 +232,7 @@ impl DeviceManager {
             .scan_devices()
             .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
         {
-            devices.append(&mut Self::init_hid_devices(connection, device).await?);
+            devices.append(&mut Self::init_hid_devices(connection, device, handles.clone()).await?);
         }
 
         Ok(devices)
@@ -228,6 +260,7 @@ impl DeviceManager {
                         return Some(AsusDevice {
                             device: dev_type,
                             dbus_path: path,
+                            hid_key: None,
                         });
                     }
                 }
@@ -275,10 +308,13 @@ impl DeviceManager {
         Ok(devices)
     }
 
-    pub async fn find_all_devices(connection: &Connection) -> Vec<AsusDevice> {
+    pub async fn find_all_devices(
+        connection: &Connection,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+    ) -> Vec<AsusDevice> {
         let mut devices: Vec<AsusDevice> = Vec::new();
         // HID first, always
-        if let Ok(devs) = &mut Self::init_all_hid(connection).await {
+        if let Ok(devs) = &mut Self::init_all_hid(connection, handles.clone()).await {
             devices.append(devs);
         }
         // USB after, need to check if HID picked something up and if so, skip it
@@ -306,6 +342,7 @@ impl DeviceManager {
                     devices.push(AsusDevice {
                         device: dev_type,
                         dbus_path: path,
+                        hid_key: None,
                     });
                 }
             } else {
@@ -328,6 +365,7 @@ impl DeviceManager {
                         devices.push(AsusDevice {
                             device: dev_type,
                             dbus_path: path,
+                            hid_key: None,
                         });
                     }
                 }
@@ -355,6 +393,7 @@ impl DeviceManager {
                         devices.push(AsusDevice {
                             device: dev_type,
                             dbus_path: path,
+                            hid_key: None,
                         });
                     }
                 }
@@ -370,16 +409,19 @@ impl DeviceManager {
 
     pub async fn new(connection: Connection) -> Result<Self, RogError> {
         let conn_copy = connection.clone();
-        let devices = Self::find_all_devices(&conn_copy).await;
+        let hid_handles = Arc::new(Mutex::new(HashMap::new()));
+        let devices = Self::find_all_devices(&conn_copy, hid_handles.clone()).await;
         info!("Found {} valid devices on startup", devices.len());
         let devices = Arc::new(Mutex::new(devices));
         let manager = Self {
             _dbus_connection: connection,
+            _hid_handles: hid_handles.clone(),
         };
 
         // TODO: The /sysfs/ LEDs don't cause events, so they need to be manually
         // checked for and added
 
+        let hid_handles_thread = hid_handles.clone();
         std::thread::spawn(move || {
             let mut monitor = MonitorBuilder::new()?.listen()?;
             let mut poll = Poll::new()?;
@@ -408,6 +450,7 @@ impl DeviceManager {
 
                     let devices = devices.clone();
                     let conn_copy = conn_copy.clone();
+                    let hid_handles = hid_handles_thread.clone();
                     block_on(async move {
                         // SCSCI devs
                         if subsys == "block" {
@@ -483,6 +526,7 @@ impl DeviceManager {
                                         // Iter in reverse so as to not screw up indexing
                                         for index in removals.iter().rev() {
                                             let dev = devices.lock().await.remove(*index);
+                                            let hid_key = dev.hid_key.clone();
                                             let path = path.clone();
                                             let res = match dev.device {
                                                 DeviceHandle::Aura(_) => {
@@ -512,14 +556,20 @@ impl DeviceManager {
                                                 _ => todo!(),
                                             };
                                             info!("AuraManager removed: {path:?}, {res}");
+                                            if let Some(key) = hid_key {
+                                                hid_handles.lock().await.remove(&key);
+                                            }
                                         }
                                     }
                                 } else if action == "add" {
                                     let evdev = event.device();
-                                    if let Ok(mut new_devs) =
+                                    if let Ok(mut new_devs) = Self::init_hid_devices(
-                                        Self::init_hid_devices(&conn_copy, evdev)
+                                        &conn_copy,
-                                            .await
+                                        evdev,
-                                            .map_err(|e| error!("Couldn't add new device: {e:?}"))
+                                        hid_handles.clone(),
+                                    )
+                                    .await
+                                    .map_err(|e| error!("Couldn't add new device: {e:?}"))
                                     {
                                         devices.lock().await.append(&mut new_devs);
                                     }

asusd/src/aura_scsi/mod.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use config::ScsiConfig;
-use futures_util::lock::{Mutex, MutexGuard};
 use rog_scsi::{AuraEffect, Device, Task};
+use tokio::sync::{Mutex, MutexGuard};
 
 use crate::error::RogError;
 

asusd/src/aura_scsi/trait_impls.rs

@@ -83,7 +83,7 @@ impl ScsiZbus {
     #[zbus(property)]
     async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
         // entirely possible to deadlock here, so use try instead of lock()
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             let mode = config.current_mode;
             match config.modes.get(&mode) {
                 Some(effect) => Ok(effect.clone()),

asusd/src/aura_slash/mod.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use config::SlashConfig;
-use futures_util::lock::{Mutex, MutexGuard};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::usb_raw::USBRaw;
 use rog_slash::usb::{slash_pkt_enable, slash_pkt_init, slash_pkt_options, slash_pkt_set_mode};
+use tokio::sync::{Mutex, MutexGuard};
 
 use crate::error::RogError;
 

asusd/src/aura_types.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use config_traits::{StdConfig, StdConfigLoad};
-use futures_util::lock::Mutex;
 use log::{debug, error, info};
 use rog_anime::error::AnimeError;
 use rog_anime::usb::get_anime_type;
@@ -13,6 +12,7 @@ use rog_platform::usb_raw::USBRaw;
 use rog_scsi::{open_device, ScsiType};
 use rog_slash::error::SlashError;
 use rog_slash::SlashType;
+use tokio::sync::Mutex;
 
 use crate::aura_anime::config::AniMeConfig;
 use crate::aura_anime::AniMe;

asusd/src/ctrl_backlight.rs

@@ -2,9 +2,9 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
 use log::{info, warn};
 use rog_platform::backlight::{Backlight, BacklightType};
+use tokio::sync::Mutex;
 use zbus::fdo::Error as FdoErr;
 use zbus::object_server::SignalEmitter;
 use zbus::{interface, Connection};
@@ -13,7 +13,7 @@ use crate::config::Config;
 use crate::error::RogError;
 use crate::ASUS_ZBUS_PATH;
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct CtrlBacklight {
     backlights: Vec<Backlight>,
     config: Arc<Mutex<Config>>,

asusd/src/ctrl_fancurves.rs

@@ -3,13 +3,13 @@ use std::sync::Arc;
 
 use config_traits::{StdConfig, StdConfigLoad};
 use futures_lite::StreamExt;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
 use rog_platform::platform::{PlatformProfile, RogPlatform};
 use rog_profiles::error::ProfileError;
 use rog_profiles::fan_curve_set::CurveData;
 use rog_profiles::{find_fan_curve_node, FanCurvePU, FanCurveProfiles};
 use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
 use zbus::object_server::SignalEmitter;
 use zbus::{interface, Connection};
 

asusd/src/ctrl_platform.rs

@@ -3,12 +3,12 @@ use std::process::Command;
 use std::sync::Arc;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
 use rog_platform::asus_armoury::{AttrValue, FirmwareAttribute, FirmwareAttributes};
 use rog_platform::cpu::{CPUControl, CPUGovernor, CPUEPP};
 use rog_platform::platform::{PlatformProfile, Properties, RogPlatform};
 use rog_platform::power::AsusPower;
+use tokio::sync::Mutex;
 use zbus::fdo::Error as FdoErr;
 use zbus::object_server::SignalEmitter;
 use zbus::{interface, Connection};

asusd/src/daemon.rs

@@ -11,11 +11,11 @@ use asusd::ctrl_fancurves::CtrlFanCurveZbus;
 use asusd::ctrl_platform::CtrlPlatform;
 use asusd::{print_board_info, start_tasks, CtrlTask, ZbusRun, DBUS_NAME};
 use config_traits::{StdConfig, StdConfigLoad2};
-use futures_util::lock::Mutex;
 use log::{error, info};
 use rog_platform::asus_armoury::FirmwareAttributes;
 use rog_platform::platform::RogPlatform;
 use rog_platform::power::AsusPower;
+use tokio::sync::Mutex;
 use zbus::fdo::ObjectManager;
 
 #[tokio::main]

rog-aura/src/effects/mod.rs

@@ -207,12 +207,14 @@ mod tests {
     fn single_key_next_state_then_create() {
         let layout = KeyLayout::default_layout();
         let mut seq = AdvancedEffects::new(false);
-        seq.effects
+        seq.effects.push(Effect::Static(Static::new(
-            .push(Effect::Static(Static::new(LedCode::F, Colour {
+            LedCode::F,
+            Colour {
                 r: 255,
                 g: 127,
                 b: 0,
-            })));
+            },
+        )));
 
         seq.next_state(&layout);
         let packets = seq.create_packets();

rog-aura/src/keyboard/layouts.rs

@@ -335,93 +335,117 @@ impl KeyLayout {
                 KeyShape::new_led(1.0, 1.0, 0.1, 0.1, 0.1, 0.1),
             )]),
             key_rows: vec![
-                KeyRow::new(0.1, 0.1, vec![
+                KeyRow::new(
-                    (LedCode::Esc, "regular".to_owned()),
+                    0.1,
-                    (LedCode::F1, "regular".to_owned()),
+                    0.1,
-                    (LedCode::F2, "regular".to_owned()),
+                    vec![
-                    (LedCode::F3, "regular".to_owned()),
+                        (LedCode::Esc, "regular".to_owned()),
-                    (LedCode::F4, "regular".to_owned()),
+                        (LedCode::F1, "regular".to_owned()),
-                    // not sure which key to put here
+                        (LedCode::F2, "regular".to_owned()),
-                    (LedCode::F5, "regular".to_owned()),
+                        (LedCode::F3, "regular".to_owned()),
-                    (LedCode::F6, "regular".to_owned()),
+                        (LedCode::F4, "regular".to_owned()),
-                    (LedCode::F7, "regular".to_owned()),
+                        // not sure which key to put here
-                    (LedCode::F8, "regular".to_owned()),
+                        (LedCode::F5, "regular".to_owned()),
-                    (LedCode::F9, "regular".to_owned()),
+                        (LedCode::F6, "regular".to_owned()),
-                    (LedCode::F10, "regular".to_owned()),
+                        (LedCode::F7, "regular".to_owned()),
-                    (LedCode::F11, "regular".to_owned()),
+                        (LedCode::F8, "regular".to_owned()),
-                    (LedCode::F12, "regular".to_owned()),
+                        (LedCode::F9, "regular".to_owned()),
-                ]),
+                        (LedCode::F10, "regular".to_owned()),
-                KeyRow::new(0.1, 0.1, vec![
+                        (LedCode::F11, "regular".to_owned()),
-                    (LedCode::Tilde, "regular".to_owned()),
+                        (LedCode::F12, "regular".to_owned()),
-                    (LedCode::N1, "regular".to_owned()),
+                    ],
-                    (LedCode::N2, "regular".to_owned()),
+                ),
-                    (LedCode::N3, "regular".to_owned()),
+                KeyRow::new(
-                    (LedCode::N4, "regular".to_owned()),
+                    0.1,
-                    (LedCode::N5, "regular".to_owned()),
+                    0.1,
-                    (LedCode::N6, "regular".to_owned()),
+                    vec![
-                    (LedCode::N7, "regular".to_owned()),
+                        (LedCode::Tilde, "regular".to_owned()),
-                    (LedCode::N8, "regular".to_owned()),
+                        (LedCode::N1, "regular".to_owned()),
-                    (LedCode::N9, "regular".to_owned()),
+                        (LedCode::N2, "regular".to_owned()),
-                    (LedCode::N0, "regular".to_owned()),
+                        (LedCode::N3, "regular".to_owned()),
-                    (LedCode::Hyphen, "regular".to_owned()),
+                        (LedCode::N4, "regular".to_owned()),
-                    (LedCode::Equals, "regular".to_owned()),
+                        (LedCode::N5, "regular".to_owned()),
-                    (LedCode::Backspace, "regular".to_owned()),
+                        (LedCode::N6, "regular".to_owned()),
-                ]),
+                        (LedCode::N7, "regular".to_owned()),
-                KeyRow::new(0.1, 0.1, vec![
+                        (LedCode::N8, "regular".to_owned()),
-                    (LedCode::Tab, "regular".to_owned()),
+                        (LedCode::N9, "regular".to_owned()),
-                    (LedCode::Q, "regular".to_owned()),
+                        (LedCode::N0, "regular".to_owned()),
-                    (LedCode::W, "regular".to_owned()),
+                        (LedCode::Hyphen, "regular".to_owned()),
-                    (LedCode::E, "regular".to_owned()),
+                        (LedCode::Equals, "regular".to_owned()),
-                    (LedCode::R, "regular".to_owned()),
+                        (LedCode::Backspace, "regular".to_owned()),
-                    (LedCode::T, "regular".to_owned()),
+                    ],
-                    (LedCode::Y, "regular".to_owned()),
+                ),
-                    (LedCode::U, "regular".to_owned()),
+                KeyRow::new(
-                    (LedCode::I, "regular".to_owned()),
+                    0.1,
-                    (LedCode::O, "regular".to_owned()),
+                    0.1,
-                    (LedCode::P, "regular".to_owned()),
+                    vec![
-                    (LedCode::LBracket, "regular".to_owned()),
+                        (LedCode::Tab, "regular".to_owned()),
-                    (LedCode::RBracket, "regular".to_owned()),
+                        (LedCode::Q, "regular".to_owned()),
-                    (LedCode::BackSlash, "regular".to_owned()),
+                        (LedCode::W, "regular".to_owned()),
-                ]),
+                        (LedCode::E, "regular".to_owned()),
-                KeyRow::new(0.1, 0.1, vec![
+                        (LedCode::R, "regular".to_owned()),
-                    (LedCode::Caps, "regular".to_owned()),
+                        (LedCode::T, "regular".to_owned()),
-                    (LedCode::A, "regular".to_owned()),
+                        (LedCode::Y, "regular".to_owned()),
-                    (LedCode::S, "regular".to_owned()),
+                        (LedCode::U, "regular".to_owned()),
-                    (LedCode::D, "regular".to_owned()),
+                        (LedCode::I, "regular".to_owned()),
-                    (LedCode::F, "regular".to_owned()),
+                        (LedCode::O, "regular".to_owned()),
-                    (LedCode::G, "regular".to_owned()),
+                        (LedCode::P, "regular".to_owned()),
-                    (LedCode::H, "regular".to_owned()),
+                        (LedCode::LBracket, "regular".to_owned()),
-                    (LedCode::J, "regular".to_owned()),
+                        (LedCode::RBracket, "regular".to_owned()),
-                    (LedCode::K, "regular".to_owned()),
+                        (LedCode::BackSlash, "regular".to_owned()),
-                    (LedCode::L, "regular".to_owned()),
+                    ],
-                    (LedCode::SemiColon, "regular".to_owned()),
+                ),
-                    (LedCode::Quote, "regular".to_owned()),
+                KeyRow::new(
-                    (LedCode::Return, "regular".to_owned()),
+                    0.1,
-                ]),
+                    0.1,
-                KeyRow::new(0.1, 0.1, vec![
+                    vec![
-                    (LedCode::LShift, "regular".to_owned()),
+                        (LedCode::Caps, "regular".to_owned()),
-                    (LedCode::Z, "regular".to_owned()),
+                        (LedCode::A, "regular".to_owned()),
-                    (LedCode::X, "regular".to_owned()),
+                        (LedCode::S, "regular".to_owned()),
-                    (LedCode::C, "regular".to_owned()),
+                        (LedCode::D, "regular".to_owned()),
-                    (LedCode::V, "regular".to_owned()),
+                        (LedCode::F, "regular".to_owned()),
-                    (LedCode::B, "regular".to_owned()),
+                        (LedCode::G, "regular".to_owned()),
-                    (LedCode::N, "regular".to_owned()),
+                        (LedCode::H, "regular".to_owned()),
-                    (LedCode::M, "regular".to_owned()),
+                        (LedCode::J, "regular".to_owned()),
-                    (LedCode::Comma, "regular".to_owned()),
+                        (LedCode::K, "regular".to_owned()),
-                    (LedCode::Period, "regular".to_owned()),
+                        (LedCode::L, "regular".to_owned()),
-                    (LedCode::FwdSlash, "regular".to_owned()),
+                        (LedCode::SemiColon, "regular".to_owned()),
-                    (LedCode::Rshift, "regular".to_owned()),
+                        (LedCode::Quote, "regular".to_owned()),
-                ]),
+                        (LedCode::Return, "regular".to_owned()),
-                KeyRow::new(0.1, 0.1, vec![
+                    ],
-                    (LedCode::LCtrl, "regular".to_owned()),
+                ),
-                    (LedCode::LFn, "regular".to_owned()),
+                KeyRow::new(
-                    (LedCode::Meta, "regular".to_owned()),
+                    0.1,
-                    (LedCode::LAlt, "regular".to_owned()),
+                    0.1,
-                    (LedCode::Spacebar, "regular".to_owned()),
+                    vec![
-                    (LedCode::RAlt, "regular".to_owned()),
+                        (LedCode::LShift, "regular".to_owned()),
-                    (LedCode::PrtSc, "regular".to_owned()),
+                        (LedCode::Z, "regular".to_owned()),
-                    (LedCode::RCtrl, "regular".to_owned()),
+                        (LedCode::X, "regular".to_owned()),
-                ]),
+                        (LedCode::C, "regular".to_owned()),
+                        (LedCode::V, "regular".to_owned()),
+                        (LedCode::B, "regular".to_owned()),
+                        (LedCode::N, "regular".to_owned()),
+                        (LedCode::M, "regular".to_owned()),
+                        (LedCode::Comma, "regular".to_owned()),
+                        (LedCode::Period, "regular".to_owned()),
+                        (LedCode::FwdSlash, "regular".to_owned()),
+                        (LedCode::Rshift, "regular".to_owned()),
+                    ],
+                ),
+                KeyRow::new(
+                    0.1,
+                    0.1,
+                    vec![
+                        (LedCode::LCtrl, "regular".to_owned()),
+                        (LedCode::LFn, "regular".to_owned()),
+                        (LedCode::Meta, "regular".to_owned()),
+                        (LedCode::LAlt, "regular".to_owned()),
+                        (LedCode::Spacebar, "regular".to_owned()),
+                        (LedCode::RAlt, "regular".to_owned()),
+                        (LedCode::PrtSc, "regular".to_owned()),
+                        (LedCode::RCtrl, "regular".to_owned()),
+                    ],
+                ),
             ],
         }
     }

rog-platform/src/cpu.rs

@@ -267,18 +267,24 @@ mod tests {
     fn check_cpu() {
         let cpu = CPUControl::new().unwrap();
         assert_eq!(cpu.get_governor().unwrap(), CPUGovernor::Powersave);
-        assert_eq!(cpu.get_available_governors().unwrap(), vec![
+        assert_eq!(
-            CPUGovernor::Performance,
+            cpu.get_available_governors().unwrap(),
-            CPUGovernor::Powersave
+            vec![
-        ]);
+                CPUGovernor::Performance,
+                CPUGovernor::Powersave
+            ]
+        );
 
         assert_eq!(cpu.get_epp().unwrap(), CPUEPP::BalancePower);
-        assert_eq!(cpu.get_available_epp().unwrap(), vec![
+        assert_eq!(
-            CPUEPP::Default,
+            cpu.get_available_epp().unwrap(),
-            CPUEPP::Performance,
+            vec![
-            CPUEPP::BalancePerformance,
+                CPUEPP::Default,
-            CPUEPP::BalancePower,
+                CPUEPP::Performance,
-            CPUEPP::Power,
+                CPUEPP::BalancePerformance,
-        ]);
+                CPUEPP::BalancePower,
+                CPUEPP::Power,
+            ]
+        );
     }
 }

simulators/src/simulator.rs

@@ -158,7 +158,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                     canvas.set_draw_color(Color::RGB(*b, *b, *b));
 
                     let x: i32 = w + x_count as i32 * w
-                        - if !(y_count + y_offset as usize).is_multiple_of(2) {
+                        - if !((y_count + y_offset as usize) % 2 == 0) {
                             0
                         } else {
                             w / 2