Update changelog

Combination for power state leds boot/sleep/all/keys/side LEDS

Closes #191

See merge request asus-linux/asusctl!111

.gitignore

@@ -4,3 +4,4 @@ cargo-config
 .idea
 vendor-*
 vendor_*
+.vscode-ctags

CHANGELOG.md

@@ -4,7 +4,107 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [Unreleased ]
+
+## [4.1.0] - 2022-06-20
+### Changed
+- Huge refactor to use zbus 2.2 + zvariant 3.0 in system-daemon.
+- Daemons with tasks now use `smol` for async ops.
+- Fixes to fan-curve settings from CLI (Author: Armas Span)
+- Add brightness to anime zbus notification
+- Adjust how threads in AniMe matrix controller work
+- Use proper power-state packet for keyboard LED's (Author: Martin Piffault)
+### Added
+- Support for GA402R LED modes
+- Support for GU502LV LED modes
+- Support for G512 LED modes
+- Support for G513IC LED modes (Author: dada513)
+- Support for G513QM LED modes (Author: Martin Piffault)
+- Add side-LED toggle support (Author: Martin Piffault)
+- Support reloading keyboard mode on wake (from sleep/hiber)
+- Support reloading charge-level on wake (from sleep/hiber)
+- Support running AniMe animation blocks on wake/sleep and boot/shutdown events
+
+# [4.0.7] - 2021-12-19
+### Changed
+- Fix incorrect power-profile validation
+- Update asusd-ledmodes.toml to support Asus Rog Strix G15 G513QE (@LordVicky)
+- Update patch notes and links
+
+# [4.0.6] - 2021-11-01
+### Changed
+- Fix CLI for bios toggles
+### Added
+- Extra commands for AniMe: pixel-image, gif, pixel-gif
+
+# [4.0.5] - 2021-10-27
+### Changed
+- Convert fan curve percentage to 0-255 expected by kernel driver only if '%' char is used, otherwise the expected range for fan power is 0-255
+- Use correct error in daemon for invalid charging limit
+- Enforce charging limit values in range 20-100
+### Added
+- LED modes for G513QR
+
+# [4.0.4] - 2021-10-02
+### Changed
+- Add missing Profile commands
+- Spawn tasks on individual threads to prevent blocking
+- Don't force fan-curve default on reload
+- Begin obsoleting the graphics switch command in favour of supergfxctl
+- Slim down the notification daemon to pure ASUS notifications
+
+# [4.0.3] - 2021-09-16
+### Changed
+- Don't show fan-curve warning if fan-curve available
+- Add G713QR to Strix led-modes
+- Fix part of CLI fan-curve control
+
+# [4.0.2] - 2021-09-14
+### Changed
+- Backup old configs to *-old if parse fails
+- Prevent some types of crashes related to unpatched kernels
+- Add better help for graphics errors
+- Add better help for asusctl general errors
+- Implement fan-curve dbus API
+- Implement partial fan-curve control via CLI tool
+  + Set fan curve for profile + fan gpu/cpu
+
+# [4.0.1] - 2021-09-11
+### Changed
+- Fix asusd-ledmodes.toml
+
+# [4.0.0] - 2021-09-10
+### Added
+- AniMe:
+  + Support 8bit RGB, RGBA, 16bit Greyscalw, RGB, RGBA
+  + add `AsusImage` type for slanted-template pixel-perfect images
+  + `BREAKING:` plain `Image` with time period is changed and old anime configs break as a result (sorry)
+- LED:
+  + By popular request LED prev/next cycle is added
+  + Add led modes for GX551Q
+### BREAKING CHANGES
+- Graphics control:
+  + graphics control is pulled out of asusd and moved to new package; https://gitlab.com/asus-linux/supergfxctl
+- Proflies:
+  + profiles now depend on power-profile-daemon plus kernel patches for support of platform_profile
+    - if your system supports fan-curves you will also require upcoming kernel patches for this
+  + profiles are now moved to a new file
+  + fan-curves are only partially completed due to this release needing to be done sooner
+
+# [3.7.2] - 2021-08-02
+### Added
+- Enable multizone support on Strix 513IH
+- Add G513QY ledmodes
+### Changed
+- Fix missing CLI command help for some supported options
+- Fix incorrectly selecting profile by name, where the active profile was being copied to the selected profile
+- Add `asusd` version back to `asusctl -v` report
+- Fix various clippy warnings
+
+# [3.7.1] - 2021-06-11
+### Changed
+- Refine graphics mode switching:
+  + Disallow switching to compute or vfio mode unless existing mode is "Integrated"
 
 # [3.7.0] - 2021-06-06
 ### Changed

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-types", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles"]
+members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-supported", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles"]
 
 [profile.release]
 lto = true
@@ -13,4 +13,4 @@ opt-level = 1
 
 [profile.bench]
 debug = false
-opt-level = 3
+opt-level = 3

MANUAL.md

@@ -16,57 +16,15 @@ but can also be used with non-asus laptops with reduced features.
 
 The functionality that `asusd` exposes is:
 
-- graphics switching
 - anime control
 - led keyboard control (aura)
 - charge limiting
 - bios/efivar control
-- profiles (fan/cpu)
+- power profile switching
+- fan curves (if supported, this is auto-detected)
 
 each of these will be detailed in sections.
 
-### Graphics switching
-
-`asusd` can switch graphics modes between:
-- `integrated`, uses the iGPU only and force-disables the dGPU
-- `compute`, enables Nvidia without Xorg. Useful for ML/Cuda
-- `hybrid`, enables Nvidia prime-offload mode
-- `nvidia`, uses the Nvidia gpu only
-- `vfio`, binds the Nvidia gpu to vfio for VM pass-through
-
-Switching to/from Hybrid and Nvidia modes requires a logout only (no reboot). Switching between integrated/compute/vfio does not require a logout and is instant.
-
-#### Required actions in distro
-
-**Rebootless note:** You must edit `/etc/default/grub` to remove `nvidia-drm.modeset=1`
-from the line `GRUB_CMDLINE_LINUX=` and then recreate your grub config. In fedora
-you can do this with `sudo grub2-mkconfig -o /etc/grub2.cfg` - other distro may be
-similar but with a different config location. It's possible that graphics driver updates
-may change this.
-
-This switcher conflicts with other gpu switchers like optimus-manager, suse-prime
-or ubuntu-prime, system76-power, and bbswitch. If you have issues with `asusd`
-always defaulting to `integrated` mode on boot then you will need to check for
-stray configs blocking nvidia modules from loading in:
-- `/etc/modprobe.d/`
-- `/usr/lib/modprope.d/`
-
-#### Config options
-
-1. `"gfx_mode": "<MODE>",`: MODE can be <Integrated, Hybrid, Compute, Nvidia, vfio>
-2. `"gfx_last_mode": "Nvidia",`: currently unused
-3. `"gfx_managed": true,`: enable or disable graphics switching controller
-4. `"gfx_vfio_enable": false,`: enable vfio switching for Nvidia GPU passthrough
-5. `"gfx_save_compute_vfio": false,`: wether or not to save the vfio state (so it sticks between boots)
-
-#### Graphics switching notes
-
-**G-Sync note:** Some laptops are capable of using the dGPU as the sole GPU in the system which is generally to enable g-sync on the laptop display panel. This is controlled by the bios/efivar control and will be covered in that section.
-
-**vfio note:** The vfio modules *must not* be compiled into the kernel, they need
-to be separate modules. If you don't plan to use vfio mode then you can ignore this
-otherwise you may need a custom built kernel.
-
 ### AniMe control
 
 Controller for the fancy AniMe matrix display on the lid of some machines. This controller is a work in progress.
@@ -139,55 +97,27 @@ These options are not written to the config file as they are stored in efivars.
 
 ### Profiles
 
-Profiles provide a method setting up various basic CPU and fan settings in profile blocks which can then be switched between or cycled through. The CPU controls so far are:
+asusctl can support setting a power profile via platform_profile drivers. This requires [power-profiles-daemon](https://gitlab.freedesktop.org/hadess/power-profiles-daemon) v0.10.0 minimum. It also requires the kernel patch for platform_profile support to be applied form [here](https://lkml.org/lkml/2021/8/18/1022) - this patch is merged to 5.15 kernel upstream.
 
-- Min/Max percentage of CPU frequency (Intel only for now)
-- CPU turbo boost enable or disable
-- Fan presets. These are 0: Normal, 1: Boost, 2: Silent.
-- Fan curves, override fan-preset. AMD only.
-
-#### Config options
-
-Example:
-```json
-  "toggle_profiles": [
-    "normal",
-    "boost",
-    "silent"
-  ],
-  "power_profiles": {
-    "boost": {
-      "min_percentage": 0,
-      "max_percentage": 100,
-      "turbo": true,
-      "fan_preset": 1,
-      "fan_curve": null
-    },
-    "normal": {
-      "min_percentage": 0,
-      "max_percentage": 100,
-      "turbo": true,
-      "fan_preset": 0,
-      "fan_curve": null
-    },
-    "silent": {
-      "min_percentage": 0,
-      "max_percentage": 100,
-      "turbo": true,
-      "fan_preset": 2,
-      "fan_curve": null
-    }
-  }
-```
-
-1. `"toggle_profiles": [],`: these are the profile names that will be cycled through when using a provided next/prev dbus method.
-2. `"power_profiles": {}`: all the available profiles.
+A common use of asusctl is to bind the `fn+f5` (fan) key to `asusctl profile -n` to cycle through the 3 profiles:
+1. Balanced
+2. Performance
+3. Quiet
 
 #### Fan curves
 
-**fan_curve note:** This is a WIP. Currently it relies on `acpi_call` kernel module which is ancient and hacky, not intended for this purpose. A proper kernel driver is in progress.
+Fan curve support requires a laptop that supports it (this is detected automatically) and the kernel patch from [here](https://lkml.org/lkml/2021/10/23/250) which is accepted for the 5.17 kernel release .
 
-See [this document](https://github.com/cronosun/atrofac/blob/master/ADVANCED.md#limits) for details on the string format required, e.g, `"fan_curve": "30c:0%,40c:5%,50c:10%,60c:20%,70c:35%,80c:55%,90c:65%,100c:65%"`.
+The fan curve format can be of varying formats:
+
+- `30c:0%,40c:5%,50c:10%,60c:20%,70c:35%,80c:55%,90c:65%,100c:65%"`
+- `30:0,40:5,50:10,60:20,70:35,80:55,90:65,100:65"`
+- `30 0,40 5,50 10,60 20,70 35,80 55,90 65,100 65"`
+- `30 0 40 5 50 10 60 20 70 35 80 55 90 65 100 65"`
+
+the order must always be the same "temperature:percentage", lowest from left to rigth being highest.
+
+The config file is located at `/etc/asusd/profile.conf` and is self-descriptive. On first run it is populated with the system EC defaults.
 
 ### Support controller
 
@@ -236,6 +166,18 @@ Each object in the array can be one of:
       }
 ```
 
+##### AsusImage
+
+Virtually the same as `AsusAnimation` but for png files, typically created in the same "slanted" style using a template (`diagonal-template.png`) as the ASUS gifs for pixel perfection.
+
+```json
+      "AsusImage": {
+        "file": "<FILE_PATH>",
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+```
+
 ##### ImageAnimation
 
 `ImageAnimation` can play *any* gif of any size.
@@ -319,7 +261,7 @@ A cycle is how many gif loops to run:
           "Cycles": 2
         },
 ```
-`Infinite` means that this gif will never end: 
+`Infinite` means that this gif will never end:
 ```json
         "time": "Infinite",
 ```
@@ -414,4 +356,4 @@ Reference to any ASUS products, services, processes, or other information and/or
 
 The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
 
----
+---

Makefile

@@ -16,8 +16,6 @@ BIN_D := asusd
 BIN_U := asusd-user
 BIN_N := asus-notify
 LEDCFG := asusd-ledmodes.toml
-X11CFG := 90-nvidia-screen-G05.conf
-PMRULES := 90-asusd-nvidia-pm.rules
 
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
@@ -45,35 +43,48 @@ install:
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_N)" "$(DESTDIR)$(bindir)/$(BIN_N)"
-	$(INSTALL_DATA) "./data/$(PMRULES)" "$(DESTDIR)$(libdir)/udev/rules.d/$(PMRULES)"
+
 	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
 	$(INSTALL_DATA) "./data/$(LEDCFG)" "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
-	$(INSTALL_DATA) "./data/$(X11CFG)" "$(DESTDIR)$(datarootdir)/X11/xorg.conf.d/$(X11CFG)"
+
 	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
 	$(INSTALL_DATA) "./data/$(BIN_N).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_N).service"
 	$(INSTALL_DATA) "./data/$(BIN_U).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_U).service"
+
 	$(INSTALL_DATA) "./data/icons/asus_notif_yellow.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_green.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_red.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
+
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-compute.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-hybrid.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-integrated.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-nvidia.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-vfio.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/notification-reboot.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
+
 	$(INSTALL_DATA) "./data/_asusctl" "$(DESTDIR)$(zshcpl)/_asusctl"
 	$(INSTALL_DATA) "./data/completions/asusctl.fish" "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
-	cd data && find "./anime" -type f -exec install -Dm 755 "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
+	cd rog-anime/data && find "./anime" -type f -exec install -Dm 755 "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
 
 uninstall:
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_C)"
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_D)"
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_N)"
-	rm -f "$(DESTDIR)$(libdir)/udev/rules.d/$(PMRULES)"
 	rm -f "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
 	rm -f "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	rm -f "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
-	rm -f "$(DESTDIR)$(datarootdir)/X11/xorg.conf.d/$(X11CFG)"
 	rm -f "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
 	rm -r "$(DESTDIR)$(libdir)/systemd/user/$(BIN_N).service"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
 	rm -f "$(DESTDIR)$(zshcpl)/_asusctl"
 	rm -f "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
 	rm -rf "$(DESTDIR)$(datarootdir)/asusd"

README.md

@@ -5,6 +5,12 @@
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.
 
+## Kernel support
+
+**The minimum supported kernel version is 5.15**
+
+Fan curve control on laptops with this feature require [this patch](https://lkml.org/lkml/2021/10/23/250) which has been merged for 5.17 upstream.
+
 ## Goals
 
 1. To provide an interface for rootless control of some system functions most users wish to control such as fan speeds, keyboard LEDs, graphics modes.
@@ -19,13 +25,9 @@ supported (while asusd might still run fine on them). For best support use fedor
 Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
 a system-level daemon should.
 
-**NOTICE:**
-
-Various patches are required for keyboard support. See [this post](https://asus-linux.org/blog/updates-2021-05-06/) for details on status and which kernels will have which patches.
-
 ## Discord
 
-[Discord server link](https://discord.gg/ngbdKabAnP)
+[Discord server link](https://discord.gg/4ZKGd7Un5t)
 
 ## SUPPORTED LAPTOPS
 
@@ -48,30 +50,35 @@ will probably suffer another rename once it becomes generic enough to do so.
 - [X] Per-key LED setting
 - [X] Fancy LED modes (See examples) (currently being reworked)
 - [X] Saving settings for reload
-- [X] Logging - required for journalctl
-- [X] AniMatrix display on G14 models that include it (currently being reworked)
+- [X] AniMatrix display on G14 models that include it
 - [X] Set battery charge limit (with kernel supporting this)
-- [X] Fan curve control on G14 + G15 thanks to @Yarn1
-- [X] Graphics mode switching between iGPU, dGPU, on-demand, and vfio (for VM pass-through)
-  + [X] Requires only a logout/login
+- [X] Fan curve control on G14 + G15. Requires kernel patch (should reach 5.15 kernel)
 - [X] Toggle bios setting for boot/POST sound
 - [X] Toggle bios setting for "dedicated gfx" mode on supported laptops (g-sync)
 
 # BUILDING
 
-Requirements are rust >= 1.47 installed from rustup.io if the distro provided version is too old, and `make`.
+Requirements are rust >= 1.57 installed from rustup.io if the distro provided version is too old, and `make`.
 
-**Ubuntu*:** `apt install libclang-dev libudev-dev`
+**Ubuntu (unsuported):**
 
-**fedora:** `dnf install clang-devel systemd-devel`
+    apt install libclang-dev libudev-dev
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    make
+    sudo make install
+
+**fedora:**
+
+    dnf install clang-devel systemd-devel
+    make
+    sudo make install
 
 ## Installing
+- Fedora copr = https://copr.fedorainfracloud.org/coprs/lukenukem/asus-linux/
+- openSUSE = https://download.opensuse.org/repositories/home:/luke_nukem:/asus/
+- Ubuntu = not supported due to packaging woes, but you can build and install on your own.
 
-Download repositories are available [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/) for the latest versions of Fedora, Ubuntu, and openSUSE.
-
----
-
-Run `make` then `sudo make install` then reboot.
+=======
 
 The default init method is to use the udev rule, this ensures that the service is
 started when the device is initialised and ready.
@@ -84,11 +91,6 @@ $ systemctl daemon-reload && systemctl restart asusd
 
 You may also need to activate the service for debian install. If running Pop!_OS, I suggest disabling `system76-power` gnome-shell extension and systemd service.
 
-If you would like to run this daemon on another non-ASUS laptop you can. You'll
-have all features available except the LED and AniMe control (further controllers
-can be added on request). You will need to install the alternative service from
-`data/asusd-alt.service`.
-
 ## Uninstalling
 
 Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
@@ -111,4 +113,4 @@ Reference to any ASUS products, services, processes, or other information and/or
 
 The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
 
----
+---

asus-notify/Cargo.toml

@@ -1,20 +1,22 @@
 [package]
 name = "asus-notify"
-version = "3.0.1"
+version = "3.1.0"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+zbus = "^2.2"
 # serialisation
 serde_json = "^1.0"
 rog_dbus = { path = "../rog-dbus" }
 rog_aura = { path = "../rog-aura" }
-rog_types = { path = "../rog-types" }
+rog_supported = { path = "../rog-supported" }
 rog_profiles = { path = "../rog-profiles" }
+smol = "^1.2"
 
 [dependencies.notify-rust]
 version = "^4.3"
 default-features = false
-features = ["z"]
+features = ["z"]

asus-notify/src/main.rs

@@ -1,11 +1,16 @@
 use notify_rust::{Hint, Notification, NotificationHandle};
 use rog_aura::AuraEffect;
-use rog_dbus::{DbusProxies, Signals};
-use rog_profiles::profiles::{FanLevel, Profile};
-use rog_types::gfx_vendors::GfxVendors;
-use std::error::Error;
-use std::thread::sleep;
-use std::time::Duration;
+use rog_dbus::{
+    zbus_charge::ChargeProxy, zbus_led::LedProxy, zbus_profile::ProfileProxy,
+    zbus_rogbios::RogBiosProxy,
+};
+use rog_profiles::Profile;
+use smol::{future, Executor};
+use std::{
+    error::Error,
+    sync::{Arc, Mutex},
+};
+use zbus::export::futures_util::StreamExt;
 
 const NOTIF_HEADER: &str = "ROG Control";
 
@@ -15,77 +20,11 @@ macro_rules! notify {
             notif.close();
         }
         if let Ok(x) = $notifier($data) {
-            $last_notif = Some(x);
+            $last_notif.replace(x);
         }
     };
 }
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("asus-notify version {}", env!("CARGO_PKG_VERSION"));
-    println!("   rog-dbus version {}", rog_dbus::VERSION);
-
-    let (proxies, conn) = DbusProxies::new()?;
-    let signals = Signals::new(&proxies)?;
-
-    let mut last_notification: Option<NotificationHandle> = None;
-
-    let recv = proxies.setup_recv(conn);
-    let mut err_count = 0;
-    loop {
-        sleep(Duration::from_millis(100));
-        if let Err(err) = recv.next_signal() {
-            if err_count < 3 {
-                err_count += 1;
-                println!("{}", err);
-            }
-            if err_count == 3 {
-                err_count += 1;
-                println!("Max error count reached. Spooling silently.");
-            }
-            sleep(Duration::from_millis(2000));
-            continue;
-        }
-        err_count = 0;
-
-        if let Ok(data) = signals.led_mode.try_recv() {
-            notify!(do_led_notif, last_notification, &data);
-        }
-        if let Ok(data) = signals.profile.try_recv() {
-            notify!(do_thermal_notif, last_notification, &data);
-        }
-        if let Ok(data) = signals.charge.try_recv() {
-            notify!(do_charge_notif, last_notification, &data);
-        }
-        if let Ok(data) = signals.gfx_vendor.try_recv() {
-            notify!(do_gfx_notif, last_notification, &data);
-        }
-    }
-}
-
-fn do_thermal_notif(profile: &Profile) -> Result<NotificationHandle, Box<dyn Error>> {
-    let fan = profile.fan_preset;
-    let turbo = if profile.turbo { "enabled" } else { "disabled" };
-    let icon = match fan {
-        FanLevel::Normal => "asus_notif_yellow",
-        FanLevel::Boost => "asus_notif_red",
-        FanLevel::Silent => "asus_notif_green",
-    };
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(&format!(
-            "Thermal profile changed to {}, turbo {}",
-            profile.name.to_uppercase(),
-            turbo
-        ))
-        .hint(Hint::Resident(true))
-        .timeout(2000)
-        .hint(Hint::Category("device".into()))
-        //.hint(Hint::Transient(true))
-        .icon(icon)
-        .show()?;
-    Ok(x)
-}
-
 macro_rules! base_notification {
     ($body:expr) => {
         Notification::new()
@@ -96,6 +35,121 @@ macro_rules! base_notification {
     };
 }
 
+type SharedHandle = Arc<Mutex<Option<NotificationHandle>>>;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("asus-notify version {}", env!("CARGO_PKG_VERSION"));
+    println!("   rog-dbus version {}", rog_dbus::VERSION);
+
+    let last_notification: SharedHandle = Arc::new(Mutex::new(None));
+
+    let executor = Executor::new();
+    // BIOS notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = RogBiosProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_post_boot_sound().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_post_sound_notif, lock, &out.sound());
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    // Charge notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = ChargeProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_charge().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_charge_notif, lock, &out.limit);
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    // Profile notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = ProfileProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_profile().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_thermal_notif, lock, &out.profile);
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    // LED notif
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = LedProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_led().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = last_notification.try_lock() {
+                            notify!(do_led_notif, lock, &out.data);
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    loop {
+        smol::block_on(executor.tick());
+    }
+}
+
+fn do_thermal_notif(profile: &Profile) -> Result<NotificationHandle, Box<dyn Error>> {
+    let icon = match profile {
+        Profile::Balanced => "asus_notif_yellow",
+        Profile::Performance => "asus_notif_red",
+        Profile::Quiet => "asus_notif_green",
+    };
+    let profile: &str = (*profile).into();
+    let x = Notification::new()
+        .summary("ASUS ROG")
+        .body(&format!(
+            "Thermal profile changed to {}",
+            profile.to_uppercase(),
+        ))
+        .hint(Hint::Resident(true))
+        .timeout(2000)
+        .hint(Hint::Category("device".into()))
+        //.hint(Hint::Transient(true))
+        .icon(icon)
+        .show()?;
+    Ok(x)
+}
+
 fn do_led_notif(ledmode: &AuraEffect) -> Result<NotificationHandle, notify_rust::error::Error> {
     base_notification!(&format!(
         "Keyboard LED mode changed to {}",
@@ -107,9 +161,6 @@ fn do_charge_notif(limit: &u8) -> Result<NotificationHandle, notify_rust::error:
     base_notification!(&format!("Battery charge limit changed to {}", limit))
 }
 
-fn do_gfx_notif(vendor: &GfxVendors) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!(
-        "Graphics mode changed to {}",
-        <&str>::from(vendor)
-    ))
+fn do_post_sound_notif(on: &bool) -> Result<NotificationHandle, notify_rust::error::Error> {
+    base_notification!(&format!("BIOS Post sound {}", on))
 }

asusctl/Cargo.toml

@@ -1,23 +1,26 @@
 [package]
 name = "asusctl"
-version = "3.5.0"
+version = "4.0.7"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+zbus = "^2.2"
 rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_profiles = { path = "../rog-profiles" }
-rog_types = { path = "../rog-types" }
-rog_fan_curve = { version = "^0.1", features = ["serde"] }
+rog_supported = { path = "../rog-supported" }
+daemon = { path = "../daemon" }
 gumdrop = "^0.8"
-yansi-term = "^0.1"
+toml = "^0.5.8"
+
+sysfs-class = "^0.1.2"
 
 [dev-dependencies]
-tinybmp = "^0.2.3"
-glam = "0.14.0"
+tinybmp = "^0.3.3"
+glam = "0.20.5"
 rog_dbus = { path = "../rog-dbus" }
-gif = "^0.11.2"
+gif = "^0.11.2"

asusctl/examples/anime-diag-png.rs

@@ -1,10 +1,10 @@
 use std::{env, error::Error, path::Path, process::exit};
 
 use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 3 {

asusctl/examples/anime-diag.rs

@@ -1,7 +1,7 @@
 use std::{thread::sleep, time::Duration};
 
 use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -9,7 +9,7 @@ use rog_dbus::RogDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     for step in (2..50).rev() {
         let mut matrix = AnimeDiagonal::new(None);

asusctl/examples/anime-gif.rs

@@ -1,10 +1,10 @@
 use std::{env, path::Path, thread::sleep};
 
 use rog_anime::{ActionData, ActionLoader, Sequences};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 3 {

asusctl/examples/anime-grid.rs

@@ -1,5 +1,5 @@
 use rog_anime::{AnimeDataBuffer, AnimeGrid};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -7,7 +7,7 @@ use rog_dbus::RogDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
     let mut matrix = AnimeGrid::new(None);
     let tmp = matrix.get_mut();
 

asusctl/examples/anime-outline.rs

@@ -1,11 +1,11 @@
 use rog_anime::AnimeDataBuffer;
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
 // Top row start at 1, ends at 32
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
     let mut matrix = AnimeDataBuffer::new();
     matrix.get_mut()[1] = 100; // start = 1
     for n in matrix.get_mut()[2..32].iter_mut() {

asusctl/examples/anime-png.rs

@@ -3,10 +3,10 @@ use std::{env, error::Error, path::Path, process::exit};
 use rog_anime::{
     AnimeDataBuffer, {AnimeImage, Vec2},
 };
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {

asusctl/examples/anime-spinning.rs

@@ -5,10 +5,10 @@ use std::{
 use rog_anime::{
     AnimeDataBuffer, {AnimeImage, Vec2},
 };
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {

asusctl/src/anime_cli.rs

@@ -1,54 +1,4 @@
 use gumdrop::Options;
-use rog_aura::error::Error;
-use std::str::FromStr;
-
-#[derive(Copy, Clone, Debug)]
-pub enum AnimeStatusValue {
-    On,
-    Off,
-}
-impl FromStr for AnimeStatusValue {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "on" => Ok(AnimeStatusValue::On),
-            "off" => Ok(AnimeStatusValue::Off),
-            _ => {
-                print!("Invalid argument, must be one of: on, off");
-                Err(Error::ParseAnime)
-            }
-        }
-    }
-}
-impl From<AnimeStatusValue> for bool {
-    fn from(value: AnimeStatusValue) -> Self {
-        match value {
-            AnimeStatusValue::On => true,
-            AnimeStatusValue::Off => false,
-        }
-    }
-}
-
-#[derive(Options)]
-pub struct AnimeLeds {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        no_long,
-        required,
-        short = "b",
-        meta = "",
-        help = "set all leds brightness value"
-    )]
-    led_brightness: u8,
-}
-impl AnimeLeds {
-    pub fn led_brightness(&self) -> u8 {
-        self.led_brightness
-    }
-}
 
 #[derive(Options)]
 pub struct AnimeCommand {
@@ -56,21 +6,30 @@ pub struct AnimeCommand {
     pub help: bool,
     #[options(
         meta = "",
-        help = "turn on/off the panel (accept/reject write requests)"
+        help = "enable/disable the panel LEDs (does not erase last image)"
     )]
-    pub turn: Option<AnimeStatusValue>,
-    #[options(meta = "", help = "turn on/off the panel at boot (with Asus effect)")]
-    pub boot: Option<AnimeStatusValue>,
+    pub enable: Option<bool>,
+    #[options(
+        meta = "",
+        help = "enable/disable system animations (boot/sleep/shutdown)"
+    )]
+    pub boot_enable: Option<bool>,
+    #[options(meta = "", help = "set global AniMe brightness value")]
+    pub brightness: Option<f32>,
     #[options(command)]
     pub command: Option<AnimeActions>,
 }
 
 #[derive(Options)]
 pub enum AnimeActions {
-    #[options(help = "change all leds brightness")]
-    Leds(AnimeLeds),
-    #[options(help = "display an 8bit greyscale png")]
+    #[options(help = "display a PNG image")]
     Image(AnimeImage),
+    #[options(help = "display a diagonal/pixel-perfect PNG")]
+    PixelImage(AnimeImageDiagonal),
+    #[options(help = "display an animated GIF")]
+    Gif(AnimeGif),
+    #[options(help = "display an animated diagonal/pixel-perfect GIF")]
+    PixelGif(AnimeGifDiagonal),
 }
 
 #[derive(Options)]
@@ -90,3 +49,53 @@ pub struct AnimeImage {
     #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
     pub bright: f32,
 }
+
+#[derive(Options)]
+pub struct AnimeImageDiagonal {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+}
+
+#[derive(Options)]
+pub struct AnimeGif {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "scale 1.0 == normal")]
+    pub scale: f32,
+    #[options(meta = "", default = "0.0", help = "x position (float)")]
+    pub x_pos: f32,
+    #[options(meta = "", default = "0.0", help = "y position (float)")]
+    pub y_pos: f32,
+    #[options(meta = "", default = "0.0", help = "the angle in radians")]
+    pub angle: f32,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+    #[options(
+        meta = "",
+        default = "1",
+        help = "how many loops to play - 0 is infinite"
+    )]
+    pub loops: u32,
+}
+
+#[derive(Options)]
+pub struct AnimeGifDiagonal {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+    #[options(
+        meta = "",
+        default = "1",
+        help = "how many loops to play - 0 is infinite"
+    )]
+    pub loops: u32,
+}

asusctl/src/aura_cli.rs

@@ -124,6 +124,8 @@ pub struct MultiColourSpeed {
 /// Byte value for setting the built-in mode.
 ///
 /// Enum corresponds to the required integer value
+///
+// NOTE: The option names here must match those in rog-aura crate
 #[derive(Options)]
 pub enum SetAuraBuiltin {
     #[options(help = "set a single static colour")]
@@ -135,7 +137,7 @@ pub enum SetAuraBuiltin {
     #[options(help = "rainbow cycling in one of four directions")]
     Rainbow(SingleSpeedDirection),
     #[options(help = "rain pattern mimicking raindrops")]
-    Star(TwoColourSpeed),
+    Stars(TwoColourSpeed),
     #[options(help = "rain pattern of three preset colours")]
     Rain(SingleSpeed),
     #[options(help = "pressed keys are highlighted to fade")]
@@ -233,7 +235,7 @@ impl From<&SetAuraBuiltin> for AuraEffect {
                 data.mode = AuraModeNum::Rainbow;
                 data
             }
-            SetAuraBuiltin::Star(x) => {
+            SetAuraBuiltin::Stars(x) => {
                 let mut data: AuraEffect = x.into();
                 data.mode = AuraModeNum::Star;
                 data

asusctl/src/cli_opts.rs

@@ -0,0 +1,101 @@
+use crate::{
+    anime_cli::AnimeCommand,
+    aura_cli::{LedBrightness, SetAuraBuiltin},
+    profiles_cli::{FanCurveCommand, ProfileCommand},
+};
+use gumdrop::Options;
+
+#[derive(Default, Options)]
+pub struct CliStart {
+    #[options(help_flag, help = "print help message")]
+    pub help: bool,
+    #[options(help = "show program version number")]
+    pub version: bool,
+    #[options(help = "show supported functions of this laptop")]
+    pub show_supported: bool,
+    #[options(meta = "", help = "<off, low, med, high>")]
+    pub kbd_bright: Option<LedBrightness>,
+    #[options(help = "Toggle to next keyboard brightness")]
+    pub next_kbd_bright: bool,
+    #[options(help = "Toggle to previous keyboard brightness")]
+    pub prev_kbd_bright: bool,
+    #[options(meta = "", help = "Set your battery charge limit <20-100>")]
+    pub chg_limit: Option<u8>,
+    #[options(command)]
+    pub command: Option<CliCommand>,
+}
+
+#[derive(Options)]
+pub enum CliCommand {
+    #[options(help = "Set the keyboard lighting from built-in modes")]
+    LedMode(LedModeCommand),
+    #[options(help = "Set or select platform_profile")]
+    Profile(ProfileCommand),
+    #[options(help = "Set, select, or modify fan curves if supported")]
+    FanCurve(FanCurveCommand),
+    #[options(help = "Set the graphics mode (obsoleted by supergfxctl)")]
+    Graphics(GraphicsCommand),
+    #[options(name = "anime", help = "Manage AniMe Matrix")]
+    Anime(AnimeCommand),
+    #[options(help = "Change bios settings")]
+    Bios(BiosCommand),
+}
+
+#[derive(Options)]
+pub struct LedModeCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "switch to next aura mode")]
+    pub next_mode: bool,
+    #[options(help = "switch to previous aura mode")]
+    pub prev_mode: bool,
+    #[options(
+        meta = "",
+        help = "set the keyboard LED to enabled while the device is awake"
+    )]
+    pub boot_enable: Option<bool>,
+    #[options(
+        meta = "",
+        help = "set the keyboard LED suspend animation to enabled while the device is suspended"
+    )]
+    pub sleep_enable: Option<bool>,
+    #[options(
+        meta = "",
+        help = "set the full keyboard LEDs (keys and side) to enabled"
+    )]
+    pub all_leds_enable: Option<bool>,
+    #[options(meta = "", help = "set the keyboard keys LEDs to enabled")]
+    pub keys_leds_enable: Option<bool>,
+    #[options(meta = "", help = "set the keyboard side LEDs to enabled")]
+    pub side_leds_enable: Option<bool>,
+    #[options(command)]
+    pub command: Option<SetAuraBuiltin>,
+}
+
+#[derive(Options)]
+pub struct GraphicsCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+}
+
+#[derive(Options, Debug)]
+pub struct BiosCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(
+        meta = "",
+        no_long,
+        help = "set bios POST sound: asusctl -p <true/false>"
+    )]
+    pub post_sound_set: Option<bool>,
+    #[options(no_long, help = "read bios POST sound")]
+    pub post_sound_get: bool,
+    #[options(
+        meta = "",
+        no_long,
+        help = "activate dGPU dedicated/G-Sync: asusctl -d <true/false>, reboot required"
+    )]
+    pub dedicated_gfx_set: Option<bool>,
+    #[options(no_long, help = "get GPU mode")]
+    pub dedicated_gfx_get: bool,
+}

asusctl/src/main.rs

@@ -1,112 +1,30 @@
-mod anime_cli;
-mod aura_cli;
-mod profiles_cli;
+use std::process::Command;
+use std::thread::sleep;
+use std::{env::args, path::Path};
+
+use gumdrop::{Opt, Options};
+
+use anime_cli::{AnimeActions, AnimeCommand};
+use profiles_cli::{FanCurveCommand, ProfileCommand};
+use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2};
+use rog_aura::{self, AuraEffect};
+use rog_dbus::RogDbusClientBlocking;
+use rog_profiles::error::ProfileError;
+use rog_supported::SupportedFunctions;
+use rog_supported::{
+    AnimeSupportedFunctions, LedSupportedFunctions, PlatformProfileFunctions,
+    RogBiosSupportedFunctions,
+};
 
 use crate::aura_cli::{LedBrightness, SetAuraBuiltin};
-use anime_cli::{AnimeActions, AnimeCommand};
-use gumdrop::{Opt, Options};
-use profiles_cli::ProfileCommand;
-use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2, ANIME_DATA_LEN};
-use rog_aura::{self, AuraEffect};
-use rog_dbus::RogDbusClient;
-use rog_profiles::profiles::Profile;
-use rog_types::{
-    gfx_vendors::GfxVendors,
-    supported::{
-        FanCpuSupportedFunctions, LedSupportedFunctions, RogBiosSupportedFunctions,
-        SupportedFunctions,
-    },
-};
-use std::{env::args, path::Path};
-use yansi_term::Colour::Green;
-use yansi_term::Colour::Red;
+use crate::cli_opts::*;
 
-#[derive(Default, Options)]
-struct CliStart {
-    #[options(help_flag, help = "print help message")]
-    help: bool,
-    #[options(help = "show program version number")]
-    version: bool,
-    #[options(help = "show supported functions of this laptop")]
-    show_supported: bool,
-    #[options(meta = "", help = "<off, low, med, high>")]
-    kbd_bright: Option<LedBrightness>,
-    #[options(meta = "", help = "<20-100>")]
-    chg_limit: Option<u8>,
-    #[options(command)]
-    command: Option<CliCommand>,
-}
+mod anime_cli;
+mod aura_cli;
+mod cli_opts;
+mod profiles_cli;
 
-#[derive(Options)]
-enum CliCommand {
-    #[options(help = "Set the keyboard lighting from built-in modes")]
-    LedMode(LedModeCommand),
-    #[options(help = "Create and configure profiles")]
-    Profile(ProfileCommand),
-    #[options(help = "Set the graphics mode")]
-    Graphics(GraphicsCommand),
-    #[options(name = "anime", help = "Manage AniMe Matrix")]
-    Anime(AnimeCommand),
-    #[options(help = "Change bios settings")]
-    Bios(BiosCommand),
-}
-
-#[derive(Options)]
-struct LedModeCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(help = "switch to next aura mode")]
-    next_mode: bool,
-    #[options(help = "switch to previous aura mode")]
-    prev_mode: bool,
-    #[options(
-        meta = "",
-        help = "set the keyboard LED to enabled while the device is awake"
-    )]
-    awake_enable: Option<bool>,
-    #[options(
-        meta = "",
-        help = "set the keyboard LED suspend animation to enabled while the device is suspended"
-    )]
-    sleep_enable: Option<bool>,
-    #[options(command)]
-    command: Option<SetAuraBuiltin>,
-}
-
-#[derive(Options)]
-struct GraphicsCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        meta = "",
-        help = "Set graphics mode: <nvidia, hybrid, compute, integrated>"
-    )]
-    mode: Option<GfxVendors>,
-    #[options(help = "Get the current mode")]
-    get: bool,
-    #[options(help = "Get the current power status")]
-    pow: bool,
-    #[options(help = "Do not ask for confirmation")]
-    force: bool,
-}
-
-#[derive(Options, Debug)]
-struct BiosCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(meta = "", no_long, help = "set bios POST sound <true/false>")]
-    post_sound_set: Option<bool>,
-    #[options(no_long, help = "read bios POST sound")]
-    post_sound_get: bool,
-    #[options(
-        meta = "",
-        no_long,
-        help = "activate dGPU dedicated/G-Sync <true/false>"
-    )]
-    dedicated_gfx_set: Option<bool>,
-    #[options(no_long, help = "get GPU mode")]
-    dedicated_gfx_get: bool,
-}
+const CONFIG_ADVICE: &str = "A config file need to be removed so a new one can be generated";
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args: Vec<String> = args().skip(1).collect();
@@ -129,219 +47,306 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    let (dbus, _) = RogDbusClient::new()?;
+    let (dbus, _) = RogDbusClientBlocking::new()
+        .map_err(|e| {
+            print_error_help(Box::new(e), None);
+            std::process::exit(3);
+        })
+        .unwrap();
 
-    let supported = dbus.proxies().supported().get_supported_functions()?;
-
-    if parsed.help {
-        print_supported_help(&supported, &parsed);
-        println!("\nSee https://asus-linux.org/faq/ for additional help");
-        std::process::exit(1);
-    }
+    let supported = dbus
+        .proxies()
+        .supported()
+        .supported_functions()
+        .map_err(|e| {
+            print_error_help(Box::new(e), None);
+            std::process::exit(4);
+        })
+        .unwrap();
 
     if parsed.version {
-        println!("  asusctl v{}", env!("CARGO_PKG_VERSION"));
-        println!(" rog-dbus v{}", rog_dbus::VERSION);
-        println!("rog-types v{}", rog_types::VERSION);
+        print_versions();
+        println!();
+        print_laptop_info();
         return Ok(());
     }
 
-    match parsed.command {
-        Some(CliCommand::LedMode(mode)) => handle_led_mode(&dbus, &supported.keyboard_led, &mode)?,
-        Some(CliCommand::Profile(cmd)) => handle_profile(&dbus, &supported.fan_cpu_ctrl, &cmd)?,
-        Some(CliCommand::Graphics(cmd)) => do_gfx(&dbus, &supported.rog_bios_ctrl, cmd)?,
-        Some(CliCommand::Anime(cmd)) => {
-            if (cmd.command.is_none() && cmd.boot.is_none() && cmd.turn.is_none()) || cmd.help {
-                println!("Missing arg or command\n\n{}", cmd.self_usage());
-                if let Some(lst) = cmd.self_command_list() {
-                    println!("\n{}", lst);
-                }
-            }
-            if let Some(anime_turn) = cmd.turn {
-                dbus.proxies().anime().set_led_power(anime_turn.into())?
-            }
-            if let Some(anime_boot) = cmd.boot {
-                dbus.proxies()
-                    .anime()
-                    .set_system_animations(anime_boot.into())?
-            }
-            if let Some(action) = cmd.command {
-                match action {
-                    AnimeActions::Leds(anime_leds) => {
-                        let data = AnimeDataBuffer::from_vec(
-                            [anime_leds.led_brightness(); ANIME_DATA_LEN].to_vec(),
-                        );
-                        dbus.proxies().anime().write(data)?;
-                    }
-                    AnimeActions::Image(image) => {
-                        if image.help_requested() {
-                            println!("Missing arg or command\n\n{}", image.self_usage());
-                            if let Some(lst) = image.self_command_list() {
-                                println!("\n{}", lst);
-                            }
-                            std::process::exit(1);
-                        }
-
-                        let matrix = AnimeImage::from_png(
-                            Path::new(&image.path),
-                            image.scale,
-                            image.angle,
-                            Vec2::new(image.x_pos, image.y_pos),
-                            image.bright,
-                        )?;
-
-                        dbus.proxies()
-                            .anime()
-                            .write(<AnimeDataBuffer>::from(&matrix))
-                            .unwrap();
-                    }
-                }
-            }
-        }
-        Some(CliCommand::Bios(cmd)) => handle_bios_option(&dbus, &supported.rog_bios_ctrl, &cmd)?,
-        None => {
-            if (!parsed.show_supported && parsed.kbd_bright.is_none() && parsed.chg_limit.is_none())
-                || parsed.help
-            {
-                println!("{}", CliStart::usage());
-                println!();
-                println!("{}", CliStart::command_list().unwrap());
-            }
-        }
-    }
-
-    if let Some(brightness) = parsed.kbd_bright {
-        match brightness.level() {
-            None => {
-                let level = dbus.proxies().led().get_led_brightness()?;
-                println!("Current keyboard led brightness: {}", level.to_string());
-            }
-            Some(level) => dbus
-                .proxies()
-                .led()
-                .set_led_brightness(<rog_aura::LedBrightness>::from(level))?,
-        }
-    }
-
-    if parsed.show_supported {
-        let dat = dbus.proxies().supported().get_supported_functions()?;
-        println!("Supported laptop functions:\n\n{}", dat);
-    }
-
-    if let Some(chg_limit) = parsed.chg_limit {
-        dbus.proxies().charge().write_limit(chg_limit)?;
+    if let Err(err) = do_parsed(&parsed, &supported, &dbus) {
+        print_error_help(err, Some(&supported));
     }
 
     Ok(())
 }
 
-fn print_supported_help(supported: &SupportedFunctions, parsed: &CliStart) {
-    // As help option don't work with `parse_args_default`
-    // we will call `parse_args_default_or_exit` instead
-    let usage: Vec<String> = parsed.self_usage().lines().map(|s| s.to_string()).collect();
-    for line in usage.iter().filter(|line| {
-        if line.contains("--fan-mode") && !supported.fan_cpu_ctrl.stock_fan_modes {
-            return false;
+fn print_error_help(err: Box<dyn std::error::Error>, supported: Option<&SupportedFunctions>) {
+    if do_diagnose("asusd") {
+        println!("\nError: {}\n", err);
+        print_versions();
+        println!();
+        print_laptop_info();
+        if let Some(supported) = supported {
+            println!();
+            println!("Supported laptop functions:\n\n{}", supported);
         }
-        if line.contains("--chg-limit") && !supported.charge_ctrl.charge_level_set {
-            return false;
-        }
-        true
-    }) {
-        println!("{}", line);
-    }
-
-    // command strings are in order of the struct
-    let commands: Vec<String> = CliCommand::usage().lines().map(|s| s.to_string()).collect();
-    println!("\nCommands available");
-    for line in commands.iter().filter(|line| {
-        if line.contains("profile")
-            && !supported.fan_cpu_ctrl.stock_fan_modes
-            && !supported.fan_cpu_ctrl.fan_curve_set
-        {
-            return false;
-        }
-        if line.contains("led-mode") && !supported.keyboard_led.stock_led_modes.is_empty() {
-            return false;
-        }
-        if line.contains("bios")
-            && (!supported.rog_bios_ctrl.dedicated_gfx_toggle
-                || !supported.rog_bios_ctrl.post_sound_toggle)
-        {
-            return false;
-        }
-        if line.contains("anime") && !supported.anime_ctrl.0 {
-            return false;
-        }
-        true
-    }) {
-        println!("{}", line);
-    }
-
-    if !supported.fan_cpu_ctrl.stock_fan_modes {
-        println!("Note: Fan mode control is not supported by this laptop");
-    }
-    if !supported.charge_ctrl.charge_level_set {
-        println!("Note: Charge control is not supported by this laptop");
     }
 }
 
-fn do_gfx(
-    dbus: &RogDbusClient,
-    supported: &RogBiosSupportedFunctions,
-    command: GraphicsCommand,
-) -> Result<(), Box<dyn std::error::Error>> {
-    if command.mode.is_none() && !command.get && !command.pow && !command.force || command.help {
-        println!("{}", command.self_usage());
-    }
+fn print_versions() {
+    println!("App and daemon versions:");
+    println!("      asusctl v{}", env!("CARGO_PKG_VERSION"));
+    println!("        asusd v{}", daemon::VERSION);
+    println!("\nComponent crate versions:");
+    println!("    rog-anime v{}", rog_anime::VERSION);
+    println!("     rog-aura v{}", rog_aura::VERSION);
+    println!("     rog-dbus v{}", rog_dbus::VERSION);
+    println!(" rog-profiles v{}", rog_profiles::VERSION);
+    println!("rog-supported v{}", rog_supported::VERSION);
+}
 
-    if let Some(mode) = command.mode {
-        if supported.dedicated_gfx_toggle && dbus.proxies().rog_bios().get_dedicated_gfx()? == 1 {
-            println!("You can not change modes until you turn dedicated/G-Sync off and reboot");
-            std::process::exit(-1);
-        }
+fn print_laptop_info() {
+    let dmi = sysfs_class::DmiId::default();
+    let board_name = dmi.board_name().expect("Could not get board_name");
+    let prod_family = dmi.product_family().expect("Could not get product_family");
 
-        println!("If anything fails check `journalctl -b -u asusd`\n");
+    println!("Product family: {}", prod_family.trim());
+    println!("Board name: {}", board_name.trim());
+}
 
-        dbus.proxies().gfx().gfx_write_mode(&mode).map_err(|err|{
-            println!("Graphics mode change error. You may be in an invalid state.");
-            println!("Check mode with `asusctl graphics -g` and switch to opposite\nmode to correct it, e.g: if integrated, switch to hybrid, or if nvidia, switch to integrated.\n");
-            err
-        })?;
-        let res = dbus.gfx_wait_changed()?;
+fn do_diagnose(name: &str) -> bool {
+    if name != "asusd" && !check_systemd_unit_enabled(name) {
         println!(
-            "Graphics mode changed to {}. User action required is: {}",
-            <&str>::from(mode),
-            <&str>::from(&res)
+            "\n\x1b[0;31m{} is not enabled, enable it with `systemctl enable {}\x1b[0m",
+            name, name
         );
-        std::process::exit(0)
+        return true;
+    } else if !check_systemd_unit_active(name) {
+        println!(
+            "\n\x1b[0;31m{} is not running, start it with `systemctl start {}\x1b[0m",
+            name, name
+        );
+        return true;
+    } else {
+        println!("\nSome error happened (sorry)");
+        println!(
+            "Please use `systemctl status {}` and `journalctl -b -u {}` for more information",
+            name, name
+        );
+        println!("{}", CONFIG_ADVICE);
     }
-    if command.get {
-        let res = dbus.proxies().gfx().gfx_get_mode()?;
-        println!("Current graphics mode: {}", <&str>::from(res));
-    }
-    if command.pow {
-        let res = dbus.proxies().gfx().gfx_get_pwr()?;
-        match res {
-            rog_types::gfx_vendors::GfxPower::Active => {
-                println!("Current power status: {}", Red.paint(<&str>::from(&res)))
+    false
+}
+
+fn do_parsed(
+    parsed: &CliStart,
+    supported: &SupportedFunctions,
+    dbus: &RogDbusClientBlocking,
+) -> Result<(), Box<dyn std::error::Error>> {
+    match &parsed.command {
+        Some(CliCommand::LedMode(mode)) => handle_led_mode(dbus, &supported.keyboard_led, mode)?,
+        Some(CliCommand::Profile(cmd)) => handle_profile(dbus, &supported.platform_profile, cmd)?,
+        Some(CliCommand::FanCurve(cmd)) => {
+            handle_fan_curve(dbus, &supported.platform_profile, cmd)?
+        }
+        Some(CliCommand::Graphics(_)) => do_gfx()?,
+        Some(CliCommand::Anime(cmd)) => handle_anime(dbus, &supported.anime_ctrl, cmd)?,
+        Some(CliCommand::Bios(cmd)) => handle_bios_option(dbus, &supported.rog_bios_ctrl, cmd)?,
+        None => {
+            if (!parsed.show_supported
+                && parsed.kbd_bright.is_none()
+                && parsed.chg_limit.is_none()
+                && !parsed.next_kbd_bright
+                && !parsed.prev_kbd_bright)
+                || parsed.help
+            {
+                println!("{}", CliStart::usage());
+                println!();
+                if let Some(cmdlist) = CliStart::command_list() {
+                    println!("{}", cmdlist);
+                }
+            }
+        }
+    }
+
+    if let Some(brightness) = &parsed.kbd_bright {
+        match brightness.level() {
+            None => {
+                let level = dbus.proxies().led().led_brightness()?;
+                println!("Current keyboard led brightness: {}", level);
+            }
+            Some(level) => dbus
+                .proxies()
+                .led()
+                .set_brightness(<rog_aura::LedBrightness>::from(level))?,
+        }
+    }
+
+    if parsed.next_kbd_bright {
+        dbus.proxies().led().next_led_brightness()?;
+    }
+
+    if parsed.prev_kbd_bright {
+        dbus.proxies().led().prev_led_brightness()?;
+    }
+
+    if parsed.show_supported {
+        println!("Supported laptop functions:\n\n{}", supported);
+    }
+
+    if let Some(chg_limit) = parsed.chg_limit {
+        dbus.proxies().charge().set_limit(chg_limit)?;
+    }
+
+    Ok(())
+}
+
+fn do_gfx() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Please use supergfxctl for graphics switching. supergfxctl is the result of making asusctl graphics switching generic so all laptops can use it");
+    println!("This command will be removed in future");
+    Ok(())
+}
+
+fn handle_anime(
+    dbus: &RogDbusClientBlocking,
+    _supported: &AnimeSupportedFunctions,
+    cmd: &AnimeCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if (cmd.command.is_none()
+        && cmd.enable.is_none()
+        && cmd.boot_enable.is_none()
+        && cmd.brightness.is_none())
+        || cmd.help
+    {
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+    }
+    if let Some(anime_turn) = cmd.enable {
+        dbus.proxies().anime().set_on_off(anime_turn)?
+    }
+    if let Some(anime_boot) = cmd.boot_enable {
+        dbus.proxies().anime().set_boot_on_off(anime_boot)?
+    }
+    if let Some(bright) = cmd.brightness {
+        dbus.proxies().anime().set_brightness(bright as f32)?
+    }
+    if let Some(action) = cmd.command.as_ref() {
+        match action {
+            AnimeActions::Image(image) => {
+                if image.help_requested() || image.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", image.self_usage());
+                    if let Some(lst) = image.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    std::process::exit(1);
+                }
+
+                let matrix = AnimeImage::from_png(
+                    Path::new(&image.path),
+                    image.scale,
+                    image.angle,
+                    Vec2::new(image.x_pos, image.y_pos),
+                    image.bright,
+                )?;
+
+                dbus.proxies()
+                    .anime()
+                    .write(<AnimeDataBuffer>::from(&matrix))?;
+            }
+            AnimeActions::PixelImage(image) => {
+                if image.help_requested() || image.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", image.self_usage());
+                    if let Some(lst) = image.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    std::process::exit(1);
+                }
+
+                let matrix = AnimeDiagonal::from_png(Path::new(&image.path), None, image.bright)?;
+
+                dbus.proxies()
+                    .anime()
+                    .write(<AnimeDataBuffer>::from(&matrix))?;
+            }
+            AnimeActions::Gif(gif) => {
+                if gif.help_requested() || gif.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", gif.self_usage());
+                    if let Some(lst) = gif.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    std::process::exit(1);
+                }
+
+                let matrix = AnimeGif::from_gif(
+                    Path::new(&gif.path),
+                    gif.scale,
+                    gif.angle,
+                    Vec2::new(gif.x_pos, gif.y_pos),
+                    AnimTime::Count(1),
+                    gif.bright,
+                )?;
+
+                let mut loops = gif.loops as i32;
+                loop {
+                    for frame in matrix.frames() {
+                        dbus.proxies().anime().write(frame.frame().clone())?;
+                        sleep(frame.delay());
+                    }
+                    if loops >= 0 {
+                        loops -= 1;
+                    }
+                    if loops == 0 {
+                        break;
+                    }
+                }
+            }
+            AnimeActions::PixelGif(gif) => {
+                if gif.help_requested() || gif.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", gif.self_usage());
+                    if let Some(lst) = gif.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    std::process::exit(1);
+                }
+
+                let matrix = AnimeGif::from_diagonal_gif(
+                    Path::new(&gif.path),
+                    AnimTime::Count(1),
+                    gif.bright,
+                )?;
+
+                let mut loops = gif.loops as i32;
+                loop {
+                    for frame in matrix.frames() {
+                        dbus.proxies().anime().write(frame.frame().clone())?;
+                        sleep(frame.delay());
+                    }
+                    if loops >= 0 {
+                        loops -= 1;
+                    }
+                    if loops == 0 {
+                        break;
+                    }
+                }
             }
-            _ => println!("Current power status: {}", Green.paint(<&str>::from(&res))),
         }
     }
     Ok(())
 }
 
 fn handle_led_mode(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &LedSupportedFunctions,
     mode: &LedModeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
     if mode.command.is_none()
         && !mode.prev_mode
         && !mode.next_mode
+        && mode.boot_enable.is_none()
         && mode.sleep_enable.is_none()
-        && mode.awake_enable.is_none()
+        && mode.all_leds_enable.is_none()
+        && mode.keys_leds_enable.is_none()
+        && mode.side_leds_enable.is_none()
     {
         if !mode.help {
             println!("Missing arg or command\n");
@@ -349,23 +354,24 @@ fn handle_led_mode(
         println!("{}\n", mode.self_usage());
         println!("Commands available");
 
-        let commands: Vec<String> = LedModeCommand::command_list()
-            .unwrap()
-            .lines()
-            .map(|s| s.to_string())
-            .collect();
-        for command in commands.iter().filter(|command| {
-            for mode in &supported.stock_led_modes {
-                if command.contains(<&str>::from(mode)) {
+        if let Some(cmdlist) = LedModeCommand::command_list() {
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
+            for command in commands.iter().filter(|command| {
+                for mode in &supported.stock_led_modes {
+                    if command
+                        .trim()
+                        .starts_with(&<&str>::from(mode).to_lowercase())
+                    {
+                        return true;
+                    }
+                }
+                if supported.multizone_led_mode && command.trim().starts_with("multi") {
                     return true;
                 }
+                false
+            }) {
+                println!("{}", command);
             }
-            if supported.multizone_led_mode {
-                return true;
-            }
-            false
-        }) {
-            println!("{}", command);
         }
 
         println!("\nHelp can also be requested on modes, e.g: static --help");
@@ -399,129 +405,134 @@ fn handle_led_mode(
         }
     }
 
-    if let Some(enable) = mode.awake_enable {
-        dbus.proxies().led().set_awake_enabled(enable)?;
+    if let Some(enable) = mode.boot_enable {
+        dbus.proxies().led().set_boot_enabled(enable)?;
     }
 
     if let Some(enable) = mode.sleep_enable {
         dbus.proxies().led().set_sleep_enabled(enable)?;
     }
 
+    if let Some(enable) = mode.all_leds_enable {
+        dbus.proxies().led().set_all_leds_enabled(enable)?;
+    }
+    if let Some(enable) = mode.keys_leds_enable {
+        dbus.proxies().led().set_keys_leds_enabled(enable)?;
+    }
+    if let Some(enable) = mode.side_leds_enable {
+        dbus.proxies().led().set_side_leds_enabled(enable)?;
+    }
+
     Ok(())
 }
 
 fn handle_profile(
-    dbus: &RogDbusClient,
-    supported: &FanCpuSupportedFunctions,
+    dbus: &RogDbusClientBlocking,
+    supported: &PlatformProfileFunctions,
     cmd: &ProfileCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if !cmd.next
-        && !cmd.create // TODO
-        && !cmd.list
-        && cmd.profile.is_none()
-        && !cmd.active_name
-        && !cmd.active_data
-        && !cmd.profiles_data
-        && cmd.remove.is_none()
-        && cmd.curve.is_none() // TODO
-        && cmd.fan_preset.is_none() // TODO
-        && cmd.turbo.is_none() // TODO
-        && cmd.max_percentage.is_none() // TODO
-        && cmd.min_percentage.is_none()
-    // TODO
-    {
+    if !supported.platform_profile {
+        println!("Profiles not supported by either this kernel or by the laptop.");
+        return Err(ProfileError::NotSupported.into());
+    }
+
+    if !cmd.next && !cmd.list && cmd.profile_set.is_none() && !cmd.profile_get {
         if !cmd.help {
             println!("Missing arg or command\n");
         }
-        let usage: Vec<String> = ProfileCommand::usage()
-            .lines()
-            .map(|s| s.to_string())
-            .collect();
-        for line in usage
-            .iter()
-            .filter(|line| !line.contains("--curve") || supported.fan_curve_set)
-        {
-            println!("{}", line);
-        }
+        println!("{}", ProfileCommand::usage());
 
         if let Some(lst) = cmd.self_command_list() {
             println!("\n{}", lst);
         }
-
-        println!("Note: turbo, frequency, fan preset and fan curve options will apply to");
-        println!("      to the currently active profile unless a profile name is specified");
         std::process::exit(1);
     }
 
     if cmd.next {
-        dbus.proxies().profile().next_fan()?;
-    }
-    if let Some(profile) = &cmd.remove {
-        dbus.proxies().profile().remove(profile)?
+        dbus.proxies().profile().next_profile()?;
+    } else if let Some(profile) = cmd.profile_set {
+        dbus.proxies().profile().set_active_profile(profile)?;
     }
+
     if cmd.list {
-        let profile_names = dbus.proxies().profile().profile_names()?;
-        println!("Available profiles are {:?}", profile_names);
+        let res = dbus.proxies().profile().profiles()?;
+        res.iter().for_each(|p| println!("{:?}", p));
     }
-    if cmd.active_name {
+
+    if cmd.profile_get {
+        let res = dbus.proxies().profile().active_profile()?;
+        println!("Active profile is {:?}", res);
+    }
+
+    Ok(())
+}
+
+fn handle_fan_curve(
+    dbus: &RogDbusClientBlocking,
+    supported: &PlatformProfileFunctions,
+    cmd: &FanCurveCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.fan_curves {
+        println!("Fan-curves not supported by either this kernel or by the laptop.");
         println!(
-            "Active profile: {:?}",
-            dbus.proxies().profile().active_name()?
+            "This requires kernel 5.17 (unlreleased) or the fan curve patch listed in the readme."
         );
+        return Err(ProfileError::NotSupported.into());
     }
-    if cmd.active_data {
-        println!("Active profile:");
-        println!("{:?}", dbus.proxies().profile().active_data()?);
-    }
-    if cmd.profiles_data {
-        println!("Profiles:");
-        for s in dbus.proxies().profile().all_profile_data()? {
-            println!("{:?}", s);
+
+    if !cmd.get_enabled && !cmd.default && cmd.mod_profile.is_none() {
+        if !cmd.help {
+            println!("Missing arg or command\n");
         }
+        println!("{}", FanCurveCommand::usage());
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+        std::process::exit(1);
     }
 
-    let mut set_profile = false;
-    let mut profile;
-    if cmd.create {
-        profile = Profile::default();
-        set_profile = true;
-    } else {
-        profile = dbus.proxies().profile().active_data()?;
+    if (cmd.enabled.is_some() || cmd.fan.is_some() || cmd.data.is_some())
+        && cmd.mod_profile.is_none()
+    {
+        println!("--enabled, --fan, and --data options require --mod-profile");
+        std::process::exit(666);
     }
 
-    if let Some(turbo) = cmd.turbo {
-        set_profile = true;
-        profile.turbo = turbo;
+    if cmd.get_enabled {
+        let res = dbus.proxies().profile().enabled_fan_profiles()?;
+        println!("{:?}", res);
     }
-    if let Some(min) = cmd.min_percentage {
-        set_profile = true;
-        profile.min_percentage = min;
+
+    if cmd.default {
+        dbus.proxies().profile().set_active_curve_to_defaults()?;
     }
-    if let Some(max) = cmd.max_percentage {
-        set_profile = true;
-        profile.max_percentage = max;
-    }
-    if let Some(preset) = cmd.fan_preset {
-        set_profile = true;
-        profile.fan_preset = preset;
-    }
-    if let Some(ref curve) = cmd.curve {
-        set_profile = true;
-        profile.fan_curve = curve.as_config_string();
-    }
-    if let Some(ref name) = cmd.profile {
-        set_profile = true;
-        profile.name = name.clone();
-    }
-    if set_profile {
-        dbus.proxies().profile().new_or_modify(&profile)?;
+
+    if let Some(profile) = cmd.mod_profile {
+        if cmd.enabled.is_none() && cmd.data.is_none() {
+            let data = dbus.proxies().profile().fan_curve_data(profile)?;
+            let data = toml::to_string(&data)?;
+            println!("\nFan curves for {:?}\n\n{}", profile, data);
+        }
+
+        if let Some(enabled) = cmd.enabled {
+            dbus.proxies()
+                .profile()
+                .set_fan_curve_enabled(profile, enabled)?;
+        }
+
+        if let Some(mut curve) = cmd.data.clone() {
+            let fan = cmd.fan.unwrap_or_default();
+            curve.set_fan(fan);
+            dbus.proxies().profile().set_fan_curve(profile, curve)?;
+        }
     }
 
     Ok(())
 }
 
 fn handle_bios_option(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &RogBiosSupportedFunctions,
     cmd: &BiosCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -540,23 +551,23 @@ fn handle_bios_option(
                 .collect();
 
             for line in usage.iter().filter(|line| {
-                !line.contains("sound") && !supported.post_sound_toggle
-                    || !line.contains("GPU") && !supported.dedicated_gfx_toggle
+                line.contains("sound") && supported.post_sound_toggle
+                    || line.contains("GPU") && supported.dedicated_gfx_toggle
             }) {
                 println!("{}", line);
             }
         }
 
         if let Some(opt) = cmd.post_sound_set {
-            dbus.proxies().rog_bios().set_post_sound(opt)?;
+            dbus.proxies().rog_bios().set_post_boot_sound(opt)?;
         }
         if cmd.post_sound_get {
-            let res = dbus.proxies().rog_bios().get_post_sound()? == 1;
+            let res = dbus.proxies().rog_bios().post_boot_sound()? == 1;
             println!("Bios POST sound on: {}", res);
         }
         if let Some(opt) = cmd.dedicated_gfx_set {
             println!("Rebuilding initrd to include drivers");
-            dbus.proxies().rog_bios().set_dedicated_gfx(opt)?;
+            dbus.proxies().rog_bios().set_dedicated_graphic_mode(opt)?;
             println!("The mode change is not active until you reboot, on boot the bios will make the required change");
             if opt {
                 println!(
@@ -567,9 +578,33 @@ fn handle_bios_option(
             }
         }
         if cmd.dedicated_gfx_get {
-            let res = dbus.proxies().rog_bios().get_dedicated_gfx()? == 1;
+            let res = dbus.proxies().rog_bios().dedicated_graphic_mode()? == 1;
             println!("Bios dedicated GPU on: {}", res);
         }
     }
     Ok(())
 }
+
+fn check_systemd_unit_active(name: &str) -> bool {
+    if let Ok(out) = Command::new("systemctl")
+        .arg("is-active")
+        .arg(name)
+        .output()
+    {
+        let buf = String::from_utf8_lossy(&out.stdout);
+        return !buf.contains("inactive") && !buf.contains("failed");
+    }
+    false
+}
+
+fn check_systemd_unit_enabled(name: &str) -> bool {
+    if let Ok(out) = Command::new("systemctl")
+        .arg("is-enabled")
+        .arg(name)
+        .output()
+    {
+        let buf = String::from_utf8_lossy(&out.stdout);
+        return buf.contains("enabled");
+    }
+    false
+}

asusctl/src/profiles_cli.rs

@@ -1,6 +1,5 @@
 use gumdrop::Options;
-use rog_fan_curve::{Curve, Fan};
-use rog_profiles::profiles::FanLevel;
+use rog_profiles::{fan_curve_set::CurveData, FanCurvePU, Profile};
 
 #[derive(Debug, Clone, Options)]
 pub struct ProfileCommand {
@@ -8,46 +7,45 @@ pub struct ProfileCommand {
     pub help: bool,
     #[options(help = "toggle to next profile in list")]
     pub next: bool,
-    #[options(help = "create the profile if it doesn't exist")]
-    pub create: bool,
-    #[options(meta = "", help = "remove a profile by name")]
-    pub remove: Option<String>,
     #[options(help = "list available profiles")]
     pub list: bool,
-    #[options(help = "get active profile name")]
-    pub active_name: bool,
-    #[options(help = "get active profile data")]
-    pub active_data: bool,
-    #[options(help = "get all profile data")]
-    pub profiles_data: bool,
 
-    // Options for profile
-    #[options(meta = "", help = "enable or disable cpu turbo")]
-    pub turbo: Option<bool>,
-    #[options(meta = "", help = "set min cpu scaling (intel)")]
-    pub min_percentage: Option<u8>,
-    #[options(meta = "", help = "set max cpu scaling (intel)")]
-    pub max_percentage: Option<u8>,
+    #[options(help = "get profile")]
+    pub profile_get: bool,
+    #[options(meta = "", help = "set the active profile")]
+    pub profile_set: Option<Profile>,
+}
+
+#[derive(Debug, Clone, Options)]
+pub struct FanCurveCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "get enabled fan profiles")]
+    pub get_enabled: bool,
+    #[options(help = "set the active profile's fan curve to default")]
+    pub default: bool,
 
-    #[options(meta = "", help = "<silent, normal, boost>")]
-    pub fan_preset: Option<FanLevel>,
     #[options(
         meta = "",
-        parse(try_from_str = "parse_fan_curve"),
-        help = "set fan curve"
+        help = "profile to modify fan-curve for. Shows data if no options provided"
     )]
-    pub curve: Option<Curve>,
-    #[options(free)]
-    pub profile: Option<String>,
-}
+    pub mod_profile: Option<Profile>,
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> fan curve. `mod-profile` required"
+    )]
+    pub enabled: Option<bool>,
+    #[options(
+        meta = "",
+        help = "select fan <cpu/gpu> to modify. `mod-profile` required"
+    )]
+    pub fan: Option<FanCurvePU>,
 
-fn parse_fan_curve(data: &str) -> Result<Curve, String> {
-    let curve = Curve::from_config_str(data)?;
-    if let Err(err) = curve.check_safety(Fan::Cpu) {
-        return Err(format!("Unsafe curve {:?}", err));
-    }
-    if let Err(err) = curve.check_safety(Fan::Gpu) {
-        return Err(format!("Unsafe curve {:?}", err));
-    }
-    Ok(curve)
+    #[options(
+        meta = "",
+        help = "data format = 30c:1%,49c:2%,59c:3%,69c:4%,79c:31%,89c:49%,99c:56%,109c:58%.
+                      `--mod-profile` required. If '%' is omitted the fan range is 0-255"
+    )]
+    pub data: Option<CurveData>,
 }

daemon-user/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "daemon-user"
-version = "1.2.0"
+version = "1.3.0"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 description = "Usermode daemon for user settings, anime, per-key lighting"
@@ -21,10 +21,12 @@ serde_derive = "^1.0"
 
 rog_anime = { path = "../rog-anime" }
 rog_dbus = { path = "../rog-dbus" }
-rog_types = { path = "../rog-types" }
+rog_supported = { path = "../rog-supported" }
 
-dirs = "3.0.1"
+dirs = "^4.0"
 
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = "^2.6"
+zbus = "^2.2"
+zvariant = "^3.0"
+zvariant_derive = "^3.0"
+
+smol = "^1.2"

daemon-user/src/ctrl_anime.rs

@@ -1,5 +1,6 @@
+use rog_anime::error::AnimeError;
 use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 use serde_derive::{Deserialize, Serialize};
 use std::time::Duration;
 use std::{
@@ -65,14 +66,14 @@ pub enum TimeType {
 /// and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
-    client: RogDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
     do_early_return: Arc<AtomicBool>,
 }
 
 impl<'a> CtrlAnimeInner<'static> {
     pub fn new(
         sequences: Sequences,
-        client: RogDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
         do_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(Self {
@@ -90,17 +91,24 @@ impl<'a> CtrlAnimeInner<'static> {
         for action in self.sequences.iter() {
             match action {
                 ActionData::Animation(frames) => {
-                    rog_anime::run_animation(frames, self.do_early_return.clone(), &|output| {
-                        self.client.proxies().anime().write(output).unwrap()
-                    })
-                    .unwrap();
+                    rog_anime::run_animation(frames, &|output| {
+                        if self.do_early_return.load(Ordering::Acquire) {
+                            return Ok(true); // Do safe exit
+                        }
+                        self.client
+                            .proxies()
+                            .anime()
+                            .write(output)
+                            .map_err(|e| AnimeError::Dbus(format!("{}", e)))
+                            .map(|_| false)
+                    })?;
                 }
                 ActionData::Image(image) => {
                     self.client
                         .proxies()
                         .anime()
                         .write(image.as_ref().clone())
-                        .unwrap();
+                        .ok();
                 }
                 ActionData::Pause(duration) => {
                     let start = Instant::now();
@@ -127,7 +135,7 @@ impl<'a> CtrlAnimeInner<'static> {
 
 pub struct CtrlAnime<'a> {
     config: Arc<Mutex<UserAnimeConfig>>,
-    client: RogDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
     inner_early_return: Arc<AtomicBool>,
@@ -137,7 +145,7 @@ impl<'a> CtrlAnime<'static> {
     pub fn new(
         config: Arc<Mutex<UserAnimeConfig>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
-        client: RogDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
         inner_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(CtrlAnime {
@@ -148,12 +156,14 @@ impl<'a> CtrlAnime<'static> {
         })
     }
 
-    pub fn add_to_server(self, server: &mut zbus::ObjectServer) {
+    pub async fn add_to_server(self, server: &mut zbus::Connection) {
         server
+            .object_server()
             .at(
                 &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
                 self,
             )
+            .await
             .map_err(|err| {
                 println!("CtrlAnime: add_to_server {}", err);
                 err
@@ -261,12 +271,12 @@ impl CtrlAnime<'static> {
         scale: f32,
         angle: f32,
         xy: (f32, f32),
-        time: Option<Timer>,
+        time: Timer,
         brightness: f32,
     ) -> zbus::fdo::Result<String> {
         if let Ok(mut config) = self.config.try_lock() {
             let file = Path::new(&file);
-            let time = time.map(|time| time.into());
+            let time = time.into();
             let action = ActionLoader::Image {
                 file: file.into(),
                 scale,
@@ -349,13 +359,13 @@ impl CtrlAnime<'static> {
     pub fn set_state(&mut self, on: bool) -> zbus::fdo::Result<()> {
         // Operations here need to be in specific order
         if on {
-            self.client.proxies().anime().set_led_power(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
             // Let the inner loop run
             self.inner_early_return.store(false, Ordering::SeqCst);
         } else {
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
-            self.client.proxies().anime().set_led_power(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
         }
         Ok(())
     }

daemon-user/src/daemon.rs

@@ -1,67 +1,70 @@
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 use rog_user::{
     ctrl_anime::{CtrlAnime, CtrlAnimeInner},
     user_config::*,
     DBUS_NAME,
 };
+use smol::Executor;
 use std::sync::Arc;
 use std::sync::Mutex;
-use std::thread;
-use zbus::{fdo, Connection};
+use zbus::Connection;
 
 use std::sync::atomic::AtomicBool;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!(" user daemon v{}", rog_user::VERSION);
-    println!("   rog-anime v{}", rog_anime::VERSION);
-    println!("    rog-dbus v{}", rog_dbus::VERSION);
-    println!("   rog-types v{}", rog_types::VERSION);
+    println!("  user daemon v{}", rog_user::VERSION);
+    println!("    rog-anime v{}", rog_anime::VERSION);
+    println!("     rog-dbus v{}", rog_dbus::VERSION);
+    println!("rog-supported v{}", rog_supported::VERSION);
 
-    let (client, _) = RogDbusClient::new().unwrap();
-    let supported = client.proxies().supported().get_supported_functions()?;
+    let (client, _) = RogDbusClientBlocking::new()?;
+    let supported = client.proxies().supported().supported_functions()?;
 
     let mut config = UserConfig::new();
     config.load_config()?;
 
-    let anime_config = UserAnimeConfig::load_config(config.active_anime)?;
-    let anime = anime_config.create_anime()?;
-
-    let anime_config = Arc::new(Mutex::new(anime_config));
-
-    // Create server
-    let connection = Connection::new_session()?;
-    fdo::DBusProxy::new(&connection)?
-        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-    let mut server = zbus::ObjectServer::new(&connection);
+    let executor = Executor::new();
 
+    let early_return = Arc::new(AtomicBool::new(false));
     // Set up the anime data and run loop/thread
     if supported.anime_ctrl.0 {
-        let early_return = Arc::new(AtomicBool::new(false));
-        // Inner behind mutex required for thread safety
-        let inner = Arc::new(Mutex::new(CtrlAnimeInner::new(
-            anime,
-            client,
-            early_return.clone(),
-        )?));
-        // Need new client object for dbus control part
-        let (client, _) = RogDbusClient::new().unwrap();
-        let anime_control = CtrlAnime::new(anime_config, inner.clone(), client, early_return)?;
-        anime_control.add_to_server(&mut server);
-        // Thread using inner
-        let _anime_thread = thread::Builder::new()
-            .name("Anime User".into())
-            .spawn(move || loop {
-                if let Ok(inner) = inner.try_lock() {
-                    inner.run().unwrap();
+        let anime_config = UserAnimeConfig::load_config(config.active_anime)?;
+        let anime = anime_config.create_anime()?;
+        let anime_config = Arc::new(Mutex::new(anime_config));
+
+        executor
+            .spawn(async move {
+                // Create server
+                let mut connection = Connection::session().await.unwrap();
+                connection.request_name(DBUS_NAME).await.unwrap();
+
+                // Inner behind mutex required for thread safety
+                let inner = Arc::new(Mutex::new(
+                    CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
+                ));
+                // Need new client object for dbus control part
+                let (client, _) = RogDbusClientBlocking::new().unwrap();
+                let anime_control =
+                    CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
+                anime_control.add_to_server(&mut connection).await;
+                loop {
+                    if let Ok(inner) = inner.clone().try_lock() {
+                        inner.run().ok();
+                    }
                 }
-            })?;
+            })
+            .detach();
     }
 
-    if supported.keyboard_led.per_key_led_mode {}
+    // if supported.keyboard_led.per_key_led_mode {
+    //     executor
+    //         .spawn(async move {
+    //            //
+    //         })
+    //         .detach();
+    // }
 
     loop {
-        if let Err(err) = server.try_handle_next() {
-            println!("{}", err);
-        }
+        smol::block_on(executor.tick());
     }
 }

daemon-user/src/user_config.rs

@@ -95,6 +95,15 @@ impl Default for UserAnimeConfig {
         Self {
             name: "default".to_string(),
             anime: vec![
+                ActionLoader::AsusImage {
+                    file: "/usr/share/asusd/anime/custom/diagonal-template.png".into(),
+                    brightness: 1.0,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        None,
+                        Duration::from_secs(2),
+                    )),
+                },
                 ActionLoader::AsusAnimation {
                     file: "/usr/share/asusd/anime/asus/rog/Sunset.gif".into(),
                     brightness: 0.5,
@@ -121,11 +130,11 @@ impl Default for UserAnimeConfig {
                     scale: 1.0,
                     angle: 0.0,
                     translation: Vec2::default(),
-                    time: Some(AnimTime::Fade(Fade::new(
+                    time: AnimTime::Fade(Fade::new(
                         Duration::from_secs(2),
                         Some(Duration::from_secs(1)),
                         Duration::from_secs(2),
-                    ))),
+                    )),
                     brightness: 0.6,
                 },
                 ActionLoader::Pause(Duration::from_secs(1)),

daemon/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "daemon"
-version = "3.7.0"
+version = "4.1.0"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -18,29 +18,31 @@ name = "asusd"
 path = "src/daemon.rs"
 
 [dependencies]
-rog_anime = { path = "../rog-anime" }
-rog_aura = { path = "../rog-aura" }
-rog_types = { path = "../rog-types" }
+rog_anime = { path = "../rog-anime", features = ["dbus"] }
+rog_aura = { path = "../rog-aura", features = ["dbus"] }
+rog_supported = { path = "../rog-supported" }
 rog_profiles = { path = "../rog-profiles" }
 rog_dbus = { path = "../rog-dbus" }
-rusb = "^0.8"
+
+async-trait = "^0.1"
+smol = "^1.2"
+
+rusb = "^0.9"
 udev = "^0.6"
 
 # cli and logging
 log = "^0.4"
-env_logger = "^0.8"
+env_logger = "^0.9"
 
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = { version = "^2.6" }
-logind-zbus = "^0.7.1"
+zbus = "^2.2"
+zvariant = "^3.2"
+logind-zbus = { version = "^3.0" } #, default-features = false, features = ["non_blocking"] }
 
 # serialisation
 serde = "^1.0"
 serde_derive = "^1.0"
 serde_json = "^1.0"
-toml = "^0.5"
+toml = "^0.5.8"
 
 # Device control
 sysfs-class = "^0.1.2" # used for backlight control and baord ID
-rog_fan_curve = { version = "0.1", features = ["serde"] }

daemon/src/config.rs

@@ -1,134 +1,57 @@
-use log::{error, info, warn};
-use rog_profiles::profiles::{FanLevel, Profile};
-use rog_types::gfx_vendors::GfxVendors;
+use log::{error, warn};
 use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
-
-use crate::config_old::*;
-use crate::VERSION;
+use std::path::PathBuf;
 
 pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
-pub static AURA_CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
 
 #[derive(Deserialize, Serialize)]
 pub struct Config {
-    pub gfx_mode: GfxVendors,
-    /// Only for informational purposes.
-    #[serde(skip)]
-    pub gfx_tmp_mode: Option<GfxVendors>,
-    pub gfx_managed: bool,
-    pub gfx_vfio_enable: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
+    /// Save charge limit for restoring on boot
     pub bat_charge_limit: u8,
-    pub power_profiles: BTreeMap<String, Profile>,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        let mut pwr = BTreeMap::new();
-        pwr.insert(
-            "normal".into(),
-            Profile::new(
-                "normal".into(),
-                0,
-                100,
-                true,
-                FanLevel::Normal,
-                "".to_string(),
-            ),
-        );
-        pwr.insert(
-            "boost".into(),
-            Profile::new(
-                "boost".into(),
-                0,
-                100,
-                true,
-                FanLevel::Boost,
-                "".to_string(),
-            ),
-        );
-        pwr.insert(
-            "silent".into(),
-            Profile::new(
-                "silent".into(),
-                0,
-                100,
-                false,
-                FanLevel::Silent,
-                "".to_string(),
-            ),
-        );
-
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_tmp_mode: None,
-            gfx_managed: true,
-            gfx_vfio_enable: false,
-            active_profile: "normal".into(),
-            toggle_profiles: vec!["normal".into(), "boost".into(), "silent".into()],
-            curr_fan_mode: 0,
-            bat_charge_limit: 100,
-            power_profiles: pwr,
-        }
-    }
 }
 
 impl Config {
+    fn new() -> Self {
+        Config {
+            bat_charge_limit: 100,
+        }
+    }
+
     /// `load` will attempt to read the config, and panic if the dir is missing
     pub fn load() -> Self {
         let mut file = OpenOptions::new()
             .read(true)
             .write(true)
             .create(true)
-            .open(&CONFIG_PATH)
-            .unwrap_or_else(|_| panic!("The directory /etc/asusd/ is missing")); // okay to cause panic here
+            .open(&PathBuf::from(CONFIG_PATH))
+            .unwrap_or_else(|e| panic!("Error opening {}, {}", CONFIG_PATH, e)); // okay to cause panic here
         let mut buf = String::new();
+        let config;
         if let Ok(read_len) = file.read_to_string(&mut buf) {
             if read_len == 0 {
-                return Config::create_default(&mut file);
+                config = Self::new();
+            } else if let Ok(data) = serde_json::from_str(&buf) {
+                config = data;
             } else {
-                if let Ok(data) = serde_json::from_str(&buf) {
-                    return data;
-                } else if let Ok(data) = serde_json::from_str::<ConfigV352>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    return config;
-                } else if let Ok(data) = serde_json::from_str::<ConfigV341>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    return config;
-                } else if let Ok(data) = serde_json::from_str::<ConfigV324>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    return config;
-                } else if let Ok(data) = serde_json::from_str::<ConfigV317>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    return config;
-                }
-                warn!("Could not deserialise {}", CONFIG_PATH);
-                panic!("Please remove {} then restart asusd", CONFIG_PATH);
+                warn!(
+                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
+                    CONFIG_PATH, CONFIG_PATH
+                );
+                let cfg_old = CONFIG_PATH.to_string() + "-old";
+                std::fs::rename(CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
+                    panic!(
+                        "Could not rename. Please remove {} then restart service: Error {}",
+                        CONFIG_PATH, err
+                    )
+                });
+                config = Self::new();
             }
+        } else {
+            config = Self::new()
         }
-        Config::create_default(&mut file)
-    }
-
-    fn create_default(file: &mut File) -> Self {
-        let config = Config::default();
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string_pretty(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", CONFIG_PATH));
+        config.write();
         config
     }
 
@@ -142,12 +65,8 @@ impl Config {
             if l == 0 {
                 warn!("File is empty {}", CONFIG_PATH);
             } else {
-                let mut x: Config = serde_json::from_str(&buf)
+                *self = serde_json::from_str(&buf)
                     .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
-                // copy over serde skipped values
-                x.gfx_tmp_mode = self.gfx_tmp_mode;
-                x.curr_fan_mode = self.curr_fan_mode;
-                *self = x;
             }
         }
     }

daemon/src/config_old.rs

@@ -1,161 +0,0 @@
-use rog_fan_curve::Curve;
-use rog_profiles::profiles::Profile;
-use rog_types::gfx_vendors::GfxVendors;
-use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-
-use crate::config::Config;
-
-/// for parsing old v3.1.7 config
-#[allow(dead_code)]
-#[derive(Deserialize)]
-pub(crate) struct ConfigV317 {
-    pub gfx_mode: GfxVendors,
-    pub gfx_managed: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
-    pub bat_charge_limit: u8,
-    pub kbd_led_brightness: u8,
-    pub kbd_backlight_mode: u8,
-    #[serde(skip)]
-    pub kbd_backlight_modes: Option<bool>,
-    pub power_profiles: BTreeMap<String, ProfileV317>,
-}
-
-impl ConfigV317 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: self.gfx_mode,
-            gfx_tmp_mode: None,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.curr_fan_mode,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: ProfileV317::transform_map(self.power_profiles),
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct ConfigV324 {
-    pub gfx_mode: GfxVendors,
-    pub gfx_managed: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
-    pub bat_charge_limit: u8,
-    pub power_profiles: BTreeMap<String, ProfileV317>,
-}
-
-impl ConfigV324 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_tmp_mode: None,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.curr_fan_mode,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: ProfileV317::transform_map(self.power_profiles),
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct ConfigV341 {
-    pub gfx_mode: GfxVendors,
-    pub gfx_managed: bool,
-    pub gfx_vfio_enable: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
-    pub bat_charge_limit: u8,
-    pub power_profiles: BTreeMap<String, ProfileV317>,
-}
-
-impl ConfigV341 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_tmp_mode: None,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.curr_fan_mode,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: ProfileV317::transform_map(self.power_profiles),
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct ConfigV352 {
-    pub gfx_mode: GfxVendors,
-    pub gfx_last_mode: GfxVendors,
-    pub gfx_managed: bool,
-    pub gfx_vfio_enable: bool,
-    pub gfx_save_compute_vfio: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
-    pub bat_charge_limit: u8,
-    pub power_profiles: BTreeMap<String, ProfileV317>,
-}
-
-impl ConfigV352 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_tmp_mode: None,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.curr_fan_mode,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: ProfileV317::transform_map(self.power_profiles),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct ProfileV317 {
-    pub min_percentage: u8,
-    pub max_percentage: u8,
-    pub turbo: bool,
-    pub fan_preset: u8,
-    pub fan_curve: Option<Curve>,
-}
-
-impl ProfileV317 {
-    fn into_current(self, name: String) -> Profile {
-        Profile {
-            name,
-            min_percentage: self.min_percentage,
-            max_percentage: self.max_percentage,
-            turbo: self.turbo,
-            fan_preset: self.fan_preset.into(),
-            fan_curve: self
-                .fan_curve
-                .map_or_else(|| "".to_string(), |c| c.as_config_string()),
-        }
-    }
-
-    fn transform_map(map: BTreeMap<String, ProfileV317>) -> BTreeMap<String, Profile> {
-        let mut new_map = BTreeMap::new();
-        map.iter().for_each(|(k, v)| {
-            new_map.insert(k.to_string(), v.clone().into_current(k.to_string()));
-        });
-        new_map
-    }
-}

daemon/src/ctrl_anime.rs

@@ -1,456 +0,0 @@
-use log::{error, info, warn};
-use logind_zbus::ManagerProxy;
-use rog_anime::{
-    usb::{
-        pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on, pkts_for_init, PROD_ID,
-        VENDOR_ID,
-    },
-    ActionData, AnimeDataBuffer, AnimePacketType, AnimePowerStates, ANIME_DATA_LEN,
-};
-use rog_types::supported::AnimeSupportedFunctions;
-use rusb::{Device, DeviceHandle};
-use std::{
-    error::Error,
-    sync::{Arc, Mutex},
-    thread::sleep,
-};
-use std::{
-    sync::atomic::{AtomicBool, Ordering},
-    time::Duration,
-};
-use zbus::{dbus_interface, Connection};
-use zvariant::ObjectPath;
-
-use crate::{
-    config_anime::{AnimeConfig, AnimeConfigCached},
-    error::RogError,
-    GetSupported,
-};
-
-impl GetSupported for CtrlAnime {
-    type A = AnimeSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        AnimeSupportedFunctions(CtrlAnime::get_device(VENDOR_ID, PROD_ID).is_ok())
-    }
-}
-
-pub struct CtrlAnime {
-    handle: DeviceHandle<rusb::GlobalContext>,
-    cache: AnimeConfigCached,
-    config: AnimeConfig,
-    // set to force thread to exit
-    thread_exit: Arc<AtomicBool>,
-    // Set to false when the thread exits
-    thread_running: Arc<AtomicBool>,
-}
-
-impl CtrlAnime {
-    #[inline]
-    pub fn new(config: AnimeConfig) -> Result<CtrlAnime, 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
-        })?;
-
-        info!("Device has an AniMe Matrix display");
-        let mut cache = AnimeConfigCached::default();
-        cache.init_from_config(&config)?;
-
-        let ctrl = CtrlAnime {
-            handle: device,
-            cache,
-            config,
-            thread_exit: Arc::new(AtomicBool::new(false)),
-            thread_running: Arc::new(AtomicBool::new(false)),
-        };
-        ctrl.do_initialization();
-
-        Ok(ctrl)
-    }
-
-    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)
-    }
-
-    /// 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.
-    ///
-    /// Because this also writes to the usb device, other write tries (display only) *must*
-    /// get the mutex lock and set the thread_exit atomic.
-    fn run_thread(inner: Arc<Mutex<CtrlAnime>>, actions: Vec<ActionData>, mut once: bool) {
-        if actions.is_empty() {
-            warn!("AniMe system actions was empty");
-            return;
-        }
-        // Loop rules:
-        // - Lock the mutex **only when required**. That is, the lock must be held for the shortest duration possible.
-        // - An AtomicBool used for thread exit should be checked in every loop, including nested
-
-        // The only reason for this outer thread is to prevent blocking while waiting for the
-        // next spawned thread to exit
-        std::thread::Builder::new()
-            .name("AniMe system thread start".into())
-            .spawn(move || {
-                info!("AniMe system thread started");
-                // Getting copies of these Atomics is done *in* the thread to ensure
-                // we don't block other threads/main
-                let thread_exit;
-                let thread_running;
-                // First two loops are to ensure we *do* aquire a lock on the mutex
-                // The reason the loop is required is because the USB writes can block
-                // for up to 10ms. We can't fail to get the atomics.
-                loop {
-                    if let Ok(lock) = inner.try_lock() {
-                        thread_exit = lock.thread_exit.clone();
-                        thread_running = lock.thread_running.clone();
-                        // Make any running loop exit first
-                        thread_exit.store(true, Ordering::SeqCst);
-                        break;
-                    }
-                }
-
-                loop {
-                    // wait for other threads to set not running so we know they exited
-                    if !thread_running.load(Ordering::SeqCst) {
-                        thread_exit.store(false, Ordering::SeqCst);
-                        info!("AniMe forced a thread to exit");
-                        break;
-                    }
-                }
-
-                'main: loop {
-                    if thread_exit.load(Ordering::SeqCst) {
-                        break 'main;
-                    }
-                    for action in actions.iter() {
-                        match action {
-                            ActionData::Animation(frames) => {
-                                rog_anime::run_animation(frames, thread_exit.clone(), &|frame| {
-                                    if let Ok(lock) = inner.try_lock() {
-                                        lock.write_data_buffer(frame);
-                                    }
-                                })
-                                .unwrap();
-
-                                if thread_exit.load(Ordering::SeqCst) {
-                                    break 'main;
-                                }
-                            }
-                            ActionData::Image(image) => {
-                                once = false;
-                                if let Ok(lock) = inner.try_lock() {
-                                    lock.write_data_buffer(image.as_ref().clone())
-                                }
-                            }
-                            ActionData::Pause(duration) => sleep(*duration),
-                            ActionData::AudioEq => {}
-                            ActionData::SystemInfo => {}
-                            ActionData::TimeDate => {}
-                            ActionData::Matrix => {}
-                        }
-                    }
-                    if once || actions.is_empty() {
-                        break 'main;
-                    }
-                }
-                // Clear the display on exit
-                if let Ok(lock) = inner.try_lock() {
-                    let data = AnimeDataBuffer::from_vec([0u8; ANIME_DATA_LEN].to_vec());
-                    lock.write_data_buffer(data);
-                }
-                // Loop ended, set the atmonics
-                thread_exit.store(false, Ordering::SeqCst);
-                thread_running.store(false, Ordering::SeqCst);
-                info!("AniMe system thread exited");
-            })
-            .map(|err| info!("AniMe system thread: {:?}", err))
-            .ok();
-    }
-
-    fn write_bytes(&self, message: &[u8]) {
-        match self.handle.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!("Failed to write to led interrupt: {}", 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) {
-        for led in buffer.get_mut()[7..].iter_mut() {
-            let mut bright = *led as f32 * self.config.brightness;
-            if bright > 254.0 {
-                bright = 254.0;
-            }
-            *led = bright as u8;
-        }
-        let data = AnimePacketType::from(buffer);
-        for row in data.iter() {
-            self.write_bytes(row);
-        }
-        self.write_bytes(&pkt_for_flush());
-    }
-
-    fn do_initialization(&self) {
-        let pkts = pkts_for_init();
-        self.write_bytes(&pkts[0]);
-        self.write_bytes(&pkts[1]);
-    }
-}
-
-pub struct CtrlAnimeTask<'a> {
-    inner: Arc<Mutex<CtrlAnime>>,
-    _c: Connection,
-    manager: ManagerProxy<'a>,
-}
-
-impl<'a> CtrlAnimeTask<'a> {
-    pub fn new(inner: Arc<Mutex<CtrlAnime>>) -> Self {
-        let connection = Connection::new_system().unwrap();
-
-        let manager = ManagerProxy::new(&connection).unwrap();
-
-        let c1 = inner.clone();
-        // Run this action when the system starts shutting down
-        manager
-            .connect_prepare_for_shutdown(move |shutdown| {
-                if shutdown {
-                    'outer: loop {
-                        if let Ok(lock) = c1.try_lock() {
-                            lock.thread_exit.store(true, Ordering::SeqCst);
-                            CtrlAnime::run_thread(c1.clone(), lock.cache.shutdown.clone(), false);
-                            break 'outer;
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        let c1 = inner.clone();
-        // Run this action when the system wakes up from sleep
-        manager
-            .connect_prepare_for_sleep(move |sleep| {
-                if !sleep {
-                    // wait a fraction for things to wake up properly
-                    std::thread::sleep(Duration::from_millis(100));
-                    'outer: loop {
-                        if let Ok(lock) = c1.try_lock() {
-                            lock.thread_exit.store(true, Ordering::SeqCst);
-                            CtrlAnime::run_thread(c1.clone(), lock.cache.wake.clone(), true);
-                            break 'outer;
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        Self {
-            inner,
-            _c: connection,
-            manager,
-        }
-    }
-}
-
-impl<'a> crate::CtrlTask for CtrlAnimeTask<'a> {
-    fn do_task(&self) -> Result<(), RogError> {
-        if let Ok(mut lock) = self.inner.try_lock() {
-            // Refresh the config and cache incase the user has edited it
-            let config = AnimeConfig::load();
-            lock.cache
-                .init_from_config(&config)
-                .map_err(|err| {
-                    warn!("CtrlAnimeTask: do_task {}", err);
-                    err
-                })
-                .ok();
-        }
-
-        // Check for signals on each task iteration, this will run the callbacks
-        // if any signal is recieved
-        self.manager.next_signal()?;
-        Ok(())
-    }
-}
-
-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());
-
-            let action = lock.cache.boot.clone();
-            CtrlAnime::run_thread(self.0.clone(), action, true);
-        }
-        Ok(())
-    }
-}
-
-pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
-
-/// The struct with the main dbus methods requires this trait
-impl crate::ZbusAdd for CtrlAnimeZbus {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlAnimeDisplay: add_to_server {}", err);
-                err
-            })
-            .ok();
-    }
-}
-
-// None of these calls can be guarnateed to succeed unless we loop until okay
-// If the try_lock *does* succeed then any other thread trying to lock will not grab it
-// until we finish.
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlAnimeZbus {
-    /// Writes a data stream of length. Will force system thread to exit until it is restarted
-    fn write(&self, input: AnimeDataBuffer) {
-        'outer: loop {
-            if let Ok(lock) = self.0.try_lock() {
-                lock.thread_exit.store(true, Ordering::SeqCst);
-                lock.write_data_buffer(input);
-                break 'outer;
-            }
-        }
-    }
-
-    /// Set the global AniMe brightness
-    fn set_brightness(&self, bright: f32) {
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                let mut bright = bright;
-                if bright < 0.0 {
-                    bright = 0.0
-                } else if bright > 254.0 {
-                    bright = 254.0;
-                }
-                lock.config.brightness = bright;
-                lock.config.write();
-                break 'outer;
-            }
-        }
-    }
-
-    /// Set whether the AniMe is displaying images/data
-    fn set_on_off(&self, status: bool) {
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                lock.write_bytes(&pkt_for_set_on(status));
-                lock.config.awake_enabled = status;
-                lock.config.write();
-
-                let states = AnimePowerStates {
-                    enabled: lock.config.awake_enabled,
-                    boot_anim_enabled: lock.config.boot_anim_enabled,
-                };
-                self.notify_power_states(&states)
-                    .unwrap_or_else(|err| warn!("{}", err));
-                break 'outer;
-            }
-        }
-    }
-
-    /// Set whether the AniMe will show boot, suspend, or off animations
-    fn set_boot_on_off(&self, on: bool) {
-        '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.config.boot_anim_enabled = on;
-                lock.config.write();
-
-                let states = AnimePowerStates {
-                    enabled: lock.config.awake_enabled,
-                    boot_anim_enabled: lock.config.boot_anim_enabled,
-                };
-                self.notify_power_states(&states)
-                    .unwrap_or_else(|err| warn!("{}", err));
-                break 'outer;
-            }
-        }
-    }
-
-    /// The main loop is the base system set action if the user isn't running
-    /// the user daemon
-    fn run_main_loop(&self, start: bool) {
-        if start {
-            'outer: loop {
-                if let Ok(lock) = self.0.try_lock() {
-                    lock.thread_exit.store(true, Ordering::SeqCst);
-                    CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
-                    break 'outer;
-                }
-            }
-        }
-    }
-
-    /// Get status of if the AniMe LEDs are on
-    #[dbus_interface(property)]
-    fn awake_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.awake_enabled;
-        }
-        true
-    }
-
-    /// Get the status of if factory system-status animations are enabled
-    #[dbus_interface(property)]
-    fn boot_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.boot_anim_enabled;
-        }
-        true
-    }
-
-    /// Notify listeners of the status of AniMe LED power and factory system-status animations
-    #[dbus_interface(signal)]
-    fn notify_power_states(&self, data: &AnimePowerStates) -> zbus::Result<()>;
-}

daemon/src/ctrl_anime/config.rs

@@ -166,11 +166,17 @@ impl AnimeConfig {
                     info!("Updated config version to: {}", VERSION);
                     return config;
                 }
-                AnimeConfig::write_backup(buf);
                 warn!(
-                    "Could not deserialise {}. Backed up as *-old",
-                    ANIME_CONFIG_PATH
+                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
+                    ANIME_CONFIG_PATH, ANIME_CONFIG_PATH
                 );
+                let cfg_old = ANIME_CONFIG_PATH.to_string() + "-old";
+                std::fs::rename(ANIME_CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
+                    panic!(
+                        "Could not rename. Please remove {} then restart service: Error {}",
+                        ANIME_CONFIG_PATH, err
+                    )
+                });
             }
         }
         AnimeConfig::create_default(&mut file)
@@ -246,12 +252,4 @@ impl AnimeConfig {
         file.write_all(json.as_bytes())
             .unwrap_or_else(|err| error!("Could not write config: {}", err));
     }
-
-    fn write_backup(buf: String) {
-        let mut path = ANIME_CONFIG_PATH.to_string();
-        path.push_str("-old");
-        let mut file = File::create(&path).expect("Couldn't overwrite config");
-        file.write_all(buf.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
 }

daemon/src/ctrl_anime/mod.rs

@@ -0,0 +1,424 @@
+pub mod config;
+pub mod zbus;
+
+use ::zbus::Connection;
+use async_trait::async_trait;
+use log::{error, info, warn};
+use logind_zbus::manager::ManagerProxy;
+use rog_anime::{
+    error::AnimeError,
+    usb::{
+        pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on, pkts_for_init, PROD_ID,
+        VENDOR_ID,
+    },
+    ActionData, AnimeDataBuffer, AnimePacketType, ANIME_DATA_LEN,
+};
+use rog_supported::AnimeSupportedFunctions;
+use rusb::{Device, DeviceHandle};
+use smol::{stream::StreamExt, Executor};
+use std::{
+    cell::RefCell,
+    error::Error,
+    sync::{Arc, Mutex},
+    thread::sleep,
+};
+use std::{
+    sync::atomic::{AtomicBool, Ordering},
+    time::Duration,
+};
+
+use crate::{error::RogError, GetSupported};
+
+use self::config::{AnimeConfig, AnimeConfigCached};
+
+impl GetSupported for CtrlAnime {
+    type A = AnimeSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        AnimeSupportedFunctions(CtrlAnime::get_device(VENDOR_ID, PROD_ID).is_ok())
+    }
+}
+
+pub struct CtrlAnime {
+    _node: String,
+    handle: RefCell<DeviceHandle<rusb::GlobalContext>>,
+    cache: AnimeConfigCached,
+    config: AnimeConfig,
+    // set to force thread to exit
+    thread_exit: Arc<AtomicBool>,
+    // Set to false when the thread exits
+    thread_running: Arc<AtomicBool>,
+}
+
+impl CtrlAnime {
+    #[inline]
+    pub fn new(config: AnimeConfig) -> Result<CtrlAnime, Box<dyn Error>> {
+        let node = Self::find_node("193b")?;
+        let device = Self::get_dev_handle()?;
+
+        info!("Device has an AniMe Matrix display");
+        let mut cache = AnimeConfigCached::default();
+        cache.init_from_config(&config)?;
+
+        let ctrl = CtrlAnime {
+            _node: node,
+            handle: RefCell::new(device),
+            cache,
+            config,
+            thread_exit: Arc::new(AtomicBool::new(false)),
+            thread_running: Arc::new(AtomicBool::new(false)),
+        };
+        ctrl.do_initialization();
+
+        Ok(ctrl)
+    }
+
+    fn find_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("usb").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(attr) = device.attribute_value("idProduct") {
+                if attr == id_product {
+                    if let Some(dev_node) = device.devnode() {
+                        info!("Using device at: {:?} for AniMe control", dev_node);
+                        return Ok(dev_node.to_string_lossy().to_string());
+                    }
+                }
+            }
+        }
+        Err(RogError::MissingFunction(
+            "ASUS AniMe device node not found".into(),
+        ))
+    }
+
+    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)
+    }
+
+    /// 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.
+    ///
+    /// Because this also writes to the usb device, other write tries (display only) *must*
+    /// get the mutex lock and set the thread_exit atomic.
+    fn run_thread(inner: Arc<Mutex<CtrlAnime>>, actions: Vec<ActionData>, mut once: bool) {
+        if actions.is_empty() {
+            warn!("AniMe system actions was empty");
+            return;
+        }
+
+        // Loop rules:
+        // - Lock the mutex **only when required**. That is, the lock must be held for the shortest duration possible.
+        // - An AtomicBool used for thread exit should be checked in every loop, including nested
+
+        // The only reason for this outer thread is to prevent blocking while waiting for the
+        // next spawned thread to exit
+        std::thread::Builder::new()
+            .name("AniMe system thread start".into())
+            .spawn(move || {
+                info!("AniMe new system thread started");
+                // Getting copies of these Atomics is done *in* the thread to ensure
+                // we don't block other threads/main
+                let thread_exit;
+                let thread_running;
+                loop {
+                    if let Ok(lock) = inner.try_lock() {
+                        thread_exit = lock.thread_exit.clone();
+                        thread_running = lock.thread_running.clone();
+                        break;
+                    }
+                }
+                // First two loops are to ensure we *do* aquire a lock on the mutex
+                // The reason the loop is required is because the USB writes can block
+                // for up to 10ms. We can't fail to get the atomics.
+                while thread_running.load(Ordering::SeqCst) {
+                    // Make any running loop exit first
+                    thread_exit.store(true, Ordering::SeqCst);
+                    break;
+                }
+
+                info!("AniMe no previous system thread running (now)");
+                thread_exit.store(false, Ordering::SeqCst);
+
+                'main: loop {
+                    thread_running.store(true, Ordering::SeqCst);
+                    for action in actions.iter() {
+                        if thread_exit.load(Ordering::SeqCst) {
+                            break 'main;
+                        }
+                        match action {
+                            ActionData::Animation(frames) => {
+                                if let Err(err) = rog_anime::run_animation(frames, &|frame| {
+                                    if thread_exit.load(Ordering::Acquire) {
+                                        info!("rog-anime: frame-loop was asked to exit");
+                                        return Ok(true); // Do safe exit
+                                    }
+                                    inner
+                                        .try_lock()
+                                        .map(|lock| {
+                                            lock.write_data_buffer(frame);
+                                            false // Don't exit yet
+                                        })
+                                        .map_err(|err| {
+                                            warn!("rog_anime::run_animation:callback {}", err);
+                                            AnimeError::NoFrames
+                                        })
+                                }) {
+                                    warn!("rog_anime::run_animation:Animation {}", err);
+                                    break 'main;
+                                };
+                            }
+                            ActionData::Image(image) => {
+                                once = false;
+                                if let Ok(lock) = inner.try_lock() {
+                                    lock.write_data_buffer(image.as_ref().clone())
+                                }
+                            }
+                            ActionData::Pause(duration) => sleep(*duration),
+                            ActionData::AudioEq => {}
+                            ActionData::SystemInfo => {}
+                            ActionData::TimeDate => {}
+                            ActionData::Matrix => {}
+                        }
+                    }
+                    if once || actions.is_empty() {
+                        break 'main;
+                    }
+                }
+                // Clear the display on exit
+                if let Ok(lock) = inner.try_lock() {
+                    let data = AnimeDataBuffer::from_vec([0u8; ANIME_DATA_LEN].to_vec());
+                    lock.write_data_buffer(data);
+                }
+                // Loop ended, set the atmonics
+                thread_running.store(false, Ordering::SeqCst);
+                info!("AniMe system thread exited");
+            })
+            .map(|err| info!("AniMe system thread: {:?}", err))
+            .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) {
+        for led in buffer.get_mut()[7..].iter_mut() {
+            let mut bright = *led as f32 * self.config.brightness;
+            if bright > 254.0 {
+                bright = 254.0;
+            }
+            *led = bright as u8;
+        }
+        let data = AnimePacketType::from(buffer);
+        for row in data.iter() {
+            self.write_bytes(row);
+        }
+        self.write_bytes(&pkt_for_flush());
+    }
+
+    fn do_initialization(&self) {
+        let pkts = pkts_for_init();
+        self.write_bytes(&pkts[0]);
+        self.write_bytes(&pkts[1]);
+    }
+}
+
+pub struct CtrlAnimeTask {
+    inner: Arc<Mutex<CtrlAnime>>,
+}
+
+impl CtrlAnimeTask {
+    pub async fn new(inner: Arc<Mutex<CtrlAnime>>) -> CtrlAnimeTask {
+        Self { inner }
+    }
+}
+
+#[async_trait]
+impl crate::CtrlTask for CtrlAnimeTask {
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system()
+            .await
+            .expect("CtrlAnimeTask could not create dbus connection");
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlAnimeTask could not create ManagerProxy");
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_sleep().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                if args.start {
+                                    loop {
+                                        // Loop is required to try an attempt to get the mutex *without* blocking
+                                        // other threads - it is possible to end up with deadlocks otherwise.
+                                        if let Ok(lock) = inner.clone().try_lock() {
+                                            info!("CtrlAnimeTask running sleep animation");
+                                            CtrlAnime::run_thread(
+                                                inner.clone(),
+                                                lock.cache.shutdown.clone(),
+                                                true,
+                                            );
+                                            break;
+                                        }
+                                    }
+                                } else {
+                                    loop {
+                                        if let Ok(lock) = inner.clone().try_lock() {
+                                            info!("CtrlAnimeTask running wake animation");
+                                            CtrlAnime::run_thread(
+                                                inner.clone(),
+                                                lock.cache.wake.clone(),
+                                                true,
+                                            );
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlAnimeTask could not create ManagerProxy");
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_shutdown().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                if args.start {
+                                    loop {
+                                        if let Ok(lock) = inner.clone().try_lock() {
+                                            info!("CtrlAnimeTask running sleep animation");
+                                            CtrlAnime::run_thread(
+                                                inner.clone(),
+                                                lock.cache.shutdown.clone(),
+                                                true,
+                                            );
+                                            break;
+                                        }
+                                    }
+                                } else {
+                                    // If waking up - intention is to catch hibernation event
+                                    loop {
+                                        if let Ok(lock) = inner.clone().lock() {
+                                            info!("CtrlAnimeTask running wake animation");
+                                            CtrlAnime::run_thread(
+                                                inner.clone(),
+                                                lock.cache.wake.clone(),
+                                                true,
+                                            );
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+
+        Ok(())
+    }
+}
+
+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());
+
+            let action = lock.cache.boot.clone();
+            CtrlAnime::run_thread(self.0.clone(), action, true);
+        }
+        Ok(())
+    }
+}

daemon/src/ctrl_anime/zbus.rs

@@ -0,0 +1,140 @@
+use std::sync::{Arc, Mutex};
+
+use async_trait::async_trait;
+use rog_anime::{
+    usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
+    AnimeDataBuffer, AnimePowerStates,
+};
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use std::sync::atomic::Ordering;
+
+use super::CtrlAnime;
+
+pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
+
+/// The struct with the main dbus methods requires this trait
+#[async_trait]
+impl crate::ZbusAdd for CtrlAnimeZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
+    }
+}
+
+// None of these calls can be guarnateed to succeed unless we loop until okay
+// If the try_lock *does* succeed then any other thread trying to lock will not grab it
+// until we finish.
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnimeZbus {
+    /// Writes a data stream of length. Will force system thread to exit until it is restarted
+    fn write(&self, input: AnimeDataBuffer) {
+        'outer: loop {
+            if let Ok(lock) = self.0.try_lock() {
+                lock.thread_exit.store(true, Ordering::SeqCst);
+                lock.write_data_buffer(input);
+                break 'outer;
+            }
+        }
+    }
+
+    /// Set the global AniMe brightness
+    fn set_brightness(&self, bright: f32) {
+        'outer: loop {
+            if let Ok(mut lock) = self.0.try_lock() {
+                let mut bright = bright;
+                if bright < 0.0 {
+                    bright = 0.0
+                } else if bright > 254.0 {
+                    bright = 254.0;
+                }
+                lock.config.brightness = bright;
+                lock.config.write();
+                break 'outer;
+            }
+        }
+    }
+
+    /// Set whether the AniMe is displaying images/data
+    async fn set_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, status: bool) {
+        let states;
+        'outer: loop {
+            if let Ok(mut lock) = self.0.try_lock() {
+                lock.write_bytes(&pkt_for_set_on(status));
+                lock.config.awake_enabled = status;
+                lock.config.write();
+
+                states = Some(AnimePowerStates {
+                    brightness: lock.config.brightness.floor() as u8,
+                    enabled: lock.config.awake_enabled,
+                    boot_anim_enabled: lock.config.boot_anim_enabled,
+                });
+                break 'outer;
+            }
+        }
+        if let Some(state) = states {
+            Self::notify_power_states(&ctxt, state).await.ok();
+        }
+    }
+
+    /// Set whether the AniMe will show boot, suspend, or off animations
+    async fn set_boot_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, on: bool) {
+        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.config.boot_anim_enabled = on;
+                lock.config.write();
+
+                states = Some(AnimePowerStates {
+                    brightness: lock.config.brightness.floor() as u8,
+                    enabled: lock.config.awake_enabled,
+                    boot_anim_enabled: lock.config.boot_anim_enabled,
+                });
+                break 'outer;
+            }
+        }
+        if let Some(state) = states {
+            Self::notify_power_states(&ctxt, state).await.ok();
+        }
+    }
+
+    /// The main loop is the base system set action if the user isn't running
+    /// the user daemon
+    fn run_main_loop(&self, start: bool) {
+        if start {
+            'outer: loop {
+                if let Ok(lock) = self.0.try_lock() {
+                    lock.thread_exit.store(true, Ordering::SeqCst);
+                    CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
+                    break 'outer;
+                }
+            }
+        }
+    }
+
+    /// Get status of if the AniMe LEDs are on/displaying while system is awake
+    #[dbus_interface(property)]
+    fn awake_enabled(&self) -> bool {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.config.awake_enabled;
+        }
+        true
+    }
+
+    /// Get the status of if factory system-status animations are enabled
+    #[dbus_interface(property)]
+    fn boot_enabled(&self) -> bool {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.config.boot_anim_enabled;
+        }
+        true
+    }
+
+    /// Notify listeners of the status of AniMe LED power and factory system-status animations
+    #[dbus_interface(signal)]
+    async fn notify_power_states(
+        ctxt: &SignalContext<'_>,
+        data: AnimePowerStates,
+    ) -> zbus::Result<()>;
+}

daemon/src/ctrl_aura/config.rs

@@ -1,6 +1,6 @@
 use crate::laptops::LaptopLedData;
 use log::{error, info, warn};
-use rog_aura::{AuraEffect, AuraModeNum, AuraZone, LedBrightness};
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, LedBrightness, LedPowerStates};
 use serde_derive::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::fs::{File, OpenOptions};
@@ -8,27 +8,6 @@ use std::io::{Read, Write};
 
 pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
 
-#[derive(Deserialize, Serialize)]
-pub struct AuraConfigV320 {
-    pub brightness: u32,
-    pub current_mode: AuraModeNum,
-    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
-}
-
-impl AuraConfigV320 {
-    pub(crate) fn into_current(self) -> AuraConfig {
-        AuraConfig {
-            brightness: <LedBrightness>::from(self.brightness),
-            current_mode: self.current_mode,
-            builtins: self.builtins,
-            multizone: self.multizone,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
-        }
-    }
-}
-
 #[derive(Deserialize, Serialize)]
 pub struct AuraConfigV352 {
     pub brightness: LedBrightness,
@@ -44,8 +23,42 @@ impl AuraConfigV352 {
             current_mode: self.current_mode,
             builtins: self.builtins,
             multizone: self.multizone,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
+            power_states: LedPowerStates {
+                boot_anim: true,
+                sleep_anim: true,
+                all_leds: true,
+                keys_leds: true,
+                side_leds: true,
+            },
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct AuraConfigV407 {
+    pub brightness: LedBrightness,
+    pub current_mode: AuraModeNum,
+    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    pub multizone: Option<AuraMultiZone>,
+    pub awake_enabled: bool,
+    pub sleep_anim_enabled: bool,
+    pub side_leds_enabled: bool,
+}
+
+impl AuraConfigV407 {
+    pub(crate) fn into_current(self) -> AuraConfig {
+        AuraConfig {
+            brightness: self.brightness,
+            current_mode: self.current_mode,
+            builtins: self.builtins,
+            multizone: self.multizone,
+            power_states: LedPowerStates {
+                boot_anim: true,
+                sleep_anim: self.sleep_anim_enabled,
+                all_leds: self.awake_enabled,
+                keys_leds: self.awake_enabled,
+                side_leds: self.side_leds_enabled,
+            },
         }
     }
 }
@@ -56,8 +69,7 @@ pub struct AuraConfig {
     pub current_mode: AuraModeNum,
     pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
     pub multizone: Option<AuraMultiZone>,
-    pub awake_enabled: bool,
-    pub sleep_anim_enabled: bool,
+    pub power_states: LedPowerStates,
 }
 
 impl Default for AuraConfig {
@@ -67,8 +79,13 @@ impl Default for AuraConfig {
             current_mode: AuraModeNum::Static,
             builtins: BTreeMap::new(),
             multizone: None,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
+            power_states: LedPowerStates {
+                boot_anim: true,
+                sleep_anim: true,
+                all_leds: true,
+                keys_leds: true,
+                side_leds: true,
+            },
         }
     }
 }
@@ -90,26 +107,35 @@ impl AuraConfig {
         let mut buf = String::new();
         if let Ok(read_len) = file.read_to_string(&mut buf) {
             if read_len == 0 {
-                return AuraConfig::create_default(&mut file, &supported_led_modes);
+                return AuraConfig::create_default(&mut file, supported_led_modes);
             } else {
                 if let Ok(data) = serde_json::from_str(&buf) {
                     return data;
-                } else if let Ok(data) = serde_json::from_str::<AuraConfigV320>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated AuraConfig version");
-                    return config;
                 } else if let Ok(data) = serde_json::from_str::<AuraConfigV352>(&buf) {
                     let config = data.into_current();
                     config.write();
                     info!("Updated AuraConfig version");
                     return config;
+                } else if let Ok(data) = serde_json::from_str::<AuraConfigV407>(&buf) {
+                    let config = data.into_current();
+                    config.write();
+                    info!("Updated AuraConfig version");
+                    return config;
                 }
-                warn!("Could not deserialise {}", AURA_CONFIG_PATH);
-                panic!("Please remove {} then restart asusd", AURA_CONFIG_PATH);
+                warn!(
+                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
+                    AURA_CONFIG_PATH, AURA_CONFIG_PATH
+                );
+                let cfg_old = AURA_CONFIG_PATH.to_string() + "-old";
+                std::fs::rename(AURA_CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
+                    panic!(
+                        "Could not rename. Please remove {} then restart service: Error {}",
+                        AURA_CONFIG_PATH, err
+                    )
+                });
             }
         }
-        AuraConfig::create_default(&mut file, &supported_led_modes)
+        AuraConfig::create_default(&mut file, supported_led_modes)
     }
 
     fn create_default(file: &mut File, support_data: &LaptopLedData) -> Self {
@@ -153,7 +179,7 @@ impl AuraConfig {
             .unwrap_or_else(|err| error!("Could not write config: {}", err));
     }
 
-    /// Multipurpose, will accecpt AuraEffect with zones and put in the correct store
+    /// Multipurpose, will accept AuraEffect with zones and put in the correct store
     pub fn set_builtin(&mut self, effect: AuraEffect) {
         match effect.zone() {
             AuraZone::None => {

daemon/src/ctrl_aura/controller.rs

@@ -2,22 +2,21 @@
 static KBD_BRIGHT_PATH: &str = "/sys/class/leds/asus::kbd_backlight/brightness";
 
 use crate::{
-    config_aura::AuraConfig,
     error::RogError,
     laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
     CtrlTask,
 };
-use log::{info, warn};
-use logind_zbus::ManagerProxy;
+use async_trait::async_trait;
+use log::{error, info, warn};
+use logind_zbus::manager::ManagerProxy;
+use rog_aura::usb::leds_message;
 use rog_aura::{
-    usb::{
-        LED_APPLY, LED_AWAKE_OFF_SLEEP_OFF, LED_AWAKE_OFF_SLEEP_ON, LED_AWAKE_ON_SLEEP_OFF,
-        LED_AWAKE_ON_SLEEP_ON, LED_SET,
-    },
+    usb::{LED_APPLY, LED_SET},
     AuraEffect, LedBrightness, LED_MSG_LEN,
 };
-use rog_types::supported::LedSupportedFunctions;
-use std::{fs::OpenOptions, thread::spawn};
+use rog_supported::LedSupportedFunctions;
+use smol::{stream::StreamExt, Executor};
+use std::fs::OpenOptions;
 use std::io::{Read, Write};
 use std::path::Path;
 use std::sync::Arc;
@@ -26,15 +25,17 @@ use zbus::Connection;
 
 use crate::GetSupported;
 
+use super::config::AuraConfig;
+
 impl GetSupported for CtrlKbdLed {
     type A = LedSupportedFunctions;
 
     fn get_supported() -> Self::A {
         // let mode = <&str>::from(&<AuraModes>::from(*mode));
-        let multizone_led_mode = false;
-        let per_key_led_mode = false;
         let laptop = LaptopLedData::get_data();
         let stock_led_modes = laptop.standard;
+        let multizone_led_mode = laptop.multizone;
+        let per_key_led_mode = laptop.per_key;
 
         LedSupportedFunctions {
             brightness_set: CtrlKbdLed::get_kbd_bright_path().is_some(),
@@ -53,47 +54,13 @@ pub struct CtrlKbdLed {
     pub config: AuraConfig,
 }
 
-pub struct CtrlKbdLedTask<'a> {
+pub struct CtrlKbdLedTask {
     inner: Arc<Mutex<CtrlKbdLed>>,
-    _c: Connection,
-    manager: ManagerProxy<'a>,
 }
 
-impl<'a> CtrlKbdLedTask<'a> {
+impl CtrlKbdLedTask {
     pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        let connection = Connection::new_system().unwrap();
-
-        let manager = ManagerProxy::new(&connection).unwrap();
-
-        let c1 = inner.clone();
-        // Run this action when the system wakes up from sleep
-        manager
-            .connect_prepare_for_sleep(move |sleep| {
-                if !sleep {
-                    let c1 = c1.clone();
-                    spawn(move || {
-                        // wait a fraction for things to wake up properly
-                        //std::thread::sleep(Duration::from_millis(100));
-                        loop {
-                        if let Ok(ref mut lock) = c1.try_lock() {
-                            lock.set_brightness(lock.config.brightness).ok();
-                            break;
-                        }}
-                    });
-                }                    
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        Self {
-            inner,
-            _c: connection,
-            manager,
-        }
+        Self { inner }
     }
 
     fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
@@ -121,12 +88,62 @@ impl<'a> CtrlKbdLedTask<'a> {
     }
 }
 
-impl<'a> CtrlTask for CtrlKbdLedTask<'a> {
-    fn do_task(&self) -> Result<(), RogError> {
-        self.manager.next_signal()?;
-        if let Ok(ref mut lock) = self.inner.try_lock() {
-            return Self::update_config(lock);
-        }
+#[async_trait]
+impl CtrlTask for CtrlKbdLedTask {
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system()
+            .await
+            .expect("CtrlKbdLedTask could not create dbus connection");
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlKbdLedTask could not create ManagerProxy");
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_sleep().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                // If waking up
+                                if !args.start {
+                                    info!("CtrlKbdLedTask reloading brightness and modes");
+                                    loop {
+                                        // Loop so that we do aquire the lock but also don't block other
+                                        // threads (prevents potential deadlocks)
+                                        if let Ok(lock) = inner.clone().try_lock() {
+                                            // Can't reload brightness due to system setting the brightness on sleep/wake
+                                            // and the config update task saving that change.
+                                            // lock.set_brightness(lock.config.brightness)
+                                            //     .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                                            //     .ok();
+                                            if let Some(mode) =
+                                                lock.config.builtins.get(&lock.config.current_mode)
+                                            {
+                                                lock.write_mode(mode)
+                                                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                                                    .ok();
+                                            }
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+
+        let inner = self.inner.clone();
+        self.repeating_task(500, executor, move || loop {
+            if let Ok(ref mut lock) = inner.try_lock() {
+                Self::update_config(lock).unwrap();
+                break;
+            }
+        })
+        .await;
         Ok(())
     }
 }
@@ -141,8 +158,8 @@ impl crate::Reloadable for CtrlKbdLedReloader {
                 ctrl.do_command(mode).ok();
             }
 
-            ctrl.set_states_enabled(ctrl.config.awake_enabled, ctrl.config.sleep_anim_enabled)
-                .map_err(|err| warn!("{}", err))
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{err}"))
                 .ok();
         }
         Ok(())
@@ -166,9 +183,10 @@ impl CtrlKbdLed {
             match Self::find_led_node(prod) {
                 Ok(node) => {
                     led_node = Some(node);
+                    info!("Looked for keyboard controller 0x{prod}: Found");
                     break;
                 }
-                Err(err) => warn!("led_node: {}", err),
+                Err(err) => info!("Looked for keyboard controller 0x{prod}: {err}"),
             }
         }
 
@@ -237,20 +255,44 @@ impl CtrlKbdLed {
         Ok(())
     }
 
-    /// Set if awake/on LED active, and/or sleep animation active
-    pub(super) fn set_states_enabled(&self, awake: bool, sleep: bool) -> Result<(), RogError> {
-        let bytes = if awake && sleep {
-            LED_AWAKE_ON_SLEEP_ON
-        } else if awake && !sleep {
-            LED_AWAKE_ON_SLEEP_OFF
-        } else if !awake && sleep {
-            LED_AWAKE_OFF_SLEEP_ON
-        } else if !awake && !sleep {
-            LED_AWAKE_OFF_SLEEP_OFF
+    pub fn next_brightness(&mut self) -> Result<(), RogError> {
+        let mut bright = (self.config.brightness as u32) + 1;
+        if bright > 3 {
+            bright = 0;
+        }
+        self.config.brightness = <LedBrightness>::from(bright);
+        self.config.write();
+        self.set_brightness(self.config.brightness)
+    }
+
+    pub fn prev_brightness(&mut self) -> Result<(), RogError> {
+        let mut bright = self.config.brightness as u32;
+        if bright == 0 {
+            bright = 3;
         } else {
-            LED_AWAKE_ON_SLEEP_ON
-        };
-        self.write_bytes(&bytes)?;
+            bright -= 1;
+        }
+        self.config.brightness = <LedBrightness>::from(bright);
+        self.config.write();
+        self.set_brightness(self.config.brightness)
+    }
+
+    /// 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> {
+        let bytes = leds_message(
+            config.power_states.boot_anim,
+            config.power_states.sleep_anim,
+            config.power_states.all_leds,
+            config.power_states.keys_leds,
+            config.power_states.side_leds,
+        );
+
+        // Quite ugly, must be a more idiomatic way to do
+        let message = [
+            0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ];
+
+        self.write_bytes(&message)?;
         self.write_bytes(&LED_SET)?;
         // Changes won't persist unless apply is set
         self.write_bytes(&LED_APPLY)?;
@@ -369,7 +411,7 @@ impl CtrlKbdLed {
 
             self.config.read();
             if let Some(data) = self.config.builtins.get(&next) {
-                self.write_mode(&data)?;
+                self.write_mode(data)?;
                 self.config.current_mode = next;
             }
             self.config.write();
@@ -380,7 +422,7 @@ impl CtrlKbdLed {
 
     #[inline]
     fn write_mode(&self, mode: &AuraEffect) -> Result<(), RogError> {
-        if !self.supported_modes.standard.contains(&mode.mode()) {
+        if !self.supported_modes.standard.contains(mode.mode()) {
             return Err(RogError::NotSupported);
         }
         let bytes: [u8; LED_MSG_LEN] = mode.into();

daemon/src/ctrl_aura/mod.rs

@@ -1,2 +1,3 @@
+pub mod config;
 pub mod controller;
 pub mod zbus;

daemon/src/ctrl_aura/zbus.rs

@@ -0,0 +1,312 @@
+use async_trait::async_trait;
+use log::warn;
+use rog_aura::{AuraEffect, LedBrightness, LedPowerStates};
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use super::controller::CtrlKbdLedZbus;
+
+#[async_trait]
+impl crate::ZbusAdd for CtrlKbdLedZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Led", server).await;
+    }
+}
+
+/// The main interface for changing, reading, or notfying signals
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlKbdLedZbus {
+    /// Set the keyboard brightness level (0-3)
+    async fn set_brightness(&mut self, brightness: LedBrightness) {
+        if let Ok(ctrl) = self.0.try_lock() {
+            ctrl.set_brightness(brightness)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+        }
+    }
+
+    /// Set the keyboard LED to enabled while the device is awake
+    async fn set_boot_enabled(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: bool,
+    ) {
+        let mut states = None;
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            ctrl.config.power_states.boot_anim = enabled;
+            ctrl.config.write();
+
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+
+            states = Some(ctrl.config.power_states);
+        }
+        // Need to pull state out like this due to MutexGuard
+        if let Some(states) = states {
+            Self::notify_power_states(&ctxt, &states)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    /// Set the keyboard LED suspend animation to enabled while the device is suspended
+    async fn set_sleep_enabled(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: bool,
+    ) {
+        let mut states = None;
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            ctrl.config.power_states.sleep_anim = enabled;
+            ctrl.config.write();
+
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+
+            states = Some(ctrl.config.power_states);
+        }
+        if let Some(states) = states {
+            Self::notify_power_states(&ctxt, &states)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    /// Set all the keyboard LEDs (keys and side) to enabled
+    async fn set_all_leds_enabled(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: bool,
+    ) {
+        let mut states = None;
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            ctrl.config.power_states.all_leds = enabled;
+            ctrl.config.power_states.keys_leds = enabled;
+            ctrl.config.power_states.side_leds = enabled;
+            ctrl.config.write();
+
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+
+            states = Some(ctrl.config.power_states);
+        }
+        // Need to pull state out like this due to MutexGuard
+        if let Some(states) = states {
+            Self::notify_power_states(&ctxt, &states)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    /// Set the keyboard keys LEDs to enabled
+    async fn set_keys_leds_enabled(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: bool,
+    ) {
+        let mut states = None;
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            ctrl.config.power_states.keys_leds = enabled;
+            ctrl.config.write();
+
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+
+            states = Some(ctrl.config.power_states);
+        }
+        // Need to pull state out like this due to MutexGuard
+        if let Some(states) = states {
+            Self::notify_power_states(&ctxt, &states)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    /// Set the keyboard side LEDs to enabled
+    async fn set_side_leds_enabled(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: bool,
+    ) {
+        let mut states = None;
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            ctrl.config.power_states.side_leds = enabled;
+            ctrl.config.write();
+
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+
+            states = Some(ctrl.config.power_states);
+        }
+        // Need to pull state out like this due to MutexGuard
+        if let Some(states) = states {
+            Self::notify_power_states(&ctxt, &states)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    async fn set_led_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        effect: AuraEffect,
+    ) {
+        let mut led = None;
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            match ctrl.do_command(effect) {
+                Ok(_) => {
+                    if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                        led = Some(mode.clone());
+                    }
+                }
+                Err(err) => {
+                    warn!("{}", err);
+                }
+            }
+        }
+        if let Some(led) = led {
+            Self::notify_led(&ctxt, led)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    async fn next_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut led = None;
+        if let Ok(mut ctrl) = self.0.lock() {
+            ctrl.toggle_mode(false)
+                .unwrap_or_else(|err| warn!("{}", err));
+
+            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                led = Some(mode.clone());
+            }
+        }
+        if let Some(led) = led {
+            Self::notify_led(&ctxt, led)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    async fn prev_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut led = None;
+        if let Ok(mut ctrl) = self.0.lock() {
+            ctrl.toggle_mode(true)
+                .unwrap_or_else(|err| warn!("{}", err));
+
+            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                led = Some(mode.clone());
+            }
+        }
+        if let Some(led) = led {
+            Self::notify_led(&ctxt, led)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    async fn next_led_brightness(&self) {
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            ctrl.next_brightness()
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    async fn prev_led_brightness(&self) {
+        if let Ok(mut ctrl) = self.0.try_lock() {
+            ctrl.prev_brightness()
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+    }
+
+    #[dbus_interface(property)]
+    async fn boot_enabled(&self) -> bool {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.config.power_states.boot_anim;
+        }
+        true
+    }
+
+    #[dbus_interface(property)]
+    async fn sleep_enabled(&self) -> bool {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.config.power_states.sleep_anim;
+        }
+        true
+    }
+
+    #[dbus_interface(property)]
+    async fn all_leds_enabled(&self) -> bool {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.config.power_states.all_leds;
+        }
+        true
+    }
+
+    #[dbus_interface(property)]
+    async fn keys_leds_enabled(&self) -> bool {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.config.power_states.keys_leds;
+        }
+        true
+    }
+
+    #[dbus_interface(property)]
+    fn side_leds_enabled(&self) -> bool {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.config.power_states.side_leds;
+        }
+        true
+    }
+
+    /// Return the current mode data
+    #[dbus_interface(property)]
+    async fn led_mode(&self) -> String {
+        if let Ok(ctrl) = self.0.try_lock() {
+            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+                if let Ok(json) = serde_json::to_string(&mode) {
+                    return json;
+                }
+            }
+        }
+        warn!("SetKeyBacklight could not deserialise");
+        "SetKeyBacklight could not deserialise".to_string()
+    }
+
+    /// Return a list of available modes
+    #[dbus_interface(property)]
+    async fn led_modes(&self) -> String {
+        if let Ok(ctrl) = self.0.try_lock() {
+            if let Ok(json) = serde_json::to_string(&ctrl.config.builtins) {
+                return json;
+            }
+        }
+        warn!("SetKeyBacklight could not deserialise");
+        "SetKeyBacklight could not serialise".to_string()
+    }
+
+    /// Return the current LED brightness
+    #[dbus_interface(property)]
+    async fn led_brightness(&self) -> i8 {
+        if let Ok(ctrl) = self.0.try_lock() {
+            return ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1);
+        }
+        warn!("SetKeyBacklight could not serialise");
+        -1
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
+
+    #[dbus_interface(signal)]
+    async fn notify_power_states(
+        signal_ctxt: &SignalContext<'_>,
+        data: &LedPowerStates,
+    ) -> zbus::Result<()>;
+}

daemon/src/ctrl_charge.rs

@@ -1,16 +1,23 @@
+use crate::CtrlTask;
 use crate::{config::Config, error::RogError, GetSupported};
-//use crate::dbus::DbusEvents;
+use async_trait::async_trait;
 use log::{info, warn};
-use rog_types::supported::ChargeSupportedFunctions;
+use logind_zbus::manager::ManagerProxy;
+use rog_supported::ChargeSupportedFunctions;
+use smol::stream::StreamExt;
+use smol::Executor;
 use std::fs::OpenOptions;
 use std::io::Write;
 use std::path::Path;
 use std::sync::Arc;
 use std::sync::Mutex;
 use zbus::dbus_interface;
-use zvariant::ObjectPath;
+use zbus::Connection;
+use zbus::SignalContext;
 
-static BAT_CHARGE_PATH: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
+static BAT_CHARGE_PATH0: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
+static BAT_CHARGE_PATH1: &str = "/sys/class/power_supply/BAT1/charge_control_end_threshold";
+static BAT_CHARGE_PATH2: &str = "/sys/class/power_supply/BAT2/charge_control_end_threshold";
 
 impl GetSupported for CtrlCharge {
     type A = ChargeSupportedFunctions;
@@ -28,24 +35,27 @@ pub struct CtrlCharge {
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlCharge {
-    pub fn set_limit(&mut self, limit: u8) {
+    async fn set_limit(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        limit: u8,
+    ) -> zbus::fdo::Result<()> {
+        if !(20..=100).contains(&limit) {
+            return Err(RogError::ChargeLimit(limit))?;
+        }
         if let Ok(mut config) = self.config.try_lock() {
-            self.set(limit, &mut config)
-                .map_err(|err| {
-                    warn!("CtrlCharge: set_limit {}", err);
-                    err
-                })
-                .ok();
-            self.notify_charge(limit)
+            Self::set(limit, &mut config)
                 .map_err(|err| {
                     warn!("CtrlCharge: set_limit {}", err);
                     err
                 })
                 .ok();
         }
+        Self::notify_charge(&ctxt, limit).await?;
+        Ok(())
     }
 
-    pub fn limit(&self) -> i8 {
+    fn limit(&self) -> i8 {
         if let Ok(config) = self.config.try_lock() {
             return config.bat_charge_limit as i8;
         }
@@ -53,21 +63,13 @@ impl CtrlCharge {
     }
 
     #[dbus_interface(signal)]
-    pub fn notify_charge(&self, limit: u8) -> zbus::Result<()> {}
+    async fn notify_charge(ctxt: &SignalContext<'_>, limit: u8) -> zbus::Result<()>;
 }
 
+#[async_trait]
 impl crate::ZbusAdd for CtrlCharge {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Charge"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlCharge: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Charge", server).await;
     }
 }
 
@@ -75,7 +77,7 @@ impl crate::Reloadable for CtrlCharge {
     fn reload(&mut self) -> Result<(), RogError> {
         if let Ok(mut config) = self.config.try_lock() {
             config.read();
-            self.set(config.bat_charge_limit, &mut config)?;
+            Self::set(config.bat_charge_limit, &mut config)?;
         }
         Ok(())
     }
@@ -88,8 +90,12 @@ impl CtrlCharge {
     }
 
     fn get_battery_path() -> Result<&'static str, RogError> {
-        if Path::new(BAT_CHARGE_PATH).exists() {
-            Ok(BAT_CHARGE_PATH)
+        if Path::new(BAT_CHARGE_PATH0).exists() {
+            Ok(BAT_CHARGE_PATH0)
+        } else if Path::new(BAT_CHARGE_PATH1).exists() {
+            Ok(BAT_CHARGE_PATH1)
+        } else if Path::new(BAT_CHARGE_PATH2).exists() {
+            Ok(BAT_CHARGE_PATH2)
         } else {
             Err(RogError::MissingFunction(
                 "Charge control not available, you may require a v5.8.10 series kernel or newer"
@@ -98,20 +104,19 @@ impl CtrlCharge {
         }
     }
 
-    pub(super) fn set(&self, limit: u8, config: &mut Config) -> Result<(), RogError> {
+    pub(super) fn set(limit: u8, config: &mut Config) -> Result<(), RogError> {
         if !(20..=100).contains(&limit) {
-            warn!(
-                "Unable to set battery charge limit, must be between 20-100: requested {}",
-                limit
-            );
+            return Err(RogError::ChargeLimit(limit));
         }
 
+        let path = Self::get_battery_path()?;
+
         let mut file = OpenOptions::new()
             .write(true)
-            .open(BAT_CHARGE_PATH)
-            .map_err(|err| RogError::Path(BAT_CHARGE_PATH.into(), err))?;
+            .open(path)
+            .map_err(|err| RogError::Path(path.into(), err))?;
         file.write_all(limit.to_string().as_bytes())
-            .map_err(|err| RogError::Write(BAT_CHARGE_PATH.into(), err))?;
+            .map_err(|err| RogError::Write(path.into(), err))?;
         info!("Battery charge limit: {}", limit);
 
         config.read();
@@ -121,3 +126,76 @@ impl CtrlCharge {
         Ok(())
     }
 }
+
+#[async_trait]
+impl CtrlTask for CtrlCharge {
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system()
+            .await
+            .expect("CtrlCharge could not create dbus connection");
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlCharge could not create ManagerProxy");
+
+        let config1 = self.config.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_sleep().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                // If waking up
+                                if !args.start {
+                                    info!("CtrlCharge reloading charge limit");
+                                    if let Ok(mut lock) = config1.try_lock() {
+                                        Self::set(lock.bat_charge_limit, &mut lock)
+                                            .map_err(|err| {
+                                                warn!("CtrlCharge: set_limit {}", err);
+                                                err
+                                            })
+                                            .ok();
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlCharge could not create ManagerProxy");
+
+        let config = self.config.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_shutdown().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                // If waking up - intention is to catch hibernation event
+                                if !args.start {
+                                    info!("CtrlCharge reloading charge limit");
+                                    loop {
+                                        if let Ok(mut lock) = config.clone().try_lock() {
+                                            Self::set(lock.bat_charge_limit, &mut lock)
+                                                .map_err(|err| {
+                                                    warn!("CtrlCharge: set_limit {}", err);
+                                                    err
+                                                })
+                                                .ok();
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+        Ok(())
+    }
+}

daemon/src/ctrl_gfx/controller.rs

@@ -1,679 +0,0 @@
-use ::zbus::Connection;
-use ctrl_gfx::error::GfxError;
-use ctrl_gfx::*;
-use ctrl_rog_bios::CtrlRogBios;
-use log::{error, info, warn};
-use logind_zbus::{
-    types::{SessionClass, SessionInfo, SessionState, SessionType},
-    ManagerProxy, SessionProxy,
-};
-use rog_types::gfx_vendors::{GfxPower, GfxRequiredUserAction, GfxVendors};
-use std::{io::Write, ops::Add, path::Path, time::Instant};
-use std::{iter::FromIterator, thread::JoinHandle};
-use std::{process::Command, thread::sleep, time::Duration};
-use std::{str::FromStr, sync::mpsc};
-use std::{sync::Arc, sync::Mutex};
-use sysfs_class::RuntimePM;
-use sysfs_class::{PciDevice, SysClass};
-use system::{GraphicsDevice, PciBus};
-
-use crate::*;
-
-const THREAD_TIMEOUT_MSG: &str = "GFX: thread time exceeded 3 minutes, exiting";
-
-pub struct CtrlGraphics {
-    bus: PciBus,
-    _amd: Vec<GraphicsDevice>,
-    _intel: Vec<GraphicsDevice>,
-    nvidia: Vec<GraphicsDevice>,
-    #[allow(dead_code)]
-    other: Vec<GraphicsDevice>,
-    config: Arc<Mutex<Config>>,
-    thread_kill: Arc<Mutex<Option<mpsc::Sender<bool>>>>,
-}
-
-impl Reloadable for CtrlGraphics {
-    fn reload(&mut self) -> Result<(), RogError> {
-        self.auto_power()?;
-        info!("GFX: Reloaded gfx mode: {:?}", self.get_gfx_mode()?);
-        Ok(())
-    }
-}
-
-impl CtrlGraphics {
-    pub fn new(config: Arc<Mutex<Config>>) -> std::io::Result<CtrlGraphics> {
-        let bus = PciBus::new()?;
-        info!("GFX: Rescanning PCI bus");
-        bus.rescan()?;
-        let devs = PciDevice::all()?;
-
-        let functions = |parent: &PciDevice| -> Vec<PciDevice> {
-            let mut functions = Vec::new();
-            if let Some(parent_slot) = parent.id().split('.').next() {
-                for func in devs.iter() {
-                    if let Some(func_slot) = func.id().split('.').next() {
-                        if func_slot == parent_slot {
-                            info!("GFX: {}: Function for {}", func.id(), parent.id());
-                            functions.push(func.clone());
-                        }
-                    }
-                }
-            }
-            functions
-        };
-
-        let mut amd = Vec::new();
-        let mut intel = Vec::new();
-        let mut nvidia = Vec::new();
-        let mut other = Vec::new();
-        for dev in devs.iter() {
-            let c = dev.class().map_err(|err| {
-                error!(
-                    "GFX: device error: {}, {}",
-                    dev.path().to_string_lossy(),
-                    err
-                );
-                err
-            })?;
-            if 0x03 == (c >> 16) & 0xFF {
-                match dev.vendor()? {
-                    0x1002 => {
-                        info!("GFX: {}: AMD graphics", dev.id());
-                        amd.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    0x10DE => {
-                        info!("GFX: {}: NVIDIA graphics", dev.id());
-                        dev.set_runtime_pm(sysfs_class::RuntimePowerManagement::On)?;
-                        nvidia.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    0x8086 => {
-                        info!("GFX: {}: Intel graphics", dev.id());
-                        intel.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    vendor => {
-                        info!("GFX: {}: Other({:X}) graphics", dev.id(), vendor);
-                        other.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                }
-            }
-        }
-
-        Ok(CtrlGraphics {
-            bus,
-            _amd: amd,
-            _intel: intel,
-            nvidia,
-            other,
-            config,
-            thread_kill: Arc::new(Mutex::new(None)),
-        })
-    }
-
-    pub fn bus(&self) -> PciBus {
-        self.bus.clone()
-    }
-
-    pub fn devices(&self) -> Vec<GraphicsDevice> {
-        self.nvidia.clone()
-    }
-
-    /// Save the selected `Vendor` mode to config
-    fn save_gfx_mode(vendor: GfxVendors, config: Arc<Mutex<Config>>) {
-        if let Ok(mut config) = config.lock() {
-            config.gfx_mode = vendor;
-            config.write();
-        }
-    }
-
-    /// Associated method to get which vendor mode is set
-    pub fn get_gfx_mode(&self) -> Result<GfxVendors, RogError> {
-        if let Ok(config) = self.config.lock() {
-            if let Some(mode) = config.gfx_tmp_mode {
-                return Ok(mode);
-            }
-            return Ok(config.gfx_mode);
-        }
-        // TODO: Error here
-        Ok(GfxVendors::Hybrid)
-    }
-
-    pub(super) fn get_runtime_status() -> Result<GfxPower, RogError> {
-        let path = Path::new("/sys/bus/pci/devices/0000:01:00.0/power/runtime_status");
-        if path.exists() {
-            let buf = std::fs::read_to_string(path).map_err(|err| {
-                RogError::Read(
-                    "/sys/bus/pci/devices/0000:01:00.0/power/runtime_status".to_string(),
-                    err,
-                )
-            })?;
-            Ok(GfxPower::from_str(&buf)?)
-        } else {
-            Ok(GfxPower::Off)
-        }
-    }
-
-    /// Some systems have a fallback service to load nouveau if nvidia fails
-    fn toggle_fallback_service(vendor: GfxVendors) -> Result<(), RogError> {
-        let action = if vendor == GfxVendors::Nvidia {
-            info!("GFX: Enabling nvidia-fallback.service");
-            "enable"
-        } else {
-            info!("GFX: Disabling nvidia-fallback.service");
-            "disable"
-        };
-
-        let status = Command::new("systemctl")
-            .arg(action)
-            .arg("nvidia-fallback.service")
-            .status()
-            .map_err(|err| RogError::Command("systemctl".into(), err))?;
-
-        if !status.success() {
-            // Error is ignored in case this service is removed
-            warn!(
-                "systemctl: {} (ignore warning if service does not exist!)",
-                status
-            );
-        }
-
-        Ok(())
-    }
-
-    /// Write the appropriate xorg config for the chosen mode
-    fn write_xorg_conf(vendor: GfxVendors) -> Result<(), RogError> {
-        let text = if vendor == GfxVendors::Nvidia {
-            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_NVIDIA, PRIMARY_GPU_END].concat()
-        } else {
-            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_END].concat()
-        };
-
-        if !Path::new(XORG_PATH).exists() {
-            std::fs::create_dir(XORG_PATH).map_err(|err| RogError::Write(XORG_PATH.into(), err))?;
-        }
-
-        let file = XORG_PATH.to_string().add(XORG_FILE);
-        info!("GFX: Writing {}", file);
-        let mut file = std::fs::OpenOptions::new()
-            .create(true)
-            .truncate(true)
-            .write(true)
-            .open(&file)
-            .map_err(|err| RogError::Write(file, err))?;
-
-        file.write_all(&text)
-            .and_then(|_| file.sync_all())
-            .map_err(|err| RogError::Write(MODPROBE_PATH.into(), err))?;
-        Ok(())
-    }
-
-    /// Creates the full modprobe.conf required for vfio pass-through
-    fn get_vfio_conf(devices: &[GraphicsDevice]) -> Vec<u8> {
-        let mut vifo = MODPROBE_VFIO.to_vec();
-        for (d_count, dev) in devices.iter().enumerate() {
-            for (f_count, func) in dev.functions().iter().enumerate() {
-                let vendor = func.vendor().unwrap();
-                let device = func.device().unwrap();
-                unsafe {
-                    vifo.append(format!("{:x}", vendor).as_mut_vec());
-                }
-                vifo.append(&mut vec![b':']);
-                unsafe {
-                    vifo.append(format!("{:x}", device).as_mut_vec());
-                }
-                if f_count < dev.functions().len() - 1 {
-                    vifo.append(&mut vec![b',']);
-                }
-            }
-            if d_count < dev.functions().len() - 1 {
-                vifo.append(&mut vec![b',']);
-            }
-        }
-        let mut conf = MODPROBE_INTEGRATED.to_vec();
-        conf.append(&mut vifo);
-        conf
-    }
-
-    fn write_modprobe_conf(vendor: GfxVendors, devices: &[GraphicsDevice]) -> Result<(), RogError> {
-        info!("GFX: Writing {}", MODPROBE_PATH);
-        let content = match vendor {
-            GfxVendors::Nvidia | GfxVendors::Hybrid => {
-                let mut base = MODPROBE_BASE.to_vec();
-                base.append(&mut MODPROBE_DRM_MODESET.to_vec());
-                base
-            }
-            GfxVendors::Vfio => Self::get_vfio_conf(devices),
-            GfxVendors::Integrated => MODPROBE_INTEGRATED.to_vec(),
-            GfxVendors::Compute => MODPROBE_BASE.to_vec(),
-        };
-
-        let mut file = std::fs::OpenOptions::new()
-            .create(true)
-            .truncate(true)
-            .write(true)
-            .open(MODPROBE_PATH)
-            .map_err(|err| RogError::Path(MODPROBE_PATH.into(), err))?;
-
-        file.write_all(&content)
-            .and_then(|_| file.sync_all())
-            .map_err(|err| RogError::Write(MODPROBE_PATH.into(), err))?;
-
-        Ok(())
-    }
-
-    fn unbind_remove_nvidia(devices: &[GraphicsDevice]) -> Result<(), RogError> {
-        // Unbind NVIDIA graphics devices and their functions
-        let unbinds = devices.iter().map(|dev| dev.unbind());
-        // Remove NVIDIA graphics devices and their functions
-        let removes = devices.iter().map(|dev| dev.remove());
-        Result::from_iter(unbinds.chain(removes))
-            .map_err(|err| RogError::Command("device unbind error".into(), err))
-    }
-
-    fn unbind_only(devices: &[GraphicsDevice]) -> Result<(), RogError> {
-        let unbinds = devices.iter().map(|dev| dev.unbind());
-        Result::from_iter(unbinds)
-            .map_err(|err| RogError::Command("device unbind error".into(), err))
-    }
-
-    fn do_driver_action(driver: &str, action: &str) -> Result<(), GfxError> {
-        let mut cmd = Command::new(action);
-        cmd.arg(driver);
-
-        let mut count = 0;
-        const MAX_TRIES: i32 = 6;
-        loop {
-            if count > MAX_TRIES {
-                let msg = format!("{} {} failed for unknown reason", action, driver);
-                error!("GFX: {}", msg);
-                return Ok(()); //Err(RogError::Modprobe(msg));
-            }
-
-            let output = cmd
-                .output()
-                .map_err(|err| GfxError::Command(format!("{:?}", cmd), err))?;
-            if !output.status.success() {
-                if output
-                    .stderr
-                    .ends_with("is not currently loaded\n".as_bytes())
-                {
-                    return Ok(());
-                }
-                if output.stderr.ends_with("is builtin.\n".as_bytes()) {
-                    return Err(GfxError::VfioBuiltin);
-                }
-                if output.stderr.ends_with("Permission denied\n".as_bytes()) {
-                    warn!(
-                        "{} {} failed: {:?}",
-                        action,
-                        driver,
-                        String::from_utf8_lossy(&output.stderr)
-                    );
-                    warn!("GFX: It may be safe to ignore the above error, run `lsmod |grep {}` to confirm modules loaded", driver);
-                    return Ok(());
-                }
-                if String::from_utf8_lossy(&output.stderr)
-                    .contains(&format!("Module {} not found", driver))
-                {
-                    return Err(GfxError::MissingModule(driver.into()));
-                }
-                if count >= MAX_TRIES {
-                    let msg = format!(
-                        "{} {} failed: {:?}",
-                        action,
-                        driver,
-                        String::from_utf8_lossy(&output.stderr)
-                    );
-                    return Err(GfxError::Modprobe(msg));
-                }
-            } else if output.status.success() {
-                return Ok(());
-            }
-
-            count += 1;
-            std::thread::sleep(std::time::Duration::from_millis(50));
-        }
-    }
-
-    fn do_display_manager_action(action: &str) -> Result<(), RogError> {
-        let mut cmd = Command::new("systemctl");
-        cmd.arg(action);
-        cmd.arg(DISPLAY_MANAGER);
-
-        let status = cmd
-            .status()
-            .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
-        if !status.success() {
-            let msg = format!(
-                "systemctl {} {} failed: {:?}",
-                action, DISPLAY_MANAGER, status
-            );
-            return Err(GfxError::DisplayManagerAction(msg, status).into());
-        }
-        Ok(())
-    }
-
-    fn wait_display_manager_state(state: &str) -> Result<(), RogError> {
-        let mut cmd = Command::new("systemctl");
-        cmd.arg("is-active");
-        cmd.arg(DISPLAY_MANAGER);
-
-        let mut count = 0;
-
-        while count <= 5 {
-            let output = cmd
-                .output()
-                .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
-            if output.stdout.starts_with(state.as_bytes()) {
-                return Ok(());
-            }
-            std::thread::sleep(std::time::Duration::from_millis(500));
-            count += 1;
-        }
-        Err(GfxError::DisplayManagerTimeout(state.into()).into())
-    }
-
-    /// Determine if we need to logout/thread. Integrated<->Vfio mode does not
-    /// require logout.
-    fn logout_required(&self, vendor: GfxVendors) -> GfxRequiredUserAction {
-        if let Ok(config) = self.config.lock() {
-            let current = config.gfx_mode;
-            if matches!(
-                current,
-                GfxVendors::Integrated | GfxVendors::Vfio | GfxVendors::Compute
-            ) && matches!(
-                vendor,
-                GfxVendors::Integrated | GfxVendors::Vfio | GfxVendors::Compute
-            ) {
-                return GfxRequiredUserAction::None;
-            }
-        }
-        GfxRequiredUserAction::Logout
-    }
-
-    /// Write the config changes and add/remove drivers and devices depending
-    /// on selected mode:
-    ///
-    /// Tasks:
-    /// - write xorg config
-    /// - write modprobe config
-    /// - rescan for devices
-    ///   + add drivers
-    ///   + or remove drivers and devices
-    ///
-    /// The daemon needs direct access to this function when it detects that the
-    pub fn do_vendor_tasks(
-        vendor: GfxVendors,
-        vfio_enable: bool,
-        devices: &[GraphicsDevice],
-        bus: &PciBus,
-    ) -> Result<(), RogError> {
-        // Rescan before doing remove or add drivers
-        bus.rescan()?;
-        // Make sure the power management is set to auto for nvidia devices
-        let devs = PciDevice::all()?;
-        for dev in devs.iter() {
-            let c = dev.class().map_err(|err| {
-                error!(
-                    "GFX: device error: {}, {}",
-                    dev.path().to_string_lossy(),
-                    err
-                );
-                err
-            })?;
-            if 0x03 == (c >> 16) & 0xFF && dev.vendor()? == 0x10DE {
-                info!("GFX: {}: NVIDIA graphics, setting PM to auto", dev.id());
-                dev.set_runtime_pm(sysfs_class::RuntimePowerManagement::On)?;
-            }
-        }
-        //
-        Self::write_xorg_conf(vendor)?;
-        // Write different modprobe to enable boot control to work
-        Self::write_modprobe_conf(vendor, devices)?;
-
-        match vendor {
-            GfxVendors::Nvidia | GfxVendors::Hybrid | GfxVendors::Compute => {
-                if vfio_enable {
-                    for driver in VFIO_DRIVERS.iter() {
-                        Self::do_driver_action(driver, "rmmod")?;
-                    }
-                }
-                for driver in NVIDIA_DRIVERS.iter() {
-                    Self::do_driver_action(driver, "modprobe")?;
-                }
-            }
-            GfxVendors::Vfio => {
-                if vfio_enable {
-                    Self::do_driver_action("nouveau", "rmmod")?;
-                    for driver in NVIDIA_DRIVERS.iter() {
-                        Self::do_driver_action(driver, "rmmod")?;
-                    }
-                    Self::unbind_only(&devices)?;
-                    Self::do_driver_action("vfio-pci", "modprobe")?;
-                } else {
-                    return Err(GfxError::VfioDisabled.into());
-                }
-            }
-            GfxVendors::Integrated => {
-                Self::do_driver_action("nouveau", "rmmod")?;
-                if vfio_enable {
-                    for driver in VFIO_DRIVERS.iter() {
-                        Self::do_driver_action(driver, "rmmod")?;
-                    }
-                }
-                for driver in NVIDIA_DRIVERS.iter() {
-                    Self::do_driver_action(driver, "rmmod")?;
-                }
-                Self::unbind_remove_nvidia(&devices)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Check if the user has any graphical uiser sessions that are active or online
-    fn graphical_user_sessions_exist(
-        connection: &Connection,
-        sessions: &[SessionInfo],
-    ) -> Result<bool, RogError> {
-        for session in sessions {
-            let session_proxy = SessionProxy::new(connection, session)?;
-            if session_proxy.get_class()? == SessionClass::User {
-                match session_proxy.get_type()? {
-                    SessionType::X11 | SessionType::Wayland | SessionType::MIR => {
-                        match session_proxy.get_state()? {
-                            SessionState::Online | SessionState::Active => return Ok(true),
-                            SessionState::Closing | SessionState::Invalid => {}
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-        Ok(false)
-    }
-
-    /// Spools until all user sessions are ended then switches to requested mode
-    fn fire_starter(
-        vendor: GfxVendors,
-        devices: Vec<GraphicsDevice>,
-        bus: PciBus,
-        thread_stop: mpsc::Receiver<bool>,
-        config: Arc<Mutex<Config>>,
-    ) -> Result<String, RogError> {
-        info!("GFX: display-manager thread started");
-
-        const SLEEP_PERIOD: Duration = Duration::from_millis(100);
-        let start_time = Instant::now();
-
-        let connection = Connection::new_system()?;
-        let manager = ManagerProxy::new(&connection)?;
-        let mut sessions = manager.list_sessions()?;
-
-        loop {
-            let tmp = manager.list_sessions()?;
-            if !tmp.iter().eq(&sessions) {
-                info!("GFX thread: Sessions list changed");
-                sessions = tmp;
-            }
-
-            if !Self::graphical_user_sessions_exist(&connection, &sessions)? {
-                break;
-            }
-
-            if let Ok(stop) = thread_stop.try_recv() {
-                if stop {
-                    return Ok("Graphics mode change was cancelled".into());
-                }
-            }
-            // exit if 3 minutes pass
-            if Instant::now().duration_since(start_time).as_secs() > 180 {
-                warn!("{}", THREAD_TIMEOUT_MSG);
-                return Ok(THREAD_TIMEOUT_MSG.into());
-            }
-
-            // Don't spin at max speed
-            sleep(SLEEP_PERIOD);
-        }
-
-        info!("GFX thread: all graphical user sessions ended, continuing");
-        Self::do_display_manager_action("stop")?;
-        Self::wait_display_manager_state("inactive")?;
-
-        let mut  mode_to_save = vendor;
-        // Need to change to integrated before we can change to vfio or compute
-        if let Ok(mut config) = config.try_lock() {
-            // Since we have a lock, reset tmp to none. This thread should only ever run
-            // for Integrated, Hybrid, or Nvidia. Tmp is also only for informational
-            config.gfx_tmp_mode = None;
-            //
-            let vfio_enable = config.gfx_vfio_enable;
-            
-            if matches!(vendor, GfxVendors::Compute | GfxVendors::Vfio)
-                && matches!(config.gfx_mode, GfxVendors::Nvidia | GfxVendors::Hybrid)
-            {
-                Self::do_vendor_tasks(GfxVendors::Integrated, vfio_enable, &devices, &bus)?;
-                Self::do_display_manager_action("restart")?;
-                sleep(Duration::from_millis(1000)); // Allow some time for the desktop to start
-                Self::do_vendor_tasks(vendor, vfio_enable, &devices, &bus)?;
-                config.gfx_tmp_mode = Some(vendor);
-                mode_to_save = GfxVendors::Integrated;
-            } else {
-                Self::do_vendor_tasks(vendor, vfio_enable, &devices, &bus)?;
-                Self::do_display_manager_action("restart")?;
-            }
-        }
-
-        // Save selected mode in case of reboot
-        Self::save_gfx_mode(mode_to_save, config);
-        info!("GFX thread: display-manager started");
-
-        let v: &str = vendor.into();
-        info!("GFX thread: Graphics mode changed to {} successfully", v);
-        Ok(format!("Graphics mode changed to {} successfully", v))
-    }
-
-    /// Before starting a new thread the old one *must* be cancelled
-    fn cancel_thread(&self) {
-        if let Ok(lock) = self.thread_kill.lock() {
-            if let Some(tx) = lock.as_ref() {
-                // Cancel the running thread
-                info!("GFX: Cancelling previous thread");
-                tx.send(true)
-                    .map_err(|err| {
-                        warn!("GFX thread: {}", err);
-                    })
-                    .ok();
-            }
-        }
-    }
-
-    /// The thread is used only in cases where a logout is required
-    fn setup_thread(&mut self, vendor: GfxVendors) {
-        let config = self.config.clone();
-        let devices = self.nvidia.clone();
-        let bus = self.bus.clone();
-        let (tx, rx) = mpsc::channel();
-        if let Ok(mut lock) = self.thread_kill.lock() {
-            *lock = Some(tx);
-        }
-        let killer = self.thread_kill.clone();
-
-        let _join: JoinHandle<()> = std::thread::spawn(move || {
-            Self::fire_starter(vendor, devices, bus, rx, config)
-                .map_err(|err| {
-                    error!("GFX: {}", err);
-                })
-                .ok();
-            // clear the tx/rx when done
-            if let Ok(mut lock) = killer.try_lock() {
-                *lock = None;
-            }
-        });
-    }
-
-    /// Initiates a mode change by starting a thread that will wait until all
-    /// graphical sessions are exited before performing the tasks required
-    /// to switch modes.
-    ///
-    /// For manually calling (not on boot/startup) via dbus
-    pub fn set_gfx_config(
-        &mut self,
-        vendor: GfxVendors,
-    ) -> Result<GfxRequiredUserAction, RogError> {
-        if let Ok(gsync) = CtrlRogBios::get_gfx_mode() {
-            if gsync == 1 {
-                return Err(GfxError::GsyncModeActive.into());
-            }
-        }
-
-        let vfio_enable = if let Ok(config) = self.config.try_lock() {
-            config.gfx_vfio_enable
-        } else {
-            false
-        };
-
-        if !vfio_enable && matches!(vendor, GfxVendors::Vfio) {
-            return Err(GfxError::VfioDisabled.into());
-        }
-
-        // Must always cancel any thread running
-        self.cancel_thread();
-        // determine which method we need here
-        let action_required = self.logout_required(vendor);
-        if matches!(action_required, GfxRequiredUserAction::Logout) {
-            // Yeah need the thread to check if all users are logged out
-            info!("GFX: mode change requires a logout to complete");
-            self.setup_thread(vendor);
-        } else {
-            // Okay cool, we can switch on/off vfio
-            info!("GFX: mode change does not require logout");
-            let devices = self.nvidia.clone();
-            let bus = self.bus.clone();
-            Self::do_vendor_tasks(vendor, vfio_enable, &devices, &bus)?;
-            info!("GFX: Graphics mode changed to {}", <&str>::from(vendor));
-            if matches!(vendor, GfxVendors::Vfio | GfxVendors::Compute) {
-                if let Ok(mut config) = self.config.try_lock() {
-                    config.gfx_tmp_mode = Some(vendor);
-                };
-            }
-        }
-        // TODO: undo if failed? Save last mode, catch errors...
-        Ok(action_required)
-    }
-
-    /// Used only on boot to set correct mode
-    fn auto_power(&mut self) -> Result<(), RogError> {
-        let vendor = self.get_gfx_mode()?;
-        let devices = self.nvidia.clone();
-        let bus = self.bus.clone();
-
-        let vfio_enable = if let Ok(config) = self.config.try_lock() {
-            config.gfx_vfio_enable
-        } else {
-            false
-        };
-
-        Self::do_vendor_tasks(vendor, vfio_enable, &devices, &bus)?;
-        Self::toggle_fallback_service(vendor)?;
-        Ok(())
-    }
-}

daemon/src/ctrl_gfx/error.rs

@@ -1,58 +0,0 @@
-use std::fmt;
-use std::{error, process::ExitStatus};
-
-use crate::error::RogError;
-
-#[derive(Debug)]
-pub enum GfxError {
-    ParseVendor,
-    ParsePower,
-    Bus(String, std::io::Error),
-    DisplayManagerAction(String, ExitStatus),
-    DisplayManagerTimeout(String),
-    GsyncModeActive,
-    VfioBuiltin,
-    VfioDisabled,
-    MissingModule(String),
-    Modprobe(String),
-    Command(String, std::io::Error),
-}
-
-impl fmt::Display for GfxError {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            GfxError::ParseVendor => write!(f, "Could not parse vendor name"),
-            GfxError::ParsePower => write!(f, "Could not parse dGPU power status"),
-            GfxError::Bus(func, error) => write!(f, "Bus error: {}: {}", func, error),
-            GfxError::DisplayManagerAction(action, status) => {
-                write!(f, "Display-manager action {} failed: {}", action, status)
-            }
-            GfxError::DisplayManagerTimeout(state) => {
-                write!(f, "Timed out waiting for display-manager {} state", state)
-            }
-            GfxError::GsyncModeActive => write!(
-                f,
-                "Can not switch gfx modes when dedicated/G-Sync mode is active"
-            ),
-            GfxError::VfioBuiltin => write!(
-                f,
-                "Can not switch to vfio mode if the modules are built in to kernel"
-            ),
-            GfxError::VfioDisabled => {
-                write!(f, "Can not switch to vfio mode if disabled in config file")
-            }
-            GfxError::MissingModule(m) => write!(f, "The module {} is missing", m),
-            GfxError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
-            GfxError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
-        }
-    }
-}
-
-impl error::Error for GfxError {}
-
-impl From<GfxError> for RogError {
-    fn from(err: GfxError) -> Self {
-        RogError::GfxSwitching(err)
-    }
-}

daemon/src/ctrl_gfx/mod.rs

@@ -1,62 +0,0 @@
-pub mod error;
-
-pub mod controller;
-
-pub mod system;
-
-pub mod zbus_gfx;
-
-const NVIDIA_DRIVERS: [&str; 4] = ["nvidia_drm", "nvidia_modeset", "nvidia_uvm", "nvidia"];
-
-const VFIO_DRIVERS: [&str; 5] = [
-    "vfio-pci",
-    "vfio_iommu_type1",
-    "vfio_virqfd",
-    "vfio_mdev",
-    "vfio",
-];
-
-const DISPLAY_MANAGER: &str = "display-manager.service";
-
-const MODPROBE_PATH: &str = "/etc/modprobe.d/asusd.conf";
-
-static MODPROBE_BASE: &[u8] = br#"# Automatically generated by asusd
-# If you have issues with i2c_nvidia_gpu, copy the 2 lines below to a
-# new blacklist file and uncomment
-#blacklist i2c_nvidia_gpu
-#alias i2c_nvidia_gpu off
-blacklist nouveau
-alias nouveau off
-options nvidia NVreg_DynamicPowerManagement=0x02
-"#;
-
-static MODPROBE_DRM_MODESET: &[u8] = br#"
-options nvidia-drm modeset=1
-"#;
-
-static MODPROBE_INTEGRATED: &[u8] = br#"# Automatically generated by asusd
-blacklist i2c_nvidia_gpu
-blacklist nvidia
-blacklist nvidia-drm
-blacklist nvidia-modeset
-blacklist nouveau
-alias nouveau off
-"#;
-
-static MODPROBE_VFIO: &[u8] = br#"options vfio-pci ids="#;
-
-const XORG_FILE: &str = "90-nvidia-primary.conf";
-const XORG_PATH: &str = "/etc/X11/xorg.conf.d/";
-
-static PRIMARY_GPU_BEGIN: &[u8] = br#"# Automatically generated by asusd
-Section "OutputClass"
-    Identifier "nvidia"
-    MatchDriver "nvidia-drm"
-    Driver "nvidia"
-    Option "AllowEmptyInitialConfiguration" "true""#;
-
-static PRIMARY_GPU_NVIDIA: &[u8] = br#"
-    Option "PrimaryGPU" "true""#;
-
-static PRIMARY_GPU_END: &[u8] = br#"
-EndSection"#;

daemon/src/ctrl_gfx/system.rs

@@ -1,160 +0,0 @@
-use log::{error, info, warn};
-use std::fs::read_to_string;
-use std::{fs::write, io, path::PathBuf};
-use sysfs_class::{PciDevice, SysClass};
-
-pub struct Module {
-    pub name: String,
-}
-
-impl Module {
-    fn parse(line: &str) -> io::Result<Module> {
-        let mut parts = line.split(' ');
-
-        let name = parts
-            .next()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "module name not found"))?;
-
-        Ok(Module {
-            name: name.to_string(),
-        })
-    }
-
-    pub fn all() -> io::Result<Vec<Module>> {
-        let mut modules = Vec::new();
-
-        let data = read_to_string("/proc/modules")?;
-        for line in data.lines() {
-            let module = Module::parse(line)?;
-            modules.push(module);
-        }
-
-        Ok(modules)
-    }
-}
-
-#[derive(Clone)]
-pub struct PciBus {
-    path: PathBuf,
-}
-
-impl PciBus {
-    pub fn new() -> io::Result<PciBus> {
-        let path = PathBuf::from("/sys/bus/pci");
-        if path.is_dir() {
-            Ok(PciBus { path })
-        } else {
-            Err(io::Error::new(
-                io::ErrorKind::NotFound,
-                "pci directory not found",
-            ))
-        }
-    }
-
-    /// Will rescan the device tree, which adds all removed devices back
-    pub fn rescan(&self) -> io::Result<()> {
-        write(self.path.join("rescan"), "1")
-    }
-}
-
-#[derive(Clone)]
-pub struct GraphicsDevice {
-    _id: String,
-    functions: Vec<PciDevice>,
-}
-
-impl GraphicsDevice {
-    pub fn new(id: String, functions: Vec<PciDevice>) -> GraphicsDevice {
-        GraphicsDevice { _id: id, functions }
-    }
-
-    pub fn exists(&self) -> bool {
-        self.functions.iter().any(|func| func.path().exists())
-    }
-
-    pub fn functions(&self) -> &[PciDevice] {
-        &self.functions
-    }
-
-    pub fn unbind(&self) -> Result<(), std::io::Error> {
-        for func in self.functions.iter() {
-            if func.path().exists() {
-                match func.driver() {
-                    Ok(driver) => {
-                        info!("{}: Unbinding {}", driver.id(), func.id());
-                        unsafe {
-                            driver.unbind(&func).map_err(|err| {
-                                error!("gfx unbind: {}", err);
-                                err
-                            })?;
-                        }
-                    }
-                    Err(err) => match err.kind() {
-                        io::ErrorKind::NotFound => (),
-                        _ => {
-                            error!("gfx driver: {:?}, {}", func.path(), err);
-                            return Err(err);
-                        }
-                    },
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn rebind(&self) -> Result<(), std::io::Error> {
-        for func in self.functions.iter() {
-            if func.path().exists() {
-                match func.driver() {
-                    Ok(driver) => {
-                        info!("{}: Binding {}", driver.id(), func.id());
-                        unsafe {
-                            driver.bind(&func).map_err(|err| {
-                                error!("gfx bind: {}", err);
-                                err
-                            })?;
-                        }
-                    }
-                    Err(err) => match err.kind() {
-                        io::ErrorKind::NotFound => (),
-                        _ => {
-                            error!("gfx driver: {:?}, {}", func.path(), err);
-                            return Err(err);
-                        }
-                    },
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn remove(&self) -> Result<(), std::io::Error> {
-        for func in self.functions.iter() {
-            if func.path().exists() {
-                match func.driver() {
-                    Ok(driver) => {
-                        error!("{}: in use by {}", func.id(), driver.id());
-                    }
-                    Err(why) => match why.kind() {
-                        std::io::ErrorKind::NotFound => {
-                            info!("{}: Removing", func.id());
-                            unsafe {
-                                // ignore errors and carry on
-                                if let Err(err) = func.remove() {
-                                    error!("gfx remove: {}", err);
-                                }
-                            }
-                        }
-                        _ => {
-                            error!("Remove device failed");
-                        }
-                    },
-                }
-            } else {
-                warn!("{}: Already removed", func.id());
-            }
-        }
-        info!("Removed all gfx devices");
-        Ok(())
-    }
-}

daemon/src/ctrl_gfx/zbus_gfx.rs

@@ -1,56 +0,0 @@
-use ::zbus::dbus_interface;
-use log::{error, info, warn};
-use rog_types::gfx_vendors::{GfxPower, GfxRequiredUserAction, GfxVendors};
-use zvariant::ObjectPath;
-
-use crate::ZbusAdd;
-
-use super::controller::CtrlGraphics;
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlGraphics {
-    fn vendor(&self) -> zbus::fdo::Result<GfxVendors> {
-        self.get_gfx_mode().map_err(|err| {
-            error!("GFX: {}", err);
-            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
-        })
-    }
-
-    fn power(&self) -> zbus::fdo::Result<GfxPower> {
-        Self::get_runtime_status().map_err(|err| {
-            error!("GFX: {}", err);
-            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
-        })
-    }
-
-    fn set_vendor(&mut self, vendor: GfxVendors) -> zbus::fdo::Result<GfxRequiredUserAction> {
-        info!("GFX: Switching gfx mode to {}", <&str>::from(vendor));
-        let msg = self.set_gfx_config(vendor).map_err(|err| {
-            error!("GFX: {}", err);
-            zbus::fdo::Error::Failed(format!("GFX fail: {}", err))
-        })?;
-        self.notify_gfx(&vendor)
-            .unwrap_or_else(|err| warn!("GFX: {}", err));
-        self.notify_action(&msg)
-            .unwrap_or_else(|err| warn!("GFX: {}", err));
-        Ok(msg)
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_gfx(&self, vendor: &GfxVendors) -> zbus::Result<()> {}
-
-    #[dbus_interface(signal)]
-    fn notify_action(&self, action: &GfxRequiredUserAction) -> zbus::Result<()> {}
-}
-
-impl ZbusAdd for CtrlGraphics {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&ObjectPath::from_str_unchecked("/org/asuslinux/Gfx"), self)
-            .map_err(|err| {
-                warn!("GFX: CtrlGraphics: add_to_server {}", err);
-                err
-            })
-            .ok();
-    }
-}

daemon/src/ctrl_leds/zbus.rs

@@ -1,165 +0,0 @@
-use log::{error, warn};
-use rog_aura::{AuraEffect, LedBrightness, LedPowerStates};
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-
-use super::controller::CtrlKbdLedZbus;
-
-impl crate::ZbusAdd for CtrlKbdLedZbus {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&ObjectPath::from_str_unchecked("/org/asuslinux/Led"), self)
-            .map_err(|err| {
-                error!("DbusKbdLed: add_to_server {}", err);
-            })
-            .ok();
-    }
-}
-
-/// The main interface for changing, reading, or notfying signals
-///
-/// LED commands are split between Brightness, Modes, Per-Key
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlKbdLedZbus {
-    /// Set the keyboard brightness level (0-3)
-    fn set_brightness(&mut self, brightness: LedBrightness) {
-        if let Ok(ctrl) = self.0.try_lock() {
-            ctrl.set_brightness(brightness)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-        }
-    }
-
-    /// Set the keyboard LED to enabled while the device is awake
-    fn set_awake_enabled(&mut self, enabled: bool) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.set_states_enabled(enabled, ctrl.config.sleep_anim_enabled)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-            ctrl.config.awake_enabled = enabled;
-            ctrl.config.write();
-
-            let states = LedPowerStates {
-                enabled: ctrl.config.awake_enabled,
-                sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
-            };
-            self.notify_power_states(&states)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-    }
-
-    /// Set the keyboard LED suspend animation to enabled while the device is suspended
-    fn set_sleep_enabled(&mut self, enabled: bool) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.set_states_enabled(ctrl.config.awake_enabled, enabled)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-            ctrl.config.sleep_anim_enabled = enabled;
-            ctrl.config.write();
-            let states = LedPowerStates {
-                enabled: ctrl.config.awake_enabled,
-                sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
-            };
-            self.notify_power_states(&states)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-    }
-
-    fn set_led_mode(&mut self, effect: AuraEffect) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            match ctrl.do_command(effect) {
-                Ok(_) => {
-                    if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                        self.notify_led(mode.clone())
-                            .unwrap_or_else(|err| warn!("{}", err));
-                    }
-                }
-                Err(err) => {
-                    warn!("{}", err);
-                }
-            }
-        }
-    }
-
-    fn next_led_mode(&self) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.toggle_mode(false)
-                .unwrap_or_else(|err| warn!("{}", err));
-
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                self.notify_led(mode.clone())
-                    .unwrap_or_else(|err| warn!("{}", err));
-            }
-        }
-    }
-
-    fn prev_led_mode(&self) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.toggle_mode(true)
-                .unwrap_or_else(|err| warn!("{}", err));
-
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                self.notify_led(mode.clone())
-                    .unwrap_or_else(|err| warn!("{}", err));
-            }
-        }
-    }
-
-    #[dbus_interface(property)]
-    fn awake_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.awake_enabled;
-        }
-        true
-    }
-
-    #[dbus_interface(property)]
-    fn sleep_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.sleep_anim_enabled;
-        }
-        true
-    }
-
-    /// Return the current mode data
-    #[dbus_interface(property)]
-    fn led_mode(&self) -> String {
-        if let Ok(ctrl) = self.0.try_lock() {
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                if let Ok(json) = serde_json::to_string(&mode) {
-                    return json;
-                }
-            }
-        }
-        warn!("SetKeyBacklight could not deserialise");
-        "SetKeyBacklight could not deserialise".to_string()
-    }
-
-    /// Return a list of available modes
-    #[dbus_interface(property)]
-    fn led_modes(&self) -> String {
-        if let Ok(ctrl) = self.0.try_lock() {
-            if let Ok(json) = serde_json::to_string(&ctrl.config.builtins) {
-                return json;
-            }
-        }
-        warn!("SetKeyBacklight could not deserialise");
-        "SetKeyBacklight could not serialise".to_string()
-    }
-
-    /// Return the current LED brightness
-    #[dbus_interface(property)]
-    fn led_brightness(&self) -> i8 {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1);
-        }
-        warn!("SetKeyBacklight could not serialise");
-        -1
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_led(&self, data: AuraEffect) -> zbus::Result<()>;
-
-    #[dbus_interface(signal)]
-    fn notify_power_states(&self, data: &LedPowerStates) -> zbus::Result<()>;
-}

daemon/src/ctrl_profiles/config.rs

@@ -0,0 +1,101 @@
+use log::{error, warn};
+use rog_profiles::{FanCurveProfiles, Profile};
+use serde_derive::{Deserialize, Serialize};
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ProfileConfig {
+    #[serde(skip)]
+    config_path: String,
+    /// For restore on boot
+    pub active_profile: Profile,
+    /// States to restore
+    pub fan_curves: Option<FanCurveProfiles>,
+}
+
+impl ProfileConfig {
+    fn new(config_path: String) -> Self {
+        Self {
+            config_path,
+            active_profile: Profile::Balanced,
+            fan_curves: None,
+        }
+    }
+
+    pub fn set_defaults_and_save(&mut self) {
+        self.active_profile = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+        if let Ok(res) = FanCurveProfiles::is_supported() {
+            if res {
+                let curves = FanCurveProfiles::default();
+                self.fan_curves = Some(curves);
+            }
+        }
+        self.write();
+    }
+
+    pub fn load(config_path: String) -> Self {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(&config_path)
+            .unwrap_or_else(|_| panic!("The directory /etc/asusd/ is missing")); // okay to cause panic here
+        let mut buf = String::new();
+        let mut config;
+        if let Ok(read_len) = file.read_to_string(&mut buf) {
+            if read_len == 0 {
+                config = Self::new(config_path);
+                config.set_defaults_and_save();
+            } else if let Ok(data) = toml::from_str(&buf) {
+                config = data;
+                config.config_path = config_path;
+            } else {
+                warn!(
+                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
+                    config_path, config_path
+                );
+                let cfg_old = config_path.clone() + "-old";
+                std::fs::rename(config_path.clone(), cfg_old).unwrap_or_else(|err| {
+                    panic!(
+                        "Could not rename. Please remove {} then restart service: Error {}",
+                        config_path, err
+                    )
+                });
+                config = Self::new(config_path);
+                config.set_defaults_and_save();
+            }
+        } else {
+            config = Self::new(config_path);
+            config.set_defaults_and_save();
+        }
+        config
+    }
+
+    pub fn read(&mut self) {
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(&self.config_path)
+            .unwrap_or_else(|err| panic!("Error reading {}: {}", self.config_path, err));
+
+        let mut buf = String::new();
+        if let Ok(l) = file.read_to_string(&mut buf) {
+            if l == 0 {
+                warn!("File is empty {}", self.config_path);
+            } else {
+                let mut data: ProfileConfig = toml::from_str(&buf)
+                    .unwrap_or_else(|_| panic!("Could not deserialise {}", self.config_path));
+                // copy over serde skipped values
+                data.config_path = self.config_path.clone();
+                *self = data;
+            }
+        }
+    }
+
+    pub fn write(&self) {
+        let mut file = File::create(&self.config_path).expect("Couldn't overwrite config");
+        let data = toml::to_string(self).expect("Parse config to toml failed");
+        file.write_all(data.as_bytes())
+            .unwrap_or_else(|err| error!("Could not write config: {}", err));
+    }
+}

daemon/src/ctrl_profiles/controller.rs

@@ -1,103 +1,157 @@
-use crate::error::RogError;
-use crate::{config::Config, GetSupported};
-use log::info;
-use rog_profiles::profiles::Profile;
-use rog_types::supported::FanCpuSupportedFunctions;
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
-pub struct CtrlFanAndCpu {
-    pub config: Arc<Mutex<Config>>,
+use crate::error::RogError;
+use crate::{CtrlTask, GetSupported};
+use async_trait::async_trait;
+use log::{info, warn};
+use rog_profiles::error::ProfileError;
+use rog_profiles::{FanCurveProfiles, Profile};
+use rog_supported::PlatformProfileFunctions;
+use smol::Executor;
+
+use super::config::ProfileConfig;
+
+pub struct CtrlPlatformProfile {
+    pub config: ProfileConfig,
 }
 
-impl GetSupported for CtrlFanAndCpu {
-    type A = FanCpuSupportedFunctions;
+impl GetSupported for CtrlPlatformProfile {
+    type A = PlatformProfileFunctions;
 
     fn get_supported() -> Self::A {
-        FanCpuSupportedFunctions {
-            stock_fan_modes: Profile::get_fan_path().is_ok(),
-            min_max_freq: Profile::get_intel_supported(),
-            fan_curve_set: rog_fan_curve::Board::from_board_name().is_some(),
+        if !Profile::is_platform_profile_supported() {
+            warn!(
+                r#"
+platform_profile kernel interface not found, your laptop does not support this, or the interface is missing.
+To enable profile support you require a kernel version 5.15.2 minimum.
+"#
+            );
+        }
+
+        let res = FanCurveProfiles::is_supported();
+        let mut fan_curve_supported = res.is_err();
+        if let Ok(r) = res {
+            fan_curve_supported = r;
+        };
+
+        if !fan_curve_supported {
+            info!(
+                r#"
+fan curves kernel interface not found, your laptop does not support this, or the interface is missing.
+To enable fan-curve support you require a kernel with the following patch applied:
+https://lkml.org/lkml/2021/10/23/250
+This patch has been accepted upstream for 5.17 kernel release.
+"#
+            );
+        }
+
+        PlatformProfileFunctions {
+            platform_profile: Profile::is_platform_profile_supported(),
+            fan_curves: fan_curve_supported,
         }
     }
 }
 
-impl crate::Reloadable for CtrlFanAndCpu {
+impl crate::Reloadable for CtrlPlatformProfile {
+    /// Fetch the active profile and use that to set all related components up
     fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut cfg) = self.config.clone().try_lock() {
-            let active = cfg.active_profile.clone();
-            if let Some(existing) = cfg.power_profiles.get_mut(&active) {
-                existing.set_system_all()?;
-                cfg.write();
+        if let Some(curves) = &mut self.config.fan_curves {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                // There is a possibility that the curve was default zeroed, so this call initialises
+                // the data from system read and we need to save it after
+                curves.write_profile_curve_to_platform(self.config.active_profile, &mut device)?;
+                self.config.write();
             }
         }
         Ok(())
     }
 }
 
-impl CtrlFanAndCpu {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        Profile::get_fan_path()?;
-        info!("Device has thermal throttle control");
-        Ok(CtrlFanAndCpu { config })
-    }
+impl CtrlPlatformProfile {
+    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
+        if Profile::is_platform_profile_supported() {
+            info!("Device has profile control available");
 
-    /// Toggle to next profile in list
-    pub(super) fn do_next_profile(&mut self) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.clone().try_lock() {
-            config.read();
-
-            let mut i = config
-                .toggle_profiles
-                .binary_search(&config.active_profile)
-                .unwrap_or(0)
-                + 1;
-            if i >= config.toggle_profiles.len() {
-                i = 0;
+            if FanCurveProfiles::get_device().is_ok() {
+                info!("Device has fan curves available");
             }
 
-            let profile = config.toggle_profiles[i].clone();
+            return Ok(CtrlPlatformProfile { config });
+        }
 
-            if let Some(existing) = config.power_profiles.get(&profile) {
-                existing.set_system_all()?;
-                config.active_profile = existing.name.clone();
-                config.write();
-                info!("Profile was changed to: {}", profile);
+        Err(ProfileError::NotSupported.into())
+    }
+
+    pub fn save_config(&self) {
+        self.config.write();
+    }
+
+    /// Toggle to next profile in list. This will first read the config, switch, then write out
+    pub(super) fn set_next_profile(&mut self) -> Result<(), RogError> {
+        // Read first just incase the user has modified the config before calling this
+        match self.config.active_profile {
+            Profile::Balanced => {
+                Profile::set_profile(Profile::Performance)?;
+                self.config.active_profile = Profile::Performance;
+            }
+            Profile::Performance => {
+                Profile::set_profile(Profile::Quiet)?;
+                self.config.active_profile = Profile::Quiet;
+            }
+            Profile::Quiet => {
+                Profile::set_profile(Profile::Balanced)?;
+                self.config.active_profile = Profile::Balanced;
+            }
+        }
+        self.write_profile_curve_to_platform()?;
+        Ok(())
+    }
+
+    /// Set the curve for the active profile active
+    pub(super) fn write_profile_curve_to_platform(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = &mut self.config.fan_curves {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.write_profile_curve_to_platform(self.config.active_profile, &mut device)?;
             }
         }
         Ok(())
     }
 
-    pub(super) fn set_active(&mut self, profile: &str) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.clone().try_lock() {
-            config.read();
-            if let Some(existing) = config.power_profiles.get(profile) {
-                existing.set_system_all()?;
-                config.active_profile = existing.name.clone();
-                config.write();
-                info!("Profile was changed to: {}", profile);
+    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = self.config.fan_curves.as_mut() {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.set_active_curve_to_defaults(self.config.active_profile, &mut device)?;
             }
         }
         Ok(())
     }
-
-    pub(super) fn new_or_modify(&mut self, profile: &Profile) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.clone().try_lock() {
-            config.read();
-
-            if let Some(existing) = config.power_profiles.get_mut(&profile.name) {
-                *existing = profile.clone();
-                existing.set_system_all()?;
-            } else {
-                config
-                    .power_profiles
-                    .insert(profile.name.clone(), profile.clone());
-                profile.set_system_all()?;
-            }
-
-            config.active_profile = profile.name.clone();
-            config.write();
-        }
-        Ok(())
-    }
+}
+
+pub struct CtrlProfileTask {
+    ctrl: Arc<Mutex<CtrlPlatformProfile>>,
+}
+
+impl CtrlProfileTask {
+    pub fn new(ctrl: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
+        Self { ctrl }
+    }
+}
+
+#[async_trait]
+impl CtrlTask for CtrlProfileTask {
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let ctrl = self.ctrl.clone();
+        self.repeating_task(666, executor, move || {
+            if let Ok(ref mut lock) = ctrl.try_lock() {
+                let new_profile = Profile::get_active_profile().unwrap();
+                if new_profile != lock.config.active_profile {
+                    lock.config.active_profile = new_profile;
+                    lock.write_profile_curve_to_platform().unwrap();
+                    lock.save_config();
+                }
+            }
+        })
+        .await;
+        Ok(())
+    }
 }

daemon/src/ctrl_profiles/mod.rs

@@ -1,3 +1,3 @@
-pub mod zbus;
-
+pub mod config;
 pub mod controller;
+pub mod zbus;

daemon/src/ctrl_profiles/zbus.rs

@@ -1,163 +1,187 @@
+use async_trait::async_trait;
 use log::warn;
-use rog_profiles::profiles::Profile;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::fan_curve_set::FanCurveSet;
+use rog_profiles::Profile;
+use zbus::Connection;
+use zbus::SignalContext;
 
 use std::sync::Arc;
 use std::sync::Mutex;
 use zbus::{dbus_interface, fdo::Error};
-use zvariant::ObjectPath;
 
-use super::controller::CtrlFanAndCpu;
+use super::controller::CtrlPlatformProfile;
 
-pub struct FanAndCpuZbus {
-    inner: Arc<Mutex<CtrlFanAndCpu>>,
+static UNSUPPORTED_MSG: &str =
+    "Fan curves are not supported on this laptop or you require a patched kernel";
+
+pub struct ProfileZbus {
+    inner: Arc<Mutex<CtrlPlatformProfile>>,
 }
 
-impl FanAndCpuZbus {
-    pub fn new(inner: Arc<Mutex<CtrlFanAndCpu>>) -> Self {
+impl ProfileZbus {
+    pub fn new(inner: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
         Self { inner }
     }
 }
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
-impl FanAndCpuZbus {
-    /// Create new profile and make active
-    fn set_profile(&self, profile: String) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.set_active(&profile)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-        self.do_notification();
-    }
-
-    /// New or modify profile details and make active, will create if it does not exist
-    fn new_or_modify(&self, profile: Profile) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.new_or_modify(&profile)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-        self.do_notification();
-    }
-
-    /// Fetch the active profile name
-    fn next_profile(&mut self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.do_next_profile()
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-        self.do_notification();
-    }
-
-    /// Fetch the active profile name
-    fn active_name(&mut self) -> zbus::fdo::Result<String> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                return Ok(cfg.active_profile.clone());
-            }
-        }
-        Err(Error::Failed(
-            "Failed to get active profile name".to_string(),
-        ))
-    }
-
-    // TODO: Profile can't implement Type because of Curve
-    /// Fetch the active profile details
-    fn active_data(&mut self) -> zbus::fdo::Result<Profile> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                    return Ok(profile.clone());
-                }
-            }
-        }
-        Err(Error::Failed(
-            "Failed to get active profile details".to_string(),
-        ))
-    }
-
-    /// Fetch all profile data
+impl ProfileZbus {
+    /// Fetch profile names
     fn profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                return Ok(cfg.power_profiles.values().cloned().collect());
-            }
+        if let Ok(profiles) = Profile::get_profile_names() {
+            return Ok(profiles);
         }
         Err(Error::Failed(
             "Failed to get all profile details".to_string(),
         ))
     }
 
-    fn profile_names(&self) -> zbus::fdo::Result<Vec<String>> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                let profile_names = cfg.power_profiles.keys().cloned().collect::<Vec<String>>();
-                return Ok(profile_names);
-            }
+    /// Toggle to next platform_profile. Names provided by `Profiles`.
+    /// If fan-curves are supported will also activate a fan curve for profile.
+    async fn next_profile(&mut self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut profile = None;
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.set_next_profile()
+                .unwrap_or_else(|err| warn!("{}", err));
+            ctrl.save_config();
+            profile = Some(ctrl.config.active_profile);
+        }
+        if let Some(profile) = profile {
+            Self::notify_profile(&ctxt, profile).await.ok();
         }
-
-        Err(Error::Failed("Failed to get all profile names".to_string()))
     }
 
-    fn remove(&self, profile: &str) -> zbus::fdo::Result<()> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-
-                if !cfg.power_profiles.contains_key(profile) {
-                    return Err(Error::Failed("Invalid profile specified".to_string()));
-                }
-
-                if cfg.power_profiles.keys().len() == 1 {
-                    return Err(Error::Failed("Cannot delete the last profile".to_string()));
-                }
-
-                if cfg.active_profile == *profile {
-                    return Err(Error::Failed(
-                        "Cannot delete the active profile".to_string(),
-                    ));
-                }
-
-                cfg.power_profiles.remove(profile);
-                cfg.write();
-
-                return Ok(());
-            }
+    /// Fetch the active profile name
+    fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.config.read();
+            return Ok(ctrl.config.active_profile);
         }
+        Err(Error::Failed(
+            "Failed to get active profile name".to_string(),
+        ))
+    }
 
-        Err(Error::Failed("Failed to lock configuration".to_string()))
+    /// Set this platform_profile name as active
+    async fn set_active_profile(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        profile: Profile,
+    ) {
+        let mut tmp = None;
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            // Read first just incase the user has modified the config before calling this
+            ctrl.config.read();
+            Profile::set_profile(profile)
+                .map_err(|e| warn!("set_profile, {}", e))
+                .ok();
+            ctrl.config.active_profile = profile;
+            ctrl.write_profile_curve_to_platform()
+                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
+                .ok();
+
+            ctrl.save_config();
+            tmp = Some(ctrl.config.active_profile);
+        }
+        if let Some(profile) = tmp {
+            Self::notify_profile(&ctxt, profile).await.ok();
+        }
+    }
+
+    /// Get a list of profiles that have fan-curves enabled.
+    fn enabled_fan_profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.config.read();
+            if let Some(curves) = &ctrl.config.fan_curves {
+                return Ok(curves.get_enabled_curve_profiles().to_vec());
+            }
+            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
+        }
+        Err(Error::Failed(
+            "Failed to get enabled fan curve names".to_string(),
+        ))
+    }
+
+    /// Set a profile fan curve enabled status. Will also activate a fan curve if in the
+    /// same profile mode
+    fn set_fan_curve_enabled(&mut self, profile: Profile, enabled: bool) -> zbus::fdo::Result<()> {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.config.read();
+            return if let Some(curves) = &mut ctrl.config.fan_curves {
+                curves.set_profile_curve_enabled(profile, enabled);
+
+                ctrl.write_profile_curve_to_platform()
+                    .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
+                    .ok();
+
+                ctrl.save_config();
+                Ok(())
+            } else {
+                Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
+            };
+        }
+        Err(Error::Failed(
+            "Failed to get enabled fan curve names".to_string(),
+        ))
+    }
+
+    /// Get the fan-curve data for the currently active Profile
+    fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<FanCurveSet> {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.config.read();
+            if let Some(curves) = &ctrl.config.fan_curves {
+                let curve = curves.get_fan_curves_for(profile);
+                return Ok(curve.clone());
+            }
+            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
+        }
+        Err(Error::Failed("Failed to get fan curve data".to_string()))
+    }
+
+    /// Set the fan curve for the specified profile.
+    /// Will also activate the fan curve if the user is in the same mode.
+    fn set_fan_curve(&self, profile: Profile, curve: CurveData) -> zbus::fdo::Result<()> {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.config.read();
+            if let Some(curves) = &mut ctrl.config.fan_curves {
+                curves
+                    .save_fan_curve(curve, profile)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            } else {
+                return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
+            }
+            ctrl.write_profile_curve_to_platform()
+                .map_err(|e| warn!("Profile::set_profile, {}", e))
+                .ok();
+            ctrl.save_config();
+        }
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curve to the defaults of the platform.
+    ///
+    /// Each platform_profile has a different default and the defualt can be read
+    /// only for the currently active profile.
+    fn set_active_curve_to_defaults(&self) -> zbus::fdo::Result<()> {
+        if let Ok(mut ctrl) = self.inner.try_lock() {
+            ctrl.config.read();
+            ctrl.set_active_curve_to_defaults()
+                .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
+                .ok();
+            ctrl.save_config();
+        }
+        Ok(())
     }
 
     #[dbus_interface(signal)]
-    fn notify_profile(&self, profile: &Profile) -> zbus::Result<()> {}
-}
-
-impl FanAndCpuZbus {
-    fn do_notification(&self) {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(cfg) = ctrl.config.clone().try_lock() {
-                if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                    self.notify_profile(&profile)
-                        .unwrap_or_else(|err| warn!("{}", err));
-                }
-            }
-        }
+    async fn notify_profile(signal_ctxt: &SignalContext<'_>, profile: Profile) -> zbus::Result<()> {
     }
 }
 
-impl crate::ZbusAdd for FanAndCpuZbus {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Profile"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("DbusFanAndCpu: add_to_server {}", err);
-                err
-            })
-            .ok();
+#[async_trait]
+impl crate::ZbusAdd for ProfileZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Profile", server).await;
     }
 }

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_types::supported::RogBiosSupportedFunctions;
+use rog_supported::RogBiosSupportedFunctions;
 use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::{Read, Write};
@@ -8,8 +9,8 @@ use std::path::Path;
 use std::process::Command;
 use std::sync::Arc;
 use std::sync::Mutex;
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
+use zbus::Connection;
+use zbus::{dbus_interface, SignalContext};
 
 const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
 const DRACUT_PATH: &str = "/usr/bin/dracut";
@@ -36,22 +37,23 @@ impl GetSupported for CtrlRogBios {
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlRogBios {
-    pub fn set_dedicated_graphic_mode(&mut self, dedicated: bool) {
+    async fn set_dedicated_graphic_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        dedicated: bool,
+    ) {
         self.set_gfx_mode(dedicated)
             .map_err(|err| {
                 warn!("CtrlRogBios: set_asus_switch_graphic_mode {}", err);
                 err
             })
             .ok();
-        self.notify_dedicated_graphic_mode(dedicated)
-            .map_err(|err| {
-                warn!("CtrlRogBios: notify_asus_switch_graphic_mode {}", err);
-                err
-            })
+        Self::notify_dedicated_graphic_mode(&ctxt, dedicated)
+            .await
             .ok();
     }
 
-    pub fn dedicated_graphic_mode(&self) -> i8 {
+    fn dedicated_graphic_mode(&self) -> i8 {
         Self::get_gfx_mode()
             .map_err(|err| {
                 warn!("CtrlRogBios: get_gfx_mode {}", err);
@@ -61,24 +63,27 @@ impl CtrlRogBios {
     }
 
     #[dbus_interface(signal)]
-    pub fn notify_dedicated_graphic_mode(&self, dedicated: bool) -> zbus::Result<()> {}
+    async fn notify_dedicated_graphic_mode(
+        signal_ctxt: &SignalContext<'_>,
+        dedicated: bool,
+    ) -> zbus::Result<()> {
+    }
 
-    pub fn set_post_boot_sound(&mut self, on: bool) {
+    async fn set_post_boot_sound(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        on: bool,
+    ) {
         Self::set_boot_sound(on)
             .map_err(|err| {
                 warn!("CtrlRogBios: set_post_boot_sound {}", err);
                 err
             })
             .ok();
-        self.notify_post_boot_sound(on)
-            .map_err(|err| {
-                warn!("CtrlRogBios: notify_post_boot_sound {}", err);
-                err
-            })
-            .ok();
+        Self::notify_post_boot_sound(&ctxt, on).await.ok();
     }
 
-    pub fn post_boot_sound(&self) -> i8 {
+    fn post_boot_sound(&self) -> i8 {
         Self::get_boot_sound()
             .map_err(|err| {
                 warn!("CtrlRogBios: get_boot_sound {}", err);
@@ -88,21 +93,13 @@ impl CtrlRogBios {
     }
 
     #[dbus_interface(signal)]
-    pub fn notify_post_boot_sound(&self, dedicated: bool) -> zbus::Result<()> {}
+    async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
 }
 
+#[async_trait]
 impl crate::ZbusAdd for CtrlRogBios {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/RogBios"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlRogBios: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/RogBios", server).await;
     }
 }
 
@@ -168,7 +165,7 @@ impl CtrlRogBios {
             .map_err(|err| RogError::Path(path.into(), err))?;
 
         let mut data = Vec::new();
-        file.read_to_end(&mut data).unwrap();
+        file.read_to_end(&mut data)?;
 
         let idx = data.len() - 1;
         if dedicated {
@@ -269,7 +266,7 @@ impl CtrlRogBios {
                             RogError::Write(module_include.to_string_lossy().to_string(), err)
                         })?;
                     // add nvidia modules to module_include
-                    file.write_all(modules.concat().as_bytes()).unwrap();
+                    file.write_all(modules.concat().as_bytes())?;
                 } else {
                     let file = std::fs::OpenOptions::new()
                         .read(true)
@@ -292,7 +289,7 @@ impl CtrlRogBios {
                         .map_err(|err| {
                             RogError::Write(module_include.to_string_lossy().to_string(), err)
                         })?;
-                    std::io::BufWriter::new(file).write_all(&buf).unwrap();
+                    std::io::BufWriter::new(file).write_all(&buf)?;
                 }
             }
 

daemon/src/ctrl_supported.rs

@@ -1,24 +1,24 @@
-use log::warn;
+use async_trait::async_trait;
 use serde_derive::{Deserialize, Serialize};
 use zbus::dbus_interface;
-use zvariant::ObjectPath;
-use zvariant_derive::Type;
+use zbus::Connection;
+use zvariant::Type;
 
 use crate::{
-    ctrl_anime::CtrlAnime, ctrl_charge::CtrlCharge, ctrl_leds::controller::CtrlKbdLed,
-    ctrl_profiles::controller::CtrlFanAndCpu, ctrl_rog_bios::CtrlRogBios, GetSupported,
+    ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_charge::CtrlCharge,
+    ctrl_profiles::controller::CtrlPlatformProfile, ctrl_rog_bios::CtrlRogBios, GetSupported,
 };
 
-use rog_types::supported::{
-    AnimeSupportedFunctions, ChargeSupportedFunctions, FanCpuSupportedFunctions,
-    LedSupportedFunctions, RogBiosSupportedFunctions,
+use rog_supported::{
+    AnimeSupportedFunctions, ChargeSupportedFunctions, LedSupportedFunctions,
+    PlatformProfileFunctions, RogBiosSupportedFunctions,
 };
 
 #[derive(Serialize, Deserialize, Type)]
 pub struct SupportedFunctions {
     pub anime_ctrl: AnimeSupportedFunctions,
     pub charge_ctrl: ChargeSupportedFunctions,
-    pub fan_cpu_ctrl: FanCpuSupportedFunctions,
+    pub platform_profile: PlatformProfileFunctions,
     pub keyboard_led: LedSupportedFunctions,
     pub rog_bios_ctrl: RogBiosSupportedFunctions,
 }
@@ -30,18 +30,10 @@ impl SupportedFunctions {
     }
 }
 
+#[async_trait]
 impl crate::ZbusAdd for SupportedFunctions {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Supported"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("SupportedFunctions: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Supported", server).await;
     }
 }
 
@@ -53,7 +45,7 @@ impl GetSupported for SupportedFunctions {
             anime_ctrl: CtrlAnime::get_supported(),
             keyboard_led: CtrlKbdLed::get_supported(),
             charge_ctrl: CtrlCharge::get_supported(),
-            fan_cpu_ctrl: CtrlFanAndCpu::get_supported(),
+            platform_profile: CtrlPlatformProfile::get_supported(),
             rog_bios_ctrl: CtrlRogBios::get_supported(),
         }
     }

daemon/src/daemon.rs

@@ -1,31 +1,36 @@
-use daemon::ctrl_leds::controller::{
+use std::env;
+use std::error::Error;
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+
+use ::zbus::Connection;
+use daemon::ctrl_profiles::controller::CtrlProfileTask;
+use log::LevelFilter;
+use log::{error, info, warn};
+use smol::Executor;
+
+use daemon::ctrl_anime::config::AnimeConfig;
+use daemon::ctrl_anime::zbus::CtrlAnimeZbus;
+use daemon::ctrl_anime::*;
+use daemon::ctrl_aura::config::AuraConfig;
+use daemon::ctrl_aura::controller::{
     CtrlKbdLed, CtrlKbdLedReloader, CtrlKbdLedTask, CtrlKbdLedZbus,
 };
+use daemon::ctrl_charge::CtrlCharge;
+use daemon::ctrl_profiles::config::ProfileConfig;
+use daemon::ctrl_rog_bios::CtrlRogBios;
 use daemon::{
     config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
 };
-use daemon::{config_anime::AnimeConfig, config_aura::AuraConfig, ctrl_charge::CtrlCharge};
-use daemon::{ctrl_anime::*, ctrl_gfx::controller::CtrlGraphics};
 use daemon::{
-    ctrl_profiles::{controller::CtrlFanAndCpu, zbus::FanAndCpuZbus},
+    ctrl_profiles::{controller::CtrlPlatformProfile, zbus::ProfileZbus},
     laptops::LaptopLedData,
 };
-
 use daemon::{CtrlTask, Reloadable, ZbusAdd};
-use log::LevelFilter;
-use log::{error, info, warn};
 use rog_dbus::DBUS_NAME;
-use rog_types::gfx_vendors::GfxVendors;
-use std::error::Error;
-use std::io::Write;
-use std::sync::Arc;
-use std::sync::Mutex;
+use rog_profiles::Profile;
 
-use daemon::ctrl_rog_bios::CtrlRogBios;
-use std::convert::Into;
-use zbus::fdo;
-use zbus::Connection;
-use zvariant::ObjectPath;
+static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
 
 pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut logger = env_logger::Builder::new();
@@ -35,36 +40,46 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         .filter(None, LevelFilter::Info)
         .init();
 
-    info!("      daemon v{}", daemon::VERSION);
-    info!("   rog-anime v{}", rog_anime::VERSION);
-    info!("    rog-aura v{}", rog_aura::VERSION);
-    info!("    rog-dbus v{}", rog_dbus::VERSION);
-    info!("rog-profiles v{}", rog_profiles::VERSION);
-    info!("   rog-types v{}", rog_types::VERSION);
+    let is_service = match env::var_os("IS_SERVICE") {
+        Some(val) => val == "1",
+        None => false,
+    };
 
-    start_daemon()?;
+    if !is_service {
+        println!("asusd schould be only run from the right systemd service");
+        println!(
+            "do not run in your terminal, if you need an logs please use journalctl -b -u asusd"
+        );
+        println!("asusd will now exit");
+        return Ok(());
+    }
+
+    info!("       daemon v{}", daemon::VERSION);
+    info!("    rog-anime v{}", rog_anime::VERSION);
+    info!("     rog-aura v{}", rog_aura::VERSION);
+    info!("     rog-dbus v{}", rog_dbus::VERSION);
+    info!(" rog-profiles v{}", rog_profiles::VERSION);
+    info!("rog-supported v{}", rog_supported::VERSION);
+
+    let mut executor = Executor::new();
+
+    smol::block_on(start_daemon(&mut executor))?;
     Ok(())
 }
 
 /// The actual main loop for the daemon
-fn start_daemon() -> Result<(), Box<dyn Error>> {
+async fn start_daemon(executor: &mut Executor<'_>) -> Result<(), Box<dyn Error>> {
     let supported = SupportedFunctions::get_supported();
     print_board_info();
-    println!("{}", serde_json::to_string_pretty(&supported).unwrap());
+    println!("{}", serde_json::to_string_pretty(&supported)?);
 
-    // Collect tasks for task thread
-    let mut tasks: Vec<Box<dyn CtrlTask + Send>> = Vec::new();
     // Start zbus server
-    let connection = Connection::new_system()?;
-    fdo::DBusProxy::new(&connection)?
-        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-    let mut object_server = zbus::ObjectServer::new(&connection);
+    let mut connection = Connection::system().await?;
 
     let config = Config::load();
-    let enable_gfx_switching = config.gfx_managed;
     let config = Arc::new(Mutex::new(config));
 
-    supported.add_to_server(&mut object_server);
+    supported.add_to_server(&mut connection).await;
 
     match CtrlRogBios::new(config.clone()) {
         Ok(mut ctrl) => {
@@ -72,7 +87,7 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
             ctrl.reload()
                 .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
             // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
+            ctrl.add_to_server(&mut connection).await;
         }
         Err(err) => {
             error!("rog_bios_control: {}", err);
@@ -85,23 +100,36 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
             ctrl.reload()
                 .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
             // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
+            ctrl.add_to_server(&mut connection).await;
+
+            let task = CtrlCharge::new(config)?;
+            task.create_tasks(executor).await.ok();
         }
         Err(err) => {
             error!("charge_control: {}", err);
         }
     }
 
-    match CtrlFanAndCpu::new(config.clone()) {
-        Ok(mut ctrl) => {
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("Profile control: {}", err));
-            let tmp = Arc::new(Mutex::new(ctrl));
-            FanAndCpuZbus::new(tmp).add_to_server(&mut object_server);
-        }
-        Err(err) => {
-            error!("Profile control: {}", err);
+    if Profile::is_platform_profile_supported() {
+        let profile_config = ProfileConfig::load(PROFILE_CONFIG_PATH.into());
+        match CtrlPlatformProfile::new(profile_config) {
+            Ok(mut ctrl) => {
+                ctrl.reload()
+                    .unwrap_or_else(|err| warn!("Profile control: {}", err));
+
+                let tmp = Arc::new(Mutex::new(ctrl));
+                let task = CtrlProfileTask::new(tmp.clone());
+                task.create_tasks(executor).await.ok();
+
+                let task = ProfileZbus::new(tmp.clone());
+                task.add_to_server(&mut connection).await;
+            }
+            Err(err) => {
+                error!("Profile control: {}", err);
+            }
         }
+    } else {
+        warn!("platform_profile support not found. This requires kernel 5.15.x or the patch applied: https://lkml.org/lkml/2021/8/18/1022");
     }
 
     match CtrlAnime::new(AnimeConfig::load()) {
@@ -114,9 +142,10 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                 .unwrap_or_else(|err| warn!("AniMe: {}", err));
 
             let zbus = CtrlAnimeZbus(inner.clone());
-            zbus.add_to_server(&mut object_server);
+            zbus.add_to_server(&mut connection).await;
 
-            tasks.push(Box::new(CtrlAnimeTask::new(inner)));
+            let task = CtrlAnimeTask::new(inner).await;
+            task.create_tasks(executor).await.ok();
         }
         Err(err) => {
             error!("AniMe control: {}", err);
@@ -134,95 +163,21 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                 .reload()
                 .unwrap_or_else(|err| warn!("Keyboard LED control: {}", err));
 
-            CtrlKbdLedZbus::new(inner.clone()).add_to_server(&mut object_server);
+            CtrlKbdLedZbus::new(inner.clone())
+                .add_to_server(&mut connection)
+                .await;
+
             let task = CtrlKbdLedTask::new(inner);
-            tasks.push(Box::new(task));
+            task.create_tasks(executor).await.ok();
         }
         Err(err) => {
             error!("Keyboard control: {}", err);
         }
     }
 
-    // Graphics switching requires some checks on boot specifically for g-sync capable laptops
-    if enable_gfx_switching {
-        match CtrlGraphics::new(config.clone()) {
-            Ok(mut ctrl) => {
-                // Need to check if a laptop has the dedicated gfx switch
-                if CtrlRogBios::has_dedicated_gfx_toggle() {
-                    if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
-                        if let Ok(config) = config.lock() {
-                            if ded == 1 {
-                                warn!("Dedicated GFX toggle is on but driver mode is not nvidia \nSetting to nvidia driver mode");
-                                let devices = ctrl.devices();
-                                let bus = ctrl.bus();
-                                CtrlGraphics::do_vendor_tasks(
-                                    GfxVendors::Nvidia,
-                                    false,
-                                    &devices,
-                                    &bus,
-                                )?;
-                            } else if ded == 0 {
-                                info!("Dedicated GFX toggle is off");
-                                let devices = ctrl.devices();
-                                let bus = ctrl.bus();
-                                CtrlGraphics::do_vendor_tasks(
-                                    config.gfx_mode,
-                                    false,
-                                    &devices,
-                                    &bus,
-                                )?;
-                            }
-                        }
-                    }
-                }
-                ctrl.reload()
-                    .unwrap_or_else(|err| error!("Gfx controller: {}", err));
-                ctrl.add_to_server(&mut object_server);
-            }
-            Err(err) => {
-                error!("Gfx control: {}", err);
-            }
-        }
-    }
-
-    // TODO: implement messaging between threads to check fails
-
-    // Run tasks
-    let handle = std::thread::Builder::new()
-        .name("asusd watch".to_string())
-        .spawn(move || loop {
-            std::thread::sleep(std::time::Duration::from_millis(100));
-
-            for ctrl in tasks.iter() {
-                ctrl.do_task()
-                    .map_err(|err| {
-                        warn!("do_task error: {}", err);
-                    })
-                    .ok();
-            }
-        });
-
-    // Run zbus server
-    object_server
-        .with(
-            &ObjectPath::from_str_unchecked("/org/asuslinux/Charge"),
-            |obj: &CtrlCharge| {
-                let x = obj.limit();
-                obj.notify_charge(x as u8)
-            },
-        )
-        .map_err(|err| {
-            warn!("object_server notify_charge error: {}", err);
-        })
-        .ok();
-
-    // Loop to check errors and iterate zbus server
+    // Request dbus name after finishing initalizing all functions
+    connection.request_name(DBUS_NAME).await?;
     loop {
-        if let Err(err) = &handle {
-            error!("{}", err);
-        }
-        if let Err(err) = object_server.try_handle_next() {
-            error!("{}", err);
-        }
+        smol::block_on(executor.tick());
     }
 }

daemon/src/error.rs

@@ -1,14 +1,9 @@
-use rog_fan_curve::CurveError;
 use rog_profiles::error::ProfileError;
-use rog_types::error::GraphicsError;
 use std::convert::From;
 use std::fmt;
 
-use crate::ctrl_gfx::error::GfxError;
-
 #[derive(Debug)]
 pub enum RogError {
-    ParseFanLevel,
     ParseVendor,
     ParseLed,
     MissingProfile(String),
@@ -18,25 +13,22 @@ pub enum RogError {
     Write(String, std::io::Error),
     NotSupported,
     NotFound(String),
-    FanCurve(CurveError),
     DoTask(String),
     MissingFunction(String),
     MissingLedBrightNode(String, std::io::Error),
     ReloadFail(String),
-    GfxSwitching(GfxError),
     Profiles(ProfileError),
     Initramfs(String),
     Modprobe(String),
-    Command(String, std::io::Error),
     Io(std::io::Error),
     Zbus(zbus::Error),
+    ChargeLimit(u8),
 }
 
 impl fmt::Display for RogError {
     // This trait requires `fmt` with this exact signature.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            RogError::ParseFanLevel => write!(f, "Parse profile error"),
             RogError::ParseVendor => write!(f, "Parse gfx vendor error"),
             RogError::ParseLed => write!(f, "Parse LED error"),
             RogError::MissingProfile(profile) => write!(f, "Profile does not exist {}", profile),
@@ -46,39 +38,22 @@ impl fmt::Display for RogError {
             RogError::Write(path, error) => write!(f, "Write {}: {}", path, error),
             RogError::NotSupported => write!(f, "Not supported"),
             RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
-            RogError::FanCurve(err) => write!(f, "Custom fan-curve error: {}", err),
             RogError::DoTask(deets) => write!(f, "Task error: {}", deets),
             RogError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
             RogError::MissingLedBrightNode(path, error) => write!(f, "Led node at {} is missing, please check you have the required patch or dkms module installed: {}", path, error),
             RogError::ReloadFail(deets) => write!(f, "Task error: {}", deets),
-            RogError::GfxSwitching(deets) => write!(f, "Graphics switching error: {}", deets),
             RogError::Profiles(deets) => write!(f, "Profile error: {}", deets),
             RogError::Initramfs(detail) => write!(f, "Initiramfs error: {}", detail),
             RogError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
-            RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
             RogError::Io(detail) => write!(f, "std::io error: {}", detail),
             RogError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
+            RogError::ChargeLimit(value) => write!(f, "Invalid charging limit, not in range 20-100%: {}", value),
         }
     }
 }
 
 impl std::error::Error for RogError {}
 
-impl From<CurveError> for RogError {
-    fn from(err: CurveError) -> Self {
-        RogError::FanCurve(err)
-    }
-}
-
-impl From<GraphicsError> for RogError {
-    fn from(err: GraphicsError) -> Self {
-        match err {
-            GraphicsError::ParseVendor => RogError::GfxSwitching(GfxError::ParseVendor),
-            GraphicsError::ParsePower => RogError::GfxSwitching(GfxError::ParsePower),
-        }
-    }
-}
-
 impl From<ProfileError> for RogError {
     fn from(err: ProfileError) -> Self {
         RogError::Profiles(err)

daemon/src/laptops.rs

@@ -10,10 +10,8 @@ pub const ASUS_KEYBOARD_DEVICES: [&str; 4] = ["1866", "1869", "1854", "19b6"];
 pub fn print_board_info() {
     let dmi = sysfs_class::DmiId::default();
     let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_name = dmi.product_name().expect("Could not get product_name");
     let prod_family = dmi.product_family().expect("Could not get product_family");
 
-    info!("Product name: {}", prod_name.trim());
     info!("Product family: {}", prod_family.trim());
     info!("Board name: {}", board_name.trim());
 }

daemon/src/lib.rs

@@ -1,17 +1,12 @@
 #![deny(unused_must_use)]
 /// Configuration loading, saving
 pub mod config;
-pub mod config_anime;
-pub mod config_aura;
-pub(crate) mod config_old;
 /// Control of AniMe matrix display
 pub mod ctrl_anime;
+/// Keyboard LED brightness control, RGB, and LED display modes
+pub mod ctrl_aura;
 /// Control of battery charge level
 pub mod ctrl_charge;
-/// GPU switching and power
-pub mod ctrl_gfx;
-/// Keyboard LED brightness control, RGB, and LED display modes
-pub mod ctrl_leds;
 /// Control CPU min/max freq and turbo, fan mode, fan curves
 ///
 /// Intel machines can control:
@@ -32,11 +27,17 @@ pub mod laptops;
 /// Fetch all supported functions for the laptop
 pub mod ctrl_supported;
 
-mod error;
+pub mod error;
+
+use std::time::Duration;
 
 use crate::error::RogError;
+use async_trait::async_trait;
 use config::Config;
-use zbus::ObjectServer;
+use log::warn;
+use smol::{stream::StreamExt, Executor, Timer};
+use zbus::Connection;
+use zvariant::ObjectPath;
 
 pub static VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -44,12 +45,48 @@ pub trait Reloadable {
     fn reload(&mut self) -> Result<(), RogError>;
 }
 
+#[async_trait]
 pub trait ZbusAdd {
-    fn add_to_server(self, server: &mut ObjectServer);
+    async fn add_to_server(self, server: &mut Connection);
+
+    async fn add_to_server_helper(
+        iface: impl zbus::Interface,
+        path: &str,
+        server: &mut Connection,
+    ) {
+        server
+            .object_server()
+            .at(&ObjectPath::from_str_unchecked(path), iface)
+            .await
+            .map_err(|err| {
+                warn!("{}: add_to_server {}", path, err);
+                err
+            })
+            .ok();
+    }
 }
 
+/// Set up a task to run on the async executor
+#[async_trait]
 pub trait CtrlTask {
-    fn do_task(&self) -> Result<(), RogError>;
+    /// Implement to set up various tasks that may be required, using the `Executor`.
+    /// No blocking loops are allowed, or they must be run on a separate thread.
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError>;
+
+    /// Create a timed repeating task
+    async fn repeating_task(
+        &self,
+        millis: u64,
+        executor: &mut Executor,
+        mut task: impl FnMut() + Send + 'static,
+    ) {
+        let timer = Timer::interval(Duration::from_millis(millis));
+        executor
+            .spawn(async move {
+                timer.for_each(|_| task()).await;
+            })
+            .detach();
+    }
 }
 
 pub trait CtrlTaskComplex {

data/90-asusd-nvidia-pm.rules

@@ -1,7 +0,0 @@
-# Enable runtime PM for NVIDIA VGA/3D controller devices on driver bind
-ACTION=="bind", SUBSYSTEM=="pci", ATTR{vendor}=="0x10de", ATTR{class}=="0x030000", TEST=="power/control", ATTR{power/control}="auto"
-ACTION=="bind", SUBSYSTEM=="pci", ATTR{vendor}=="0x10de", ATTR{class}=="0x030200", TEST=="power/control", ATTR{power/control}="auto"
-
-# Disable runtime PM for NVIDIA VGA/3D controller devices on driver unbind
-ACTION=="unbind", SUBSYSTEM=="pci", ATTR{vendor}=="0x10de", ATTR{class}=="0x030000", TEST=="power/control", ATTR{power/control}="on"
-ACTION=="unbind", SUBSYSTEM=="pci", ATTR{vendor}=="0x10de", ATTR{class}=="0x030200", TEST=="power/control", ATTR{power/control}="on"

data/90-nvidia-screen-G05.conf

@@ -1,4 +0,0 @@
-Section "ServerLayout"
-  Identifier "layout"
-  Option "AllowNVIDIAGPUScreens"
-EndSection

data/asusd-alt.service

@@ -3,6 +3,7 @@ Description=ASUS Notebook Control
 After=basic.target syslog.target
 
 [Service]
+Environment=IS_SERVICE=1
 ExecStart=/usr/bin/asusd
 Restart=on-failure
 Type=dbus

data/asusd-ledmodes.toml

@@ -12,9 +12,16 @@ standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight
 multizone = false
 per_key = true
 
+[[led_data]]
+prod_family = "Zephyrus M"
+board_names = ["GM501GS"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = true
+per_key = false
+
 [[led_data]]
 prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LW"]
+board_names = ["GU502LW", "GU502LV"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
 multizone = false
 per_key = true
@@ -35,14 +42,14 @@ per_key = false
 
 [[led_data]]
 prod_family = "ROG Strix"
-board_names = ["G531GW", "G733QS", "G733QR"]
+board_names = ["G531GW", "G533QR", "G533QS", "G733QS", "G733QR", "G513QR", "G713QR", "G513QM"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
 multizone = false
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Strix"
-board_names = ["GX531", "G512LV", "G712LV", "G712LW"]
+board_names = ["G513QE", "GX531", "G512LV", "G712LV", "G712LW", "G513IH", "G513QY", "G713QM", "G512"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
 multizone = true
 per_key = false
@@ -89,6 +96,21 @@ standard = ["Static", "Breathe", "Pulse"]
 multizone = false
 per_key = false
 
+[[led_data]]
+prod_family = "ROG Zephyrus G14"
+board_names = ["GA402R"]
+standard = ["Static", "Breathe", "Pulse", "Rainbow"]
+multizone = false
+per_key = false
+
+# GA503QE at higher priority (first match) than GA503Q
+[[led_data]]
+prod_family = "ROG Zephyrus G15"
+board_names = ["GA503QE"]
+standard = ["Static", "Breathe", "Pulse"]
+multizone = false
+per_key = false
+
 [[led_data]]
 prod_family = "ROG Zephyrus G15"
 board_names = ["GA503Q"]
@@ -102,3 +124,24 @@ board_names = ["GX550L"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
 multizone = false
 per_key = true
+
+[[led_data]]
+prod_family = "ROG Zephyrus Duo 15 SE"
+board_names = ["GX551Q"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = false
+per_key = true
+
+[[led_data]]
+prod_family = "ROG Flow X13"
+board_names = ["GV301QH", "GV301QE"]
+standard = ["Static", "Breathe", "Pulse"]
+multizone = false
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Strix" 
+board_names = ["G513IC"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = false
+per_key = false

data/asusd.service

@@ -2,9 +2,11 @@
 Description=ASUS Notebook Control
 StartLimitInterval=200
 StartLimitBurst=2
-Before=display-manager.service
+Before=multi-user.target
 
 [Service]
+Environment=IS_SERVICE=1
+ExecStartPre=/bin/sleep 2
 ExecStart=/usr/bin/asusd
 Restart=on-failure
 Restart=always

data/icons/scalable/gpu-compute.svg

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Gravit.io -->
+
+<svg
+   style="isolation:isolate"
+   viewBox="0 0 82.733002 82.733002"
+   width="82.733002pt"
+   height="82.733002pt"
+   version="1.1"
+   id="svg19"
+   sodipodi:docname="gpu-compute.svg"
+   inkscape:version="1.1 (c68e22c387, 2021-05-23)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview21"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:document-units="pt"
+     showgrid="false"
+     inkscape:zoom="4.96875"
+     inkscape:cx="15.597484"
+     inkscape:cy="54.742138"
+     inkscape:window-width="2048"
+     inkscape:window-height="1083"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg19" />
+  <defs
+     id="defs5">
+    <clipPath
+       id="_clipPath_ZEBBDq6ZtbLgkRXocTHUWTcRbcURZIva">
+      <rect
+         width="128"
+         height="128"
+         id="rect2"
+         x="0"
+         y="0" />
+    </clipPath>
+  </defs>
+  <g
+     clip-path="url(#_clipPath_ZEBBDq6ZtbLgkRXocTHUWTcRbcURZIva)"
+     id="g17"
+     transform="translate(-22.624,-23)">
+    <rect
+       width="128"
+       height="128"
+       style="fill:#000000"
+       fill-opacity="0"
+       id="rect7"
+       x="0"
+       y="0" />
+    <g
+       id="g15">
+      <path
+         id="path9"
+         style="opacity:1;mix-blend-mode:normal;fill:#ed1c24;fill-opacity:1;stroke:#000000;stroke-width:0.5;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+         d="m 13.789062,13.789062 v 6.894532 H 0 v 6.894531 H 13.789062 V 41.367188 H 0 v 6.894531 H 13.789062 V 62.048828 H 0 v 6.894531 H 13.789062 V 82.732422 H 0 v 6.894531 h 13.789062 v 6.894531 h 6.894532 v 13.789066 h 6.894531 V 96.521484 h 13.789063 v 13.789066 h 6.894531 V 96.521484 h 13.789062 v 13.789066 h 6.892578 V 96.521484 h 13.789063 v 13.789066 h 6.896484 V 96.521484 h 6.894532 z"
+         transform="matrix(0.75,0,0,0.75,22.624,23)" />
+      <path
+         id="path9-3"
+         style="isolation:isolate;mix-blend-mode:normal;fill:#76b900;fill-opacity:1;stroke:#000000;stroke-width:0.375;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+         d="m 95.016578,95.391113 -0.0051,-5.170896 10.341782,-0.01017 -0.005,-5.170896 -10.341789,0.01017 -0.01017,-10.341791 10.341799,-0.01018 -0.005,-5.170895 -10.341787,0.01018 -0.01017,-10.340328 10.341797,-0.01017 -0.005,-5.170896 -10.341794,0.01017 -0.01018,-10.341792 10.341784,-0.01017 -0.005,-5.170895 -10.341791,0.01017 -0.0051,-5.170897 -5.170898,0.0051 -0.01017,-10.341796 -5.170896,0.0051 0.01017,10.341797 -10.341792,0.01017 -0.01017,-10.341795 -5.170897,0.0051 0.01017,10.341796 -10.341791,0.01017 -0.01017,-10.341796 -5.169431,0.0051 0.01017,10.341795 -10.341792,0.01018 -0.01017,-10.341797 -5.172361,0.0051 0.01017,10.341795 -5.170894,0.0051 z" />
+      <rect
+         x="38.146"
+         y="38.512001"
+         width="51.708"
+         height="51.708"
+         fill="rgb(77,77,77)"
+         id="rect11"
+         style="fill:none" />
+      <path
+         d="m 67.238,81.543 c 3.416,0 7.169,-0.866 10.056,-2.262 l -1.395,-4.474 c -2.165,0.818 -4.86,1.299 -7.169,1.299 -7.313,0 -11.884,-4.811 -11.884,-12.317 0,-7.073 4.138,-11.114 11.162,-11.114 2.646,0 5.678,0.529 7.843,1.395 l 1.732,-4.811 c -2.839,-1.347 -6.111,-2.069 -9.43,-2.069 -10.537,0 -17.754,6.976 -17.754,17.465 0,10.104 6.832,16.888 16.839,16.888 z"
+         fill="#dddddd"
+         id="path13"
+         style="stroke:#000000;stroke-opacity:1;stroke-width:0.5;stroke-miterlimit:4;stroke-dasharray:none;fill:#ffffff" />
+    </g>
+  </g>
+</svg>

data/icons/scalable/gpu-hybrid.svg

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Gravit.io -->
+
+<svg
+   style="isolation:isolate"
+   viewBox="0 0 82.733002 82.733002"
+   width="82.733002pt"
+   height="82.733002pt"
+   version="1.1"
+   id="svg19"
+   sodipodi:docname="gpu-hybrid.svg"
+   inkscape:version="1.1 (c68e22c387, 2021-05-23)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview21"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:document-units="pt"
+     showgrid="false"
+     inkscape:zoom="4.96875"
+     inkscape:cx="15.798742"
+     inkscape:cy="54.742138"
+     inkscape:window-width="2048"
+     inkscape:window-height="1083"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg19" />
+  <defs
+     id="defs5">
+    <clipPath
+       id="_clipPath_uVSrFPVusaaYDISWhfCjIlGBeb9FaZAr">
+      <rect
+         width="128"
+         height="128"
+         id="rect2"
+         x="0"
+         y="0" />
+    </clipPath>
+  </defs>
+  <g
+     clip-path="url(#_clipPath_uVSrFPVusaaYDISWhfCjIlGBeb9FaZAr)"
+     id="g17"
+     transform="translate(-22.624,-23)">
+    <rect
+       width="128"
+       height="128"
+       style="fill:#000000"
+       fill-opacity="0"
+       id="rect7"
+       x="0"
+       y="0" />
+    <g
+       id="g15">
+      <path
+         d="m 38.137,23 v 10.342 h -5.171 v 5.17 H 22.624 v 5.171 H 32.966 V 54.025 H 22.624 v 5.171 H 32.966 V 69.537 H 22.624 v 5.171 H 32.966 V 85.05 H 22.624 v 5.17 h 10.342 v 5.171 h 5.171 v 10.342 h 5.171 V 95.391 h 10.341 v 10.342 H 58.82 V 95.391 h 10.342 v 10.342 h 5.17 V 95.391 h 10.342 v 10.342 h 5.171 V 95.391 h 5.171 V 90.22 h 10.341 V 85.05 H 95.016 V 74.708 h 10.341 V 69.537 H 95.016 V 59.196 h 10.341 V 54.025 H 95.016 V 43.683 h 10.341 V 38.512 H 95.016 v -5.17 H 89.845 V 23 H 84.674 V 33.342 H 74.332 V 23 h -5.17 V 33.342 H 58.82 V 23 H 53.649 V 33.342 H 43.308 V 23 Z"
+         fill="rgb(77,77,77)"
+         id="path9"
+         style="fill:#ed1c24;fill-opacity:1;stroke:#000000;stroke-opacity:1;stroke-width:0.75;stroke-miterlimit:4;stroke-dasharray:none" />
+      <rect
+         x="38.146"
+         y="38.512001"
+         width="51.708"
+         height="51.708"
+         fill="rgb(77,77,77)"
+         id="rect11"
+         style="fill:#76b900;fill-opacity:1;stroke:#000000;stroke-opacity:1" />
+      <path
+         d="m 51.464,79 h 5.663 V 66.118 H 70.916 V 79 h 5.62 V 49 h -5.62 V 61.147 H 57.127 V 49 h -5.663 z"
+         fill="rgb(221,221,221)"
+         id="path13"
+         style="fill:#ececec;stroke:#000000;stroke-opacity:1;stroke-width:0.5;stroke-miterlimit:4;stroke-dasharray:none" />
+    </g>
+  </g>
+</svg>

data/icons/scalable/gpu-integrated.svg

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Gravit.io -->
+
+<svg
+   style="isolation:isolate"
+   viewBox="0 0 82.410369 82.410377"
+   width="82.41037pt"
+   height="82.410378pt"
+   version="1.1"
+   id="svg17"
+   sodipodi:docname="gpu-integrated.svg"
+   inkscape:version="1.1 (c68e22c387, 2021-05-23)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview19"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:document-units="pt"
+     showgrid="false"
+     inkscape:zoom="4.96875"
+     inkscape:cx="14.389937"
+     inkscape:cy="54.742138"
+     inkscape:window-width="2048"
+     inkscape:window-height="1083"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg17" />
+  <defs
+     id="defs5">
+    <clipPath
+       id="_clipPath_GAg6mcrkdqJgsmZOjvo6JT6R1d3r9FoI">
+      <rect
+         width="128"
+         height="128"
+         id="rect2"
+         x="0"
+         y="0" />
+    </clipPath>
+  </defs>
+  <path
+     style="fill:#ed1c24;fill-opacity:1;stroke:#000000;stroke-width:0.75;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+     d="M 15.92217,76.9033 V 71.771223 H 13.28066 10.63915 V 69.129715 66.488208 H 5.507075 0.375 v -2.037735 -2.037735 h 5.132075 5.132075 v -5.73585 -5.73585 H 5.507075 0.375 V 48.903302 46.865566 H 5.507075 10.63915 V 41.205189 35.544811 H 5.507075 0.375 V 33.431604 31.318396 H 5.507075 10.63915 V 25.658019 19.997641 H 5.507075 0.375 V 17.959906 15.92217 h 5.132075 5.132075 v -2.641509 -2.64151 h 2.64151 2.64151 V 5.5070763 0.375 h 2.037736 2.037735 v 5.1320763 5.1320747 h 5.660378 5.660377 V 5.5070763 0.375 h 2.113207 2.113208 v 5.1320763 5.1320747 h 5.660377 5.660378 V 5.5070763 0.375 h 1.947066 1.947063 l 0.09711,1.8490563 c 0.07996,1.52246 0.251242,6.717377 0.253724,7.695141 0.0014,0.5274167 -0.04609,0.5197837 3.905982,0.6286047 1.618867,0.04457 3.945285,0.123799 5.16981,0.176053 l 2.226412,0.09501 V 5.5969303 0.375 h 2.037735 2.037743 v 5.1320763 5.1320747 h 2.641507 2.641508 v 2.64151 2.641509 h 5.132077 5.13207 v 2.037736 2.037735 h -5.13207 -5.132077 v 5.660378 5.660377 h 5.132077 5.13207 v 2.113208 2.113207 h -5.13207 -5.132077 v 5.660378 5.660377 h 5.132077 5.13207 v 2.037736 2.037736 h -5.13207 -5.132077 v 5.73585 5.73585 h 5.132077 5.13207 v 2.037735 2.037735 h -5.13207 -5.132077 v 2.641507 2.641508 H 69.129718 66.488211 V 76.9033 82.035378 H 64.450468 62.412733 V 76.9033 71.771223 h -5.73585 -5.735846 V 76.9033 82.035378 H 48.903301 46.865566 V 76.9033 71.771223 H 41.205188 35.544811 V 76.9033 82.035378 H 33.431603 31.318396 V 76.9033 71.771223 H 25.658019 19.997641 V 76.9033 82.035378 H 17.959906 15.92217 Z"
+     id="path1355" />
+</svg>

data/icons/scalable/gpu-nvidia.svg

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Gravit.io -->
+
+<svg
+   style="isolation:isolate"
+   viewBox="0 0 82.410369 82.410377"
+   width="82.41037pt"
+   height="82.410378pt"
+   version="1.1"
+   id="svg17"
+   sodipodi:docname="gpu-nvidia.svg"
+   inkscape:version="1.1 (c68e22c387, 2021-05-23)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview19"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:document-units="pt"
+     showgrid="false"
+     inkscape:zoom="4.96875"
+     inkscape:cx="14.389937"
+     inkscape:cy="54.742138"
+     inkscape:window-width="2048"
+     inkscape:window-height="1083"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg17" />
+  <defs
+     id="defs5">
+    <clipPath
+       id="_clipPath_GAg6mcrkdqJgsmZOjvo6JT6R1d3r9FoI">
+      <rect
+         width="128"
+         height="128"
+         id="rect2"
+         x="0"
+         y="0" />
+    </clipPath>
+  </defs>
+  <path
+     style="fill:#76b900;fill-opacity:1;stroke:#000000;stroke-width:0.75;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+     d="M 15.92217,76.9033 V 71.771223 H 13.28066 10.63915 V 69.129715 66.488208 H 5.507075 0.375 v -2.037735 -2.037735 h 5.132075 5.132075 v -5.73585 -5.73585 H 5.507075 0.375 V 48.903302 46.865566 H 5.507075 10.63915 V 41.205189 35.544811 H 5.507075 0.375 V 33.431604 31.318396 H 5.507075 10.63915 V 25.658019 19.997641 H 5.507075 0.375 V 17.959906 15.92217 h 5.132075 5.132075 v -2.641509 -2.64151 h 2.64151 2.64151 V 5.5070763 0.375 h 2.037736 2.037735 v 5.1320763 5.1320747 h 5.660378 5.660377 V 5.5070763 0.375 h 2.113207 2.113208 v 5.1320763 5.1320747 h 5.660377 5.660378 V 5.5070763 0.375 h 1.947066 1.947063 l 0.09711,1.8490563 c 0.07996,1.52246 0.251242,6.717377 0.253724,7.695141 0.0014,0.5274167 -0.04609,0.5197837 3.905982,0.6286047 1.618867,0.04457 3.945285,0.123799 5.16981,0.176053 l 2.226412,0.09501 V 5.5969303 0.375 h 2.037735 2.037743 v 5.1320763 5.1320747 h 2.641507 2.641508 v 2.64151 2.641509 h 5.132077 5.13207 v 2.037736 2.037735 h -5.13207 -5.132077 v 5.660378 5.660377 h 5.132077 5.13207 v 2.113208 2.113207 h -5.13207 -5.132077 v 5.660378 5.660377 h 5.132077 5.13207 v 2.037736 2.037736 h -5.13207 -5.132077 v 5.73585 5.73585 h 5.132077 5.13207 v 2.037735 2.037735 h -5.13207 -5.132077 v 2.641507 2.641508 H 69.129718 66.488211 V 76.9033 82.035378 H 64.450468 62.412733 V 76.9033 71.771223 h -5.73585 -5.735846 V 76.9033 82.035378 H 48.903301 46.865566 V 76.9033 71.771223 H 41.205188 35.544811 V 76.9033 82.035378 H 33.431603 31.318396 V 76.9033 71.771223 H 25.658019 19.997641 V 76.9033 82.035378 H 17.959906 15.92217 Z"
+     id="path1355" />
+</svg>

data/icons/scalable/gpu-vfio.svg

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Gravit.io -->
+
+<svg
+   style="isolation:isolate"
+   viewBox="0 0 82.733002 82.733002"
+   width="82.733002pt"
+   height="82.733002pt"
+   version="1.1"
+   id="svg19"
+   sodipodi:docname="gpu-vfio.svg"
+   inkscape:version="1.1 (c68e22c387, 2021-05-23)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview21"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:document-units="pt"
+     showgrid="false"
+     inkscape:zoom="7.8686859"
+     inkscape:cx="55.091791"
+     inkscape:cy="55.155334"
+     inkscape:window-width="2048"
+     inkscape:window-height="1083"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg19" />
+  <defs
+     id="defs5">
+    <clipPath
+       id="_clipPath_ZEBBDq6ZtbLgkRXocTHUWTcRbcURZIva">
+      <rect
+         width="128"
+         height="128"
+         id="rect2"
+         x="0"
+         y="0" />
+    </clipPath>
+  </defs>
+  <g
+     clip-path="url(#_clipPath_ZEBBDq6ZtbLgkRXocTHUWTcRbcURZIva)"
+     id="g17"
+     transform="translate(-22.624,-23)">
+    <rect
+       width="128"
+       height="128"
+       style="fill:#000000"
+       fill-opacity="0"
+       id="rect7"
+       x="0"
+       y="0" />
+    <g
+       id="g15">
+      <path
+         id="path9"
+         style="opacity:1;mix-blend-mode:normal;fill:#ed1c24;fill-opacity:1;stroke:#000000;stroke-width:0.5;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+         d="m 13.789062,13.789062 v 6.894532 H 0 v 6.894531 H 13.789062 V 41.367188 H 0 v 6.894531 H 13.789062 V 62.048828 H 0 v 6.894531 H 13.789062 V 82.732422 H 0 v 6.894531 h 13.789062 v 6.894531 h 6.894532 v 13.789066 h 6.894531 V 96.521484 h 13.789063 v 13.789066 h 6.894531 V 96.521484 h 13.789062 v 13.789066 h 6.892578 V 96.521484 h 13.789063 v 13.789066 h 6.896484 V 96.521484 h 6.894532 z"
+         transform="matrix(0.75,0,0,0.75,22.624,23)" />
+      <path
+         id="path9-3"
+         style="isolation:isolate;mix-blend-mode:normal;fill:#76b900;fill-opacity:1;stroke:#000000;stroke-width:0.375;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+         d="m 95.016578,95.391113 -0.0051,-5.170896 10.341782,-0.01017 -0.005,-5.170896 -10.341789,0.01017 -0.01017,-10.341791 10.341799,-0.01018 -0.005,-5.170895 -10.341787,0.01018 -0.01017,-10.340328 10.341797,-0.01017 -0.005,-5.170896 -10.341794,0.01017 -0.01018,-10.341792 10.341784,-0.01017 -0.005,-5.170895 -10.341791,0.01017 -0.0051,-5.170897 -5.170898,0.0051 -0.01017,-10.341796 -5.170896,0.0051 0.01017,10.341797 -10.341792,0.01017 -0.01017,-10.341795 -5.170897,0.0051 0.01017,10.341796 -10.341791,0.01017 -0.01017,-10.341796 -5.169431,0.0051 0.01017,10.341795 -10.341792,0.01018 -0.01017,-10.341797 -5.172361,0.0051 0.01017,10.341795 -5.170894,0.0051 z" />
+      <rect
+         x="38.146"
+         y="38.512001"
+         width="51.708"
+         height="51.708"
+         fill="rgb(77,77,77)"
+         id="rect11"
+         style="fill:none" />
+    </g>
+  </g>
+  <path
+     d="m 38.016104,57.595764 h 6.037 l 11.263,-31.267 h -5.947 l -8.064,24.374 -7.75,-24.374 h -6.758 z"
+     fill="#dddddd"
+     id="path849"
+     style="isolation:isolate;stroke:#000000;stroke-opacity:1;stroke-width:0.5;stroke-miterlimit:4;stroke-dasharray:none;fill:#ffffff" />
+</svg>

data/icons/scalable/notification-reboot.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!-- Generator: Gravit.io --><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="isolation:isolate" viewBox="141 297.96 507.339 471.04" width="507.339pt" height="471.04pt"><g><g><g><g><path d=" M 537.075 443.463 L 537.075 443.463 L 564.723 427.335 C 504.903 324.571 375.966 285.313 269.027 337.304 L 269.027 297.96 L 237.027 297.96 L 237.027 393.96 L 333.027 393.96 L 333.027 361.96 L 292.147 361.96 C 382.665 323.563 487.612 358.486 537.075 443.463 Z " fill="rgb(204,64,64)"/><path d=" M 245.027 692.775 C 170.84 632.524 151.314 527.353 198.931 444.488 L 171.187 428.488 C 116.876 523.063 137.426 642.887 220.147 713.96 L 181.027 713.96 L 181.027 745.96 L 277.027 745.96 L 277.027 649.96 L 245.027 649.96 L 245.027 692.775 L 245.027 692.775 Z " fill="rgb(204,64,64)"/><path d=" M 580.451 499.048 L 512.579 566.936 L 535.203 589.56 L 562.403 562.36 C 551.734 661.49 468.201 736.724 368.499 737 L 368.499 769 C 487.289 768.688 585.833 677.011 594.707 558.552 L 625.715 589.56 L 648.339 566.936 L 580.451 499.048 Z " fill="rgb(204,64,64)"/></g></g></g></g></svg>

data/user-example.json

@@ -1,64 +0,0 @@
-{
-  "anime": [
-    {
-      "AsusAnimation": {
-        "file": "/usr/share/asusd/anime/asus/rog/Sunset.gif",
-        "time": {
-          "Cycles": 1
-        },
-        "brightness": 0.5
-      }
-    },
-    {
-      "ImageAnimation": {
-        "file": "/usr/share/asusd/anime/custom/sonic-run.gif",
-        "scale": 0.9,
-        "angle": 0.65,
-        "translation": [
-          0.0,
-          0.0
-        ],
-        "time": {
-          "Time": {
-            "secs": 5,
-            "nanos": 0
-          }
-        },
-        "brightness": 0.5
-      }
-    },
-    {
-      "Image": {
-        "file": "/usr/share/asusd/anime/custom/rust.png",
-        "scale": 1.0,
-        "angle": 0.0,
-        "translation": [
-          0.0,
-          0.0
-        ],
-        "brightness": 0.6
-      }
-    },
-    {
-      "Pause": {
-        "secs": 6,
-        "nanos": 0
-      }
-    },
-    {
-      "ImageAnimation": {
-        "file": "/usr/share/asusd/anime/custom/sonic-wait.gif",
-        "scale": 0.9,
-        "angle": 0.0,
-        "translation": [
-          3.0,
-          2.0
-        ],
-        "time": {
-          "Cycles": 2
-        },
-        "brightness": 0.5
-      }
-    }
-  ]
-}

design-patterns.md

@@ -28,18 +28,53 @@ impl CtrlAnime {
 }
 ```
 
-The task trait:
+The task trait. There are three ways to implement this:
 
 ```rust
 pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);
 
 impl crate::CtrlTask for CtrlAnimeTask {
-    fn do_task(&self) -> Result<(), RogError> {
+    // This will run once only
+    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
        if let Ok(lock) = self.inner.try_lock() {
             <some action>
         }
         Ok(())
     }
+
+    // This will run until the notification stream closes (which in most cases will be never)
+    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system().await.unwrap();
+        let manager = ManagerProxy::new(&connection).await.unwrap();
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                // A notification from logind dbus interface
+                if let Ok(p) = manager.receive_prepare_for_sleep().await {
+                    // A stream that will continuously output events
+                    p.for_each(|_| {
+                        if let Ok(lock) = inner.try_lock() {
+                            // Do stuff here
+                        }
+                    })
+                    .await;
+                }
+            })
+            .detach();
+    }
+
+    // This task will run every 500 milliseconds
+    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let inner = self.inner.clone();
+        // This is a provided free trait to help set up a repeating task
+        self.repeating_task(500, executor, move || {
+            if let Ok(lock) = inner.try_lock() {
+                // Do stuff here
+            }
+        })
+        .await;
+    }
 }
 ```
 
@@ -61,18 +96,11 @@ The Zbus requirements:
 ```rust
 pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);
 
+#[async_trait]
 impl crate::ZbusAdd for CtrlAnimeZbus {
     fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlAnimeDisplay: add_to_server {}", err);
-                err
-            })
-            .ok();
+        // This is a provided free helper trait with pre-set body. It will move self in-to.
+        Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
     }
 }
 

rog-anime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_anime"
-version = "1.0.5"
+version = "1.3.3"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -14,17 +14,17 @@ exclude = ["data"]
 
 [features]
 default = ["dbus"]
-dbus = ["zvariant", "zvariant_derive"]
+dbus = ["zvariant"]
 
 [dependencies]
 png_pong = "^0.8.0"
 pix = "0.13"
 gif = "^0.11.2"
+log = "*"
 
 serde = "^1.0"
 serde_derive = "^1.0"
 
-glam = { version = "0.14.0", features = ["serde"] }
+glam = { version = "0.20.5", features = ["serde"] }
 
-zvariant = { version = "^2.6", optional = true }
-zvariant_derive = { version = "^2.6", optional = true }
+zvariant = { version = "^3.0", optional = true }