Fix slash enable

asusd/src/aura_slash/config.rs

@@ -18,6 +18,7 @@ pub struct SlashConfig {
     pub show_on_sleep: bool,
     pub show_on_battery: bool,
     pub show_battery_warning: bool,
+    pub show_on_lid_closed: bool,
 }
 
 impl Default for SlashConfig {
@@ -33,6 +34,7 @@ impl Default for SlashConfig {
             show_on_sleep: true,
             show_on_battery: true,
             show_battery_warning: true,
+            show_on_lid_closed: true,
         }
     }
 }

asusd/src/aura_slash/mod.rs

@@ -4,8 +4,7 @@ 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::{get_options_packet, pkt_set_mode, pkts_for_init};
-use rog_slash::SlashType;
+use rog_slash::usb::{slash_pkt_enable, slash_pkt_init, slash_pkt_options, slash_pkt_set_mode};
 
 use crate::error::RogError;
 
@@ -46,14 +45,14 @@ impl Slash {
     pub async fn do_initialization(&self) -> Result<(), RogError> {
         // Don't try to initialise these models as the asus drivers already did
         let config = self.config.lock().await;
-        if !matches!(config.slash_type, SlashType::GA605 | SlashType::GU605) {
-            for pkt in &pkts_for_init(config.slash_type) {
-                self.write_bytes(pkt).await?;
-            }
+        for pkt in &slash_pkt_init(config.slash_type) {
+            self.write_bytes(pkt).await?;
         }
+        self.write_bytes(&slash_pkt_enable(config.slash_type, config.enabled))
+            .await?;
 
         // Apply config upon initialization
-        let option_packets = get_options_packet(
+        let option_packets = slash_pkt_options(
             config.slash_type,
             config.enabled,
             config.brightness,
@@ -61,7 +60,7 @@ impl Slash {
         );
         self.write_bytes(&option_packets).await?;
 
-        let mode_packets = pkt_set_mode(config.slash_type, config.display_mode);
+        let mode_packets = slash_pkt_set_mode(config.slash_type, config.display_mode);
         // self.node.write_bytes(&mode_packets[0])?;
         self.write_bytes(&mode_packets[1]).await?;
 

asusd/src/aura_slash/trait_impls.rs

@@ -1,8 +1,9 @@
 use config_traits::StdConfig;
 use log::{debug, error, warn};
 use rog_slash::usb::{
-    get_battery_saver_packet, get_boot_packet, get_low_battery_packet, get_options_packet,
-    get_shutdown_packet, get_sleep_packet, pkt_save, pkt_set_mode,
+    slash_pkt_battery_saver, slash_pkt_boot, slash_pkt_enable, slash_pkt_lid_closed,
+    slash_pkt_low_battery, slash_pkt_options, slash_pkt_save, slash_pkt_set_mode,
+    slash_pkt_shutdown, slash_pkt_sleep,
 };
 use rog_slash::{DeviceState, SlashMode};
 use zbus::zvariant::OwnedObjectPath;
@@ -58,7 +59,14 @@ impl SlashZbus {
             config.brightness
         };
         self.0
-            .write_bytes(&get_options_packet(
+            .write_bytes(&slash_pkt_enable(config.slash_type, enabled))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::enable {}", err);
+            })
+            .ok();
+        self.0
+            .write_bytes(&slash_pkt_options(
                 config.slash_type,
                 enabled,
                 brightness,
@@ -88,7 +96,7 @@ impl SlashZbus {
         let mut config = self.0.lock_config().await;
         let enabled = brightness > 0;
         self.0
-            .write_bytes(&get_options_packet(
+            .write_bytes(&slash_pkt_options(
                 config.slash_type,
                 enabled,
                 brightness,
@@ -116,7 +124,7 @@ impl SlashZbus {
     async fn set_interval(&self, interval: u8) {
         let mut config = self.0.lock_config().await;
         self.0
-            .write_bytes(&get_options_packet(
+            .write_bytes(&slash_pkt_options(
                 config.slash_type, config.enabled, config.brightness, interval,
             ))
             .await
@@ -140,10 +148,12 @@ impl SlashZbus {
     async fn set_mode(&self, mode: SlashMode) -> zbus::Result<()> {
         let mut config = self.0.lock_config().await;
 
-        let command_packets = pkt_set_mode(config.slash_type, mode);
+        let command_packets = slash_pkt_set_mode(config.slash_type, mode);
         // self.node.write_bytes(&command_packets[0])?;
         self.0.write_bytes(&command_packets[1]).await?;
-        self.0.write_bytes(&pkt_save(config.slash_type)).await?;
+        self.0
+            .write_bytes(&slash_pkt_save(config.slash_type))
+            .await?;
 
         config.display_mode = mode;
         config.write();
@@ -167,7 +177,7 @@ impl SlashZbus {
     async fn set_show_on_boot(&self, enable: bool) -> zbus::Result<()> {
         let mut config = self.0.lock_config().await;
         self.0
-            .write_bytes(&get_boot_packet(config.slash_type, enable))
+            .write_bytes(&slash_pkt_boot(config.slash_type, enable))
             .await?;
         config.show_on_boot = enable;
         config.write();
@@ -184,7 +194,7 @@ impl SlashZbus {
     async fn set_show_on_sleep(&self, enable: bool) -> zbus::Result<()> {
         let mut config = self.0.lock_config().await;
         self.0
-            .write_bytes(&get_sleep_packet(config.slash_type, enable))
+            .write_bytes(&slash_pkt_sleep(config.slash_type, enable))
             .await?;
         config.show_on_sleep = enable;
         config.write();
@@ -201,7 +211,7 @@ impl SlashZbus {
     async fn set_show_on_shutdown(&self, enable: bool) -> zbus::Result<()> {
         let mut config = self.0.lock_config().await;
         self.0
-            .write_bytes(&get_shutdown_packet(config.slash_type, enable))
+            .write_bytes(&slash_pkt_shutdown(config.slash_type, enable))
             .await?;
         config.show_on_shutdown = enable;
         config.write();
@@ -218,7 +228,7 @@ impl SlashZbus {
     async fn set_show_on_battery(&self, enable: bool) -> zbus::Result<()> {
         let mut config = self.0.lock_config().await;
         self.0
-            .write_bytes(&get_battery_saver_packet(config.slash_type, enable))
+            .write_bytes(&slash_pkt_battery_saver(config.slash_type, enable))
             .await?;
         config.show_on_battery = enable;
         config.write();
@@ -235,12 +245,32 @@ impl SlashZbus {
     async fn set_show_battery_warning(&self, enable: bool) -> zbus::Result<()> {
         let mut config = self.0.lock_config().await;
         self.0
-            .write_bytes(&get_low_battery_packet(config.slash_type, enable))
+            .write_bytes(&slash_pkt_low_battery(config.slash_type, enable))
             .await?;
         config.show_battery_warning = enable;
         config.write();
         Ok(())
     }
+
+    #[zbus(property)]
+    async fn show_on_lid_closed(&self) -> zbus::fdo::Result<bool> {
+        let config = self.0.lock_config().await;
+        Ok(config.show_on_lid_closed)
+    }
+
+    #[zbus(property)]
+    async fn set_show_on_lid_closed(&self, enable: bool) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_lid_closed(config.slash_type, enable))
+            .await?;
+        self.0
+            .write_bytes(&slash_pkt_save(config.slash_type))
+            .await?;
+        config.show_on_lid_closed = enable;
+        config.write();
+        Ok(())
+    }
 }
 
 impl Reloadable for SlashZbus {
@@ -248,7 +278,7 @@ impl Reloadable for SlashZbus {
         debug!("reloading slash settings");
         let config = self.0.lock_config().await;
         self.0
-            .write_bytes(&get_options_packet(
+            .write_bytes(&slash_pkt_options(
                 config.slash_type,
                 config.enabled,
                 config.brightness,
@@ -272,12 +302,12 @@ impl Reloadable for SlashZbus {
             };
         }
 
-        write_bytes_with_warning!(get_boot_packet, show_on_boot, "show_on_boot");
-        write_bytes_with_warning!(get_sleep_packet, show_on_sleep, "show_on_sleep");
-        write_bytes_with_warning!(get_shutdown_packet, show_on_shutdown, "show_on_shutdown");
-        write_bytes_with_warning!(get_battery_saver_packet, show_on_battery, "show_on_battery");
+        write_bytes_with_warning!(slash_pkt_boot, show_on_boot, "show_on_boot");
+        write_bytes_with_warning!(slash_pkt_sleep, show_on_sleep, "show_on_sleep");
+        write_bytes_with_warning!(slash_pkt_shutdown, show_on_shutdown, "show_on_shutdown");
+        write_bytes_with_warning!(slash_pkt_battery_saver, show_on_battery, "show_on_battery");
         write_bytes_with_warning!(
-            get_low_battery_packet,
+            slash_pkt_low_battery,
             show_battery_warning,
             "show_battery_warning"
         );